home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / CONTRIB / GNU-COMM / GCL-1.0 / GCL-1 / gcl-1.0 / c / predicate.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-07  |  13.4 KB  |  773 lines
  1. /*
  2.  Copyright (C) 1994 M. Hagiya, W. Schelter, T. Yuasa
  3.  
  4. This file is part of GNU Common Lisp, herein referred to as GCL
  5.  
  6. GCL is free software; you can redistribute it and/or modify it under
  7. the terms of the GNU LIBRARY GENERAL PUBLIC LICENSE as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GCL is distributed in the hope that it will be useful, but WITHOUT
  12. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public 
  14. License for more details.
  15.  
  16. You should have received a copy of the GNU Library General Public License 
  17. along with GCL; see the file COPYING.  If not, write to the Free Software
  18. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  
  20. */
  21.  
  22. /*
  23.     predicate.c
  24.  
  25.     predicates
  26. */
  27.  
  28. #include "include.h"
  29.  
  30. Lnull()
  31. {
  32.     check_arg(1);
  33.  
  34.     if (vs_base[0] == Cnil)
  35.         vs_base[0] = Ct;
  36.     else
  37.         vs_base[0] = Cnil;
  38. }
  39.  
  40. Lsymbolp()
  41. {
  42.     check_arg(1);
  43.  
  44.     if (type_of(vs_base[0]) == t_symbol)
  45.         vs_base[0] = Ct;
  46.     else
  47.         vs_base[0] = Cnil;
  48. }
  49.  
  50. Latom()
  51. {
  52.     check_arg(1);
  53.  
  54.     if (type_of(vs_base[0]) != t_cons)
  55.         vs_base[0] = Ct;
  56.     else
  57.         vs_base[0] = Cnil;
  58. }
  59.  
  60. Lconsp()
  61. {
  62.     check_arg(1);
  63.  
  64.     if (type_of(vs_base[0]) == t_cons)
  65.         vs_base[0] = Ct;
  66.     else
  67.         vs_base[0] = Cnil;
  68. }
  69.  
  70. Llistp()
  71. {
  72.     check_arg(1);
  73.  
  74.     if (vs_base[0] == Cnil || type_of(vs_base[0]) == t_cons)
  75.         vs_base[0] = Ct;
  76.     else
  77.         vs_base[0] = Cnil;
  78. }
  79.  
  80. Lnumberp()
  81. {
  82.     enum type t;
  83.     check_arg(1);
  84.  
  85.     t = type_of(vs_base[0]);
  86.     if (t == t_fixnum || t == t_bignum || t == t_ratio ||
  87.         t == t_shortfloat || t == t_longfloat ||
  88.         t == t_complex)
  89.         vs_base[0] = Ct;
  90.     else
  91.         vs_base[0] = Cnil;
  92. }
  93.  
  94. Lintegerp()
  95. {
  96.     enum type t;
  97.     check_arg(1);
  98.  
  99.     t = type_of(vs_base[0]);
  100.     if (t == t_fixnum || t == t_bignum)
  101.         vs_base[0] = Ct;
  102.     else
  103.         vs_base[0] = Cnil;
  104. }
  105.  
  106. Lrationalp()
  107. {
  108.     enum type t;
  109.     check_arg(1);
  110.  
  111.     t = type_of(vs_base[0]);
  112.     if (t == t_fixnum || t == t_bignum || t == t_ratio)
  113.         vs_base[0] = Ct;
  114.     else
  115.         vs_base[0] = Cnil;
  116. }
  117.  
  118. Lfloatp()
  119. {
  120.     enum type t;
  121.     check_arg(1);
  122.  
  123.     t = type_of(vs_base[0]);
  124.     if (t == t_longfloat || t == t_shortfloat)
  125.         vs_base[0] = Ct;
  126.     else
  127.         vs_base[0] = Cnil;
  128. }
  129.  
  130. Lcomplexp()
  131. {
  132.     check_arg(1);
  133.  
  134.     if (type_of(vs_base[0]) == t_complex)
  135.         vs_base[0] = Ct;
  136.     else
  137.         vs_base[0] = Cnil;
  138. }
  139.  
  140. Lcharacterp()
  141. {
  142.     check_arg(1);
  143.  
  144.     if (type_of(vs_base[0]) == t_character)
  145.         vs_base[0] = Ct;
  146.     else
  147.         vs_base[0] = Cnil;
  148. }
  149.  
  150. Lstringp()
  151. {
  152.     check_arg(1);
  153.  
  154.     if (type_of(vs_base[0]) == t_string)
  155.         vs_base[0] = Ct;
  156.     else
  157.         vs_base[0] = Cnil;
  158. }
  159.  
  160. Lbit_vector_p()
  161. {
  162.     check_arg(1);
  163.  
  164.     if (type_of(vs_base[0]) == t_bitvector)
  165.         vs_base[0] = Ct;
  166.     else
  167.         vs_base[0] = Cnil;
  168. }
  169.  
  170. Lvectorp()
  171. {
  172.     enum type t;
  173.     check_arg(1);
  174.  
  175.     t = type_of(vs_base[0]);
  176.     if (t == t_vector || t == t_string || t == t_bitvector)
  177.         vs_base[0] = Ct;
  178.     else
  179.         vs_base[0] = Cnil;
  180. }
  181.  
  182. Lsimple_string_p()
  183. {
  184.     check_arg(1);
  185.  
  186.     if (type_of(vs_base[0]) == t_string &&
  187.         !vs_base[0]->st.st_adjustable &&
  188.         !vs_base[0]->st.st_hasfillp &&
  189.         vs_base[0]->st.st_displaced->c.c_car == Cnil)
  190.         vs_base[0] = Ct;
  191.     else
  192.         vs_base[0] = Cnil;
  193. }
  194.  
  195. Lsimple_bit_vector_p()
  196. {
  197.     check_arg(1);
  198.  
  199.     if (type_of(vs_base[0]) == t_bitvector &&
  200.         !vs_base[0]->bv.bv_adjustable &&
  201.         !vs_base[0]->bv.bv_hasfillp &&
  202.         vs_base[0]->bv.bv_displaced->c.c_car == Cnil)
  203.         vs_base[0] = Ct;
  204.     else
  205.         vs_base[0] = Cnil;
  206. }
  207.  
  208. Lsimple_vector_p()
  209. {
  210.     enum type t;
  211.     check_arg(1);
  212.  
  213.     t = type_of(vs_base[0]);
  214.     if (t == t_vector &&
  215.         !vs_base[0]->v.v_adjustable &&
  216.         !vs_base[0]->v.v_hasfillp &&
  217.         vs_base[0]->v.v_displaced->c.c_car == Cnil &&
  218.         (enum aelttype)vs_base[0]->v.v_elttype == aet_object)
  219.         vs_base[0] = Ct;
  220.     else
  221.         vs_base[0] = Cnil;
  222. }
  223.  
  224. Larrayp()
  225. {
  226.     enum type t;
  227.     check_arg(1);
  228.  
  229.     t = type_of(vs_base[0]);
  230.     if (t == t_array ||
  231.         t == t_vector || t == t_string || t == t_bitvector)
  232.         vs_base[0] = Ct;
  233.     else
  234.         vs_base[0] = Cnil;
  235. }
  236.  
  237. Lpackagep()
  238. {
  239.     check_arg(1);
  240.  
  241.     if (type_of(vs_base[0]) == t_package)
  242.         vs_base[0] = Ct;
  243.     else
  244.         vs_base[0] = Cnil;
  245. }
  246.  
  247. Lfunctionp()
  248. {
  249.     enum type t;
  250.     object x;
  251.  
  252.     check_arg(1);
  253.     t = type_of(vs_base[0]);
  254.     if (t == t_cfun || t == t_cclosure || t == t_sfun || t == t_gfun
  255.         || t == t_vfun)
  256.         vs_base[0] = Ct;
  257.     else if (t == t_symbol) {
  258.         if (vs_base[0]->s.s_gfdef != OBJNULL &&
  259.             vs_base[0]->s.s_mflag == FALSE)
  260.             vs_base[0] = Ct;
  261.         else
  262.             vs_base[0] = Cnil;
  263.     } else if (t == t_cons) {
  264.         x = vs_base[0]->c.c_car;
  265.         if (x == Slambda || x == Slambda_block ||
  266.             x == siSlambda_block_expanded ||
  267.             x == Slambda_closure || x == Slambda_block_closure)
  268.             vs_base[0] = Ct;
  269.         else
  270.             vs_base[0] = Cnil;
  271.     } else
  272.         vs_base[0] = Cnil;
  273. }
  274.  
  275. Lcompiled_function_p()
  276. {
  277.     check_arg(1);
  278.  
  279.     if (type_of(vs_base[0]) == t_cfun ||
  280.         type_of(vs_base[0]) == t_cclosure  ||
  281.         type_of(vs_base[0]) == t_sfun   ||
  282.         type_of(vs_base[0]) == t_gfun ||
  283.         type_of(vs_base[0]) == t_vfun
  284.         
  285.         
  286.         )
  287.         vs_base[0] = Ct;
  288.     else
  289.         vs_base[0] = Cnil;
  290. }
  291.  
  292. Lcommonp()
  293. {
  294.     check_arg(1);
  295.  
  296.     if (type_of(vs_base[0]) != t_spice)
  297.         vs_base[0] = Ct;
  298.     else
  299.         vs_base[0] = Cnil;
  300. }
  301.  
  302. Leq()
  303. {
  304.     check_arg(2);
  305.  
  306.     if (vs_base[0] == vs_base[1])
  307.         vs_base[0] = Ct;
  308.     else
  309.         vs_base[0] = Cnil;
  310.     vs_pop;
  311. }
  312.  
  313. bool
  314. eql(x, y)
  315. object x, y;
  316. {
  317.     enum type t;
  318.  
  319.     if (x == y)
  320.         return(TRUE);
  321.     if ((t = type_of(x)) != type_of(y))
  322.         return(FALSE);
  323.     switch (t) {
  324.  
  325.     case t_fixnum:
  326.         if (fix(x) == fix(y))
  327.             return(TRUE);
  328.         else
  329.             return(FALSE);
  330.  
  331.     case t_bignum:
  332.         if (big_compare((struct bignum *)x,
  333.                 (struct bignum *)y) == 0)
  334.             return(TRUE);
  335.         else
  336.             return(FALSE);
  337.  
  338.     case t_ratio:
  339.         if (eql(x->rat.rat_num, y->rat.rat_num) &&
  340.             eql(x->rat.rat_den, y->rat.rat_den))
  341.             return(TRUE);
  342.         else
  343.             return(FALSE);
  344.  
  345.     case t_shortfloat:
  346.         if (sf(x) == sf(y))
  347.             return(TRUE);
  348.         else
  349.             return(FALSE);
  350.  
  351.     case t_longfloat:
  352.         if (lf(x) == lf(y))
  353.             return(TRUE);
  354.         else
  355.             return(FALSE);
  356.  
  357.     case t_complex:
  358.         if (eql(x->cmp.cmp_real, y->cmp.cmp_real) &&
  359.             eql(x->cmp.cmp_imag, y->cmp.cmp_imag))
  360.             return(TRUE);
  361.         else
  362.             return(FALSE);
  363.  
  364.     case t_character:
  365.         if (char_code(x) == char_code(y) &&
  366.             char_bits(x) == char_bits(y) &&
  367.             char_font(x) == char_font(y))
  368.             return(TRUE);
  369.         else
  370.             return(FALSE);
  371.     }
  372.     return(FALSE);
  373. }
  374.  
  375. Leql()
  376. {
  377.     check_arg(2);
  378.  
  379.     if (eql(vs_base[0], vs_base[1]))
  380.         vs_base[0] = Ct;
  381.     else
  382.         vs_base[0] = Cnil;
  383.     vs_pop;
  384. }
  385.  
  386. bool
  387.  
  388. equal(x, y)
  389. register object x;
  390. #ifdef UNIX   /* in non unix case cs_check want's an address */
  391. register
  392. #endif
  393. object y;
  394. {
  395. register enum type t;
  396.  
  397.     cs_check(y);
  398.  
  399. BEGIN:
  400.     if ((t = type_of(x)) != type_of(y))
  401.         return(FALSE);
  402.     if (x==y)
  403.         return(TRUE);
  404.     switch (t) {
  405.  
  406.     case t_cons:
  407.         if (!equal(x->c.c_car, y->c.c_car))
  408.             return(FALSE);
  409.         x = x->c.c_cdr;
  410.         y = y->c.c_cdr;
  411.         goto BEGIN;
  412.  
  413.         case t_structure:
  414.     case t_symbol: 
  415.     case t_vector:
  416.         case t_array:
  417.         return FALSE;
  418.  
  419.     case t_fixnum :
  420.     return(fix(x)==fix(y));
  421.     case t_shortfloat:
  422.     return(x->SF.SFVAL==y->SF.SFVAL);
  423.     case t_longfloat:
  424.     return(x->LF.LFVAL==y->LF.LFVAL);
  425.  
  426.      case t_string:
  427.         return(string_eq(x, y));
  428.  
  429.     case t_bitvector:
  430.     {
  431.         int i, ox, oy;
  432.  
  433.         if (x->bv.bv_fillp != y->bv.bv_fillp)
  434.             return(FALSE);
  435.         ox = x->bv.bv_offset;
  436.         oy = y->bv.bv_offset;
  437.         for (i = 0;  i < x->bv.bv_fillp;  i++)
  438.             if((x->bv.bv_self[(i+ox)/8] & (0200>>(i+ox)%8))
  439.              !=(y->bv.bv_self[(i+oy)/8] & (0200>>(i+oy)%8)))
  440.                 return(FALSE);
  441.         return(TRUE);
  442.     }
  443.  
  444.     case t_pathname:
  445. #ifdef UNIX
  446.         if (equal(x->pn.pn_host, y->pn.pn_host) &&
  447.             equal(x->pn.pn_device, y->pn.pn_device) &&
  448.             equal(x->pn.pn_directory, y->pn.pn_directory) &&
  449.             equal(x->pn.pn_name, y->pn.pn_name) &&
  450.             equal(x->pn.pn_type, y->pn.pn_type) &&
  451.             equal(x->pn.pn_version, y->pn.pn_version))
  452. #endif
  453.             return(TRUE);
  454.         else
  455.             return(FALSE);
  456.  
  457.     }
  458.     return(eql(x,y));
  459. }
  460.  
  461. Lequal()
  462. {
  463.     check_arg(2);
  464.  
  465.     if (equal(vs_base[0], vs_base[1]))
  466.         vs_base[0] = Ct;
  467.     else
  468.         vs_base[0] = Cnil;
  469.     vs_pop;
  470. }
  471.  
  472. bool
  473. equalp(x, y)
  474. object x, y;
  475. {
  476.     enum type tx, ty;
  477.     int j;
  478.  
  479.     cs_check(x);
  480.  
  481. BEGIN:
  482.     if (eql(x, y))
  483.         return(TRUE);
  484.     tx = type_of(x);
  485.     ty = type_of(y);
  486.  
  487.     switch (tx) {
  488.     case t_fixnum:
  489.     case t_bignum:
  490.     case t_ratio:
  491.     case t_shortfloat:
  492.     case t_longfloat:
  493.     case t_complex:
  494.         if (ty == t_fixnum || ty == t_bignum || ty == t_ratio ||
  495.             ty == t_shortfloat || ty == t_longfloat ||
  496.             ty == t_complex)
  497.             return(!number_compare(x, y));
  498.         else
  499.             return(FALSE);
  500.  
  501.     case t_vector:
  502.     case t_string:
  503.     case t_bitvector:
  504.         if (ty == t_vector || ty == t_string || ty == t_bitvector)
  505.             { j = x->v.v_fillp;
  506.               if (j != y->v.v_fillp)
  507.                 return FALSE;
  508.               goto ARRAY;}
  509.         else
  510.             return(FALSE);
  511.  
  512.     case t_array:
  513.         if (ty == t_array && x->a.a_rank == y->a.a_rank)
  514.           { if (x->a.a_rank > 1)
  515.              {int i=0;
  516.               for (i=0; i< x->a.a_rank; i++)
  517.             {if (x->a.a_dims[i]!=y->a.a_dims[i])
  518.                return(FALSE);}}
  519.             if (x->a.a_dim != y->a.a_dim)
  520.               return(FALSE);
  521.             j=x->a.a_dim;
  522.             goto ARRAY;}
  523.         else
  524.             return(FALSE);
  525.     }
  526.     if (tx != ty)
  527.         return(FALSE);
  528.     switch (tx) {
  529.     case t_character:
  530.         return(char_equal(x, y));
  531.  
  532.     case t_cons:
  533.         if (!equalp(x->c.c_car, y->c.c_car))
  534.             return(FALSE);
  535.         x = x->c.c_cdr;
  536.         y = y->c.c_cdr;
  537.         goto BEGIN;
  538.  
  539.     case t_structure:
  540.         {
  541.         int i;
  542.         if (x->str.str_def != y->str.str_def)
  543.             return(FALSE);
  544.         {int leng= S_DATA(x->str.str_def)->length;
  545.          unsigned char *s_type= & SLOT_TYPE(x->str.str_def,0);
  546.          unsigned short *s_pos= & SLOT_POS(x->str.str_def,0);
  547.         for (i = 0;  i < leng;  i++,s_pos++)
  548.          {if (s_type[i]==0)
  549.            {if (!equalp(STREF(object,x,*s_pos),STREF(object,y,*s_pos)))
  550.                return FALSE;}
  551.           else
  552.            if (! (*s_pos & (sizeof(object)-1)))
  553.             switch(s_type[i]){
  554.             case aet_lf:
  555.              if(STREF(longfloat,x,*s_pos) != STREF(longfloat,y,*s_pos))
  556.             return(FALSE);
  557.               break;
  558.             case aet_sf:
  559.              if(STREF(shortfloat,x,*s_pos)!=STREF(shortfloat,y,*s_pos))
  560.             return(FALSE);
  561.               break;
  562.             default:
  563.               if(STREF(int,x,*s_pos)!=STREF(int,y,*s_pos))
  564.             return(FALSE);
  565.               break;}}
  566.         return(TRUE);
  567.     }}
  568.  
  569.     case t_pathname:
  570.         return(equal(x, y));
  571.     }
  572.     return(FALSE);
  573.  
  574. ARRAY:
  575.  
  576.     {
  577.         int i;
  578.  
  579.         vs_push(Cnil);
  580.         vs_push(Cnil);
  581.         for (i = 0;  i < j;  i++) {
  582.             vs_top[-2] = aref(x, i);
  583.             vs_top[-1] = aref(y, i);
  584.             if (!equalp(vs_top[-2], vs_top[-1])) {
  585.                 vs_pop;
  586.                 vs_pop;
  587.                 return(FALSE);
  588.             }
  589.         }
  590.         vs_pop;
  591.         vs_pop;
  592.         return(TRUE);
  593.     }
  594. }
  595.  
  596. Lequalp()
  597. {
  598.     check_arg(2);
  599.  
  600.     if (equalp(vs_base[0], vs_base[1]))
  601.         vs_base[0] = Ct;
  602.     else
  603.         vs_base[0] = Cnil;
  604.     vs_pop;
  605. }
  606.  
  607. Fand(args)
  608. object args;
  609. {
  610.     object *top = vs_top;
  611.  
  612.     if (endp(args)) {
  613.         vs_base = vs_top;
  614.         vs_push(Ct);
  615.         return;
  616.     }
  617.     while (!endp(MMcdr(args))) {
  618.         eval(MMcar(args));
  619.         if (vs_base[0] == Cnil) {
  620.             vs_base = vs_top = top;
  621.             vs_push(Cnil);
  622.             return;
  623.         }
  624.         vs_top = top;
  625.         args = MMcdr(args);
  626.     }
  627.     eval(MMcar(args));
  628. }
  629.  
  630. For(args)
  631. object args;
  632. {
  633.     object *top = vs_top;
  634.  
  635.     if (endp(args)) {
  636.         vs_base = vs_top;
  637.         vs_push(Cnil);
  638.         return;
  639.     }
  640.     while (!endp(MMcdr(args))) {
  641.         eval(MMcar(args));
  642.         if (vs_base[0] != Cnil) {
  643.             top[0] = vs_base[0];
  644.             vs_base = top;
  645.             vs_top = top+1;
  646.             return;
  647.         }
  648.         vs_top = top;
  649.         args = MMcdr(args);
  650.     }
  651.     eval(MMcar(args));
  652. }
  653.  
  654. /*
  655.     Contains_sharp_comma returns TRUE, iff the argument contains
  656.     a cons whose car is si:|#,| or a STRUCTURE.
  657.     Refer to the compiler about this magic.
  658. */
  659. bool
  660. contains_sharp_comma(x)
  661. object x;
  662. {
  663.     enum type tx;
  664.  
  665.     cs_check(x);
  666.  
  667. BEGIN:
  668.     tx = type_of(x);
  669.     if (tx == t_complex)
  670.         return(contains_sharp_comma(x->cmp.cmp_real) ||
  671.                contains_sharp_comma(x->cmp.cmp_imag));
  672.     if (tx == t_vector)
  673.     {
  674.         int i;
  675.        if (x->v.v_elttype == aet_object)
  676.         for (i = 0;  i < x->v.v_fillp;  i++)
  677.             if (contains_sharp_comma(x->v.v_self[i]))
  678.                 return(TRUE);
  679.         return(FALSE);
  680.     }
  681.     if (tx == t_cons) {
  682.         if (x->c.c_car == siSsharp_comma)
  683.             return(TRUE);
  684.         if (contains_sharp_comma(x->c.c_car))
  685.             return(TRUE);
  686.         x = x->c.c_cdr;
  687.         goto BEGIN;
  688.     }
  689.     if (tx == t_array)
  690.     {
  691.         int i, j;
  692.        if (x->a.a_elttype == aet_object) {
  693.         for (i = 0, j = 1;  i < x->a.a_rank;  i++)
  694.             j *= x->a.a_dims[i];
  695.         for (i = 0;  i < j;  i++)
  696.             if (contains_sharp_comma(x->a.a_self[i]))
  697.                 return(TRUE);
  698.           }
  699.         return(FALSE);
  700.     }
  701.     if (tx == t_structure)
  702.         return(TRUE);        /*  Oh, my god!  */
  703.     return(FALSE);
  704. }
  705.  
  706. siLcontains_sharp_comma()
  707. {
  708.     check_arg(1);
  709.  
  710.     if (contains_sharp_comma(vs_base[0]))
  711.         vs_base[0] = Ct;
  712.     else
  713.         vs_base[0] = Cnil;
  714. }
  715.  
  716. siLspicep()
  717. {
  718.     check_arg(1);
  719.     if (type_of(vs_base[0]) == t_spice)
  720.         vs_base[0] = Ct;
  721.     else
  722.         vs_base[0] = Cnil;
  723. }
  724.  
  725. siLfixnump()
  726. {
  727.     check_arg(1);
  728.     if (type_of(vs_base[0]) == t_fixnum)
  729.         vs_base[0] = Ct;
  730.     else
  731.         vs_base[0] = Cnil;
  732. }
  733.  
  734. init_predicate_function()
  735. {
  736.     make_function("NULL", Lnull);
  737.     make_function("SYMBOLP", Lsymbolp);
  738.     make_function("ATOM", Latom);
  739.     make_function("CONSP", Lconsp);
  740.     make_function("LISTP", Llistp);
  741.     make_function("NUMBERP", Lnumberp);
  742.     make_function("INTEGERP", Lintegerp);
  743.     make_function("RATIONALP", Lrationalp);
  744.     make_function("FLOATP", Lfloatp);
  745.     make_function("COMPLEXP", Lcomplexp);
  746.     make_function("CHARACTERP", Lcharacterp);
  747.     make_function("STRINGP", Lstringp);
  748.     make_function("BIT-VECTOR-P", Lbit_vector_p);
  749.     make_function("VECTORP", Lvectorp);
  750.     make_function("SIMPLE-STRING-P", Lsimple_string_p);
  751.     make_function("SIMPLE-BIT-VECTOR-P", Lsimple_bit_vector_p);
  752.     make_function("SIMPLE-VECTOR-P", Lsimple_vector_p);
  753.     make_function("ARRAYP", Larrayp);
  754.     make_function("PACKAGEP", Lpackagep);
  755.     make_function("FUNCTIONP", Lfunctionp);
  756.     make_function("COMPILED-FUNCTION-P", Lcompiled_function_p);
  757.     make_function("COMMONP", Lcommonp);
  758.  
  759.     make_function("EQ", Leq);
  760.     make_function("EQL", Leql);
  761.     make_function("EQUAL", Lequal);
  762.     make_function("EQUALP", Lequalp);
  763.  
  764.     make_function("NOT", Lnull);
  765.     make_special_form("AND",Fand);
  766.     make_special_form("OR",For);
  767.  
  768.     make_si_function("CONTAINS-SHARP-COMMA", siLcontains_sharp_comma);
  769.  
  770.     make_si_function("FIXNUMP", siLfixnump);
  771.     make_si_function("SPICEP", siLspicep);
  772. }
  773.