"

 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.

"

Object subclass:#Smalltalk

	instanceVariableNames:''

	classVariableNames:'ExitBlocks CachedClasses SystemPath StartupClass StartupSelector

		StartupArguments CommandLineArguments CachedAbbreviations

		SilentLoading Initializing StandAlone LogDoits LoadBinaries

		RealSystemPath ResourcePath SourcePath BitmapPath BinaryPath

		FileInPath ImageStartTime ImageRestartTime DemoMode'

	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).

    However, it provides the known enumeration protocol.

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

    Instance variables:

					none - all handling is done in the VM

    Class variables:

	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

	StartupClass    <Class>         

	StartupSelector <Symbol>        

	StartupArguments <Array>

					class and selector, where the system starts up

					(right after VM initialization)

					If an image is saved while this is nonNil, the image will come up

					there.

	CommandLineArguments <Array>    command line broken into words

	SilentLoading   <Boolean>       suppresses messages during fileIn and in compiler

					(can be set to true from a customized main)

	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.

	ImageStartTime  <AbsoluteTime>  timestamp when this system was started the very first time

					(i.e. the time of the initial start without an image)

	ImageRestartTime

			<AbsoluteTIme>  timestamp when this image was started

    strictly private classVariables (helpers):

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

	CachedAbbreviations

			<Dictionary>    className to filename mappings

	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.

"

! !

!Smalltalk class methodsFor:'initialization'!

initGlobalsFromEnvironment

    "setup globals from the shell-environment"

    |envString i langString terrString|

    "

     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 notNil ifTrue:[

        envString isEmpty ifFalse:[

            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.

    OperatingSystem enableFpExceptionInterrupts.

    ObjectMemory userInterruptHandler:self.

    ObjectMemory signalInterruptHandler:self.

    ObjectMemory recursionInterruptHandler:self.

    "

     Smalltalk initInterrupts

    "

!

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)

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

	    /usr/lib/smalltalk       (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'.

    "

    |p homePath|

    SystemPath isNil ifTrue:[

	homePath := OperatingSystem getHomeDirectory.

	homePath isNil ifTrue:[

	    homePath := '.'

	].

	"

	 the path is set to search files first locally

	 - this allows private stuff to override global stuff

	"

	SystemPath := OrderedCollection new.

	SystemPath add:'.'.

	SystemPath add:'..'.

	SystemPath add:homePath.

	(OperatingSystem isDirectory:(p := homePath , '/.smalltalk')) ifTrue:[

	    SystemPath add:p

	].

	p := OperatingSystem getEnvironment:'SMALLTALK_LIBDIR'.

	p notNil ifTrue:[

	    SystemPath add:p

	].

	p := OperatingSystem getEnvironment:'STX_LIBDIR'.

	p notNil ifTrue:[

	    SystemPath add:p

	].

	(OperatingSystem isDirectory:'/usr/local/lib/smalltalk') ifTrue:[

	    SystemPath add:'/usr/local/lib/smalltalk'

	].

	(OperatingSystem isDirectory:'/usr/lib/smalltalk') ifTrue:[

	    SystemPath add:'/usr/lib/smalltalk'

	].

	self flushPathCaches

    ]

    "

     Smalltalk initSystemPath

     Smalltalk systemPath

    "

!

initUserPreferences

    "setup other stuff"

    LogDoits := false.

    LoadBinaries := false.

!

initializeModules

    "perform module specific initialization and

     send #initialize to all classes.

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

%{

    __init_registered_modules__(3 COMMA_CON);

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

%}

!

initializeSystem

    "initialize all other classes; setup dispatcher processes etc.

     This one is the first entry into the smalltalk world right after startup,

     ususally followed by Smalltalk>>start.

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

     case the show starts in Smalltalk>>restart."

%{

#ifdef WIN32

    printf("here initializeSystem\n");

#endif

%}.

    SilentLoading := false.

    Initializing := true.

    "

     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.

    ObjectMemory 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

    ].

    "

     now, finally, initialize all other classes

    "

    self initializeModules.

"/    self allBehaviorsDo:[:aClass |

"/ 'init ' print. aClass name printNL.

"/      aClass initialize

"/    ].

    ImageStartTime := AbsoluteTime now.

    Display notNil ifTrue:[

	Display initialize.

    ].

    self initInterrupts.

    self initUserPreferences.

    "Modified: 13.12.1995 / 17:43:27 / 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

     (otherwise, the file-descriptors are invalid)"

    Stdout reOpen. Stderr reOpen. Stdin reOpen.

! !

!Smalltalk class methodsFor:'accessing'!

at:aKey

    "retrieve the value stored under aKey, a symbol. 

     Return nil if not present (this will be changed to trigger an error)"

%{  /* NOCONTEXT */

    RETURN ( __GLOBAL_GET(aKey) );

%}

!

at:aKey ifAbsent:aBlock

    "retrieve the value stored at aKey.

     If there is nothing stored under this key, return the value of

     the evaluation of aBlock."

    (self includesKey:aKey) ifTrue:[

	^ self at:aKey

    ].

    ^ aBlock value

    "

     Smalltalk at:#fooBar                       <- returns nil

     Smalltalk at:#fooBar ifAbsent:['sorry']    <- no error

    "

!

at:aKey put:aValue

    "store the argument aValue under aKey, a symbol"

" "

    |oldValue|

%{

    oldValue = __GLOBAL_SET(aKey, aValue, (OBJ *)0);

%}.

    CachedClasses notNil ifTrue:[

	oldValue isBehavior ifTrue:[

	    oldValue name == aKey ifTrue:[

		CachedClasses remove:oldValue ifAbsent:[]

	    ]

	].

	aValue isBehavior ifTrue:[

	    aValue isMeta ifTrue:[

		self halt

	    ].

	    CachedClasses add:aValue

	].

    ].

    ^ aValue.

" "

%{  /* NOCONTEXT */

    (void) __GLOBAL_SET(aKey, aValue, (OBJ *)0);

%}.

    CachedClasses := nil.

    ^ aValue

!

currentNameSpace

    ^ self

!

includesKey:aKey

    "return true, if the key is known"

%{  /* NOCONTEXT */

    RETURN ( __GLOBAL_KEYKNOWN(aKey) );

%}

!

keyAtValue:anObject

    "return the symbol under which anObject is stored - or nil"

    self keysDo:[:aKey |

	(self at:aKey) == anObject ifTrue:[^ aKey]

    ].

    ^ nil

    "Smalltalk keyAtValue:Object"

!

keys

    "return a collection with all keys in the Smalltalk dictionary"

    |keys|

    keys := IdentitySet new.

    self keysDo:[:k | keys add:k].

    ^ keys

!

removeKey:aKey

    "remove the association stored under the key-argument from the globals dictionary.

     WARNING: 

	this is somewhat dangerous: conceptionally, the association is removed,

	to which machine & byte compiled code refers if it accesses a global.

	If there are still global accesses in some literalArray or from machine-compiled code,

	it continues to reference the globals value via that obsolete association and gets a nil

	value.  (which is correct)

	However, if that global is later reintroduced, a new association will be created and

	the new global now referenced via the new association.

	The old accesses will still see nil, although the globals value is actually non-nil

	(this is questionable).

	To avoid this problem, the #removeClass: method never removed the key."