"

 COPYRIGHT (c) 1989 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.

"

ClassDescription subclass:#Class

	 instanceVariableNames:'classvars comment subclasses classFilename package revision

		history'

	 classVariableNames:'UpdatingChanges LockChangesFile FileOutErrorSignal

		CatchMethodRedefinitions MethodRedefinitionSignal

		UpdateChangeFileQuerySignal'

	 poolDictionaries:''

	 category:'Kernel-Classes'

!

!Class class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1989 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

"

    Class adds more functionality to classes; minimum stuff has already

    been defined in Behavior and ClassDescription; this adds naming, categories etc.

    Also change management and recompilation is defined here (since the superclasses

    do not have enough symbolic information to support compilation).

    For production code, the stc compiler is planned to (optionally) generate classes 

    as subclasses of Behavior - to excludes all name, source info etc., 

    however, normally all classes are subclasses of Class.

    Instance variables:

	classvars       <String>        the names of the class variables

	comment         <String>        the classes comment; either a string,

					a number specifying the offset in classFilename, or nil

	subclasses      <Collection>    cached collection of subclasses

					(currently unused - but will be soon)

	classFilename   <String>        the file (or nil) where the classes

					sources are found 

	package         <Symbol>        the package, in which the class was defined

					(inserted by compilers)

	revision        <String>        revision string - inserted by stc

	history         <any>           a place for a history string (not currently used)

    Class variables:

	UpdatingChanges <Boolean>       true if the changes-file shall be updated

					(except during startup and when filing in, this flag

					 is usually true)

	LockChangesFile <Boolean>       if true, the change file is locked for updates.

					Required when multiple users operate on a common

					change file.

					This is an experimental new feature, being evaluated.

	UpdateChangeFileQuerySignal     used as an upQuery from the change management.

					Whenever a changeRecord is to be written,

					this signal is raised and a handler (if present)

					is supposed to return true or false.

					If unhandled, the value of the global

					UpdatingChanges is returned for backward

					compatibility (which means that the old

					mechanism is used if no query-handler

					is present).

	FileOutErrorSignal              raised when an error occurs during fileOut

	CatchMethodRedefinitions        if true, classes protect themself 

	MethodRedefinitionSignal        (by raising MethodRedefinitionSignal)

					from redefining any existing methods,

					which are defined in another package.

					(i.e. a signal will be raised, if you

					 fileIn something which redefines an

					 existing method and the packages do not

					 match).

					The default is (currently) true.

    WARNING: layout known by compiler and runtime system

"

!

version

!Class class methodsFor:'initialization'!

initialize

    "the classvariable 'UpdatingChanges' controls if changes are put

     into the changes-file; normally this variable is set to true, but

     (for example) during fileIn or when changes are applied, it is set to false

     to avoid putting too much junk into the changes-file."

    UpdatingChanges := true.

    LockChangesFile := false.

    CatchMethodRedefinitions := true.

    FileOutErrorSignal isNil ifTrue:[

	FileOutErrorSignal := ErrorSignal newSignalMayProceed:false.

	FileOutErrorSignal nameClass:self message:#fileOutErrorSignal.

	FileOutErrorSignal notifierString:'error during fileOut'.

	MethodRedefinitionSignal := ErrorSignal newSignalMayProceed:true.

	MethodRedefinitionSignal nameClass:self message:#methodRedefinitionSignal.

	MethodRedefinitionSignal notifierString:'attempt to redefine method from different package'.

	UpdateChangeFileQuerySignal := QuerySignal new mayProceed:true.

	UpdateChangeFileQuerySignal nameClass:self message:#updateChangeFileQuerySignal.

	UpdateChangeFileQuerySignal notifierString:'asking if changeFile update is wanted'.

	UpdateChangeFileQuerySignal handlerBlock:[:ex | ex proceedWith:UpdatingChanges].

    ]

! !

!Class class methodsFor:'Signal constants'!

fileOutErrorSignal

    "return the signal raised when an error occurs while fileing out.

     This is signalled to allow browsers some user feed back in case

     a fileout fails (for example due to disk-full errors)"

    ^ FileOutErrorSignal

!

methodRedefinitionSignal

    "return the signal raised when a method is about to be installed

     which redefines an existing method and the methods packages are not

     equal. This helps when filing in alien code, to prevent existing

     methods to be overwritten or redefined by incompatible methods"

    ^ MethodRedefinitionSignal

!

updateChangeFileQuerySignal

    "return the signal used as an upQuery if the changeFile should be updated.

     If unhandled, the value of UpdatingChanges is returned by the signals

     static handler."

    ^ UpdateChangeFileQuerySignal

! !

!Class class methodsFor:'accessing - flags'!

catchMethodRedefinitions

    "return the redefinition catching flag."

    ^ CatchMethodRedefinitions

!

catchMethodRedefinitions:aBoolean

    "turn on/off redefinition catching. Return the prior value of the flag."

    |prev|

    prev := CatchMethodRedefinitions.

    CatchMethodRedefinitions := aBoolean.

    ^ prev

!

lockChangesFile

    "return true, if the change file is locked during update"

    ^ LockChangesFile

!

lockChangesFile:aBoolean

    "turn on/off change-file-locking. Return the previous value of the flag."

    |prev|

    prev := LockChangesFile.

    LockChangesFile := aBoolean.

    ^ prev

!

updateChanges:aBoolean

    "turn on/off changes management. Return the prior value of the flag."

    |prev|

    prev := UpdatingChanges.

    UpdatingChanges := aBoolean.

    ^ prev

!

updatingChanges

    "return true if changes are recorded"

    ^ UpdatingChanges

! !

!Class class methodsFor:'enumeration '!

allClassesInCategory:aCategory do:aBlock

    "evaluate aBlock for all classes in aCategory;

     no specific order is defined."

    Smalltalk allBehaviorsDo:[:aClass |

	aClass isMeta ifFalse:[

	    (aClass category = aCategory) ifTrue:[

		aBlock value:aClass

	    ]

	].

    ]

    "

     Class allClassesInCategory:'Kernel-Classes' 

			     do:[:class |Transcript showCr:class name]

    "

!

allClassesInCategory:aCategory inOrderDo:aBlock

    "evaluate aBlock for all classes in aCategory;

     superclasses come first - then subclasses."

    |classes|

    classes := OrderedCollection new.

    Smalltalk allBehaviorsDo:[:aClass |

	aClass isMeta ifFalse:[

	    (aClass category = aCategory) ifTrue:[

		classes add:aClass

	    ]

	]

    ].

    classes topologicalSort:[:a :b | b isSubclassOf:a].

    classes do:aBlock

! !

!Class class methodsFor:'helpers'!

revisionInfoFromString:aString

    "return a dictionary filled with revision info.

     This extracts the relevant info from aString."

    |words info nm|

    info := IdentityDictionary new.

    words := aString asCollectionOfWords.

    "/

    "/ supported formats:

    "/

    "/ $-Header: pathName rev date time user state $

    "/ $-Revision: rev $

    "/ $-Id: fileName rev date time user state $

    "/

    ((words at:1) = '$Header:') ifTrue:[

	nm := words at:2.

	info at:#repositoryPathName put:nm.

	(nm endsWith:',v') ifTrue:[

	    nm := nm copyWithoutLast:2

	].

	info at:#fileName put:nm asFilename baseName.

	info at:#revision put:(words at:3).

	info at:#date put:(words at:4).

	info at:#time put:(words at:5).

	info at:#user put:(words at:6).

	info at:#state put:(words at:7).

	^ info

    ].

    ((words at:1) = '$Revision:') ifTrue:[

	info at:#revision put:(words at:2).

	^ info

    ].

    ((words at:1) = '$Id:') ifTrue:[

	info at:#fileName put:(words at:2).

	info at:#revision put:(words at:3).

	info at:#date put:(words at:4).

	info at:#time put:(words at:5).

	info at:#user put:(words at:6).

	info at:#state put:(words at:7).

	^ info

    ].

    "/

    "/ mhmh - maybe its some other source code system

    "/

    SourceCodeManager notNil ifTrue:[

	^ SourceCodeManager revisionInfoFromString:aString

    ].

    ^ nil

    "Created: 15.11.1995 / 14:58:35 / cg"

! !

!Class methodsFor:'ST/V subclass creation'!

subclass:t instanceVariableNames:f classVariableNames:d poolDictionaries:s

    "this method allows fileIn of ST/V classes 

     (which seem to have no category)"

    ^ self subclass:t 

	   instanceVariableNames:f

	   classVariableNames:d

	   poolDictionaries:s

	   category:'ST/V classes'

!

variableByteSubclass:t classVariableNames:d poolDictionaries:s

    "this method allows fileIn of ST/V variable byte classes 

     (which seem to have no category and no instvars)"

    ^ self variableByteSubclass:t 

	   instanceVariableNames:''

	   classVariableNames:d

	   poolDictionaries:s

	   category:'ST/V classes'

!

variableSubclass:t instanceVariableNames:f classVariableNames:d poolDictionaries:s

    "this method allows fileIn of ST/V variable pointer classes 

     (which seem to have no category)"

    ^ self variableSubclass:t 

	   instanceVariableNames:f

	   classVariableNames:d

	   poolDictionaries:s

	   category:'ST/V classes'

! !

!Class methodsFor:'accessing'!

addClassVarName:aString

    "add a class variable if not already there and initialize it with nil.

     Also writes a change record and notifies dependents.

     BUG: Currently, no recompilation is done - this will change."

    (self classVarNames includes:aString) ifFalse:[

	self classVariableString:(self classVariableString , ' ' , aString).

	self addChangeRecordForClass:self.

	self updateRevisionString.

	self changed:#definition.

    ]

    "Created: 29.10.1995 / 19:40:51 / cg"

!

allClassVarNames

    "return a collection of all the class variable name-strings

     this includes all superclass-class variables"

    ^ self addAllClassVarNamesTo:(OrderedCollection new)

    "

     Float allClassVarNames

    "

!

classFilename

    "return the name of the file from which the class was compiled.

     This is currently NOT used."

    ^ classFilename

!

classVarAt:aSymbol

    "return the value of a class variable.

     Currently, this returns nil if there is no such classvar -

     this may change."

    "

     this hides the (current) implementation of classVariables

     from the outside world. Currently, classvars are stored in

     the Smalltalk dictionary with a funny name, since there are

     no classPools yet.

    "

    ^ Smalltalk at:(self name , ':' , aSymbol) asSymbol

!

classVarAt:aSymbol put:something

    "store something in a classvariable.

     Currently this creates a global with a funny name if no such

     classVar exists - this may change."

    "

     this hides the (current) implementation of classVariables

     from the outside world. Currently, classvars are stored in

     the Smalltalk dictionary with a funny name, since there are

     no classPools yet.

    "

    Smalltalk at:(self name , ':' , aSymbol) asSymbol put:something.

!

classVarNames

    "return a collection of the class variable name-strings.

     Only names of class variables defined in this class are included

     in the returned collection - use allClassVarNames, to get all known names."

    classvars isNil ifTrue:[

	^ OrderedCollection new

    ].

    ^ classvars asCollectionOfWords

    "

     Object classVarNames 

     Float classVarNames

    "

!

classVariableString

    "return a string of the class variables names.

     Only names of class variables defined in this class are in the

     returned string."

    classvars isNil ifTrue:[^ ''].

    ^ classvars

    "

     Object classVariableString 

     Float classVariableString  

    "

!

classVariableString:aString

    "set the classes classvarnames string; 

     Initialize new class variables with nil, clear and remove old ones. 

     No change record is written and no classes are recompiled."

    |prevVarNames varNames any|

    "ignore for metaclasses except the one"

    (self isMeta) ifTrue:[

	(self == Metaclass) ifFalse:[

	    ^ self

	]

    ].

    (classvars = aString) ifFalse:[

	prevVarNames := self classVarNames.

	classvars := aString.

	varNames := self classVarNames.

	"new ones get initialized to nil;

	 - old ones are nilled and removed from Smalltalk"

	any := false.

	varNames do:[:aName |

	    (prevVarNames includes:aName) ifFalse:[

		"a new one"

		self classVarAt:aName put:nil.

		any := true.

	    ] ifTrue:[

		prevVarNames remove:aName

	    ]

	].

	"left overs are gone"

	prevVarNames do:[:aName |

	    self classVarAt:aName put:nil.

	    Smalltalk removeKey:(self name , ':' , aName) asSymbol.

	].

	any ifTrue:[

	    Smalltalk changed:#classVariables with:self

	].

    ]

!

comment

    "return the comment (aString) of the class"

    |stream string|

    "the comment is either a string, or an integer specifying the

     position within the classes sourcefile ...

    "

    comment isNumber ifTrue:[