eXept Software AG Logo

Smalltalk/X Webserver

Documentation of class 'Smalltalk':
Home

everywhere
www.exept.de
for:
[back]

Class: Smalltalk

Inheritance:

   Object
   |
   +--Smalltalk
Package:
stx:libbasic
Category:
System-Support
Version:
rev: 1.935 date: 2010/04/30 16:51:56
user: stefan
file: Smalltalk.st directory: libbasic
module: stx stc-classLibrary: libbasic
Author:
Claus Gittinger

Description:


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)

Related information:

    ObjectMemory
    StandaloneStartup
    GetOpt
    ReadEvalPrintLoop

Class protocol:

Compatibility-Squeak
o  at: aKey ifAbsentPut: aBlock
return the element indexed by aKey if present,
if not present, store the result of evaluating valueBlock
under aKey and return it.

o  beep

o  garbageCollect

o  garbageCollectMost
collect recently created garbage; return the amount of freeSpace.
In ST/X, only the newSpace is collected here, and the sum of
newSpace + freeListSpace is returned.

o  hasClassNamed: aNameStringOrSymbol

o  isMorphic

o  platformName
not yet fully implemented (I have to figure out, what squeak returns in each case...)

o  registerExternalObject: anObject
Register the given object in the external objects array and return its index.
If it is already there, just return its index.
ExternalObjects are protected from GC and can be accessed easily from
primitive code (via the global Smalltalk:SpecialObjectArray)

o  removeClassNamed: aName
Invoked from fileouts: if there is currently a class in the system named aName, then remove it.
If anything untoward happens, report it in the Transcript.

o  renameClassNamed: oldName as: newName

o  unregisterExternalObject: anObject
Unregister the given object in the external objects array.
Do nothing if it isn't registered.

o  windowSystemName
not yet fully implemented (I have to figure out, what squeak returns in each case...)

Compatibility-V'Age
o  allClassesImplementing: aSelector

o  declareConstant: constantName poolName: poolName value: value

o  declarePoolDictionary: poolDictionaryName

Compatibility-VW5.4
o  defineClass: nameSymbol superclass: superclass indexedType: indexed private: private instanceVariableNames: instVars classInstanceVariableNames: classInstVars imports: imports category: category

o  defineClass: nameSymbol superclass: superclass indexedType: indexed private: private instanceVariableNames: instVars classInstanceVariableNames: classInstVars imports: imports category: category attributes: annotations

o  defineNameSpace: nameSymbol private: private imports: imports category: category

accessing
o  associationAt: aKey
return a key-value association for aKey.
Since ST/X's Smalltalk as no real dictionary, this is
simulated here.

o  associationAt: aKey ifAbsent: exceptionBlock
return a key-value association for aKey, or the value
from exceptionBlock, if no such key is present.
Since ST/X's Smalltalk as no real dictionary, this is
simulated here.

o  at: aKey
retrieve the value stored under aKey, a symbol.
Return nil if not present
(this will be changed to trigger an error - better use #at:ifAbsent:)

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

o  at: aKey ifPresent: aBlock
try to retrieve the value stored at aKey.
If there is nothing stored under this key, do nothing.
Otherwise, evaluate aBlock, passing the retrieved value as argument.

o  at: aKey put: aValue
store the argument aValue under aKey, a symbol.
Return aValue (sigh).

o  includesKey: aKey
return true, if the key is known

o  keyAtValue: anObject
return the symbol under which anObject is stored - or nil

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

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

o  startBlocks

o  values
return a collection with all values in the Smalltalk dictionary

binary storage
o  addGlobalsForBinaryStorageTo: globalDictionary

o  storeBinaryDefinitionOf: anObject on: stream manager: manager

browsing
o  browseAllCallsOn: aSelectorSymbol
startup a browser for all methods sending a particular message

o  browseAllSelect: aBlock
startup a browser for all methods for which aBlock returns true

o  browseChanges
startup a changes browser

o  browseClass: aClass
startup a browser on aClass.
The broser will only show that class (i.e. be a singleClass-browser).
See browseInClass: for a full browser, which has aClass selected initially.

o  browseImplementorsMatching: aSelectorSymbolOrMatchPattern
startup a browser for all methods implementing a message matching

o  browseImplementorsOf: aSelectorSymbol
startup a browser for all methods implementing a particular message

o  browseInClass: aClass
startup a full browser showing aClass.
The browser will be a full browser with aClass initially selekted.
See browseClass: for a singleClass browser, which shows only a single class.

o  browseInClass: aClass selector: selector
startup a full browser showing aClass>>selector.
The browser will be a full browser with aClass initially selekted.
See browseClass: for a singleClass browser, which shows only a single class.

class management
o  changeCategoryOf: aClass to: newCategory
change a classes category, add a change record,
send change notifications

o  defineNameSpace: name private: private imports: imports category: category attributes: annotations

o  flushCachedClass: aClass

o  flushCachedClasses

o  removeClass: aClass
remove the argument, aClass from the smalltalk dictionary;
we have to flush the caches since these methods are now void.
Also, class variables of aClass are removed.

o  renameClass: aClass to: newName
rename aClass to newName. Most of the work is in
renaming the classVariables (create & copy over values)
and patching the classes methods to access the new variables.

copying
o  deepCopy
redefined to return self - there is only one Smalltalk dictionary

o  deepCopyUsing: aDictionary postCopySelector: postCopySelector
return a deep copy of the receiver.
Redefined to return the receiver - there is only one Smalltalk dictionary

o  shallowCopy
redefined to return self - there is only one Smalltalk dictionary

o  simpleDeepCopy
redefined to return self - there is only one Smalltalk dictionary

debugging ST/X
o  compileTrace: aBoolean
dump generated inline code (NOOP if VM was compiled without the trace-debug option)

o  debugBreakPoint
call the dummy debug function, on which a breakpoint
can be put in adb, sdb, dbx or gdb.
WARNING: this method is for debugging only
it will be removed without notice.

o  exitWithCoreDump
abort program and dump core

o  fatalAbort
report a fatal-error, print a stack backtrace and exit with core dump.
(You may turn off the stack print with debugPrinting:false)

o  fatalAbort: aMessage
report a fatal-error; print a stack backtrace and exit with core dump
(You may turn off the stack print with debugPrinting:false)

o  vmInstructionTrace: aBoolean

enumerating
o  allBehaviorsDo: aBlock
evaluate the argument, aBlock for all classes and metaclasses in the system

o  allClassCategories
return a set of all class categories in the system

o  allClassesAndMetaclassesDo: aBlock
evaluate the argument, aBlock for all classes and metaclasses in the system.

o  allClassesDo: aBlock
evaluate the argument, aBlock for all classes in the system.

o  allClassesForWhich: filter
return a collection with all classes in the system,
for which filter evaluates to true.

o  allClassesForWhich: filter do: aBlock
evaluate the argument, aBlock for all classes in the system, for which filter evaluates to true.

o  allClassesInCategory: aCategory
return a collection of for all classes in aCategory;
The order of the classes is not defined.

o  allClassesInCategory: aCategory do: aBlock
evaluate the argument, aBlock for all classes in the aCategory;
The order of the classes is not defined.

o  allClassesInCategory: aCategory inOrderDo: aBlock
evaluate the argument, aBlock for all classes in aCategory;
superclasses come first - then subclasses

o  allClassesInOrderDo: aBlock
evaluate the argument, aBlock for all classes in the system;
Evaluation order is by inheritance: superclasses come first.

o  allClassesInPackage: aPackageID
evaluate the argument, aBlock for all classes a package;
The order of the classes is not defined.
The returned collection may include private classes

o  allClassesInPackage: aPackageID do: aBlock
evaluate the argument, aBlock for all classes a package;
The order of the classes is not defined.

o  allKeysDo: aBlock
evaluate the argument, aBlock for all keys in the Smalltalk dictionary

o  allMethodCategories
return a set of all method-categories (protocols) in the system

o  allMethodsDo: aBlock
enumerate all methods in all classes

o  allMethodsWithSelectorDo: aTwoArgBlock
enumerate all methods in all classes and evaluate aBlock
with method and selector as arguments.

o  associationsDo: aBlock
evaluate the argument, aBlock for all key/value pairs
in the Smalltalk dictionary

o  basicKeys
for rel > 5 only

o  do: aBlock
evaluate the argument, aBlock for all values in the Smalltalk dictionary

o  keysAndValuesDo: aBlock
evaluate the two-arg block, aBlock for all keys and values

o  keysAndValuesSelect: selectBlockWith2Args thenCollect: collectBlockWith2Args

o  keysDo: aBlock
evaluate the argument, aBlock for all keys in the Smalltalk dictionary

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

o  initGlobalsFromEnvironment
setup globals from the shell-environment

o  initInterrupts
initialize interrupts

o  initStandardStreams
initialize some well-known streams

o  initStandardTools
predefine some tools which we might need later
- if the view-classes exist,
they will redefine Inspector and Debugger for graphical interfaces

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

o  initUserPreferences
setup other stuff

o  initializeClass: aClass
sent from VM via #initializeModules

o  initializeModules
perform module specific initialization and
send #initialize to all classes.
Notice: this is not called when an image is restarted

o  initializeModulesOnce
perform module specific initialization and
send #initialize to all classes.
Notice: this is not called when an image is restarted

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

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

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

inspecting
o  inspectorClass
redefined to launch a DictionaryInspector (instead of the default Inspector).

message control
o  silentLoading
returns the Silentloading class variable, which globally controls if compilation
messages are shown on the transcript during a fileIn.

o  silentLoading: aBoolean
allows access to the Silentloading class variable, which controls
messages (especially during fileIn) onto the transcript.
You can save a snapshot with this flag set to true, which makes
the image come up silent. Can also be set, to read in files unlogged.

o  silentlyLoadingDo: aBlock
evaluates aBlock with silent loading on - no compilation messages (except errors)
are shown on the transcript

misc accessing
o  beHeadless: aBoolean
set/clear the headlessOperation flag.

o  beSTScript: aBoolean
set/clear the isSTScript flag.

o  standAloneApp: aBoolean
set/clear the StandAlone flag.

misc stuff
o  addExitBlock: aBlock
add a block to be executed when Smalltalk finishes.
This feature is currently not used anywhere - but could be useful for
cleanup in stand alone applications.

Better use: ObjectMemory>>#addDependent: and handle the change message
#aboutToQuit.

o  addImageStartBlock: aBlock
add a blocks to be executed in a separate process after
everything has been initialized.
These blocks will be executed after an image restart.

o  addStartBlock: aBlock
add a 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 are usually started here (see smalltalk.rc / private.rc).

o  exit
finish the Smalltalk system

o  exit: statusInteger
finish the Smalltalk system

private-system management-packages
o  knownPackages

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  loadExtensionsForPackage: aPackageId

o  loadExtensionsFromDirectory: packageDirOrString

o  loadPackage: aPackageString asAutoloaded: doLoadAsAutoloaded
make certain, that some particular package is loaded into the system.
Return true if loaded, false otherwise.

o  loadPackage: packageId fromAllSourceFilesInDirectory: aDirectory
load all source files found in aDirectory and treat them like
a package. Allows for initial import of alien ST-code as a new package.
Experimental.

o  loadPackage: packageId fromClassLibrary: aFilename
load a package from a compiled classLib.
Experimental.

o  loadPackage: aPackageString fromDirectory: packageDirOrStringOrNil asAutoloaded: doLoadAsAutoloaded
load a package referenced by aPackageString - a string like 'stx:libbasic'.
The package is either located in packageDirOrStringOrNil, or in the current directory

o  loadPackage: packageId fromLoadAllFile: aFilename

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  loadPackage: aPackageId fromZIPArchive: f asAutoloaded: doLoadAsAutoloaded
load a package from a .zip delivery file.
Experimental.

o  loadPackageFromAbbrevFile: aPackageId asAutoloaded: doLoadAsAutoloaded

** This is an obsolete interface - do not use it (it may vanish in future versions) **

queries
o  allClasses
return an unordered collection of all classes in the system.
Only globally anchored classes are returned
(i.e. anonymous ones have to be aquired by Behavior allSubInstances)

o  allClassesAndMetaclasses
return an unordered collection of all classes with their metaclasses in the system.

o  allClassesWithAllPrivateClasses
return an unordered collection of all classes in the Smalltalk namespace.
Only globally anchored classes are returned; Namespaces are not included.
(i.e. anonymous ones have to be aquired by Behavior allSubInstances)

o  allExtensionsForPackage: aProjectID

o  allImplementorsOf: aSelector

o  allLoadedProjectIDs

o  allProjectIDs

o  allProjectsIdsIncludingUnloadedClasses: includeUnloadedClasses
Returns all projects ids.
Excludes projects coming from unloaded classes if includeUnloadedClasses is false.

o  cellAt: aName
return the address of a global cell
- used internally for compiler only

o  classCategoryCompletion: aPartialCategory
given a partial class category name, return an array consisting of
2 entries: 1st: the best (longest) match
2nd: collection consisting of matching categories

o  classNamed: aString
return the class with name aString, or nil if absent.
To get to the metaClass, append ' class' to the string.
To get a nameSpace or private class, prefix the name as required.
If a private class of an autoloaded class is referenced, the owning class
will be loaded.

o  classNames
return a collection of all classNames in the system

o  classnameCompletion: aPartialClassName
given a partial classname, return an array consisting of
2 entries: 1st: the best (longest) match
2nd: collection consisting of matching names

o  classnameCompletion: aPartialClassName inEnvironment: anEnvironment
given a partial classname, return an array consisting of
2 entries: 1st: the best (longest) match
2nd: collection consisting of matching names

o  defaultNameSpace
return the default namespace, where new classes are installed,
if NO special nameSpace handler is present

o  globalNameCompletion: aPartialGlobalName
given a partial globalName, return an array consisting of
2 entries: 1st: the best (longest) match
2nd: collection consisting of matching names

o  globalnameCompletion: aPartialGlobalName
given a partial globalName, return an array consisting of
2 entries: 1st: the best (longest) match
2nd: collection consisting of matching names

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  hasNameSpaces
can be redefined by dummy namespaces/environments, to suppress
the namespace display in a browser (PocketSmalltalk)

o  hasNamespaces
can be redefined by dummy namespaces/environments, to suppress
the namespace display in a browser (PocketSmalltalk)

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  hasSelectorNameSpaces
for now return false
Selector namespaces are being implemented and supported by the VM,
but not yet fully supported by all tools...
Therefore, for now, do not generate code which uses this feature.

o  includes: something
this should come from Collection.
will change the inheritance - Smalltalk is actually a collection

o  isBrowserStartable

o  isNameSpace
return true, if the receiver is a nameSpace.

o  isRealNameSpace
return true, if the receiver is a nameSpace, but not Smalltalk (which is also a class).

o  isTopLevelNameSpace

o  isTopLevelNamespace
obsolete - use isTopLevelNameSpace

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  keyIsClassVariableNameKey: aKey

o  loadedClassNamed: aString
Same as #classNamed,
but a private class of an autoloaded class will not be found.

o  methodProtocolCompletion: aPartialProtocolName
given a partial method protocol name, return an array consisting of
2 entries: 1st: the best (longest) match
2nd: collection consisting of matching protocols

o  numberOfGlobals
return the number of global variables in the system

o  referencesAny: aCollection
redefined, since the references are only kept in the VM's symbol table

o  referencesDerivedInstanceOf: aClass
redefined, since the references are only kept in the VM's symbol table

o  referencesInstanceOf: aClass
redefined, since the references are only kept in the VM's symbol table

o  referencesObject: anObject
redefined, since the references are only kept in the VM's symbol table

o  resolveName: nameIn inClass: aClass
resolve aName as if compiled within aClass;
i.e. if it has a private class with this name, return it;
if aName is known within the classes namespace, return that.
Otherwise, return a global with that name.
This should be used whereever Smalltalk>>at: used to be used,
to resolve a global by name.

o  selectorCompletion: aPartialSymbolName
given a partial selector, return an array consisting of
2 entries: 1st: the longest match
2nd: collection consisting of matching implemented selectors

o  selectorCompletion: aPartialSymbolName inEnvironment: anEnvironment
given a partial selector, return an array consisting of
2 entries: 1st: the longest match
2nd: collection consisting of matching implemented selectors

queries-system
o  dialectName

o  dialectReleaseVersion

o  isDolphinSmalltalk
return false here - this may be useful to write portable
applications - add #isDolphinSmalltalk to your dolphin,
returning true there.

o  isSmalltalkMT
return false here - this may be useful to write portable
applications - add #isSmalltalkMT to your smalltalk-MT,
returning true there.

o  isSmalltalkV
return false here - this may be useful to write portable
applications - add #isSmalltalkV to your smalltalkV,
returning true there.

o  isSmalltalkX
return true here - this may be useful to write portable
applications - add #isSmalltalkX to your other smalltalks,
returning false there.

o  isSqueak
return false here - this may be useful to write portable
applications - add #isSqueak to your squeak,
returning true there.

o  isVisualAge
return false here - this may be useful to write portable
applications - add #isVisualAge to your visualAge,
returning true there.

o  isVisualWorks
return false here - this may be useful to write portable
applications - add #isVisualWorks to your visualWorks,
returning true there.

startup
o  browserWindowStartup

o  displayInitializationDone
inform the restart, that the display has been initialized

o  hideSplashWindow

o  mainStartup: graphicalMode
common start/restart action, if there is a Display, initialize it
and start dispatching; otherwise go into a read-eval-print loop.

o  openDisplay
try to open a display connection.
If so, also read display- and keyboard.rc

o  readEvalPrint

o  restart
startup after an image has been loaded;
there are three change-notifications made to dependents of ObjectMemory,
which allow a stepwise re-init: #earlyRestart, #restarted and #returnFromSnapshot.

#earlySystemInstallation is sent for ST80 compatibility

#earlyRestart is send first, nothing has been setup yet.
(should be used to flush all device dependent entries)

#restarted is send right after.
(should be used to recreate external resources (fds, bitmaps etc)

#returnFromSnapshot is sent last
(should be used to restart processes, reOpen Streams which cannot
be automatically be reopened (i.e. Sockets, Pipes) and so on.
(Notice that positionable fileStreams are already reopened and repositioned)

o  showSplashMessage: aString
put the message into the splash screen (if there is one).
Use this for messages during startup

o  showSplashMessage: aMessageStringOrNil color: rgbValueOrNil
put the message into the splash screen (if there is one).

o  splashInfo: aString
like infoPrintCR,
but in addition put the message into the splash screen (if there is one).
Use this for info messages during startup

o  start
main startup, if there is a Display, initialize it
and start dispatching; otherwise go into a read-eval-print loop.

o  startStartBlockProcess
at the end of the smalltalk initialization, start all actions that
were delayed until the ProcessorScheduler is running in a separate process

startup queries
o  commandLine
return the full command line arguments (with which ST/X was started)

o  commandLineArgumentNamed: aString
extract a named argument from the command line arguments.

o  commandLineArguments
return the user command line arguments;
This is a collection of strings (separated command line words),
from which the internal startup arguments have already been removed.
I.e. if started with: 'smalltalk -I -f xxx foo bar baz',
the commandLineArguments will be #('foo' 'bar' 'baz').
In contrast, the value returned by #commandLine will be the full set of words.

o  commandName
return the excutables name - this is normally 'stx',
but can be something else for standAlone apps.

o  hasNoConsole
return true, if this is a console-less application (i.e. I am winstx)
i.e. there should be no writing to stdout/stderr

o  isHeadless
return true, if this is a headless application
i.e. no default Display connection is required/used

o  isPlugin
return true, if this is a plugin application
i.e. running in a browserWindow

o  isSTScript
return true, if this is stscript. i.e. the stx scripting engine.

o  isSharedLibraryComponent
return true, if this is a shared library component of another application
i.e. a dll within another app.

o  isSmalltalkDevelopmentSystem
return true, if this is a real smalltalk system
i.e. NOT a stripped or a linked application (such as the webServer)
and NOT a plugIn (i.e. running in a browser)
and NOT a sharedLibrary component (i.e. a dll in another app).
This is used to determine, wether debugging is possible or not.

o  isStandAloneApp
return true, if this is a standAlone application
i.e. a stripped & linked application (such as the webServer)
in contrast to a full smalltalk (development) system.

o  startupArguments
return the arguments passed to StartupClass when stx gets started.
Usually these are nil,
but saving an image with a non-nil StartupClass/StartupSelector/StartupArgs allows for
a simple way to configure and create stand-alone applications

o  startupClass
return the class, that will get the start message when smalltalk
starts and its non-nil. Usually this is nil,
but saving an image with a non-nil StartupClass/StartupSelector/StartupArgs allows for
a simple way to configure and create stand-alone applications

o  startupClass: aClass selector: aSymbol arguments: anArrayOrNil
set the class, selector and arguments to be performed when smalltalk
starts. Setting those before saving a snapshot, will make the saved
image come up executing your application (instead of the normal mainloop)

o  startupSelector
return the selector, that will be sent to StartupClass.
Usually this is nil,
but saving an image with a non-nil StartupClass/StartupSelector allows for
a simple way to configure and create stand-alone applications

o  wasStartedFromImage
return true, if this smalltalk was started from an image,
as opposed to a fresh and clean startup

system environment
o  language
return the language setting

o  language: aLanguageSymbol
set the language - send out change notifications

o  language: aLanguageSymbol territory: aTerritorySymbol
set the language & territory - send out change notifications

o  languageTerritory
return the language territory setting

o  languageTerritory: aTerritorySymbol
set the language territory - send out change notifications

o  setLanguage: aLanguageSymbol
set the language without change notification

o  setLanguage: aLanguageSymbol territory: aTerritorySymbol
set the language & territory - no change notification

system management
o  compressSources
compress the sources file, and remove all method source strings
from the system and replace them by refs to a string in the source file.
This is a bit different in ST/X than in other smalltalks,
since we use per-class sourcefiles for the compiled classes,
and a mix of in-memory strings and one-for-all sourceFile for
incremental compiled methods.
Therefore, only those sources which are not coming from compiled
methods are put into the 'st.src' file - all others are untouched.
This is being automated - so dont care for now.

o  generateSingleSourceFile
generate the sources file, and remove all method source strings
from the system and replace them by refs to a string in the source file.
This makes the image independent from the per-class source files
and makes transportation of endUser applications easier, since
only 3 files (executable, image and sourceFile) need to be
transported.

o  installAutoloadedClassNamed: clsName category: cat package: package revision: revisionOrNil
create & install an autoload stub for a class named: clsName,
to be loaded from package.
If revisionOrNil is non-nil, set it up to load exactly that revision
(otherwise, the newest revision will be loaded

o  installAutoloadedClassNamed: clsName category: cat package: package revision: revisionOrNil numClassInstVars: numClassInstVarsOrNil
create & install an autoload stub for a class named: clsName,
to be loaded from package.
If revisionOrNil is non-nil, set it up to load exactly that revision
(otherwise, the newest revision will be loaded

o  installAutoloadedClasses
scan all packages and install all classes found there as
autoloaded. This takes some time ...

o  installAutoloadedClassesFrom: anAbbrevFilePath
read the given abbreviation file; install all classes found there as
autoloaded. This takes some time ...

o  installAutoloadedClassesFromStream: anAbbrevFileStream
read the given abbreviation file;
install all classes found there as autoloaded, and also update the
abbreviation (className-to-fileName mapping) table.
This takes some time ...

o  loadBinaries
return true, if binaries should be loaded into the system,
false if this should be suppressed. The default is false (for now).

o  loadBinaries: aBoolean
turn on/off loading of binary objects

o  logDoits
return true if doits should go into the changes file
as well as changes - by default, this is off, since
it can blow up the changes file enormously ...

o  logDoits: aBoolean
turn on/off logging of doits in the changes file.
By default, this is off, since it can blow up the
changes file enormously ...

o  makeBytecodeMethods
walk over all methods and make each a bytecode method
iff it does not contain primitive C code.
Experimental and not yet used.

o  recursiveInstallAutoloadedClassesFrom: aDirectory rememberIn: dirsConsulted maxLevels: maxLevels noAutoload: noAutoloadIn packageTop: packageTopPath
read all abbrev.stc files from and under aDirectory
and install autoloaded classes.
If a file called NOAUTOLOAD is found, no classes there and below are installed as autoloaded
(however, the directories are searched for packages)
If a file called NOPACKAGES is found, no further searching is done in that directory or below.

o  recursiveInstallAutoloadedClassesFrom: aDirectory rememberIn: dirsConsulted maxLevels: maxLevels noAutoload: noAutoloadIn packageTop: packageTopPath showSplashInLevels: showSplashInLevels
read all abbrev.stc files from and under aDirectory
and install autoloaded classes.
If a file called NOAUTOLOAD is found, no classes there and below are installed as autoloaded
(however, the directories are searched for packages)
If a file called NOPACKAGES is found, no further searching is done in that directory or below.

o  replaceReferencesTo: anObject with: newRef
if the receiver refers to the argument, anObject, replace this reference with newRef.
Return true, if any reference was changed.
Notice: this does not change the class-reference.

o  saveEmergencyImage: aBoolean
set/clear the flag which controls if ST/X should save an
emergency image in case of a broken display connection.
The default is true.
This may be useful, if you work with an unsecure display
(serial line), and want to have a chance of proceeding after
a crash. In multiheaded applications, this only affects
crashes of the master Display connection (the initial connection);
errors on other displays are reported to the views and treated
like window destroy from the windowManager.

o  systemOrganization
for partial ST80 compatibility;
In ST80, Smalltalk organization returns a systemOrganizer, which
keeps track of class-categories, while all classes return a classOrganizer
from #organization, which keeps track of method categories of that class.
Since in ST/X, Smalltalk is a class, there is now a conflict.
To make a workaround possible, use #systemOrganization when porting
VW apps to ST/X to get the class-categories.
Read the documentation in SystemOrganizer for more info.

system management-fileIn
o  fileIn: aFileName
read in the named file - look for it in some standard places;
return true if ok, false if failed.
This method can load almost anything which makes sense:
.st - source files
.cls - binary smalltalk bytecode files
.so - binary compiled machine code class libraries
[.class - java bytecode -- soon to come]

o  fileIn: aFileName inPackage: aPackageID
read in the named file in a packages directory.

o  fileIn: aFileName lazy: lazy
read in the named file - look for it in some standard places;
return true if ok, false if failed.
If lazy is true, no code is generated for methods, instead stubs
are created which compile themself when first executed. This allows
for much faster fileIn (but slows down the first execution later).
Since no syntax checks are done when doing lazy fileIn, use this only for
code which is known to be syntactically correct.

o  fileIn: aFileName lazy: lazy silent: silent
read in the named file - look for it in some standard places;
return true if ok, false if failed.
If lazy is true, no code is generated for methods, instead stubs
are created which compile themself when first executed. This allows
for much faster fileIn (but slows down the first execution later).
Since no syntax checks are done when doing lazy fileIn, use this only for
code which is known to be syntactically correct.
If silent is true, no compiler messages are output to the transcript.
Giving nil for silent/lazy will use the current settings.

o  fileIn: aFileNameOrString lazy: lazy silent: silent logged: logged
read in the named file - look for it in some standard places;
return true if ok, false if failed.
If lazy is true, no code is generated for methods, instead stubs
are created which compile themself when first executed. This allows
for much faster fileIn (but slows down the first execution later).
Since no syntax checks are done when doing lazy fileIn, use this only for
code which is known to be syntactically correct.
If silent is true, no compiler messages are output to the transcript.
Giving nil for silent/lazy will use the current settings.
This method can load almost anything which makes sense:
.st - source files
.cls - binary smalltalk bytecode files
.so - binary compiled machine code class libraries
[.class - java bytecode -- soon to come]

o  fileIn: aFileName logged: logged
read in the named file - look for it in some standard places;
return true if ok, false if failed.
The argument logged controls, if the changefile is to be updated.

o  fileIn: aFileName silent: silent
read in the named file - look for it in some standard places;
return true if ok, false if failed.
If silent is true, no compiler messages are output to the transcript.

o  fileInChanges
read in the last changes file - bringing the system to the state it
had when left the last time.
WARNING: this method is rubbish: it should only read things after the
last '**snapshot**' - entry
(instead of the complete changes file).

o  fileInClass: aClassName
find a source/object file for aClassName and -if found - load it.
search is in some standard places trying driver-file (.ld), object-file (.o) and
finally source file (.st) in that order.
The file is first searched for using the class name, then the abbreviated name.

o  fileInClass: aClassName fromObject: aFileName
read in the named object file and dynamic-link it into the system
- look for it in some standard places.
Only install the named class from this object file.
Return true if ok, false if failed.

o  fileInClass: aClassName initialize: doInit
find a source/object file for aClassName and -if found - load it.
search is in some standard places trying driver-file (.ld), object-file (.o) and
finally source file (.st) in that order.
The file is first searched for using the class name, then the abbreviated name.

o  fileInClass: aClassName initialize: doInit lazy: loadLazy
find a source/object file for aClassName and -if found - load it.
search is in some standard places trying driver-file (.ld), object-file (.o) and
finally source file (.st) in that order.
The file is first searched for using the class name, then the abbreviated name.

o  fileInClass: aClassName initialize: doInit lazy: loadLazy silent: beSilent
find a source/object file for aClassName and -if found - load it.
Search is in some standard places, trying driver-file (.ld), object-file (.so / .o) and
finally source file (.st), in that order.
The file is first searched for using the class name, then the abbreviated name.
The argument doInit controlls if the class should be sent a #initialize after the
load; loadLazy tells if it should be loaded lazyly. beSilent tells if the compiler
should not send notes to the transcript; it can be true, false or nil, where
nil uses the value from SilentLoading.

o  fileInClass: aClassName package: package
find a source/object file for aClassName and -if found - load it.
search is in some standard places trying driver-file (.ld), object-file (.o) and
finally source file (.st) in that order.
The file is first searched for using the class name, then the abbreviated name.

o  fileInClass: aClassName package: package initialize: doInit lazy: loadLazy silent: beSilent
find a source/object file for aClassName and -if found - load it.
This is the workhorse for autoloading.
Search is in some standard places, trying driver-file (.ld), object-file (.so / .o) and
finally source file (.st), in that order.
The file is first searched for using the class name, then the abbreviated name.
The argument doInit controlls if the class should be sent a #initialize after the
load; loadLazy tells if it should be loaded lazyly. beSilent tells if the compiler
should not send notes to the transcript; it can be true, false or nil, where
nil uses the value from SilentLoading.

o  fileInClassLibrary: aClassLibraryName
find an object file containing a binary class library in some standard places
and load it. This install all of its contained classes.
Return true if ok, false if not.
Notice: the argument may not have an extension (by purpose);
the sharedLib extension (.dll / .so / .sl) is added here, to
make the caller independent of the underlying operatingSystem.

o  fileInClassLibrary: aClassLibraryName inPackage: packageID
find an object file containing a binary class library in some standard places
and load it. This installs all of its contained classes.
Return true if ok, false if not.
Notice: the argument may not have an extension (by purpose);
the sharedLib extension (.dll / .so / .sl) is added here, to
make the caller independent of the underlying operatingSystem.

o  fileInStream: streamArg

o  fileInStream: streamArg lazy: lazy silent: silent logged: logged addPath: morePath
read sourceCode from aStream;
return true if ok, false if failed.
If lazy is true, no code is generated for methods, instead stubs
are created which compile themself when first executed. This allows
for much faster fileIn (but slows down the first execution later).
Since no syntax checks are done when doing lazy fileIn, use this only for
code which is known to be syntactically correct.
If silent is true, no compiler messages are output to the transcript.
Giving nil for silent/lazy will use the current settings.
If morePath is nonNil, it is prepended to the systemPath temporarily during the
fileIn. This allows for st-expressions to refer to more files (i.e. fileIn more)
using a relative path.

o  isClassLibraryLoaded: name
return true, if a particular class library is already loaded

o  loadClassLibraryIfAbsent: name
dynamically load a classLibrary, if not already loaded
and the system supports dynamic loading.
Return true, if the library is loaded, false if not.
This entry is called without system specific filename
extensions - it is portable among different architectures
as long as corresponding files (x.so / x.dll / x.sl / x.o)
are be present ...

o  secureFileIn: aFileName
read in the named file, looking for it at standard places.
Catch any error during fileIn. Return true if ok, false if failed

o  silentFileIn: aFilename
same as fileIn:, but do not output 'compiled...'-messages on Transcript.
Main use is during startup.

system management-files
o  bitmapFileStreamFor: aFileName
search aFileName in some standard places;
return a readonly fileStream or nil if not found.
Searches in subdirectories named 'bitmaps' in the SystemPath.
Notice: this does not look in the package-specific bitmaps directories.

o  bitmapFromFileNamed: aFileName forClass: aClass
backward compatibility:
search aFileName in some standard places:
first in the redefinable bitmaps path,
then in the classes own package directory if existing.
Return an image or nil.

o  bitmapFromFileNamed: aFileName inPackage: aPackage
backward compatibility:
search aFileName in some standard places:
first in the redefinable bitmaps path,
then in the package directory if existing.
Return an image or nil.

o  classNameForFile: aFileName
return the className which corresponds to an abbreviated fileName,
or nil if no special translation applies. The given filename arg may
include a '.st' suffix (but no other).

o  constructPathFor: aDirectoryName
search for aDirectory in SystemPath;
return a collection of pathes which include that directory.

o  fileInFileStreamFor: aFileName
obsolete
search aFileName in some standard places;
return a readonly fileStream or nil if not found.
Searches in subdirectories named 'fileIn' in SystemPath

o  fileNameForClass: aClassOrClassName
return a actual or expected (or most wanted) filename for aClassOrClassName
- only the base name (without directory part) and without suffix.

o  filenameAbbreviations
return a dictionary containing the classname-to-filename
mappings. (needed for sys5.3 users, where filenames are limited
to 14 chars)

o  flushPathCaches
forget pathCaches - these are collections containing valid directory names,
where system files (resource, bitmaps etc.) are found.
A flush is only required, if a new system directory has been created while
the system is active, and those files should override the others
(for example, if you created a private resource directory)

o  getBinaryFileName: aFileName
obsolete
search aFileName in some standard places
(subdirectories named 'binary' in SystemPath);
return the absolute filename or nil if none is found.

o  getBitmapFileName: aFileName
for backward compatibility:
search aFileName in some standard places
(subdirectories named 'bitmaps' in SystemPath);
Return the pathName or nil if none is found.

o  getBitmapFileName: aFileName forPackage: aPackageIDOrNil
for backward compatibility.
search aFileName in some standard places:
first in the redefinable bitmaps path,
then in the package directory if existing.
Return a path or nil.
Search order is:
bitmaps/<pkg>/file
resources/<pkg>/bitmaps/file
<pkg>/bitmaps/file

o  getFileInFileName: aFileName
obsolete
search aFileName in some standard places
(subdirectories named 'fileIn' in SystemPath);
return the absolute filename or nil if none is found.

o  getPackageDirectoryForPackage: aPackageID
search for a particular package; return its directory, or nil.
Stand alone applications might get nil, if there are only binaries installed.

o  getPackageFileName: aFileName
search aFileName in some standard places
(packagePath and subdirectories named 'packages' in SystemPath);
return the absolute filename or nil if none is found.

o  getResourceFileName: aFileName

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  getResourceFileName: aFileName forClass: aClassOrNil
search aFileName in some standard places
(subdirectories named 'resource' in SystemPath);
and in aClasses package directory.
Return the absolute filename or nil if none is found.

o  getResourceFileName: aFileName forPackage: aPackageIDOrNil
search aFileName in some standard places
(subdirectories named 'resource' in SystemPath);
and in a packages directory.
Return the absolute filename or nil if none is found.
Search order is:
resources/<pkg>/file
<pkg>/resources/file

o  getSourceFileName: aFileName
search aFileName in some standard places
(subdirectories named 'source' in SystemPath);
return the absolute filename or nil if none is found.
This is used to find a sourceFile for a methods source,
if no sourceCodeManager is available.

o  getSystemFileName: aFileNameOrString
search aFileNameOrString in some standard places;
return the absolute filename or nil if none is found.
see comment in Smalltalk>>initSystemPath.
This should be used to access resources such as bitmaps, doc-files,
and other help files.

o  imageFromFileNamed: aFileName forClass: aClass
search aFileName in some standard places:
first in the redefinable bitmaps path, then in the classes
own package directory if existing.
Return an image or nil.

o  imageFromFileNamed: aFileName inPackage: aPackage
search aFileName in some standard places:
first in the redefinable bitmaps path,
then in the package directory if existing.
Return an image or nil.
Search order is:
bitmaps/<pkg>/file
resources/<pkg>/bitmaps/file
<pkg>/bitmaps/file

o  libraryFileNameOfClass: aClassOrClassName
for a given class, return the name of a classLibrary which contains
binary code for it.
Read the libinfo file 'liblist.stc' (which is created during the compilation process)
for an entry for aClassOrClassName.
Search for the className in the first col, and return the value found in
the 2nd col.
Return nil if no entry is found.

A nil returns means that this class is either built-in or not present
in a package-class library (i.e. either as separate .o or separate .st file).
Otherwise, the returned name is the classLibrary object of that class.
The classes code can be loaded from that file if binary loading is supported.

o  packagePath
return a collection of additional directorynames, where smalltalk
looks for package directories.
Notice, that directories named 'packages' under the systemPath are
always consulted - even if not in the packagePath

o  packagePath: aPath
set the packagePath;
a collection of additional directorynames, where smalltalk
looks for package directories.
Notice, that directories named 'packages' under the systemPath are
always consulted - even if not in the packagePath

o  projectDirectoryForClass: aClass
given a class, return the path to its package directory;
nil if not found.

o  projectDirectoryForPackage: aPackage
given a packageID, return the path to its package directory;
nil if not found.

o  readAbbreviations
read classname to filename mappings from include/abbrev.stc.
sigh - all for those poor sys5.3 or MSDOS people with short filenames ...

o  readAbbreviationsFromStream: aStream
read classname to filename mappings from aStream.
sigh - all for those poor sys5.3 or MSDOS people with short filenames ...

o  realSystemPath
return the realSystemPath - thats the directory names from
SystemPath which exist and are readable

o  recursiveReadAllAbbreviationsFrom: aDirectory

o  recursiveReadAllAbbreviationsFrom: aDirectory maxLevels: maxLevels
read all abbreviations from and under aDirectory.

o  resourceDirectoryForPackage: aPackage
given a packageID, return the path to its resource directory;
nil if not found.

o  resourceFileStreamFor: aFileName
search aFileName in some standard places;
return a readonly fileStream or nil if not found.
Searches in subdirectories named 'resource' in SystemPath

o  resourceFileStreamFor: aFileName forClass: aClassOrNil
search aFileName in some standard places and in the classes
package-resource directory.
Return a readonly fileStream or nil if not found.
Searches in subdirectories named 'resource' in SystemPath

o  searchPath: aPath for: aFileName in: aDirName
search aPath for a subdirectory named aDirectory with a file
named aFileName

o  setFilename: aFileNameString forClass: aClassNameString package: aPackageNameString

o  sourceDirectoryNameOfClass: aClassOrClassName
for a given class, return the pathname relative to TOP of the classes source code.
Read the files 'abbrev.stc' and 'liblist.stc' (which are created during the compilation process)
for an entry for aClassOrClassName.
Search for the className in the first col, and return the value found in
the 3rd col.
Return nil if no entry is found.

o  sourceFileStreamFor: aFileName
search aFileName in some standard places;
return a readonly fileStream or nil if not found.
Searches in subdirectories named 'source' in SystemPath

o  systemFileStreamFor: aFileName
search aFileName in some standard places;
return a readonly fileStream or nil if not found.
see comment in Smalltalk>>initSystemPath

o  systemPath
return a collection of directorynames, where smalltalk
looks for system files
(usually in subdirs such as resources, bitmaps, source etc.)
see comment in Smalltalk>>initSystemPath.

o  systemPath: aPath
set the collection of directorynames, where smalltalk
looks for system files
(usually in subdirs such as resources, bitmaps, source etc.)
see comment in Smalltalk>>initSystemPath.

o  withAbbreviationsFromStream: aStream do: aBlock
read classname to filename mappings from aStream.
Evaluate aBlock for each tuple:
class-name , abbrev-name, package
Sigh - all for those poor sys5.3 or MSDOS people with short filenames...

system management-packages
o  loadPackage: aPackageIdOrPackage
make certain, that some particular package is loaded into the system.
Return true if loaded, false otherwise.

o  packageDirectoryForPackageId: aPackageId
used by classes to find the location of their resource- and bitmap directories.

Notice that the directory structure is different between the development
environment (top for packages is ../../../stx) and delivered stand alone executables,
where the top is specified via a shell environment variable, and is typically ../lib.
At runtime, Smalltalk knows about the systemPath setting.

o  unloadPackage: aPackageIdOrPackage

system management-undeclared variables
o  clearUndeclaredVariables
remove all undeclared variables

o  undeclaredPrefix
the prefix used for undeclared variables

time-versions
o  configuration
for developers only: return the configuration, with which
this smalltalk was compiled.

o  copyrightString
return a copyright string

o  distributorString
return a string describing the distributor of this software

o  expirationTime
for developers only: return the time when the system will expire.
after this time it will not run any longer.
It returns nil, if no expiration time has been set (system runs forever :-))

o  fullVersionString
return a full version string

o  hello
return a greeting string

o  imageRestartTime
return a timestamp for the moment when this image was restarted.
If we do not execute from an image (i.e. fresh start), return nil.

o  imageSaveTime
return a timestamp for the moment when this image was saved

o  imageStartTime
return a timestamp for the moment when this system started the first time
(i.e. the first initial start without an image)

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

ST/X revision Naming is:
<major>.<minor>.<revision>.<release>

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

ST/X revision Naming is:
<major>.<minor>.<revision>.<release>

o  releaseIdentification
for developers only: return the release
(to further identify the version in case of errors)

o  releaseNr
return the revision number.
Incremented for releases which fix bugs/add features but did not find
their way to the outside world.

ST/X revision Naming is:
<major>.<minor>.<revision>.<release>

o  revisionNr
return the revision number.
Incremented for releases which fix bugs/add features
and represent a stable workable version which got published
to the outside world.

ST/X revision Naming is:
<major>.<minor>.<revision>.<release>

o  timeStamp
return a string useful for timestamping a file.
The returned string is padded with spaces for a constant
length (to avoid changing a files size in fileOut with unchanged
class).

o  timeStamp: aStream
write a string useful for timestamping a file onto aStream.
ST80 compatibility

o  timeStampString
return a string useful for timestamping a file.

o  versionDate
return the executables build date - thats the date when the smalltalk
executable was built

o  versionString
return the version string

o  vmMajorVersionNr
return the VMs major version number.

ST/X 6.1.1; WebServer 1.620 at exept:8081; Tue, 22 May 2012 22:14:32 GMT