"

 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

		NumberOfClassesHint SystemPath StartupClass StartupSelector

		StartupArguments CommandLine CommandName CommandLineArguments

		CachedAbbreviations SilentLoading Initializing StandAlone

		HeadlessOperation IsPlugin IsSharedLibraryComponent IsSTScript

		DebuggingStandAlone LogDoits LoadBinaries RealSystemPath

		ResourcePath SourcePath BinaryPath FileInPath PackagePath

		BinaryDirName ResourceDirName SourceDirName BitmapDirName

		PackageDirName FileInDirName ChangeFileName ImageStartTime

		ImageRestartTime DemoMode SaveEmergencyImage SpecialObjectArray

		CallbackSignal KnownPackages ClassesFailedToInitialize

		HasNoConsole'

	poolDictionaries:''

	category:'System-Support'

!

Smalltalk comment:'declared from: ..\..\..\stx\libbasic\abbrev.stc'

!

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

                                        StandAlone programs also set those during initialization.

        CommandLine          <String>   Unix (OS-) command line

        CommandName          <String>   the command (i.e. argv[0])

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

                                        CommandName has been stripped off.

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

                                        Can be set in an application-specific startup script,

                                        or, for standAlone programs, by C-code during initialization.

        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,

                                        or, for standAlone programs, by C-code during initialization.

        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

                                        These are remembered, as 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

        StandaloneStartup

        GetOpt

        ReadEvalPrintLoop

"

!

readme_resources

"

    What is a resource file:

        resource files contain language transformation and sometimes

        UI-look specifics such as icons etc.

    Where are resources stored in the image:

        Resource files are only read on demand (i.e. when needed) and only read once

        i.e. they are cached in the image).

        The cached data is held in a per-class class-instVar named 'ClassResources'.

        With only a few exceptions, the only classes which need resources are the GUI

        classes under the SimpleView hierarchy.

    How does the system find resources:

        The idea is that the system-provided resource files can be overwritten

        by the user or an application configuration.

        This works via a hierarchy of directories where resources are searched for,

        with the systems standard resource-files being at the end of that chain.

        When searching for a resource file for class X, the following files are searched

        in order:

                {ResourcePath} / resources / X.rs

                {SystemPath} / (CLASSES-PACKAGE-PATH) / X.rs

                {ResourcePath} / (CLASSES-PACKAGE-PATH) / X.rs

"

! !

!Smalltalk class methodsFor:'initialization'!

basicInitializeSystem

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

     [with error handling, via the initializeSystem]

     Notice:

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

        case the show starts in Smalltalk>>restart."

    "/

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

    Stream initialize.

    PositionableStream initialize.

    Filename initialize.

    ObjectMemory initialize.

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

    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 := Timestamp now.

    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: / 08-01-1997 / 19:58:12 / stefan"

    "Modified: / 05-12-2006 / 21:48:58 / cg"

!

initGlobalsFromEnvironment

    "setup globals from the shell-environment"

    |envString i langString terrString|

    StandAlone isNil ifTrue:[

        StandAlone := false.

    ].

    HeadlessOperation isNil ifTrue:[

        HeadlessOperation := false.

    ].

    "

     extract Language and LanguageTerritory from LANG variable.

     valid are for example:

                            en_en / en

                            en_us

                            en_gb

                            de_de / de

                            de_at       (for Austria)

    "

    Language := #en.

    LanguageTerritory := #us.

    "Format of LANG is: language[_territory][.codeset][@modifier]

        language        ISO-639  Language code

        territory       ISO-3166 Contry code"

    envString := OperatingSystem getLanguage.

    envString size > 0 ifTrue:[

        i := envString indexOf:$@.

        (i ~~ 0) ifTrue:[

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

            LanguageModifier := (envString copyFrom:(i + 1)) asLowercase asSymbol.

        ] ifFalse:[

            LanguageModifier := nil.

        ].

        i := envString indexOf:$..

        (i ~~ 0) ifTrue:[

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

            LanguageCodeset := (envString copyFrom:(i + 1)) asLowercase asSymbol

        ] ifFalse:[

            LanguageCodeset := #'iso8859-1'.

        ].

        i := envString indexOf:$_.

        (i == 0) ifTrue:[

            langString := envString.

            terrString := envString

        ] ifFalse:[

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

            terrString := envString copyFrom:(i + 1)

        ].

        langString := langString asLowercase.

        terrString := terrString asLowercase.

        (langString = 'c' or:[terrString = 'c']) ifTrue:[

            ('Smalltalk [info]: ignoring wrong LANG setting (',langString,'_',terrString,') - using english') infoPrintCR.

        ] ifFalse:[

            Language := langString asSymbol.

            LanguageTerritory := terrString asSymbol

        ]

    ].

    "

     Smalltalk initGlobalsFromEnvironment

    "

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

!

initInterrupts

    "initialize interrupts"

    OperatingSystem enableUserInterrupts.

    OperatingSystem enableHardSignalInterrupts.

    OperatingSystem enableCrashSignalInterrupts.

    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.

    PrinterStream notNil ifTrue:[

        Printer := PrinterStream defaultPrinter.

    ].

    Transcript := Stderr

    "

     Smalltalk initStandardStreams

    "

    "Modified: / 25-10-2006 / 17:36:46 / cg"

!

initStandardTools

    "predefine some tools which we might need later

     - if the view-classes exist,

       they will redefine Inspector and Debugger for graphical interfaces"

    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:

            .

            <directory of exe>       (WIN32 only)

            $HOME                    (if defined)

            $HOME/.smalltalk         (if defined & existing)

            $SMALLTALK_LIBDIR        (if defined & existing)

            $STX_LIBDIR              (if defined & existing)

            $STX_TOPDIR              (if defined & existing)

            REGISTRY('HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X\<CurrentVersion>\LibDir') (WIN32 only)

            REGISTRY('HKEY_LOCAL_MACHINE\Software\eXept\Smalltalk/X\LibDir')                  (WIN32 only)

            <standard places>

     standard places (unix):

            /opt/smalltalk/<release> (if existing)

            /opt/smalltalk           (if existing)

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

            /usr/lib/smalltalk       (if existing)

            /lib/smalltalk           (if existing)

     win32:

            \programs\exept\smalltalk (if existing)

            \programs\smalltalk       (if existing)

            \smalltalk                (if existing)

     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

     OperatingSystem defaultSystemPath

     OperatingSystem defaultPackagePath

    "