"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

Object subclass:#Smalltalk

	instanceVariableNames:''

	classVariableNames:'StartBlocks ImageStartBlocks ExitBlocks CachedClasses SystemPath

		StartupClass StartupSelector StartupArguments CommandLine

		CommandLineArguments CachedAbbreviations SilentLoading

		Initializing StandAlone HeadlessOperation LogDoits LoadBinaries

		RealSystemPath ResourcePath SourcePath BitmapPath BinaryPath

		FileInPath PackagePath BinaryDirName ResourceDirName

		SourceDirName BitmapDirName PackageDirName FileInDirName

		ChangeFileName ImageStartTime ImageRestartTime DemoMode

		SaveEmergencyImage SpecialObjectArray LoadedPackages

		KnownPackages'

	poolDictionaries:''

	category:'System-Support'

!

!Smalltalk class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    This is one of the central classes in the system;

    it provides all system-startup, shutdown and maintenance support.

    Also global variables are (conceptionally) kept here.

    As you will notice, this is NOT a Dictionary

    - my implementation of globals is totally different

      due to the need to be able to access globals from c-code as well,

      I do not use associations for globals, but instead keep the

      name<->value relations in the VM and access globals via utility

      functions found there.

    However, it provides the known enumeration protocol.

    It may change to become a subclass of collection at some time,

    to inherit more collection stuff ...

    [Instance variables:]

					none - all handling is done in the VM

    [Class variables:]

	StartBlocks     <Collection>    blocks to be executed in a separate process after

					everything has been initialized. These blocks will

					be deleted after execution and therefore not be

					executed after an image restart. Initial processes

					(such as the Launcher) are usually started here.

					These blocks are added by smalltalk.rc/private.rc etc.

					via #addStartBlock during early initialization.

	ImageStartBlocks 

			<Collection>    blocks to be executed in a separate process after

					everything has been initialized. These blocks will be

					executed after an image restart.

					These blocks are usually added by smalltalk_r.rc etc.

	ExitBlocks      <Collection>    blocks to evaluate before system is

					left. Not currently used (GNU-ST compatibility).

	SystemPath      <Collection>    path to search for system files (sources, bitmaps etc)

					Set to a default here, but typically changed from some

					startup.rc file

	PackagePath     <Collection>    path to search for package.

					This is going to replace the above systemPath, and a classes

					resources will eventually searched in its package directory.

					This list defines the path, where packages are searched for,

					initially this is something like /opt/smalltalk/packages.

					Set to a default here, but typically changed from some

					startup.rc file

	StartupClass    <Class>         class and selector, where the system starts up

	StartupSelector <Symbol>        (right after VM initialization)

	StartupArguments <Array>        If an image is saved while those being nonNil, 

					the image will come up there.

					Allows for customized images to be

					generated from a standard ST/X.

	CommandLine          <String>   Unix (OS-) command line

	CommandLineArguments <Array>    Unix (OS-) command line arguments broken into words

					(initially set by the VM)

	SilentLoading   <Boolean>       suppresses messages during fileIn and in compiler

					(can be set to true from a customized main.c)

	Initializing    <Boolean>       true while (re-)initializing

					Controls the behavior of certain error

					reporters (for example: suppress dialogBoxes)

					while the system is not yet fit for full operation.

	StandAlone      <Boolean>       true, if this is a standalone app;

					if true the process scheduler watches for

					which processes are still running, and 

					exits ST/X, when the last non-background

					and non-system process exits.

	HeadlessOperation               if true, a non-existing Display connection

			<Boolean>       will NOT lead to an error-exit during startup.

					Default is false.

					Can be set in an application-specific startup script. 

	LogDoits        <Boolean>       if true, doits are also logged in the changes

					file. Default is false, since the changes file

					may become huge if every tiny doIt is saved there ...

	LoadBinaries    <Boolean>       if true, we attempt to load classes rom a binary

					file, if present. If false, this is always suppressed.

	SaveEmergencyImage <Boolean>    if true (the default), an emergency image

					is saved, if the main Display looses its

					connection. This is useful if you have a

					flaky display connection (serial line)

					and want to have your stuff saved automatically

					in case of a broken connection.

    strictly private classVariables (helpers):

	CachedClasses   <Collection>    known classes (cached for faster class enumeration)

	CachedAbbreviations

			<Dictionary>    className to filename mappings

	RealSystemPath  <Collection>    cached collection of directories along the path

					which really exist. Caching avoids long checks

					for existing directories on broken NFS volumes.

	SourcePath      <Collection>    cached names of really existing directories

	BitmapPath                      These are remembered, since in NFS systems,

	ResourcePath                    the time to lookup files may become long

	BinaryPath                      (especially, if some directories are on machines

	FileInPath                      which are not up ...). 

					Therefore, the set of really

					existing directories is cached when the SystemPath

					is walked the first time.

					A consequence is that you have to invoke

					flushSystemPath, when you create any of those

					directories while running

					(and want the running ST/X to look there)

    [author:]

	Claus Gittinger

    [see also:]

	ObjectMemory

"

! !

!Smalltalk class methodsFor:'initialization'!

initGlobalsFromEnvironment

    "setup globals from the shell-environment"

    |envString i langString terrString|

    StandAlone isNil ifTrue:[

        StandAlone := false.

    ].

    "

     extract Language and LanguageTerritory from LANG variable.

     valid are for example: english_us / us_us / us

                            english / en_en / en

                            german / de_de / de

                            german_austria

    "

    Language := #english.

    LanguageTerritory := #us.

    envString := OperatingSystem getEnvironment:'LANG'.

    envString size > 0 ifTrue:[

        i := envString indexOf:$_.

        (i == 0) ifTrue:[

            langString := envString.

            terrString := envString

        ] ifFalse:[

            langString := envString copyTo:(i - 1).

            terrString := envString copyFrom:(i + 1)

        ].

        Language := langString asLowercase asSymbol.

        LanguageTerritory := terrString asLowercase asSymbol

    ].

    "

     Smalltalk initGlobalsFromEnvironment

    "

    "Modified: 22.2.1996 / 16:59:12 / cg"

!

initInterrupts

    "initialize interrupts"

    OperatingSystem enableUserInterrupts.

    OperatingSystem enableHardSignalInterrupts.

    ObjectMemory userInterruptHandler:self.

    ObjectMemory signalInterruptHandler:self.

    ObjectMemory recursionInterruptHandler:self.

    "

     Smalltalk initInterrupts

    "

    "Modified: 20.8.1997 / 09:35:49 / stefan"

!

initStandardStreams

    "initialize some well-known streams"

    Stdout := NonPositionableExternalStream forStdout.

    Stderr := NonPositionableExternalStream forStderr.

    Stdin := NonPositionableExternalStream forStdin.

    Printer := PrinterStream.

    Transcript := Stderr

    "

     Smalltalk initStandardStreams

    "

!

initStandardTools

    "predefine some tools which we will need later

     - if the view-classes exist,

       they will redefine Inspector and Debugger for graphical interfaces"

    "redefine debug-tools, if view-classes exist"

    Display notNil ifTrue:[

        InspectorView notNil ifTrue:[

            Inspector := InspectorView

        ].

        DebugView notNil ifTrue:[

            Debugger := DebugView

        ].

        Display initialize

    ]

    "

     Smalltalk initStandardTools

    "

!

initSystemPath

    "setup path where system files are searched for.

     the default path is set to:

	    .

	    $HOME                    (if defined)

	    $HOME/.smalltalk         (if defined & existing)

	    $SMALLTALK_LIBDIR        (if defined & existing)

	    $STX_LIBDIR              (if defined & existing)

	    $STX_TOPDIR              (if defined & existing)

     unix:

	    /opt/smalltalk           (if existing)

	    /opt/smalltalk/release   (if existing)

	    /usr/local/lib/smalltalk (if existing)

	    /usr/lib/smalltalk       (if existing)

	    /lib/smalltalk           (if existing)

     win32:

	    \smalltalk                (if existing)

	    \programs\smalltalk       (if existing)

	    \programs\exept\smalltalk (if existing)

	    registry info             (if present)

     vms:

	    $stx:lib                 (if existing)

	    $stx:root                (if existing)

     of course, it is possible to add entries from the 'smalltalk.rc'

     startup file; add expressions such as:

	    Smalltalk systemPath addFirst:'/foo/bar/baz'.

	or: 

	    Smalltalk systemPath addLast:'/fee/foe/foo'.

     However, smalltalk.rc itself must be found along the above path.

    "

    ChangeFileName := 'changes'.

    OperatingSystem isVMSlike ifTrue:[

	BitmapDirName := 'bitmaps.dir'.

	BinaryDirName := 'binary.dir'.

	SourceDirName := 'source.dir'.

	ResourceDirName := 'resources.dir'.

	FileInDirName := 'filein.dir'.

	PackageDirName := 'packages.dir'.

    ] ifFalse:[

	BitmapDirName := 'bitmaps'.

	BinaryDirName := 'binary'.

	SourceDirName := 'source'.

	ResourceDirName := 'resources'.

	FileInDirName := 'fileIn'.

	PackageDirName := 'packages'.

    ].

    SystemPath isNil ifTrue:[

	SystemPath := OperatingSystem defaultSystemPath.

	self flushPathCaches

    ].

    PackagePath isNil ifTrue:[

	PackagePath := OperatingSystem defaultPackagePath.

    ].

    "

     Smalltalk initSystemPath

     Smalltalk systemPath

    "

    "Modified: / 24.12.1999 / 00:23:35 / cg"

!

initUserPreferences

    "setup other stuff"

    LogDoits := false.

    LoadBinaries := false.

    SaveEmergencyImage := true.

    "Modified: / 24.10.1997 / 18:22:47 / cg"

!

initializeModules

    "perform module specific initialization and

     send #initialize to all classes.

     Notice: this is not called when an image is restarted"

    " TODO:

     change VM/stc to invoke #Smalltalk initializeClass:aClass

     (instead of directly sending #initialize)

     This will allow us to wrap an exception handler around classes

     #initialize methods."

%{

    __init_registered_modules__(3);

    @global(DemoMode) = __getDemoMode() ? true : false;

    RETURN (self);

%}.

    ^ self primitiveFailed

!

initializeSystem

    "initialize all other classes; setup dispatcher processes etc.

     This one is the very first entry into the smalltalk world,

     right after startup, ususally immediately followed by Smalltalk>>start.

     Notice: 

        this is not called when an image is restarted; in this

        case the show starts in Smalltalk>>restart."

    Initializing := true.

    AbstractOperatingSystem initializeConcreteClass.

    CommandLineArguments isNil ifTrue:[

        CommandLineArguments := #('stx').

    ].

    CommandLine := CommandLineArguments copy.

    CommandLineArguments := CommandLineArguments asOrderedCollection.

    CommandLineArguments removeAtIndex:1. "/ the command

    SilentLoading := (CommandLineArguments includes:'--silentStartup').

    "/

    "/ define low-level debugging tools - graphical classes are not prepared yet

    "/ to handle things. 

    "/ This will bring us into the MiniDebugger when an error occurs

    "/ during startup

    "/

    Inspector := MiniInspector.

    Debugger := MiniDebugger.

    "/

    "/ start catching SIGSEGV and SIGBUS

    "/

    OperatingSystem enableHardSignalInterrupts.

    self initGlobalsFromEnvironment.

    "/

    "/ sorry - there are some, which MUST be initialized before ..

    "/ reason: if any error happens during init, we need Signals, Stdout etc. to be there

    "/

    Object initialize.

    Signal initialize.

    Filename initialize.

    ObjectMemory initialize.

    OperatingSystem initialize.

    Stream initialize.

    ExternalStream initialize.

    self initStandardStreams.    "/ setup Stdin, Stdout etc.

    "/

    "/ sorry, path must be set before ...

    "/ reason: some classes need it during initialize (they might need resources, bitmaps etc)

    "/

    self initSystemPath.

    "/

    "/ must init display here - some classes (Color, Form) need it during initialize

    "/"

    Workstation notNil ifTrue:[

        Workstation initialize

    ].

    Compiler := ByteCodeCompiler.

    Compiler isNil ifTrue:[

        "

         ByteCodeCompiler is not in the system (i.e. has not been linked in)

         this allows at least immediate evaluations for runtime systems without compiler

         NOTICE: a parser is always needed, otherwise we cannot read resource files etc.

        "

        Compiler := Parser

    ].

    "/

    "/ another one, to be initialized before others

    "/

    ProcessorScheduler initialize.

    "/

    "/ now, finally, initialize all other classes

    "/

    self initializeModules.

    ImageStartTime := AbsoluteTime now.

    Display notNil ifTrue:[

        Display initialize.

        Display initializeDeviceResources.

    ].

    self initInterrupts.

    self initUserPreferences.

    "/

    "/ give classes a chance to perform 2nd-level initialization

    "/ now, we are certain, that all other classes have been initialized

    "/ (especially: streams and signals can now be used)

    "/

    ObjectMemory changed:#initialized.

    "Modified: 8.1.1997 / 19:58:12 / stefan"

    "Modified: 7.9.1997 / 23:34:44 / cg"

!

isInitialized

    "this returns true, if the system is properly initialized;

     i.e. false during startup. Especially, the whole viewing stuff is

     not working correctly until initialized."

    ^ Initializing not

!

reinitStandardStreams

    "reinitialize some well-known streams.

     Tis must be done very early during startup, to allow for

     debug and trace messages to be output