Bug tracker tells me that my comment is too long! Anyhow here is what
I tried to post. Would love a solution as all my sources code is now
locked out of Pharo.

Pharo image: Pharo 1.3
Pharo core version: Latest update: #13298
Virtual machine used: 1.3 One-Click with Cog
Description

When I open MC and create a package for my code, I get an "Illegal
UTF-8 encoding" error when I try to open any of my packages.

8 September 2011 11:49:57 am

VM: Mac OS - intel - 1067 - Croquet Closure Cog VM [CoInterpreter
VMMaker-oscog.54] Pharo Development 1.1
Image: Pharo1.3 [Latest update: #13298]

ZnUTF8Encoder(Object)>>error:
        Receiver: a ZnUTF8Encoder
        Arguments and temporary variables:
                aString:        'illegal UTF-8 encoding'
        Receiver's instance variables:
a ZnUTF8Encoder

[| nextByte | ((nextByte := stream next) bitAnd: 192)
                        = 128
                ifTrue: [code := (code bitShift: 6)
                                                + (nextByte bitAnd: 63)]
                ifFalse: [self error: 'illegal UTF-8 encoding']] in
ZnUTF8Encoder>>nextFromStream:
        Receiver: a ZnUTF8Encoder
        Arguments and temporary variables:
                stream:         a ZnLimitedReadStream
                code:   #(26)
                nextByte:       94
        Receiver's instance variables:
a ZnUTF8Encoder

ZnUTF8Encoder>>nextFromStream:
        Receiver: a ZnUTF8Encoder
        Arguments and temporary variables:
                stream:         a ZnLimitedReadStream
                byte:   218
                next:   [| nextByte | ((nextByte := stream next) bitAnd: 192)
                        = 128
                ifTrue: ...etc...
                code:   #(26)
        Receiver's instance variables:
a ZnUTF8Encoder

[:stringStream |
[readStream atEnd]
                whileFalse: [stringStream
                                nextPut: (encoder nextFromStream: readStream)].
        nil] in ZnStringEntity>>readLimitedFrom:
        Receiver: a ZnStringEntity(text/plain;charset=UTF-8 9025B)
        Arguments and temporary variables:
                readStream:     a WriteStream 'PK'
                stringStream:   a ZnLimitedReadStream
        Receiver's instance variables:
                contentType:    text/plain;charset=UTF-8
                contentLength:  9025
                string:         nil
                encoder:        a ZnUTF8Encoder

String class(SequenceableCollection class)>>new:streamContents:
        Receiver: String
        Arguments and temporary variables:
                newSize:        100
                blockWithArg:   [:stringStream |
[readStream atEnd]
                whileFalse: [stringStream
...etc...
                stream:         a WriteStream 'PK'
        Receiver's instance variables:
                superclass:     ArrayedCollection
                methodDict:     a MethodDictionary(size 267)
                format:         2
                instanceVariables:      nil
                organization:   ('*Compiler-Kernel' 
inviolateInstanceVariableNames
isLegalInstVar...etc...
                subclasses:     {ByteString. WideString. Symbol}
                name:   #String
                classPool:      a Dictionary(#AsciiOrder->#[0 1 2 3 4 5 6 7 8 9 
10 11 12
13 14 15 16...etc...
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'Collections-Strings'
                traitComposition:       {}
                localSelectors:         nil

String class(SequenceableCollection class)>>streamContents:
        Receiver: String
        Arguments and temporary variables:
                blockWithArg:   [:stringStream |
[readStream atEnd]
                whileFalse: [stringStream
...etc...
        Receiver's instance variables:
                superclass:     ArrayedCollection
                methodDict:     a MethodDictionary(size 267)
                format:         2
                instanceVariables:      nil
                organization:   ('*Compiler-Kernel' 
inviolateInstanceVariableNames
isLegalInstVar...etc...
                subclasses:     {ByteString. WideString. Symbol}
                name:   #String
                classPool:      a Dictionary(#AsciiOrder->#[0 1 2 3 4 5 6 7 8 9 
10 11 12
13 14 15 16...etc...
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'Collections-Strings'
                traitComposition:       {}
                localSelectors:         nil

ZnStringEntity>>readLimitedFrom:
        Receiver: a ZnStringEntity(text/plain;charset=UTF-8 9025B)
        Arguments and temporary variables:
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
                readStream:     a ZnLimitedReadStream
                newString:      nil
        Receiver's instance variables:
                contentType:    text/plain;charset=UTF-8
                contentLength:  9025
                string:         nil
                encoder:        a ZnUTF8Encoder

ZnStringEntity>>readFrom:
        Receiver: a ZnStringEntity(text/plain;charset=UTF-8 9025B)
        Arguments and temporary variables:
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
        Receiver's instance variables:
                contentType:    text/plain;charset=UTF-8
                contentLength:  9025
                string:         nil
                encoder:        a ZnUTF8Encoder

ZnEntity class>>readFrom:usingType:andLength:
        Receiver: ZnEntity
        Arguments and temporary variables:
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
                mimeType:       text/plain;charset=UTF-8
                length:         9025
                newEntity:      a ZnStringEntity(text/plain;charset=UTF-8 9025B)
        Receiver's instance variables:
                superclass:     Object
                methodDict:     a
MethodDictionary(#contentLength->(ZnEntity>>#contentLength "a
Com...etc...
                format:         134
                instanceVariables:      #('contentType' 'contentLength')
                organization:   ('accessing' contentLength contentLength: 
contentType
contentType...etc...
                subclasses:     {ZnApplicationFormUrlEncodedEntity. 
ZnByteArrayEntity.
ZnMultiPartF...etc...
                name:   #ZnEntity
                classPool:      nil
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'Zinc-HTTP-Core'
                traitComposition:       {}
                localSelectors:         nil

ZnEntityReader>>readEntityFromStream
        Receiver: a ZnEntityReader
        Arguments and temporary variables:
                entity:         nil
                decodedEntityLength:    9025
                chunkedStream:  nil
        Receiver's instance variables:
                headers:        a ZnHeaders('Accept-Ranges'->'bytes'
'Cache-Control'->'max-age=-543414...etc...
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
                streaming:      nil
                allowReadingUpToEnd:    true

ZnEntityReader>>readEntity
        Receiver: a ZnEntityReader
        Arguments and temporary variables:
                entity:         nil
        Receiver's instance variables:
                headers:        a ZnHeaders('Accept-Ranges'->'bytes'
'Cache-Control'->'max-age=-543414...etc...
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
                streaming:      nil
                allowReadingUpToEnd:    true

ZnResponse(ZnMessage)>>readFrom:
        Receiver: a ZnResponse(200 OK)
        Arguments and temporary variables:
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
        Receiver's instance variables:
                headers:        a ZnHeaders('Accept-Ranges'->'bytes'
'Cache-Control'->'max-age=-543414...etc...
                entity:         nil
                statusLine:     a ZnStatusLine(200 OK)

ZnResponse class(ZnMessage class)>>readFrom:
        Receiver: ZnResponse
        Arguments and temporary variables:
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
        Receiver's instance variables:
                superclass:     ZnMessage
                methodDict:     a
MethodDictionary(#addCookie:->(ZnResponse>>#addCookie: "a
Compile...etc...
                format:         136
                instanceVariables:      #('statusLine')
                organization:   ('accessing' addCookie: code location location:
setKeepAliveFor: ...etc...
                subclasses:     nil
                name:   #ZnResponse
                classPool:      nil
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'Zinc-HTTP-Core'
                traitComposition:       {}
                localSelectors:         nil

ZnClient class>>execute:on:
        Receiver: ZnClient
        Arguments and temporary variables:
                request:        a ZnRequest(GET 
/mc/JQWidgetBox-Spinner-Core-JohnToohey.3.mcz)
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
        Receiver's instance variables:
                superclass:     Object
                methodDict:     a MethodDictionary()
                format:         2
                instanceVariables:      nil
                organization:   ('as yet unclassified')

                subclasses:     nil
                name:   #ZnClient
                classPool:      nil
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'Zinc-HTTP-Client-Server'
                traitComposition:       {}
                localSelectors:         nil

[ZnClient execute: request on: stream] in ZnHTTPSocketFacade class>>execute:on:
        Receiver: ZnHTTPSocketFacade
        Arguments and temporary variables:
                request:        a ZnRequest(GET 
/mc/JQWidgetBox-Spinner-Core-JohnToohey.3.mcz)
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
        Receiver's instance variables:
                superclass:     Object
                methodDict:     a MethodDictionary()
                format:         2
                instanceVariables:      nil
                organization:   ('as yet unclassified')

                subclasses:     nil
                name:   #ZnHTTPSocketFacade
                classPool:      nil
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'Zinc-HTTP-Client-Server'
                traitComposition:       {}
                localSelectors:         nil

BlockClosure>>ensure:
        Receiver: [ZnClient execute: request on: stream]
        Arguments and temporary variables:
                aBlock:         [stream close]
                complete:       nil
                returnValue:    nil
        Receiver's instance variables:
                outerContext:   ZnHTTPSocketFacade class>>execute:on:
                startpc:        42
                numArgs:        0

ZnHTTPSocketFacade class>>execute:on:
        Receiver: ZnHTTPSocketFacade
        Arguments and temporary variables:
                request:        a ZnRequest(GET 
/mc/JQWidgetBox-Spinner-Core-JohnToohey.3.mcz)
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
        Receiver's instance variables:
                superclass:     Object
                methodDict:     a MethodDictionary()
                format:         2
                instanceVariables:      nil
                organization:   ('as yet unclassified')

                subclasses:     nil
                name:   #ZnHTTPSocketFacade
                classPool:      nil
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'Zinc-HTTP-Client-Server'
                traitComposition:       {}
                localSelectors:         nil

ZnHTTPSocketFacade class>>httpGet:args:user:passwd:
        Receiver: ZnHTTPSocketFacade
        Arguments and temporary variables:
                urlObject:      
'http://git.parspro.com/mc/JQWidgetBox-Spinner-Core-JohnToohey.3.mcz...etc...
                queryArguments:         nil
                username:       'jt'
                password:       'trimixisg4u'
                url:    
http://git.parspro.com/mc/JQWidgetBox-Spinner-Core-JohnToohey.3.mcz
                stream:         SocketStream[inbuf:4kb/outbuf:4kb]
                request:        a ZnRequest(GET 
/mc/JQWidgetBox-Spinner-Core-JohnToohey.3.mcz)
                response:       nil
        Receiver's instance variables:
                superclass:     Object
                methodDict:     a MethodDictionary()
                format:         2
                instanceVariables:      nil
                organization:   ('as yet unclassified')

                subclasses:     nil
                name:   #ZnHTTPSocketFacade
                classPool:      nil
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'Zinc-HTTP-Client-Server'
                traitComposition:       {}
                localSelectors:         nil

HTTPSocket class>>httpGet:args:user:passwd:
        Receiver: HTTPSocket
        Arguments and temporary variables:
                url:    
'http://git.parspro.com/mc/JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'
                queryArguments:         nil
                username:       'jt'
                password:       'trimixisg4u'
        Receiver's instance variables:
                superclass:     Socket
                methodDict:     a
MethodDictionary(#contentType->(HTTPSocket>>#contentType "a
Compi...etc...
                format:         144
                instanceVariables:      #('headerTokens' 'headers' 
'responseCode')
                organization:   ('accessing' contentType contentType: 
contentsLength:
getHeader: ...etc...
                subclasses:     nil
                name:   #HTTPSocket
                classPool:      a Dictionary(#HTTPBlabEmail->''
#HTTPProxyCredentials->'' #HTTPProxy...etc...
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'Network-Protocols'
                traitComposition:       nil
                localSelectors:         nil

[contents := HTTPSocket
                                httpGet: (self urlForFileNamed: aString)
                                args: nil
                                user: self user
                                passwd: self password] in 
MCHttpRepository>>readStreamForFileNamed:do:
        Receiver: a MCHttpRepository(http://git.parspro.com/mc)
        Arguments and temporary variables:
                aString:        'JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'
                contents:       #(nil)
        Receiver's instance variables:
                creationTemplate:       'MCHttpRepository
        location: ''http://git.parspro.com/mc''
        u...etc...
                storeDiffs:     nil
                cache:  a Dictionary()
                allFileNames:   nil
                location:       'http://git.parspro.com/mc'
                user:   'jt'
                password:       'trimixisg4u'
                readerCache:    a Dictionary()

[workBlock value] in [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex total
                                        ifNil: [true]
                                        ifNotNil: [ex amount == nil])
                                ifFalse: [(nextUpdateTime < Time 
millisecondClockValue
                                                        or: [ex total = ex 
amount])
                                                ifTrue: [bar value: ex amount 
asFloat / ex total asFloat.
                                                        nextUpdateTime := Time 
millisecondClockValue + 100]].
                        ex resume]] in MCHttpRepository>>displayProgress:during:
        Receiver: a MCHttpRepository(http://git.parspro.com/mc)
        Arguments and temporary variables:
                workBlock:      [contents := HTTPSocket
                                httpGet: (self urlForFileNamed: 
aString)...etc...
        Receiver's instance variables:
                creationTemplate:       'MCHttpRepository
        location: ''http://git.parspro.com/mc''
        u...etc...
                storeDiffs:     nil
                cache:  a Dictionary()
                allFileNames:   nil
                location:       'http://git.parspro.com/mc'
                user:   'jt'
                password:       'trimixisg4u'
                readerCache:    a Dictionary()

BlockClosure>>on:do:
        Receiver: [workBlock value]
        Arguments and temporary variables:
                exception:      HTTPProgress
                handlerAction:  [:ex |
(ex total
                        ifNil: [true]
                        ifNotNil: [ex amount == ni...etc...
                handlerActive:  true
        Receiver's instance variables:
                outerContext:   [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex...etc...
                startpc:        114
                numArgs:        0

[:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex total
                                        ifNil: [true]
                                        ifNotNil: [ex amount == nil])
                                ifFalse: [(nextUpdateTime < Time 
millisecondClockValue
                                                        or: [ex total = ex 
amount])
                                                ifTrue: [bar value: ex amount 
asFloat / ex total asFloat.
                                                        nextUpdateTime := Time 
millisecondClockValue + 100]].
                        ex resume]] in MCHttpRepository>>displayProgress:during:
        Receiver: a MCHttpRepository(http://git.parspro.com/mc)
        Arguments and temporary variables:
                workBlock:      [:barValArg |
| barVal return newBarSize |
barVal := barValArg.
        re...etc...
                nextUpdateTime:         [contents := HTTPSocket
                                httpGet: (self urlForFileNamed: aSt...etc...
                bar:    #(0)
        Receiver's instance variables:
                creationTemplate:       'MCHttpRepository
        location: ''http://git.parspro.com/mc''
        u...etc...
                storeDiffs:     nil
                cache:  a Dictionary()
                allFileNames:   nil
                location:       'http://git.parspro.com/mc'
                user:   'jt'
                password:       'trimixisg4u'
                readerCache:    a Dictionary()

[result := workBlock value: progress] in [[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex |
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
        Receiver: ProgressInitiationException
        Arguments and temporary variables:
                progress:       [:barValArg |
| barVal return newBarSize |
barVal := barValArg.
        ret...etc...
                result:         #(nil)
        Receiver's instance variables:
                messageText:    nil
                tag:    nil
                signaler:       a MorphicUIManager
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex to...etc...
                maxVal:         1.0
                minVal:         0.0
                aPoint:         960@589
                progressTitle:  'Downloading 
JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'

BlockClosure>>on:do:
        Receiver: [result := workBlock value: progress]
        Arguments and temporary variables:
                exception:      ProgressNotification
                handlerAction:  [:ex |
ex extraParam isString
                ifTrue: [SystemProgressMorph un...etc...
                handlerActive:  true
        Receiver's instance variables:
                outerContext:   [[result := workBlock value: progress]
                on: ProgressNotification...etc...
                startpc:        87
                numArgs:        0

[[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex |
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
        Receiver: ProgressInitiationException
        Arguments and temporary variables:
                progress:       [:barValArg |
| barVal return newBarSize |
barVal := barValArg.
        ret...etc...
                result:         #(nil)
        Receiver's instance variables:
                messageText:    nil
                tag:    nil
                signaler:       a MorphicUIManager
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex to...etc...
                maxVal:         1.0
                minVal:         0.0
                aPoint:         960@589
                progressTitle:  'Downloading 
JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'

BlockClosure>>ensure:
        Receiver: [[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex |
                        ex extr...etc...
        Arguments and temporary variables:
                aBlock:         [SystemProgressMorph close: progress]
                complete:       nil
                returnValue:    nil
        Receiver's instance variables:
                outerContext:   
ProgressInitiationException>>defaultMorphicAction
                startpc:        81
                numArgs:        0

ProgressInitiationException>>defaultMorphicAction
        Receiver: ProgressInitiationException
        Arguments and temporary variables:
                progress:       [:barValArg |
| barVal return newBarSize |
barVal := barValArg.
        ret...etc...
                result:         #(nil)
        Receiver's instance variables:
                messageText:    nil
                tag:    nil
                signaler:       a MorphicUIManager
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex to...etc...
                maxVal:         1.0
                minVal:         0.0
                aPoint:         960@589
                progressTitle:  'Downloading 
JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'

MorphicUIManager>>progressInitiationExceptionDefaultAction:
        Receiver: a MorphicUIManager
        Arguments and temporary variables:
                anException:    ProgressInitiationException
        Receiver's instance variables:
                interactiveParser:      nil

ProgressInitiationException>>defaultAction
        Receiver: ProgressInitiationException
        Arguments and temporary variables:

        Receiver's instance variables:
                messageText:    nil
                tag:    nil
                signaler:       a MorphicUIManager
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex to...etc...
                maxVal:         1.0
                minVal:         0.0
                aPoint:         960@589
                progressTitle:  'Downloading 
JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'

UndefinedObject>>handleSignal:
        Receiver: nil
        Arguments and temporary variables:
                exception:      ProgressInitiationException
        Receiver's instance variables:
nil

MethodContext(ContextPart)>>handleSignal:
        Receiver: BlockClosure>>on:do:
        Arguments and temporary variables:
                exception:      ProgressInitiationException
                val:    nil
        Receiver's instance variables:
                sender:         PasteUpMorph>>becomeActiveDuring:
                pc:     17
                stackp:         3
                method:         (BlockClosure>>#on:do: "a 
CompiledMethod(137625600)")
                closureOrNil:   nil
                receiver:       [aBlock value]

ProgressInitiationException(Exception)>>signal
        Receiver: ProgressInitiationException
        Arguments and temporary variables:

        Receiver's instance variables:
                messageText:    nil
                tag:    nil
                signaler:       a MorphicUIManager
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex to...etc...
                maxVal:         1.0
                minVal:         0.0
                aPoint:         960@589
                progressTitle:  'Downloading 
JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'

ProgressInitiationException>>display:at:from:to:during:
        Receiver: ProgressInitiationException
        Arguments and temporary variables:
                argString:      'Downloading 
JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'
                argPoint:       960@589
                argMinVal:      0.0
                argMaxVal:      1.0
                argWorkBlock:   [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex...etc...
        Receiver's instance variables:
                messageText:    nil
                tag:    nil
                signaler:       a MorphicUIManager
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex to...etc...
                maxVal:         1.0
                minVal:         0.0
                aPoint:         960@589
                progressTitle:  'Downloading 
JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'

ProgressInitiationException class>>display:at:from:to:during:
        Receiver: ProgressInitiationException
        Arguments and temporary variables:
                aString:        'Downloading 
JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'
                aPoint:         960@589
                minVal:         0.0
                maxVal:         1.0
                workBlock:      [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex to...etc...
        Receiver's instance variables:
                superclass:     Exception
                methodDict:     a
MethodDictionary(#defaultAction->(ProgressInitiationException>>#d...etc...
                format:         152
                instanceVariables:      #('workBlock' 'maxVal' 'minVal' 
'aPoint' 'progressTitle')
                organization:   ('*Morphic' defaultMorphicAction)
('accessing' maxVal minVal poin...etc...
                subclasses:     nil
                name:   #ProgressInitiationException
                classPool:      nil
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'UIManager-Support'
                traitComposition:       nil
                localSelectors:         nil

MorphicUIManager>>displayProgress:at:from:to:during:
        Receiver: a MorphicUIManager
        Arguments and temporary variables:
                titleString:    'Downloading 
JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'
                aPoint:         960@589
                minVal:         0.0
                maxVal:         1.0
                workBlock:      [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex to...etc...
        Receiver's instance variables:
                interactiveParser:      nil

MCHttpRepository>>displayProgress:during:
        Receiver: a MCHttpRepository(http://git.parspro.com/mc)
        Arguments and temporary variables:
                label:  'Downloading JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'
                workBlock:      [contents := HTTPSocket
                                httpGet: (self urlForFileNamed: 
aString)...etc...
                nextUpdateTime:         #(0)
        Receiver's instance variables:
                creationTemplate:       'MCHttpRepository
        location: ''http://git.parspro.com/mc''
        u...etc...
                storeDiffs:     nil
                cache:  a Dictionary()
                allFileNames:   nil
                location:       'http://git.parspro.com/mc'
                user:   'jt'
                password:       'trimixisg4u'
                readerCache:    a Dictionary()

MCHttpRepository>>readStreamForFileNamed:do:
        Receiver: a MCHttpRepository(http://git.parspro.com/mc)
        Arguments and temporary variables:
                aString:        'JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'
                aBlock:         [:s | (MCVersionReader readerClassForFileNamed: 
aString)
                ifNotNil: [:...etc...
                contents:       #(nil)
        Receiver's instance variables:
                creationTemplate:       'MCHttpRepository
        location: ''http://git.parspro.com/mc''
        u...etc...
                storeDiffs:     nil
                cache:  a Dictionary()
                allFileNames:   nil
                location:       'http://git.parspro.com/mc'
                user:   'jt'
                password:       'trimixisg4u'
                readerCache:    a Dictionary()

MCHttpRepository(MCFileBasedRepository)>>versionReaderForFileNamed:do:
        Receiver: a MCHttpRepository(http://git.parspro.com/mc)
        Arguments and temporary variables:
                aString:        'JQWidgetBox-Spinner-Core-JohnToohey.3.mcz'
                aBlock:         [:r | r
                ifNotNil: [readerCache at: aString put: r]]
        Receiver's instance variables:
                creationTemplate:       'MCHttpRepository
        location: ''http://git.parspro.com/mc''
        u...etc...
                storeDiffs:     nil
                cache:  a Dictionary()
                allFileNames:   nil
                location:       'http://git.parspro.com/mc'
                user:   'jt'
                password:       'trimixisg4u'
                readerCache:    a Dictionary()


--- The full stack ---
ZnUTF8Encoder(Object)>>error:
[| nextByte | ((nextByte := stream next) bitAnd: 192)
                        = 128
                ifTrue: [code := (code bitShift: 6)
                                                + (nextByte bitAnd: 63)]
                ifFalse: [self error: 'illegal UTF-8 encoding']] in
ZnUTF8Encoder>>nextFromStream:
ZnUTF8Encoder>>nextFromStream:
[:stringStream |
[readStream atEnd]
                whileFalse: [stringStream
                                nextPut: (encoder nextFromStream: readStream)].
        nil] in ZnStringEntity>>readLimitedFrom:
String class(SequenceableCollection class)>>new:streamContents:
String class(SequenceableCollection class)>>streamContents:
ZnStringEntity>>readLimitedFrom:
ZnStringEntity>>readFrom:
ZnEntity class>>readFrom:usingType:andLength:
ZnEntityReader>>readEntityFromStream
ZnEntityReader>>readEntity
ZnResponse(ZnMessage)>>readFrom:
ZnResponse class(ZnMessage class)>>readFrom:
ZnClient class>>execute:on:
[ZnClient execute: request on: stream] in ZnHTTPSocketFacade class>>execute:on:
BlockClosure>>ensure:
ZnHTTPSocketFacade class>>execute:on:
ZnHTTPSocketFacade class>>httpGet:args:user:passwd:
HTTPSocket class>>httpGet:args:user:passwd:
[contents := HTTPSocket
                                httpGet: (self urlForFileNamed: aString)
                                args: nil
                                user: self user
                                passwd: self password] in 
MCHttpRepository>>readStreamForFileNamed:do:
[workBlock value] in [:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex total
                                        ifNil: [true]
                                        ifNotNil: [ex amount == nil])
                                ifFalse: [(nextUpdateTime < Time 
millisecondClockValue
                                                        or: [ex total = ex 
amount])
                                                ifTrue: [bar value: ex amount 
asFloat / ex total asFloat.
                                                        nextUpdateTime := Time 
millisecondClockValue + 100]].
                        ex resume]] in MCHttpRepository>>displayProgress:during:
BlockClosure>>on:do:
[:bar | [workBlock value]
                on: HTTPProgress
                do: [:ex |
                        (ex total
                                        ifNil: [true]
                                        ifNotNil: [ex amount == nil])
                                ifFalse: [(nextUpdateTime < Time 
millisecondClockValue
                                                        or: [ex total = ex 
amount])
                                                ifTrue: [bar value: ex amount 
asFloat / ex total asFloat.
                                                        nextUpdateTime := Time 
millisecondClockValue + 100]].
                        ex resume]] in MCHttpRepository>>displayProgress:during:
[result := workBlock value: progress] in [[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex |
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
BlockClosure>>on:do:
[[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex |
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
BlockClosure>>ensure:
ProgressInitiationException>>defaultMorphicAction
MorphicUIManager>>progressInitiationExceptionDefaultAction:
ProgressInitiationException>>defaultAction
UndefinedObject>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
ProgressInitiationException(Exception)>>signal
ProgressInitiationException>>display:at:from:to:during:
ProgressInitiationException class>>display:at:from:to:during:
MorphicUIManager>>displayProgress:at:from:to:during:
MCHttpRepository>>displayProgress:during:
MCHttpRepository>>readStreamForFileNamed:do:
MCHttpRepository(MCFileBasedRepository)>>versionReaderForFileNamed:do:
 - - - - - - - - - - - - - - -
                        - - - - - - - - - - - - - - - - - -
[self resizeCache: readerCache.
        super
                versionReaderForFileNamed: aString
                do: [:r | r
                                ifNotNil: [readerCache at: aString put: r]]] in
MCHttpRepository>>versionReaderForFileNamed:
Dictionary>>at:ifAbsent:
MCHttpRepository>>versionReaderForFileNamed:
MCHttpRepository>>versionReaderForFileNamed:do:
MCHttpRepository(MCFileBasedRepository)>>loadVersionFromFileNamed:
[self loadVersionFromFileNamed: aString] in
MCHttpRepository(MCFileBasedRepository)>>versionFromFileNamed:
Dictionary>>at:ifAbsent:
MCHttpRepository(MCFileBasedRepository)>>versionFromFileNamed:
[version := repository versionFromFileNamed: selectedVersion] in
MCFileRepositoryInspector>>version
BlockClosure>>ensure:
CursorWithMask(Cursor)>>showWhile:
MCFileRepositoryInspector>>version
MCFileRepositoryInspector(MCVersionInspector)>>versionSummary
MCFileRepositoryInspector(MCVersionInspector)>>summary
PluggableTextMorph>>getText
PluggableTextMorph>>update:
[:aDependent | aDependent update: aParameter] in
MCFileRepositoryInspector(Object)>>changed:
DependentsArray>>do:
MCFileRepositoryInspector(Object)>>changed:
MCFileRepositoryInspector>>versionSelection:
PluggableListMorph>>changeModelSelection:
PluggableListMorph>>mouseUpOnSingle:
PluggableListMorph>>mouseUp:
PluggableListMorph(Morph)>>handleMouseUp:
MouseButtonEvent>>sentTo:
PluggableListMorph(Morph)>>handleEvent:
MorphicEventDispatcher>>dispatchDefault:with:
MorphicEventDispatcher>>dispatchEvent:with:
PluggableListMorph(Morph)>>processEvent:using:
PluggableListMorph(Morph)>>processEvent:
PluggableListMorph>>handleFocusEvent:
[ActiveHand := self.
        ActiveEvent := anEvent.
        result := focusHolder
                                handleFocusEvent: (anEvent
                                                transformedBy: (focusHolder 
transformedFrom: self))] in
HandMorph>>sendFocusEvent:to:clear:
[aBlock value] in PasteUpMorph>>becomeActiveDuring:
BlockClosure>>on:do:
PasteUpMorph>>becomeActiveDuring:
HandMorph>>sendFocusEvent:to:clear:
HandMorph>>sendEvent:focus:clear:
HandMorph>>sendMouseEvent:
HandMorph>>handleEvent:
HandMorph>>processEvents
[:h |
ActiveHand := h.
        h processEvents.
        ActiveHand := nil] in WorldState>>doOneCycleNowFor:
Array(SequenceableCollection)>>do:
WorldState>>handsDo:
WorldState>>doOneCycleNowFor:
WorldState>>doOneCycleFor:
PasteUpMorph>>doOneCycle
[[World doOneCycle.
        Processor yield.
        false] whileFalse.
        nil] in Project class>>spawnNewProcess
[self value.
        Processor terminateActive] in BlockClosure>>newProcess




On Thu, Sep 8, 2011 at 10:24, Marcus Denker <[email protected]> wrote:
>
> On Sep 8, 2011, at 4:19 PM, John Toohey wrote:
>
>> Many thanks. Unfortunately this version throws errors when I try to
>> load my code from MC. "Error: Illegal UTF-8 encoding" from MC when I
>> try to build my image. Can you tell me what is the *most* stable
>> version that I can use with Cog and SS 3.x?
>>
>
> This one. I have never seen that error. So.. a case for the bug tracker.
>
>        http://code.google.com/p/pharo/issues
>
>> On Thu, Sep 8, 2011 at 10:05, Marcus Denker <[email protected]> wrote:
>>>
>>> On Sep 8, 2011, at 3:59 PM, John Toohey wrote:
>>>
>>>> Hi,
>>>> Is there a 1.3 OneClick build available with the Cog VM, or should I
>>>> just down load the linux and OSX Cog builds from the Jenkins server?
>>>
>>> The script on the hudson is old... we need to update it. And move everything
>>> from hudson to jenkins. And, and...
>>>
>>> So for now:
>>>
>>>        https://gforge.inria.fr/frs/download.php/28922/Pharo-1.3-OneClick.zip
>>>
>>> hand-build one-click with Cog as build from 
>>> https://ci.lille.inria.fr/pharo/view/Cog/
>>>
>>>> often run into problems with having different VMs/Plugin on different
>>>> servers, and like the idea of having both Liux and OSX supported in
>>>> one package, where I can just update the image.
>>>
>>>
>>>
>>>
>>>
>>> --
>>> Marcus Denker -- http://marcusdenker.de
>>>
>>>
>>>
>>
>>
>>
>> --
>> ~JT
>>
>
> --
> Marcus Denker -- http://marcusdenker.de
>
>
>



-- 
~JT

Reply via email to