home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / devel / lisp / kcl_tar.z / kcl_tar / h / object.h < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-04  |  15.6 KB  |  670 lines
  1. /*
  2. (c) Copyright Taiichi Yuasa and Masami Hagiya, 1984.  All rights reserved.
  3. Copying of this file is authorized to users who have executed the true and
  4. proper "License Agreement for Kyoto Common LISP" with SIGLISP.
  5. */
  6.  
  7. /*
  8.     object.h
  9. */
  10.  
  11. /*
  12.     Some system constants.
  13. */
  14.  
  15. #define    TRUE        1    /*  boolean true value  */
  16. #define    FALSE        0    /*  boolean false value  */
  17.  
  18. #define    NBPP        4    /*  number of bytes per pointer  */
  19.  
  20. #define    PAGESIZE    2048    /*  page size in bytes  */
  21. #define    PAGEWIDTH    11    /*  page width  */
  22.                 /*  log2(PAGESIZE)  */
  23.  
  24. #define    CHCODELIM    256    /*  character code limit  */
  25.                 /*  ASCII character set  */
  26. #define    CHFONTLIM    1    /*  character font limit  */
  27. #define    CHBITSLIM    1    /*  character bits limit  */
  28. #define    CHCODEFLEN    8    /*  character code field length  */
  29. #define    CHFONTFLEN    0    /*  character font field length  */
  30. #define    CHBITSFLEN      0    /*  character bits field length  */
  31.  
  32. #define    PHTABSIZE    512    /*  number of entries  */
  33.                 /*  in the package hash table  */
  34.  
  35. #define    ARANKLIM    64    /*  array rank limit  */
  36.  
  37. #define    RTABSIZE    CHCODELIM
  38.                 /*  read table size  */
  39.  
  40. #define    CBMINSIZE    64    /*  contiguous block minimal size  */
  41.  
  42.  
  43. typedef int bool;
  44. typedef int fixnum;
  45. typedef float shortfloat;
  46. typedef double longfloat;
  47.  
  48. /*
  49.     Definition of the type of LISP objects.
  50. */
  51. typedef union lispunion *object;
  52.  
  53. /*
  54.     OBJect NULL value.
  55.     It should not coincide with any legal object value.
  56. */
  57. #define    OBJNULL        ((object)NULL)
  58.  
  59. /*
  60.     Definition of each implementation type.
  61. */
  62.  
  63. struct fixnum_struct {
  64.     short    t, m;
  65.     fixnum    FIXVAL;        /*  fixnum value  */
  66. };
  67. #define    fix(obje)    (obje)->FIX.FIXVAL
  68.  
  69. #define    SMALL_FIXNUM_LIMIT    1024
  70.  
  71. struct fixnum_struct small_fixnum_table[2*SMALL_FIXNUM_LIMIT];
  72.  
  73. #define    small_fixnum(i)  \
  74.     (object)(small_fixnum_table+SMALL_FIXNUM_LIMIT+(i))
  75.  
  76. struct shortfloat_struct {
  77.     short        t, m;
  78.     shortfloat    SFVAL;    /*  shortfloat value  */
  79. };
  80. #define    sf(obje)    (obje)->SF.SFVAL
  81.  
  82. struct longfloat_struct {
  83.     short        t, m;
  84.     longfloat    LFVAL;    /*  longfloat value  */
  85. };
  86. #define    lf(obje)    (obje)->LF.LFVAL
  87.  
  88. struct bignum {
  89.     short        t, m;
  90.     struct bignum   *big_cdr;    /*  bignum cdr  */
  91.     int        big_car;    /*  bignum car  */
  92. };
  93.  
  94. struct ratio {
  95.     short    t, m;
  96.     object    rat_den;    /*  denominator  */
  97.                 /*  must be an integer  */
  98.     object    rat_num;    /*  numerator  */
  99.                 /*  must be an integer  */
  100. };
  101.  
  102. struct complex {
  103.     short    t, m;
  104.     object    cmp_real;    /*  real part  */
  105.                 /*  must be a number  */
  106.     object    cmp_imag;    /*  imaginary part  */
  107.                 /*  must be a number  */
  108. };
  109.  
  110. struct character {
  111.     short        t, m;
  112.     unsigned short    ch_code;    /*  code  */
  113.     unsigned char    ch_font;    /*  font  */
  114.     unsigned char    ch_bits;    /*  bits  */
  115. };
  116.  
  117. #ifdef MV
  118.  
  119. #endif
  120.  
  121. #ifdef AV
  122. struct character character_table[];
  123. #endif
  124.  
  125. #define    code_char(c)        (object)(character_table+(c))
  126. #define    char_code(obje)        (obje)->ch.ch_code
  127. #define    char_font(obje)        (obje)->ch.ch_font
  128. #define    char_bits(obje)        (obje)->ch.ch_bits
  129.  
  130. enum stype {            /*  symbol type  */
  131.     stp_ordinary,        /*  ordinary  */
  132.     stp_constant,        /*  constant  */
  133.         stp_special        /*  special  */
  134. };
  135.  
  136. #define    Cnil            ((object)&Cnil_body)
  137. #define    Ct            ((object)&Ct_body)
  138.  
  139. struct symbol {
  140.     short    t, m;
  141.     object    s_dbind;    /*  dynamic binding  */
  142.     int    (*s_sfdef)();    /*  special form definition  */
  143.                 /*  This field coincides with c_car  */
  144.  
  145. #define    NOT_SPECIAL        ((int (*)())Cnil)
  146.  
  147. #define    s_fillp        st_fillp
  148. #define    s_self        st_self
  149.  
  150.     int    s_fillp;    /*  print name length  */
  151.     char    *s_self;    /*  print name  */
  152.                 /*  These fields coincide with  */
  153.                 /*  st_fillp and st_self.  */
  154.  
  155.     object    s_gfdef;        /*  global function definition  */
  156.                 /*  For a macro,  */
  157.                 /*  its expansion function  */
  158.                 /*  is to be stored.  */
  159.     object    s_plist;    /*  property list  */
  160.     object    s_hpack;    /*  home package  */
  161.                 /*  Cnil for uninterned symbols  */
  162.     short    s_stype;    /*  symbol type  */
  163.                 /*  of enum stype  */
  164.     short    s_mflag;    /*  macro flag  */
  165. };
  166.  
  167. struct symbol Cnil_body, Ct_body;
  168.  
  169. struct package {
  170.     short    t, m;
  171.     object    p_name;        /*  package name  */
  172.                 /*  a string  */
  173.     object    p_nicknames;    /*  nicknames  */
  174.                 /*  list of strings  */
  175.     object    p_shadowings;    /*  shadowing symbol list  */
  176.     object    p_uselist;    /*  use-list of packages  */
  177.     object    p_usedbylist;    /*  used-by-list of packages  */
  178.     object    *p_internal;    /*  hashtable for internal symbols  */
  179.     object    *p_external;    /*  hashtable for external symbols  */
  180.     struct package
  181.         *p_link;    /*  package link  */
  182. };
  183.  
  184. /*
  185.     The values returned by intern and find_symbol.
  186.     File_symbol may return 0.
  187. */
  188. #define    INTERNAL    1
  189. #define    EXTERNAL    2
  190. #define    INHERITED    3
  191.  
  192. /*
  193.     All the packages are linked through p_link.
  194. */
  195. struct package *pack_pointer;    /*  package pointer  */
  196.  
  197. struct cons {
  198.     short    t, m;
  199.     object    c_cdr;        /*  cdr  */
  200.     object    c_car;        /*  car  */
  201. };
  202.  
  203. enum httest {            /*  hash table key test function  */
  204.     htt_eq,            /*  eq  */
  205.     htt_eql,        /*  eql  */
  206.     htt_equal        /*  equal  */
  207. };
  208.  
  209. struct htent {            /*  hash table entry  */
  210.     object    hte_key;    /*  key  */
  211.     object    hte_value;    /*  value  */
  212. };
  213.  
  214. struct hashtable {        /*  hash table header  */
  215.     short    t, m;
  216.     struct htent
  217.         *ht_self;    /*  pointer to the hash table  */
  218.     object    ht_rhsize;    /*  rehash size  */
  219.     object    ht_rhthresh;    /*  rehash threshold  */
  220.     int    ht_nent;    /*  number of entries  */
  221.     int    ht_size;    /*  hash table size  */
  222.     short    ht_test;    /*  key test function  */
  223.                 /*  of enum httest  */
  224. };
  225.  
  226. enum aelttype {            /*  array element type  */
  227.     aet_object,        /*  t  */
  228.     aet_ch,            /*  string-char  */
  229.     aet_bit,        /*  bit  */
  230.     aet_fix,        /*  fixnum  */
  231.     aet_sf,            /*  short-float  */
  232.     aet_lf            /*  long-float  */
  233. };
  234.  
  235. struct array {            /*  array header  */
  236.     short    t, m;
  237.     short    a_rank;        /*  array rank  */
  238. /*    short    v_hasfillp;        has-fill-pointer flag  */
  239.     short    a_adjustable;    /*  adjustable flag  */
  240.     int    a_dim;        /*  dimension  */
  241.     int    *a_dims;    /*  table of dimensions  */
  242. /*    int    v_fillp;        fill pointer  */
  243.     object    *a_self;    /*  pointer to the array  */
  244.     object    a_displaced;    /*  displaced  */
  245.     short    a_elttype;    /*  element type  */
  246.     short    a_offset;    /*  bitvector offset  */
  247. };
  248.  
  249. struct vector {            /*  vector header  */
  250.     short    t, m;
  251.     short    v_hasfillp;    /*  has-fill-pointer flag  */
  252.     short    v_adjustable;    /*  adjustable flag  */
  253.     int    v_dim;        /*  dimension  */
  254.     int    v_fillp;    /*  fill pointer  */
  255.                 /*  For simple vectors,  */
  256.                 /*  v_fillp is equal to v_dim.  */
  257.     object    *v_self;    /*  pointer to the vector  */
  258.     object    v_displaced;    /*  displaced  */
  259.     short    v_elttype;    /*  element type  */
  260.     short    v_offset;    /*  not used  */
  261. };
  262.  
  263. struct string {            /*  string header  */
  264.     short    t, m;
  265.     short    st_hasfillp;    /*  has-fill-pointer flag  */
  266.     short    st_adjustable;    /*  adjustable flag  */
  267.     int    st_dim;        /*  dimension  */
  268.                 /*  string length  */
  269.     int    st_fillp;    /*  fill pointer  */
  270.                 /*  For simple strings,  */
  271.                 /*  st_fillp is equal to st_dim.  */
  272.     char    *st_self;    /*  pointer to the string  */
  273.     object    st_displaced;    /*  displaced  */
  274. };
  275.  
  276. struct ustring {
  277.     short    t, m;
  278.     short    ust_hasfillp;
  279.     short    ust_adjustable;
  280.     int    ust_dim;
  281.     int    ust_fillp;
  282.     unsigned char
  283.         *ust_self;
  284.     object    ust_displaced;
  285. };
  286.  
  287. struct bitvector {        /*  bitvector header  */
  288.     short    t, m;
  289.     short    bv_hasfillp;    /*  has-fill-pointer flag  */
  290.     short    bv_adjustable;    /*  adjustable flag  */
  291.     int    bv_dim;        /*  dimension  */
  292.                 /*  number of bits  */
  293.     int    bv_fillp;    /*  fill pointer  */
  294.                 /*  For simple bitvectors,  */
  295.                 /*  st_fillp is equal to st_dim.  */
  296.     char    *bv_self;    /*  pointer to the bitvector  */
  297.     object    bv_displaced;    /*  displaced  */
  298.     short    bv_elttype;    /*  not used  */
  299.     short    bv_offset;    /*  bitvector offset  */
  300.                 /*  the position of the first bit  */
  301.                 /*  in the first byte  */
  302. };
  303.  
  304. struct fixarray {        /*  fixnum array header  */
  305.     short    t, m;
  306.     short    fixa_rank;    /*  array rank  */
  307.     short    fixa_adjustable;/*  adjustable flag  */
  308.     int    fixa_dim;    /*  dimension  */
  309.     int    *fixa_dims;    /*  table of dimensions  */
  310.     fixnum    *fixa_self;    /*  pointer to the array  */
  311.     object    fixa_displaced;    /*  displaced  */
  312.     short    fixa_elttype;    /*  element type  */
  313.     short    fixa_offset;    /*  not used  */
  314. };
  315.  
  316. struct sfarray {        /*  short-float array header  */
  317.     short    t, m;
  318.     short    sfa_rank;    /*  array rank  */
  319.     short    sfa_adjustable;    /*  adjustable flag  */
  320.     int    sfa_dim;    /*  dimension  */
  321.     int    *sfa_dims;    /*  table of dimensions  */
  322.     shortfloat
  323.         *sfa_self;    /*  pointer to the array  */
  324.     object    sfa_displaced;    /*  displaced  */
  325.     short    sfa_elttype;    /*  element type  */
  326.     short    sfa_offset;    /*  not used  */
  327. };
  328.  
  329. struct lfarray {        /*  long-float array header  */
  330.     short    t, m;
  331.     short    lfa_rank;    /*  array rank  */
  332.     short    lfa_adjustable;    /*  adjustable flag  */
  333.     int    lfa_dim;        /*  dimension  */
  334.     int    *lfa_dims;    /*  table of dimensions  */
  335.     longfloat
  336.         *lfa_self;    /*  pointer to the array  */
  337.     object    lfa_displaced;    /*  displaced  */
  338.     short    lfa_elttype;    /*  element type  */
  339.     short    lfa_offset;    /*  not used  */
  340. };
  341.  
  342. struct structure {        /*  structure header  */
  343.     short    t, m;
  344.     object    str_name;    /*  structure name  */
  345.     object    *str_self;    /*  structure self  */
  346.     int    str_length;    /*  structure length  */
  347. };
  348.  
  349. enum smmode {            /*  stream mode  */
  350.     smm_input,        /*  input  */
  351.     smm_output,        /*  output  */
  352.     smm_io,            /*  input-output  */
  353.     smm_probe,        /*  probe  */
  354.     smm_synonym,        /*  synonym  */
  355.     smm_broadcast,        /*  broadcast  */
  356.     smm_concatenated,    /*  concatenated  */
  357.     smm_two_way,        /*  two way  */
  358.     smm_echo,        /*  echo  */
  359.     smm_string_input,    /*  string input  */
  360.     smm_string_output    /*  string output  */
  361. };
  362.  
  363. struct stream {
  364.     short    t, m;
  365.     FILE    *sm_fp;        /*  file pointer  */
  366.     object    sm_object0;    /*  some object  */
  367.     object    sm_object1;    /*  some object */
  368.     int    sm_int0;    /*  some int  */
  369.     int    sm_int1;    /*  some int  */
  370.     short    sm_mode;    /*  stream mode  */
  371.                 /*  of enum smmode  */
  372. };
  373.  
  374. #ifdef BSD
  375. #define    BASEFF        (char *)0xffffffff
  376. #endif
  377.  
  378. #ifdef ATT
  379. #define    BASEFF        (unsigned char *)0xffffffff
  380. #endif
  381.  
  382. #ifdef E15
  383. #define    BASEFF        (unsigned char *)0xffffffff
  384. #endif
  385.  
  386. #ifdef MV
  387.  
  388.  
  389. #endif
  390.  
  391. struct random {
  392.     short        t, m;
  393.     unsigned    rnd_value;    /*  random state value  */
  394. };
  395.  
  396. enum chattrib {            /*  character attribute  */
  397.     cat_whitespace,        /*  whitespace  */
  398.     cat_terminating,    /*  terminating macro  */
  399.     cat_non_terminating,    /*  non-terminating macro  */
  400.     cat_single_escape,    /*  single-escape  */
  401.     cat_multiple_escape,    /*  multiple-escape  */
  402.     cat_constituent        /*  constituent  */
  403. };
  404.  
  405. struct rtent {                /*  read table entry  */
  406.     enum chattrib    rte_chattrib;    /*  character attribute  */
  407.     object        rte_macro;    /*  macro function  */
  408.     object        *rte_dtab;    /*  pointer to the  */
  409.                     /*  dispatch table  */
  410.                     /*  NULL for  */
  411.                     /*  non-dispatching  */
  412.                     /*  macro character, or  */
  413.                     /*  non-macro character  */
  414. };
  415.  
  416. struct readtable {            /*  read table  */
  417.     short        t, m;
  418.     struct rtent    *rt_self;    /*  read table itself  */
  419. };
  420.  
  421. struct pathname {
  422.     short    t, m;
  423.     object    pn_host;    /*  host  */
  424.     object    pn_device;    /*  device  */
  425.     object    pn_directory;    /*  directory  */
  426.     object    pn_name;    /*  name  */
  427.     object    pn_type;    /*  type  */
  428.     object    pn_version;    /*  version  */
  429. };
  430.  
  431. struct cfun {            /*  compiled function header  */
  432.     short    t, m;
  433.     object    cf_name;    /*  compiled function name  */
  434.     int    (*cf_self)();    /*  entry address  */
  435.     object    cf_data;    /*  data the function uses  */
  436.                 /*  for GBC  */
  437.     char    *cf_start;    /*  start address of the code  */
  438.     int    cf_size;    /*  code size  */
  439. };
  440.  
  441. struct cclosure {        /*  compiled closure header  */
  442.     short    t, m;
  443.     object    cc_name;    /*  compiled closure name  */
  444.     int    (*cc_self)();    /*  entry address  */
  445.     object    cc_env;        /*  environment  */
  446.     object    cc_data;    /*  data the closure uses  */
  447.                 /*  for GBC  */
  448.     char    *cc_start;    /*  start address of the code  */
  449.     int    cc_size;    /*  code size  */
  450.     object    *cc_turbo;    /*  turbo charger */
  451. };
  452.  
  453. struct spice {
  454.     short    t, m;
  455.     int    spc_dummy;
  456. };
  457.  
  458. /*
  459.     dummy type
  460. */
  461. struct dummy {
  462.     short    t, m;
  463. };
  464.  
  465. /*
  466.     Definition of lispunion.
  467. */
  468. union lispunion {
  469.     struct fixnum_struct
  470.             FIX;    /*  fixnum  */
  471.     struct bignum    big;    /*  bignum  */
  472.     struct ratio    rat;    /*  ratio  */
  473.     struct shortfloat_struct
  474.             SF;    /*  short floating-point number  */
  475.     struct longfloat_struct
  476.             LF;    /*  long floating-point number  */
  477.     struct complex    cmp;    /*  complex number  */
  478.     struct character
  479.             ch;    /*  character  */
  480.     struct symbol    s;    /*  symbol  */
  481.     struct package    p;    /*  package  */
  482.     struct cons    c;    /*  cons  */
  483.     struct hashtable
  484.             ht;    /*  hash table  */
  485.     struct array    a;    /*  array  */
  486.     struct vector    v;    /*  vector  */
  487.     struct string    st;    /*  string  */
  488.     struct ustring    ust;
  489.     struct bitvector
  490.             bv;    /*  bit-vector  */
  491.     struct structure
  492.             str;    /*  structure  */
  493.     struct stream    sm;    /*  stream  */
  494.     struct random    rnd;    /*  random-states  */
  495.     struct readtable
  496.             rt;    /*  read table  */
  497.     struct pathname    pn;    /*  path name  */
  498.     struct cfun    cf;    /*  compiled function  */
  499.     struct cclosure    cc;    /*  compiled closure  */
  500.     struct spice    spc;    /*  spice  */
  501.  
  502.     struct dummy    d;    /*  dummy  */
  503.  
  504.     struct fixarray    fixa;    /*  fixnum array  */
  505.     struct sfarray    sfa;    /*  short-float array  */
  506.     struct lfarray    lfa;    /*  long-float array  */
  507. };
  508.  
  509. /*
  510.     The struct of free lists.
  511. */
  512. struct freelist {
  513.     short    t, m;
  514.     object    f_link;
  515. };
  516.  
  517. #define    FREE    (-1)        /*  free object  */
  518.  
  519. /*
  520.     Implementation types.
  521. */
  522. enum type {
  523.     t_cons = 0,
  524.     t_start = t_cons,
  525.     t_fixnum,
  526.     t_bignum,
  527.     t_ratio,
  528.     t_shortfloat,
  529.     t_longfloat,
  530.     t_complex,
  531.     t_character,
  532.     t_symbol,
  533.     t_package,
  534. /*    t_cons,  */
  535.     t_hashtable,
  536.     t_array,
  537.     t_vector,
  538.     t_string,
  539.     t_bitvector,
  540.     t_structure,
  541.     t_stream,
  542.     t_random,
  543.     t_readtable,
  544.     t_pathname,
  545.     t_cfun,
  546.     t_cclosure,
  547.     t_spice,
  548.     t_end,
  549.     t_contiguous,        /*  contiguous block  */
  550.     t_relocatable,        /*  relocatable block  */
  551.     t_other            /*  other  */
  552. };
  553.  
  554. /*
  555.     Type map.
  556.  
  557.     enum type type_map[MAXPAGE];
  558. */
  559. char type_map[MAXPAGE];
  560.  
  561. /*
  562.     Type_of.
  563. */
  564. #define    type_of(obje)    ((enum type)(((object)(obje))->d.t))
  565.  
  566. /*
  567.     Storage manager for each type.
  568. */
  569. struct typemanager {
  570.     enum type
  571.         tm_type;    /*  type  */
  572.     int    tm_size;    /*  element size in bytes  */
  573.     int    tm_nppage;    /*  number per page  */
  574.     object    tm_free;    /*  free list  */
  575.                 /*  Note that it is of type object.  */
  576.     int    tm_nfree;    /*  number of free elements  */
  577.     int    tm_nused;    /*  number of elements used  */
  578.     int    tm_npage;    /*  number of pages  */
  579.     int    tm_maxpage;    /*  maximum number of pages  */
  580.     char    *tm_name;    /*  type name  */
  581.     int    tm_gbccount;    /*  GBC count  */
  582. };
  583.  
  584. /*
  585.     The table of type managers.
  586. */
  587. struct typemanager tm_table[(int)t_end];
  588.  
  589. #define    tm_of(t)    (&(tm_table[(int)tm_table[(int)(t)].tm_type]))
  590.  
  591. /*
  592.     Contiguous block header.
  593. */
  594. struct contblock {        /*  contiguous block header  */
  595.     int    cb_size;    /*  size in bytes  */
  596.     struct contblock
  597.         *cb_link;    /*  contiguous block link  */
  598. };
  599.  
  600. /*
  601.     The pointer to the contiguous blocks.
  602. */
  603. struct contblock *cb_pointer;    /*  contblock pointer  */
  604.  
  605. /*
  606.     Variables for memory management.
  607. */
  608. int ncb;            /*  number of contblocks  */
  609. int ncbpage;            /*  number of contblock pages  */
  610. int maxcbpage;            /*  maximum number of contblock pages  */
  611. int cbgbccount;            /*  contblock gbc count  */
  612.  
  613. int holepage;            /*  hole pages  */
  614. int nrbpage;            /*  number of relblock pages  */
  615. int rbgbccount;            /*  relblock gbc count  */
  616.  
  617. char *rb_start;            /*  relblock start  */
  618. char *rb_end;            /*  relblock end  */
  619. char *rb_limit;            /*  relblock limit  */
  620. char *rb_pointer;        /*  relblock pointer  */
  621. char *rb_start1;        /*  relblock start in copy space  */
  622. char *rb_pointer1;        /*  relblock pointer in copy space  */
  623.  
  624. char *heap_end;            /*  heap end  */
  625. char *core_end;            /*  core end  */
  626.  
  627. #define    HOLEPAGE    128
  628.  
  629. #ifdef ATT
  630. #undef HOLEPAGE
  631. #define    HOLEPAGE    32
  632. #endif
  633.  
  634. #ifdef E15
  635. #undef HOLEPAGE
  636. #define    HOLEPAGE    32
  637. #endif
  638.  
  639. #define    INIT_HOLEPAGE    150
  640. #define    INIT_NRBPAGE    50
  641. #define    RB_GETA        512
  642.  
  643. /*
  644.     Endp macro.
  645. */
  646. /*
  647. #define    endp(obje)    ((enum type)((endp_temp = (obje))->d.t) == t_cons ? \
  648.              FALSE : endp_temp == Cnil ? TRUE : \
  649.              (bool)FEwrong_type_argument(Slist, endp_temp))
  650.  
  651. object endp_temp;
  652. */
  653.  
  654. #define    endp(obje)    endp1(obje)
  655.  
  656. #ifdef AV
  657. #define    STATIC    register
  658. #endif
  659. #ifdef MV
  660.  
  661. #endif
  662.  
  663. #define    TIME_ZONE    (-9)
  664.  
  665. int FIXtemp;
  666.  
  667. #define    isUpper(xxx)    (((xxx)&0200) == 0 && isupper(xxx))
  668. #define    isLower(xxx)    (((xxx)&0200) == 0 && islower(xxx))
  669. #define    isDigit(xxx)    (((xxx)&0200) == 0 && isdigit(xxx))
  670.