aboutsummaryrefslogtreecommitdiffstats
path: root/scm.h
blob: 504f8499f56d67c59577e0d68904a8865ed0bee0 (plain)
1
2
3
4
5
6
7
8
9
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
/* Copyright (C) 1990-1999 Free Software Foundation, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; see the file COPYING.  If not, write to
 * the Free Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111, USA.
 *
 * As a special exception, the Free Software Foundation gives permission
 * for additional uses of the text contained in its release of SCM.
 *
 * The exception is that, if you link the SCM library with other files
 * to produce an executable, this does not by itself cause the
 * resulting executable to be covered by the GNU General Public License.
 * Your use of that executable is in no way restricted on account of
 * linking the SCM library code into it.
 *
 * This exception does not however invalidate any other reasons why
 * the executable file might be covered by the GNU General Public License.
 *
 * This exception applies only to the code released by the
 * Free Software Foundation under the name SCM.  If you copy
 * code from other Free Software Foundation releases into a copy of
 * SCM, as the General Public License permits, the exception does
 * not apply to the code that you add in this way.  To avoid misleading
 * anyone as to the status of such modified files, you must delete
 * this exception notice from them.
 *
 * If you write modifications of your own for SCM, it is your choice
 * whether to permit this exception to apply to your modifications.
 * If you do not wish that, delete this exception notice.
 */

/* "scm.h" SCM data types and external functions. */

#ifdef __cplusplus
extern "C" {
#endif

#ifdef _WIN32
# include <windows.h>
#endif

#ifdef _WIN32_WCE
# include <windows.h>
#endif

#ifdef hpux
# ifndef __GNUC__
#  define const /**/
# endif
#endif

#ifdef PLAN9
# include <u.h>
# include <libc.h>
/* Simple imitation of some Unix system calls */
# define exit(val) exits("")
# define getcwd getwd
/* we have our own isatty */
int isatty (int);
#endif

typedef long SCM;
typedef struct {SCM car, cdr;} cell;
typedef struct {long sname;SCM (*cproc)();} subr;
typedef struct {long sname;double (*dproc)();} dsubr;
typedef struct {const char *string;SCM (*cproc)();} iproc;
typedef struct {const char *name;} subr_info;

#include <stdio.h>
#include "scmfig.h"

#ifdef _WIN32
# ifdef DLLSCM
#  define SCM_DLL_EXPORT __declspec(dllexport)
#  define SCM_DLL_IMPORT __declspec(dllimport)  
#  ifdef SCM_DLL
#   define SCM_EXPORT SCM_DLL_EXPORT
#  else
#   define SCM_EXPORT SCM_DLL_IMPORT
#  endif
# else
#  define SCM_DLL_EXPORT /**/
#  define SCM_DLL_IMPORT extern
#  define SCM_EXPORT extern
# endif 
#else
# define SCM_DLL_EXPORT /**/
# define SCM_DLL_IMPORT extern
# define SCM_EXPORT extern
#endif


typedef struct {
  sizet eltsize;
  sizet len;
  sizet alloclen;
  sizet maxlen;
  char *what;
  char *elts;} scm_gra;

#ifdef USE_ANSI_PROTOTYPES
# define P(s) s
#else
# define P(s) ()
#endif

#ifndef STDC_HEADERS
	int isatty P((int));
#endif

typedef struct {
  SCM	(*mark)P((SCM));
  sizet	(*free)P((CELLPTR));
  int	(*print)P((SCM exp, SCM port, int writing));
  SCM	(*equalp)P((SCM, SCM));
} smobfuns;

typedef struct {
  char	*name;
  SCM	(*mark)P((SCM ptr));
  int	(*free)P((FILE *p));
  int	(*print)P((SCM exp, SCM port, int writing));
  SCM	(*equalp)P((SCM, SCM));
  int	(*fputc)P((int c, FILE *p));
/*    int	(*fputs)P((char *s, FILE *p)); */
/*    sizet	(*fwrite)P((char *s, sizet siz, sizet num, FILE *p)); */
  int	(*fputs)P((const char *s, FILE *p));
  sizet (*fwrite)P((const void *s, sizet siz, sizet num, FILE *p));
  int	(*fflush)P((FILE *stream));
  int	(*fgetc)P((FILE *p));
  int	(*fclose)P((FILE *p));
  int	(*ungetc)P((int c, SCM p));
} ptobfuns;

typedef struct {
  SCM data;
  SCM port;
  long flags;
  long line;
  int unread;
  short col;
  short colprev;
} port_info;

typedef struct {
  SCM v;
  sizet base;
} array;
typedef struct {
  long lbnd;
  long ubnd;
  long inc;
} array_dim;

#ifdef FLOATS
typedef struct {char *string;double (*cproc)P((double));} dblproc;
# ifdef SINGLES
#  ifdef CDR_DOUBLES
typedef struct {SCM type;double num;} flo;
#  else
typedef struct {SCM type;float num;} flo;
#  endif
# endif
typedef struct {SCM type;double *real;} dbl;
#endif

#define IMP(x) (6 & (int)(x))
#define NIMP(x) (!IMP(x))

#define INUMP(x) (2 & (int)(x))
#define NINUMP(x) (!INUMP(x))
#define INUM0 ((SCM) 2)
#define ICHRP(x) ((0xff & (int)(x))==0xf4)
#define ICHR(x) ((unsigned char)((x)>>8))
#define MAKICHR(x) (((x)<<8)+0xf4L)

#define ILOC00	(0x000000fcL)
#define ILOCP(n) ((0xff & (int)(n))==(int)ILOC00)
#define MAKILOC(if, id) (ILOC00 + (((long)id)<<8) + (((long)if)<<16))
#define IDIST(n) (((int)(n)>>8) & 0x7f)
#define IFRAME(n) (((int)(n)>>16))
#define ICDRP(n) (ICDR & (n))
#define ICDR (1L<<15)

/* ISYMP tests for ISPCSYM and ISYM */
#define ISYMP(n) ((0x187 & (int)(n))==4)
/* IFLAGP tests for ISPCSYM, ISYM and IFLAG */
#define IFLAGP(n) ((0x87 & (int)(n))==4)
#define ISYMNUM(n) (((int)((n)>>9)) & 0x7f)
#define ISYMVAL(n) ((int)((n)>>16))
#define MAKISYMVAL(isym, val) ((isym) | ((long)(val) <<16))
#define ISYMCHARS(n) (isymnames[ISYMNUM(n)])
#define MAKSPCSYM(n) (((n)<<9)+((n)<<3)+4L)
#define MAKISYM(n) (((n)<<9)+0x74L)
#define MAKIFLAG(n) (((n)<<9)+0x174L)
/* This is to make the print representation of some evaluated code,
   as in backtraces, make a little more sense. */
#define MAKSPCSYM2(work, look) ((127L & (work)) | ((127L<<9) & (look)))

SCM_EXPORT char *isymnames[];
#define NUM_ISPCSYM 14
#define IM_AND MAKSPCSYM(0)
#define IM_BEGIN MAKSPCSYM(1)
#define IM_CASE MAKSPCSYM(2)
#define IM_COND MAKSPCSYM(3)
#define IM_DO MAKSPCSYM(4)
#define IM_IF MAKSPCSYM(5)
#define IM_LAMBDA MAKSPCSYM(6)
#define IM_LET MAKSPCSYM(7)
#define IM_LETSTAR MAKSPCSYM(8)
#define IM_LETREC MAKSPCSYM(9)
#define IM_OR MAKSPCSYM(10)
#define IM_QUOTE MAKSPCSYM(11)
#define IM_SET MAKSPCSYM(12)
#define IM_FUNCALL MAKSPCSYM(13)

#define s_and (ISYMCHARS(IM_AND)+2)
#define s_begin (ISYMCHARS(IM_BEGIN)+2)
#define s_case (ISYMCHARS(IM_CASE)+2)
#define s_cond (ISYMCHARS(IM_COND)+2)
#define s_do (ISYMCHARS(IM_DO)+2)
#define s_if (ISYMCHARS(IM_IF)+2)
#define s_lambda (ISYMCHARS(IM_LAMBDA)+2)
#define s_let (ISYMCHARS(IM_LET)+2)
#define s_letstar (ISYMCHARS(IM_LETSTAR)+2)
#define s_letrec (ISYMCHARS(IM_LETREC)+2)
#define s_or (ISYMCHARS(IM_OR)+2)
#define s_quote (ISYMCHARS(IM_QUOTE)+2)
#define s_set (ISYMCHARS(IM_SET)+2)
#define s_define (ISYMCHARS(IM_DEFINE)+2)
#define s_delay (ISYMCHARS(IM_DELAY)+2)
#define s_quasiquote (ISYMCHARS(IM_QUASIQUOTE)+2)
#define s_let_syntax (ISYMCHARS(IM_LET_SYNTAX)+2)

SCM_EXPORT SCM i_dot, i_quote, i_quasiquote, i_unquote, i_uq_splicing;
#define s_apply (ISYMCHARS(IM_APPLY)+2)

/* each symbol defined here must have a unique number which
   corresponds to it's position in isymnames[] in repl.c */
  /* These are used for dispatch in eval.c */
#define IM_APPLY MAKISYM(14)
#define IM_FARLOC_CAR MAKISYM(15)
#define IM_FARLOC_CDR MAKISYM(16)
#define IM_DELAY MAKISYM(17)
#define IM_QUASIQUOTE MAKISYM(18)
#define IM_EVAL_FOR_APPLY MAKISYM(19)
#define IM_LET_SYNTAX MAKISYM(20)
#define IM_ACRO_CALL MAKISYM(21)
#define IM_LINUM MAKISYM(22)
#define IM_DEFINE MAKISYM(23)

  /* These are not used for dispatch. */
#define IM_UNQUOTE MAKISYM(24)
#define IM_UQ_SPLICING MAKISYM(25)
#define IM_ELSE MAKISYM(26)
#define IM_ARROW MAKISYM(27)
#define IM_VALUES_TOKEN MAKISYM(28)
#define IM_KEYWORD MAKISYM(29)

#define SCM_MAKE_LINUM(n) (IM_LINUM | ((unsigned long)(n))<<16)
#define SCM_LINUM(x) ((unsigned long)(x)>>16)
#define SCM_LINUMP(x) ((0xffffL & (x))==IM_LINUM)

#define NUM_ISYMS 30

#define BOOL_F MAKIFLAG(NUM_ISYMS+0)
#define BOOL_T MAKIFLAG(NUM_ISYMS+1)
#define UNDEFINED MAKIFLAG(NUM_ISYMS+2)
#define EOF_VAL MAKIFLAG(NUM_ISYMS+3)
#ifdef SICP
# define EOL BOOL_F
#else
# define EOL MAKIFLAG(NUM_ISYMS+4)
#endif
#define UNSPECIFIED MAKIFLAG(NUM_ISYMS+5)
#define NUM_IFLAGS NUM_ISYMS+6

/* Now some unnamed flags used as magic cookies by scm_top_level. */
/* Argument n can range from -4 to 16 */
#ifdef SHORT_INT
# define COOKIE(n) (n)
# define UNCOOK(f) (f)
#else
# define COOKIE(n) MAKIFLAG(NUM_IFLAGS+4+n)
# define UNCOOK(f) (ISYMNUM(f)-(NUM_IFLAGS+4))
#endif

#define FALSEP(x) (BOOL_F==(x))
#define NFALSEP(x) (BOOL_F != (x))
/* BOOL_NOT returns the other boolean.  The order of ^s here is
   important for Borland C++. */
#define BOOL_NOT(x)  ((x) ^ (BOOL_T ^ BOOL_F))
#define NULLP(x) (EOL==(x))
#define NNULLP(x) (EOL != (x))
#define UNBNDP(x) (UNDEFINED==(x))
#define CELLP(x) (!NCELLP(x))
#define NCELLP(x) ((sizeof(cell)-1) & (int)(x))

#define GCMARKP(x) (1 & (int)CDR(x))
#define GC8MARKP(x) (0x80 & (int)CAR(x))
#define SETGCMARK(x) CDR(x) |= 1;
#define CLRGCMARK(x) CDR(x) &= ~1L;
#define SETGC8MARK(x) CAR(x) |= 0x80;
#define CLRGC8MARK(x) CAR(x) &= ~0x80L;
#define TYP3(x) (7 & (int)CAR(x))
#define TYP7(x) (0x7f & (int)CAR(x))
#define TYP7S(x) (0x7d & (int)CAR(x))
#define TYP16(x) (0xffff & (int)CAR(x))
#define TYP16S(x) (0xfeff & (int)CAR(x))
#define GCTYP16(x) (0xff7f & (int)CAR(x))

#define NCONSP(x) (1 & (int)CAR(x))
#define CONSP(x) (!NCONSP(x))
#define ECONSP(x) (CONSP(x) || (1==TYP3(x)))
#define NECONSP(x) (NCONSP(x) && (1 != TYP3(x)))
#define SCM_GLOCP(x) (tc3_cons_gloc==(7 & (int)(x)))

#define CAR(x) (((cell *)(SCM2PTR(x)))->car)
#define CDR(x) (((cell *)(SCM2PTR(x)))->cdr)
#define GCCDR(x) (~1L & CDR(x))
#define SETCDR(x, v) CDR(x) = (SCM)(v)

#ifdef _M_ARM
/* MS CLARM compiler bug workaround.  */
volatile SCM MS_CLARM_dumy;
# define CODE(x) (MS_CLARM_dumy = (CAR(x)-tc3_closure))
#else
# define CODE(x) (CAR(x)-tc3_closure)
#endif
#define CLOSUREP(x) (TYP3(x)==tc3_closure)
#define SETCODE(x, e) CAR(x) = (e)+tc3_closure
#define ENV(x) ((~7L & CDR(x)) ? (~7L & CDR(x)) : EOL)
#define GCENV ENV
#define ARGC(x) ((6L & CDR(x))>>1)
#ifdef CAUTIOUS
# define SCM_ESTK_FRLEN 4
#else
# define SCM_ESTK_FRLEN 3
#endif
#define SCM_ESTK_BASE 4
#define SCM_ESTK_PARENT(v) (VELTS(v)[0])
#define SCM_ESTK_PARENT_WRITABLEP(v) (VELTS(v)[1])
#define SCM_ESTK_PARENT_INDEX(v) (VELTS(v)[2])
SCM_EXPORT long tc16_env, tc16_ident;
#define ENVP(x) (tc16_env==TYP16(x))
#define SCM_ENV_FORMALS CAR
#ifdef MACRO
# define M_IDENTP(x) (tc16_ident==TYP16(x))
# define M_IDENT_LEXP(x) ((tc16_ident | (1L<<16))==CAR(x))
# define IDENTP(x) (SYMBOLP(x) || M_IDENTP(x))
# define IDENT_PARENT(x) (M_IDENT_LEXP(x) ? CAR(CDR(x)) : CDR(x))
# define IDENT_ENV(x) (M_IDENT_LEXP(x) ? CDR(CDR(x)) : BOOL_F)
#else
# define IDENTP SYMBOLP
# define M_IDENTP(x) (0)
#endif

  /* markers for various static environment frame types */
  /* FIXME these need to be exported somehow to Scheme */
#ifdef CAUTIOUS
# define SCM_ENV_FILENAME MAKINUM(1)
# define SCM_ENV_PROCNAME MAKINUM(2)
#endif
#define SCM_ENV_DOC MAKINUM(3)
#define SCM_ENV_ANNOTATION MAKINUM(4)
#define SCM_ENV_CONSTANT MAKINUM(5)
#define SCM_ENV_SYNTAX MAKINUM(6)
#define SCM_ENV_END MAKINUM(7)

#define PORTP(x) (TYP7(x)==tc7_port)
#define OPPORTP(x) (((0x7f | OPN) & CAR(x))==(tc7_port | OPN))
#define OPINPORTP(x) (((0x7f | OPN | RDNG) & CAR(x))==(tc7_port | OPN | RDNG))
#define OPOUTPORTP(x) (((0x7f | OPN | WRTNG) & CAR(x))==(tc7_port | OPN | WRTNG))
#define OPIOPORTP(x) (((0x7f | OPN | RDNG | WRTNG) & CAR(x))==(tc7_port | OPN | RDNG | WRTNG))
#define FPORTP(x) (TYP16S(x)==tc7_port)
#define OPFPORTP(x) (((0xfeff | OPN) & CAR(x))==(tc7_port | OPN))
#define OPINFPORTP(x) (((0xfeff | OPN | RDNG) & CAR(x))==(tc7_port | OPN | RDNG))
#define OPOUTFPORTP(x) (((0xfeff | OPN | WRTNG) & CAR(x))==(tc7_port | OPN | WRTNG))

#define INPORTP(x) (((0x7f | RDNG) & CAR(x))==(tc7_port | RDNG))
#define OUTPORTP(x) (((0x7f | WRTNG) & CAR(x))==(tc7_port | WRTNG))
#define OPENP(x) (OPN & CAR(x))
#define CLOSEDP(x) (!OPENP(x))
#define STREAM(x) ((FILE *)(CDR(x)))
#define SETSTREAM SETCDR
#define CRDYP(port) ((CAR(port) & CRDY) && (EOF != CGETUN(port)))
#define CLRDY(port) (CAR(port) &= (SCM_PORTFLAGS(port) | (~0xf0000)))
#define CGETUN(port) (scm_port_table[SCM_PORTNUM(port)].unread)

#define tc_socket (tc7_port | OPN)
#define SOCKP(x) (((0x7f | OPN | RDNG | WRTNG) & CAR(x))==(tc_socket))
#define SOCKTYP(x) (INUM(SCM_PORTDATA(x)))

#define DIRP(x) (NIMP(x) && (TYP16(x)==(tc16_dir)))
#define OPDIRP(x) (NIMP(x) && (CAR(x)==(tc16_dir | OPN)))

#ifdef FLOATS
# define INEXP(x) (TYP16(x)==tc16_flo)
# define CPLXP(x) (CAR(x)==tc_dblc)
# define REAL(x) (*(((dbl *) (SCM2PTR(x)))->real))
# define IMAG(x) (*((double *)(CHARS(x)+sizeof(double))))
/* ((&REAL(x))[1]) */
# ifdef SINGLES
#  define REALP(x) ((~REAL_PART & CAR(x))==tc_flo)
#  define SINGP(x) (CAR(x)==tc_flo)
#  define FLO(x) (((flo *)(SCM2PTR(x)))->num)
#  define REALPART(x) (SINGP(x)?0.0+FLO(x):REAL(x))
# else /* SINGLES */
#  define REALP(x) (CAR(x)==tc_dblr)
#  define REALPART REAL
# endif /* SINGLES */
#endif

#ifdef FLOATS
# define NUMBERP(x) (INUMP(x) || (NIMP(x) && NUMP(x)))
#else
# ifdef BIGDIG
#  define NUMBERP(x) (INUMP(x) || (NIMP(x) && NUMP(x)))
# else
#  define NUMBERP INUMP
# endif
#endif
#define NUMP(x) ((0xfcff & (int)CAR(x))==tc7_smob)
#define BIGP(x) (TYP16S(x)==tc16_bigpos)
#define BIGSIGN(x) (0x0100 & (int)CAR(x))
#define BDIGITS(x) ((BIGDIG *)(CDR(x)))
#define NUMDIGS(x) ((sizet)(((unsigned long)CAR(x))>>16))
#define MAKE_NUMDIGS(v, t) ((((v)+0L)<<16)+(t))
#define SETNUMDIGS(x, v, t) CAR(x) = MAKE_NUMDIGS(v, t)

#define SNAME(x) ((char *)(subrs[NUMDIGS(x)].name))
#define SUBRF(x) (((subr *)(SCM2PTR(x)))->cproc)
#define DSUBRF(x) (((dsubr *)(SCM2PTR(x)))->dproc)
#define CCLO_SUBR(x) (VELTS(x)[0])
#define CCLO_LENGTH NUMDIGS
#define CXR_OP SMOBNUM

#define SYMBOLP(x) (TYP7S(x)==tc7_ssymbol)
#define STRINGP(x) (TYP7(x)==tc7_string)
#define NSTRINGP(x) (!STRINGP(x))
#define VECTORP(x) (TYP7(x)==tc7_vector)
#define NVECTORP(x) (!VECTORP(x))
#define LENGTH(x) (((unsigned long)CAR(x))>>8)
#define LENGTH_MAX (((unsigned long)-1L)>>8)
#define MAKE_LENGTH(v, t) ((((v)+0L)<<8) + (t))
#define SETLENGTH(x, v, t) CAR(x) = MAKE_LENGTH(v, t)
#define CHARS(x) ((char *)(CDR(x)))
#define UCHARS(x) ((unsigned char *)(CDR(x)))
#define VELTS(x) ((SCM *)CDR(x))
#define SETCHARS SETCDR
#define SETVELTS SETCDR

SCM_EXPORT long tc16_array;
#define ARRAYP(a) (tc16_array==TYP16(a))
#define ARRAY_V(a) (((array *)CDR(a))->v)
/*#define ARRAY_NDIM(x) NUMDIGS(x)*/
#define ARRAY_NDIM(x) ((sizet)(CAR(x)>>17))
#define ARRAY_CONTIGUOUS 0x10000
#define ARRAY_CONTP(x) (ARRAY_CONTIGUOUS & (int)CAR(x))
#define ARRAY_BASE(a) (((array *)CDR(a))->base)
#define ARRAY_DIMS(a) ((array_dim *)(CHARS(a)+sizeof(array)))

#define FREEP(x) (CAR(x)==tc_free_cell)
#define NFREEP(x) (!FREEP(x))

#define SMOBNUM(x) (0x0ff & (CAR(x)>>8))
#define PTOBNUM(x) (0x0ff & (CAR(x)>>8))
#define SCM_PORTNUM(x) ((int)(((unsigned long)CAR(x))>>20))
#define SCM_PORTNUM_MAX ((int)((0x7fffUL<<20)>>20))
#define SCM_PORTFLAGS(x) (scm_port_table[SCM_PORTNUM(x)].flags)
#define SCM_PORTDATA(x) (scm_port_table[SCM_PORTNUM(x)].data)
#define SCM_SETFLAGS(x, flags) (CAR(x) = (CAR(x) & ~0x0f0000L) | (flags))
/* This is used (only) for closing ports. */
#define SCM_SET_PTOBNUM(x, typ) (CAR(x)=(typ)|(CAR(x) & ~0x0ffffL))

#define DIGITS '0':case '1':case '2':case '3':case '4':\
		case '5':case '6':case '7':case '8':case '9'

/* Aggregated types for dispatch in switch statements. */

#define tcs_cons_inum 2: case 6:case 10:case 14:\
		 case 18:case 22:case 26:case 30:\
		 case 34:case 38:case 42:case 46:\
		 case 50:case 54:case 58:case 62:\
		 case 66:case 70:case 74:case 78:\
		 case 82:case 86:case 90:case 94:\
		 case 98:case 102:case 106:case 110:\
		 case 114:case 118:case 122:case 126
#define tcs_cons_iloc 124
#define tcs_cons_ispcsym 4:case 12:case 20:case 28:\
		   case 36:case 44:case 52:case 60:\
		   case 68:case 76:case 84:case 92:\
		   case 100:case 108
#define tcs_cons_chflag 116	/* char *or* flag */
#define tcs_cons_imcar tcs_cons_inum:\
		   case tcs_cons_iloc:\
		   case tcs_cons_ispcsym:\
		   case tcs_cons_chflag

#define tcs_cons_nimcar 0:case 8:case 16:case 24:\
		 case 32:case 40:case 48:case 56:\
		 case 64:case 72:case 80:case 88:\
		 case 96:case 104:case 112:case 120
#define tcs_cons_gloc 1:case 9:case 17:case 25:\
		 case 33:case 41:case 49:case 57:\
		 case 65:case 73:case 81:case 89:\
		 case 97:case 105:case 113:case 121

#define tcs_closures   3:case 11:case 19:case 27:\
		 case 35:case 43:case 51:case 59:\
		 case 67:case 75:case 83:case 91:\
		 case 99:case 107:case 115:case 123
#define tcs_subrs tc7_asubr:case tc7_subr_0:case tc7_subr_1:case tc7_cxr:\
	case tc7_subr_3:case tc7_subr_2:case tc7_rpsubr:case tc7_subr_1o:\
	case tc7_subr_2o:case tc7_lsubr_2:case tc7_lsubr
#define tcs_symbols tc7_ssymbol:case tc7_msymbol
#define tcs_bignums tc16_bigpos:case tc16_bigneg
#define tcs_uves tc7_string:case tc7_bvect:\
         case tc7_uvect:case tc7_ivect:case tc7_svect:\
         case tc7_fvect:case tc7_dvect:case tc7_cvect

#define tc3_cons_nimcar 0
#define tc3_cons_imcar  2:case 4:case 6
#define tc3_cons_gloc	1
#define tc3_closure	3
#define tc3_tc7_types	5:case 7

#define tc7_ssymbol	5
#define tc7_msymbol	7
#define tc7_string	13
#define tc7_vector	15
#define tc7_bvect	21
/* spare 23 */
#define tc7_ivect	29
#define tc7_uvect	31
#define tc7_svect	37
/* spare 39 */
#define tc7_fvect	45
#define tc7_dvect	47
#define tc7_cvect	53
#define tc7_port	55
#define tc7_contin	61
#define tc7_specfun	63

/* spare 69 71 77 79 */
#define tc7_subr_0	85
#define tc7_subr_1	87
#define tc7_cxr		93
#define tc7_subr_3	95
#define tc7_subr_2	101
#define tc7_asubr	103
#define tc7_subr_1o	109
#define tc7_subr_2o	111
#define tc7_lsubr_2	117
#define tc7_lsubr	119
#define tc7_rpsubr	125

#define tc7_smob	127
#define tc_free_cell	127
#define tc_broken_heart (tc_free_cell+0x10000)

#define tc16_apply	(tc7_specfun | (0L<<8))
#define tc16_call_cc	(tc7_specfun | (1L<<8))
#define tc16_cclo	(tc7_specfun | (2L<<8))
#define tc16_eval	(tc7_specfun | (3L<<8))
#define tc16_values	(tc7_specfun | (4L<<8))
#define tc16_call_wv	(tc7_specfun | (5L<<8))

#define tc16_flo	0x017f
#define tc_flo		0x017fL

#define REAL_PART	(1L<<16)
#define IMAG_PART	(2L<<16)
#define tc_dblr		(tc16_flo|REAL_PART)
#define tc_dblc		(tc16_flo|REAL_PART|IMAG_PART)

#define tc16_bigpos	0x027f
#define tc16_bigneg	0x037f

  /* The first four flags fit in the car of a port cell, remaining
   flags only in the port table */
#define OPN		(1L<<16)
#define RDNG		(2L<<16)
#define WRTNG		(4L<<16)
#define CRDY		(8L<<16)

#define TRACKED		(16L<<16)
#define BINARY		(32L<<16)
#define BUF0		(64L<<16)
#define EXCLUSIVE	(128L<<16)
		/* LSB is used for gc mark */

SCM_EXPORT scm_gra subrs_gra;
#define subrs ((subr_info *)(subrs_gra.elts))
/* SCM_EXPORT sizet numsmob, numptob;
  SCM_EXPORT smobfuns *smobs;
  SCM_EXPORT ptobfuns *ptobs;
  SCM_EXPORT ptobfuns pipob; */
SCM_EXPORT scm_gra smobs_gra;
#define numsmob (smobs_gra.len)
#define smobs ((smobfuns *)(smobs_gra.elts))
SCM_EXPORT scm_gra ptobs_gra;
#define numptob (ptobs_gra.len)
#define ptobs ((ptobfuns *)(ptobs_gra.elts))
SCM_EXPORT port_info *scm_port_table;

#define tc16_fport (tc7_port + 0*256L)
#define tc16_pipe (tc7_port + 1*256L)
#define tc16_strport (tc7_port + 2*256L)
#define tc16_sfport (tc7_port + 3*256L)
SCM_EXPORT long tc16_dir;
SCM_EXPORT long tc16_clport;

SCM_EXPORT SCM sys_protects[];
#define cur_inp		 sys_protects[0]
#define cur_outp	 sys_protects[1]
#define cur_errp	 sys_protects[2]
#define def_inp          sys_protects[3]
#define def_outp 	 sys_protects[4]
#define def_errp 	 sys_protects[5]
#define sys_errp 	 sys_protects[6]
#define sys_safep  	 sys_protects[7]
#define listofnull 	 sys_protects[8]
#define undefineds 	 sys_protects[9]
#define nullvect   	 sys_protects[10]
#define nullstr    	 sys_protects[11]
#define progargs  	 sys_protects[12]
#define loadports 	 sys_protects[13]
#define rootcont  	 sys_protects[14]
#define dynwinds  	 sys_protects[15]
#define list_unspecified sys_protects[16]
#define f_evapply	 sys_protects[17]
#define eval_env	 sys_protects[18]
#define f_apply_closure  sys_protects[19]
#define flo0		 sys_protects[20]
#define scm_uprotects	 sys_protects[21]
#define NUM_PROTECTS 22

/* now for connects between source files */

/* SCM_EXPORT sizet num_finals;
   SCM_EXPORT void (**finals)P((void));
   SCM_EXPORT sizet num_finals; */
SCM_EXPORT scm_gra finals_gra;
#define num_finals (finals_gra.len)
#define finals ((void (**)())(finals_gra.elts))

SCM_EXPORT unsigned char upcase[], downcase[];
SCM_EXPORT SCM symhash;
SCM_EXPORT int symhash_dim;
SCM_EXPORT long heap_cells;
SCM_EXPORT CELLPTR heap_org;
SCM_EXPORT VOLATILE SCM freelist;
SCM_EXPORT long gc_cells_collected, gc_malloc_collected, gc_ports_collected;
SCM_EXPORT long gc_syms_collected;
SCM_EXPORT long cells_allocated, lcells_allocated, mallocated, lmallocated;
SCM_EXPORT long mtrigger;
SCM_EXPORT SCM *loc_loadpath;
SCM_EXPORT SCM *loc_errobj;
SCM_EXPORT SCM loadport;
SCM_EXPORT char *errjmp_bad;
SCM_EXPORT int ints_disabled, output_deferred, gc_hook_pending, gc_hook_active;
SCM_EXPORT unsigned long SIG_deferred;
SCM_EXPORT SCM exitval;
SCM_EXPORT int cursinit;
SCM_EXPORT unsigned int poll_count, tick_count;
SCM_EXPORT int dumped;
SCM_EXPORT char *execpath;
SCM_EXPORT char s_no_execpath[];
SCM_EXPORT int scm_verbose;
#define verbose (scm_verbose+0)

SCM_EXPORT const char dirsep[];

/* strings used in several source files */

SCM_EXPORT char s_read[], s_write[], s_newline[], s_system[];
SCM_EXPORT char s_make_string[], s_make_vector[], s_list[], s_op_pipe[];
#define s_string (s_make_string+5)
#define s_vector (s_make_vector+5)
#define s_pipe (s_op_pipe+5)
SCM_EXPORT char s_make_sh_array[];
SCM_EXPORT char s_array_fill[];
#define s_array (s_make_sh_array+12)
SCM_EXPORT char s_ccl[];
#define s_limit (s_ccl+10)
SCM_EXPORT char s_close_port[];
#define s_port_type (s_close_port+6)
SCM_EXPORT char s_call_cc[];
#define s_cont (s_call_cc+18)
SCM_EXPORT char s_try_create_file[];
SCM_EXPORT char s_badenv[];

SCM_EXPORT void (*init_user_scm) P((void));

/* function prototypes */

SCM_EXPORT void (* deferred_proc) P((void));
SCM_EXPORT void	process_signals P((void));
SCM_EXPORT int	handle_it P((int i));
SCM_EXPORT SCM	must_malloc_cell P((long len, SCM c, char *what));
SCM_EXPORT void	must_realloc_cell P((SCM z, long olen, long len, char *what));
SCM_EXPORT char	*must_malloc P((long len, char *what));
SCM_EXPORT char	*must_realloc P((char *where, long olen, long len, char *what));
SCM_EXPORT void	must_free P((char *obj, sizet len));
SCM_EXPORT void	scm_protect_temp P((SCM *ptr));
SCM_EXPORT long	ilength P((SCM sx));
SCM_EXPORT SCM	hash P((SCM obj, SCM n));
SCM_EXPORT SCM	hashv P((SCM obj, SCM n));
SCM_EXPORT SCM	hashq P((SCM obj, SCM n));
SCM_EXPORT SCM	obhash P((SCM obj));
SCM_EXPORT SCM	obunhash P((SCM obj));
SCM_EXPORT unsigned long strhash P((unsigned char *str, sizet len, unsigned long n));
SCM_EXPORT unsigned long hasher P((SCM obj, unsigned long n, sizet d));
SCM_EXPORT SCM	lroom P((SCM args));
SCM_EXPORT SCM	lflush P((SCM port));
SCM_EXPORT void	scm_init_gra P((scm_gra *gra, sizet eltsize, sizet len,
			sizet maxlen, char *what));
SCM_EXPORT int	scm_grow_gra P((scm_gra *gra, char *elt));
SCM_EXPORT void	scm_trim_gra P((scm_gra *gra));
SCM_EXPORT void	scm_free_gra P((scm_gra *gra));
SCM_EXPORT long	newsmob P((smobfuns *smob));
SCM_EXPORT long	newptob P((ptobfuns *ptob));
SCM_EXPORT SCM	scm_port_entry P((FILE *stream, long ptype, long flags));
SCM_EXPORT SCM	scm_open_ports P((void));
SCM_EXPORT void	prinport P((SCM exp, SCM port, char *type));
SCM_EXPORT SCM	repl P((void));
SCM_EXPORT void	repl_report P((void));
SCM_EXPORT void	growth_mon P((char *obj, long size, char *units, int grewp));
SCM_EXPORT void	gc_start P((char *what));
SCM_EXPORT void	gc_end P((void));
SCM_EXPORT void	gc_mark P((SCM p));
SCM_EXPORT void	scm_gc_hook P((void));
SCM_EXPORT SCM     scm_gc_protect P((SCM obj));
SCM_EXPORT SCM	scm_add_finalizer P((SCM value, SCM finalizer));
SCM_EXPORT void	scm_run_finalizers P((int exiting));
SCM_EXPORT void    scm_egc_start P((void));
SCM_EXPORT void    scm_egc_end P((void));
SCM_EXPORT void	heap_report P((void));
SCM_EXPORT void	gra_report P((void));
SCM_EXPORT void	exit_report P((void));
SCM_EXPORT void	stack_report P((void));
SCM_EXPORT SCM	scm_stack_trace P((SCM contin));
SCM_EXPORT SCM	scm_scope_trace P((SCM env));
SCM_EXPORT SCM	scm_frame_trace P((SCM contin, SCM nf));
SCM_EXPORT SCM	scm_frame2env P((SCM contin, SCM nf));
SCM_EXPORT SCM	scm_frame_eval P((SCM contin, SCM nf, SCM expr));
SCM_EXPORT void	iprin1 P((SCM exp, SCM port, int writing));
SCM_EXPORT void	intprint P((long n, int radix, SCM port));
SCM_EXPORT void	iprlist P((char *hdr, SCM exp, int tlr, SCM port, int writing));
SCM_EXPORT SCM	scm_env_lookup P((SCM var, SCM stenv));
SCM_EXPORT SCM	scm_env_rlookup P((SCM addr, SCM stenv, char *what));
SCM_EXPORT SCM	scm_env_getprop P((SCM prop, SCM env));
SCM_EXPORT SCM	scm_env_addprop P((SCM prop, SCM val, SCM env));
SCM_EXPORT long	num_frames P((SCM estk, int i));
SCM_EXPORT SCM	*estk_frame P((SCM estk, int i, int nf));
SCM_EXPORT SCM	*cont_frame P((SCM contin, int nf));
SCM_EXPORT SCM	stacktrace1 P((SCM estk, int i));
SCM_EXPORT void	scm_princode P((SCM code, SCM env, SCM port, int writing));
SCM_EXPORT void	scm_princlosure P((SCM proc, SCM port, int writing));
SCM_EXPORT void	lputc P((int c, SCM port));
SCM_EXPORT void	lputs P((char *s, SCM port));
SCM_EXPORT sizet	lfwrite P((char *ptr, sizet size, sizet nitems, SCM port));
SCM_EXPORT int	lgetc P((SCM port));
SCM_EXPORT void	lungetc P((int c, SCM port));
SCM_EXPORT char	*grow_tok_buf P((SCM tok_buf));
SCM_EXPORT long	mode_bits P((char *modes, char *cmodes));
SCM_EXPORT long	time_in_msec P((long x));
SCM_EXPORT SCM	my_time P((void));
SCM_EXPORT SCM	your_time P((void));
SCM_EXPORT void	init_iprocs P((iproc *subra, int type));

SCM_EXPORT void	final_scm P((int));
SCM_EXPORT void	init_sbrk P((void));
SCM_EXPORT int	init_buf0 P((FILE *inport));
SCM_EXPORT void	scm_init_from_argv P((int argc, char **argv, char *script_arg,
			      int iverbose, int buf0stdin));
SCM_EXPORT void	init_signals P((void));
SCM_EXPORT SCM	scm_top_level P((char *initpath, SCM (*toplvl_fun)()));
SCM_EXPORT void	restore_signals P((void));
SCM_EXPORT void	free_storage P((void));
SCM_EXPORT char	*dld_find_executable P((const char* command));
SCM_EXPORT char	*scm_find_execpath P((int argc, char **argv, char *script_arg));
SCM_EXPORT void	init_scm P((int iverbose, int buf0stdin, long init_heap_size));
SCM_EXPORT void    scm_init_INITS P((void));
SCM_EXPORT SCM	scm_init_extensions P((void));
SCM_EXPORT void	ignore_signals P((void));
SCM_EXPORT void	unignore_signals P((void));

SCM_EXPORT void	add_feature P((char *str));
SCM_EXPORT int	raprin1 P((SCM exp, SCM port, int writing));
SCM_EXPORT SCM	markcdr P((SCM ptr));
#define mark0 (0)    /*SCM mark0 P((SCM ptr)); */
SCM_EXPORT SCM	equal0 P((SCM ptr1, SCM ptr2));
SCM_EXPORT sizet	free0 P((CELLPTR ptr));
SCM_EXPORT void	scm_warn P((char *str1, char *str2, SCM obj));
SCM_EXPORT void	everr P((SCM exp, SCM env, SCM arg, char *pos, char *s_subr, int codep));
SCM_EXPORT void	wta P((SCM arg, char *pos, char *s_subr));
SCM_EXPORT void	scm_experr P((SCM arg, char *pos, char *s_subr));
SCM_EXPORT SCM	intern P((char *name, sizet len));
SCM_EXPORT SCM	sysintern P((const char *name, SCM val));
SCM_EXPORT SCM	sym2vcell P((SCM sym));
SCM_EXPORT SCM	makstr P((long len));
SCM_EXPORT SCM	scm_maksubr P((const char *name, int type, SCM (*fcn)()));
SCM_EXPORT SCM	make_subr P((const char *name, int type, SCM (*fcn)()));
SCM_EXPORT SCM	make_synt P((const char *name, long flags, SCM (*fcn)()));
SCM_EXPORT SCM	make_gsubr P((const char *name, int req, int opt, int rst,
		      SCM (*fcn)()));
SCM_EXPORT SCM	closure P((SCM code, int nargs));
SCM_EXPORT SCM	makprom P((SCM code));
SCM_EXPORT SCM	force P((SCM x));
SCM_EXPORT SCM	makarb P((SCM name));
SCM_EXPORT SCM	tryarb P((SCM arb));
SCM_EXPORT SCM	relarb P((SCM arb));
SCM_EXPORT SCM	ceval P((SCM x, SCM static_env, SCM env));
SCM_EXPORT SCM	scm_wrapcode P((SCM code, SCM env));
SCM_EXPORT SCM	scm_current_env P((void));
SCM_EXPORT SCM	prolixity P((SCM arg));
SCM_EXPORT SCM	gc_for_newcell P((void));
SCM_EXPORT void	gc_for_open_files P((void));
SCM_EXPORT SCM	gc P((SCM arg));
SCM_EXPORT SCM	tryload P((SCM filename, SCM reader));
SCM_EXPORT SCM	acons P((SCM w, SCM x, SCM y));
SCM_EXPORT SCM	cons2 P((SCM w, SCM x, SCM y));
SCM_EXPORT SCM	resizuve P((SCM vect, SCM len));
SCM_EXPORT SCM	lnot P((SCM x));
SCM_EXPORT SCM	booleanp P((SCM obj));
SCM_EXPORT SCM	eq P((SCM x, SCM y));
SCM_EXPORT SCM	equal P((SCM x, SCM y));
SCM_EXPORT SCM	consp P((SCM x));
SCM_EXPORT SCM	cons P((SCM x, SCM y));
SCM_EXPORT SCM	nullp P((SCM x));
SCM_EXPORT SCM	setcar P((SCM pair, SCM value));
SCM_EXPORT SCM	setcdr P((SCM pair, SCM value));
SCM_EXPORT SCM	listp P((SCM x));
SCM_EXPORT SCM	list P((SCM objs));
SCM_EXPORT SCM	length P((SCM x));
SCM_EXPORT SCM	append P((SCM args));
SCM_EXPORT SCM	reverse P((SCM lst));
SCM_EXPORT SCM	list_ref P((SCM lst, SCM k));
SCM_EXPORT SCM	memq P((SCM x, SCM lst));
SCM_EXPORT SCM	member P((SCM x, SCM lst));
SCM_EXPORT SCM	memv P((SCM x, SCM lst));
SCM_EXPORT SCM	assq P((SCM x, SCM alist));
SCM_EXPORT SCM	assoc P((SCM x, SCM alist));
SCM_EXPORT SCM	symbolp P((SCM x));
SCM_EXPORT SCM	symbol2string P((SCM s));
SCM_EXPORT SCM	string2symbol P((SCM s));
SCM_EXPORT SCM	numberp P((SCM x));
SCM_EXPORT SCM	exactp P((SCM x));
SCM_EXPORT SCM	inexactp P((SCM x));
SCM_EXPORT SCM	eqp P((SCM x, SCM y));
SCM_EXPORT SCM	lessp P((SCM x, SCM y));
SCM_EXPORT SCM	greaterp P((SCM x, SCM y));
SCM_EXPORT SCM	leqp P((SCM x, SCM y));
SCM_EXPORT SCM	greqp P((SCM x, SCM y));
SCM_EXPORT SCM	zerop P((SCM z));
SCM_EXPORT SCM	positivep P((SCM x));
SCM_EXPORT SCM	negativep P((SCM x));
SCM_EXPORT SCM	oddp P((SCM n));
SCM_EXPORT SCM	evenp P((SCM n));
SCM_EXPORT SCM	lmax P((SCM x, SCM y));
SCM_EXPORT SCM	lmin P((SCM x, SCM y));
SCM_EXPORT SCM	sum P((SCM x, SCM y));
SCM_EXPORT SCM	difference P((SCM x, SCM y));
SCM_EXPORT SCM	product P((SCM x, SCM y));
SCM_EXPORT SCM	divide P((SCM x, SCM y));
SCM_EXPORT SCM	lquotient P((SCM x, SCM y));
SCM_EXPORT SCM	absval P((SCM x));
SCM_EXPORT SCM	lremainder P((SCM x, SCM y));
SCM_EXPORT SCM	modulo P((SCM x, SCM y));
SCM_EXPORT SCM	lgcd P((SCM x, SCM y));
SCM_EXPORT SCM	llcm P((SCM n1, SCM n2));
SCM_EXPORT SCM	number2string P((SCM x, SCM radix));
SCM_EXPORT SCM	istring2number P((char *str, long len, long radix));
SCM_EXPORT SCM	string2number P((SCM str, SCM radix));
SCM_EXPORT SCM	istr2flo P((char *str, long len, long radix));
SCM_EXPORT SCM	mkbig P((sizet nlen, int sign));
SCM_EXPORT SCM	mkstrport P((SCM pos, SCM str, long modes, char *caller));
SCM_EXPORT SCM	mksafeport P((int maxlen, SCM port));
SCM_EXPORT int	reset_safeport P((SCM sfp, int maxlen, SCM port));
SCM_EXPORT SCM	long2big P((long n));
SCM_EXPORT SCM	ulong2big P((unsigned long n));
SCM_EXPORT SCM	big2inum P((SCM b, sizet l));
SCM_EXPORT sizet iint2str P((long num, int rad, char *p));
SCM_EXPORT SCM	floequal P((SCM x, SCM y));
SCM_EXPORT SCM	uve_equal P((SCM u, SCM v));
SCM_EXPORT SCM  uve_read P((SCM v, SCM port));
SCM_EXPORT SCM  uve_write P((SCM v, SCM port));
SCM_EXPORT SCM	raequal P((SCM ra0, SCM ra1));
SCM_EXPORT SCM	array_equal P((SCM u, SCM v));
SCM_EXPORT SCM	array_rank P((SCM ra));
SCM_EXPORT int  rafill P((SCM ra, SCM fill, SCM ignore));
SCM_EXPORT SCM	uve_fill P((SCM uve, SCM fill));
SCM_EXPORT SCM	array_fill P((SCM ra, SCM fill));
SCM_EXPORT SCM	array_prot P((SCM ra));
SCM_EXPORT SCM  array_rank P((SCM ra));
SCM_EXPORT SCM  array_contents P((SCM ra, SCM strict));
SCM_EXPORT int	bigprint P((SCM exp, SCM port, int writing));
SCM_EXPORT int	floprint P((SCM sexp, SCM port, int writing));
SCM_EXPORT SCM	istr2int P((char *str, long len, long radix));
SCM_EXPORT SCM	istr2bve P((char *str, long len));
SCM_EXPORT void	ipruk P((char *hdr, SCM ptr, SCM port));
SCM_EXPORT SCM	charp P((SCM x));
SCM_EXPORT SCM	char_lessp P((SCM x, SCM y));
SCM_EXPORT SCM	chci_eq P((SCM x, SCM y));
SCM_EXPORT SCM	chci_lessp P((SCM x, SCM y));
SCM_EXPORT SCM	char_alphap P((SCM chr));
SCM_EXPORT SCM	char_nump P((SCM chr));
SCM_EXPORT SCM	char_whitep P((SCM chr));
SCM_EXPORT SCM	char_upperp P((SCM chr));
SCM_EXPORT SCM	char_lowerp P((SCM chr));
SCM_EXPORT SCM	char2int P((SCM chr));
SCM_EXPORT SCM	int2char P((SCM n));
SCM_EXPORT SCM	char_upcase P((SCM chr));
SCM_EXPORT SCM	char_downcase P((SCM chr));
SCM_EXPORT SCM	stringp P((SCM x));
SCM_EXPORT SCM	string P((SCM chrs));
SCM_EXPORT SCM	make_string P((SCM k, SCM chr));
SCM_EXPORT SCM	string2list P((SCM str));
SCM_EXPORT SCM	st_length P((SCM str));
SCM_EXPORT SCM	st_ref P((SCM str, SCM k));
SCM_EXPORT SCM	st_set P((SCM str, SCM k, SCM chr));
SCM_EXPORT SCM	st_equal P((SCM s1, SCM s2));
SCM_EXPORT SCM	stci_equal P((SCM s1, SCM s2));
SCM_EXPORT SCM	st_lessp P((SCM s1, SCM s2));
SCM_EXPORT SCM	stci_lessp P((SCM s1, SCM s2));
SCM_EXPORT SCM	substring P((SCM str, SCM start, SCM end));
SCM_EXPORT SCM	st_append P((SCM args));
SCM_EXPORT SCM	vectorp P((SCM x));
SCM_EXPORT SCM	vector_length P((SCM v));
SCM_EXPORT SCM	vector P((SCM l));
SCM_EXPORT SCM	vector_ref P((SCM v, SCM k));
SCM_EXPORT SCM	vector_set P((SCM v, SCM k, SCM obj));
SCM_EXPORT SCM	make_vector P((SCM k, SCM fill));
SCM_EXPORT SCM	vector2list P((SCM v));
SCM_EXPORT SCM	for_each P((SCM proc, SCM arg1, SCM args));
SCM_EXPORT SCM	procedurep P((SCM obj));
SCM_EXPORT SCM	apply P((SCM proc, SCM arg1, SCM args));
SCM_EXPORT SCM	scm_cvapply P((SCM proc, long n, SCM *argv));
SCM_EXPORT int	scm_arity_check P((SCM proc, long argc, char *what));
SCM_EXPORT SCM	map P((SCM proc, SCM arg1, SCM args));
SCM_EXPORT SCM	scm_make_cont P((void));
SCM_EXPORT SCM	copytree P((SCM obj));
SCM_EXPORT SCM	eval P((SCM obj));
SCM_EXPORT SCM	scm_values P((SCM arg1, SCM arg2, SCM rest, char *what));
SCM_EXPORT SCM	scm_eval_values P((SCM x, SCM static_env, SCM env));
SCM_EXPORT SCM	identp P((SCM obj));
SCM_EXPORT SCM	ident2sym P((SCM id));
SCM_EXPORT SCM	ident_eqp P((SCM id1, SCM id2, SCM env));
SCM_EXPORT int	scm_nullenv_p P((SCM env));
SCM_EXPORT SCM	env2tree P((SCM env));
SCM_EXPORT SCM	renamed_ident P((SCM id, SCM env));
SCM_EXPORT SCM	scm_check_linum P((SCM x, SCM *linum));
SCM_EXPORT SCM	scm_add_linum P((SCM linum, SCM x));
SCM_EXPORT SCM	input_portp P((SCM x));
SCM_EXPORT SCM	output_portp P((SCM x));
SCM_EXPORT SCM	cur_input_port P((void));
SCM_EXPORT SCM	cur_output_port P((void));
SCM_EXPORT SCM	i_setbuf0 P((SCM port));
SCM_EXPORT SCM	try_open_file P((SCM filename, SCM modes));
SCM_EXPORT SCM	open_file P((SCM filename, SCM modes));
SCM_EXPORT SCM	open_pipe P((SCM pipestr, SCM modes));
SCM_EXPORT SCM	close_port P((SCM port));
SCM_EXPORT SCM	scm_read P((SCM port));
SCM_EXPORT SCM	scm_read_char P((SCM port));
SCM_EXPORT SCM	peek_char P((SCM port));
SCM_EXPORT SCM	eof_objectp P((SCM x));
SCM_EXPORT int	scm_io_error P((SCM port, char *what));
SCM_EXPORT SCM	lwrite P((SCM obj, SCM port));
SCM_EXPORT SCM	display P((SCM obj, SCM port));
SCM_EXPORT SCM	newline P((SCM port));
SCM_EXPORT SCM	write_char P((SCM chr, SCM port));
SCM_EXPORT SCM	scm_port_line P((SCM port));
SCM_EXPORT SCM	scm_port_col P((SCM port));
SCM_EXPORT void	scm_line_msg P((SCM file, SCM linum, SCM port));
SCM_EXPORT void	scm_err_line P((char *what, SCM file, SCM linum, SCM port));
SCM_EXPORT SCM	lgetenv P((SCM nam));
SCM_EXPORT SCM	prog_args P((void));
SCM_EXPORT SCM	makacro P((SCM code));
SCM_EXPORT SCM	makmacro P((SCM code));
SCM_EXPORT SCM	makmmacro P((SCM code));
SCM_EXPORT SCM	makidmacro P((SCM code));
SCM_EXPORT void	poll_routine P((void));
SCM_EXPORT void	tick_signal P((void));
SCM_EXPORT void	stack_check P((void));
SCM_EXPORT SCM	list2ura P((SCM ndim, SCM prot, SCM lst));
SCM_EXPORT SCM	make_ra P((int ndim));
SCM_EXPORT SCM	makflo P((float x));
SCM_EXPORT SCM	arrayp P((SCM v, SCM prot));
SCM_EXPORT SCM	aset P((SCM v, SCM obj, SCM args));
SCM_EXPORT SCM	aref P((SCM v, SCM args));
SCM_EXPORT SCM     scm_array_ref P((SCM args));
SCM_EXPORT SCM	cvref P((SCM v, sizet pos, SCM last));
SCM_EXPORT SCM	quit P((SCM n));
#ifdef CAREFUL_INTS
SCM_EXPORT void	ints_viol P((ints_infot *info, int sense));
SCM_EXPORT void    ints_warn P((char *s1, char* s2, char *fname, int linum));
#endif
SCM_EXPORT void	add_final P((void (*final)(void)));
SCM_EXPORT SCM	makcclo P((SCM proc, long len));
SCM_EXPORT SCM	make_uve P((long k, SCM prot));
SCM_EXPORT long	scm_prot2type P((SCM prot));
SCM_EXPORT long	aind P((SCM ra, SCM args, char *what));
SCM_EXPORT SCM	scm_eval_string P((SCM str));
SCM_EXPORT SCM	scm_load_string P((SCM str));
SCM_EXPORT SCM	scm_unexec P((const SCM pathname));
SCM_EXPORT SCM     scm_logbitp  P((SCM index, SCM j1));
SCM_EXPORT SCM     scm_logtest  P((SCM x, SCM y));
SCM_EXPORT SCM     scm_logxor P((SCM x, SCM y));
SCM_EXPORT SCM     scm_logand P((SCM x, SCM y));
SCM_EXPORT SCM     scm_logior P((SCM x, SCM y));
SCM_EXPORT SCM     scm_lognot P((SCM n));
SCM_EXPORT SCM     scm_intexpt P((SCM z1, SCM z2));
SCM_EXPORT SCM     scm_ash P((SCM n, SCM cnt));
SCM_EXPORT SCM     scm_bitfield P((SCM n, SCM start, SCM end));
SCM_EXPORT SCM     scm_logcount P((SCM n));
SCM_EXPORT SCM     scm_intlength P((SCM n));
SCM_EXPORT SCM     scm_copybit P((SCM index, SCM j1, SCM bit));
SCM_EXPORT SCM	scm_bitif P((SCM mask, SCM n0, SCM n1));
SCM_EXPORT SCM	scm_copybitfield P((SCM to, SCM start, SCM rest));

				/* Defined in "rope.c" */
SCM_EXPORT SCM	 long2num P((long n));
SCM_EXPORT SCM	ulong2num P((unsigned long n));
SCM_EXPORT unsigned char  num2uchar  P((SCM num, char *pos, char *s_caller));
SCM_EXPORT unsigned short num2ushort P((SCM num, char *pos, char *s_caller));
SCM_EXPORT unsigned long  num2ulong  P((SCM num, char *pos, char *s_caller));
SCM_EXPORT 	 long  num2long   P((SCM num, char *pos, char *s_caller));
SCM_EXPORT 	 short num2short  P((SCM num, char *pos, char *s_caller));
SCM_EXPORT         double num2dbl    P((SCM num, char *pos, char *s_caller));
SCM_EXPORT SCM	makfromstr  P((char *src, sizet len));
SCM_EXPORT SCM	makfromstrs P((int argc, char **argv));
SCM_EXPORT SCM	makfrom0str P((char *scr));
SCM_EXPORT char  **makargvfrmstrs P((SCM args, char *s_v));
SCM_EXPORT void	must_free_argv P((char **argv));
SCM_EXPORT SCM	scm_evstr  P((char *str));
SCM_EXPORT void	scm_ldstr  P((char *str));
SCM_EXPORT int	scm_ldfile P((char *path));
SCM_EXPORT int	scm_ldprog P((char *path));
SCM_EXPORT unsigned long scm_addr P((SCM args, char *name));
SCM_EXPORT unsigned long scm_base_addr P((SCM v, char *name));
SCM_EXPORT int	scm_cell_p P((SCM x));

#ifdef FLOATS
SCM_EXPORT SCM	makdbl P((double x, double y));
SCM_EXPORT SCM	dbl2big P((double d));
SCM_EXPORT double	big2dbl P((SCM b));
SCM_EXPORT double	lasinh P((double x));
SCM_EXPORT double	lacosh P((double x));
SCM_EXPORT double	latanh P((double x));
SCM_EXPORT double	ltrunc P((double x));
SCM_EXPORT double	scm_round P((double x));
SCM_EXPORT double	floident P((double x));
#endif

#ifdef BIGDIG
SCM_EXPORT void	longdigs P((long x, BIGDIG digs[DIGSPERLONG]));
SCM_EXPORT SCM	adjbig P((SCM b, sizet nlen));
SCM_EXPORT SCM	normbig P((SCM b));
SCM_EXPORT SCM	copybig P((SCM b, int sign));
SCM_EXPORT SCM	addbig P((BIGDIG *x, sizet nx, int xsgn, SCM bigy, int sgny));
SCM_EXPORT SCM	mulbig P((BIGDIG *x, sizet nx, BIGDIG *y, sizet ny, int sgn));
SCM_EXPORT unsigned int divbigdig P((BIGDIG *ds, sizet h, BIGDIG div));
SCM_EXPORT SCM	divbigint P((SCM x, long z, int sgn, int mode));
SCM_EXPORT SCM	divbigbig P((BIGDIG *x, sizet nx, BIGDIG *y, sizet ny, int sgn,
		   int modes));
SCM_EXPORT long	 pseudolong P((long x));
#endif
SCM_EXPORT int	bigcomp P((SCM x, SCM y));
SCM_EXPORT SCM	bigequal P((SCM x, SCM y));
SCM_EXPORT int	scm_bigdblcomp P((SCM b, double d));

/* "script.c" functions */
SCM_EXPORT char *	scm_cat_path P((char *str1, const char *str2, long n));
SCM_EXPORT char *	scm_try_path P((char *path));
SCM_EXPORT char *	script_find_executable P((const char *command));
SCM_EXPORT char **	script_process_argv P((int argc, char **argv));
SCM_EXPORT int	script_count_argv P((char **argv));
SCM_EXPORT char *	find_impl_file P((char *exec_path, const char *generic_name,
			  const char *initname, const char *sep));

/* environment cache functions */
SCM_EXPORT void scm_ecache_report P((void));
SCM_EXPORT void scm_estk_reset P((sizet size));
SCM_EXPORT void scm_env_cons P((SCM x, SCM y));
SCM_EXPORT void scm_env_cons2 P((SCM w, SCM x, SCM y));
SCM_EXPORT void scm_env_cons3 P((SCM v, SCM w, SCM x, SCM y));
SCM_EXPORT void scm_env_v2lst P((long argc, SCM *argv));
SCM_EXPORT void scm_extend_env P((void));
SCM_EXPORT void scm_egc P((void));

/* Global state for environment cache */
SCM_EXPORT CELLPTR scm_ecache;
SCM_EXPORT VOLATILE long scm_ecache_index, scm_ecache_len;
SCM_EXPORT SCM scm_env, scm_env_tmp;
SCM_EXPORT SCM scm_egc_roots[];
SCM_EXPORT VOLATILE long scm_egc_root_index;
SCM_EXPORT SCM scm_estk;
SCM_EXPORT SCM *scm_estk_v, *scm_estk_ptr;
SCM_EXPORT long scm_estk_size;
#ifndef RECKLESS
SCM_EXPORT SCM scm_trace, scm_trace_env;
#endif

#ifdef RECKLESS
# define ASRTER(_cond, _arg, _pos, _subr) ;
# define ASRTGO(_cond, _label) ;
#else
# define ASRTER(_cond, _arg, _pos, _subr) if(!(_cond))wta(_arg, (char *)(_pos), _subr);
# define ASRTGO(_cond, _label) if(!(_cond)) goto _label;
#endif

#define ARGn		1
#define ARG1		2
#define ARG2		3
#define ARG3		4
#define ARG4		5
#define ARG5		6
  /* following must match entry indexes in errmsgs[] */
#define WNA		7
#define OVFLOW		8
#define OUTOFRANGE	9
#define NALLOC		10
#define THRASH		11
#define EXIT		12
#define HUP_SIGNAL	13
#define INT_SIGNAL	14
#define FPE_SIGNAL	15
#define BUS_SIGNAL	16
#define SEGV_SIGNAL	17
#define ALRM_SIGNAL	18
#define VTALRM_SIGNAL   19
#define PROF_SIGNAL	20

#define EVAL(x, env, venv) (IMP(x)?(x):ceval((x), (SCM)(env), (SCM)(venv)))
#define SIDEVAL(x, env, venv) if NIMP(x) ceval((x), (SCM)(env), (SCM)(venv))

#define NEWCELL(_into) {if IMP(freelist) _into = gc_for_newcell();\
	else {_into = freelist;freelist = CDR(freelist);++cells_allocated;}}
/*
#define NEWCELL(_into) {DEFER_INTS;if IMP(freelist) _into = gc_for_newcell();\
	else {_into = freelist;freelist = CDR(freelist);++cells_allocated;}\
        ALLOW_INTS;}
*/

#ifdef __cplusplus
}
#endif