Index: /branches/arm/lisp-kernel/arm-constants.h
===================================================================
--- /branches/arm/lisp-kernel/arm-constants.h	(revision 13644)
+++ /branches/arm/lisp-kernel/arm-constants.h	(revision 13645)
@@ -24,9 +24,9 @@
 #define temp1 4
 #define temp2 5
-#define temp3 6
-#define fn    7
-#define rcontext 8
-#define imm0 9
-#define imm1 10
+#define fn    6
+#define rcontext 7
+#define imm0 8
+#define imm1 9
+#define imm2 10
 #define allocptr 11
 #define vsp 12
@@ -35,8 +35,8 @@
 #define pc 15
 
-#define fname temp3
+#define fname temp1
 #define nfn temp2
 #define next_method_context temp1
-#define nargs imm1
+#define nargs imm2
 #define allocbase temp0         /* while consing */
 
@@ -59,17 +59,4 @@
 #define node_shift 2
 
-#define TCR_FLAG_BIT_FOREIGN fixnumshift
-#define TCR_FLAG_BIT_AWAITING_PRESET (fixnumshift+1)
-#define TCR_FLAG_BIT_ALT_SUSPEND (fixnumshift+2)
-#define TCR_FLAG_BIT_PROPAGATE_EXCEPTION (fixnumshift+3)
-#define TCR_FLAG_BIT_SUSPEND_ACK_PENDING (fixnumshift+4)
-#define TCR_FLAG_BIT_PENDING_EXCEPTION (fixnumshift+5)
-#define TCR_FLAG_BIT_FOREIGN_EXCEPTION (fixnumshift+6)
-#define TCR_FLAG_BIT_PENDING_SUSPEND (fixnumshift+7)
-
-#define TCR_STATE_FOREIGN (1)
-#define TCR_STATE_LISP    (0)
-#define TCR_STATE_EXCEPTION_WAIT (2)
-#define TCR_STATE_EXCEPTION_RETURN (4)
 
 /*  Tags. */
@@ -107,12 +94,4 @@
 
 
-/*  Order of CAR and CDR doesn't seem to matter much - there aren't */
-/*  too many tricks to be played with predecrement/preincrement addressing. */
-/*  Keep them in the confusing MCL 3.0 order, to avoid confusion. */
-
-typedef struct cons {
-  LispObj cdr;
-  LispObj car;
-} cons;
 
 
@@ -227,22 +206,4 @@
 #define max_non_array_node_subtag ((19<<ntagbits)|fulltag_immheader)
 	
-/*  The objects themselves look something like this: */
-
-typedef struct lispsymbol {
-  LispObj header;
-  LispObj pname;
-  LispObj vcell;
-  LispObj fcell;
-  LispObj package_predicate;
-  LispObj flags;
-  LispObj plist;
-  LispObj binding_index;
-} lispsymbol;
-
-typedef struct ratio {
-  LispObj header;
-  LispObj numer;
-  LispObj denom;
-} ratio;
 
 typedef struct double_float {
@@ -258,62 +219,4 @@
 } single_float;
 
-typedef struct macptr {
-  LispObj header;
-  LispObj address;
-  LispObj class;
-  LispObj type;
-} macptr;
-
-typedef struct xmacptr {
-  LispObj header;
-  LispObj address;
-  LispObj class;
-  LispObj type;
-  LispObj flags;
-  LispObj link;
-} xmacptr;
-  
-
-typedef struct eabi_c_frame {
-  struct eabi_c_frame *backlink;
-  unsigned savelr;
-  unsigned params[8];
-} eabi_c_frame;
-
-/* PowerOpen ABI C frame */
-
-typedef struct c_frame {
-  struct c_frame *backlink;
-  unsigned crsave;
-  unsigned savelr;
-  unsigned unused[2];
-  unsigned savetoc;		/* Used with CFM */
-  unsigned params[8];		/* Space for callee to save r3-r10 */
-} c_frame;
-
-typedef struct lisp_frame {
-  struct lisp_frame *backlink;
-  LispObj savefn;
-  LispObj savelr;
-  LispObj savevsp;
-} lisp_frame;
-
-typedef struct special_binding {
-  struct special_binding *link;
-  struct lispsymbol *sym;
-  LispObj value;
-} special_binding;
-
-/* The GC (at least) needs to know what a
-   package looks like, so that it can do GCTWA. */
-typedef struct package {
-  LispObj header;
-  LispObj itab;			/* itab and etab look like (vector (fixnum . fixnum) */
-  LispObj etab;
-  LispObj used;
-  LispObj used_by;
-  LispObj names;
-  LispObj shadowed;
-} package;
 
 /*
@@ -352,95 +255,4 @@
 } xframe_list;
 
-#define fixnum_bitmask(n)  (1<<((n)+fixnumshift))
-
-/* 
-  The GC (at least) needs to know about hash-table-vectors and their flag bits.
-*/
-
-typedef struct hash_table_vector_header {
-  LispObj header;
-  LispObj link;                 /* If weak */
-  LispObj flags;                /* a fixnum; see below */
-  LispObj gc_count;             /* gc-count kernel global */
-  LispObj free_alist;           /* preallocated conses for finalization_alist */
-  LispObj finalization_alist;   /* key/value alist for finalization */
-  LispObj weak_deletions_count; /* incremented when GC deletes weak pair */
-  LispObj hash;                 /* backpointer to hash-table */
-  LispObj deleted_count;        /* number of deleted entries [not maintained if lock-free] */
-  LispObj count;                /* number of valid entries [not maintained if lock-free] */
-  LispObj cache_idx;            /* index of last cached pair */
-  LispObj cache_key;            /* value of last cached key */
-  LispObj cache_value;          /* last cached value */
-  LispObj size;                 /* number of entries in table */
-  LispObj size_reciprocal;      /* shifted reciprocal of size */
-} hash_table_vector_header;
-
-/*
-  Bits (masks)  in hash_table_vector.flags:
-*/
-
-/* GC should track keys when addresses change */ 
-#define nhash_track_keys_mask fixnum_bitmask(28) 
-
-/* GC should set when nhash_track_keys_bit & addresses change */
-#define nhash_key_moved_mask  fixnum_bitmask(27) 
-
-/* weak on key or value (need new "weak both" encoding.) */
-#define nhash_weak_mask       fixnum_bitmask(12)
-
-/* weak on value */
-#define nhash_weak_value_mask fixnum_bitmask(11)
-
-/* finalizable */
-#define nhash_finalizable_mask fixnum_bitmask(10)
-
-/* keys frozen, i.e. don't clobber keys, only values */
-#define nhash_keys_frozen_mask fixnum_bitmask(9)
-
-/* Lfun bits */
-
-#define lfbits_nonnullenv_mask fixnum_bitmask(0)
-#define lfbits_keys_mask fixnum_bitmask(1)
-#define lfbits_restv_mask fixnum_bitmask(7)
-#define lfbits_optinit_mask fixnum_bitmask(14)
-#define lfbits_rest_mask fixnum_bitmask(15)
-#define lfbits_aok_mask fixnum_bitmask(16)
-#define lfbits_lap_mask fixnum_bitmask(23)
-#define lfbits_trampoline_mask fixnum_bitmask(24)
-#define lfbits_evaluated_mask fixnum_bitmask(25)
-#define lfbits_cm_mask fixnum_bitmask(26)         /* combined_method */
-#define lfbits_nextmeth_mask fixnum_bitmask(26)   /* or call_next_method with method_mask */
-#define lfbits_gfn_mask fixnum_bitmask(27)        /* generic_function */
-#define lfbits_nextmeth_with_args_mask fixnum_bitmask(27)   /* or call_next_method_with_args with method_mask */
-#define lfbits_method_mask fixnum_bitmask(28)     /* method function */
-/* PPC only but want it defined for xcompile */
-#define lfbits_noname_mask fixnum_bitmask(29)
-
-
-/* Creole */
-
-#define doh_quantum 400
-#define doh_block_slots ((doh_quantum >> 2) - 3)
-
-typedef struct doh_block {
-  struct doh_block *link;
-  unsigned size;
-  unsigned free;
-  LispObj data[doh_block_slots];
-} doh_block, *doh_block_ptr;
-
-
-#define population_weak_list (0<<fixnum_shift)
-#define population_weak_alist (1<<fixnum_shift)
-#define population_termination_bit (16+fixnum_shift)
-#define population_type_mask ((1<<population_termination_bit)-1)
-
-#define gc_retain_pages_bit fixnum_bitmask(0)
-#define gc_integrity_check_bit fixnum_bitmask(2)
-#define egc_verbose_bit fixnum_bitmask(3)
-#define gc_verbose_bit fixnum_bitmask(4)
-#define gc_allow_stack_overflows_bit fixnum_bitmask(5)
-#define gc_postgc_pending fixnum_bitmask(26)
-
 #include "lisp-errors.h"
 
@@ -448,5 +260,5 @@
 
 
-#define nil_value (0x00003015+(LOWMEM_BIAS))
+#define nil_value (0x10000000+fulltag_nil)
 
 #define TCR_BIAS (0)
Index: /branches/arm/lisp-kernel/arm-constants.s
===================================================================
--- /branches/arm/lisp-kernel/arm-constants.s	(revision 13645)
+++ /branches/arm/lisp-kernel/arm-constants.s	(revision 13645)
@@ -0,0 +1,653 @@
+/*   Copyright (C) 2009 Clozure Associates */
+/*   Copyright (C) 1994-2001 Digitool, Inc */
+/*   This file is part of Clozure CL. */
+
+/*   Clozure CL is licensed under the terms of the Lisp Lesser GNU Public */
+/*   License , known as the LLGPL and distributed with Clozure CL as the */
+/*   file "LICENSE".  The LLGPL consists of a preamble and the LGPL, */
+/*   which is distributed with Clozure CL as the file "LGPL".  Where these */
+/*   conflict, the preamble takes precedence. */
+
+/*   Clozure CL is referenced in the preamble as the "LIBRARY." */
+
+/*   The LLGPL is also available online at */
+/*   http://opensource.franz.com/preamble.html */
+
+
+        
+nbits_in_word = 32
+nbits_in_byte = 8
+ntagbits = 3	/* But only 2 are significant to lisp */
+nlisptagbits = 2
+nfixnumtagbits = 2
+num_subtag_bits = 8
+fixnumshift = 2
+fixnum_shift = 2
+fulltagmask = 7
+tagmask = 3
+fixnummask = 3
+subtag_mask = 0xff        
+ncharcodebits = 24              /* arguably, we're only using the low 8 */
+charcode_shift = nbits_in_word-ncharcodebits
+word_shift = 2
+node_size = 4
+dnode_size = 8
+dnode_align_bits = 3
+dnode_shift = dnode_align_bits
+bitmap_shift = 5
+
+
+fixnumone = (1<<fixnumshift)
+fixnum_one = fixnumone
+fixnum1 = fixnumone
+
+/* registers.  These assignments may not be viable. */
+define(`arg_z',`r0')
+define(`arg_y',`r1')
+define(`arg_x',`r2')
+define(`temp0',`r3')
+define(`temp1',`r4')
+define(`temp2',`r5')
+define(`fn',`r6')
+define(`rcontext',`r7')
+define(`imm0',`r8')
+define(`imm1',`r9')
+define(`imm2',`r10')
+define(`allocptr',`r11')
+define(`vsp',`r12')
+define(`sp',`r13')
+define(`lr',`r14')
+define(`pc',`r15')
+
+define(`fname',`temp1')
+define(`nfn',`temp2')
+define(`next_method_context',`temp1')
+define(`nargs',`imm2')
+define(`allocbase',`temp0')     /* while consing */
+
+/* ARM conditions */
+eq = 0
+ne = 1
+cs = 2
+cc = 3
+mi = 4
+pl = 5
+vs = 6
+vc = 7
+hi = 8
+ls = 9
+ge = 10
+lt = 11
+gt = 12
+le = 13
+al = 14
+
+/* Tags. */
+/* There are two-bit tags and three-bit tags. */
+/* A FULLTAG is the value of the low three bits of a tagged object. */
+/* A TAG is the value of the low two bits of a tagged object. */
+/* A TYPECODE is either a TAG or the value of a "tag-misc" objects header-byte. */
+
+/* There are 4 primary TAG values.  Any object which lisp can "see" can be classified */
+/* by its TAG.  (Some headers have FULLTAGS that are congruent modulo 4 with the */
+/* TAGS of other objects, but lisp can't "see" headers.) */
+
+
+tag_fixnum = 0	/* All fixnums, whether odd or even */
+tag_list = 1	/* Conses and NIL */
+tag_misc = 2	/* Heap-consed objects other than lists: vectors, symbols, functions, floats ... */
+tag_imm = 3	/* Immediate-objects: characters, UNBOUND, other markers. */
+
+
+/*  And there are 8 FULLTAG values.  Note that NIL has its own FULLTAG (congruent mod 4 to tag-list), */
+/*  that FULLTAG-MISC is > 4 (so that code-vector entry-points can be branched to, since the low */
+/*  two bits of the PC are ignored) and that both FULLTAG-MISC and FULLTAG-IMM have header fulltags */
+/*  that share the same TAG. */
+/*  Things that walk memory (and the stack) have to be careful to look at the FULLTAG of each */
+/*  object that they see. */
+
+
+fulltag_even_fixnum = 0	/* I suppose EVENP/ODDP might care; nothing else does. */
+fulltag_cons = 1	/* a real (non_null) cons.  Shares TAG with fulltag_nil. */
+fulltag_nodeheader = 2	/* Header of heap_allocated object that contains lisp_object pointers */
+fulltag_imm = 3	/* a "real" immediate object.  Shares TAG with fulltag_immheader. */
+fulltag_odd_fixnum = 4	/* */
+fulltag_nil = 5	/* NIL and nothing but.  (Note that there's still a hidden NILSYM.) */
+fulltag_misc = 6	/* Pointer "real" tag_misc object.  Shares TAG with fulltag_nodeheader. */
+fulltag_immheader = 7	/* Header of heap-allocated object that contains unboxed data. */
+
+nil_value = (0x10000000+fulltag_nil)
+misc_bias = fulltag_misc
+cons_bias = tag_list        
+
+/* Functions are of (conceptually) unlimited size. */
+	_struct(_function,-misc_bias)
+	 _node(header)
+         _node(entrypoint)      /* codevector & ~tagmask */
+	 _node(codevector)
+	_ends
+
+	_struct(tsp_frame,0)
+	 _node(backlink)
+	 _node(type)
+	 _struct_label(fixed_overhead)
+	 _struct_label(data_offset)
+	_ends
+
+/* Order of CAR and CDR doesn't seem to matter much - there aren't */
+/* too many tricks to be played with predecrement/preincrement addressing. */
+/* Keep them in the confusing MCL 3.0 order, to avoid confusion. */
+	_struct(cons,-cons_bias)
+	 _node(cdr)
+	 _node(car)
+	_ends
+	
+misc_header_offset = -fulltag_misc
+misc_subtag_offset = misc_header_offset+3		/* low byte of header */
+misc_data_offset = misc_header_offset+4		/* first word of data */
+misc_dfloat_offset = misc_header_offset+8		/* double-floats are doubleword-aligned */
+
+max_64_bit_constant_index = ((0x7fff + misc_dfloat_offset)>>3)
+max_32_bit_constant_index = ((0x7fff + misc_data_offset)>>2)
+max_16_bit_constant_index = ((0x7fff + misc_data_offset)>>1)
+max_8_bit_constant_index = (0x7fff + misc_data_offset)
+max_1_bit_constant_index = ((0x7fff + misc_data_offset)<<5)
+
+/* T is almost adjacent to NIL: since NIL is a misaligned CONS, it spans */
+/* two doublewords.  The arithmetic difference between T and NIL is */
+/* such that the least-significant bit and exactly one other bit is */
+/* set in the result. */
+
+t_offset = (8+(8-fulltag_nil)+fulltag_misc)
+t_value = nil_value+t_offset
+
+/* The order in which various header values are defined is significant in several ways: */
+/* 1) Numeric subtags precede non-numeric ones; there are further orderings among numeric subtags. */
+/* 2) All subtags which denote CL arrays are preceded by those that don't, */
+/*    with a further ordering which requires that (< header-arrayH header-vectorH ,@all-other-CL-vector-types) */
+/* 3) The element-size of ivectors is determined by the ordering of ivector subtags. */
+/* 4) All subtags are >= fulltag-immheader . */
+
+define(`define_subtag',`
+subtag_$1 = $2|($3<<ntagbits)')
+	
+define(`define_imm_subtag',`
+	define_subtag($1,fulltag_immheader,$2)')
+
+	
+define(`define_node_subtag',`
+	define_subtag($1,fulltag_nodeheader,$2)')
+
+		
+/*Immediate subtags. */
+	define_subtag(character,fulltag_imm,9)
+	define_subtag(unbound,fulltag_imm,6)
+        define_subtag(illegal,fulltag_imm,10)
+	define_subtag(go_tag,fulltag_imm,12)
+	define_subtag(block_tag,fulltag_imm,24)
+	define_subtag(vsp_protect,fulltag_imm,7)
+        define_subtag(no_thread_local_binding,fulltag_imm,30)
+unbound_marker = subtag_unbound
+undefined = unbound_marker
+illegal_marker = subtag_illegal
+no_thread_local_binding_marker = subtag_no_thread_local_binding
+/*Numeric subtags. */
+
+	define_imm_subtag(bignum,0)
+min_numeric_subtag = subtag_bignum
+
+	define_node_subtag(ratio,1)
+max_rational_subtag = subtag_ratio
+
+	define_imm_subtag(single_float,1)
+	define_imm_subtag(double_float,2)
+min_float_subtag = subtag_single_float
+max_float_subtag = subtag_double_float
+max_real_subtag = subtag_double_float
+
+	define_node_subtag(complex,3)
+max_numeric_subtag = subtag_complex
+
+
+/* CL array types.  There are more immediate types than node types; all CL array subtags must be > than */
+/* all non-CL-array subtags.  So we start by defining the immediate subtags in decreasing order, starting */
+/* with that subtag whose element size isn't an integral number of bits and ending with those whose */
+/* element size - like all non-CL-array fulltag-immheader types - is 32 bits. */
+
+	define_imm_subtag(bit_vector,31)
+	define_imm_subtag(double_float_vector,30)
+	define_imm_subtag(s16_vector,29)
+	define_imm_subtag(u16_vector,28)
+min_16_bit_ivector_subtag = subtag_u16_vector
+max_16_bit_ivector_subtag = subtag_s16_vector
+	define_imm_subtag(s8_vector,26)
+	define_imm_subtag(u8_vector,25)
+min_8_bit_ivector_subtag = subtag_u8_vector
+max_8_bit_ivector_subtag = fulltag_immheader|(27<<ntagbits)
+        define_imm_subtag(simple_base_string,24)
+        define_imm_subtag(fixnum_vector,23)
+	define_imm_subtag(s32_vector,22)
+	define_imm_subtag(u32_vector,21)
+	define_imm_subtag(single_float_vector,20)
+max_32_bit_ivector_subtag = fulltag_immheader|(24<<ntagbits)
+min_cl_ivector_subtag = subtag_single_float_vector
+
+
+	define_node_subtag(vectorH,20)
+	define_node_subtag(arrayH,19)
+	define_node_subtag(simple_vector,21)
+min_vector_subtag = subtag_vectorH
+min_array_subtag = subtag_arrayH
+
+/* So, we get the remaining subtags (n: (n > max-numeric-subtag) & (n < min-array-subtag)) */
+/* for various immediate/node object types. */
+
+	define_imm_subtag(macptr,3)
+min_non_numeric_imm_subtag = subtag_macptr
+
+	define_imm_subtag(dead_macptr,4)
+	define_imm_subtag(code_vector,5)
+	define_imm_subtag(creole,6)
+
+max_non_array_imm_subtag = (18<<ntagbits)|fulltag_immheader
+
+	define_node_subtag(catch_frame,4)
+	define_node_subtag(function,5)
+	define_node_subtag(basic_stream,6)
+	define_node_subtag(symbol,7)
+	define_node_subtag(lock,8)
+	define_node_subtag(hash_vector,9)
+	define_node_subtag(pool,10)
+	define_node_subtag(weak,11)
+	define_node_subtag(package,12)
+	define_node_subtag(slot_vector,13)
+	define_node_subtag(instance,14)
+	define_node_subtag(struct,15)
+	define_node_subtag(istruct,16)
+	define_node_subtag(value_cell,17)
+        define_node_subtag(xfunction,18)
+max_non_array_node_subtag = (18<<ntagbits)|fulltag_immheader
+	
+/* The objects themselves look something like this: */
+	_structf(ratio)
+	 _node(numer)
+	 _node(denom)
+	_endstructf
+
+	_structf(single_float)
+	 _word(value)
+	_endstructf
+
+	_structf(double_float)
+	 _word(pad)
+	 _dword(value)
+	_endstructf
+
+	_structf(symbol)
+	 _node(pname)
+	 _node(vcell)
+	 _node(fcell)
+	 _node(package_predicate)
+	 _node(flags)
+         _node(plist)
+         _node(binding_index)
+	_endstructf
+
+	_structf(catch_frame)
+	 _node(catch_tag)	/* #<unbound> -> unwind-protect, else catch */
+	 _node(link)		/* backpointer to previous catch frame */
+	 _node(mvflag)		/* 0 if single-valued catch, fixnum 1 otherwise */
+	 _node(csp)		/* pointer to lisp_frame on csp */
+	 _node(db_link)		/* head of special-binding chain */
+	 _field(regs,8*node_size)	/* save7-save0 */
+	 _node(xframe)		/* exception frame chain */
+	 _node(tsp_segment)	/* maybe someday; padding for now */
+	_endstructf
+
+	_structf(macptr)
+	 _node(address)
+         _node(domain)
+         _node(type)
+	_endstructf
+
+	_structf(vectorH)
+	 _node(logsize)
+	 _node(physsize)
+	 _node(data_vector)
+	 _node(displacement)
+	 _node(flags)
+	_endstructf
+
+        _structf(arrayH)
+         _node(rank)
+         _node(physsize)
+         _node(data_vector)
+         _node(displacement)
+         _node(flags)
+         _struct_label(dim0)
+        _endstructf
+        
+	
+        	
+	_struct(lisp_frame,0)
+	 _node(backlink) 
+	 _node(savefn)	
+	 _node(savelr)	
+	 _node(savevsp)	
+	_ends
+	
+
+
+	_struct(vector,-fulltag_misc)
+	 _node(header)
+	 _struct_label(data)
+	_ends
+
+        _struct(binding,0)
+         _node(link)
+         _node(sym)
+         _node(val)
+        _ends
+
+
+
+symbol_extra = symbol.size-fulltag_misc
+	
+	_struct(nrs,nil_value-fulltag_nil)
+	 _struct_pad(fulltag_nil)
+	 _field(nilptr,16-fulltag_nil)
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(tsym)
+	 _struct_pad(symbol_extra)	/* t */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(nilsym)
+	 _struct_pad(symbol_extra)	/* nil */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(errdisp)
+	 _struct_pad(symbol_extra)	/* %err-disp */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(cmain)
+	 _struct_pad(symbol_extra)	/* cmain */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(eval)
+	 _struct_pad(symbol_extra)	/* eval */
+ 
+	 _struct_pad(fulltag_misc)
+	 _struct_label(appevalfn)
+	 _struct_pad(symbol_extra)	/* apply-evaluated-function */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(error)
+	 _struct_pad(symbol_extra)	/* error */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(defun)
+	 _struct_pad(symbol_extra)	/* %defun */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(defvar)
+	 _struct_pad(symbol_extra)	/* %defvar */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(defconstant)
+	 _struct_pad(symbol_extra)	/* %defconstant */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(macrosym)
+	 _struct_pad(symbol_extra)	/* %macro */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(kernelrestart)
+	 _struct_pad(symbol_extra)	/* %kernel-restart */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(package)
+	 _struct_pad(symbol_extra)	/* *package* */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(total_bytes_freed)		/* *total-bytes-freed* */
+	 _struct_pad(symbol_extra)
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(kallowotherkeys)
+	 _struct_pad(symbol_extra)	/* allow-other-keys */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(toplcatch)
+	 _struct_pad(symbol_extra)	/* %toplevel-catch% */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(toplfunc)
+	 _struct_pad(symbol_extra)	/* %toplevel-function% */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(callbacks)
+	 _struct_pad(symbol_extra)	/* %pascal-functions% */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(allmeteredfuns)
+	 _struct_pad(symbol_extra)	/* *all-metered-functions* */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(total_gc_microseconds)		/* *total-gc-microseconds* */
+	 _struct_pad(symbol_extra)
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(builtin_functions)		/* %builtin-functions% */
+	 _struct_pad(symbol_extra)                
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(udf)
+	 _struct_pad(symbol_extra)	/* %unbound-function% */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(init_misc)
+	 _struct_pad(symbol_extra)	/* %init-misc */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(macro_code)
+	 _struct_pad(symbol_extra)	/* %macro-code% */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(closure_code)
+	 _struct_pad(symbol_extra)      /* %closure-code% */
+
+       	 _struct_pad(fulltag_misc)
+	 _struct_label(new_gcable_ptr) /* %new-gcable-ptr */
+	 _struct_pad(symbol_extra)
+	
+       	 _struct_pad(fulltag_misc)
+	 _struct_label(gc_event_status_bits)
+	 _struct_pad(symbol_extra)	/* *gc-event-status-bits* */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(post_gc_hook)
+	 _struct_pad(symbol_extra)	/* *post-gc-hook* */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(handlers)
+	 _struct_pad(symbol_extra)	/* %handlers% */
+
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(all_packages)
+	 _struct_pad(symbol_extra)	/* %all-packages% */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(keyword_package)
+	 _struct_pad(symbol_extra)	/* *keyword-package* */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(finalization_alist)
+	 _struct_pad(symbol_extra)	/* %finalization-alist% */
+
+	 _struct_pad(fulltag_misc)
+	 _struct_label(foreign_thread_control)
+	 _struct_pad(symbol_extra)	/* %foreign-thread-control */
+
+	_ends
+
+define(`def_header',`
+$1 = ($2<<num_subtag_bits)|$3')
+
+	def_header(single_float_header,single_float.element_count,subtag_single_float)
+	def_header(double_float_header,double_float.element_count,subtag_double_float)
+	def_header(one_digit_bignum_header,1,subtag_bignum)
+	def_header(two_digit_bignum_header,2,subtag_bignum)
+	def_header(three_digit_bignum_header,3,subtag_bignum)
+	def_header(symbol_header,symbol.element_count,subtag_symbol)
+	def_header(value_cell_header,1,subtag_value_cell	)
+	def_header(macptr_header,macptr.element_count,subtag_macptr)
+	def_header(vectorH_header,vectorH.element_count,subtag_vectorH)
+
+	include(errors.s)
+
+/* Symbol bits that we care about */
+sym_vbit_bound = (0+fixnum_shift)
+sym_vbit_bound_mask = (1<<sym_vbit_bound)
+sym_vbit_const = (1+fixnum_shift)
+sym_vbit_const_mask = (1<<sym_vbit_const)
+
+	_struct(area,0)
+	 _node(pred) 
+	 _node(succ) 
+	 _node(low) 
+	 _node(high) 
+	 _node(active) 
+	 _node(softlimit) 
+	 _node(hardlimit) 
+	 _node(code) 
+	 _node(markbits) 
+	 _node(ndwords) 
+	 _node(older) 
+	 _node(younger) 
+	 _node(h) 
+	 _node(sofprot) 
+	 _node(hardprot) 
+	 _node(owner) 
+	 _node(refbits) 
+	 _node(nextref) 
+	_ends
+
+
+
+
+TCR_BIAS = 0
+/* TCR_BIAS = 0x7000 */
+        
+/*  Thread context record. */
+
+	_struct(tcr,-TCR_BIAS)
+	 _node(prev)		/* in doubly-linked list */
+	 _node(next)		/* in doubly-linked list */
+	 _node(lisp_fpscr)	/* lisp thread's fpscr (in low word) */
+	 _node(lisp_fpscr_low)
+	 _node(db_link)		/* special binding chain head */
+	 _node(catch_top)	/* top catch frame */
+	 _node(save_vsp)	/* VSP when in foreign code */
+	 _node(save_tsp)	/* TSP when in foreign code */
+	 _node(cs_area)		/* cstack area pointer */
+	 _node(vs_area)		/* vstack area pointer */
+	 _node(ts_area)		/* tstack area pointer */
+	 _node(cs_limit)	/* cstack overflow limit */
+	 _node(bytes_consed_high)
+	 _node(bytes_consed_low)
+	 _node(log2_allocation_quantum)
+	 _node(interrupt_pending)
+	 _node(xframe)		/* per-thread exception frame list */
+	 _node(errno_loc)	/* per-thread  errno location */
+	 _node(ffi_exception)	/* fpscr exception bits from ff-call */
+	 _node(osid)		/* OS thread id */
+         _node(valence)		/* odd when in foreign code */
+	 _node(foreign_exception_status)
+	 _node(native_thread_info)
+	 _node(native_thread_id)
+	 _node(last_allocptr)
+	 _node(save_allocptr)
+	 _node(save_allocbase)
+	 _node(reset_completion)
+	 _node(activate)
+         _node(suspend_count)
+         _node(suspend_context)
+	 _node(pending_exception_context)
+	 _node(suspend)		/* semaphore for suspension notify */
+	 _node(resume)		/* sempahore for resumption notify */
+	 _node(flags)      
+	 _node(gc_context)
+         _node(termination_semaphore)
+         _node(unwinding)
+         _node(tlb_limit)
+         _node(tlb_pointer)     /* Consider using tcr+N as tlb_pointer */
+	 _node(shutdown_count)
+         _node(safe_ref_address)
+	_ends
+
+TCR_FLAG_BIT_FOREIGN = fixnum_shift
+TCR_FLAG_BIT_AWAITING_PRESET = (fixnum_shift+1)
+TCR_FLAG_BIT_ALT_SUSPEND = (fixnumshift+2)
+TCR_FLAG_BIT_PROPAGATE_EXCEPTION = (fixnumshift+3)
+TCR_FLAG_BIT_SUSPEND_ACK_PENDING = (fixnumshift+4)
+TCR_FLAG_BIT_PENDING_EXCEPTION = (fixnumshift+5)
+TCR_FLAG_BIT_FOREIGN_EXCEPTION = (fixnumshift+6)
+TCR_FLAG_BIT_PENDING_SUSPEND = (fixnumshift+7)        
+	
+r0 = 0
+r1 = 1
+r2 = 2
+r3 = 3
+r4 = 4
+r5 = 5
+r6 = 6
+r7 = 7
+r8 = 8
+r9 = 9
+r10 = 10
+r11 = 11
+r12 = 12
+r13 = 13
+sp = 13        
+r14 = 14
+lr = 14
+r15 = 15
+pc = 15
+        
+        
+/* Lisp code keeps 0.0 in fp_zero */
+define(`fp_zero',`f31')   /* a non-volatile reg as far as FFI is concerned. */
+define(`fp_s32conv',`f30')   /* for s32->fp conversion */
+	
+/* registers, as used in destrucuring-bind/macro-bind */
+
+define(`whole_reg',`temp1')
+define(`arg_reg',`temp3')
+define(`keyvect_reg',`temp2')
+define(`mask_req_start',`24')
+define(`mask_req_width',`8')
+define(`mask_opt_start',`16')
+define(`mask_opt_width',`8')
+define(`mask_key_start',`8')
+define(`mask_key_width',`8')
+define(`mask_initopt',`7')
+define(`mask_keyp',`6') /*  note that keyp can be true even when 0 keys. */
+define(`mask_aok',`5')
+define(`mask_restp',`4')
+
+define(`STACK_ALIGN',8)
+define(`STACK_ALIGN_MASK',7)
+
+
+define(`TCR_STATE_FOREIGN',1)
+define(`TCR_STATE_LISP',0)
+define(`TCR_STATE_EXCEPTION_WAIT',2)
+define(`TCR_STATE_EXCEPTION_RETURN',4)
+
+define(`RESERVATION_DISCHARGE',0x2004)
+
+lisp_globals_limit = (0x3010+(LOWMEM_BIAS))
+        
+INTERRUPT_LEVEL_BINDING_INDEX = fixnumone
Index: /branches/arm/lisp-kernel/arm-macros.s
===================================================================
--- /branches/arm/lisp-kernel/arm-macros.s	(revision 13644)
+++ /branches/arm/lisp-kernel/arm-macros.s	(revision 13645)
@@ -58,9 +58,9 @@
 
 define(`box_fixnum',`
-        __(mov #1,$2 lsl #fixnumshift)
+        __(mov #1,$2, lsl #fixnumshift)
 	')
 
 define(`unbox_fixnum',`	
-	__(mov $1,$2 asr #fixnumshift)
+	__(mov $1,$2, asr #fixnumshift)
 	')
 
@@ -72,20 +72,19 @@
 	')
 
-define(`push',`
-	__(stru($1,-node_size($2)))
+define(`push1',`
+        __(str $1,[$2,#-node_size]!)
 	')
 	
 	/* Generally not a great idea. */
-define(`pop',`
-	__(ldr($1,0($2)))
-	__(la $2,node_size($2))
-	')
-	
-define(`vpush',`
-	__(push($1,vsp))
-	')
-	
-define(`vpop',`
-	__(pop($1,vsp))
+define(`pop1',`
+        __(ldr $1,[$2],#node_size)
+	')
+	
+define(`vpush1',`
+	__(push1($1,vsp))
+	')
+	
+define(`vpop1',`
+	__(pop1($1,vsp))
 	')
 	
@@ -106,5 +105,5 @@
 
 define(`vref32',`
-	__(lwz $1,misc_data_offset+(($3)<<2)($2))
+        __(ldr #1,[$2,#misc_data_offset+(($3)<<2)])
 	')
         
@@ -113,17 +112,9 @@
 	')
 	
-ifdef(`PPC64',`
-        define(`vref64',`
-        __(ld $1,misc_data_offset+(($3)<<3)($2))
-	')
-
-        define(`vrefr',`
-        __(vref64($1,$2,$3))
-	')
-',`
-        define(`vrefr',`
+define(`vrefr',`
         __(vref32($1,$2,$3))
 	')
-')
+
+
         
                 	
@@ -132,25 +123,13 @@
 	')
 	
-	/* Size is unboxed element count */
-define(`header_size',`
-	__(srri($1,$2,num_subtag_bits))
-	')
 	
 	/* "Length" is fixnum element count */
 define(`header_length',`
-ifdef(`PPC64',`
-        __(rldicr $1,$2,nbits_in_word-(num_subtag_bits-nfixnumtagbits),63-nfixnumtagbits)
-        __(clrldi $1,$1,(num_subtag_bits-nfixnumtagbits))
-        ',`               
-	__(rlwinm $1,$2,nbits_in_word-(num_subtag_bits-nfixnumtagbits),(num_subtag_bits-nfixnumtagbits),31-nfixnumtagbits)
+        mov $1,#-1<<fixnumshift
+        and $1,$1,$2,lsr #num_subtag_bits-fixnumshift
         ')
 ')        
 
 
-define(`vector_size',`
-	__(getvheader(ifelse($3.`',$1,$3),$2))
-	__(header_size($1,ifelse($3.`',$1,$3)))
-	')
-	
 define(`vector_length',`
 	__(getvheader($3,$2))
@@ -193,12 +172,9 @@
 	/* vpop argregs - nargs is known to be non-zero */
 define(`vpop_argregs_nz',`
-	new_macro_labels()
-	__(cmplri(cr1,nargs,node_size*2))
-	__(vpop(arg_z))
-	__(blt cr1,macro_label(l0))
-	__(vpop(arg_y))
-	__(bne cr1,macro_label(l0))
-	__(vpop(arg_x))
-macro_label(l0):')
+        __(cmp nargs,#node_size*2)
+        __(vpop1(arg_z))
+        __(ldrhs arg_y,[vsp],#node_size)
+        __(ldrhi arg_x,[vsp],#node_size)
+        ')
 
                 
@@ -238,45 +214,19 @@
 	
 define(`_car',`
-	__(ldr($1,cons.car($2)))
+        __(ldr $1,[$2,#cons.car])
 ')
 	
 define(`_cdr',`
-	__(ldr($1,cons.cdr($2)))
+        __(ldr $1,[$2,#cons.cdr])
 	')
 	
 define(`_rplaca',`
-	__(str($2,cons.car($1)))
+        __(str $2,[$1,#cons.car])
 	')
 	
 define(`_rplacd',`
-	__(str($2,cons.cdr($1)))
-	')
-
-define(`vpush_saveregs',`
-	__(vpush(save7))
-	__(vpush(save6))
-	__(vpush(save5))
-	__(vpush(save4))
-	__(vpush(save3))
-	__(vpush(save2))
-	__(vpush(save1))
-	__(vpush(save0))
-	')
-	
-define(`restore_saveregs',`
-	__(ldr(save0,node_size*0($1)))
-	__(ldr(save1,node_size*1($1)))
-	__(ldr(save2,node_size*2($1)))
-	__(ldr(save3,node_size*3($1)))
-	__(ldr(save4,node_size*4($1)))
-	__(ldr(save5,node_size*5($1)))
-	__(ldr(save6,node_size*6($1)))
-	__(ldr(save7,node_size*7($1)))
-')
-
-define(`vpop_saveregs',`
-	__(restore_saveregs(vsp))
-	__(la vsp,node_size*8(vsp))
-')
+        __(str $2,[$1,#cons.cdr])
+	')
+
 
 define(`trap_unless_lisptag_equal',`
@@ -285,17 +235,6 @@
 ')
 
-ifdef(`PPC64',`
-define(`trap_unless_list',`
-	new_macro_labels()
-	__(cmpdi ifelse($3,$3,cr0),$1,nil_value)
-	__(extract_fulltag($2,$1))
-	__(beq ifelse($3,$3,cr0),macro_label(is_list))
-	__(tdnei $2,fulltag_cons)
-macro_label(is_list):	
-
-')',`	
 define(`trap_unless_list',`
 	__(trap_unless_lisptag_equal($1,tag_list,$2))
-')
 ')
 
@@ -312,14 +251,11 @@
 /* "jump" to the code-vector of the function in nfn. */
 define(`jump_nfn',`
-	__(ldr(temp0,_function.codevector(nfn)))
-	__(mtctr temp0)
-	__(bctr)
+        __(ldr pc,[nfn,#_function.codevector])
 ')
 
 /* "call the code-vector of the function in nfn. */
 define(`call_nfn',`
-	__(ldr(temp0,_function.codevector(nfn)))
-	__(mtctr temp0)
-	__(bctrl)
+        __(ldr lr,[nfn,#_function.codevector])
+        __(blx lr)
 ')
 	
@@ -327,5 +263,5 @@
 /* "jump" to the function in fnames function cell. */
 define(`jump_fname',`
-	__(ldr(nfn,symbol.fcell(fname)))
+	__(ldr nfn,[fname,#symbol.fcell])
 	__(jump_nfn())
 ')
@@ -333,25 +269,17 @@
 /* call the function in fnames function cell. */
 define(`call_fname',`
-	__(ldr(nfn,symbol.fcell(fname)))
+	__(ldr nfn,[fname,#symbol.fcell])
 	__(call_nfn())
 ')
 
-define(`do_funcall',`
-	new_macro_labels()
-	__(extract_fulltag(imm0,temp0))
-	__(cmpri(imm0,fulltag_misc))
-	__(mr nfn,temp0)
-	__(bne- macro_label(bad))
-	__(extract_subtag(imm0,temp0))
-	__(cmpri(imm0,subtag_function))
-	__(cmpri(cr1,imm0,subtag_symbol))
-        __(bne cr0,macro_label(_sym))
-        __(jump_nfn())
-macro_label(_sym):             
-	__(mr fname,temp0)
-	__(bne cr1,macro_label(bad))
-	__(jump_fname())
-macro_label(bad):
-	__(uuo_interr(error_cant_call,temp0))
+define(`funcall_nfn',`
+        __(extract_typecode(imm0,nfn))
+        __(cmp imm0,#subtag_symbol)
+        __(moveq fname,nfn)
+        __(ldreq nfn,[fname,#symbol.fcell])
+        __(cmpne imm0,#subtag_function)
+        __(ldreq pc,[nfn,#_function.entrypoint])
+        __(uuo_error_cant_call(nfn,al))
+
 ')	
 
@@ -393,18 +321,5 @@
 ')	
 
-define(`restore_catch_nvrs',`
-        __(ldr(first_nvr,catch_frame.regs+(node_size*0)($1)))
-        __(ldr(second_nvr,catch_frame.regs+(node_size*1)($1)))
-        __(ldr(third_nvr,catch_frame.regs+(node_size*2)($1)))
-        __(ldr(fourth_nvr,catch_frame.regs+(node_size*3)($1)))
-        __(ldr(fifth_nvr,catch_frame.regs+(node_size*4)($1)))
-        __(ldr(sixth_nvr,catch_frame.regs+(node_size*5)($1)))
-        __(ldr(seventh_nvr,catch_frame.regs+(node_size*6)($1)))
-        __(ldr(eighth_nvr,catch_frame.regs+(node_size*7)($1)))
-')               
-
-define(`DCBZL',`
-	__(.long (31<<26)+(1<<21)+($1<<16)+($2<<11)+(1014<<1))
-')
+
 	
 define(`check_stack_alignment',`
@@ -419,31 +334,15 @@
 
 define(`clear_alloc_tag',`
-	__(clrrri(allocptr,allocptr,ntagbits))
-')
-
-/* If the GC interrupts the current thread (after the trap), it needs */
-/*   to ensure that the cons cell that's been "reserved" stays reserved */
-/*   (e.g. the tagged allocptr has to be treated as a node.)  If that */
-/*   reserved cons cell gets tenured, the car and cdr are of a generation */
-/*   that's at least as old (so memoization isn't an issue.) */
-
-/*   More generally, if the GC interrupts a thread when allocptr is */
-/*   tagged as a cons: */
-
-/*    a) if the trap hasn't been taken (yet), the GC should force the */
-/*       thread to resume in such a way that the trap will be taken ; */
-/*       the segment allocator should worry about allocating the object. */
-
-/*    b) If the trap has been taken, allocptr is treated as a node as */
-/*       described above.  Allocbase is made to point to the base of the */
-/*       cons cell, so that the thread's next allocation attempt will */
-/*       invoke the segment allocator. */
-	
+        __(bic allocptr,allocptr,#fulltagmask)
+')
+
 define(`Cons',`
-	__(la allocptr,(-cons.size+fulltag_cons)(allocptr))
-        __(alloc_trap())
-	__(str($3,cons.cdr(allocptr)))
-	__(str($2,cons.car(allocptr)))
-	__(mr $1,allocptr)
+        __(ldr allocbase,[rcontext,#tcr.save_allocbase])
+        __(add allocptr,allocptr,#-cons.size+fulltag_cons)
+        __(cmp allocptr,allocbase)
+        __(uuo_alloc_trap(lo))
+        __(str $3,[allocptr,#cons.cdr])
+        __(str $2,[allocptr,#cons.car])
+        __(mov $1,allocptr)
 	__(clear_alloc_tag())
 ')
Index: /branches/arm/lisp-kernel/linuxarm/Makefile
===================================================================
--- /branches/arm/lisp-kernel/linuxarm/Makefile	(revision 13645)
+++ /branches/arm/lisp-kernel/linuxarm/Makefile	(revision 13645)
@@ -0,0 +1,107 @@
+#
+#   Copyright (C) 1994-2001 Digitool, Inc
+#   This file is part of Clozure CL.  
+#
+#   Clozure CL is licensed under the terms of the Lisp Lesser GNU Public
+#   License , known as the LLGPL and distributed with Clozure CL as the
+#   file "LICENSE".  The LLGPL consists of a preamble and the LGPL,
+#   which is distributed with Clozure CL as the file "LGPL".  Where these
+#   conflict, the preamble takes precedence.  
+#
+#   Clozure CL is referenced in the preamble as the "LIBRARY."
+#
+#   The LLGPL is also available online at
+#   http://opensource.franz.com/preamble.html
+
+
+VPATH = ../
+RM = /bin/rm
+# Versions of GNU as >= 2.9.1 all seem to work
+# AS = gas-2.9.1
+AS = as
+M4 = m4
+ASFLAGS =
+M4FLAGS = -DLINUX -DARM
+CDEFINES = -DLINUX -DARM -D_REENTRANT -D_GNU_SOURCE
+CDEBUG = -g
+COPT = -O2
+# Once in a while, -Wformat says something useful.  The odds are against that,
+# however.
+WFORMAT = -Wno-format
+
+# If the linker supports a "--hash-style=" option, use traditional
+# Sysv hash tables.  (If it doesn't support that option, assume
+# that traditional hash tables will be used by default.)
+ld_has_hash_style = $(shell $(LD) --help | grep "hash-style=")
+ifeq ($(ld_has_hash_style),)
+HASH_STYLE=
+else
+HASH_STYLE="-Wl,--hash-style=sysv"
+endif
+
+# The only version of GCC I have that supports both ppc32 and ppc64
+# compilation uses the -m32 option to target ppc32.  This may not be
+# definitive; there seem to be a bewildering array of similar options
+# in other GCC versions.  It's assumed here that if "-m32" is recognized,
+# it's required as well.
+
+PPC32 = $(shell ($(CC) --help -v 2>&1 | grep -q -e "-m32 ") && /bin/echo "-m32")
+
+# Likewise, some versions of GAS may need a "-a32" flag, to force the
+# output file to be 32-bit compatible.
+
+A32 = $(shell ($(AS) --help -v 2>&1 | grep -q -e "-a32") && /bin/echo "-a32")
+
+.s.o:
+	$(M4) $(M4FLAGS) -I../ $< | $(AS) $(A32) $(ASFLAGS) -o $@
+.c.o:
+	$(CC) -c $< $(CDEFINES) $(CDEBUG) $(COPT) $(WFORMAT) $(PPC32) -o $@
+
+SPOBJ = pad.o arm-spjump.o arm-spentry.o arm-subprims.o
+ASMOBJ = arm-asmutils.o imports.o
+
+COBJ  = pmcl-kernel.o gc-common.o arm-gc.o bits.o  arm-exceptions.o \
+	image.o thread_manager.o lisp-debug.o memory.o unix-calls.o
+
+DEBUGOBJ = lispdcmd.o plprint.o plsym.o plbt.o ppc_print.o
+KERNELOBJ= $(COBJ) ppc-asmutils.o  imports.o
+
+SPINC =	lisp.s m4macros.m4 arm-constants.s arm-macros.s errors.s arm-uuo.s
+
+CHEADERS = area.h bits.h arm-constants.h lisp-errors.h gc.h lisp.h \
+	lisp-exceptions.h lisp_globals.h macros.h memprotect.h image.h \
+	Threads.h arm-exceptions.h
+
+# Subprims linked into the kernel ?
+# Yes:
+
+KSPOBJ = $(SPOBJ)
+all:	../../armcl
+
+
+# No:
+
+# KSPOBJ=
+# all:	../../ppccl ../../subprims.so
+
+OSLIBS = -ldl -lm -lpthread
+
+
+../../armcl:	$(KSPOBJ) $(KERNELOBJ) $(DEBUGOBJ)
+	$(CC) $(PPC32) $(CDEBUG)  -Wl,--export-dynamic $(HASH_STYLE) -o $@ -T ./elf32ppclinux.x $(KSPOBJ) $(KERNELOBJ) $(DEBUGOBJ) $(OSLIBS)
+
+
+$(SPOBJ): $(SPINC)
+$(ASMOBJ): $(SPINC)
+$(COBJ): $(CHEADERS)
+$(DEBUGOBJ): $(CHEADERS) lispdcmd.h
+
+
+cclean:
+	$(RM) -f $(KERNELOBJ) $(DEBUGOBJ) ../../ppccl
+
+clean:	cclean
+	$(RM) -f $(SPOBJ)
+
+strip:	../../ppccl
+	strip -g ../../ppccl