C语言接口与实现[+]

第1章 简介

1. literate程序

2. 宏指令与条件编译指令

第2章 接口与实现

1. 接口与实现的关系

2. Arith接口及实现：

arith.h:

/*  $Id: H:/drh/idioms/book/RCS/inter.doc,v 1.11 1997/02/21 19:42:15 drh Exp $  */
extern  int Arith_max( int x,  int y);
extern  int Arith_min( int x,  int y);
extern  int Arith_div( int x,  int y);
extern  int Arith_mod( int x,  int y);
extern  int Arith_ceiling( int x,  int y);
extern  int Arith_floor  ( int x,  int y);

arith.c

 

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/inter.doc,v 1.11 1997/02/21 19:42:15 drh Exp $ ";
#include  " arith.h "
int Arith_max( int x,  int y) {
     return x > y ? x : y;
}
int Arith_min( int x,  int y) {
     return x > y ? y : x;
}
int Arith_div( int x,  int y) {
     if (- 13/ 5 == - 2
    &&    (x <  0) != (y <  0) && x%y !=  0)
         return x/y -  1;
     else
         return x/y;
}
int Arith_mod( int x,  int y) {
     if (- 13/ 5 == - 2
    &&    (x <  0) != (y <  0) && x%y !=  0)
         return x%y + y;
     else
         return x%y;
}
int Arith_floor( int x,  int y) {
     return Arith_div(x, y);
}
int Arith_ceiling( int x,  int y) {
     return Arith_div(x, y) + (x%y !=  0);
}

 

3. 抽象数据类型Stack

4. 客户调用程序的责任

stack.h

View Code

stack.c 

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/inter.doc,v 1.11 1997/02/21 19:42:15 drh Exp $ ";
#include <stddef.h>
#include  " assert.h "
#include  " mem.h "
#include  " stack.h "
#define T Stack_T
struct T {
     int count;
     struct elem {
         void *x;
         struct elem *link;
    } *head;
};
T Stack_new( void) {
    T stk;
    NEW(stk);
    stk->count =  0;
    stk->head = NULL;
     return stk;
}
int Stack_empty(T stk) {
    assert(stk);
     return stk->count ==  0;
}
void Stack_push(T stk,  void *x) {
     struct elem *t;
    assert(stk);
    NEW(t);
    t->x = x;
    t->link = stk->head;
    stk->head = t;
    stk->count++;
}
void *Stack_pop(T stk) {
     void *x;
     struct elem *t;
    assert(stk);
    assert(stk->count >  0);
    t = stk->head;
    stk->head = t->link;
    stk->count--;
    x = t->x;
    FREE(t);
     return x;
}
void Stack_free(T *stk) {
     struct elem *t, *u;
    assert(stk && *stk);
     for (t = (*stk)->head; t; t = u) {
        u = t->link;
        FREE(t);
    }
    FREE(*stk);
}

第3章 原子

1. 接口

atom.h: 

View Code

atom.c:

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/atom.doc,v 1.10 1997/02/21 19:42:46 drh Exp $ ";
#include  " atom.h "
#include < string.h>
#include  " assert.h "
#include <limits.h>
#include  " mem.h "
#define NELEMS(x) ((sizeof (x))/(sizeof ((x)[0])))
static  struct atom {
     struct atom *link;
     int len;
     char *str;
} *buckets[ 2048];
static unsigned  long scatter[] = {
2078917053,  143302914,  1027100827,  1953210302,  755253631,  2002600785,
1405390230,  45248011,  1099951567,  433832350,  2018585307,  438263339,
813528929,  1703199216,  618906479,  573714703,  766270699,  275680090,
1510320440,  1583583926,  1723401032,  1965443329,  1098183682,  1636505764,
980071615,  1011597961,  643279273,  1315461275,  157584038,  1069844923,
471560540,  89017443,  1213147837,  1498661368,  2042227746,  1968401469,
1353778505,  1300134328,  2013649480,  306246424,  1733966678,  1884751139,
744509763,  400011959,  1440466707,  1363416242,  973726663,  59253759,
1639096332,  336563455,  1642837685,  1215013716,  154523136,  593537720,
704035832,  1134594751,  1605135681,  1347315106,  302572379,  1762719719,
269676381,  774132919,  1851737163,  1482824219,  125310639,  1746481261,
1303742040,  1479089144,  899131941,  1169907872,  1785335569,  485614972,
907175364,  382361684,  885626931,  200158423,  1745777927,  1859353594,
259412182,  1237390611,  48433401,  1902249868,  304920680,  202956538,
348303940,  1008956512,  1337551289,  1953439621,  208787970,  1640123668,
1568675693,  478464352,  266772940,  1272929208,  1961288571,  392083579,
871926821,  1117546963,  1871172724,  1771058762,  139971187,  1509024645,
109190086,  1047146551,  1891386329,  994817018,  1247304975,  1489680608,
706686964,  1506717157,  579587572,  755120366,  1261483377,  884508252,
958076904,  1609787317,  1893464764,  148144545,  1415743291,  2102252735,
1788268214,  836935336,  433233439,  2055041154,  2109864544,  247038362,
299641085,  834307717,  1364585325,  23330161,  457882831,  1504556512,
1532354806,  567072918,  404219416,  1276257488,  1561889936,  1651524391,
618454448,  121093252,  1010757900,  1198042020,  876213618,  124757630,
2082550272,  1834290522,  1734544947,  1828531389,  1982435068,  1002804590,
1783300476,  1623219634,  1839739926,  69050267,  1530777140,  1802120822,
316088629,  1830418225,  488944891,  1680673954,  1853748387,  946827723,
1037746818,  1238619545,  1513900641,  1441966234,  367393385,  928306929,
946006977,  985847834,  1049400181,  1956764878,  36406206,  1925613800,
2081522508,  2118956479,  1612420674,  1668583807,  1800004220,  1447372094,
523904750,  1435821048,  923108080,  216161028,  1504871315,  306401572,
2018281851,  1820959944,  2136819798,  359743094,  1354150250,  1843084537,
1306570817,  244413420,  934220434,  672987810,  1686379655,  1301613820,
1601294739,  484902984,  139978006,  503211273,  294184214,  176384212,
281341425,  228223074,  147857043,  1893762099,  1896806882,  1947861263,
1193650546,  273227984,  1236198663,  2116758626,  489389012,  593586330,
275676551,  360187215,  267062626,  265012701,  719930310,  1621212876,
2108097238,  2026501127,  1865626297,  894834024,  552005290,  1404522304,
48964196,  5816381,  1889425288,  188942202,  509027654,  36125855,
365326415,  790369079,  264348929,  513183458,  536647531,  13672163,
313561074,  1730298077,  286900147,  1549759737,  1699573055,  776289160,
2143346068,  1975249606,  1136476375,  262925046,  92778659,  1856406685,
1884137923,  53392249,  1735424165,  1602280572
};
const  char *Atom_string( const  char *str) {
    assert(str);
     return Atom_new(str, strlen(str));
}
const  char *Atom_int( long n) {
     char str[ 43];
     char *s = str +  sizeof str;
    unsigned  long m;
     if (n == LONG_MIN)
        m = LONG_MAX +  1UL;
     else  if (n <  0)
        m = -n;
     else
        m = n;
     do
        *--s = m% 10 +  ' 0 ';
     while ((m /=  10) >  0);
     if (n <  0)
        *--s =  ' - ';
     return Atom_new(s, (str +  sizeof str) - s);
}
const  char *Atom_new( const  char *str,  int len) {
    unsigned  long h;
     int i;
     struct atom *p;
    assert(str);
    assert(len >=  0);
     for (h =  0, i =  0; i < len; i++)
        h = (h<< 1) + scatter[(unsigned  char)str[i]];
    h &= NELEMS(buckets)- 1;
     for (p = buckets[h]; p; p = p->link)
         if (len == p->len) {
             for (i =  0; i < len && p->str[i] == str[i]; )
                i++;
             if (i == len)
                 return p->str;
        }
    p = ALLOC( sizeof (*p) + len +  1);
    p->len = len;
    p->str = ( char *)(p +  1);
     if (len >  0)
        memcpy(p->str, str, len);
    p->str[len] =  ' \0 ';
    p->link = buckets[h];
    buckets[h] = p;
     return p->str;
}
int Atom_length( const  char *str) {
     struct atom *p;
     int i;
    assert(str);
     for (i =  0; i < NELEMS(buckets); i++)
         for (p = buckets[i]; p; p = p->link)
             if (p->str == str)
                 return p->len;
    assert( 0);
     return  0;
}

第4章 异常与断言

except.h 

/*  $Id: H:/drh/idioms/book/RCS/except.doc,v 1.10 1997/02/21 19:43:55 drh Exp $  */
#ifndef EXCEPT_INCLUDED
#define EXCEPT_INCLUDED
#include <setjmp.h>
#define T Except_T
typedef  struct T {
     char *reason;
} T;
typedef  struct Except_Frame Except_Frame;
struct Except_Frame {
    Except_Frame *prev;
    jmp_buf env;
     const  char *file;
     int line;
     const T *exception;
};
enum { Except_entered= 0, Except_raised,
       Except_handled,   Except_finalized };
#ifdef WIN32
__declspec(thread)
#endif
extern Except_Frame *Except_stack;
extern  const Except_T Assert_Failed;
void Except_raise( const T *e,  const  char *file, int line);
#define RAISE(e) Except_raise(&(e), __FILE__, __LINE__)
#define RERAISE Except_raise(Except_frame.exception, \
    Except_frame.file, Except_frame.line)
#define RETURN switch (Except_stack = Except_stack->prev,0) default: return
#define TRY do { \
     volatile  int Except_flag; \
    Except_Frame Except_frame; \
    Except_frame.prev = Except_stack; \
    Except_stack = &Except_frame;  \
    Except_flag = setjmp(Except_frame.env); \
     if (Except_flag == Except_entered) {
#define EXCEPT(e) \
         if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
    }  else  if (Except_frame.exception == &(e)) { \
        Except_flag = Except_handled;
#define ELSE \
         if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
    }  else { \
        Except_flag = Except_handled;
#define FINALLY \
         if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
    } { \
         if (Except_flag == Except_entered) \
            Except_flag = Except_finalized;
#define END_TRY \
         if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
        }  if (Except_flag == Except_raised) RERAISE; \
}  while ( 0)
#undef T
#endif

except.c 

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/except.doc,v 1.10 1997/02/21 19:43:55 drh Exp $ ";
#include <stdlib.h>
#include <stdio.h>
#include  " assert.h "
#include  " except.h "
#define T Except_T
#ifdef WIN32
__declspec(thread)
#endif
Except_Frame *Except_stack = NULL;
void Except_raise( const T *e,  const  char *file,
     int line) {
    Except_Frame *p = Except_stack;
    assert(e);
     if (p == NULL) {
        fprintf(stderr,  " Uncaught exception ");
         if (e->reason)
            fprintf(stderr,  "  %s ", e->reason);
         else
            fprintf(stderr,  "  at 0x%p ", e);
         if (file && line >  0)
            fprintf(stderr,  "  raised at %s:%d\n ", file, line);
        fprintf(stderr,  " aborting...\n ");
        fflush(stderr);
        abort();
    }
    p->exception = e;
    p->file = file;
    p->line = line;
    Except_stack = Except_stack->prev;
    longjmp(p->env, Except_raised);
}

assert.h

/*  $Id: H:/drh/idioms/book/RCS/except.doc,v 1.10 1997/02/21 19:43:55 drh Exp $  */
#undef assert
#ifdef NDEBUG
#define assert(e) ((void)0)
#else
#include  " except.h "
extern  void assert( int e);
#define assert(e) ((void)((e)||(RAISE(Assert_Failed),0)))
#endif

assert.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/except.doc,v 1.10 1997/02/21 19:43:55 drh Exp $ ";
#include  " assert.h "
const Except_T Assert_Failed = {  " Assertion failed " };
void (assert)( int e) {
    assert(e);
}

 

第5章 内存管理

MEM分配接口

mem.h

/*  $Id: H:/drh/idioms/book/RCS/mem.doc,v 1.12 1997/10/27 23:08:05 drh Exp $  */
#ifndef MEM_INCLUDED
#define MEM_INCLUDED
#include  " except.h "
extern  const Except_T Mem_Failed;
extern  void *Mem_alloc ( long nbytes,
     const  char *file,  int line);
extern  void *Mem_calloc( long count,  long nbytes,
     const  char *file,  int line);
extern  void Mem_free( void *ptr,
     const  char *file,  int line);
extern  void *Mem_resize( void *ptr,  long nbytes,
     const  char *file,  int line);
#define ALLOC(nbytes) \
    Mem_alloc((nbytes), __FILE__, __LINE__)
#define CALLOC(count, nbytes) \
    Mem_calloc((count), (nbytes), __FILE__, __LINE__)
#define  NEW(p) ((p) = ALLOC((long)sizeof *(p)))
#define NEW0(p) ((p) = CALLOC(1, (long)sizeof *(p)))
#define FREE(ptr) ((void)(Mem_free((ptr), \
    __FILE__, __LINE__), (ptr) =  0))
#define RESIZE(ptr, nbytes)     ((ptr) = Mem_resize((ptr), \
    (nbytes), __FILE__, __LINE__))
#endif

 

 

mem.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/mem.doc,v 1.12 1997/10/27 23:08:05 drh Exp $ ";
#include <stdlib.h>
#include <stddef.h>
#include  " assert.h "
#include  " except.h "
#include  " mem.h "
const Except_T Mem_Failed = {  " Allocation Failed " };
void *Mem_alloc( long nbytes,  const  char *file,  int line){
     void *ptr;
    assert(nbytes >  0);
    ptr = malloc(nbytes);
     if (ptr == NULL)
        {
             if (file == NULL)
                RAISE(Mem_Failed);
             else
                Except_raise(&Mem_Failed, file, line);
        }
     return ptr;
}
void *Mem_calloc( long count,  long nbytes,
     const  char *file,  int line) {
     void *ptr;
    assert(count >  0);
    assert(nbytes >  0);
    ptr = calloc(count, nbytes);
     if (ptr == NULL)
        {
             if (file == NULL)
                RAISE(Mem_Failed);
             else
                Except_raise(&Mem_Failed, file, line);
        }
     return ptr;
}
void Mem_free( void *ptr,  const  char *file,  int line) {
     if (ptr)
        free(ptr);
}
void *Mem_resize( void *ptr,  long nbytes,
     const  char *file,  int line) {
    assert(ptr);
    assert(nbytes >  0);
    ptr = realloc(ptr, nbytes);
     if (ptr == NULL)
        {
             if (file == NULL)
                RAISE(Mem_Failed);
             else
                Except_raise(&Mem_Failed, file, line);
        }
     return ptr;
}

 

第6章 进一步内存管理

arena.h

View Code

 

arena.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/arena.doc,v 1.10 1997/02/21 19:45:19 drh Exp $ ";
#include <stdlib.h>
#include < string.h>
#include  " assert.h "
#include  " except.h "
#include  " arena.h "
#define T Arena_T
const Except_T Arena_NewFailed =
    {  " Arena Creation Failed " };
const Except_T Arena_Failed    =
    {  " Arena Allocation Failed " };
#define THRESHOLD 10
struct T {
    T prev;
     char *avail;
     char *limit;
};
union align {
#ifdef MAXALIGN
     char pad[MAXALIGN];
#else
     int i;
     long l;
     long *lp;
     void *p;
     void (*fp)( void);
     float f;
     double d;
     long  double ld;
#endif
};
union header {
     struct T b;
    union align a;
};
static T freechunks;
static  int nfree;
T Arena_new( void) {
    T arena = malloc( sizeof (*arena));
     if (arena == NULL)
        RAISE(Arena_NewFailed);
    arena->prev = NULL;
    arena->limit = arena->avail = NULL;
     return arena;
}
void Arena_dispose(T *ap) {
    assert(ap && *ap);
    Arena_free(*ap);
    free(*ap);
    *ap = NULL;
}
void *Arena_alloc(T arena,  long nbytes,
     const  char *file,  int line) {
    assert(arena);
    assert(nbytes >  0);
    nbytes = ((nbytes +  sizeof (union align) -  1)/
        ( sizeof (union align)))*( sizeof (union align));
     while (nbytes > arena->limit - arena->avail) {
        T ptr;
         char *limit;
         if ((ptr = freechunks) != NULL) {
            freechunks = freechunks->prev;
            nfree--;
            limit = ptr->limit;
        }  else {
             long m =  sizeof (union header) + nbytes +  10* 1024;
            ptr = malloc(m);
             if (ptr == NULL)
                {
                     if (file == NULL)
                        RAISE(Arena_Failed);
                     else
                        Except_raise(&Arena_Failed, file, line);
                }
            limit = ( char *)ptr + m;
        }
        *ptr = *arena;
        arena->avail = ( char *)((union header *)ptr +  1);
        arena->limit = limit;
        arena->prev  = ptr;
    }
    arena->avail += nbytes;
     return arena->avail - nbytes;
}
void *Arena_calloc(T arena,  long count,  long nbytes,
     const  char *file,  int line) {
     void *ptr;
    assert(count >  0);
    ptr = Arena_alloc(arena, count*nbytes, file, line);
    memset(ptr,  ' \0 ', count*nbytes);
     return ptr;
}
void Arena_free(T arena) {
    assert(arena);
     while (arena->prev) {
         struct T tmp = *arena->prev;
         if (nfree < THRESHOLD) {
            arena->prev->prev = freechunks;
            freechunks = arena->prev;
            nfree++;
            freechunks->limit = arena->limit;
        }  else
            free(arena->prev);
        *arena = tmp;
    }
    assert(arena->limit == NULL);
    assert(arena->avail == NULL);
}

 

第7章 链表

 

list.h

/*  $Id: H:/drh/idioms/book/RCS/list.doc,v 1.11 1997/02/21 19:46:01 drh Exp $  */
#ifndef LIST_INCLUDED
#define LIST_INCLUDED
#define T List_T
typedef  struct T *T;
struct T {
    T rest;
     void *first;
};
extern T      List_append (T list, T tail);
extern T      List_copy   (T list);
extern T      List_list   ( void *x, ...);
extern T      List_pop    (T list,  void **x);
extern T      List_push   (T list,  void *x);
extern T      List_reverse(T list);
extern  int    List_length (T list);
extern  void   List_free   (T *list);
extern  void   List_map    (T list,
     void apply( void **x,  void *cl),  void *cl);
extern  void **List_toArray(T list,  void *end);
#undef T
#endif

 

list.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/list.doc,v 1.11 1997/02/21 19:46:01 drh Exp $ ";
#include <stdarg.h>
#include <stddef.h>
#include  " assert.h "
#include  " mem.h "
#include  " list.h "
#define T List_T
T List_push(T list,  void *x) {
    T p;
    NEW(p);
    p->first = x;
    p->rest  = list;
     return p;
}
T List_list( void *x, ...) {
    va_list ap;
    T list, *p = &list;
    va_start(ap, x);
     for ( ; x; x = va_arg(ap,  void *)) {
        NEW(*p);
        (*p)->first = x;
        p = &(*p)->rest;
    }
    *p = NULL;
    va_end(ap);
     return list;
}
T List_append(T list, T tail) {
    T *p = &list;
     while (*p)
        p = &(*p)->rest;
    *p = tail;
     return list;
}
T List_copy(T list) {
    T head, *p = &head;
     for ( ; list; list = list->rest) {
        NEW(*p);
        (*p)->first = list->first;
        p = &(*p)->rest;
    }
    *p = NULL;
     return head;
}
T List_pop(T list,  void **x) {
     if (list) {
        T head = list->rest;
         if (x)
            *x = list->first;
        FREE(list);
         return head;
    }  else
         return list;
}
T List_reverse(T list) {
    T head = NULL, next;
     for ( ; list; list = next) {
        next = list->rest;
        list->rest = head;
        head = list;
    }
     return head;
}
int List_length(T list) {
     int n;
     for (n =  0; list; list = list->rest)
        n++;
     return n;
}
void List_free(T *list) {
    T next;
    assert(list);
     for ( ; *list; *list = next) {
        next = (*list)->rest;
        FREE(*list);
    }
}
void List_map(T list,
     void apply( void **x,  void *cl),  void *cl) {
    assert(apply);
     for ( ; list; list = list->rest)
        apply(&list->first, cl);
}
void **List_toArray(T list,  void *end) {
     int i, n = List_length(list);
     void **array = ALLOC((n +  1)* sizeof (*array));
     for (i =  0; i < n; i++) {
        array[i] = list->first;
        list = list->rest;
    }
    array[i] = end;
     return array;
}

 

第8章 表格

table.h

/*  $Id: H:/drh/idioms/book/RCS/table.doc,v 1.13 1997/10/27 23:10:11 drh Exp $  */
#ifndef TABLE_INCLUDED
#define TABLE_INCLUDED
#define T Table_T
typedef  struct T *T;
extern T    Table_new ( int hint,
     int cmp( const  void *x,  const  void *y),
    unsigned hash( const  void *key));
extern  void Table_free(T *table);
extern  int   Table_length(T table);
extern  void *Table_put   (T table,  const  void *key,
     void *value);
extern  void *Table_get   (T table,  const  void *key);
extern  void *Table_remove(T table,  const  void *key);
extern  void   Table_map    (T table,
     void apply( const  void *key,  void **value,  void *cl),
     void *cl);
extern  void **Table_toArray(T table,  void *end);
#undef T
#endif

 

 

table.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/table.doc,v 1.13 1997/10/27 23:10:11 drh Exp $ ";
#include <limits.h>
#include <stddef.h>
#include  " mem.h "
#include  " assert.h "
#include  " table.h "
#define T Table_T
struct T {
     int size;
     int (*cmp)( const  void *x,  const  void *y);
    unsigned (*hash)( const  void *key);
     int length;
    unsigned timestamp;
     struct binding {
         struct binding *link;
         const  void *key;
         void *value;
    } **buckets;
};
static  int cmpatom( const  void *x,  const  void *y) {
     return x != y;
}
static unsigned hashatom( const  void *key) {
     return (unsigned  long)key>> 2;
}
T Table_new( int hint,
     int cmp( const  void *x,  const  void *y),
    unsigned hash( const  void *key)) {
    T table;
     int i;
     static  int primes[] = {  509,  509,  1021,  2053,  4093,
         8191,  16381,  32771,  65521, INT_MAX };
    assert(hint >=  0);
     for (i =  1; primes[i] < hint; i++)
        ;
    table = ALLOC( sizeof (*table) +
        primes[i- 1]* sizeof (table->buckets[ 0]));
    table->size = primes[i- 1];
    table->cmp  = cmp  ?  cmp : cmpatom;
    table->hash = hash ? hash : hashatom;
    table->buckets = ( struct binding **)(table +  1);
     for (i =  0; i < table->size; i++)
        table->buckets[i] = NULL;
    table->length =  0;
    table->timestamp =  0;
     return table;
}
void *Table_get(T table,  const  void *key) {
     int i;
     struct binding *p;
    assert(table);
    assert(key);
    i = (*table->hash)(key)%table->size;
     for (p = table->buckets[i]; p; p = p->link)
         if ((*table->cmp)(key, p->key) ==  0)
             break;
     return p ? p->value : NULL;
}
void *Table_put(T table,  const  void *key,  void *value) {
     int i;
     struct binding *p;
     void *prev;
    assert(table);
    assert(key);
    i = (*table->hash)(key)%table->size;
     for (p = table->buckets[i]; p; p = p->link)
         if ((*table->cmp)(key, p->key) ==  0)
             break;
     if (p == NULL) {
        NEW(p);
        p->key = key;
        p->link = table->buckets[i];
        table->buckets[i] = p;
        table->length++;
        prev = NULL;
    }  else
        prev = p->value;
    p->value = value;
    table->timestamp++;
     return prev;
}
int Table_length(T table) {
    assert(table);
     return table->length;
}
void Table_map(T table,
     void apply( const  void *key,  void **value,  void *cl),
     void *cl) {
     int i;
    unsigned stamp;
     struct binding *p;
    assert(table);
    assert(apply);
    stamp = table->timestamp;
     for (i =  0; i < table->size; i++)
         for (p = table->buckets[i]; p; p = p->link) {
            apply(p->key, &p->value, cl);
            assert(table->timestamp == stamp);
        }
}
void *Table_remove(T table,  const  void *key) {
     int i;
     struct binding **pp;
    assert(table);
    assert(key);
    table->timestamp++;
    i = (*table->hash)(key)%table->size;
     for (pp = &table->buckets[i]; *pp; pp = &(*pp)->link)
         if ((*table->cmp)(key, (*pp)->key) ==  0) {
             struct binding *p = *pp;
             void *value = p->value;
            *pp = p->link;
            FREE(p);
            table->length--;
             return value;
        }
     return NULL;
}
void **Table_toArray(T table,  void *end) {
     int i, j =  0;
     void **array;
     struct binding *p;
    assert(table);
    array = ALLOC(( 2*table->length +  1)* sizeof (*array));
     for (i =  0; i < table->size; i++)
         for (p = table->buckets[i]; p; p = p->link) {
            array[j++] = ( void *)p->key;
            array[j++] = p->value;
        }
    array[j] = end;
     return array;
}
void Table_free(T *table) {
    assert(table && *table);
     if ((*table)->length >  0) {
         int i;
         struct binding *p, *q;
         for (i =  0; i < (*table)->size; i++)
             for (p = (*table)->buckets[i]; p; p = q) {
                q = p->link;
                FREE(p);
            }
    }
    FREE(*table);
}

 

 

wf程序来统计单词的频率

getword.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/table.doc,v 1.13 1997/10/27 23:10:11 drh Exp $ ";
#include <ctype.h>
#include < string.h>
#include <stdio.h>
#include  " assert.h "
#include  " getword.h "
int getword(FILE *fp,  char *buf,  int size,
     int first( int c),  int rest( int c)) {
     int i =  0, c;
    assert(fp && buf && size >  1 && first && rest);
    c = getc(fp);
     for ( ; c != EOF; c = getc(fp))
         if (first(c)) {
            {
                 if (i < size -  1)
                    buf[i++] = c;
            }
            c = getc(fp);
             break;
        }
     for ( ; c != EOF && rest(c); c = getc(fp))
        {
             if (i < size -  1)
                buf[i++] = c;
        }
     if (i < size)
        buf[i] =  ' \0 ';
     else
        buf[size- 1] =  ' \0 ';
     if (c != EOF)
        ungetc(c, fp);
     return i >  0;
}

 

wf.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/table.doc,v 1.13 1997/10/27 23:10:11 drh Exp $ ";
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <ctype.h>
#include  " atom.h "
#include  " table.h "
#include  " mem.h "
#include  " getword.h "
#include < string.h>
void wf( char *, FILE *);
int first( int c);
int rest ( int c);
int compare( const  void *x,  const  void *y);
void vfree( const  void *,  void **,  void *);
int main( int argc,  char *argv[]) {
     int i;
     for (i =  1; i < argc; i++) {
        FILE *fp = fopen(argv[i],  " r ");
         if (fp == NULL) {
            fprintf(stderr,  " %s: can't open '%s' (%s)\n ",
                argv[ 0], argv[i], strerror(errno));
             return EXIT_FAILURE;
        }  else {
            wf(argv[i], fp);
            fclose(fp);
        }
    }
     if (argc ==  1) wf(NULL, stdin);
     return EXIT_SUCCESS;
}
void wf( char *name, FILE *fp) {
    Table_T table = Table_new( 0, NULL, NULL);
     char buf[ 128];
     while (getword(fp, buf,  sizeof buf, first, rest)) {
         const  char *word;
         int i, *count;
         for (i =  0; buf[i] !=  ' \0 '; i++)
            buf[i] = tolower(buf[i]);
        word = Atom_string(buf);
        count = Table_get(table, word);
         if (count)
            (*count)++;
         else {
            NEW(count);
            *count =  1;
            Table_put(table, word, count);
        }
    }
     if (name)
        printf( " %s:\n ", name);
    {  int i;
       void **array = Table_toArray(table, NULL);
      qsort(array, Table_length(table),  2* sizeof (*array),
          compare);
       for (i =  0; array[i]; i +=  2)
          printf( " %d\t%s\n ", *( int *)array[i+ 1],
              ( char *)array[i]);
      FREE(array); }
    Table_map(table, vfree, NULL);
    Table_free(&table);
}
int first( int c) {
     return isalpha(c);
}
int rest( int c) {
     return isalpha(c) || c ==  ' _ ';
}
int compare( const  void *x,  const  void *y) {
     return strcmp(*( char **)x, *( char **)y);
}
void vfree( const  void *key,  void **count,  void *cl) {
    FREE(*count);
}

 

第9章 集合

集合的实现

set.h

/*  $Id: H:/drh/idioms/book/RCS/set.doc,v 1.11 1996/06/26 23:02:01 drh Exp $  */
#ifndef SET_INCLUDED
#define SET_INCLUDED
#define T Set_T
typedef  struct T *T;
extern T    Set_new ( int hint,
     int cmp( const  void *x,  const  void *y),
    unsigned hash( const  void *x));
extern  void Set_free(T * set);
extern  int   Set_length(T  set);
extern  int   Set_member(T  set,  const  void *member);
extern  void  Set_put   (T  set,  const  void *member);
extern  void *Set_remove(T  set,  const  void *member);
extern  void   Set_map    (T  set,
     void apply( const  void *member,  void *cl),  void *cl);
extern  void **Set_toArray(T  set,  void *end);
extern T Set_union(T s, T t);
extern T Set_inter(T s, T t);
extern T Set_minus(T s, T t);
extern T Set_diff (T s, T t);
#undef T
#endif

 

 

set.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/set.doc,v 1.11 1996/06/26 23:02:01 drh Exp $ ";
#include <limits.h>
#include <stddef.h>
#include  " mem.h "
#include  " assert.h "
#include  " arith.h "
#include  " set.h "
#define T Set_T
struct T {
     int length;
    unsigned timestamp;
     int (*cmp)( const  void *x,  const  void *y);
    unsigned (*hash)( const  void *x);
     int size;
     struct member {
         struct member *link;
         const  void *member;
    } **buckets;
};
static  int cmpatom( const  void *x,  const  void *y) {
     return x != y;
}
static unsigned hashatom( const  void *x) {
     return (unsigned  long)x>> 2;
}
static T copy(T t,  int hint) {
    T  set;
    assert(t);
     set = Set_new(hint, t->cmp, t->hash);
    {  int i;
       struct member *q;
       for (i =  0; i < t->size; i++)
           for (q = t->buckets[i]; q; q = q->link)
        {
             struct member *p;
             const  void *member = q->member;
             int i = (* set->hash)(member)% set->size;
            NEW(p);
            p->member = member;
            p->link =  set->buckets[i];
             set->buckets[i] = p;
             set->length++;
        }
    }
     return  set;
}
T Set_new( int hint,
     int cmp( const  void *x,  const  void *y),
    unsigned hash( const  void *x)) {
    T  set;
     int i;
     static  int primes[] = {  509,  509,  1021,  2053,  4093,
         8191,  16381,  32771,  65521, INT_MAX };
    assert(hint >=  0);
     for (i =  1; primes[i] < hint; i++)
        ;
     set = ALLOC( sizeof (* set) +
        primes[i- 1]* sizeof ( set->buckets[ 0]));
     set->size = primes[i- 1];
     set->cmp  = cmp  ?  cmp : cmpatom;
     set->hash = hash ? hash : hashatom;
     set->buckets = ( struct member **)( set +  1);
     for (i =  0; i <  set->size; i++)
         set->buckets[i] = NULL;
     set->length =  0;
     set->timestamp =  0;
     return  set;
}
int Set_member(T  set,  const  void *member) {
     int i;
     struct member *p;
    assert( set);
    assert(member);
    i = (* set->hash)(member)% set->size;
     for (p =  set->buckets[i]; p; p = p->link)
         if ((* set->cmp)(member, p->member) ==  0)
             break;
     return p != NULL;
}
void Set_put(T  set,  const  void *member) {
     int i;
     struct member *p;
    assert( set);
    assert(member);
    i = (* set->hash)(member)% set->size;
     for (p =  set->buckets[i]; p; p = p->link)
         if ((* set->cmp)(member, p->member) ==  0)
             break;
     if (p == NULL) {
        NEW(p);
        p->member = member;
        p->link =  set->buckets[i];
         set->buckets[i] = p;
         set->length++;
    }  else
        p->member = member;
     set->timestamp++;
}
void *Set_remove(T  set,  const  void *member) {
     int i;
     struct member **pp;
    assert( set);
    assert(member);
     set->timestamp++;
    i = (* set->hash)(member)% set->size;
     for (pp = & set->buckets[i]; *pp; pp = &(*pp)->link)
         if ((* set->cmp)(member, (*pp)->member) ==  0) {
             struct member *p = *pp;
            *pp = p->link;
            member = p->member;
            FREE(p);
             set->length--;
             return ( void *)member;
        }
     return NULL;
}
int Set_length(T  set) {
    assert( set);
     return  set->length;
}
void Set_free(T * set) {
    assert( set && * set);
     if ((* set)->length >  0) {
         int i;
         struct member *p, *q;
         for (i =  0; i < (* set)->size; i++)
             for (p = (* set)->buckets[i]; p; p = q) {
                q = p->link;
                FREE(p);
            }
    }
    FREE(* set);
}
void Set_map(T  set,
     void apply( const  void *member,  void *cl),  void *cl) {
     int i;
    unsigned stamp;
     struct member *p;
    assert( set);
    assert(apply);
    stamp =  set->timestamp;
     for (i =  0; i <  set->size; i++)
         for (p =  set->buckets[i]; p; p = p->link) {
            apply(p->member, cl);
            assert( set->timestamp == stamp);
        }
}
void **Set_toArray(T  set,  void *end) {
     int i, j =  0;
     void **array;
     struct member *p;
    assert( set);
    array = ALLOC(( set->length +  1)* sizeof (*array));
     for (i =  0; i <  set->size; i++)
         for (p =  set->buckets[i]; p; p = p->link)
            array[j++] = ( void *)p->member;
    array[j] = end;
     return array;
}
T Set_union(T s, T t) {
     if (s == NULL) {
        assert(t);
         return copy(t, t->size);
    }  else  if (t == NULL)
         return copy(s, s->size);
     else {
        T  set = copy(s, Arith_max(s->size, t->size));
        assert(s->cmp == t->cmp && s->hash == t->hash);
        {  int i;
           struct member *q;
           for (i =  0; i < t->size; i++)
               for (q = t->buckets[i]; q; q = q->link)
            Set_put( set, q->member);
        }
         return  set;
    }
}
T Set_inter(T s, T t) {
     if (s == NULL) {
        assert(t);
         return Set_new(t->size, t->cmp, t->hash);
    }  else  if (t == NULL)
         return Set_new(s->size, s->cmp, s->hash);
     else  if (s->length < t->length)
         return Set_inter(t, s);
     else {
        T  set = Set_new(Arith_min(s->size, t->size),
            s->cmp, s->hash);
        assert(s->cmp == t->cmp && s->hash == t->hash);
        {  int i;
           struct member *q;
           for (i =  0; i < t->size; i++)
               for (q = t->buckets[i]; q; q = q->link)
             if (Set_member(s, q->member))
                {
                     struct member *p;
                     const  void *member = q->member;
                     int i = (* set->hash)(member)% set->size;
                    NEW(p);
                    p->member = member;
                    p->link =  set->buckets[i];
                     set->buckets[i] = p;
                     set->length++;
                }
        }
         return  set;
    }
}
T Set_minus(T t, T s) {
     if (t == NULL){
        assert(s);
         return Set_new(s->size, s->cmp, s->hash);
    }  else  if (s == NULL)
         return copy(t, t->size);
     else {
        T  set = Set_new(Arith_min(s->size, t->size),
            s->cmp, s->hash);
        assert(s->cmp == t->cmp && s->hash == t->hash);
        {  int i;
           struct member *q;
           for (i =  0; i < t->size; i++)
               for (q = t->buckets[i]; q; q = q->link)
             if (!Set_member(s, q->member))
                {
                     struct member *p;
                     const  void *member = q->member;
                     int i = (* set->hash)(member)% set->size;
                    NEW(p);
                    p->member = member;
                    p->link =  set->buckets[i];
                     set->buckets[i] = p;
                     set->length++;
                }
        }
         return  set;
    }
}
T Set_diff(T s, T t) {
     if (s == NULL) {
        assert(t);
         return copy(t, t->size);
    }  else  if (t == NULL)
         return copy(s, s->size);
     else {
        T  set = Set_new(Arith_min(s->size, t->size),
            s->cmp, s->hash);
        assert(s->cmp == t->cmp && s->hash == t->hash);
        {  int i;
           struct member *q;
           for (i =  0; i < t->size; i++)
               for (q = t->buckets[i]; q; q = q->link)
             if (!Set_member(s, q->member))
                {
                     struct member *p;
                     const  void *member = q->member;
                     int i = (* set->hash)(member)% set->size;
                    NEW(p);
                    p->member = member;
                    p->link =  set->buckets[i];
                     set->buckets[i] = p;
                     set->length++;
                }
        }
        { T u = t; t = s; s = u; }
        {  int i;
           struct member *q;
           for (i =  0; i < t->size; i++)
               for (q = t->buckets[i]; q; q = q->link)
             if (!Set_member(s, q->member))
                {
                     struct member *p;
                     const  void *member = q->member;
                     int i = (* set->hash)(member)% set->size;
                    NEW(p);
                    p->member = member;
                    p->link =  set->buckets[i];
                     set->buckets[i] = p;
                     set->length++;
                }
        }
         return  set;
    }
}

 

实例：交叉引用列表

xref.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/set.doc,v 1.11 1996/06/26 23:02:01 drh Exp $ ";
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include  " table.h "
#include < string.h>
#include  " atom.h "
#include  " set.h "
#include  " mem.h "
#include  " getword.h "
#include <ctype.h>
int compare( const  void *x,  const  void *y);
void print(Table_T);
int cmpint( const  void *x,  const  void *y);
void xref( const  char *, FILE *, Table_T);
int first( int c);
int rest ( int c);
int      intcmp ( const  void *x,  const  void *y);
unsigned inthash( const  void *x);
int linenum;
int main( int argc,  char *argv[]) {
     int i;
    Table_T identifiers = Table_new( 0, NULL, NULL);
     for (i =  1; i < argc; i++) {
        FILE *fp = fopen(argv[i],  " r ");
         if (fp == NULL) {
            fprintf(stderr,  " %s: can't open '%s' (%s)\n ",
                argv[ 0], argv[i], strerror(errno));
             return EXIT_FAILURE;
        }  else {
            xref(argv[i], fp, identifiers);
            fclose(fp);
        }
    }
     if (argc ==  1) xref(NULL, stdin, identifiers);
    {
         int i;
         void **array = Table_toArray(identifiers, NULL);
        qsort(array, Table_length(identifiers),
             2* sizeof (*array), compare);
         for (i =  0; array[i]; i +=  2) {
            printf( " %s ", ( char *)array[i]);
            print(array[i+ 1]);
        }
        FREE(array);
    }
     return EXIT_SUCCESS;
}
int compare( const  void *x,  const  void *y) {
     return strcmp(*( char **)x, *( char **)y);
}
void print(Table_T files) {
     int i;
     void **array = Table_toArray(files, NULL);
    qsort(array, Table_length(files),  2* sizeof (*array),
        compare);
     for (i =  0; array[i]; i +=  2) {
         if (*( char *)array[i] !=  ' \0 ')
            printf( " \t%s: ", ( char *)array[i]);
        {
             int j;
             void **lines = Set_toArray(array[i+ 1], NULL);
            qsort(lines, Set_length(array[i+ 1]),  sizeof (*lines),
                cmpint);
             for (j =  0; lines[j]; j++)
                printf( "  %d ", *( int *)lines[j]);
            FREE(lines);
        }
        printf( " \n ");
    }
    FREE(array);
}
int cmpint( const  void *x,  const  void *y) {
     if (**( int **)x < **( int **)y)
         return - 1;
     else  if (**( int **)x > **( int **)y)
         return + 1;
     else
         return  0;
}
void xref( const  char *name, FILE *fp,
        Table_T identifiers){
     char buf[ 128];
     if (name == NULL)
        name =  "";
    name = Atom_string(name);
    linenum =  1;
     while (getword(fp, buf,  sizeof buf, first, rest)) {
        Set_T  set;
        Table_T files;
         const  char *id = Atom_string(buf);
        files = Table_get(identifiers, id);
         if (files == NULL) {
            files = Table_new( 0, NULL, NULL);
            Table_put(identifiers, id, files);
        }
         set = Table_get(files, name);
         if ( set == NULL) {
             set = Set_new( 0, intcmp, inthash);
            Table_put(files, name,  set);
        }
        {
             int *p = &linenum;
             if (!Set_member( set, p)) {
                NEW(p);
                *p = linenum;
                Set_put( set, p);
            }
        }
    }
}
int first( int c) {
     if (c ==  ' \n ')
        linenum++;
     return isalpha(c) || c ==  ' _ ';
}
int rest( int c) {
     return isalpha(c) || c ==  ' _ ' || isdigit(c);
}
int intcmp( const  void *x,  const  void *y) {
     return cmpint(&x, &y);
}
unsigned inthash( const  void *x) {
     return *( int *)x;
}

 

 

第10章 动态数组

array.h

/*  $Id: H:/drh/idioms/book/RCS/array.doc,v 1.11 1997/10/29 22:05:21 drh Exp $  */
#ifndef ARRAY_INCLUDED
#define ARRAY_INCLUDED
#define T Array_T
typedef  struct T *T;
extern T    Array_new ( int length,  int size);
extern  void Array_free(T *array);
extern  int Array_length(T array);
extern  int Array_size  (T array);
extern  void *Array_get(T array,  int i);
extern  void *Array_put(T array,  int i,  void *elem);
extern  void Array_resize(T array,  int length);
extern T    Array_copy  (T array,  int length);
#undef T
#endif

 

array.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/array.doc,v 1.11 1997/10/29 22:05:21 drh Exp $ ";
#include <stdlib.h>
#include < string.h>
#include  " assert.h "
#include  " array.h "
#include  " arrayrep.h "
#include  " mem.h "
#define T Array_T
T Array_new( int length,  int size) {
    T array;
    NEW(array);
     if (length >  0)
        ArrayRep_init(array, length, size,
            CALLOC(length, size));
     else
        ArrayRep_init(array, length, size, NULL);
     return array;
}
void ArrayRep_init(T array,  int length,  int size,
     void *ary) {
    assert(array);
    assert(ary && length> 0 || length== 0 && ary==NULL);
    assert(size >  0);
    array->length = length;
    array->size   = size;
     if (length >  0)
        array->array = ary;
     else
        array->array = NULL;
}
void Array_free(T *array) {
    assert(array && *array);
    FREE((*array)->array);
    FREE(*array);
}
void *Array_get(T array,  int i) {
    assert(array);
    assert(i >=  0 && i < array->length);
     return array->array + i*array->size;
}
void *Array_put(T array,  int i,  void *elem) {
    assert(array);
    assert(i >=  0 && i < array->length);
    assert(elem);
    memcpy(array->array + i*array->size, elem,
        array->size);
     return elem;
}
int Array_length(T array) {
    assert(array);
     return array->length;
}
int Array_size(T array) {
    assert(array);
     return array->size;
}
void Array_resize(T array,  int length) {
    assert(array);
    assert(length >=  0);
     if (length ==  0)
        FREE(array->array);
     else  if (array->length ==  0)
        array->array = ALLOC(length*array->size);
     else
        RESIZE(array->array, length*array->size);
    array->length = length;
}
T Array_copy(T array,  int length) {
    T copy;
    assert(array);
    assert(length >=  0);
    copy = Array_new(length, array->size);
     if (copy->length >= array->length
    && array->length >  0)
        memcpy(copy->array, array->array, array->length);
     else  if (array->length > copy->length
    && copy->length >  0)
        memcpy(copy->array, array->array, copy->length);
     return copy;
}

 

第11章 序列

seq.h

/*  $Id: H:/drh/idioms/book/RCS/seq.doc,v 1.11 1997/02/21 19:48:24 drh Exp $  */
#ifndef SEQ_INCLUDED
#define SEQ_INCLUDED
#define T Seq_T
typedef  struct T *T;
extern T Seq_new( int hint);
extern T Seq_seq( void *x, ...);
extern  void Seq_free(T *seq);
extern  int Seq_length(T seq);
extern  void *Seq_get(T seq,  int i);
extern  void *Seq_put(T seq,  int i,  void *x);
extern  void *Seq_addlo(T seq,  void *x);
extern  void *Seq_addhi(T seq,  void *x);
extern  void *Seq_remlo(T seq);
extern  void *Seq_remhi(T seq);
#undef T
#endif

 

seq.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/seq.doc,v 1.11 1997/02/21 19:48:24 drh Exp $ ";
#include <stdlib.h>
#include <stdarg.h>
#include < string.h>
#include  " assert.h "
#include  " seq.h "
#include  " array.h "
#include  " arrayrep.h "
#include  " mem.h "
#define T Seq_T
struct T {
     struct Array_T array;
     int length;
     int head;
};
static  void expand(T seq) {
     int n = seq->array.length;
    Array_resize(&seq->array,  2*n);
     if (seq->head >  0)
        {
             void **old = &(( void **)seq->array.array)[seq->head];
            memcpy(old+n, old, (n - seq->head)* sizeof ( void *));
            seq->head += n;
        }
}
T Seq_new( int hint) {
    T seq;
    assert(hint >=  0);
    NEW0(seq);
     if (hint ==  0)
        hint =  16;
    ArrayRep_init(&seq->array, hint,  sizeof ( void *),
        ALLOC(hint* sizeof ( void *)));
     return seq;
}
T Seq_seq( void *x, ...) {
    va_list ap;
    T seq = Seq_new( 0);
    va_start(ap, x);
     for ( ; x; x = va_arg(ap,  void *))
        Seq_addhi(seq, x);
    va_end(ap);
     return seq;
}
void Seq_free(T *seq) {
    assert(seq && *seq);
    assert(( void *)*seq == ( void *)&(*seq)->array);
    Array_free((Array_T *)seq);
}
int Seq_length(T seq) {
    assert(seq);
     return seq->length;
}
void *Seq_get(T seq,  int i) {
    assert(seq);
    assert(i >=  0 && i < seq->length);
     return (( void **)seq->array.array)[
               (seq->head + i)%seq->array.length];
}
void *Seq_put(T seq,  int i,  void *x) {
     void *prev;
    assert(seq);
    assert(i >=  0 && i < seq->length);
    prev = (( void **)seq->array.array)[
               (seq->head + i)%seq->array.length];
    (( void **)seq->array.array)[
        (seq->head + i)%seq->array.length] = x;
     return prev;
}
void *Seq_remhi(T seq) {
     int i;
    assert(seq);
    assert(seq->length >  0);
    i = --seq->length;
     return (( void **)seq->array.array)[
               (seq->head + i)%seq->array.length];
}
void *Seq_remlo(T seq) {
     int i =  0;
     void *x;
    assert(seq);
    assert(seq->length >  0);
    x = (( void **)seq->array.array)[
            (seq->head + i)%seq->array.length];
    seq->head = (seq->head +  1)%seq->array.length;
    --seq->length;
     return x;
}
void *Seq_addhi(T seq,  void *x) {
     int i;
    assert(seq);
     if (seq->length == seq->array.length)
        expand(seq);
    i = seq->length++;
     return (( void **)seq->array.array)[
               (seq->head + i)%seq->array.length] = x;
}
void *Seq_addlo(T seq,  void *x) {
     int i =  0;
    assert(seq);
     if (seq->length == seq->array.length)
        expand(seq);
     if (--seq->head <  0)
        seq->head = seq->array.length -  1;
    seq->length++;
     return (( void **)seq->array.array)[
               (seq->head + i)%seq->array.length] = x;
}

 

第12章 环

ring.h

/*  $Id: H:/drh/idioms/book/RCS/ring.doc,v 1.12 1997/02/21 19:49:24 drh Exp $  */
#ifndef RING_INCLUDED
#define RING_INCLUDED
#define T Ring_T
typedef  struct T *T;
extern T Ring_new ( void);
extern T Ring_ring( void *x, ...);
extern  void Ring_free  (T *ring);
extern  int  Ring_length(T  ring);
extern  void *Ring_get(T ring,  int i);
extern  void *Ring_put(T ring,  int i,  void *x);
extern  void *Ring_add(T ring,  int pos,  void *x);
extern  void *Ring_addlo(T ring,  void *x);
extern  void *Ring_addhi(T ring,  void *x);
extern  void *Ring_remove(T ring,  int i);
extern  void *Ring_remlo(T ring);
extern  void *Ring_remhi(T ring);
extern  void Ring_rotate(T ring,  int n);
#undef T
#endif

 

ring.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/ring.doc,v 1.12 1997/02/21 19:49:24 drh Exp $ ";
#include <stdlib.h>
#include <stdarg.h>
#include < string.h>
#include  " assert.h "
#include  " ring.h "
#include  " mem.h "
#define T Ring_T
struct T {
     struct node {
         struct node *llink, *rlink;
         void *value;
    } *head;
     int length;
};
T Ring_new( void) {
    T ring;
    NEW0(ring);
    ring->head = NULL;
     return ring;
}
T Ring_ring( void *x, ...) {
    va_list ap;
    T ring = Ring_new();
    va_start(ap, x);
     for ( ; x; x = va_arg(ap,  void *))
        Ring_addhi(ring, x);
    va_end(ap);
     return ring;
}
void Ring_free(T *ring) {
     struct node *p, *q;
    assert(ring && *ring);
     if ((p = (*ring)->head) != NULL) {
         int n = (*ring)->length;
         for ( ; n-- >  0; p = q) {
            q = p->rlink;
            FREE(p);
        }
    }
    FREE(*ring);
}
int Ring_length(T ring) {
    assert(ring);
     return ring->length;
}
void *Ring_get(T ring,  int i) {
     struct node *q;
    assert(ring);
    assert(i >=  0 && i < ring->length);
    {
         int n;
        q = ring->head;
         if (i <= ring->length/ 2)
             for (n = i; n-- >  0; )
                q = q->rlink;
         else
             for (n = ring->length - i; n-- >  0; )
                q = q->llink;
    }
     return q->value;
}
void *Ring_put(T ring,  int i,  void *x) {
     struct node *q;
     void *prev;
    assert(ring);
    assert(i >=  0 && i < ring->length);
    {
         int n;
        q = ring->head;
         if (i <= ring->length/ 2)
             for (n = i; n-- >  0; )
                q = q->rlink;
         else
             for (n = ring->length - i; n-- >  0; )
                q = q->llink;
    }
    prev = q->value;
    q->value = x;
     return prev;
}
void *Ring_addhi(T ring,  void *x) {
     struct node *p, *q;
    assert(ring);
    NEW(p);
     if ((q = ring->head) != NULL)
        {
            p->llink = q->llink;
            q->llink->rlink = p;
            p->rlink = q;
            q->llink = p;
        }
     else
        ring->head = p->llink = p->rlink = p;
    ring->length++;
     return p->value = x;
}
void *Ring_addlo(T ring,  void *x) {
    assert(ring);
    Ring_addhi(ring, x);
    ring->head = ring->head->llink;
     return x;
}
void *Ring_add(T ring,  int pos,  void *x) {
    assert(ring);
    assert(pos >= -ring->length && pos<=ring->length+ 1);
     if (pos ==  1 || pos == -ring->length)
         return Ring_addlo(ring, x);
     else  if (pos ==  0 || pos == ring->length +  1)
         return Ring_addhi(ring, x);
     else {
         struct node *p, *q;
         int i = pos <  0 ? pos + ring->length : pos -  1;
        {
             int n;
            q = ring->head;
             if (i <= ring->length/ 2)
                 for (n = i; n-- >  0; )
                    q = q->rlink;
             else
                 for (n = ring->length - i; n-- >  0; )
                    q = q->llink;
        }
        NEW(p);
        {
            p->llink = q->llink;
            q->llink->rlink = p;
            p->rlink = q;
            q->llink = p;
        }
        ring->length++;
         return p->value = x;
    }
}
void *Ring_remove(T ring,  int i) {
     void *x;
     struct node *q;
    assert(ring);
    assert(ring->length >  0);
    assert(i >=  0 && i < ring->length);
    {
         int n;
        q = ring->head;
         if (i <= ring->length/ 2)
             for (n = i; n-- >  0; )
                q = q->rlink;
         else
             for (n = ring->length - i; n-- >  0; )
                q = q->llink;
    }
     if (i ==  0)
        ring->head = ring->head->rlink;
    x = q->value;
    q->llink->rlink = q->rlink;
    q->rlink->llink = q->llink;
    FREE(q);
     if (--ring->length ==  0)
        ring->head = NULL;
     return x;
}
void *Ring_remhi(T ring) {
     void *x;
     struct node *q;
    assert(ring);
    assert(ring->length >  0);
    q = ring->head->llink;
    x = q->value;
    q->llink->rlink = q->rlink;
    q->rlink->llink = q->llink;
    FREE(q);
     if (--ring->length ==  0)
        ring->head = NULL;
     return x;
}
void *Ring_remlo(T ring) {
    assert(ring);
    assert(ring->length >  0);
    ring->head = ring->head->rlink;
     return Ring_remhi(ring);
}
void Ring_rotate(T ring,  int n) {
     struct node *q;
     int i;
    assert(ring);
    assert(n >= -ring->length && n <= ring->length);
     if (n >=  0)
        i = n%ring->length;
     else
        i = n + ring->length;
    {
         int n;
        q = ring->head;
         if (i <= ring->length/ 2)
             for (n = i; n-- >  0; )
                q = q->rlink;
         else
             for (n = ring->length - i; n-- >  0; )
                q = q->llink;
    }
    ring->head = q;
}

 

第13章 位向量

bit.h

/*  $Id: H:/drh/idioms/book/RCS/bit.doc,v 1.15 1997/02/21 19:49:56 drh Exp $  */
#ifndef BIT_INCLUDED
#define BIT_INCLUDED
#define T Bit_T
typedef  struct T *T;
extern T   Bit_new   ( int length);
extern  int Bit_length(T  set);
extern  int Bit_count (T  set);
extern  void Bit_free(T * set);
extern  int Bit_get(T  set,  int n);
extern  int Bit_put(T  set,  int n,  int bit);
extern  void Bit_clear(T  set,  int lo,  int hi);
extern  void Bit_set  (T  set,  int lo,  int hi);
extern  void Bit_not  (T  set,  int lo,  int hi);
extern  int Bit_lt (T s, T t);
extern  int Bit_eq (T s, T t);
extern  int Bit_leq(T s, T t);
extern  void Bit_map(T  set,
      void apply( int n,  int bit,  void *cl),  void *cl);
extern T Bit_union(T s, T t);
extern T Bit_inter(T s, T t);
extern T Bit_minus(T s, T t);
extern T Bit_diff (T s, T t);
#undef T
#endif

 

bit.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/bit.doc,v 1.15 1997/02/21 19:49:56 drh Exp $ ";
#include <stdarg.h>
#include < string.h>
#include  " assert.h "
#include  " bit.h "
#include  " mem.h "
#define T Bit_T
struct T {
     int length;
    unsigned  char *bytes;
    unsigned  long *words;
};
#define BPW (8*sizeof (unsigned long))
#define nwords(len) ((((len) + BPW - 1)&(~(BPW-1)))/BPW)
#define nbytes(len) ((((len) + 8 - 1)&(~(8-1)))/8)
#define setop(sequal, snull, tnull, op) \
     if (s == t) { assert(s);  return sequal; } \
     else  if (s == NULL) { assert(t);  return snull; } \
     else  if (t == NULL)  return tnull; \
     else { \
         int i; T  set; \
        assert(s->length == t->length); \
         set = Bit_new(s->length); \
         for (i = nwords(s->length); --i >=  0; ) \
             set->words[i] = s->words[i] op t->words[i]; \
         return  set; }
unsigned  char msbmask[] = {
     0xFF,  0xFE,  0xFC,  0xF8,
     0xF0,  0xE0,  0xC0,  0x80
};
unsigned  char lsbmask[] = {
     0x01,  0x03,  0x07,  0x0F,
     0x1F,  0x3F,  0x7F,  0xFF
};
static T copy(T t) {
    T  set;
    assert(t);
     set = Bit_new(t->length);
     if (t->length >  0)
        memcpy( set->bytes, t->bytes, nbytes(t->length));
     return  set;
}
T Bit_new( int length) {
    T  set;
    assert(length >=  0);
    NEW( set);
     if (length >  0)
         set->words = CALLOC(nwords(length),
             sizeof (unsigned  long));
     else
         set->words = NULL;
     set->bytes = (unsigned  char *) set->words;
     set->length = length;
     return  set;
}
void Bit_free(T * set) {
    assert( set && * set);
    FREE((* set)->words);
    FREE(* set);
}
int Bit_length(T  set) {
    assert( set);
     return  set->length;
}
int Bit_count(T  set) {
     int length =  0, n;
     static  char count[] = {
         0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
    assert( set);
     for (n = nbytes( set->length); --n >=  0; ) {
        unsigned  char c =  set->bytes[n];
        length += count[c& 0xF] + count[c>> 4];
    }
     return length;
}
int Bit_get(T  set,  int n) {
    assert( set);
    assert( 0 <= n && n <  set->length);
     return (( set->bytes[n/ 8]>>(n% 8))& 1);
}
int Bit_put(T  set,  int n,  int bit) {
     int prev;
    assert( set);
    assert(bit ==  0 || bit ==  1);
    assert( 0 <= n && n <  set->length);
    prev = (( set->bytes[n/ 8]>>(n% 8))& 1);
     if (bit ==  1)
         set->bytes[n/ 8] |=    1<<(n% 8);
     else
         set->bytes[n/ 8] &= ~( 1<<(n% 8));
     return prev;
}
void Bit_set(T  set,  int lo,  int hi) {
        assert( set);
        assert( 0 <= lo && hi <  set->length);
        assert(lo <= hi);
     if (lo/ 8 < hi/ 8) {
         set->bytes[lo/ 8] |= msbmask[lo% 8];
        {
             int i;
             for (i = lo/ 8+ 1; i < hi/ 8; i++)
                 set->bytes[i] =  0xFF;
        }
         set->bytes[hi/ 8] |= lsbmask[hi% 8];
    }  else
         set->bytes[lo/ 8] |= (msbmask[lo% 8]&lsbmask[hi% 8]);
}
void Bit_clear(T  set,  int lo,  int hi) {
        assert( set);
        assert( 0 <= lo && hi <  set->length);
        assert(lo <= hi);
     if (lo/ 8 < hi/ 8) {
         int i;
         set->bytes[lo/ 8] &= ~msbmask[lo% 8];
         for (i = lo/ 8+ 1; i < hi/ 8; i++)
             set->bytes[i] =  0;
         set->bytes[hi/ 8] &= ~lsbmask[hi% 8];
    }  else
         set->bytes[lo/ 8] &= ~(msbmask[lo% 8]&lsbmask[hi% 8]);
}
void Bit_not(T  set,  int lo,  int hi) {
        assert( set);
        assert( 0 <= lo && hi <  set->length);
        assert(lo <= hi);
     if (lo/ 8 < hi/ 8) {
         int i;
         set->bytes[lo/ 8] ^= msbmask[lo% 8];
         for (i = lo/ 8+ 1; i < hi/ 8; i++)
             set->bytes[i] ^=  0xFF;
         set->bytes[hi/ 8] ^= lsbmask[hi% 8];
    }  else
         set->bytes[lo/ 8] ^= (msbmask[lo% 8]&lsbmask[hi% 8]);
}
void Bit_map(T  set,
     void apply( int n,  int bit,  void *cl),  void *cl) {
     int n;
    assert( set);
     for (n =  0; n <  set->length; n++)
        apply(n, (( set->bytes[n/ 8]>>(n% 8))& 1), cl);
}
int Bit_eq(T s, T t) {
     int i;
    assert(s && t);
    assert(s->length == t->length);
     for (i = nwords(s->length); --i >=  0; )
         if (s->words[i] != t->words[i])
             return  0;
     return  1;
}
int Bit_leq(T s, T t) {
     int i;
    assert(s && t);
    assert(s->length == t->length);
     for (i = nwords(s->length); --i >=  0; )
         if ((s->words[i]&~t->words[i]) !=  0)
             return  0;
     return  1;
}
int Bit_lt(T s, T t) {
     int i, lt =  0;
    assert(s && t);
    assert(s->length == t->length);
     for (i = nwords(s->length); --i >=  0; )
         if ((s->words[i]&~t->words[i]) !=  0)
             return  0;
         else  if (s->words[i] != t->words[i])
            lt |=  1;
     return lt;
}
T Bit_union(T s, T t) {
    setop(copy(t), copy(t), copy(s), |)
}
T Bit_inter(T s, T t) {
    setop(copy(t),
        Bit_new(t->length), Bit_new(s->length), &)
}
T Bit_minus(T s, T t) {
    setop(Bit_new(s->length),
        Bit_new(t->length), copy(s), & ~)
}
T Bit_diff(T s, T t) {
    setop(Bit_new(s->length), copy(t), copy(s), ^)
}

 

fmt.h

/*  $Id: H:/drh/idioms/book/RCS/fmt.doc,v 1.10 1996/06/26 23:02:01 drh Exp $  */
#ifndef FMT_INCLUDED
#define FMT_INCLUDED
#include <stdarg.h>
#include <stdio.h>
#include  " except.h "
#define T Fmt_T
typedef  void (*T)( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[ 256],  int width,  int precision);
extern  char *Fmt_flags;
extern  const Except_T Fmt_Overflow;
extern  void Fmt_fmt ( int put( int c,  void *cl),  void *cl,
     const  char *fmt, ...);
extern  void Fmt_vfmt( int put( int c,  void *cl),  void *cl,
     const  char *fmt, va_list ap);
extern  void Fmt_print ( const  char *fmt, ...);
extern  void Fmt_fprint(FILE *stream,
     const  char *fmt, ...);
extern  int Fmt_sfmt   ( char *buf,  int size,
     const  char *fmt, ...);
extern  int Fmt_vsfmt( char *buf,  int size,
     const  char *fmt, va_list ap);
extern  char *Fmt_string ( const  char *fmt, ...);
extern  char *Fmt_vstring( const  char *fmt, va_list ap);
extern T Fmt_register( int code, T cvt);
extern  void Fmt_putd( const  char *str,  int len,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[ 256],  int width,  int precision);
extern  void Fmt_puts( const  char *str,  int len,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[ 256],  int width,  int precision);
#undef T
#endif

 

fmt.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/fmt.doc,v 1.10 1996/06/26 23:02:01 drh Exp $ ";
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include < string.h>
#include <limits.h>
#include < float.h>
#include <ctype.h>
#include <math.h>
#include  " assert.h "
#include  " except.h "
#include  " fmt.h "
#include  " mem.h "
#define T Fmt_T
struct buf {
     char *buf;
     char *bp;
     int size;
};
#define pad(n,c) do { int nn = (n); \
     while (nn-- >  0) \
        put((c), cl); }  while ( 0)
static  void cvt_s( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
     char *str = va_arg(*app,  char *);
    assert(str);
    Fmt_puts(str, strlen(str), put, cl, flags,
        width, precision);
}
static  void cvt_d( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
     int val = va_arg(*app,  int);
    unsigned m;
     char buf[ 43];
     char *p = buf +  sizeof buf;
     if (val == INT_MIN)
        m = INT_MAX +  1U;
     else  if (val <  0)
        m = -val;
     else
        m = val;
     do
        *--p = m% 10 +  ' 0 ';
     while ((m /=  10) >  0);
     if (val <  0)
        *--p =  ' - ';
    Fmt_putd(p, (buf +  sizeof buf) - p, put, cl, flags,
        width, precision);
}
static  void cvt_u( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
    unsigned m = va_arg(*app, unsigned);
     char buf[ 43];
     char *p = buf +  sizeof buf;
     do
        *--p = m% 10 +  ' 0 ';
     while ((m /=  10) >  0);
    Fmt_putd(p, (buf +  sizeof buf) - p, put, cl, flags,
        width, precision);
}
static  void cvt_o( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
    unsigned m = va_arg(*app, unsigned);
     char buf[ 43];
     char *p = buf +  sizeof buf;
     do
        *--p = (m& 0x7) +  ' 0 ';
     while ((m>>=  3) !=  0);
    Fmt_putd(p, (buf +  sizeof buf) - p, put, cl, flags,
        width, precision);
}
static  void cvt_x( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
    unsigned m = va_arg(*app, unsigned);
     char buf[ 43];
     char *p = buf +  sizeof buf;
     do
        *--p =  " 0123456789abcdef "[m& 0xf];
     while ((m>>=  4) !=  0);
    Fmt_putd(p, (buf +  sizeof buf) - p, put, cl, flags,
        width, precision);
}
static  void cvt_p( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
    unsigned  long m = (unsigned  long)va_arg(*app,  void*);
     char buf[ 43];
     char *p = buf +  sizeof buf;
    precision = INT_MIN;
     do
        *--p =  " 0123456789abcdef "[m& 0xf];
     while ((m>>=  4) !=  0);
    Fmt_putd(p, (buf +  sizeof buf) - p, put, cl, flags,
        width, precision);
}
static  void cvt_c( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
     if (width == INT_MIN)
        width =  0;
     if (width <  0) {
        flags[ ' - '] =  1;
        width = -width;
    }
     if (!flags[ ' - '])
        pad(width -  1,  '   ');
    put((unsigned  char)va_arg(*app,  int), cl);
     if ( flags[ ' - '])
        pad(width -  1,  '   ');
}
static  void cvt_f( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
     char buf[DBL_MAX_10_EXP+ 1+ 1+ 99+ 1];
     if (precision <  0)
        precision =  6;
     if (code ==  ' g ' && precision ==  0)
        precision =  1;
    {
         static  char fmt[] =  " %.dd? ";
        assert(precision <=  99);
        fmt[ 4] = code;
        fmt[ 3] =      precision% 10 +  ' 0 ';
        fmt[ 2] = (precision/ 10)% 10 +  ' 0 ';
        sprintf(buf, fmt, va_arg(*app,  double));
    }
    Fmt_putd(buf, strlen(buf), put, cl, flags,
        width, precision);
}
const Except_T Fmt_Overflow = {  " Formatting Overflow " };
static T cvt[ 256] = {
  /*    0-  7  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*    8- 15  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   16- 23  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   24- 31  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   32- 39  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   40- 47  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   48- 55  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   56- 63  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   64- 71  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   72- 79  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   80- 87  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   88- 95  */  0,      0,  0,      0,      0,      0,      0,      0,
  /*   96-103  */  0,      0,  0, cvt_c, cvt_d, cvt_f, cvt_f, cvt_f,
  /*  104-111  */  0,      0,  0,      0,      0,      0,      0, cvt_o,
  /*  112-119  */ cvt_p,  0,  0, cvt_s,      0, cvt_u,      0,      0,
  /*  120-127  */ cvt_x,  0,  0,      0,      0,      0,      0,      0
};
char *Fmt_flags =  " -+ 0 ";
static  int outc( int c,  void *cl) {
    FILE *f = cl;
     return putc(c, f);
}
static  int insert( int c,  void *cl) {
     struct buf *p = cl;
     if (p->bp >= p->buf + p->size)
        RAISE(Fmt_Overflow);
    *p->bp++ = c;
     return c;
}
static  int append( int c,  void *cl) {
     struct buf *p = cl;
     if (p->bp >= p->buf + p->size) {
        RESIZE(p->buf,  2*p->size);
        p->bp = p->buf + p->size;
        p->size *=  2;
    }
    *p->bp++ = c;
     return c;
}
void Fmt_puts( const  char *str,  int len,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
    assert(str);
    assert(len >=  0);
    assert(flags);
     if (width == INT_MIN)
        width =  0;
     if (width <  0) {
        flags[ ' - '] =  1;
        width = -width;
    }
     if (precision >=  0)
        flags[ ' 0 '] =  0;
     if (precision >=  0 && precision < len)
        len = precision;
     if (!flags[ ' - '])
        pad(width - len,  '   ');
    {
         int i;
         for (i =  0; i < len; i++)
            put((unsigned  char)*str++, cl);
    }
     if ( flags[ ' - '])
        pad(width - len,  '   ');
}
void Fmt_fmt( int put( int c,  void *),  void *cl,
     const  char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    Fmt_vfmt(put, cl, fmt, ap);
    va_end(ap);
}
void Fmt_print( const  char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    Fmt_vfmt(outc, stdout, fmt, ap);
    va_end(ap);
}
void Fmt_fprint(FILE *stream,  const  char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    Fmt_vfmt(outc, stream, fmt, ap);
    va_end(ap);
}
int Fmt_sfmt( char *buf,  int size,  const  char *fmt, ...) {
    va_list ap;
     int len;
    va_start(ap, fmt);
    len = Fmt_vsfmt(buf, size, fmt, ap);
    va_end(ap);
     return len;
}
int Fmt_vsfmt( char *buf,  int size,  const  char *fmt,
    va_list ap) {
     struct buf cl;
    assert(buf);
    assert(size >  0);
    assert(fmt);
    cl.buf = cl.bp = buf;
    cl.size = size;
    Fmt_vfmt(insert, &cl, fmt, ap);
    insert( 0, &cl);
     return cl.bp - cl.buf -  1;
}
char *Fmt_string( const  char *fmt, ...) {
     char *str;
    va_list ap;
    assert(fmt);
    va_start(ap, fmt);
    str = Fmt_vstring(fmt, ap);
    va_end(ap);
     return str;
}
char *Fmt_vstring( const  char *fmt, va_list ap) {
     struct buf cl;
    assert(fmt);
    cl.size =  256;
    cl.buf = cl.bp = ALLOC(cl.size);
    Fmt_vfmt(append, &cl, fmt, ap);
    append( 0, &cl);
     return RESIZE(cl.buf, cl.bp - cl.buf);
}
void Fmt_vfmt( int put( int c,  void *cl),  void *cl,
     const  char *fmt, va_list ap) {
    assert(put);
    assert(fmt);
     while (*fmt)
         if (*fmt !=  ' % ' || *++fmt ==  ' % ')
            put((unsigned  char)*fmt++, cl);
         else
            {
                unsigned  char c, flags[ 256];
                 int width = INT_MIN, precision = INT_MIN;
                memset(flags,  ' \0 ',  sizeof flags);
                 if (Fmt_flags) {
                    unsigned  char c = *fmt;
                     for ( ; c && strchr(Fmt_flags, c); c = *++fmt) {
                        assert(flags[c] <  255);
                        flags[c]++;
                    }
                }
                 if (*fmt ==  ' * ' || isdigit(*fmt)) {
                     int n;
                     if (*fmt ==  ' * ') {
                        n = va_arg(ap,  int);
                        assert(n != INT_MIN);
                        fmt++;
                    }  else
                         for (n =  0; isdigit(*fmt); fmt++) {
                             int d = *fmt -  ' 0 ';
                            assert(n <= (INT_MAX - d)/ 10);
                            n =  10*n + d;
                        }
                    width = n;
                }
                 if (*fmt ==  ' . ' && (*++fmt ==  ' * ' || isdigit(*fmt))) {
                     int n;
                     if (*fmt ==  ' * ') {
                        n = va_arg(ap,  int);
                        assert(n != INT_MIN);
                        fmt++;
                    }  else
                         for (n =  0; isdigit(*fmt); fmt++) {
                             int d = *fmt -  ' 0 ';
                            assert(n <= (INT_MAX - d)/ 10);
                            n =  10*n + d;
                        }
                    precision = n;
                }
                c = *fmt++;
                assert(cvt[c]);
                (*cvt[c])(c, &ap, put, cl, flags, width, precision);
            }
}
T Fmt_register( int code, T newcvt) {
    T old;
    assert( 0 < code
        && code < ( int)( sizeof (cvt)/ sizeof (cvt[ 0])));
    old = cvt[code];
    cvt[code] = newcvt;
     return old;
}
void Fmt_putd( const  char *str,  int len,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
     int sign;
    assert(str);
    assert(len >=  0);
    assert(flags);
     if (width == INT_MIN)
        width =  0;
     if (width <  0) {
        flags[ ' - '] =  1;
        width = -width;
    }
     if (precision >=  0)
        flags[ ' 0 '] =  0;
     if (len >  0 && (*str ==  ' - ' || *str ==  ' + ')) {
        sign = *str++;
        len--;
    }  else  if (flags[ ' + '])
        sign =  ' + ';
     else  if (flags[ '   '])
        sign =  '   ';
     else
        sign =  0;
    {  int n;
       if (precision <  0)
          precision =  1;
       if (len < precision)
          n = precision;
       else  if (precision ==  0 && len ==  1 && str[ 0] ==  ' 0 ')
          n =  0;
       else
          n = len;
       if (sign)
          n++;
       if (flags[ ' - ']) {
           if (sign)
            put(sign, cl);
      }  else  if (flags[ ' 0 ']) {
           if (sign)
            put(sign, cl);
          pad(width - n,  ' 0 ');
      }  else {
          pad(width - n,  '   ');
           if (sign)
            put(sign, cl);
      }
      pad(precision - len,  ' 0 ');
      {
           int i;
           for (i =  0; i < len; i++)
              put((unsigned  char)*str++, cl);
      }
       if (flags[ ' - '])
          pad(width - n,  '   '); }
}

 

str.h

/*  $Id: H:/drh/idioms/book/RCS/str.doc,v 1.10 1996/06/26 23:02:01 drh Exp $  */
#ifndef STR_INCLUDED
#define STR_INCLUDED
#include <stdarg.h>
extern  char *Str_sub( const  char *s,  int i,  int j);
extern  char *Str_dup( const  char *s,  int i,  int j,  int n);
extern  char *Str_cat( const  char *s1,  int i1,  int j1,
     const  char *s2,  int i2,  int j2);
extern  char *Str_catv   ( const  char *s, ...);
extern  char *Str_reverse( const  char *s,  int i,  int j);
extern  char *Str_map    ( const  char *s,  int i,  int j,
     const  char * from,  const  char *to);
extern  int Str_pos( const  char *s,  int i);
extern  int Str_len( const  char *s,  int i,  int j);
extern  int Str_cmp( const  char *s1,  int i1,  int j1,
     const  char *s2,  int i2,  int j2);
extern  int Str_chr  ( const  char *s,  int i,  int j,  int c);
extern  int Str_rchr ( const  char *s,  int i,  int j,  int c);
extern  int Str_upto ( const  char *s,  int i,  int j,
     const  char * set);
extern  int Str_rupto( const  char *s,  int i,  int j,
     const  char * set);
extern  int Str_find ( const  char *s,  int i,  int j,
     const  char *str);
extern  int Str_rfind( const  char *s,  int i,  int j,
     const  char *str);
extern  int Str_any   ( const  char *s,  int i,
     const  char * set);
extern  int Str_many  ( const  char *s,  int i,  int j,
     const  char * set);
extern  int Str_rmany ( const  char *s,  int i,  int j,
     const  char * set);
extern  int Str_match ( const  char *s,  int i,  int j,
     const  char *str);
extern  int Str_rmatch( const  char *s,  int i,  int j,
     const  char *str);
extern  void Str_fmt( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision);
#undef T
#endif

 

str.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/str.doc,v 1.10 1996/06/26 23:02:01 drh Exp $ ";
#include < string.h>
#include <limits.h>
#include  " assert.h "
#include  " fmt.h "
#include  " str.h "
#include  " mem.h "
#define idx(i, len) ((i) <= 0 ? (i) + (len) : (i) - 1)
#define convert(s, i, j) do { int len; \
    assert(s); len = strlen(s); \
    i = idx(i, len); j = idx(j, len); \
     if (i > j) {  int t = i; i = j; j = t; } \
    assert(i >=  0 && j <= len); }  while ( 0)
char *Str_sub( const  char *s,  int i,  int j) {
     char *str, *p;
    convert(s, i, j);
    p = str = ALLOC(j - i +  1);
     while (i < j)
        *p++ = s[i++];
    *p =  ' \0 ';
     return str;
}
char *Str_dup( const  char *s,  int i,  int j,  int n) {
     int k;
     char *str, *p;
    assert(n >=  0);
    convert(s, i, j);
    p = str = ALLOC(n*(j - i) +  1);
     if (j - i >  0)
         while (n-- >  0)
             for (k = i; k < j; k++)
                *p++ = s[k];
    *p =  ' \0 ';
     return str;
}
char *Str_reverse( const  char *s,  int i,  int j) {
     char *str, *p;
    convert(s, i, j);
    p = str = ALLOC(j - i +  1);
     while (j > i)
        *p++ = s[--j];
    *p =  ' \0 ';
     return str;
}
char *Str_cat( const  char *s1,  int i1,  int j1,
               const  char *s2,  int i2,  int j2) {
     char *str, *p;
    convert(s1, i1, j1);
    convert(s2, i2, j2);
    p = str = ALLOC(j1 - i1 + j2 - i2 +  1);
     while (i1 < j1)
        *p++ = s1[i1++];
     while (i2 < j2)
        *p++ = s2[i2++];
    *p =  ' \0 ';
     return str;
}
char *Str_catv( const  char *s, ...) {
     char *str, *p;
     const  char *save = s;
     int i, j, len =  0;
    va_list ap;
    va_start(ap, s);
     while (s) {
        i = va_arg(ap,  int);
        j = va_arg(ap,  int);
        convert(s, i, j);
        len += j - i;
        s = va_arg(ap,  const  char *);
    }
    va_end(ap);
    p = str = ALLOC(len +  1);
    s = save;
    va_start(ap, s);
     while (s) {
        i = va_arg(ap,  int);
        j = va_arg(ap,  int);
        convert(s, i, j);
         while (i < j)
            *p++ = s[i++];
        s = va_arg(ap,  const  char *);
    }
    va_end(ap);
    *p =  ' \0 ';
     return str;
}
char *Str_map( const  char *s,  int i,  int j,
     const  char * from,  const  char *to) {
     static  char map[ 256] = {  0 };
     if ( from && to) {
        unsigned c;
         for (c =  0; c <  sizeof map; c++)
            map[c] = c;
         while (* from && *to)
            map[(unsigned  char)* from++] = *to++;
        assert(* from ==  0 && *to ==  0);
    }  else {
        assert( from == NULL && to == NULL && s);
        assert(map[ ' a ']);
    }
     if (s) {
         char *str, *p;
        convert(s, i, j);
        p = str = ALLOC(j - i +  1);
         while (i < j)
            *p++ = map[(unsigned  char)s[i++]];
        *p =  ' \0 ';
         return str;
    }  else
         return NULL;
}
int Str_pos( const  char *s,  int i) {
     int len;
    assert(s);
    len = strlen(s);
    i = idx(i, len);
    assert(i >=  0 && i <= len);
     return i +  1;
}
int Str_len( const  char *s,  int i,  int j) {
    convert(s, i, j);
     return j - i;
}
int Str_cmp( const  char *s1,  int i1,  int j1,
     const  char *s2,  int i2,  int j2) {
    convert(s1, i1, j1);
    convert(s2, i2, j2);
    s1 += i1;
    s2 += i2;
     if (j1 - i1 < j2 - i2) {
         int cond = strncmp(s1, s2, j1 - i1);
         return cond ==  0 ? - 1 : cond;
    }  else  if (j1 - i1 > j2 - i2) {
         int cond = strncmp(s1, s2, j2 - i2);
         return cond ==  0 ? + 1 : cond;
    }  else
         return strncmp(s1, s2, j1 - i1);
}
int Str_chr( const  char *s,  int i,  int j,  int c) {
    convert(s, i, j);
     for ( ; i < j; i++)
         if (s[i] == c)
             return i +  1;
     return  0;
}
int Str_rchr( const  char *s,  int i,  int j,  int c) {
    convert(s, i, j);
     while (j > i)
         if (s[--j] == c)
             return j +  1;
     return  0;
}
int Str_upto( const  char *s,  int i,  int j,
     const  char * set) {
    assert( set);
    convert(s, i, j);
     for ( ; i < j; i++)
         if (strchr( set, s[i]))
             return i +  1;
     return  0;
}
int Str_rupto( const  char *s,  int i,  int j,
     const  char * set) {
    assert( set);
    convert(s, i, j);
     while (j > i)
         if (strchr( set, s[--j]))
             return j +  1;
     return  0;
}
int Str_find( const  char *s,  int i,  int j,
     const  char *str) {
     int len;
    convert(s, i, j);
    assert(str);
    len = strlen(str);
     if (len ==  0)
         return i +  1;
     else  if (len ==  1) {
         for ( ; i < j; i++)
             if (s[i] == *str)
                 return i +  1;
    }  else
         for ( ; i + len <= j; i++)
             if ((strncmp(&s[i], str, len) ==  0))
                 return i +  1;
     return  0;
}
int Str_rfind( const  char *s,  int i,  int j,
     const  char *str) {
     int len;
    convert(s, i, j);
    assert(str);
    len = strlen(str);
     if (len ==  0)
         return j +  1;
     else  if (len ==  1) {
         while (j > i)
             if (s[--j] == *str)
                 return j +  1;
    }  else
         for ( ; j - len >= i; j--)
             if (strncmp(&s[j-len], str, len) ==  0)
                 return j - len +  1;
     return  0;
}
int Str_any( const  char *s,  int i,  const  char * set) {
     int len;
    assert(s);
    assert( set);
    len = strlen(s);
    i = idx(i, len);
    assert(i >=  0 && i <= len);
     if (i < len && strchr( set, s[i]))
         return i +  2;
     return  0;
}
int Str_many( const  char *s,  int i,  int j,
     const  char * set) {
    assert( set);
    convert(s, i, j);
     if (i < j && strchr( set, s[i])) {
         do
            i++;
         while (i < j && strchr( set, s[i]));
         return i +  1;
    }
     return  0;
}
int Str_rmany( const  char *s,  int i,  int j,
     const  char * set) {
    assert( set);
    convert(s, i, j);
     if (j > i && strchr( set, s[j- 1])) {
         do
            --j;
         while (j >= i && strchr( set, s[j]));
         return j +  2;
    }
     return  0;
}
int Str_match( const  char *s,  int i,  int j,
     const  char *str) {
     int len;
    convert(s, i, j);
    assert(str);
    len = strlen(str);
     if (len ==  0)
         return i +  1; 
     else  if (len ==  1) {
         if (i < j && s[i] == *str)
             return i +  2;
    }  else  if (i + len <= j && (strncmp(&s[i], str, len) ==  0))
         return i + len +  1;
     return  0;
}
int Str_rmatch( const  char *s,  int i,  int j,
     const  char *str) {
     int len;
    convert(s, i, j);
    assert(str);
    len = strlen(str);
     if (len ==  0)
         return j +  1;
     else  if (len ==  1) {
         if (j > i && s[j- 1] == *str)
             return j;
    }  else  if (j - len >= i
    && strncmp(&s[j-len], str, len) ==  0)
         return j - len +  1;
     return  0;
}
void Str_fmt( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
     char *s;
     int i, j;
    assert(app && flags);
    s = va_arg(*app,  char *);
    i = va_arg(*app,  int);
    j = va_arg(*app,  int);
    convert(s, i, j);
    Fmt_puts(s + i, j - i, put, cl, flags,
        width, precision);
}

 

ids.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/str.doc,v 1.10 1996/06/26 23:02:01 drh Exp $ ";
#include <stdlib.h>
#include <stdio.h>
#include  " fmt.h "
#include  " str.h "
int main( int argc,  char *argv[]) {
     char line[ 512];
     static  char  set[] =  " 0123456789_ "
         " abcdefghijklmnopqrstuvwxyz "
         " ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
    Fmt_register( ' S ', Str_fmt);
     while (fgets(line,  sizeof line, stdin) != NULL) {
         int i =  1, j;
         while ((i = Str_upto(line, i,  0, & set[ 10])) >  0){
            j = Str_many(line, i,  0,  set);
            Fmt_print( " %S\n ", line, i, j);
            i = j;
        }
    }
     return EXIT_SUCCESS;
}

 

text.h

/*  $Id: H:/drh/idioms/book/RCS/text.doc,v 1.10 1996/06/26 23:02:01 drh Exp $  */
#ifndef TEXT_INCLUDED
#define TEXT_INCLUDED
#include <stdarg.h>
#define T Text_T
typedef  struct T {
     int len;
     const  char *str;
} T;
typedef  struct Text_save_T *Text_save_T;
extern  const T Text_cset;
extern  const T Text_ascii;
extern  const T Text_ucase;
extern  const T Text_lcase;
extern  const T Text_digits;
extern  const T Text_null;
extern T     Text_put( const  char *str);
extern  char *Text_get( char *str,  int size, T s);
extern T     Text_box( const  char *str,  int len);
extern T Text_sub(T s,  int i,  int j);
extern  int Text_pos(T s,  int i);
extern T Text_cat    (T s1, T s2);
extern T Text_dup    (T s,  int n);
extern T Text_reverse(T s);
extern T Text_map(T s,  const T * from,  const T *to);
extern  int Text_cmp(T s1, T s2);
extern  int Text_chr  (T s,  int i,  int j,  int c);
extern  int Text_rchr (T s,  int i,  int j,  int c);
extern  int Text_upto (T s,  int i,  int j, T  set);
extern  int Text_rupto(T s,  int i,  int j, T  set);
extern  int Text_any  (T s,  int i, T  set);
extern  int Text_many (T s,  int i,  int j, T  set);
extern  int Text_rmany(T s,  int i,  int j, T  set);
extern  int Text_find  (T s,  int i,  int j, T str);
extern  int Text_rfind (T s,  int i,  int j, T str);
extern  int Text_match (T s,  int i,  int j, T str);
extern  int Text_rmatch(T s,  int i,  int j, T str);
extern  void Text_fmt( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision);
extern Text_save_T Text_save( void);
extern  void        Text_restore(Text_save_T *save);
#undef T
#endif

 

text.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/text.doc,v 1.10 1996/06/26 23:02:01 drh Exp $ ";
#include < string.h>
#include <limits.h>
#include  " assert.h "
#include  " fmt.h "
#include  " text.h "
#include  " mem.h "
#define T Text_T
#define idx(i, len) ((i) <= 0 ? (i) + (len) : (i) - 1)
#define isatend(s, n) ((s).str+(s).len == current->avail\
    && current->avail + (n) <= current->limit)
#define equal(s, i, t) \
    (memcmp(&(s).str[i], (t).str, (t).len) ==  0)
struct Text_save_T {
     struct chunk *current;
     char *avail;
};
static  char cset[] =
     " \000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017 "
     " \020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 "
     " \040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057 "
     " \060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077 "
     " \100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117 "
     " \120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137 "
     " \140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157 "
     " \160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177 "
     " \200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217 "
     " \220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237 "
     " \240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257 "
     " \260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277 "
     " \300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317 "
     " \320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337 "
     " \340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357 "
     " \360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377 "
    ;
const T Text_cset   = {  256, cset };
const T Text_ascii  = {  127, cset };
const T Text_ucase  = {   26, cset +  ' A ' };
const T Text_lcase  = {   26, cset +  ' a ' };
const T Text_digits = {   10, cset +  ' 0 ' };
const T Text_null   = {    0, cset };
static  struct chunk {
     struct chunk *link;
     char *avail;
     char *limit;
} head = { NULL, NULL, NULL }, *current = &head;
static  char *alloc( int len) {
    assert(len >=  0);
     if (current->avail + len > current->limit) {
        current = current->link = 
            ALLOC( sizeof (*current) +  10* 1024 + len);
        current->avail = ( char *)(current +  1);
        current->limit = current->avail +  10* 1024 + len;
        current->link = NULL;
    }
    current->avail += len;
     return current->avail - len;
}
int Text_pos(T s,  int i) {
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    assert(i >=  0 && i <= s.len);
     return i +  1;
}
T Text_box( const  char *str,  int len) {
    T text;
    assert(str);
    assert(len >=  0);
    text.str = str;
    text.len = len;
     return text;
}
T Text_sub(T s,  int i,  int j) {
    T text;
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
    text.len = j - i;
    text.str = s.str + i;
     return text;
}
T Text_put( const  char *str) {
    T text;
    assert(str);
    text.len = strlen(str);
    text.str = memcpy(alloc(text.len), str, text.len);
     return text;
}
char *Text_get( char *str,  int size, T s) {
    assert(s.len >=  0 && s.str);
     if (str == NULL)
        str = ALLOC(s.len +  1);
     else
        assert(size >= s.len +  1);
    memcpy(str, s.str, s.len);
    str[s.len] =  ' \0 ';
     return str;
}
T Text_dup(T s,  int n) {
    assert(s.len >=  0 && s.str);
    assert(n >=  0);
     if (n ==  0 || s.len ==  0)
         return Text_null;
     if (n ==  1)
         return s;
    {
        T text;
         char *p;
        text.len = n*s.len;
         if (isatend(s, text.len - s.len)) {
            text.str = s.str;
            p = alloc(text.len - s.len);
            n--;
        }  else
            text.str = p = alloc(text.len);
         for ( ; n-- >  0; p += s.len)
            memcpy(p, s.str, s.len);
         return text;
    }
}
T Text_cat(T s1, T s2) {
    assert(s1.len >=  0 && s1.str);
    assert(s2.len >=  0 && s2.str);
     if (s1.len ==  0)
         return s2;
     if (s2.len ==  0)
         return s1;
     if (s1.str + s1.len == s2.str) {
        s1.len += s2.len;
         return s1;
    }
    {
        T text;
        text.len = s1.len + s2.len;
         if (isatend(s1, s2.len)) {
            text.str = s1.str;
            memcpy(alloc(s2.len), s2.str, s2.len);
        }  else {
             char *p;
            text.str = p = alloc(s1.len + s2.len);
            memcpy(p,          s1.str, s1.len);
            memcpy(p + s1.len, s2.str, s2.len);
        }
         return text;
    } 
}
T Text_reverse(T s) {
    assert(s.len >=  0 && s.str);
     if (s.len ==  0)
         return Text_null;
     else  if (s.len ==  1)
         return s;
     else {
        T text;
         char *p;
         int i = s.len;
        text.len = s.len;
        text.str = p = alloc(s.len);
         while (--i >=  0)
            *p++ = s.str[i];
         return text;
    }
}
T Text_map(T s,  const T * from,  const T *to) {
     static  char map[ 256];
     static  int inited =  0;
    assert(s.len >=  0 && s.str);
     if ( from && to) {
         int k;
         for (k =  0; k < ( int) sizeof map; k++)
            map[k] = k;
        assert( from->len == to->len);
         for (k =  0; k <  from->len; k++)
            map[ from->str[k]] = to->str[k];
        inited =  1;
    }  else {
        assert( from == NULL && to == NULL);
        assert(inited);
    }
     if (s.len ==  0)
         return Text_null;
     else {
        T text;
         int i;
         char *p;
        text.len = s.len;
        text.str = p = alloc(s.len);
         for (i =  0; i < s.len; i++)
            *p++ = map[s.str[i]];
         return text;
    }
}
int Text_cmp(T s1, T s2) {
    assert(s1.len >=  0 && s1.str);
    assert(s2.len >=  0 && s2.str);
     if (s1.str == s2.str)
         return s1.len - s2.len;
     else  if (s1.len < s2.len) {
         int cond = memcmp(s1.str, s2.str, s1.len);
         return cond ==  0 ? - 1 : cond;
    }  else  if (s1.len > s2.len) {
         int cond = memcmp(s1.str, s2.str, s2.len);
         return cond ==  0 ? + 1 : cond;
    }  else
         return memcmp(s1.str, s2.str, s1.len);
}
Text_save_T Text_save( void) {
    Text_save_T save;
    NEW(save);
    save->current = current;
    save->avail = current->avail;
    alloc( 1);
     return save;
}
void Text_restore(Text_save_T *save) {
     struct chunk *p, *q;
    assert(save && *save);
    current = (*save)->current;
    current->avail = (*save)->avail;
    FREE(*save);
     for (p = current->link; p; p = q) {
        q = p->link;
        FREE(p);
    }
    current->link = NULL;
}
int Text_chr(T s,  int i,  int j,  int c) {
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     for ( ; i < j; i++)
         if (s.str[i] == c)
             return i +  1;
     return  0;
}
int Text_rchr(T s,  int i,  int j,  int c) {
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     while (j > i)
         if (s.str[--j] == c)
             return j +  1;
     return  0;
}
int Text_upto(T s,  int i,  int j, T  set) {
    assert( set.len >=  0 &&  set.str);
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     for ( ; i < j; i++)
         if (memchr( set.str, s.str[i],  set.len))
             return i +  1;
     return  0;
}
int Text_rupto(T s,  int i,  int j, T  set) {
    assert( set.len >=  0 &&  set.str);
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     while (j > i)
         if (memchr( set.str, s.str[--j],  set.len))
             return j +  1;
     return  0;
}
int Text_find(T s,  int i,  int j, T str) {
    assert(str.len >=  0 && str.str);
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     if (str.len ==  0)
         return i +  1;
     else  if (str.len ==  1) {
         for ( ; i < j; i++)
             if (s.str[i] == *str.str)
                 return i +  1;
    }  else
         for ( ; i + str.len <= j; i++)
             if (equal(s, i, str))
                 return i +  1;
     return  0;
}
int Text_rfind(T s,  int i,  int j, T str) {
    assert(str.len >=  0 && str.str);
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     if (str.len ==  0)
         return j +  1;
     else  if (str.len ==  1) {
         while (j > i)
             if (s.str[--j] == *str.str)
                 return j +  1;
    }  else
         for ( ; j - str.len >= i; j--)
             if (equal(s, j - str.len, str))
                 return j - str.len +  1;
     return  0;
}
int Text_any(T s,  int i, T  set) {
    assert(s.len >=  0 && s.str);
    assert( set.len >=  0 &&  set.str);
    i = idx(i, s.len);
    assert(i >=  0 && i <= s.len);
     if (i < s.len && memchr( set.str, s.str[i],  set.len))
         return i +  2;
     return  0;
}
int Text_many(T s,  int i,  int j, T  set) {
    assert( set.len >=  0 &&  set.str);
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     if (i < j && memchr( set.str, s.str[i],  set.len)) {
         do
            i++;
         while (i < j
        && memchr( set.str, s.str[i],  set.len));
         return i +  1;
    }
     return  0;
}
int Text_rmany(T s,  int i,  int j, T  set) {
    assert( set.len >=  0 &&  set.str);
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     if (j > i && memchr( set.str, s.str[j- 1],  set.len)) {
         do
            --j;
         while (j >= i
        && memchr( set.str, s.str[j],  set.len));
         return j +  2;
    }
     return  0;
}
int Text_match(T s,  int i,  int j, T str) {
    assert(str.len >=  0 && str.str);
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     if (str.len ==  0)
         return i +  1;
     else  if (str.len ==  1) {
         if (i < j && s.str[i] == *str.str)
             return i +  2;
    }  else  if (i + str.len <= j && equal(s, i, str))
         return i + str.len +  1;
     return  0;
}
int Text_rmatch(T s,  int i,  int j, T str) {
    assert(str.len >=  0 && str.str);
    assert(s.len >=  0 && s.str);
    i = idx(i, s.len);
    j = idx(j, s.len);
     if (i > j) {  int t = i; i = j; j = t; }
    assert(i >=  0 && j <= s.len);
     if (str.len ==  0)
         return j +  1;
     else  if (str.len ==  1) {
         if (j > i && s.str[j- 1] == *str.str)
             return j;
    }  else  if (j - str.len >= i
    && equal(s, j - str.len, str))
         return j - str.len +  1;
     return  0;
}
void Text_fmt( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
    T *s;
    assert(app && flags);
    s = va_arg(*app, T*);
    assert(s && s->len >=  0 && s->str);
    Fmt_puts(s->str, s->len, put, cl, flags,
        width, precision);
}

 

xp.h

/*  $Id: H:/drh/idioms/book/RCS/xp.doc,v 1.10 1996/06/26 23:02:01 drh Exp $  */
#ifndef XP_INCLUDED
#define XP_INCLUDED
#define T XP_T
typedef unsigned  char *T;
extern  int XP_add( int n, T z, T x, T y,  int carry);
extern  int XP_sub( int n, T z, T x, T y,  int borrow);
extern  int XP_mul(T z,  int n, T x,  int m, T y);
extern  int XP_div( int n, T q, T x,  int m, T y, T r,T tmp);
extern  int XP_sum     ( int n, T z, T x,  int y);
extern  int XP_diff    ( int n, T z, T x,  int y);
extern  int XP_product ( int n, T z, T x,  int y);
extern  int XP_quotient( int n, T z, T x,  int y);
extern  int XP_neg( int n, T z, T x,  int carry);
extern  int XP_cmp( int n, T x, T y);
extern  void XP_lshift( int n, T z,  int m, T x,
     int s,  int fill);
extern  void XP_rshift( int n, T z,  int m, T x,
     int s,  int fill);
extern  int           XP_length ( int n, T x);
extern unsigned  long XP_fromint( int n, T z,
    unsigned  long u);
extern unsigned  long XP_toint  ( int n, T x);
extern  int   XP_fromstr( int n, T z,  const  char *str,
     int  base,  char **end);
extern  char *XP_tostr  ( char *str,  int size,  int  base,
     int n, T x);
#undef T
#endif

 

xp.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/xp.doc,v 1.10 1996/06/26 23:02:01 drh Exp $ ";
#include <ctype.h>
#include < string.h>
#include  " assert.h "
#include  " xp.h "
#define T XP_T
#define BASE (1<<8)
static  char map[] = {
      0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
     36,  36,  36,  36,  36,  36,  36,
     10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,
     23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,
     36,  36,  36,  36,  36,  36,
     10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,
     23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35
};
unsigned  long XP_fromint( int n, T z, unsigned  long u) {
     int i =  0;
     do
        z[i++] = u%BASE;
     while ((u /= BASE) >  0 && i < n);
     for ( ; i < n; i++)
        z[i] =  0;
     return u;
}
unsigned  long XP_toint( int n, T x) {
    unsigned  long u =  0;
     int i = ( int) sizeof u;
     if (i > n)
        i = n;
     while (--i >=  0)
        u = BASE*u + x[i];
     return u;
}
int XP_length( int n, T x) {
     while (n >  1 && x[n- 1] ==  0)
        n--;
     return n;
}
int XP_add( int n, T z, T x, T y,  int carry) {
     int i;
     for (i =  0; i < n; i++) {
        carry += x[i] + y[i];
        z[i] = carry%BASE;
        carry /= BASE;
    }
     return carry;
}
int XP_sub( int n, T z, T x, T y,  int borrow) {
     int i;
     for (i =  0; i < n; i++) {
         int d = (x[i] + BASE) - borrow - y[i];
        z[i] = d%BASE;
        borrow =  1 - d/BASE;
    }
     return borrow;
}
int XP_sum( int n, T z, T x,  int y) {
     int i;
     for (i =  0; i < n; i++) {
        y += x[i];
        z[i] = y%BASE;
        y /= BASE;
    }
     return y;
}
int XP_diff( int n, T z, T x,  int y) {
     int i;
     for (i =  0; i < n; i++) {
         int d = (x[i] + BASE) - y;
        z[i] = d%BASE;
        y =  1 - d/BASE;
    }
     return y;
}
int XP_neg( int n, T z, T x,  int carry) {
     int i;
     for (i =  0; i < n; i++) {
        carry += (unsigned  char)~x[i];
        z[i] = carry%BASE;
        carry /= BASE;
    }
     return carry;
}
int XP_mul(T z,  int n, T x,  int m, T y) {
     int i, j, carryout =  0;
     for (i =  0; i < n; i++) {
        unsigned carry =  0;
         for (j =  0; j < m; j++) {
            carry += x[i]*y[j] + z[i+j];
            z[i+j] = carry%BASE;
            carry /= BASE;
        }
         for ( ; j < n + m - i; j++) {
            carry += z[i+j];
            z[i+j] = carry%BASE;
            carry /= BASE;
        }
        carryout |= carry;
    }
     return carryout;
}
int XP_product( int n, T z, T x,  int y) {
     int i;
    unsigned carry =  0;
     for (i =  0; i < n; i++) {
        carry += x[i]*y;
        z[i] = carry%BASE;
        carry /= BASE;
    }
     return carry;
}
int XP_div( int n, T q, T x,  int m, T y, T r, T tmp) {
     int nx = n, my = m;
    n = XP_length(n, x);
    m = XP_length(m, y);
     if (m ==  1) {
         if (y[ 0] ==  0)
             return  0;
        r[ 0] = XP_quotient(nx, q, x, y[ 0]);
        memset(r +  1,  ' \0 ', my -  1);
    }  else  if (m > n) {
        memset(q,  ' \0 ', nx);
        memcpy(r, x, n);
        memset(r + n,  ' \0 ', my - n);
    }  else {
         int k;
        unsigned  char *rem = tmp, *dq = tmp + n +  1;
        assert( 2 <= m && m <= n);
        memcpy(rem, x, n);
        rem[n] =  0;
         for (k = n - m; k >=  0; k--) {
             int qk;
            {
                 int i;
                assert( 2 <= m && m <= k+m && k+m <= n);
                {
                     int km = k + m;
                    unsigned  long y2 = y[m- 1]*BASE + y[m- 2];
                    unsigned  long r3 = rem[km]*(BASE*BASE) +
                        rem[km- 1]*BASE + rem[km- 2];
                    qk = r3/y2;
                     if (qk >= BASE)
                        qk = BASE -  1;
                }
                dq[m] = XP_product(m, dq, y, qk);
                 for (i = m; i >  0; i--)
                     if (rem[i+k] != dq[i])
                         break;
                 if (rem[i+k] < dq[i])
                    dq[m] = XP_product(m, dq, y, --qk);
            }
            q[k] = qk;
            {
                 int borrow;
                assert( 0 <= k && k <= k+m);
                borrow = XP_sub(m +  1, &rem[k], &rem[k], dq,  0);
                assert(borrow ==  0);
            }
        }
        memcpy(r, rem, m);
        {
             int i;
             for (i = n-m+ 1; i < nx; i++)
                q[i] =  0;
             for (i = m; i < my; i++)
                r[i] =  0;
        }
    }
     return  1;
}
int XP_quotient( int n, T z, T x,  int y) {
     int i;
    unsigned carry =  0;
     for (i = n -  1; i >=  0; i--) {
        carry = carry*BASE + x[i];
        z[i] = carry/y;
        carry %= y;
    }
     return carry;
}
int XP_cmp( int n, T x, T y) {
     int i = n -  1;
     while (i >  0 && x[i] == y[i])
        i--;
     return x[i] - y[i];
}
void XP_lshift( int n, T z,  int m, T x,  int s,  int fill) {
    fill = fill ?  0xFF :  0;
    {
         int i, j = n -  1;
         if (n > m)
            i = m -  1;
         else
            i = n - s/ 8 -  1;
         for ( ; j >= m + s/ 8; j--)
            z[j] =  0;
         for ( ; i >=  0; i--, j--)
            z[j] = x[i];
         for ( ; j >=  0; j--)
            z[j] = fill;
    }
    s %=  8;
     if (s >  0)
        {
            XP_product(n, z, z,  1<<s);
            z[ 0] |= fill>>( 8-s);
        }
}
void XP_rshift( int n, T z,  int m, T x,  int s,  int fill) {
    fill = fill ?  0xFF :  0;
    {
         int i, j =  0;
         for (i = s/ 8; i < m && j < n; i++, j++)
            z[j] = x[i];
         for ( ; j < n; j++)
            z[j] = fill;
    }
    s %=  8;
     if (s >  0)
        {
            XP_quotient(n, z, z,  1<<s);
            z[n- 1] |= fill<<( 8-s);
        }
}
int XP_fromstr( int n, T z,  const  char *str,
     int  base,  char **end) {
     const  char *p = str;
    assert(p);
    assert( base >=  2 &&  base <=  36);
     while (*p && isspace(*p))
        p++;
     if ((*p && isalnum(*p) && map[*p- ' 0 '] <  base)) {
         int carry;
         for ( ; (*p && isalnum(*p) && map[*p- ' 0 '] <  base); p++) {
            carry = XP_product(n, z, z,  base);
             if (carry)
                 break;
            XP_sum(n, z, z, map[*p- ' 0 ']);
        }
         if (end)
            *end = ( char *)p;
         return carry;
    }  else {
         if (end)
            *end = ( char *)str;
         return  0;
    }
}
char *XP_tostr( char *str,  int size,  int  base,
     int n, T x) {
     int i =  0;
    assert(str);
    assert( base >=  2 &&  base <=  36);
     do {
         int r = XP_quotient(n, x, x,  base);
        assert(i < size);
        str[i++] =
             " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ "[r];
         while (n >  1 && x[n- 1] ==  0)
            n--;
    }  while (n >  1 || x[ 0] !=  0);
    assert(i < size);
    str[i] =  ' \0 ';
    {
         int j;
         for (j =  0; j < --i; j++) {
             char c = str[j];
            str[j] = str[i];
            str[i] = c;
        }
    }
     return str;
}

 

ap.h

/*  $Id: H:/drh/idioms/book/RCS/ap.doc,v 1.11 1996/06/26 23:02:01 drh Exp $  */
#ifndef AP_INCLUDED
#define AP_INCLUDED
#include <stdarg.h>
#define T AP_T
typedef  struct T *T;
extern T AP_new    ( long  int n);
extern T AP_fromstr( const  char *str,  int  base,
     char **end);
extern  long  int AP_toint(T x);
extern  char    *AP_tostr( char *str,  int size,
     int  base, T x);
extern  void     AP_fmt( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision);
extern  void AP_free(T *z);
extern T AP_neg(T x);
extern T AP_add(T x, T y);
extern T AP_sub(T x, T y);
extern T AP_mul(T x, T y);
extern T AP_div(T x, T y);
extern T AP_mod(T x, T y);
extern T AP_pow(T x, T y, T p);
extern T    AP_addi(T x,  long  int y);
extern T    AP_subi(T x,  long  int y);
extern T    AP_muli(T x,  long  int y);
extern T    AP_divi(T x,  long  int y);
extern  long AP_modi(T x,  long  int y);
extern T AP_lshift(T x,  int s);
extern T AP_rshift(T x,  int s);
extern  int AP_cmp (T x, T y);
extern  int AP_cmpi(T x,  long  int y);
#undef T
#endif

 

 

ap.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/ap.doc,v 1.11 1996/06/26 23:02:01 drh Exp $ ";
#include <ctype.h>
#include <limits.h>
#include <stdlib.h>
#include < string.h>
#include  " assert.h "
#include  " ap.h "
#include  " fmt.h "
#include  " xp.h "
#include  " mem.h "
#define T AP_T
struct T {
     int sign;
     int ndigits;
     int size;
    XP_T digits;
};
#define iszero(x) ((x)->ndigits==1 && (x)->digits[0]==0)
#define maxdigits(x,y) ((x)->ndigits > (y)->ndigits ? \
    (x)->ndigits : (y)->ndigits)
#define isone(x) ((x)->ndigits==1 && (x)->digits[0]==1)
static T normalize(T z,  int n);
static  int cmp(T x, T y);
static T mk( int size) {
    T z = CALLOC( 1,  sizeof (*z) + size);
    assert(size >  0);
    z->sign =  1;
    z->size = size;
    z->ndigits =  1;
    z->digits = (XP_T)(z +  1);
     return z;
}
static T  set(T z,  long  int n) {
     if (n == LONG_MIN)
        XP_fromint(z->size, z->digits, LONG_MAX +  1UL);
     else  if (n <  0)
        XP_fromint(z->size, z->digits, -n);
     else
        XP_fromint(z->size, z->digits, n);
    z->sign = n <  0 ? - 1 :  1;
     return normalize(z, z->size);
}
static T normalize(T z,  int n) {
    z->ndigits = XP_length(n, z->digits);
     return z;
}
static T add(T z, T x, T y) {
     int n = y->ndigits;
     if (x->ndigits < n)
         return add(z, y, x);
     else  if (x->ndigits > n) {
         int carry = XP_add(n, z->digits, x->digits,
            y->digits,  0);
        z->digits[z->size- 1] = XP_sum(x->ndigits - n,
            &z->digits[n], &x->digits[n], carry);
    }  else
        z->digits[n] = XP_add(n, z->digits, x->digits,
            y->digits,  0);
     return normalize(z, z->size);
}
static T sub(T z, T x, T y) {
     int borrow, n = y->ndigits;
    borrow = XP_sub(n, z->digits, x->digits,
        y->digits,  0);
     if (x->ndigits > n)
        borrow = XP_diff(x->ndigits - n, &z->digits[n],
            &x->digits[n], borrow);
    assert(borrow ==  0);
     return normalize(z, z->size);
}
static T mulmod(T x, T y, T p) {
    T z, xy = AP_mul(x, y);
    z = AP_mod(xy, p);
    AP_free(&xy);
     return z;
}
static  int cmp(T x, T y) {
     if (x->ndigits != y->ndigits)
         return x->ndigits - y->ndigits;
     else
         return XP_cmp(x->ndigits, x->digits, y->digits);
}
T AP_new( long  int n) {
     return  set(mk( sizeof ( long  int)), n);
}
void AP_free(T *z) {
    assert(z && *z);
    FREE(*z);
}
T AP_neg(T x) {
    T z;
    assert(x);
    z = mk(x->ndigits);
    memcpy(z->digits, x->digits, x->ndigits);
    z->ndigits = x->ndigits;
    z->sign = iszero(z) ?  1 : -x->sign;
     return z;
}
T AP_mul(T x, T y) {
    T z;
    assert(x);
    assert(y);
    z = mk(x->ndigits + y->ndigits);
    XP_mul(z->digits, x->ndigits, x->digits, y->ndigits,
        y->digits);
    normalize(z, z->size);
    z->sign = iszero(z)
        || ((x->sign^y->sign) ==  0) ?  1 : - 1;
     return z;
}
T AP_add(T x, T y) {
    T z;
    assert(x);
    assert(y);
     if (((x->sign^y->sign) ==  0)) {
        z = add(mk(maxdigits(x,y) +  1), x, y);
        z->sign = iszero(z) ?  1 : x->sign;
    }  else
         if (cmp(x, y) >  0) {
            z = sub(mk(x->ndigits), x, y);
            z->sign = iszero(z) ?  1 : x->sign;
        }
         else {
            z = sub(mk(y->ndigits), y, x);
            z->sign = iszero(z) ?  1 : -x->sign;
        }
     return z;
}
T AP_sub(T x, T y) {
    T z;
    assert(x);
    assert(y);
     if (!((x->sign^y->sign) ==  0)) {
        z = add(mk(maxdigits(x,y) +  1), x, y);
        z->sign = iszero(z) ?  1 : x->sign;
    }  else
         if (cmp(x, y) >  0) {
            z = sub(mk(x->ndigits), x, y);
            z->sign = iszero(z) ?  1 : x->sign;
        }  else {
            z = sub(mk(y->ndigits), y, x);
            z->sign = iszero(z) ?  1 : -x->sign;
        }
     return z;
}
T AP_div(T x, T y) {
    T q, r;
    assert(x);
    assert(y);
    assert(!iszero(y));
    q = mk(x->ndigits);
    r = mk(y->ndigits);
    {
        XP_T tmp = ALLOC(x->ndigits + y->ndigits +  2);
        XP_div(x->ndigits, q->digits, x->digits,
            y->ndigits, y->digits, r->digits, tmp);
        FREE(tmp);
    }
    normalize(q, q->size);
    normalize(r, r->size);
    q->sign = iszero(q)
        || ((x->sign^y->sign) ==  0) ?  1 : - 1;
     if (!((x->sign^y->sign) ==  0) && !iszero(r)) {
         int carry = XP_sum(q->size, q->digits,
            q->digits,  1);
        assert(carry ==  0);
        normalize(q, q->size);
    }
    AP_free(&r);
     return q;
}
T AP_mod(T x, T y) {
    T q, r;
    assert(x);
    assert(y);
    assert(!iszero(y));
    q = mk(x->ndigits);
    r = mk(y->ndigits);
    {
        XP_T tmp = ALLOC(x->ndigits + y->ndigits +  2);
        XP_div(x->ndigits, q->digits, x->digits,
            y->ndigits, y->digits, r->digits, tmp);
        FREE(tmp);
    }
    normalize(q, q->size);
    normalize(r, r->size);
    q->sign = iszero(q)
        || ((x->sign^y->sign) ==  0) ?  1 : - 1;
     if (!((x->sign^y->sign) ==  0) && !iszero(r)) {
         int borrow = XP_sub(r->size, r->digits,
            y->digits, r->digits,  0);
        assert(borrow ==  0);
        normalize(r, r->size);
    }
    AP_free(&q);
     return r;
}
T AP_pow(T x, T y, T p) {
    T z;
    assert(x);
    assert(y);
    assert(y->sign ==  1);
    assert(!p || p->sign== 1 && !iszero(p) && !isone(p));
     if (iszero(x))
         return AP_new( 0);
     if (iszero(y))
         return AP_new( 1);
     if (isone(x))
         return AP_new((((y)->digits[ 0]& 1) ==  0) ?  1 : x->sign);
     if (p)
         if (isone(y))
            z = AP_mod(x, p);
         else {
            T y2 = AP_rshift(y,  1), t = AP_pow(x, y2, p);
            z = mulmod(t, t, p);
            AP_free(&y2);
            AP_free(&t);
             if (!(((y)->digits[ 0]& 1) ==  0)) {
                z = mulmod(y2 = AP_mod(x, p), t = z, p);
                AP_free(&y2);
                AP_free(&t);
            }
        }
     else
         if (isone(y))
            z = AP_addi(x,  0);
         else {
            T y2 = AP_rshift(y,  1), t = AP_pow(x, y2, NULL);
            z = AP_mul(t, t);
            AP_free(&y2);
            AP_free(&t);
             if (!(((y)->digits[ 0]& 1) ==  0)) {
                z = AP_mul(x, t = z);
                AP_free(&t);
            }
        }
     return z;
}
int AP_cmp(T x, T y) {
    assert(x);
    assert(y);
     if (!((x->sign^y->sign) ==  0))
         return x->sign;
     else  if (x->sign ==  1)
         return cmp(x, y);
     else
         return cmp(y, x);
}
T AP_addi(T x,  long  int y) {
    unsigned  char d[ sizeof (unsigned  long)];
     struct T t;
    t.size =  sizeof d;
    t.digits = d;
     return AP_add(x,  set(&t, y));
}
T AP_subi(T x,  long  int y) {
    unsigned  char d[ sizeof (unsigned  long)];
     struct T t;
    t.size =  sizeof d;
    t.digits = d;
     return AP_sub(x,  set(&t, y));
}
T AP_muli(T x,  long  int y) {
    unsigned  char d[ sizeof (unsigned  long)];
     struct T t;
    t.size =  sizeof d;
    t.digits = d;
     return AP_mul(x,  set(&t, y));
}
T AP_divi(T x,  long  int y) {
    unsigned  char d[ sizeof (unsigned  long)];
     struct T t;
    t.size =  sizeof d;
    t.digits = d;
     return AP_div(x,  set(&t, y));
}
int AP_cmpi(T x,  long  int y) {
    unsigned  char d[ sizeof (unsigned  long)];
     struct T t;
    t.size =  sizeof d;
    t.digits = d;
     return AP_cmp(x,  set(&t, y));
}
long  int AP_modi(T x,  long  int y) {
     long  int rem;
    T r;
    unsigned  char d[ sizeof (unsigned  long)];
     struct T t;
    t.size =  sizeof d;
    t.digits = d;
    r = AP_mod(x,  set(&t, y));
    rem = XP_toint(r->ndigits, r->digits);
    AP_free(&r);
     return rem;
}
T AP_lshift(T x,  int s) {
    T z;
    assert(x);
    assert(s >=  0);
    z = mk(x->ndigits + ((s+ 7)&~ 7)/ 8);
    XP_lshift(z->size, z->digits, x->ndigits,
        x->digits, s,  0);
    z->sign = x->sign;
     return normalize(z, z->size);
}
T AP_rshift(T x,  int s) {
    assert(x);
    assert(s >=  0);
     if (s >=  8*x->ndigits)
         return AP_new( 0);
     else {
        T z = mk(x->ndigits - s/ 8);
        XP_rshift(z->size, z->digits, x->ndigits,
            x->digits, s,  0);
        normalize(z, z->size);
        z->sign = iszero(z) ?  1 : x->sign;
         return z;
    }
}
long  int AP_toint(T x) {
    unsigned  long u;
    assert(x);
    u = XP_toint(x->ndigits, x->digits)%(LONG_MAX +  1UL);
     if (x->sign == - 1)
         return -( long)u;
     else
         return  ( long)u;
}
T AP_fromstr( const  char *str,  int  base,  char **end) {
    T z;
     const  char *p = str;
     char *endp, sign =  ' \0 ';
     int carry;
    assert(p);
    assert( base >=  2 &&  base <=  36);
     while (*p && isspace(*p))
        p++;
     if (*p ==  ' - ' || *p ==  ' + ')
        sign = *p++;
    {
         const  char *start;
         int k, n =  0;
         for ( ; *p ==  ' 0 ' && p[ 1] ==  ' 0 '; p++)
            ;
        start = p;
         for ( ; (   ' 0 ' <= *p && *p <=  ' 9 ' && *p <  ' 0 ' +  base
            ||  ' a ' <= *p && *p <=  ' z ' && *p <  ' a ' +  base -  10
            ||  ' A ' <= *p && *p <=  ' Z ' && *p <  ' A ' +  base -  10); p++)
            n++;
         for (k =  1; ( 1<<k) <  base; k++)
            ;
        z = mk(((k*n +  7)&~ 7)/ 8);
        p = start;
    }
    carry = XP_fromstr(z->size, z->digits, p,
         base, &endp);
    assert(carry ==  0);
    normalize(z, z->size);
     if (endp == p) {
        endp = ( char *)str;
        z = AP_new( 0);
    }  else
        z->sign = iszero(z) || sign !=  ' - ' ?  1 : - 1;
     if (end)
        *end = ( char *)endp;
     return z;
}
char *AP_tostr( char *str,  int size,  int  base, T x) {
    XP_T q;
    assert(x);
    assert( base >=  2 &&  base <=  36);
    assert(str == NULL || size >  1);
     if (str == NULL) {
        {
             int k;
             for (k =  5; ( 1<<k) >  base; k--)
                ;
            size = ( 8*x->ndigits)/k +  1 +  1;
             if (x->sign ==  1)
                size++;
        }
        str = ALLOC(size);
    }
    q = ALLOC(x->ndigits);
    memcpy(q, x->digits, x->ndigits);
     if (x->sign == - 1) {
        str[ 0] =  ' - ';
        XP_tostr(str +  1, size -  1,  base, x->ndigits, q);
    }  else
        XP_tostr(str, size,  base, x->ndigits, q);
    FREE(q);
     return str;
}
void AP_fmt( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision) {
    T x;
     char *buf;
    assert(app && flags);
    x = va_arg(*app, T);
    assert(x);
    buf = AP_tostr(NULL,  0,  10, x);
    Fmt_putd(buf, strlen(buf), put, cl, flags,
        width, precision);
    FREE(buf);
}

 

calc.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/ap.doc,v 1.11 1996/06/26 23:02:01 drh Exp $ ";
#include <ctype.h>
#include <stdio.h>
#include < string.h>
#include <stdlib.h>
#include  " stack.h "
#include  " ap.h "
#include  " fmt.h "
Stack_T sp;
AP_T pop( void) {
     if (!Stack_empty(sp))
         return Stack_pop(sp);
     else {
        Fmt_fprint(stderr,  " ?stack underflow\n ");
         return AP_new( 0);
    }
}
int main( int argc,  char *argv[]) {
     int c;
    sp = Stack_new();
    Fmt_register( ' D ', AP_fmt);
     while ((c = getchar()) != EOF)
         switch (c) {
         case  '   ':  case  ' \t ':  case  ' \n ':  case  ' \f ':  case  ' \r ':
             break;
         case  ' 0 ':  case  ' 1 ':  case  ' 2 ':  case  ' 3 ':  case  ' 4 ':
         case  ' 5 ':  case  ' 6 ':  case  ' 7 ':  case  ' 8 ':  case  ' 9 ': {
             char buf[ 512];
            {
                 int i =  0;
                 for ( ; c != EOF && isdigit(c); c = getchar(), i++)
                     if (i < ( int) sizeof (buf) -  1)
                        buf[i] = c;
                 if (i > ( int) sizeof (buf) -  1) {
                    i = ( int) sizeof (buf) -  1;
                    Fmt_fprint(stderr,
                         " ?integer constant exceeds %d digits\n ", i);
                }
                buf[i] =  0;
                 if (c != EOF)
                    ungetc(c, stdin);
            }
            Stack_push(sp, AP_fromstr(buf,  10, NULL));
             break;
        }
         case  ' + ': {
            AP_T y = pop(), x = pop();
            Stack_push(sp, AP_add(x, y));
            AP_free(&x);
            AP_free(&y);
             break;
        }
         case  ' - ': {
            AP_T y = pop(), x = pop();
            Stack_push(sp, AP_sub(x, y));
            AP_free(&x);
            AP_free(&y);
             break;
        }
         case  ' * ': {
            AP_T y = pop(), x = pop();
            Stack_push(sp, AP_mul(x, y));
            AP_free(&x);
            AP_free(&y);
             break;
        }
         case  ' / ': {
            AP_T y = pop(), x = pop();
             if (AP_cmpi(y,  0) ==  0) {
                Fmt_fprint(stderr,  " ?/ by 0\n ");
                Stack_push(sp, AP_new( 0));
            }  else
                Stack_push(sp, AP_div(x, y));
            AP_free(&x);
            AP_free(&y);
             break;
        }
         case  ' % ': {
            AP_T y = pop(), x = pop();
             if (AP_cmpi(y,  0) ==  0) {
                Fmt_fprint(stderr,  " ?%% by 0\n ");
                Stack_push(sp, AP_new( 0));
            }  else
                Stack_push(sp, AP_mod(x, y));
            AP_free(&x);
            AP_free(&y);
             break;
        }
         case  ' ^ ': {
            AP_T y = pop(), x = pop();
             if (AP_cmpi(y,  0) <=  0) {
                Fmt_fprint(stderr,  " ?nonpositive power\n ");
                Stack_push(sp, AP_new( 0));
            }  else
                Stack_push(sp, AP_pow(x, y, NULL));
            AP_free(&x);
            AP_free(&y);
             break;
        }
         case  ' d ': {
            AP_T x = pop();
            Stack_push(sp, x);
            Stack_push(sp, AP_addi(x,  0));
             break;
        }
         case  ' p ': {
            AP_T x = pop();
            Fmt_print( " %D\n ", x);
            Stack_push(sp, x);
             break;
        }
         case  ' f ':
             if (!Stack_empty(sp)) {
                Stack_T tmp = Stack_new();
                 while (!Stack_empty(sp)) {
                    AP_T x = pop();
                    Fmt_print( " %D\n ", x);
                    Stack_push(tmp, x);
                }
                 while (!Stack_empty(tmp))
                    Stack_push(sp, Stack_pop(tmp));
                Stack_free(&tmp);
            }
             break;
         case  ' ~ ': {
            AP_T x = pop();
            Stack_push(sp, AP_neg(x));
            AP_free(&x);
             break;
        }
         case  ' c ':  while (!Stack_empty(sp)) {
                  AP_T x = Stack_pop(sp);
                  AP_free(&x);
              }  break;
         case  ' q ':  while (!Stack_empty(sp)) {
                  AP_T x = Stack_pop(sp);
                  AP_free(&x);
              }
              Stack_free(&sp);
               return EXIT_SUCCESS;
         default:
             if (isprint(c))
                Fmt_fprint(stderr,  " ?'%c' ", c);
             else
                Fmt_fprint(stderr,  " ?'\\%03o' ", c);
            Fmt_fprint(stderr,  "  is unimplemented\n ");
             break;
        }
     while (!Stack_empty(sp)) {
        AP_T x = Stack_pop(sp);
        AP_free(&x);
    }
    Stack_free(&sp);
     return EXIT_SUCCESS;
}

 

mp.h

/*  $Id: H:/drh/idioms/book/RCS/mp.doc,v 1.11 1996/06/26 23:02:01 drh Exp $  */
#ifndef MP_INCLUDED
#define MP_INCLUDED
#include <stdarg.h>
#include <stddef.h>
#include  " except.h "
#define T MP_T
typedef unsigned  char *T;
extern  const Except_T MP_Overflow;
extern  const Except_T MP_Dividebyzero;
extern  int MP_set( int n);
extern T MP_new(unsigned  long u);
extern T MP_fromint (T z,  long v);
extern T MP_fromintu(T z, unsigned  long u);
extern unsigned  long MP_tointu(T x);
extern           long MP_toint (T x);
extern T MP_cvt ( int m, T z, T x);
extern T MP_cvtu( int m, T z, T x);
extern T MP_add (T z, T x, T y);
extern T MP_sub (T z, T x, T y);
extern T MP_mul (T z, T x, T y);
extern T MP_div (T z, T x, T y);
extern T MP_mod (T z, T x, T y);
extern T MP_neg (T z, T x);
extern T MP_addu(T z, T x, T y);
extern T MP_subu(T z, T x, T y);
extern T MP_mulu(T z, T x, T y);
extern T MP_divu(T z, T x, T y);
extern T MP_modu(T z, T x, T y);
extern T MP_mul2u(T z, T x, T y);
extern T MP_mul2 (T z, T x, T y);
extern T MP_addi (T z, T x,  long y);
extern T MP_subi (T z, T x,  long y);
extern T MP_muli (T z, T x,  long y);
extern T MP_divi (T z, T x,  long y);
extern T MP_addui(T z, T x, unsigned  long y);
extern T MP_subui(T z, T x, unsigned  long y);
extern T MP_mului(T z, T x, unsigned  long y);
extern T MP_divui(T z, T x, unsigned  long y);
extern           long MP_modi (T x,           long y);
extern unsigned  long MP_modui(T x, unsigned  long y);
extern  int MP_cmp  (T x, T y);
extern  int MP_cmpi (T x,  long y);
extern  int MP_cmpu (T x, T y);
extern  int MP_cmpui(T x, unsigned  long y);
extern T MP_and (T z, T x, T y);
extern T MP_or  (T z, T x, T y);
extern T MP_xor (T z, T x, T y);
extern T MP_not (T z, T x);
extern T MP_andi(T z, T x, unsigned  long y);
extern T MP_ori (T z, T x, unsigned  long y);
extern T MP_xori(T z, T x, unsigned  long y);
extern T MP_lshift(T z, T x,  int s);
extern T MP_rshift(T z, T x,  int s);
extern T MP_ashift(T z, T x,  int s);
extern T     MP_fromstr(T z,  const  char *str,
     int  base,  char **end);
extern  char *MP_tostr  ( char *str,  int size,
     int  base, T x);
extern  void  MP_fmt    ( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision);
extern  void  MP_fmtu   ( int code, va_list *app,
     int put( int c,  void *cl),  void *cl,
    unsigned  char flags[],  int width,  int precision);
#undef T
#endif

mpcalc.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/mp.doc,v 1.11 1996/06/26 23:02:01 drh Exp $ ";
#include <ctype.h>
#include <stdio.h>
#include < string.h>
#include <stdlib.h>
#include <limits.h>
#include  " mem.h "
#include  " seq.h "
#include  " fmt.h "
#include  " mp.h "
Seq_T sp;
int ibase =  10;
int obase =  10;
struct {
     char *fmt;
    MP_T (*add)(MP_T, MP_T, MP_T);
    MP_T (*sub)(MP_T, MP_T, MP_T);
    MP_T (*mul)(MP_T, MP_T, MP_T);
    MP_T (*div)(MP_T, MP_T, MP_T);
    MP_T (*mod)(MP_T, MP_T, MP_T);
} s = {  " %D\n ",
    MP_add,  MP_sub,  MP_mul,  MP_div,  MP_mod  },
  u = {  " %U\n ",
    MP_addu, MP_subu, MP_mulu, MP_divu, MP_modu },
 *f = &s;
MP_T pop( void) {
     if (Seq_length(sp) >  0)
         return Seq_remhi(sp);
     else {
        Fmt_fprint(stderr,  " ?stack underflow\n ");
         return MP_new( 0);
    }
}
int main( int argc,  char *argv[]) {
     int c;
    sp = Seq_new( 0);
    Fmt_register( ' D ', MP_fmt);
    Fmt_register( ' U ', MP_fmtu);
     while ((c = getchar()) != EOF) {
        MP_T x = NULL, y = NULL, z = NULL;
        TRY
              switch (c) {
             default:
                 if (isprint(c))
                    Fmt_fprint(stderr,  " ?'%c' ", c);
                 else
                    Fmt_fprint(stderr,  " ?'\\%03o' ", c);
                Fmt_fprint(stderr,  "  is unimplemented\n ");
                 break;
             case  '   ':  case  ' \t ':  case  ' \n ':  case  ' \f ':  case  ' \r ':
                 break;
             case  ' c ':  while (Seq_length(sp) >  0) {
                      MP_T x = Seq_remhi(sp);
                      FREE(x);
                  }  break;
             case  ' q ':  while (Seq_length(sp) >  0) {
                      MP_T x = Seq_remhi(sp);
                      FREE(x);
                  }
                  Seq_free(&sp);
                   return EXIT_SUCCESS;
             case  ' 0 ':  case  ' 1 ':  case  ' 2 ':  case  ' 3 ':  case  ' 4 ':
             case  ' 5 ':  case  ' 6 ':  case  ' 7 ':  case  ' 8 ':  case  ' 9 ': {
                 char buf[ 512];
                z = MP_new( 0);
                {
                     int i =  0;
                     for ( ;  strchr(& " zyxwvutsrqponmlkjihgfedcba9876543210 "[ 36-ibase],
                            tolower(c)); c = getchar(), i++)
                         if (i < ( int) sizeof (buf) -  1)
                            buf[i] = c;
                     if (i > ( int) sizeof (buf) -  1) {
                        i = ( int) sizeof (buf) -  1;
                        Fmt_fprint(stderr,
                             " ?integer constant exceeds %d digits\n ", i);
                    }
                    buf[i] =  ' \0 ';
                     if (c != EOF)
                        ungetc(c, stdin);
                }
                MP_fromstr(z, buf, ibase, NULL);
                 break;
            }
             case  ' + ': y = pop(); x = pop();
                  z = MP_new( 0); (*f->add)(z, x, y);  break;
             case  ' - ': y = pop(); x = pop();
                  z = MP_new( 0); (*f->sub)(z, x, y);  break;
             case  ' * ': y = pop(); x = pop();
                  z = MP_new( 0); (*f->mul)(z, x, y);  break;
             case  ' / ': y = pop(); x = pop();
                  z = MP_new( 0); (*f->div)(z, x, y);  break;
             case  ' % ': y = pop(); x = pop();
                  z = MP_new( 0); (*f->mod)(z, x, y);  break;
             case  ' & ': y = pop(); x = pop();
                  z = MP_new( 0);    MP_and(z, x, y);  break;
             case  ' | ': y = pop(); x = pop();
                  z = MP_new( 0);    MP_or (z, x, y);  break;
             case  ' ^ ': y = pop(); x = pop();
                  z = MP_new( 0);    MP_xor(z, x, y);  break;
             case  ' ! ': z = pop(); MP_not(z, z);  break;
             case  ' ~ ': z = pop(); MP_neg(z, z);  break;
             case  ' i ':  case  ' o ': {
                 long n;
                x = pop();
                n = MP_toint(x);
                 if (n <  2 || n >  36)
                    Fmt_fprint(stderr,  " ?%d is an illegal base\n ",n);
                 else  if (c ==  ' i ')
                    ibase = n;
                 else
                    obase = n;
                 if (obase ==  2 || obase ==  8 || obase ==  16)
                    f = &u;
                 else
                    f = &s;
                 break;
                }
             case  ' p ':
                Fmt_print(f->fmt, z = pop(), obase);
                 break;
             case  ' f ': {
                 int n = Seq_length(sp);
                 while (--n >  0)
                    Fmt_print(f->fmt, Seq_get(sp, n), obase);
                 break;
            }
             case  ' < ': {  long s;
                    y = pop();
                    z = pop();
                    s = MP_toint(y);
                     if (s <  0 || s > INT_MAX) {
                        Fmt_fprint(stderr,
                             " ?%d is an illegal shift amount\n ", s);
                         break;
                    }; MP_lshift(z, z, s);  break; }
             case  ' > ': {  long s;
                    y = pop();
                    z = pop();
                    s = MP_toint(y);
                     if (s <  0 || s > INT_MAX) {
                        Fmt_fprint(stderr,
                             " ?%d is an illegal shift amount\n ", s);
                         break;
                    }; MP_rshift(z, z, s);  break; }
             case  ' k ': {
                 long n;
                x = pop();
                n = MP_toint(x);
                 if (n <  2 || n > INT_MAX)
                    Fmt_fprint(stderr,
                         " ?%d is an illegal precision\n ", n);
                 else  if (Seq_length(sp) >  0)
                    Fmt_fprint(stderr,  " ?nonempty stack\n ");
                 else
                    MP_set(n);
                 break;
                }
             case  ' d ': {
                MP_T x = pop();
                z = MP_new( 0);
                Seq_addhi(sp, x);
                MP_addui(z, x,  0);
                 break;
                }
            }
        EXCEPT(MP_Overflow)
            Fmt_fprint(stderr,  " ?overflow\n ");
        EXCEPT(MP_Dividebyzero)
            Fmt_fprint(stderr,  " ?divide by 0\n ");
        END_TRY;
         if (z)
            Seq_addhi(sp, z);
        FREE(x);
        FREE(y);
    }
     while (Seq_length(sp) >  0) {
        MP_T x = Seq_remhi(sp);
        FREE(x);
    }
    Seq_free(&sp);
     return EXIT_SUCCESS;
}

 

thread.h

/*  $Id: H:/drh/idioms/book/RCS/thread.doc,v 1.11 1997/02/21 19:50:51 drh Exp $  */
#ifndef THREAD_INCLUDED
#define THREAD_INCLUDED
#include  " except.h "
#define T Thread_T
typedef  struct T *T;
extern  const Except_T Thread_Failed;
extern  const Except_T Thread_Alerted;
extern  int  Thread_init ( int preempt, ...);
extern T    Thread_new  ( int apply( void *),
                 void *args,  int nbytes, ...);
extern  void Thread_exit ( int code);
extern  void Thread_alert(T t);
extern T    Thread_self ( void);
extern  int  Thread_join (T t);
extern  void Thread_pause( void);
#undef T
#endif

 

sem.h

/*  $Id: H:/drh/idioms/book/RCS/thread.doc,v 1.11 1997/02/21 19:50:51 drh Exp $  */
#ifndef SEM_INCLUDED
#define SEM_INCLUDED
#define T Sem_T
typedef  struct T {
     int count;
     void *queue;
} T;
#define LOCK(mutex) do { Sem_T *_yymutex = &(mutex); \
    Sem_wait(_yymutex);
#define END_LOCK Sem_signal(_yymutex); } while (0)
extern  void Sem_init  (T *s,  int count);
extern T   *Sem_new   ( int count);
extern  void Sem_wait  (T *s);
extern  void Sem_signal(T *s);
#undef T
#endif

 

thread.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/thread.doc,v 1.11 1997/02/21 19:50:51 drh Exp $ ";
#include <stdio.h>
#include <stdlib.h>
#include < string.h>
#include </usr/include/signal.h>
#include <sys/time.h>
#include  " assert.h "
#include  " mem.h "
#include  " thread.h "
#include  " sem.h "
void _MONITOR( void) {}
extern  void _ENDMONITOR( void);
#define T Thread_T
#define isempty(q) ((q) == NULL)
struct T {
    unsigned  long *sp;                         /*  must be first  */
    T link;
    T *inqueue;
    T handle;
    Except_Frame *estack;
     int code;
    T join;
    T next;
     int alerted;
};
static T ready = NULL;
static T current;
static  int nthreads;
static  struct Thread_T root;
static T join0;
static T freelist;
const Except_T Thread_Alerted = {  " Thread alerted " };
const Except_T Thread_Failed =
    {  " Thread creation failed " };
static  int critical;
extern  void _swtch(T  from, T to);
static  void put(T t, T *q) {
    assert(t);
    assert(t->inqueue == NULL && t->link == NULL);
     if (*q) {
        t->link = (*q)->link;
        (*q)->link = t;
    }  else
        t->link = t;
    *q = t;
    t->inqueue = q;
}
static T  get(T *q) {
    T t;
    assert(!isempty(*q));
    t = (*q)->link;
     if (t == *q)
        *q = NULL;
     else
        (*q)->link = t->link;
    assert(t->inqueue == q);
    t->link = NULL;
    t->inqueue = NULL;
     return t;
}
static  void delete(T t, T *q) {
    T p;
    assert(t->link && t->inqueue == q);
    assert(!isempty(*q));
     for (p = *q; p->link != t; p = p->link)
        ;
     if (p == t)
        *q = NULL;
     else {
        p->link = t->link;
         if (*q == t)
            *q = p;
    }
    t->link = NULL;
    t->inqueue = NULL;
}
static  void run( void) {
    T t = current;
    current =  get(&ready);
    t->estack = Except_stack;
    Except_stack = current->estack;
    _swtch(t, current);
}
static  void testalert( void) {
     if (current->alerted) {
        current->alerted =  0;
        RAISE(Thread_Alerted);
    }
}
static  void release( void) {
    T t;
     do { critical++;
     while ((t = freelist) != NULL) {
        freelist = t->next;
        FREE(t);
    }
    critical--; }  while ( 0);
}
#if linux
#include <asm/sigcontext.h>
static  int interrupt( int sig,  struct sigcontext_struct sc) {
     if (critical ||
       sc.eip >= (unsigned  long)_MONITOR
    && sc.eip <= (unsigned  long)_ENDMONITOR)
         return  0;
    put(current, &ready);
     do { critical++;
    sigsetmask(sc.oldmask);
    critical--; }  while ( 0);
    run();
     return  0;
}
#else
static  int interrupt( int sig,  int code,
     struct sigcontext *scp) {
     if (critical ||
       scp->sc_pc >= (unsigned  long)_MONITOR
    && scp->sc_pc <= (unsigned  long)_ENDMONITOR)
         return  0;
    put(current, &ready);
    sigsetmask(scp->sc_mask);
    run();
     return  0;
}
#endif
int Thread_init( int preempt, ...) {
    assert(preempt ==  0 || preempt ==  1);
    assert(current == NULL);
    root.handle = &root;
    current = &root;
    nthreads =  1;
     if (preempt) {
        {
             struct sigaction sa;
            memset(&sa,  ' \0 ',  sizeof sa);
            sa.sa_handler = ( void (*)())interrupt;
             if (sigaction(SIGVTALRM, &sa, NULL) <  0)
                 return  0;
        }
        {
             struct itimerval it;
            it.it_value.tv_sec     =   0;
            it.it_value.tv_usec    =  50;
            it.it_interval.tv_sec  =   0;
            it.it_interval.tv_usec =  50;
             if (setitimer(ITIMER_VIRTUAL, &it, NULL) <  0)
                 return  0;
        }
    }
     return  1;
}
T Thread_self( void) {
    assert(current);
     return current;
}
void Thread_pause( void) {
    assert(current);
    put(current, &ready);
    run();
}
int Thread_join(T t) {
    assert(current && t != current);
    testalert();
     if (t) {
         if (t->handle == t) {
            put(current, &t->join);
            run();
            testalert();
             return current->code;
        }  else
             return - 1;
    }  else {
        assert(isempty(join0));
         if (nthreads >  1) {
            put(current, &join0);
            run();
            testalert();
        }
         return  0;
    }
}
void Thread_exit( int code) {
    assert(current);
    release();
     if (current != &root) {
        current->next = freelist;
        freelist = current;
    }
    current->handle = NULL;
     while (!isempty(current->join)) {
        T t =  get(&current->join);
        t->code = code;
        put(t, &ready);
    }
     if (!isempty(join0) && nthreads ==  2) {
        assert(isempty(ready));
        put( get(&join0), &ready);
    }
     if (--nthreads ==  0)
        exit(code);
     else
        run();
}
void Thread_alert(T t) {
    assert(current);
    assert(t && t->handle == t);
    t->alerted =  1;
     if (t->inqueue) {
        delete(t, t->inqueue);
        put(t, &ready);
    }
}
T Thread_new( int apply( void *),  void *args,
     int nbytes, ...) {
     T t;
    assert(current);
    assert(apply);
    assert(args && nbytes >=  0 || args == NULL);
     if (args == NULL)
        nbytes =  0;
    {
         int stacksize = ( 16* 1024+ sizeof (*t)+nbytes+ 15)&~ 15;
        release();
         do { critical++;
        TRY
            t = ALLOC(stacksize);
            memset(t,  ' \0 ',  sizeof *t);
        EXCEPT(Mem_Failed)
            t = NULL;
        END_TRY;
        critical--; }  while ( 0);
         if (t == NULL)
            RAISE(Thread_Failed);
        t->sp = ( void *)(( char *)t + stacksize);
         while (((unsigned  long)t->sp)& 15)
            t->sp--;
    }
    t->handle = t;
     if (nbytes >  0) {
        t->sp -= ((nbytes +  15U)&~ 15)/ sizeof (*t->sp);
         do { critical++;
        memcpy(t->sp, args, nbytes);
        critical--; }  while ( 0);
        args = t->sp;
    }
#if alpha
    {  extern  void _start( void);
      t->sp -=  112/ 8;
      t->sp[( 48+ 24)/ 8] = (unsigned  long)Thread_exit;
      t->sp[( 48+ 16)/ 8] = (unsigned  long)args;
      t->sp[( 48+  8)/ 8] = (unsigned  long)apply;
      t->sp[( 48+  0)/ 8] = (unsigned  long)_start; }
#elif mips
    {  extern  void _start( void);
      t->sp -=  16/ 4;
      t->sp -=  88/ 4;
      t->sp[( 48+ 20)/ 4] = (unsigned  long)Thread_exit;
      t->sp[( 48+ 28)/ 4] = (unsigned  long)args;
      t->sp[( 48+ 32)/ 4] = (unsigned  long)apply;
      t->sp[( 48+ 36)/ 4] = (unsigned  long)_start; }
#elif sparc
    {      int i;  void *fp;  extern  void _start( void);
           for (i =  0; i <  8; i++)
              *--t->sp =  0;
          *--t->sp = (unsigned  long)args;
          *--t->sp = (unsigned  long)apply;
          t->sp -=  64/ 4;
          fp = t->sp;
          *--t->sp = (unsigned  long)_start -  8;
          *--t->sp = (unsigned  long)fp;
          t->sp -=  64/ 4; }
#elif linux && i386
    {  extern  void _thrstart( void);
      t->sp -=  4/ 4;
      *t->sp = (unsigned  long)_thrstart;
      t->sp -=  16/ 4;
      t->sp[ 4/ 4]  = (unsigned  long)apply;
      t->sp[ 8/ 4]  = (unsigned  long)args;
      t->sp[ 12/ 4] = (unsigned  long)t->sp + ( 4+ 16)/ 4; }
#else
    Unsupported platform
#endif
    nthreads++;
    put(t, &ready);
     return t;
}
#undef T
#define T Sem_T
T *Sem_new( int count) {
    T *s;
    NEW(s);
    Sem_init(s, count);
     return s;
}
void Sem_init(T *s,  int count) {
    assert(current);
    assert(s);
    s->count = count;
    s->queue = NULL;
}
void Sem_wait(T *s) {
    assert(current);
    assert(s);
    testalert();
     if (s->count <=  0) {
        put(current, (Thread_T *)&s->queue);
        run();
        testalert();
    }  else
        --s->count;
}
void Sem_signal(T *s) {
    assert(current);
    assert(s);
     if (s->count ==  0 && !isempty(s->queue)) {
        Thread_T t =  get((Thread_T *)&s->queue);
        assert(!t->alerted);
        put(t, &ready);
    }  else
        ++s->count;
}
#undef T

 

thread-nt.c

#include <stdio.h>
#include <stdlib.h>
#include < string.h>
#include <limits.h>
#include <windows.h>
#include <process.h>
#include  " assert.h "
#include  " mem.h "
#include  " thread.h "
#include  " sem.h "

static  char rcsid[] =  " $Id: thread-nt.c,v 1.5 1997/07/29 17:10:25 drh Exp $ ";

#define T Thread_T
struct T {
    DWORD IDThread;         /*  Win 32 thread identifier  */
    T handle;         /*  self pointer  */
     int code;         /*  exit code  */
    HANDLE join;         /*  join semaphore  */
    T joinlist;         /*  threads waiting on join  */
    T link;             /*  next thread on this join list  */
    T next;             /*  next thread on this hash chain  */
     int alerted;         /*  1 if this thread has been alerted  */
     int (*apply)( void *);     /*  initial function for this thread  */
     void *args;         /*  argument for apply  */
};

const Except_T Thread_Alerted = {  " Thread alerted " };
const Except_T Thread_Failed  = {  " Thread creation failed " };

static T allthreads[ 317];
#define HASH(id) ((int)((id)%(sizeof allthreads/sizeof allthreads[0])))
static  int nthreads;         /*  number of threads in allthreads  */
static T root;
static HANDLE join0;         /*  Thread_join(NULL) semaphore  */
static  int join0count;         /*  number of threads waiting on join0; always 0 or 1  */

static  int critical;
static CRITICAL_SECTION csection;
#define ENTERCRITICAL EnterCriticalSection(&csection); assert(critical == 0); critical++
#define LEAVECRITICAL   critical--; assert(critical == 0); LeaveCriticalSection(&csection)

static T getThreadByID(DWORD id) {
    T t;

    ENTERCRITICAL;
     for (t = allthreads[HASH(id)]; t != NULL; t = t->next)
         if (t->IDThread == id)
             break;
    LEAVECRITICAL;
    assert(t);
     return t;
}

static  void removeThread(T t) {
    T *q;

    ENTERCRITICAL;
    q = &allthreads[HASH(t->IDThread)];
     for ( ; *q != NULL && *q != t; q = &(*q)->next)
        ;
    assert(*q == t);
    *q = t->next;
    nthreads--;
    t->handle = NULL;
    LEAVECRITICAL;
}

static  void addThread(T t) {
    T *q;

    ENTERCRITICAL;
    q = &allthreads[HASH(t->IDThread)];
    t->next = *q;
    *q = t;
    nthreads++;
    t->handle = t;
    LEAVECRITICAL;
}

static  void testalert(T t) {
    ENTERCRITICAL;
     if (t->alerted) {
        t->alerted =  0;
        LEAVECRITICAL;
        RAISE(Thread_Alerted);
    }
    LEAVECRITICAL;
}

int Thread_init( int preempt, ...) {
    assert(preempt ==  0 || preempt ==  1);
    assert(root == NULL);
    TRY
        NEW0(root);
    EXCEPT(Mem_Failed)
         return - 1;
    END_TRY;
    join0 = CreateSemaphore(NULL,  0,  1, NULL);
     if (join0 == NULL)
         return - 1;
    root->join = CreateSemaphore(NULL,  0, INT_MAX, NULL);
     if (root->join == NULL) {
        BOOL result = CloseHandle(join0);
        assert(result == TRUE);
         return - 1;
    }
    InitializeCriticalSection(&csection);
    root->IDThread = GetCurrentThreadId();
    addThread(root);
     /*  handle preempt == 0  */
     return  1;
}

T Thread_self( void) {
    assert(root);
     return getThreadByID(GetCurrentThreadId());
}

void Thread_pause( void) {
    assert(root);
    Sleep( 0);
}

int Thread_join(T t) {
    T current = Thread_self();

    assert(root);
    assert(t != current);
    testalert(current);
     if (t != NULL) {
        ENTERCRITICAL;
         if (t->handle == t) {
            HANDLE join = t->join;
            DWORD result;
            assert(current->link == NULL);
            current->link = t->joinlist;
            t->joinlist = current;
            LEAVECRITICAL;
            result = WaitForSingleObject(join, INFINITE);
            assert(result != WAIT_FAILED);
            testalert(current);
             return current->code;
        }  else {
            LEAVECRITICAL;
             return - 1;
        }
    }
    ENTERCRITICAL;
     if (nthreads >  1) {
        DWORD result;
        assert(join0count ==  0);
        join0count++;
        LEAVECRITICAL;
        result = WaitForSingleObject(join0, INFINITE);
        assert(result != WAIT_FAILED);
        ENTERCRITICAL;
        join0count--;
        LEAVECRITICAL;
        testalert(current);
    }  else {
        assert(join0count ==  0);
        LEAVECRITICAL;
         return  0;
    }
}

void Thread_exit( int code) {
    BOOL result;
    T current = Thread_self();

    removeThread(current);
    ENTERCRITICAL;
     if (current->joinlist != NULL) {
        T t, n;
         int count =  0;
        assert(current->join);
         for (t = current->joinlist; t != NULL; t = n) {
            t->code = code;
            n = t->link;
            t->link = NULL;
            count++;
        }
        current->joinlist = NULL;
        result = ReleaseSemaphore(current->join, count, NULL);
        assert(result == TRUE);
    }
    result = CloseHandle(current->join);
    assert(result == TRUE);
    current->join = NULL;
     if (join0count >  0 && nthreads ==  1) {
        assert(join0count ==  1);
        result = ReleaseSemaphore(join0,  1, NULL);
        assert(result == TRUE);
    }
     if (nthreads ==  0) {
        result = CloseHandle(join0);
        assert(result == TRUE);
    }
    FREE(current);
    LEAVECRITICAL;
    _endthreadex(code);
}

void Thread_alert(T t) {
    assert(root);
    ENTERCRITICAL;
    assert(t && t->handle == t);
    t->alerted =  1;
    LEAVECRITICAL;
}

static unsigned __stdcall start( void *p) {
    T t = p;

    Except_stack = NULL;
    Thread_exit((*t->apply)(t->args));
     return  0;
}

T Thread_new( int apply( void *),  void *args,  int nbytes, ...) {
    T t;
    HANDLE hThread;

    assert(root);
    assert(apply);
    assert(args && nbytes >=  0 || args == NULL);
     if (args == NULL)
        nbytes =  0;
    TRY
        t = ALLOC(( sizeof (*t) + nbytes +  15)&~ 15);
        memset(t,  ' \0 ',  sizeof *t);
    EXCEPT(Mem_Failed)
        RAISE(Thread_Failed);
    END_TRY;
    t->join = CreateSemaphore(NULL,  0, INT_MAX, NULL);
     if (t->join == NULL) {
        FREE(t);
        RAISE(Thread_Failed);
    }
     if (nbytes >  0) {
        t->args = t +  1;
        memcpy(t->args, args, nbytes);
    }  else
        t->args = args;
    t->apply = apply;
    hThread = (HANDLE)_beginthreadex(
        NULL,         /*  default security attributes  */
         0,         /*  default stack size  */
        start,         /*  initial function  */
        t,         /*  start's argument  */
         0,         /*  default thread creation flags  */
        &t->IDThread     /*  where to store the thread id  */
        );
     if (hThread == NULL) {
        CloseHandle(t->join);
        FREE(t);
        RAISE(Thread_Failed);
    }
    CloseHandle(hThread);
    addThread(t);
     return t;
}
#undef T

#define T Sem_T
T *Sem_new( int count) {
    T *s;

    NEW(s);
    Sem_init(s, count);
     return s;
}

void Sem_init(T *s,  int count) {
    assert(root);
    assert(s);
    assert(count >=  0);
    s->count =  0;
    s->queue = CreateSemaphore(NULL, count, INT_MAX, NULL);
    assert(s->queue);
}

void Sem_wait(T *s) {
    DWORD result;
    Thread_T current = Thread_self();

    assert(s);
    testalert(current);
    result = WaitForSingleObject(s->queue, INFINITE);
    assert(result != WAIT_FAILED);
    ENTERCRITICAL;
     if (current->alerted) {
        BOOL result;
        current->alerted =  0;
        LEAVECRITICAL;
        result = ReleaseSemaphore(s->queue,  1, NULL);
        assert(result == TRUE);
        RAISE(Thread_Alerted);
    }
    LEAVECRITICAL;
}

void Sem_signal(T *s) {
    BOOL result;

    assert(root);
    assert(s);
    result = ReleaseSemaphore(s->queue,  1, NULL);
    assert(result == TRUE);
}
#undef T

 

 

chan.h

/*  $Id: H:/drh/idioms/book/RCS/thread.doc,v 1.11 1997/02/21 19:50:51 drh Exp $  */
#ifndef CHAN_INCLUDED
#define CHAN_INCLUDED
#define T Chan_T
typedef  struct T *T;
extern T   Chan_new    ( void);
extern  int Chan_send   (T c,  const  void *ptr,  int size);
extern  int Chan_receive(T c,        void *ptr,  int size);
#undef T
#endif

 

chain.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/thread.doc,v 1.11 1997/02/21 19:50:51 drh Exp $ ";
#include < string.h>
#include  " assert.h "
#include  " mem.h "
#include  " chan.h "
#include  " sem.h "
#define T Chan_T
struct T {
     const  void *ptr;
     int *size;
    Sem_T send, recv, sync;
};
T Chan_new( void) {
    T c;
    NEW(c);
    Sem_init(&c->send,  1);
    Sem_init(&c->recv,  0);
    Sem_init(&c->sync,  0);
     return c;
}
int Chan_send(Chan_T c,  const  void *ptr,  int size) {
    assert(c);
    assert(ptr);
    assert(size >=  0);
    Sem_wait(&c->send);
    c->ptr = ptr;
    c->size = &size;
    Sem_signal(&c->recv);
    Sem_wait(&c->sync);
     return size;
}
int Chan_receive(Chan_T c,  void *ptr,  int size) {
     int n;
    assert(c);
    assert(ptr);
    assert(size >=  0);
    Sem_wait(&c->recv);
    n = *c->size;
     if (size < n)
        n = size;
    *c->size = n;
     if (n >  0)
        memcpy(ptr, c->ptr, n);
    Sem_signal(&c->sync);
    Sem_signal(&c->send);
     return n;
}

 

sort.c

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/thread.doc,v 1.11 1997/02/21 19:50:51 drh Exp $ ";
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include  " assert.h "
#include  " fmt.h "
#include  " thread.h "
#include  " mem.h "
struct args {
     int *a;
     int lb, ub;
};
int cutoff =  10000;
int partition( int a[],  int i,  int j) {
     int v, k, t;
    j++;
    k = i;
    v = a[k];
     while (i < j) {
        i++;  while (a[i] < v && i < j) i++;
        j--;  while (a[j] > v         ) j--;
         if (i < j) { t = a[i]; a[i] = a[j]; a[j] = t; }
    }
    t = a[k]; a[k] = a[j]; a[j] = t;
     return j;
}
int quick( void *cl) {
     struct args *p = cl;
     int lb = p->lb, ub = p->ub;
     if (lb < ub) {
         int k = partition(p->a, lb, ub);
        p->lb = lb;
        p->ub = k -  1;
         if (k - lb > cutoff) {
            Thread_T t;
            t = Thread_new(quick, p,  sizeof *p, NULL);
            Fmt_print( " thread %p sorted %d..%d\n ", t, lb, k -  1);
        }  else
            quick(p);
        p->lb = k +  1;
        p->ub = ub;
         if (ub - k > cutoff) {
            Thread_T t;
            t = Thread_new(quick, p,  sizeof *p, NULL);
            Fmt_print( " thread %p sorted %d..%d\n ", t, k +  1, ub);
        }  else
            quick(p);
    }
     return EXIT_SUCCESS;
}
void sort( int *x,  int n,  int argc,  char *argv[]) {
     struct args args;
     if (argc >=  3)
        cutoff = atoi(argv[ 2]);
    args.a = x;
    args.lb =  0;
    args.ub = n -  1;
    quick(&args);
    Thread_join(NULL);
}
main( int argc,  char *argv[]) {
     int i, n =  100000, *x, preempt;
    preempt = Thread_init( 1, NULL);
    assert(preempt ==  1);
     if (argc >=  2)
        n = atoi(argv[ 1]);
    x = CALLOC(n,  sizeof ( int));
    srand(time(NULL));
     for (i =  0; i < n; i++)
        x[i] = rand();
    sort(x, n, argc, argv);
     for (i =  1; i < n; i++)
         if (x[i] < x[i- 1])
             break;
    assert(i == n);
    Thread_exit(EXIT_SUCCESS);
     return EXIT_SUCCESS;
}

 

 

 

 

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/thread.doc,v 1.11 1997/02/21 19:50:51 drh Exp $ ";
#include <stdio.h>
#include <stdlib.h>
#include  " assert.h "
#include  " fmt.h "
#include  " thread.h "
#include  " sem.h "
#define NBUMP 30000
struct args {
    Sem_T *mutex;
     int *ip;
};
int  unsafe( void *cl) {
     int i, *ip = cl;
     for (i =  0; i < NBUMP; i++)
        *ip = *ip +  1;
     return EXIT_SUCCESS;
}
int safe( void *cl) {
     struct args *p = cl;
     int i;
     for (i =  0; i < NBUMP; i++)
        LOCK(*p->mutex)
            *p->ip = *p->ip +  1;
        END_LOCK;
     return EXIT_SUCCESS;
}
int n;
int main( int argc,  char *argv[]) {
     int m =  5, preempt;
    preempt = Thread_init( 1, NULL);
    assert(preempt ==  1);
     if (argc >=  2)
        m = atoi(argv[ 1]);
    n =  0;
    {
         int i;
         for (i =  0; i < m; i++)
            Thread_new( unsafe, &n,  0, NULL);
        Thread_join(NULL);
    }
    Fmt_print( " %d == %d\n ", n, NBUMP*m);
    n =  0;
    {
         int i;
         struct args args;
        Sem_T mutex;
        Sem_init(&mutex,  1);
        args.mutex = &mutex;
        args.ip = &n;
         for (i =  0; i < m; i++)
            Thread_new(safe, &args,  sizeof args, NULL);
        Thread_join(NULL);
    }
    Fmt_print( " %d == %d\n ", n, NBUMP*m);
    Thread_exit(EXIT_SUCCESS);
     return EXIT_SUCCESS;
}

 

 

static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/thread.doc,v 1.11 1997/02/21 19:50:51 drh Exp $ ";
#include <stdio.h>
#include <stdlib.h>
#include  " assert.h "
#include  " fmt.h "
#include  " thread.h "
#include  " chan.h "
struct args {
    Chan_T c;
     int n, last;
};
int source( void *cl) {
     struct args *p = cl;
     int i =  2;
     if (Chan_send(p->c, &i,  sizeof i))
         for (i =  3; Chan_send(p->c, &i,  sizeof i); )
            i +=  2;
     return EXIT_SUCCESS;
}
void filter( int primes[], Chan_T input, Chan_T output) {
     int j, x;
     for (;;) {
        Chan_receive(input, &x,  sizeof x);
         for (j =  0; primes[j] !=  0 && x%primes[j] !=  0; j++)
            ;
         if (primes[j] ==  0)
              if (Chan_send(output, &x,  sizeof x) ==  0)
                 break;
    }
    Chan_receive(input, &x,  0);
}
int sink( void *cl) {
     struct args *p = cl;
    Chan_T input = p->c;
     int i =  0, j, x, primes[ 256];
    primes[ 0] =  0;
     for (;;) {
        Chan_receive(input, &x,  sizeof x);
          for (j =  0; primes[j] !=  0 && x%primes[j] !=  0; j++)
            ;
         if (primes[j] ==  0) {
             if (x > p->last)
                 break;
            Fmt_print( "  %d ", x);
            primes[i++] = x;
            primes[i] =  0;
             if (i == p->n)
                {
                    p->c = Chan_new();
                    Thread_new(sink, p,  sizeof *p, NULL);
                    filter(primes, input, p->c);
                     return EXIT_SUCCESS;
                }
        }
    }
    Fmt_print( " \n ");
    Chan_receive(input, &x,  0);
      return EXIT_SUCCESS;
}
int main( int argc,  char *argv[]) {
     struct args args;
    Thread_init( 1, NULL);
    args.c = Chan_new();
    Thread_new(source, &args,  sizeof args, NULL);
    args.n    = argc >  2 ? atoi(argv[ 2]) :  5;
    args.last = argc >  1 ? atoi(argv[ 1]) :  1000;
    Thread_new(sink,   &args,  sizeof args, NULL);
    Thread_exit(EXIT_SUCCESS);
     return EXIT_SUCCESS;
}

分类:  C/C++笔记