"

 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

			   CachedAbbreviations

			   SilentLoading Initializing

			   StandAlone

			   LogDoits'

       poolDictionaries:''

       category:'System-Support'

!

Smalltalk comment:'

COPYRIGHT (c) 1988 by Claus Gittinger

	     All Rights Reserved

'!

"

 dont depend on these being global - they will become

 class variables of some class ...

 Being global is a historical leftover ...

"

Smalltalk at:#Language put:#english!

Smalltalk at:#LanguageTerritory put:#usa!

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

"

!

version

"

"

!

documentation

"

    This is one of the central classes in the system;

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

    Also global variables are 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.

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

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

	StartupClass    <Class>         class, which gets initial message 

					(right after VM initialization)

	StartupSelector <Symbol>        message sent to StartupClass

	CachedAbbreviations

			<Dictionary>    className to filename mappings

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

"

! !

!Smalltalk class methodsFor:'time-versions'!

majorVersion

    "return the major version number.

     This is only incremented for very fundamental changes,

     which make old object files totally incompatible

     (for example, if the layout/representation of fundamental

      classes changes)."

    ^ 2

    "

     Smalltalk majorVersion

    "

!

minorVersion

    "return the minor version number.

     This is incremented for changes which make some old object

     files incompatible, or the protocol changes such that some

     classes need rework."

    ^ 10

    "

     Smalltalk minorVersion

    "

!

revision

    "return the revision number.

     Incremented for releases which fix bugs/add features."

    ^ 4

    " 

     Smalltalk revision

    "

!

versionString

    "return the version string"

    ^ (self majorVersion printString ,

       '.',

       self minorVersion printString ,

       '.',

       self revision printString)

    "

     Smalltalk versionString

    "

"

"

!

versionDate

    "return the version date - thats the date when the smalltalk

     executable was linked."

%{

#ifdef VERSIONDATE_STRING

    RETURN ( _MKSTRING(VERSIONDATE_STRING COMMA_SND) );

#endif

%}.

    ^ '21-oct-1994'

    "

     Smalltalk versionDate

    "

!      

configuration

    "for developers only: return the configuration, with which

     this smalltalk was compiled."

%{

#ifdef CONFIGURATION_STRING

    RETURN ( _MKSTRING(CONFIGURATION_STRING COMMA_SND) );

#endif

%}.

    ^ 'unknown'

    "

     Smalltalk configuration

    "

!

copyrightString

    "return a copyright string"

    ^ 'Copyright (c) 1988-94 by Claus Gittinger'

    "

     Smalltalk copyrightString

    "

!

hello

    "return a greeting string"

    "stupid: this should come from a resource file ...

     but I dont use it here, to allow mini-systems without

     Resource-stuff."

    (Language == #german) ifTrue:[

	^ 'Willkommen bei SmallTalk/X version '

	  , self versionString , ' vom ' , self versionDate

    ].

    (Language == #french) ifTrue:[

	^ 'Bienvenue a SmallTalk/X version '

	  , self versionString , ' de ' , self versionDate

    ].

    ^ 'Hello World - here is SmallTalk/X version '

      , self versionString , ' of ' , self versionDate

    "

     Smalltalk hello

    "

!

timeStamp

    "return a string useful for timestamping a file"

    ^ '''From Smalltalk/X, Version:' , (Smalltalk versionString) , ' on '

      , Date today printString , ' at ' , Time now printString

      , ''''

! !

!Smalltalk class methodsFor:'initialization'!

initialize

    "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"

    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.

    ExternalStream initialize.

    self initStandardStreams.

    "

     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

    ].

    "

     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

    "

    Inspector := MiniInspector.

    Debugger := MiniDebugger.

    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 leftover classes

    "

"/    Object allSubclassesInOrderDo:[:aClass |

    self allBehaviorsDo:[:aClass |

	"

	 avoid never-ending story ...

	"

	(aClass ~~ Smalltalk) ifTrue:[

"/ 'init ' print. aClass name printNL.

	    aClass initialize

	]

    ].

    "

     now we can enable the graphical debugger/inspector

    "

    self initStandardTools.

    self initInterrupts.

    "Smalltalk initialize"

!

initUserPreferences

    "setup other stuff"

    LogDoits := false

!

initGlobalsFromEnvironment

    "setup globals from the shell-environment"

    |envString firstChar i langString terrString|

    "

     extract Language and LanguageTerritory from LANG variable.

     the language and territory must not be abbreviated,

     valid is for example: english_usa

			   english

			   german

			   german_austria

    "

    envString := OperatingSystem getEnvironment:'LANG'.

    envString notNil ifTrue:[

	i := envString indexOf:$_.

	(i == 0) ifTrue:[

	    langString := envString.

	    terrString := envString

	] ifFalse:[

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

	    terrString := envString copyFrom:(i + 1)

	].

	Language := langString asSymbol.

	LanguageTerritory := terrString asSymbol

    ].

    "

     this too is a leftover - once all refs to View3D

     are removed, this will vanish ...

     (please use: View>>defaultStyle:)

    "

    envString := OperatingSystem getEnvironment:'VIEW3D'.

    envString notNil ifTrue:[

	firstChar := (envString at:1) asLowercase.

	(firstChar == $t) ifTrue:[

	    Smalltalk at:#View3D put:true

	] ifFalse: [

	    Smalltalk at:#View3D put:false

	]

    ]

    "Smalltalk initGlobalsFromEnvironment"

!

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"

!

initStandardStreams

    "initialize some well-known streams"

    Stdout := NonPositionableExternalStream forStdout.

    Stderr := NonPositionableExternalStream forStderr.

    Stdin := NonPositionableExternalStream forStdin.

    Printer := PrinterStream.

    Transcript := Stderr

    "Smalltalk initStandardStreams"

!

initInterrupts

    "initialize interrupts"

    OperatingSystem enableUserInterrupts.

    OperatingSystem enableHardSignalInterrupts.

    OperatingSystem enableFpExceptionInterrupts.

    ObjectMemory userInterruptHandler:self.

    ObjectMemory signalInterruptHandler:self.

    ObjectMemory recursionInterruptHandler:self.

    "Smalltalk initInterrupts"

!

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)

	    /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|

    homePath := OperatingSystem getHomeDirectory.

    "

     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

    ].

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

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

    ].

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

	SystemPath add:'/usr/lib/smalltalk'

    ].

    "

     Smalltalk initSystemPath

     Smalltalk systemPath

    "

!

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

! !

!Smalltalk class methodsFor:'startup'!

start

    "main startup, if there is a Display, initialize it

     and start dispatching; otherwise go into a read-eval-print loop"

    |idx|

    Initializing := true.

"/    Processor := ProcessorScheduler new.

    "

     while reading patches- and rc-file, do not add things into change-file

    "

    Class updateChanges:false.

    self fileIn:'patches'.

    "

     look for a '-e filename' argument - this will force evaluation of

     filename only, no standard startup

    "

    idx := Arguments indexOf:'-e'.

    idx ~~ 0 ifTrue:[

	self fileIn:(Arguments at:idx + 1).

	self exit

    ].

    (self fileIn:((Arguments at:1) , '.rc')) ifFalse:[

	"no .rc file where executable is; try default smalltalk.rc"

	(self fileIn:'smalltalk.rc') ifFalse:[

	    Transcript showCr:'no startup rc-file found'

	]

    ].

    Class updateChanges:true.

    (SilentLoading == true) ifFalse:[   "i.e. undefined counts as false" 

	Transcript showCr:(self hello).

	Transcript showCr:(self copyrightString).

	Transcript cr.