| 1 |
;; |
| 2 |
(cl:defpackage "BERGMAN-PACKAGE" |
| 3 |
(:size 1500) |
| 4 |
(:nicknames "Bergman" "BP") |
| 5 |
(:use "COMMON-LISP" "EXT" "ENVIRON0") |
| 6 |
(:shadow "COMMON-LISP" |
| 7 |
"SET" |
| 8 |
"MAP" "MAPC" "MAPCAR" "MAPCAN" "NTH" "NTHCDR" "OPEN" "PRINT" "TIME" "ERROR" |
| 9 |
"TIMES" |
| 10 |
"SQRT") ; From primaux.sl |
| 11 |
(:export |
| 12 |
"DE" "DM" "DF" "GETD" "COPYD" "REMD" |
| 13 |
"DEFSWITCH" "C-ON" "C-OFF" "ON" "OFF" "*RAISE" "DEFMODES" |
| 14 |
"ADD1" "PLUS" "PLUS2" "INCR" |
| 15 |
"MINUS" "SUB1" "DIFFERENCE" "DECR" |
| 16 |
"TIMES" "TIMES2" |
| 17 |
"DIVIDE" "QUOTIENT" "REMAINDER" |
| 18 |
"MAX2" "MIN2" |
| 19 |
"EQN" "NEQ" "GREATERP" "LESSP" |
| 20 |
"FIXP" |
| 21 |
"PAIRP" "EVLIS" "MEMQ" "ATSOC" "NCONS" "MAP" "MAPC" "MAPCAR" "MAPCAN" |
| 22 |
"GETV" "MKVECT" "PUTV" "NTH" "NTHCDR" "PUT" |
| 23 |
"FLAG1" "FLAGP" "REMFLAG1" "FLAG" "REMFLAG" |
| 24 |
"$EOF$" "$EOL$" |
| 25 |
;"LOAD" |
| 26 |
"M-LAPIN" "M-DSKIN" "COMPILE-AND-LOAD" "RDS" "WRS" "OPEN" |
| 27 |
"CHANNELFLUSH" "FLUSHCHANNEL" |
| 28 |
"MKBMPATHEXPAND" "FILEP" |
| 29 |
"GLOBALa" "GLOBAL" "FLUID" "TIME" |
| 30 |
"ERROR" "ERRORSET" "CONTINUABLEERROR" |
| 31 |
"GTBPS" "LINELENGTH" "IDP" |
| 32 |
"anick" "hseries" "stg" |
| 33 |
"DOUBLEQUOTE" |
| 34 |
"CALLSHELL" "BANNER-OUTPUT" |
| 35 |
)) |
| 36 |
|
| 37 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (IN-PACKAGE "Bergman")) |
| 38 |
(TERPRI) |
| 39 |
|
| 40 |
; Very base |
| 41 |
; SET |
| 42 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (SHADOW 'SET) ) |
| 43 |
(defun SET (symbol value) (setf (symbol-value symbol) value)) |
| 44 |
; Definitions and special characters |
| 45 |
; !, %, DE, DM, DF, GETD, COPYD, REMD |
| 46 |
; DOUBLEQUOTE added by KAE 2005-07-31 |
| 47 |
|
| 48 |
(defun skipper (x y) (declare (ignore x y)) nil) |
| 49 |
(set-macro-character #\! #'skipper) |
| 50 |
(set-syntax-from-char #\! #\\) |
| 51 |
(set-macro-character #\% #'skipper) |
| 52 |
(set-syntax-from-char #\% #\;) |
| 53 |
|
| 54 |
(defmacro DE (x y &rest z) (append (list 'defun x y) z)) |
| 55 |
|
| 56 |
(defmacro DM (name (param) &rest body) |
| 57 |
`(defmacro ,name (&whole ,param &rest ignore) |
| 58 |
(declare (ignore ignore)) |
| 59 |
,@body) |
| 60 |
) |
| 61 |
|
| 62 |
(defmacro DF (name arg &body forms) |
| 63 |
`(defmacro ,name (&rest ,(car arg)) |
| 64 |
`(let |
| 65 |
((,',(car arg) (quote ,,(car arg)))) |
| 66 |
,',@forms |
| 67 |
) |
| 68 |
) |
| 69 |
) |
| 70 |
|
| 71 |
; DOUBLEQUOTE added by KAE 2005-07-31 |
| 72 |
(defvar DOUBLEQUOTE "\"") |
| 73 |
|
| 74 |
;KAE 2002-09-06 17:45:10 |
| 75 |
;VER 27/08/2002 Changed GETD to be closer to PSL definition |
| 76 |
;{expr, fexpr, macro, nexpr} . {code-pointer, lambda} |
| 77 |
(defun GETD (x) |
| 78 |
(cond |
| 79 |
((fboundp x) (cond |
| 80 |
((macro-function x) (CONS 'MACRO (macro-function x)) ) |
| 81 |
((special-operator-p x) nil ) |
| 82 |
(t (CONS 'EXPR (symbol-function x)) ) |
| 83 |
) |
| 84 |
) |
| 85 |
) |
| 86 |
) |
| 87 |
|
| 88 |
;KAE 2002-10-18 18:59:55 |
| 89 |
;(defun COPYD (to from) |
| 90 |
; (if (getd from) (system::\%putd to (symbol-function from)) |
| 91 |
; (lisp:print (list "Can't COPYD" to "from" from))) |
| 92 |
;) |
| 93 |
|
| 94 |
;(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (LISP:PRINT "before copyd") ) |
| 95 |
|
| 96 |
(defun COPYD (to from) |
| 97 |
(prog |
| 98 |
(x) |
| 99 |
(if (setq x (getd from)) |
| 100 |
(cond |
| 101 |
( (eq (car x) 'MACRO) (environ0:bm-copy-macro to from)) |
| 102 |
( T (environ0:bm-copy-function to from)) ) |
| 103 |
(lisp:print (list "Can't COPYD" to "from" from)) |
| 104 |
) |
| 105 |
) |
| 106 |
) |
| 107 |
|
| 108 |
(defun REMD (name) |
| 109 |
(if (fboundp name) |
| 110 |
(prog1 (getd name) |
| 111 |
(fmakunbound name)) |
| 112 |
nil) |
| 113 |
) |
| 114 |
|
| 115 |
; Switches |
| 116 |
; DEFSWITCH, C-ON, C-OFF, ON, OFF, *RAISE, DEFMODES |
| 117 |
|
| 118 |
(defmacro make-switch-name (x) |
| 119 |
(concatenate 'string "*" (string x)) |
| 120 |
) |
| 121 |
|
| 122 |
(defmacro DEFSWITCH |
| 123 |
(x &optional (on-form nil) (off-form nil) (init-value nil)) |
| 124 |
`(let (temp) |
| 125 |
(progn |
| 126 |
(setq temp (intern (make-switch-name ,x))) |
| 127 |
(eval (list 'defvar temp ,init-value)) |
| 128 |
(setf (get temp 'simpfg) (list (list t ,on-form) (list nil ,off-form))) |
| 129 |
(identity ',x) |
| 130 |
) |
| 131 |
) |
| 132 |
) |
| 133 |
|
| 134 |
(defmacro C-ON (x) |
| 135 |
`(let (temp) |
| 136 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) |
| 137 |
(prog2 (setq temp (intern (make-switch-name ,x))) |
| 138 |
; (set temp t) |
| 139 |
(setf (symbol-value temp) t) |
| 140 |
(eval (car (cdar (get temp 'simpfg)))) |
| 141 |
))) |
| 142 |
) |
| 143 |
|
| 144 |
(defmacro C-OFF (x) |
| 145 |
`(let (temp) |
| 146 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) |
| 147 |
(prog2 (setq temp (intern (make-switch-name ,x))) |
| 148 |
; (set temp nil) |
| 149 |
(setf (symbol-value temp) nil) |
| 150 |
(eval (car (cdadr (get temp 'simpfg)))) |
| 151 |
))) |
| 152 |
) |
| 153 |
|
| 154 |
(defmacro ON (x) |
| 155 |
`(let (temp) |
| 156 |
; (eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) |
| 157 |
(prog2 (setq temp (intern (make-switch-name ,x))) |
| 158 |
; (set temp t) |
| 159 |
(setf (symbol-value temp) t) |
| 160 |
(eval (car (cdar (get temp 'simpfg)))) |
| 161 |
));) |
| 162 |
) |
| 163 |
|
| 164 |
(defmacro OFF (x) |
| 165 |
`(let (temp) |
| 166 |
; (eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) |
| 167 |
(prog2 (setq temp (intern (make-switch-name ,x))) |
| 168 |
; (set temp nil) |
| 169 |
(setf (symbol-value temp) nil) |
| 170 |
(eval (car (cdadr (get temp 'simpfg)))) |
| 171 |
));) |
| 172 |
) |
| 173 |
|
| 174 |
; KAE 2004/05/13 RAISE definition converted to UPPER case |
| 175 |
(DEFSWITCH RAISE '(SETF (READTABLE-CASE *READTABLE*) :UPCASE) |
| 176 |
'(SETF (READTABLE-CASE *READTABLE*) :PRESERVE) |
| 177 |
) |
| 178 |
;(defswitch RAISE '(eval-when (eval load compile) |
| 179 |
; (setf (readtable-case *readtable*) :upcase)) |
| 180 |
; '(eval-when (eval load compile) |
| 181 |
; (setf (readtable-case *readtable*) :preserve)) |
| 182 |
; |
| 183 |
;) |
| 184 |
(ON RAISE) |
| 185 |
;(defswitch RAISE) |
| 186 |
|
| 187 |
(defmacro DEFMODES (x) |
| 188 |
(let (tempm temp tempd tempd1) |
| 189 |
(SETQ tempm (intern (concatenate 'string (string x) "-MODE"))) |
| 190 |
(SETQ tempd1 `(DEFSWITCH ,tempm)) |
| 191 |
(SETQ tempm (intern (concatenate 'string "*" (string x) "-MODE"))) |
| 192 |
(setq temp (intern (concatenate 'string (string x) "-SPECIFIC"))) |
| 193 |
(setq tempd |
| 194 |
`(defmacro ,temp (code) |
| 195 |
(cond (,tempm code) |
| 196 |
)) |
| 197 |
) |
| 198 |
(setq temp (intern (concatenate 'string (string x) "-AVOIDING"))) |
| 199 |
(list 'let '() tempd1 tempd |
| 200 |
`(defmacro ,temp (code) |
| 201 |
(cond ((NOT ,tempm) code) |
| 202 |
)) |
| 203 |
|
| 204 |
T) |
| 205 |
) |
| 206 |
) |
| 207 |
|
| 208 |
; Arithmetic, comparison, integer type |
| 209 |
; ADD1, PLUS, PLUS2, INCR, |
| 210 |
; MINUS, SUB1, DIFFERENCE, DECR, |
| 211 |
; TIMES, TIMES2, |
| 212 |
; DIVIDE, QUOTIENT, REMAINDER, |
| 213 |
; MAX2, MIN2 |
| 214 |
; EQN, NEQ, GREATERP, LESSP, |
| 215 |
; FIXP |
| 216 |
|
| 217 |
|
| 218 |
(defun ADD1 (x) (1+ x)) |
| 219 |
|
| 220 |
(defmacro PLUS (&rest arg) |
| 221 |
(cons '+ arg) |
| 222 |
) |
| 223 |
|
| 224 |
(defun PLUS2 (x y) (+ x y)) |
| 225 |
|
| 226 |
(defmacro INCR (x &optional (y 1)) `(incf ,x ,y)) |
| 227 |
|
| 228 |
(defun MINUS (x) (- x)) |
| 229 |
|
| 230 |
(defun SUB1 (x) (1- x)) |
| 231 |
|
| 232 |
(defun DIFFERENCE (x y) (- x y)) |
| 233 |
|
| 234 |
(defmacro DECR (x &optional (y 1)) `(decf ,x ,y)) |
| 235 |
|
| 236 |
; KAE 2003/11/15 20:05 |
| 237 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (SHADOW 'TIMES) ) |
| 238 |
|
| 239 |
(defmacro TIMES (&rest arg) |
| 240 |
(cons '* arg) |
| 241 |
) |
| 242 |
|
| 243 |
(defun TIMES2 (x y) (* x y)) |
| 244 |
|
| 245 |
(defun DIVIDE (x y) |
| 246 |
(multiple-value-bind (x1 y1) (truncate x y) (cons x1 y1)) |
| 247 |
) |
| 248 |
|
| 249 |
(defun QUOTIENT (x y) |
| 250 |
(if (and (integerp x) (integerp y)) |
| 251 |
(truncate x y) |
| 252 |
(/ x y))) |
| 253 |
|
| 254 |
(defun REMAINDER (x y) (rem x y)) |
| 255 |
|
| 256 |
(defun MAX2 (x y) (max x y)) |
| 257 |
|
| 258 |
(defun MIN2 (x y) (min x y)) |
| 259 |
|
| 260 |
(defun EQN (x y) (eql x y)) |
| 261 |
|
| 262 |
(defun NEQ (x y) (not (equal x y))) |
| 263 |
|
| 264 |
(defun GREATERP (x y) (> x y)) |
| 265 |
|
| 266 |
(defun LESSP (x y) (< x y)) |
| 267 |
|
| 268 |
(defun FIXP (x) (integerp x)) |
| 269 |
|
| 270 |
; List and vector operations |
| 271 |
; PAIRP, EVLIS, MEMQ, ATSOC, NCONS, MAP, MAPC, MAPCAR, MAPCAN, |
| 272 |
; GETV, MKVECT, PUTV, NTH NTHCDR, PUT |
| 273 |
|
| 274 |
(defun PAIRP (x) |
| 275 |
(and (listp x) x) |
| 276 |
) |
| 277 |
|
| 278 |
(defun EVLIS (u) |
| 279 |
(if (not (pairp u)) |
| 280 |
() |
| 281 |
(cons (eval (first u)) |
| 282 |
(evlis (rest u)) |
| 283 |
) |
| 284 |
) |
| 285 |
) |
| 286 |
|
| 287 |
(defun MEMQ (x y) (member x y :test #'eq)) |
| 288 |
|
| 289 |
; MOVED to slext.sl |
| 290 |
;(defun ATSOC (x y) (assoc x y :test #'eq)) |
| 291 |
|
| 292 |
; MOVED to slext.sl |
| 293 |
;(defun NCONS (itm) (cons itm nil)) |
| 294 |
|
| 295 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (shadow '(MAP MAPC MAPCAR MAPCAN)) ) |
| 296 |
|
| 297 |
(defun MAP (x y) (lisp:mapl y x) nil) |
| 298 |
|
| 299 |
(defun MAPC (x y) (lisp:mapc y x) nil) |
| 300 |
|
| 301 |
(defun MAPCAR (x y) (lisp:mapcar y x)) |
| 302 |
|
| 303 |
(defun MAPCAN (x y) (lisp:mapcan y x)) |
| 304 |
|
| 305 |
(defun GETV (x y) (svref x y)) |
| 306 |
|
| 307 |
(defun MKVECT (dim) |
| 308 |
(make-array (1+ dim)) |
| 309 |
) |
| 310 |
|
| 311 |
(defun PUTV (vec ind what) |
| 312 |
(setf (svref vec ind) what) |
| 313 |
) |
| 314 |
|
| 315 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (SHADOW '(NTH NTHCDR)) ) |
| 316 |
|
| 317 |
(defun NTH (lst index) |
| 318 |
(LISP:NTH index lst) |
| 319 |
) |
| 320 |
|
| 321 |
(defun NTHCDR (lst index) |
| 322 |
(LISP:NTHCDR index lst) |
| 323 |
) |
| 324 |
|
| 325 |
(defun PUT (sym prop val) (SETF (GET sym prop) val)) |
| 326 |
|
| 327 |
; Flags |
| 328 |
; FLAG1, FLAGP, REMFLAG1, FLAG, REMFLAG |
| 329 |
|
| 330 |
(defun FLAG1 (u v) (when (and (symbolp u) (symbolp v)) (setf (get u v) t))) |
| 331 |
|
| 332 |
(defun FLAGP (u v) (and (symbolp u) (symbolp v) (get u v))) |
| 333 |
|
| 334 |
(defun REMFLAG1 (u v) (when (and (symbolp u) (symbolp v)) (remprop u v))) |
| 335 |
|
| 336 |
;(defun FLAG (u v) (lisp:mapcar `(lambda (x) (flag1 x (quote ,v))) u)) |
| 337 |
|
| 338 |
;(defun REMFLAG (u v) (lisp:mapcar `(lambda (x) (remflag1 x (quote ,v))) u)) |
| 339 |
|
| 340 |
(DEFUN FLAG (u v) |
| 341 |
(EVAL `(LISP:MAPCAR #'(LAMBDA (x) (FLAG1 x (QUOTE ,v))) (QUOTE ,u))) |
| 342 |
) |
| 343 |
|
| 344 |
(DEFUN REMFLAG (u v) |
| 345 |
(EVAL `(LISP:MAPCAR #'(LAMBDA (x) (REMFLAG1 x (QUOTE ,v))) (QUOTE ,u))) |
| 346 |
) |
| 347 |
|
| 348 |
|
| 349 |
; File operations |
| 350 |
; $EOF$, $EOL$, |
| 351 |
; LOAD |
| 352 |
; M-LAPIN, M-DSKIN, COMPILE-AND-LOAD, RDS, WRS, OPEN, |
| 353 |
; ------ CHANNELFLUSH, FLUSHCHANNEL, |
| 354 |
; MKBMPATHEXPAND, FILEP |
| 355 |
; FASLOUT, FASLEND deleted by KAE and JoeB 2005-08-01. |
| 356 |
; LOAD added by KAE 2005-08-03 |
| 357 |
|
| 358 |
(proclaim '(special $EOF$ $EOL$)) |
| 359 |
(setq $EOF$ #\X) |
| 360 |
(setf (get '$EOF$ 'CHAR-CODE) 26) |
| 361 |
(setq $EOL$ #\NEWLINE) |
| 362 |
|
| 363 |
;(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (SHADOW 'LOAD) ) |
| 364 |
|
| 365 |
; a stub for LOAD: CLISP LOAD used now |
| 366 |
|
| 367 |
;(DEFUN LOAD (file) |
| 368 |
; (LISP:LOAD file) |
| 369 |
;) |
| 370 |
|
| 371 |
;(DEFUN |LoaD*1| (file) |
| 372 |
; (LISP:LOAD file) |
| 373 |
;) |
| 374 |
|
| 375 |
;(DEFUN LOAD (lst) |
| 376 |
; (LISP:MAPL '|LoaD*1| lst) |
| 377 |
;) |
| 378 |
|
| 379 |
(DEFUN M-LAPIN (|x| &OPTIONAL (|y| "lapin")) |
| 380 |
(WITH-OPEN-FILE (ISTREAM |x| :DIRECTION :INPUT) |
| 381 |
(PROG (*STANDARD-INPUT* |sav-raise|) |
| 382 |
(DECLARE (SPECIAL *RAISE)) |
| 383 |
(SETQ |sav-raise| *RAISE) |
| 384 |
(SETF *STANDARD-INPUT* ISTREAM) |
| 385 |
(COND (*LOAD-VERBOSE* |
| 386 |
(TERPRI) |
| 387 |
(LISP:PRINC ";; ") |
| 388 |
(LISP:PRINC |y|) |
| 389 |
(LISP:PRINC ": loading file ") |
| 390 |
(LISP:PRINC |x|) |
| 391 |
(LISP:PRINC " ...") |
| 392 |
(TERPRI) |
| 393 |
T)) |
| 394 |
(OFF RAISE) |
| 395 |
(LOOP WHILE (LISTEN ISTREAM) DO (EVAL (READ *STANDARD-INPUT* NIL $EOF$ NIL))) |
| 396 |
(COND (*LOAD-VERBOSE* |
| 397 |
(LISP:PRINC ";; ") |
| 398 |
(LISP:PRINC |y|) |
| 399 |
(LISP:PRINC ": loading of file ") |
| 400 |
(LISP:PRINC |x|) |
| 401 |
(LISP:PRINC " is finished.") |
| 402 |
(TERPRI) |
| 403 |
T)) |
| 404 |
(LET (|tt| |zz| |$lastf$|) |
| 405 |
(SETQ |tt| (LENGTH |x|)) |
| 406 |
(COND |
| 407 |
((STRING= (SUBSEQ |x| (- |tt| 2)) "sl") |
| 408 |
(OFF RAISE) |
| 409 |
(COMPILE-FILE |
| 410 |
|x| |
| 411 |
:OUTPUT-FILE (SETQ |$lastf$| |
| 412 |
(CONCATENATE |
| 413 |
'STRING (MKBMPATHEXPAND "$bmload/") |
| 414 |
(SUBSEQ |
| 415 |
(SETQ |zz| (FILE-NAMESTRING (PARSE-NAMESTRING |x|))) |
| 416 |
0 |
| 417 |
(- (LENGTH |zz|) 2) |
| 418 |
) |
| 419 |
"fas" |
| 420 |
) |
| 421 |
) |
| 422 |
) |
| 423 |
(OFF RAISE) |
| 424 |
(LOAD |$lastf$|) |
| 425 |
) |
| 426 |
(T (IDENTITY T)) |
| 427 |
) |
| 428 |
) |
| 429 |
(COND (|sav-raise| (ON RAISE)) |
| 430 |
(T (OFF RAISE)) |
| 431 |
) |
| 432 |
(RETURN T) |
| 433 |
) |
| 434 |
) |
| 435 |
) |
| 436 |
|
| 437 |
(DEFUN M-DSKIN (x) (M-LAPIN x "dskin")) |
| 438 |
|
| 439 |
(defun COMPILE-AND-LOAD (|x|) |
| 440 |
(LET (|tt| |zz| |$lastf$|) |
| 441 |
(SETQ |tt| (LENGTH |x|)) |
| 442 |
(COND |
| 443 |
((STRING= (SUBSEQ |x| (- |tt| 2)) "sl") |
| 444 |
(OFF RAISE) |
| 445 |
(COMPILE-FILE |
| 446 |
|x| |
| 447 |
:OUTPUT-FILE (SETQ |$lastf$| |
| 448 |
(CONCATENATE |
| 449 |
'STRING (MKBMPATHEXPAND "$bmload/") |
| 450 |
(SUBSEQ |
| 451 |
(SETQ |zz| (FILE-NAMESTRING (PARSE-NAMESTRING |x|))) |
| 452 |
0 |
| 453 |
(- (LENGTH |zz|) 2) |
| 454 |
) |
| 455 |
"fas" |
| 456 |
) |
| 457 |
) |
| 458 |
) |
| 459 |
(OFF RAISE) |
| 460 |
(LOAD |$lastf$|) |
| 461 |
) |
| 462 |
(T (IDENTITY T)) |
| 463 |
) |
| 464 |
) |
| 465 |
) |
| 466 |
|
| 467 |
(defun RDS (stream) |
| 468 |
(when (null stream) |
| 469 |
(setf stream *terminal-io*)) |
| 470 |
(prog1 *standard-input* |
| 471 |
(setf *standard-input* stream))) |
| 472 |
|
| 473 |
(defun WRS (stream) |
| 474 |
(when (null stream) |
| 475 |
(setf stream *terminal-io*)) |
| 476 |
(prog1 *standard-output* |
| 477 |
(setf *standard-output* stream))) |
| 478 |
|
| 479 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (shadow 'open) ) |
| 480 |
|
| 481 |
(defun OPEN (file how) |
| 482 |
(cond ((eq how 'INPUT) |
| 483 |
(lisp:open file :direction :input)) |
| 484 |
((eq how 'OUTPUT) |
| 485 |
(lisp:open file :direction :output :if-exists :supersede)) |
| 486 |
(T (lisp:error "***** Incorrect argumet to OPEN")) |
| 487 |
) |
| 488 |
) |
| 489 |
|
| 490 |
;(defun CHANNELFLUSH (stream) (force-output stream)) |
| 491 |
|
| 492 |
;(defun FLUSHCHANNEL (stream) (force-output stream)) |
| 493 |
;MOVED to slext.sl |
| 494 |
;(defun |FlushChannel| (stream) (force-output stream)) |
| 495 |
|
| 496 |
; FASLOUT and FASLEND deleted by KAE and JoeB 2005-08-01 |
| 497 |
;(defun FASLOUT (x) (declare (ignore x)) t) |
| 498 |
|
| 499 |
;(defun FASLEND () t) |
| 500 |
|
| 501 |
;(declaim (inline FASLOUT FASLEND)) |
| 502 |
|
| 503 |
(defun MKBMPATHEXPAND (fstr) |
| 504 |
(let* |
| 505 |
((p1 0) |
| 506 |
(p (cond |
| 507 |
((setq p1 (search "/" fstr)) p1) |
| 508 |
(t (length fstr)) |
| 509 |
) |
| 510 |
) |
| 511 |
(xa (subseq fstr 0 p)) |
| 512 |
(xd (subseq fstr p)) |
| 513 |
) |
| 514 |
(if (and (string/= xa "") (equal (char xa 0) #\$)) |
| 515 |
(let |
| 516 |
((xe (sys::getenv (subseq xa 1)))) |
| 517 |
(cond |
| 518 |
(xe (concatenate 'string xe xd)) |
| 519 |
(t (progn (sys::print (concatenate 'string "***** environment variable " xa " not defined"))) |
| 520 |
fstr |
| 521 |
) |
| 522 |
) |
| 523 |
) |
| 524 |
fstr |
| 525 |
) |
| 526 |
) |
| 527 |
) |
| 528 |
|
| 529 |
; MOVED to slext.sl |
| 530 |
;(defun FILEP (x) |
| 531 |
; (cond ((probe-file x) t) |
| 532 |
; ( t nil) |
| 533 |
; ) |
| 534 |
;) |
| 535 |
|
| 536 |
; Character and print operations |
| 537 |
; READCH, CHAR2STRING, READCHAR, UNREADCHAR, RATOM, |
| 538 |
; PRINT, PRIN2, TAB, COMPRESS, EXPLODE |
| 539 |
|
| 540 |
(defun READCH () (read-char)) |
| 541 |
|
| 542 |
(defun CHAR2STRING (ch) |
| 543 |
(make-sequence 'string 1 :initial-element ch) |
| 544 |
) |
| 545 |
|
| 546 |
(defun READCHAR () (char-code (read-char))) |
| 547 |
|
| 548 |
(defun UNREADCHAR (x) (unread-char (code-char x))) |
| 549 |
|
| 550 |
; RATOM in PSL returns symbol not char |
| 551 |
|
| 552 |
(defun identity-reader (stream chr_) |
| 553 |
(declare (ignore stream)) |
| 554 |
(car (list (intern (string chr_)))) |
| 555 |
) |
| 556 |
|
| 557 |
(defun star-reader (stream chr_) |
| 558 |
(declare (ignore chr_)) |
| 559 |
(let (char2) |
| 560 |
(setq char2 (read-char stream)) |
| 561 |
(cond ((eq char2 #\*) (identity '^)) |
| 562 |
(T (progn |
| 563 |
(unread-char char2 stream) |
| 564 |
(identity '*))) |
| 565 |
)) |
| 566 |
) |
| 567 |
|
| 568 |
; VER (the problem of keeping *RAISE in non-top-level loops) |
| 569 |
|
| 570 |
(defun RATOM () |
| 571 |
(let |
| 572 |
; ( (save-readtable (copy-readtable)) |
| 573 |
( (save-readtable *readtable*) |
| 574 |
(temp nil) |
| 575 |
) |
| 576 |
(setq *readtable* (copy-readtable)) |
| 577 |
(set-macro-character #\, #'identity-reader ) |
| 578 |
(set-macro-character #\; #'identity-reader ) |
| 579 |
(set-macro-character #\+ #'identity-reader ) |
| 580 |
(set-macro-character #\- #'identity-reader ) |
| 581 |
; (set-macro-character #\* #'identity-reader ) |
| 582 |
(set-macro-character #\* #'star-reader ) |
| 583 |
(set-macro-character #\^ #'identity-reader ) |
| 584 |
(set-macro-character #\/ #'identity-reader ) |
| 585 |
(set-macro-character #\: #'identity-reader ) |
| 586 |
; .... |
| 587 |
(setq temp (read)) |
| 588 |
(setq *readtable* save-readtable) |
| 589 |
temp |
| 590 |
) |
| 591 |
) |
| 592 |
|
| 593 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (shadow 'print) ) |
| 594 |
|
| 595 |
(defun PRINT (x &optional (stream *standard-output*)) |
| 596 |
(prog1 (prin1 x stream) (terpri)) |
| 597 |
) |
| 598 |
|
| 599 |
; PRIN2 is alike PRINC but PRINC does not handle correctly #\NEWLINE |
| 600 |
|
| 601 |
(defun PRIN2 (&rest x) |
| 602 |
(lisp:mapc #'(lambda (z) |
| 603 |
(if (and (stringp z) (/= (length z) 0)) |
| 604 |
(prog (temp (zz z)) |
| 605 |
ml |
| 606 |
(cond ((not (setq temp (position #\NEWLINE zz))) (princ zz)) |
| 607 |
(t (progn (princ (subseq zz 0 temp)) |
| 608 |
(write-char #\NEWLINE) |
| 609 |
(setq zz (subseq zz (1+ temp))) |
| 610 |
(go ml) |
| 611 |
) ) |
| 612 |
) ) |
| 613 |
(princ z) |
| 614 |
)) |
| 615 |
x) |
| 616 |
) |
| 617 |
|
| 618 |
(defun format-tabulate (stream |
| 619 |
&optional (colnum 1)) |
| 620 |
(if (null colnum) (setq colnum 1)) |
| 621 |
(let* ((new-colnum (max colnum 0)) |
| 622 |
(pos (sys::line-position stream))) |
| 623 |
(if (< pos new-colnum) |
| 624 |
(format-padding (- new-colnum pos) #\Space stream) |
| 625 |
(progn (terpri) (format-padding new-colnum #\Space stream)) |
| 626 |
|
| 627 |
) ) ) |
| 628 |
|
| 629 |
(defun format-padding (count char stream) |
| 630 |
(dotimes (i count) (write-char char stream)) |
| 631 |
) |
| 632 |
|
| 633 |
(defun TAB (x) (format-tabulate NIL x)) |
| 634 |
|
| 635 |
; KAE 2004/05/13 EXPLODE and COMPRESS redefined conformed to SL |
| 636 |
; Old definitions; will be deleted later |
| 637 |
;(DEFUN EXPLODE (ida) |
| 638 |
; (LISP:MAPCAR |
| 639 |
; #'(LAMBDA (idx) |
| 640 |
; (INTERN (STRING idx))) |
| 641 |
; (COERCE (STRING ida) 'LIST))) |
| 642 |
; |
| 643 |
;(DEFUN COMPRESS (lid) |
| 644 |
; (CAR (LIST (INTERN (COERCE |
| 645 |
; (LISP:MAPCAR |
| 646 |
; #'(LAMBDA (ch) (COERCE ch 'CHARACTER)) |
| 647 |
; lid) |
| 648 |
; 'STRING))))) |
| 649 |
|
| 650 |
; COMPRESS-EXPLODE functions work for integers, floats, strings, and symbols only |
| 651 |
; EXPLODE0 not exported; it's old EXPLODE renamed |
| 652 |
(DEFUN EXPLODE0 (ida) |
| 653 |
(LISP:MAPCAR |
| 654 |
#'(LAMBDA (idx) |
| 655 |
(INTERN (STRING idx))) |
| 656 |
(COERCE (STRING ida) 'LIST))) |
| 657 |
|
| 658 |
(DEFUN EXPLODE (ida) |
| 659 |
(COND ( (TYPEP ida 'SYMBOL) |
| 660 |
(EXPLODE0 ida) |
| 661 |
) |
| 662 |
( (TYPEP ida 'NUMBER) |
| 663 |
(COND ((INTEGERP ida) |
| 664 |
(EXPLODE0 (FORMAT NIL "~D" ida)) |
| 665 |
) |
| 666 |
((FLOATP ida) |
| 667 |
(EXPLODE0 (FORMAT NIL "~G" ida)) |
| 668 |
) |
| 669 |
(T NIL) |
| 670 |
) |
| 671 |
) |
| 672 |
( (TYPEP ida 'STRING) |
| 673 |
(EXPLODE0 (CONCATENATE 'STRING "\"" ida "\"" )) |
| 674 |
) |
| 675 |
(T NIL) |
| 676 |
) |
| 677 |
) |
| 678 |
; COMPRESS0 not exported; it's old COMPRESS renamed |
| 679 |
(DEFUN COMPRESS0 (lid) |
| 680 |
(CAR (LIST (INTERN (COERCE |
| 681 |
(LISP:MAPCAR |
| 682 |
#'(LAMBDA (ch) (COERCE ch 'CHARACTER)) |
| 683 |
lid) |
| 684 |
'STRING))))) |
| 685 |
; COMPRESS1 not exported; it's a part of the old COMPRESS making a string from exploded list |
| 686 |
(DEFUN COMPRESS1 (lid) |
| 687 |
(COERCE |
| 688 |
(LISP:MAPCAR |
| 689 |
#'(LAMBDA (ch) (COERCE ch 'CHARACTER)) |
| 690 |
lid) |
| 691 |
'STRING)) |
| 692 |
|
| 693 |
(DEFUN COMPRESS (lid) |
| 694 |
(COND ( (NULL lid) |
| 695 |
NIL |
| 696 |
) |
| 697 |
( T |
| 698 |
(PROG (S V P L) |
| 699 |
(SETQ S (COMPRESS1 lid)) |
| 700 |
(SETQ L (LENGTH S)) |
| 701 |
(MULTIPLE-VALUE-SETQ (V P) (READ-FROM-STRING S)) |
| 702 |
(COND ( (AND (= L P) (OR (TYPEP V 'INTEGER) (TYPEP V 'FLOAT) (TYPEP V 'STRING) ) ) |
| 703 |
(RETURN V) |
| 704 |
) |
| 705 |
( T |
| 706 |
(RETURN (COMPRESS0 lid)) |
| 707 |
) |
| 708 |
) |
| 709 |
) |
| 710 |
) |
| 711 |
) |
| 712 |
) |
| 713 |
|
| 714 |
; Miscellaneous |
| 715 |
; GLOBALa, GLOBAL, FLUID, TIME, |
| 716 |
; ERROR, ERRORSET, CONTINUABLEERROR, |
| 717 |
; GTBPS, LINELENGTH, IDP, |
| 718 |
; anick, hseries, stg, [variables] |
| 719 |
; CALLSHELL, BANNER-OUTPUT |
| 720 |
|
| 721 |
; KAE, Joeb 2004/06/02 19:27 Chisinau |
| 722 |
; added safe [variable] |
| 723 |
; deleted 2005-07-31 by KAE |
| 724 |
|
| 725 |
; KAE, Joeb 2004/06/05 11:29 Chisinau |
| 726 |
; added stg [variable] |
| 727 |
|
| 728 |
; KAE remade GLOBALa and GLOBAL 2006-07-31 Mon 16:36:40 |
| 729 |
|
| 730 |
(DEFUN |GLOBALa| (ll) |
| 731 |
(LISP:MAPC #'(LAMBDA (lst) |
| 732 |
(COND |
| 733 |
((BOUNDP lst) (EVAL (LIST 'DEFVAR lst))) |
| 734 |
(T (EVAL (LIST 'DEFVAR lst 'NIL))) |
| 735 |
)) |
| 736 |
ll) |
| 737 |
(EVAL `(PROCLAIM '(SPECIAL ,@ll)) ) |
| 738 |
) |
| 739 |
|
| 740 |
(DEFMACRO GLOBAL (ll) |
| 741 |
`(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (|GLOBALa| ,ll)) |
| 742 |
) |
| 743 |
|
| 744 |
|
| 745 |
(defmacro FLUID (ll) `(GLOBAL ,ll)) |
| 746 |
|
| 747 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (shadow 'TIME) ) |
| 748 |
|
| 749 |
(defun TIME () |
| 750 |
(car (list |
| 751 |
(round (* (/ (get-internal-run-time) |
| 752 |
internal-time-units-per-second |
| 753 |
) |
| 754 |
1000 |
| 755 |
) |
| 756 |
) |
| 757 |
)) |
| 758 |
) |
| 759 |
|
| 760 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (shadow 'ERROR) ) |
| 761 |
|
| 762 |
(defvar EMSG!* "BERGMAN error") |
| 763 |
(defvar |ErrorNum| 0) |
| 764 |
(proclaim '(special EMSG!* |ErrorNum|)) |
| 765 |
|
| 766 |
(defun ERROR (num str) |
| 767 |
(SETQ |ErrorNum| num) (SETQ EMSG!* str) (lisp:error str)) |
| 768 |
|
| 769 |
;(defun ERRORSET (x y z) (declare (ignore y z)) (eval x)) |
| 770 |
(defun ERRORSET (frame msgp backtr) (declare (ignore backtr)) |
| 771 |
(HANDLER-CASE (LIST (EVAL frame)) |
| 772 |
(SIMPLE-ERROR () (PROGN |
| 773 |
(COND (msgp (LISP:PRINC (FORMAT NIL "***** ~A" EMSG!*))) |
| 774 |
(T T)) |
| 775 |
|ErrorNum|))) |
| 776 |
) |
| 777 |
|
| 778 |
;(defun CONTINUABLEERROR () T) |
| 779 |
(defun CONTINUABLEERROR (&rest x) (declare (ignore x)) |
| 780 |
(SETQ EMSG!* "BERGMAN continuable error") |
| 781 |
(SETQ |ErrorNum| 0) |
| 782 |
(CERROR "You will continue BERGMAN" "")) |
| 783 |
|
| 784 |
(defun GTBPS (x) (declare (ignore x)) T) |
| 785 |
|
| 786 |
(declaim (inline GTBPS)) |
| 787 |
|
| 788 |
(defun LINELENGTH (x) (declare (ignore x)) T) |
| 789 |
(declaim (inline LINELENGTH)) |
| 790 |
|
| 791 |
(defun IDP (x) (symbolp x)) |
| 792 |
|
| 793 |
(defvar anick (MKBMPATHEXPAND "$bmexe/anick")) |
| 794 |
(defvar |anick| (MKBMPATHEXPAND "$bmexe/anick")) |
| 795 |
|
| 796 |
(defvar hseries (MKBMPATHEXPAND "$bmexe/hseries")) |
| 797 |
(defvar |hseries| (MKBMPATHEXPAND "$bmexe/hseries")) |
| 798 |
|
| 799 |
;(defvar safe (MKBMPATHEXPAND "$bmload/safe")) |
| 800 |
;(defvar |safe| (MKBMPATHEXPAND "$bmload/safe")) |
| 801 |
|
| 802 |
(defvar stg (MKBMPATHEXPAND "$bmload/stg")) |
| 803 |
(defvar |stg| (MKBMPATHEXPAND "$bmload/stg")) |
| 804 |
|
| 805 |
(defun CALLSHELL (f li) (declare (ignore f li)) |
| 806 |
(LISP:PRINT "Can't execute system command") |
| 807 |
) |
| 808 |
|
| 809 |
;(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) |
| 810 |
; (load "envvars.lsp") |
| 811 |
;) |
| 812 |
|
| 813 |
(defun BANNER-OUTPUT () |
| 814 |
(DECLARE (SPECIAL |*BMVersion*|)) |
| 815 |
(LISP:PRINC (FORMAT NIL "Welcome to the BERGMAN system. (v. ~A)" |*BMVersion*|)) |
| 816 |
(ON RAISE) |
| 817 |
(TERPRI) |
| 818 |
(ENVIRON0::ENVVARSSET) |
| 819 |
) |
| 820 |
|
| 821 |
(SETQ *PRINT-CIRCLE* T) |
| 822 |
|
| 823 |
(eval-when (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) |
| 824 |
(load "switches.lsp") |
| 825 |
) |
| 826 |
|
| 827 |
(OFF RAISE) |