scsh-0.6/scsh/scsh-package.scm

;;; The packages that scsh uses/defines.
;;; Copyright (c) 1994 by Olin Shivers.

;;; Note: field-reader package (fr.scm) and here docs use READ-LINE.
;;; It is defined in rdelim.scm.

;;; You link up a scsh package by defining a package named OS-DEPENDENT
;;; that satisfies the interfaces for packages
;;;     buffered-io-flags
;;;     posix-fdflags 
;;;     posix-errno
;;;     posix-signals
;;; Anything else it provides should be specified in an interface called
;;; os-extras-interface. See the scsh structure below.
;;; Then the scsh structure can be instantiated.
;;;
;;; The architecture directories, like next/ and irix/ and so forth,
;;; provide packages that can serve as the os-dependent package. E.g.,
;;; the next-defs package, defined in next/packages.
;;;
;;; This whole mechanism would be better solved with a functor.
;;;     -Olin


;;; The LET-OPT package for optional argument parsing & defaulting
;;; is found in the let-opt.scm file.


(define-structure error-package (export error warn)
  (open signals)
;  (optimize auto-integrate)
  )


(define-structure scsh-utilities scsh-utilities-interface
  (open bitwise error-package loopholes let-opt scheme)
  (files utilities)
;  (optimize auto-integrate)
  )


;;; This guy goes into the FOR-SYNTAX part of scsh's syntax exports.
(define-structure scsh-syntax-helpers
  (export transcribe-extended-process-form)
  (open receiving	; receive
	error-package
	names	        ; generated? by JMG
	scsh-utilities	; check-arg
	scheme
	)
  (files syntax-helpers)
;  (optimize auto-integrate)
  )


;;; The bufpol/{block, line, none} values
(define-structure buffered-io-flags buffered-io-flags-interface
  (open defenum-package scheme)
  (files (machine bufpol))
;  (optimize auto-integrate)
  )


(define-structure char-set-package char-set-interface  
  (open error-package
	ascii
	define-record-types	; JAR's record macro.
	scsh-utilities		; For DEPRECATED-PROC
	scheme)
  (files char-set)
;  (optimize auto-integrate)
  )


(define-structures ((tty-flags tty-flags-interface)
		    (scsh-internal-tty-flags scsh-internal-tty-flags-interface))
  (open scheme ascii bitwise)
  (files (machine tty-consts))
;  (optimize auto-integrate)
  )


(define-structure scsh-version scsh-version-interface
  (open scheme)
  (files scsh-version))

(define-structure partial-s48-ports
  (export current-input-port current-output-port
	  newline
	  current-error-port

	  $current-input-port
	  $current-output-port
	  $current-error-port
	  $current-noise-port)
  (open ports i/o))

(define-structure signal-handler signal-handler-interface
  (open scheme
	scsh
	scsh-level-0)
  (files (scsh sighandlers)))
;;; The scsh-level-0 package is for implementation convenience.
;;; The scsh startup and top-level modules need access to scsh
;;; procedures, but they export procedures that are themselves
;;; part of scsh. So scsh-level-0 is the core scsh stuff, which is
;;; imported by these two modules. These modules all collectively
;;; export the whole scsh enchilada.

(define-structures 
  ((scsh-level-0
    (compound-interface posix-fdflags-interface
			posix-errno-interface
			posix-signals-interface
			sockets-network-interface ; Standard Network Interface
			os-extras-interface ; Extra stuff from OS.
			scsh-delimited-readers-interface
			scsh-errors-interface
			scsh-io-interface
			scsh-file-interface
			scsh-process-interface
			scsh-process-state-interface
			scsh-user/group-db-interface
			scsh-command-line-interface
			scsh-signals-interface
			scsh-environment-interface
			scsh-home-interface
			scsh-string-interface
			scsh-file-names-interface
			scsh-misc-interface
			scsh-high-level-process-interface
			scsh-time-interface ; new in 0.2
			scsh-sockets-interface ; new in 0.3
			tty-interface ; new in 0.4
			scsh-version-interface
			char-set-interface
			signal-handler-interface
			;; This stuff would probably be better off kept
			;; in separate modules, but we'll toss it in for now.
			(interface-of ascii) ; char<->ascii
			string-ports-interface
			))
   (scsh-level-0-internals (export set-command-line-args!
				   init-scsh-hindbrain
				   init-scsh-vars))
;   (scsh-regexp-package scsh-regexp-interface)
)
  (for-syntax (open scsh-syntax-helpers scheme))
  (open enumerated
	external-calls           ;JMG new FFI
	structure-refs
	cig-aux
	receiving
	defrec-package
	define-foreign-syntax
	formats
	os-dependent		; OS dependent stuff
	buffered-io-flags	; stdio dependent
	ascii
	records
	extended-ports
	partial-s48-ports
	ports
	build
	bigbit
	bitwise
	signals
	conditions
	scsh-utilities
	handle
	fluids
	weak

;	scsh-regexp-package
;	scsh-regexp-internals
	char-set-package
	scsh-version
	tty-flags
	scsh-internal-tty-flags	; Not exported
	let-opt			; optional-arg parsing & defaulting
	
	architecture     ; Was this by JMG ??
	interrupts	; signal handler code

	re-level-0
	rx-syntax

	string-lib

	loopholes	; For my bogus CALL-TERMINALLY implementation.

	scheme
	
	
	i/o                  ; all these seem to be for scsh-0.6 JMG
	i/o-internal
	channels channel-i/o
	low-channels
	code-vectors
	threads threads-internal locks placeholders
	primitives
	escapes
	command-levels
	features
	general-tables)
  (for-syntax (open scsh-syntax-helpers scheme))
  (access command-processor
	  escapes
	  i/o		; S48's force-output
	  formats
	  records	; I don't think this is necessary. !!!
	  scheme)	; For accessing the normal I/O operators.
  (files syntax
	 syscalls
	 select
	 fname
	 stringcoll
	 scsh-condition
	 rw
	 newports
	 fdports
	 procobj		; New in release 0.4.
	 (machine waitcodes)	; OS dependent code.
	 filesys
	 fileinfo
	 glob
;	 filemtch
	 time			; New in release 0.2.
	 (machine time_dep)
	 network		; New in release 0.3.
	 endian			; New in release 0.4.
	 flock			; New in release 0.4.
	 tty			; New in release 0.4.
	 pty			; New in release 0.4.
	 sighandlers		; New in release 0.5.
	 scsh
;	 re
	 rdelim  
	 )
;  (optimize auto-integrate)
  )

(define-structure defrec-package (export (define-record :syntax))
  (open records scheme)
  (for-syntax (open scheme error-package receiving))
  (files defrec)
;  (optimize auto-integrate)
  )

(define-structure defenum-package (export (define-enum-constant  :syntax)
					  (define-enum-constants :syntax))
  (open scheme)
  (files enumconst)
;  (optimize auto-integrate)
  )

;;; This code opens so many modules of gruesome, low-level S48 internals 
;;; that these two modules are segregated into separate packages, each
;;; exporting just two definitions.

(define-structure scsh-startup-package (export dump-scsh-program 
					       dump-scsh
					       make-scsh-starter
					       scsh-stand-alone-resumer)
  (open scsh-level-0-internals	; init-scsh-* set-command-line-args!
	scsh-level-0		; error-output-port command-line-arguments
	scsh-top-package	; parse-switches-and-execute
	handle			; with-handler
	command-levels  	; user-context
	write-images		; write-image
	build-internals		; simple-condition-handler
	low-level		; flush-the-symbol-table!
	command-processor	; command-output
	package-commands-internal
	filenames		; translate
	usual-resumer           ; usual-resumer
	fluids-internal            ; JMG: get-dynamic-env 
	scsh-utilities
	interrupts
	primitives
	scheme)
  (files startup))

(define-structure scsh-top-package (export parse-switches-and-execute 
					   repl )
  (open command-processor
	command-levels          ; with-new-session
	char-set-package
	ensures-loaded
	environments
	error-package
	evaluation
	extended-ports
	interfaces

	fluids-internal            ; JMG: get-dynamic-env 
	handle                     ; JMG: with-handler
;	package-commands
	interrupts
	i/o
	package-commands-internal
	package-mutation
	packages
	receiving
	scsh-version
	scsh-level-0		; with-current-input-port error-output-port
				; with-current-output-port exit
	scsh-level-0-internals	; set-command-line-args! init-scsh-vars
	scheme)
  (files top meta-arg))


(define-structure field-reader-package scsh-field-reader-interface
  (open receiving		; receive
	char-set-package
	scsh-utilities		; nth
	error-package		; error
	scsh-level-0		; delimited readers
;	scsh-regexp-package
	re-exports
	string-lib		; join-strings
	let-opt			; optional-arg parsing & defaulting
	scheme
	)
  (files fr))


(define-structures
  ((awk-expander-package (export expand-awk expand-awk/obsolete))
   (awk-support-package (export next-range next-:range
				next-range: next-:range:)))
  (open receiving		; receive
	scsh-utilities	
	error-package		; error
;	scsh-regexp-package
;	re-exports
	sre-syntax-tools
	scheme
	)
  (files awk) 
;  (optimize auto-integrate)
)
	 

(define-structure awk-package awk-interface
  (open awk-support-package	; These packages provide all the stuff 
	re-exports		; that appears in the code produced by 
	receiving		; an awk expansion.
	scheme)
  (for-syntax (open awk-expander-package scheme))
  (begin (define-syntax awk expand-awk)
	 (define-syntax awk/posix-string expand-awk/obsolete)))

;;; Exports an AWK macro that is just AWK/POSIX-STRING.
(define-structure obsolete-awk-package (export (awk :syntax))
  (open awk-package)
  (begin (define-syntax awk 
           (syntax-rules () ((awk body ...) (awk/posix-string body ....))))))

(define-structure scsh
  (compound-interface (interface-of scsh-level-0)
		      (interface-of scsh-startup-package)
;		      scsh-regexp-interface
		      re-exports-interface
		      re-old-funs-interface
		      scsh-field-reader-interface 	; new in 0.3
;		      scsh-dbm-interface
		      (export repl)
		      awk-interface
		      )

  (open structure-refs
	scsh-level-0
	scsh-level-0-internals
	re-exports
	re-old-funs
;	scsh-regexp-package
	scsh-startup-package
;	dbm
	awk-package
	field-reader-package
	scheme)

  (access scsh-top-package)
  (begin (define repl (structure-ref scsh-top-package repl)))
;  (optimize auto-integrate)
  )

(define-structure scsh-here-string-hax (export)
  (open reading
	receiving
	scsh		; Just need the delimited readers.
	features	; make-immutable!
	scheme)
  (files here))

(define-structure events event-interface
  (open scsh-level-0
	defrec-package
	locks
	placeholders
	architecture
	scheme
	interrupts)
  (files event))

;(define-structure test-package (export test-proc)
;  (open scsh-regexp-package scheme)
;  (begin (define (test-proc p)
;	   (regexp-substitute p
;			      (string-match "(foo)(.*)(bar)" "Hello foo Olin bar quux")
;			      'post 3 1 2 'pre))))


(define-structure scsh-threads
  (export fork/thread
	  fork/process
	  wait/thread
	  wait/process)
  (open structure-refs
	scheme)
  (access scsh-level-0
	  threads
	  threads-internal)
  (files threads))