hg/stx-libbasic: comparison Method.st

equal deleted inserted replaced

-:3d15dcbe0057
+:3a3d3c02c3bd
 hereby transferred.
 "
 "{ Package: 'stx:libbasic' }"
 CompiledCode variableSubclass:#Method
-	instanceVariableNames:'source sourcePosition category package mclass'
+instanceVariableNames:'source sourcePosition category package mclass'
-	classVariableNames:'PrivateMethodSignal LastFileReference LastSourceFileName
+classVariableNames:'PrivateMethodSignal LastFileReference LastSourceFileName
-		LastWhoClass LastFileLock LastMethodSources LastMethodSourcesLock
+LastWhoClass LastFileLock LastMethodSources LastMethodSourcesLock
-		CompilationLock'
+CompilationLock'
-	poolDictionaries:''
+poolDictionaries:''
-	category:'Kernel-Methods'
+category:'Kernel-Methods'
 !
 Object subclass:#MethodWhoInfo
-	instanceVariableNames:'myClass mySelector'
+instanceVariableNames:'myClass mySelector'
-	classVariableNames:''
+classVariableNames:''
-	poolDictionaries:''
+poolDictionaries:''
-	privateIn:Method
+privateIn:Method
 !
 !Method class methodsFor:'documentation'!
 copyright
 which is compiled by the machines native C-compiler.
 As opposed to JITted code, this allows for embedded primitive C-code.
 "
 !
 privacy
 "
 ST/X includes an EXPERIMENTAL implementation of method privacy.
 Individual methods may be set to private or protected via the
 privacy:#private and privacy:#protected messages. Also, categories may be
 filedIn as a whole as private using #privateMethodsFor: or as
 is equivalent to #methodsFor: (also to support fileIn of ENVY methods).
 Protected methods may be executed only when called via a self-send
 from the superclass-methods and self or super-sends from methods in the
 class itself or subclasses.
 Private methods may not be called from subclasses-methods,
 i.e. they may only be called via self sends from within the current class.
 (i.e. protected methods are less private than private ones)
 When such a situation arises, the VM (runtime system) will raise the
 PrivateMethodSignal exception (if nonNil), which usually brings you into the
 If PrivateMethodSignal is nil, the VM will not check for this, and
 execution is as usual. (you may want to nil-it for production code,
 and leave it non nil during development).
 NOTICE: there is no (not yet ?) standard defined for method privacy,
 however, the definition protocol was designed to be somewhat ENVY compatible
 (from what can be deduced by reading PD code).
 Also, the usability of privacy is still to be tested.
 This interface, the implementation and the rules for when a privacy violation
 may change (in case of some ANSI standard being defined).
 (nA := aSelector numArgs) == 1 ifTrue:[
 argNames := #('arg')
 ] ifFalse:[
 argNames := (1 to:nA) collect:[:i | 'arg' , i printString].
 ].
 ^ self
 methodDefinitionTemplateForSelector:aSelector
 andArgumentNames:argNames.
 "
 Method methodDefinitionTemplateForSelector:#foo
 Method methodDefinitionTemplateForSelector:#+
 Method methodDefinitionTemplateForSelector:#foo:bar:baz:
 "
 !
 methodDefinitionTemplateForSelector:aSelector andArgumentNames:argNames
 "given a selector, return a prototype definition string"
 aSelector numArgs > 0 ifTrue:[
 aSelector isKeyword ifTrue:[
 ^ String streamContents:[:stream |
 aSelector keywords with:argNames do:[:eachKeyword :eachArgName|
 stream nextPutAll:eachKeyword; nextPutAll:eachArgName; space.
 ].
 stream backStep.   "remove the last space"
 ].
 ].
 ^ aSelector , ' ' , (argNames at:1)
 ].
 ^ aSelector
 "
 Method methodDefinitionTemplateForSelector:#foo          andArgumentNames:#()
 Method methodDefinitionTemplateForSelector:#+            andArgumentNames:#('aNumber')
 Method methodDefinitionTemplateForSelector:#foo:bar:baz: andArgumentNames:#('fooArg' 'barArg' 'bazArg')
 "
 !
 methodPrivacySupported
 "return true, if the system was compiled to support methodPrivacy.
 !Method methodsFor:'Compatibility-VW'!
 classIsMeta
 "return true, if this method is a class method"
 ^ self mclass isMeta
 !
 sendsSelector:aSelectorSymbol
 "return true, if this method contains a message-send
 with aSelectorSymbol as selector."
 cls := self mclass.
 cls notNil ifTrue:[
 cls addChangeRecordForMethodCategory:self category:newCategory.
 self changed:#category with:oldCategory.            "/ will vanish
 cls changed:#organization with:self selector.       "/ will vanish
 Smalltalk changed:#methodCategory with:(Array with:cls with:self with:oldCategory).
 ]
 ]
 ]
 "Modified: / 25-09-2007 / 16:15:24 / cg"
 !
 comment
 "return the methods comment.
 This is done by searching for and returning the first comment
 from the methods source (excluding any double-quotes).
 Returns nil if there is no comment (or source is not available)."
 |src comment comments parser|
 src := self source.
 ].
 ].
 ^ comment.
 "
 (Method compiledMethodAt:#comment) comment
 (Object class compiledMethodAt:#infoPrinting:) comment
 "
 "Modified: / 17.2.1998 / 14:50:00 / cg"
 "Modified: / 23.2.1998 / 10:26:08 / stefan"
 !
 ^ sourcePosition
 !
 localSourceFilename:aFileName position:aNumber
 "set the methods sourcefile/position indicating, that
 this is a local file."
 source := aFileName.
 sourcePosition := aNumber negated
 ].
 !
 mclass:aClass
 "set the method's class"
 mclass == aClass ifTrue:[ ^ self ].
 "/     (mclass notNil and:[aClass notNil]) ifTrue:[
 "/         'Method [warning]: mclass already set' errorPrintCR.
 "/     ].
 cls := self mclass.
 self changed:#package.                                              "/ will vanish
 cls changed:#methodPackage with:self selector.                      "/ will vanish
 Smalltalk changed:#projectOrganization with:(Array with:cls with:self with:oldPackage).
 cls addChangeRecordForMethodPackage:self package:newPackage.
 ]
 "Modified: / 23-11-2006 / 17:01:02 / cg"
 !
 chunk notNil ifTrue:[
 ^ chunk
 ].
 LastFileLock critical:[
 "have to protect sourceStream from being closed as a side effect
 of some other process fetching some the source from a different source file"
 sourceStream := self sourceStreamUsingCache:true.
 sourceStream notNil ifTrue:[
 [
 "return true, if this is an ignored method.
 Ignored methods are physically present in the source file,
 but no code is generated for it by stc, and the VM does not see
 it in its message lookup.
 (i.e. setting a method to #ignored, and sending that selector,
 leads to either the superclasses implementation to be called,
 or a doesNotUnderstand exception to be raised)
 Notice: this is a nonstandard feature, not supported
 by other smalltalk implementations and not specified in the ANSI spec.
 !
 isRestricted
 "return the flag bit stating that this method is restricted.
 Execution of the receiver will only be allowed if the system is not in
 'trap restricted mode' (-->ObjectMemory) otherise a runtime
 error (PrivateMethodSignal) is raised.
 Notice: method restriction is a nonstandard feature, not supported
 by other smalltalk implementations and not specified in the ANSI spec.
 !Method privateMethodsFor:'accessing-visibility'!
 primSetPrivacy:aSymbol
 "set the methods access rights (privacy) from a symbol;
 Currently, this must be one of #private, #protected, #public or #ignored.
 #setPrivacy: simply sets the attribute. When changing methods, that
 have already been called, #privacy: should be used.
 Notice: method privacy is a nonstandard feature, not supported
 by other smalltalk implementations and not specified in the ANSI spec.
 If at all, use it for debugging purposes, to catch messagesends
 p = F_CLASSPRIVATE;
 else if (aSymbol == @symbol(ignored))
 p = F_IGNORED;
 else
 RETURN(false);  /* illegal symbol */
 f = (f & ~M_PRIVACY) | p;
 __INST(flags) = __mkSmallInteger(f);
 #endif
 self changed:#privacy.                                       "/ will vanish
 myClass notNil ifTrue:[
 mySelector notNil ifTrue:[
 myClass changed:#methodPrivacy with:mySelector.      "/ will vanish
 Smalltalk changed:#privacyOfMethod with:(Array with:myClass with:self with:oldPrivacy).
 myClass addChangeRecordForMethodPrivacy:self.
 ]
 ]
 ]
 "Modified: / 23-11-2006 / 17:03:20 / cg"
 !
 restricted:aBoolean
 "set or clear the flag bit stating that this method is restricted.
 Execution of the receiver will only be allowed if the system is not in
 'trap restricted mode' (-->ObjectMemory) otherise a runtime
 error (PrivateMethodSignal) is raised.
 Notice: method restriction is a nonstandard feature, not supported
 #ifdef F_RESTRICTED
 INT f = __intVal(__INST(flags));
 INT old;
 old = f;
 if (aBoolean == true)
 f |= F_RESTRICTED;
 else
 f &= ~F_RESTRICTED;
 __INST(flags) = __mkSmallInteger(f);
 if (old & F_RESTRICTED)
 !
 setPrivacy:aSymbol
 "set the methods access rights (privacy) from a symbol;
 Currently, this must be one of #private, #protected, #public or #ignored.
 #setPrivacy: simply sets the attribute. When changing methods, that
 have already been called, #privacy: should be used.
 Notice: method privacy is a nonstandard feature, not supported
 by other smalltalk implementations and not specified in the ANSI spec.
 If at all, use it for debugging purposes, to catch messagesends
 !
 setPrivacy:aSymbol flushCaches:doFlush
 "set the methods access rights (privacy) from a symbol;
 Currently, this must be one of #private, #protected, #public or #ignored.
 #setPrivacy: simply sets the attribute. When changing methods, that
 have already been called, #privacy: should be used.
 Notice: method privacy is a nonstandard feature, not supported
 by other smalltalk implementations and not specified in the ANSI spec.
 If at all, use it for debugging purposes, to catch messagesends
 the same semantics as the receiver, but uses interpreted bytecodes.
 Otherwise, return the receiver. The new method is not installed in
 the methodDictionary of any class - just returned.
 If the method contains primitive code, this may return a method
 without bytecode.
 Can be used to obtain a bytecode version of a machine-code method,
 for binary storage or dynamic recompilation (which is not yet finished)
 or to compile lazy methods down to executable ones."
 |mthd|
 !
 asByteCodeMethodWithSource:newSource
 |mthd|
 ParserFlags
 withSTCCompilation:#never
 do:[
 mthd := self asExecutableMethodWithSource:newSource.
 ].
 ^ mthd
 "Created: 24.10.1995 / 14:02:32 / cg"
 "Modified: 5.1.1997 / 01:01:53 / cg"
 !
 asExecutableMethod
 "if the receiver has neither bytecodes nor machinecode, create & return a
 method having semantics as the receivers source. This may be machine code,
 if the system supports dynamic loading of object code and the source includes
 primitive code. However, bytecode is preferred, since it compiles faster.
 Otherwise, return the receiver. The new method is not installed in
 the methodDictionary of any class - just returned.
 ^ nil.
 ].
 "/
 "/ try to save a bit of memory, by sharing the source (whatever it is)
 "/
 temporaryMethod sourceFilename:source position:sourcePosition.
 ^ temporaryMethod
 !
 asExecutableMethodWithSource:newSource
 |temporaryMethod cls|
 (happened when autoloading animation demos)
 "
 CompilationLock critical:[
 "
 dont want this to go into the changes file,
 dont want output on Transcript and definitely
 dont want a lazy method ...
 "
 Class withoutUpdatingChangesDo:[
 |silent lazy|
 inCategory:(self category)
 notifying:nil
 install:false.
 ] ifFalse:[
 temporaryMethod := compiler new
 compile:newSource
 in:cls
 notifying:nil
 ifFail:nil
 ].
 ].
 ] ensure:[
 Compiler compileLazy:lazy.
 ^ nil.
 ].
 "/
 "/ try to save a bit of memory, by sharing the source (whatever it is)
 "/
 temporaryMethod source:newSource.
 "/
 "/ dont forget the methods class & package ...
 "/
 temporaryMethod setPackage:package.
 temporaryMethod mclass:mclass.
 this method if - after a class change - a method cannot be compiled
 and is therefore no longer executable (for example, after an instvar
 has been removed, and a method still tries to access this instvar)
 Thus, we arrive here, when playing around in a classes methodArray,
 or compiler/runtime system is broken :-(,
 or you ignore the error messages during some recompile."
 %{
 /*
 * for reasons too far from being explained here,
 "{ Pragma: +optSpace }"
 "this error is triggered, if a private or protected method is called.
 If you continue in the debugger, the method will be called,
 and further privacy exceptions will NOT be reported at this call location,
 until any new method is compiled, or the privacy of any method changes,
 or the caches are flushed.
 (the reason is that after the continue, the method is enterred into the
 calling cache, for which method privacy is not checked.
 Any of the above actions flushes this cache and a privacy check
 ^ who methodClass name , ' >> ' , (who methodSelector storeString)
 ].
 ^ 'unboundMethod'
 "
 Method new whoString
 (Method compiledMethodAt:#whoString) whoString
 "
 "Modified: 1.11.1996 / 16:27:04 / cg"
 ! !
 usingCacheBoolean ifTrue:[
 (package notNil and:[package ~= PackageId noProjectID]) ifTrue:[
 "/ keep the last source file open, because open/close
 "/ operations maybe slow on NFS-mounted file systems.
 "/ Since the reference to the file is weak, it will be closed
 "/ automatically if the file is not referenced for a while.
 "/ Neat trick.
 LastFileLock critical:[
 aStream := LastFileReference at:1.
 (aStream isNil or:[aStream == 0 or:[aStream isOpen not]]) ifTrue:[
 ].
 ].
 ].
 "/ a negative sourcePosition indicates
 "/ that this is a local file
 "/ (not to be requested via the sourceCodeManager)
 "/ This kludge was added, to allow sourceCode to be
 "/ saved to a local source file (i.e. 'st.src')
 "/ and having a clue for which file is meant later.
 ^ aStream
 ].
 ].
 "/
 "/ nope - look in standard places
 "/ (if there is a source-code manager - otherwise, we already did that)
 "/
 (mgr notNil and:[Class tryLocalSourceFirst not]) ifTrue:[
 aStream := self localSourceStream.
 aStream notNil ifTrue:[
 ].
 ^ aStream
 ].
 ]
 ]
 ].
 ^ nil
 "Modified: / 26-11-2006 / 22:33:38 / cg"
 !
 |src parser|
 src := self source.
 src notNil ifTrue:[
 parser := Parser
 parseMethod:src
 in:self containingClass
 ignoreErrors:true
 ignoreWarnings:true.
 (parser notNil and:[parser ~~ #Error]) ifTrue:[
 ^ parser usedInstVars
 ].
 "Modified: 19.6.1997 / 17:54:09 / cg"
 !
 containingClass
 "return the class I am defined in.
 See comment in who."
 "based on who, which has been added for ST-80 compatibility"
 |who|
 none found - sorry
 "
 ^ nil
 "
 (Object compiledMethodAt:#at:) containingClass
 (Object class compiledMethodAt:#version) containingClass
 "
 !
 externalLibraryFunction
 "if this is an externalLibraryFunction call, return the externalLibraryFunction.
 "/ ok; it may or may not ...
 ^ self parse:#'parseMethodSilent:' return:#hasPrimitiveCode or:false
 "
 (Method compiledMethodAt:#hasPrimitiveCode) hasPrimitiveCode
 (Object compiledMethodAt:#at:) hasPrimitiveCode
 (Object compiledMethodAt:#basicAt:) hasPrimitiveCode
 "
 "Modified: 22.1.1997 / 00:03:45 / cg"
 !
 funcOrNil := self externalLibraryFunction.
 (funcOrNil isNil or:[funcOrNil isCallTypeOLE not]) ifTrue:[^ nil].
 ^ funcOrNil vtableIndex
 "
 (Method compiledMethodAt:#hasPrimitiveCode) isOLECall
 (Method compiledMethodAt:#hasPrimitiveCode) indexOfOLECall
 (Win32OperatingSystem class compiledMethodAt:#primClosePrinter:) isOLECall
 (Win32OperatingSystem class compiledMethodAt:#primClosePrinter:) indexOfOLECall
 (Win32OperatingSystem class compiledMethodAt:#primClosePrinter:) isExternalLibraryFunctionCall
 (Win32OperatingSystem class compiledMethodAt:#primClosePrinter:) externalLibraryFunctionCall
 (IUnknownPointer compiledMethodAt:#invokeAddRef) isExternalLibraryFunctionCall
 (IUnknownPointer compiledMethodAt:#invokeAddRef) externalLibraryFunction
 (IUnknownPointer compiledMethodAt:#invokeAddRef) isOLECall
 (IUnknownPointer compiledMethodAt:#invokeAddRef) indexOfOLECall
 "
 !
 isDocumentationMethod
 "Return true, if this is a documentation only (only a comment) method
 ^ self mclass isMeta
 and:[(AbstractSourceCodeManager isVersionMethodSelector:self selector)]
 "
 (Method class compiledMethodAt:#version) isVersionMethod
 (Method class compiledMethodAt:#documentation) isVersionMethod
 "
 !
 isVisualWorksTypedef
 messagesSent
 "return a collection with the message selectors sent to by the receiver.
 Uses Parser to parse methods source and extract the names.
 The returned collection includes all used message selectors (i.e. including super-send messages)"
 ^ self parse:#'parseMethodSilent:in:' with:self mclass return:#messagesSent or:#()
 "
 (Method compiledMethodAt:#printOn:) messagesSent
 (Point compiledMethodAt:#x:) messagesSent
 "
 !
 messagesSentToSelf
 "return a collection with the message selectors sent to self by the receiver.
 Uses Parser to parse methods source and extract the names."
 ^ self parse:#'parseMethodSilent:in:' with:self mclass return:#messagesSentToSelf or:#()
 !
 messagesSentToSuper
 "return a collection with the message selectors sent to super by the receiver.
 Uses Parser to parse methods source and extract the names."
 ^ self parse:#'parseMethodSilent:in:' with:self mclass return:#messagesSentToSuper or:#()
 !
 methodArgAndVarNames
 "return a collection with the methods argument and variable names.
 !
 methodDefinitionTemplate
 "return the string that defines the method and the arguments"
 ^ Method
 methodDefinitionTemplateForSelector:self selector
 andArgumentNames:self methodArgNames
 "
 (self compiledMethodAt:#printOn:) methodDefinitionTemplate
 "
 "Modified: 31.10.1995 / 14:36:49 / cg"
 !
 modificationTime
 "try to extract the modificationTime as a timeStamp from
 the receivers source. If there is no source or no history line,
 we do not know the modification time, and nil is returned."
 |s list histLine|
 HistoryManager isNil ifTrue:[^ nil].
 s := self source.
 s isNil ifTrue:[^ nil].
 list := HistoryManager getAllHistoriesFrom:s.
 list size == 0 ifTrue:[^ nil].
 histLine := list last.
 ^ Timestamp
 fromDate:histLine date
 andTime:histLine time
 "
 (Method compiledMethodAt:#modificationTime) modificationTime
 (Method compiledMethodAt:#isMethod) modificationTime
 "
 "Modified: 8.9.1995 / 15:08:22 / claus"
 "Modified: 4.11.1996 / 22:28:17 / cg"
 !
 ^ self selector
 "Created: / 9.11.1998 / 06:15:08 / cg"
 !
 parse:parseSelector return:accessSelector or:valueIfNoSource
 "helper for methodArgNames, methodVarNames etc.
 Get the source, let parser parse it using parseSelector,
 return parser-info using accessSelector"
 ^ self parse:parseSelector with:nil return:accessSelector or:valueIfNoSource
 "
 (Method compiledMethodAt:#parse:return:or:)
 parse:#'parseMethodSilent:' return:#sentMessages or:#()
 "
 !
 parse:parseSelector with:arg2 return:accessSelector or:valueIfNoSource
 "helper for methodArgNames, methodVarNames etc.
 Get the source, let parser parse it using parseSelector,
 return parser-info using accessSelector"
 |parser parserClass sourceString|
 ].
 ^ valueIfNoSource
 "
 (Method compiledMethodAt:#parse:return:or:)
 parse:#'parseMethodSilent:' return:#sentMessages or:#()
 "
 !
 parseResources
 "return the methods resource spec; either nil or a collection of symbols."
 (src findString:'resource:') == 0 ifTrue:[
 ^ nil "/ actually: error
 ].
 "/ no need to parse all - only interested in resource-info
 self parserClass isNil ifTrue:[
 ^ nil
 ].
 parser := self parserClass parseMethodArgAndVarSpecificationSilent:src in:nil.
 parser isNil ifTrue:[
 ^ nil "/ actually error
 ].
 sel isNil ifTrue:[ ^ nil ].
 cls := self mclass.
 cls isNil ifTrue:[ ^ nil ].
 ChangeSet current reverseDo:[:change |
 (change isMethodChange
 and:[ (change selector == sel)
 and:[ change changeClass == cls ]])
 ifTrue:[
 previous := change previousVersion.
 previous notNil ifTrue:[
 ^ previous
 ]
 "/                                        new := entry third.
 "/                                        new == self
 "/                                    ] ifFalse:[
 "/                                        false
 "/                                    ]
 "/                             ]
 "/                     ifNone:nil.
 "/    entry isNil ifTrue:[^nil].
 "/    ^ entry second.
 "/    ^ history at:self ifAbsent:nil
 cls := self mclass.
 cls isNil ifTrue:[^ #()].
 versions := OrderedCollection new.
 ChangeSet current reverseDo:[:change |
 (change isMethodChange
 and:[ (change selector == sel)
 and:[ change changeClass == cls ]])
 ifTrue:[
 versions addFirst:change.
 lastChange := change.
 ]
 ].
 lastChange notNil ifTrue:[
 last := lastChange previousVersion.
 last notNil ifTrue:[
 firstSrc := last source.
 (firstSrc size > 0
 and:[ firstSrc ~= lastChange source]) ifTrue:[
 versions addFirst:(MethodChange
 className:lastChange className
 selector:lastChange selector
 source:firstSrc
 category:lastChange category).
 ]
 ]
 ^ readInstVars includes:varName.
 !
 resourceType
 "ST-80 compatibility:
 return the methods first resource specs key.
 Returns either nil, or a single symbol."
 |resources|
 (resources := self resources) notNil ifTrue:[
 ^ self parseResources.
 !
 selector
 "return the selector under which I am found in my containingClasses
 method-table.
 See comment in who."
 "based on who, which has been added for ST-80 compatibility"
 |who|
 usedGlobals
 "return a collection with the global names referred to by the receiver.
 Uses Parser to parse methods source and extract them."
 ^ self parse:#'parseMethodSilent:in:' with:self mclass return:#usedGlobals or:#()
 "
 (Method compiledMethodAt:#resources) usedGlobals
 "
 !
 usedSymbols
 "return a collection with the symbols referred to by the receiver.
 Uses Parser to parse methods source and extract them.
 This collection only includes implicit symbols references
 (i.e. not messages sent)"
 ^ self parse:#'parseMethodSilent:in:' with:self mclass return:#usedSymbols or:#()
 "
 (Method compiledMethodAt:#usedSymbols) usedSymbols
 (Method compiledMethodAt:#usedSymbols) messagesSent
 "
 !
 who
 "return the class and selector of where I am defined in;
 nil is returned for unbound methods.
 ST/X special notice:
 returns an instance of MethodWhoInfo, which
 responds to #methodClass and #methodSelector query messages.
 For backward- (& ST-80) compatibility, the returned object also
 responds to #at:1 and #at:2 messages.
 Implementation notice:
 Since there is no information of the containing class
 in the method, we have to do a search here.
 Normally, this is not a problem, except when a method is
 accepted in the debugger or redefined from within a method
 (maybe done indirectly, if #doIt is done recursively)
 - the information about which class the original method was
 defined in is lost in this case.
 Problem:
 this is heavily called for in the debugger to create
 a readable context walkback. For unbound methods, it is
 slow, since the search (over all classes) will always fail.
 Q: should we add a backref from the method to the class
 and/or add a subclass of Method for unbound ones ?
 Q2: if so, what about the bad guy then, who copies methods around to
 other classes ?"
 |classes cls sel fn clsName checkBlock|
 checkBlock value:cls theMetaclass.
 ]
 ].
 "
 first, limit the search to global classes only -
 since probability is high, that the receiver is found in there ...
 "
 classes := Smalltalk allClasses.
 "
 instance methods are usually more common - search those first
 "untypical situation: an anonymous class"
 "
 |m cls|
 Object
 subclass:#FunnyClass
 instanceVariableNames:'foo'
 classVariableNames:''
 poolDictionaries:''
 category:'testing'.
 cls := Smalltalk at:#FunnyClass.
 ! !
 !Method class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/Method.st,v 1.346 2010-02-04 17:34:50 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Method.st,v 1.347 2010-04-07 17:36:33 cg Exp $'
 !
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/Method.st,v 1.346 2010-02-04 17:34:50 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Method.st,v 1.347 2010-04-07 17:36:33 cg Exp $'
 ! !
 Method initialize!

changeset 12854	3a3d3c02c3bd
parent 12695	14b7044c2e4a
child 12899	5c3e8ec6f8bb