summaryrefslogtreecommitdiffstats
path: root/pscheme.init
blob: dfa05a8cdeadbe2f252f7edcca1aff2fba8ad6e0 (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
;;; "pscheme.init" -*-scheme-*-
;;; SLIB init file for Pocket Scheme
;;; SLIB orig Author: Aubrey Jaffer (jaffer@ai.mit.edu)
;;; Author: Ben Goetter <goetter@angrygraycat.com>
;;; Initial work for 0.2.3 by Robert Goldman (goldman@htc.honeywell.com)
;;;
;;; This code is in the public domain.

; best fit for Windows CE?
(define (software-type) 'MS-DOS)

(define (scheme-implementation-type) 'PocketScheme)
(define (scheme-implementation-version) "0.3.6")

(define in-vicinity string-append)

(define (implementation-vicinity)
  "\\Program Files\\Pocket Scheme\\")

(define (library-vicinity)
  (in-vicinity (implementation-vicinity) "slib\\"))

(define (home-vicinity)
  "\\My Documents\\")

(define *features*
  '(source
    rev4-report
    ieee-p1178
    rev4-optional-procedures
    multiarg/and-
    multiarg-apply
    with-file
    char-ready?
    defmacro
    delay
    eval
    dynamic-wind
    full-continuation
    ;;trace				; Comment out for SLIB TRACE macros
    system
    string-port
    ))

;;; (OUTPUT-PORT-WIDTH <port>)
(define (output-port-width . arg) 79)

;;; (OUTPUT-PORT-HEIGHT <port>)
(define (output-port-height . arg) 12)

;;; (TMPNAM) makes a temporary file name.
(define tmpnam (let ((cntr 100))
		 (lambda () (set! cntr (+ 1 cntr))
			 (string-append "slib_" (number->string cntr)))))

;;; (FILE-EXISTS? <string>)
(define (file-exists? f) 
  (let ((file #f))
    (with-handlers (((lambda (x) #t) (lambda (x) #f)))
		   (set! file (open-input-file f))
		   (close-input-port file)
		   #t)))

;; pscheme: current-error-port, delete-file, force-output already defined

;;; CHAR-CODE-LIMIT is one greater than the largest integer which can
;;; be returned by CHAR->INTEGER.
;(define char-code-limit
; (with-handlers (
;  ((lambda (x) #t) (lambda (x) 256))
;                )
;  (integer->char 65535)
;  65536))
;;; Currently there are only three clients of this symbol. 
;;; Following observations relate to PScheme 0.3.5, JACAL 1a9, SLIB 2c5.
;;; JACAL: crashes when set to 65536.
;;; make-crc: extremely inefficient when set to 65536, spending forever in init
;;; precedence-parse: ignores any setting in excess of 256
;;; So we patch it to 256.
(define char-code-limit 256)

;;; MOST-POSITIVE-FIXNUM is used in modular.scm
;;; This is the most positive immediate-value fixnum in PScheme.
;;; The secondary representation extends fixnum values to 0xffffffff.
(define most-positive-fixnum #x07FFFFFF)

;;; Return argument
(define (identity x) x)

;;; SLIB:EVAL is single argument eval using the top-level (user) environment.
(define slib:eval eval)

;;; If your implementation provides R4RS macros:
;(define macro:eval slib:eval)
;(define macro:load load)

(define gentemp
  (let ((*gensym-counter* -1))
    (lambda ()
      (set! *gensym-counter* (+ *gensym-counter* 1))
      (string->symbol
       (string-append "slib:G" (number->string *gensym-counter*))))))

(define base:eval slib:eval)
(define defmacro:eval slib:eval)

(define (slib:eval-load <pathname> evl)
  (if (not (file-exists? <pathname>))
      (set! <pathname> (string-append <pathname> (scheme-file-suffix))))
  (call-with-input-file <pathname>
    (lambda (port)
      (let ((old-load-pathname *load-pathname*))
	(set! *load-pathname* <pathname>)
	(do ((o (read port) (read port)))
	    ((eof-object? o))
	  (evl o))
	(set! *load-pathname* old-load-pathname)))))

(define (defmacro:load <pathname>)
  (slib:eval-load <pathname> defmacro:eval))

(define slib:warn
  (lambda args
    (let ((port (current-error-port)))
      (display "Warn: " port)
      (for-each (lambda (x) (display x port)) args))))

;;; Define an error procedure for the library
(define (slib:error . k)
  (error 
   (cond
    ((= (length k) 0) '())
    ((= (length k) 1) (car k))
    ((provided? 'string-port)
     (call-with-output-string
      (lambda (out)
	(let ((add-space #f))
	  (map
	   (lambda (arg)
	     (if add-space (write-char #\space out) (set! add-space #t))
	     (display arg out))
	   k)))))
    (else (car k)))))

;;; For the benefit of slib:error above, as announced by feature string-port
(define (call-with-output-string t)
  (let* ((p (open-output-string))
	 (r (t p))
	 (s (get-output-string p)))
    (close-output-port p)
    s))

(define (call-with-input-string s t)
  (let* ((p (open-input-string s))
	 (r (t p)))
    (close-input-port p)
    r))

;;; define these as appropriate for your system.
(define slib:tab (integer->char 9))
(define slib:form-feed (integer->char 12))

;;; Support for older versions of Scheme.  Not enough code for its own file.
(define (last-pair l) (if (pair? (cdr l)) (last-pair (cdr l)) l))
(define t #t)
(define nil #f)

;;; Define these if your implementation's syntax can support it and if
;;; they are not already defined.

(define (1+ n) (+ n 1))
(define (-1+ n) (+ n -1))
(define 1- -1+)

;;; Define SLIB:EXIT to be the implementation procedure to exit or
;;; return if exitting not supported.
(define slib:exit exit)

;;; Here for backward compatability
(define (scheme-file-suffix) ".scm")

;;; (SLIB:LOAD-SOURCE "foo") should load "foo.scm" or with whatever
;;; suffix all the module files in SLIB have.  See feature 'SOURCE.

(define (slib:load-source f)
  (if (not (file-exists? f))
      (set! f (string-append f (scheme-file-suffix))))
  (load f))

;;; (SLIB:LOAD-COMPILED "foo") should load the file that was produced
;;; by compiling "foo.scm" if this implementation can compile files.
;;; See feature 'COMPILED.

(define slib:load-compiled load)

;;; At this point SLIB:LOAD must be able to load SLIB files.

(define slib:load slib:load-source)

;;; Hold onto pscheme native version
(define pscheme:require require)
(slib:load (in-vicinity (library-vicinity) "require"))