'$Revision:$'
 '
Copyright 1992-2002 Sun Microsystems, Inc. and Stanford University.
See the LICENSE file for license information.
'


 '-- Module body'

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'modules' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         oliver = bootstrap define: bootstrap stub -> 'globals' -> 'modules' -> 'oliver' -> () ToBe: bootstrap addSlotsTo: (
             bootstrap remove: 'directory' From:
             bootstrap remove: 'fileInTimeString' From:
             bootstrap remove: 'myComment' From:
             bootstrap remove: 'postFileIn' From:
             bootstrap remove: 'revision' From:
             bootstrap remove: 'subpartNames' From:
             globals modules init copy ) From: bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'modules' -> 'oliver' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals modules oliver.

CopyDowns:
globals modules init. copy 
SlotsToOmit: directory fileInTimeString myComment postFileIn revision subpartNames.

\x7fIsComplete: '.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'modules' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         directory <- 'applications'.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'modules' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (_CurrentTimeString)\x7fVisibility: public'
        
         fileInTimeString <- _CurrentTimeString.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'modules' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         myComment <- ''.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'modules' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         postFileIn = ( |
            | resend.postFileIn).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'modules' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         revision <- '$Revision:$'.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'modules' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: private'
        
         subpartNames <- ''.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> () From: ( | {
         'Category: applications\x7fModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         oliver = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         boot = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'boot' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver boot.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'boot' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         at: addr Put: byte For: count = ( |
             word.
            | 
            word: (byte <<8) || byte.
            addr to: (addr+(count/2))-1 Do: [ |:a| memory at: a Put: word ].
            (addr+(count/2))).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'boot' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         namespace* = bootstrap stub -> 'globals' -> 'oliver' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'boot' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         noSIC = ( |
             vector = ((bootstrap stub -> 'globals') \/-> 'vector') -> ().
            | 
            _Compilers: (vector copySize: 1 FillingWith: 'nic')
            Limits: vector copy).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'boot' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         reset = ( |
            | 
            video turnOff.
            memory reset.
            cpu reset).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'boot' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         setVGA720x480 = ( |
             activeH = 720.
             activeV = 480.
             addr.
             backH = 54.
             backV = 33.
             frontH = 26.
             frontV = 10.
             gray = paint named: 'gray'.
             pitch = 908.
             syncH = 108.
             syncV = 2.
            | 
            video turnOff.
            video mode: video vgaMode.
            addr: video start.

            activeV do: [
              addr: at: addr Put: (video mode encode: gray) For: activeH.
              addr: at: addr Put: 0 For: frontH.
              addr: at: addr Put: (video mode hsync) For: syncH.
              addr: at: addr Put: 0 For: backH.
            ].

            frontV do: [
              addr: at: addr Put: 0 For: activeH+frontH.
              addr: at: addr Put: (video mode hsync) For: syncH.
              addr: at: addr Put: 0 For: backH.
            ].

            syncV do: [
              addr: at: addr Put: (video mode vsync) For: activeH+frontH.
              addr: at: addr Put: ((video mode hsync) || (video mode vsync)) For: syncH.
              addr: at: addr Put: (video mode vsync) For: backH.
            ].

            backV do: [
              addr: at: addr Put: 0 For: activeH+frontH.
              addr: at: addr Put: (video mode hsync) For: syncH.
              addr: at: addr Put: 0 For: backH.
            ].

            addr: at: addr Put: (video mode end) For: 2.

            video turnOn).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         cpu = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver cpu.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         ao <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         ax <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         cycles <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         fa <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         fb <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: caches\x7fModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         fcache = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> 'fcache' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver cpu fcache.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         fo <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         fp <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         go <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         ir <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         ix <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: caches\x7fModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         mcache = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> 'mcache' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver cpu mcache.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         namespace* = bootstrap stub -> 'globals' -> 'oliver' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         pc <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: caches\x7fModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         rcache = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> 'rcache' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver cpu rcache.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         reset = ( |
            | 
            cycles: 0.
            "clear all registers"
            ao: 0. ax: 0. fa: 0. fb: 0.
            fo: 0. fp: 0. go: 0. ir: 0.
            ix: 0. pc: 0. ro: 0. rp: 0.
            sf: 0. so: 0. sp: 0. t: 0.
            self).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         ro <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         rp <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: caches\x7fModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         scache = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> 'scache' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver cpu scache.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         sf <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         so <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         sp <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'cpu' -> () From: ( | {
         'Category: registers\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         t <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         memory = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver memory.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         at: addr = ( |
             offset.
             page.
             pageNum.
            | 
            pageNum: addr / pageSize.
            offset: addr % pageSize.
            page: pages at: pageNum IfAbsent: [ ^ error: 'invalid range' ].
            checkWritten ifTrue: [
               page isOrdered ifFalse: [ ^ error: 'page never written' ].
               (page at: offset) == untouched ifTrue: [ ^ error: 'word never written' ].
               ^ page at: offset
            ].
            page isOrdered ifFalse: [ ^ untouched ].
            ^ page at: offset).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         at: addr Put: word = ( |
             offset.
             page.
             pageNum.
             v = ((bootstrap stub -> 'globals') \/-> 'vector') -> ().
            | 
            pageNum: addr / pageSize.
            offset: addr % pageSize.
            page: pages at: pageNum IfAbsent: [ ^ error: 'invalid range' ].
            (word < 0) || [word > maxWord] ifTrue: [ ^ error: 'invalid word' ].
            page isOrdered ifFalse: [
              page: v copySize: pageSize FillingWith: untouched.
              pages at: pageNum Put: page.
            ].
            page at: offset Put: word.
            video memAt: addr ChangedTo: word.
            self).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (true)'
        
         checkWritten <- bootstrap stub -> 'globals' -> 'true' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         emptyPage = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> 'emptyPage' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver memory emptyPage.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> 'emptyPage' -> () From: ( | {
         'Comment: this is the opposite of a vector\x7fModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         isOrdered = bootstrap stub -> 'globals' -> 'false' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         loadFrom: fileName = ( |
             addr.
             chk.
             dataSize.
             f <- bootstrap stub -> 'globals' -> 'unixGlobals' -> 'os_file' -> ().
             false = bootstrap stub -> 'globals' -> 'false' -> ().
             line.
             recType.
             ulba.
             word.
            | 
            f: f os_file openForReading: fileName.
            addr: 0.
            ulba: 0.
            [ line: f readLine.
              f atEOF || [line = ':00000001FF']
            ] whileFalse: [
                (line at: 0) = ':' ifFalse: [ ^ error: 'missing :' ].
                dataSize: ((line at: 1),(line at: 2)) hexAsInteger.
                addr: ((line at: 3),(line at: 4),(line at: 5),(line at: 6)) hexAsInteger.
                recType: ((line at: 7),(line at: 8)) hexAsInteger.
                chk: dataSize + recType + (addr>>8) + (addr&&16r0FF).
                recType = 0 ifTrue: [
                         0 to: (dataSize/2)-1 Do: [ |:offset|
                             word: ((line at: 9+(4*offset)),
                                    (line at: 10+(4*offset)),
                                    (line at: 11+(4*offset)),
                                    (line at: 12+(4*offset))) hexAsInteger.
                             chk: chk + (word>>8) + (word&&16r0FF).
                             at: ((((ulba<<16)+addr)/2)+offset) Put: word.
                         ].
                         chk: (chk + (((line at: 9+(2*dataSize)),(line at: 10+(2*dataSize))) hexAsInteger)) && 16r0FF.
                         chk = 0 ifFalse: [ ^ error: 'checksum error' ].
                ] False: [ recType = 4 ifTrue: [
                         dataSize = 2 ifFalse: [ ^ error: 'wrong record size' ].
                         ulba: ((line at: 9),(line at: 10),(line at: 11),(line at: 12)) hexAsInteger.
                         chk: chk + (ulba>>8) + (ulba&&16r0FF).
                         chk: (chk + (((line at: 13),(line at: 14)) hexAsInteger)) && 16r0FF.
                         chk = 0 ifFalse: [ ^ error: 'checksum error' ].
                         ] False: [ ^ error: 'unimplemented record type' ].
                ]
            ].
            f close.
            self).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         maxWord = 65535.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         memSize = 4194304.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         namespace* = bootstrap stub -> 'globals' -> 'oliver' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         pageSize = 1024.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (vector copySize: oliver memory memSize / oliver memory pageSize FillingWith: oliver memory emptyPage)'
        
         pages = vector copySize: oliver memory memSize / oliver memory pageSize FillingWith: oliver memory emptyPage.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         reset = ( |
            | 
            0 to: pages size - 1 Do: [ |:i| pages at: i Put: emptyPage]).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         saveOn: fileName = ( |
             addr.
             check.
             chk.
             f <- bootstrap stub -> 'globals' -> 'unixGlobals' -> 'os_file' -> ().
             false = bootstrap stub -> 'globals' -> 'false' -> ().
             ulba.
             word.
            | 
            check: checkWritten.
            checkWritten: false.
            f: f os_file openForWriting: fileName.
            0 to: pages size - 1 Do: [ |:pn|
              (pages at: pn) isOrdered ifTrue: [
                addr: pn*pageSize.
                ulba: (addr*2)>>16.
                f write: ':02000004'.
                f write: (ulba printStringBase: 16 PadWith: '0' ToSize: 4).
                chk: (6 + (ulba>>8) + (ulba&&16r0FF)) negate && 16r0FF.
                f writeLine: (chk printStringBase: 16 PadWith: '0' ToSize: 2).
                0 to: (pageSize/8)-1 Do: [ |:offset|
                  f write: ':10'.
                  word: (addr*2) && 16r0FFFF.
                  f write: (word printStringBase: 16 PadWith: '0' ToSize: 4).
                  chk: 16r10 + (word>>8) + (word&&16r0FF).
                  f write: '00'.
                  [word: (at: addr) && 16r0FFFF. "never written becomes FFFF"
                   addr: addr+1.
                   f write: (word printStringBase: 16 PadWith: '0' ToSize: 4).
                   chk: chk + (word>>8) + (word&&16r0FF).
                   (addr%8) = 0 ] whileFalse.
                  chk: chk negate && 16r0FF.
                  f writeLine: (chk printStringBase: 16 PadWith: '0' ToSize: 2).
                ].
              ]
            ].
            f writeLine: ':00000001FF'.
            f close.
            checkWritten: check.
            self).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'memory' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         untouched = -1.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         video = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver video.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         image = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver video image.
\x7fIsComplete: '.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         baseDrawOn: canvas = ( |
            | 
            oliver video isOn ifTrue: [ canvas pastePixmap: bits At: position ]
              False: [ canvas fillRectangle: baseBounds Color: paint ].
            self).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (bitmap)'
        
         bits <- bootstrap stub -> 'globals' -> 'bitmap' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         byte: byte Mode: mode X: x Y: y = ( |
            | 
            (mode isHSync: byte) || [mode isVSync: byte]
              ifTrue: [bits point: x@y Color: (paint named: 'red'). ^ self].
            (mode isBurst: byte)
              ifTrue: [bits point: x@y Color: (paint named: 'yellow'). ^ self].
            bits point: x@y Color: (mode colorFrom: byte).
            self).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (nil)\x7fVisibility: private'
        
         cachedMinHeight.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (nil)\x7fVisibility: private'
        
         cachedMinWidth.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fComment: The hResizing slot indicates the horizontal resizing style of
this morph, one of {rigid(0), flexible(1), shrinkWrap(2)}.
\x7fModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         hResizing <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fComment: The layoutOkay flag indicates that this morph\'s current layout
is correct; it is used to avoid unnecessary layout computations.
\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (false)\x7fVisibility: private'
        
         layoutOkay <- bootstrap stub -> 'globals' -> 'false' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fComment: This private flag is used for an important optimization.
If true, then none of this morph\'s submorphs has a
bounds that sticks out beyound this morph\'s baseBounds.
This saves recomputing the bounds for most morphs.
\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (false)\x7fVisibility: private'
        
         noStickOuts <- bootstrap stub -> 'globals' -> 'false' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         parent* = bootstrap stub -> 'traits' -> 'morph' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: filing out\x7fModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         prototype = ( |
            | morph).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fComment: This slot provides a default geometry for a morph:
a simple rectangular area. Descendants such as
circleMorphs may replace this slot with their own
representation slots such as \"center\" and \"radius\".
\x7fModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: private'
        
         rawBox <- ((127)@(328)) # ((1035)@(853)).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: private'
        
         rawColor <- paint named: 'khaki'.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (vector)\x7fVisibility: private'
        
         rawMorphs <- ((bootstrap stub -> 'globals') \/-> 'vector') -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (nil)\x7fVisibility: private'
        
         rawOwner <- bootstrap stub -> 'globals' -> 'nil' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         setWidth: w Height: h = ( |
             win.
            | 
            changed. "invalidate old size"
            win: owner winCanvases first.
            bits: pixmapCanvas copyForSameScreenAs: win Width: w Height: h.
            bits fillColor: (paint named: 'red').
            rawBox: rawBox from: rawBox origin To: rawBox origin + (w@h).
            changed. "redraw in new size").
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fComment: The vResizing slot indicates the vertical resizing style of
this morph, one of {rigid(0), flexible(1), shrinkWrap(2)}.
\x7fModuleInfo: Module: oliver InitialContents: FollowSlot\x7fVisibility: public'
        
         vResizing <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'image' -> () From: ( | {
         'Category: Basic Morph State\x7fComment: The velcroFlag indicates that all the submorphs of the reciever
are attached to the receiver as if by Velcro(tm). Futhermore, the
receiver is not open to having new morphs added to it via dropping.
This flag defaults to true.
\x7fModuleInfo: Module: oliver InitialContents: InitializeToExpression: (true)\x7fVisibility: public'
        
         velcroFlag <- bootstrap stub -> 'globals' -> 'true' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         isOn = ( |
            | stop > start).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         memAt: addr ChangedTo: word = ( |
             high.
             low.
             x.
             y.
            | 
            isOn ifFalse: [^ self].
            addr < start ifTrue: [^ self].
            addr > stop ifTrue: [^ self].
            y: (addr-start)/pitch.
            x: (addr-start)%pitch.
            high: word >> 8.
            low: word && 16r0FF.
            image byte: high Mode: mode X: x*2 Y: y.
            image byte: low Mode: mode X: (x*2)+1 Y: y.
            image changed.
            self).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         vgaMode = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( |
             {} = 'Comment: In the VGA mode a byte is interpreted as 00RRGGBB.
Bytes in the form 1000CCCC implement commands\x7fModuleInfo: Creator: globals oliver video vgaMode.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (oliver video vgaMode)'
        
         mode <- bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         namespace* = bootstrap stub -> 'globals' -> 'oliver' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         pitch <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         start = 3670016.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (0)'
        
         stop <- 0.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         testBytes: word With: block = ( |
            | 
            (block value: (word>>8)) || [block value: (word && 16r0FF)]).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         turnOff = ( |
            | stop: start-1).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         turnOn = ( |
             addr.
             height.
             lastHSync <- 0.
             wasSync <- bootstrap stub -> 'globals' -> 'false' -> ().
            | 
            addr: start.
            mode cacheColors.
            [ (addr >= memory memSize) ||
              [ addr: addr+1.
                testBytes: (memory at: addr) With: [|:b| mode isEnd: b] ]
            ] whileFalse.
            addr >= memory memSize ifTrue: [ ^ error: 'missing end instruction' ].
            stop: addr.
            start to: stop-1 Do: [ |:a. snc|
              snc: (testBytes: (memory at: a) With: [|:b| mode isHSync: b]).
              snc && [ wasSync not] ifTrue: [
                 lastHSync = 0 ifFalse: [
                        pitch = 0 ifTrue: [pitch: a-lastHSync].
                        pitch = (a-lastHSync) ifFalse: [^ error: 'bad hsync!']
                 ].
                 lastHSync: a.
               ].
               wasSync: snc.
            ].
            addr: start.
            height: (stop - start) / pitch.
            image setWidth: pitch*2 Height: height.
            0 to: height-1 Do: [ |:y|
              0 to: pitch-1 Do: [ |:x. high. low|
                low: memory at: addr.
                addr: addr+1.
                high: low >> 8.
                low: low && 16r0FF.
                image byte: high Mode: mode X: x*2 Y: y.
                image byte: low Mode: mode X: (x*2)+1 Y: y.
              ].
            ]).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         tvMode = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( |
             {} = 'Comment: In the TV mode a byte is interpreted as VVSSHHHH.
When Value is 0 and Saturation is 0, then the
Hue indicates a command unless it is also 0 (in
which case it indicates black)\x7fModuleInfo: Creator: globals oliver video tvMode.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         cacheColors = ( |
             b.
             h.
             p = bootstrap stub -> 'globals' -> 'paint' -> ().
             s.
             v = ((bootstrap stub -> 'globals') \/-> 'vector') -> ().
            | 
            colors: v copySize: 256 FillingWith: p.
            16 to: 255 Do: [ |:byte|
              b: (byte && 16rC0) /= 16rC0.
              s: (byte && 16r30) /= 16r30.
              h: ((byte && 16r0F) * 360) / 15.
              colors at: byte Put: (p copyHue: h Saturation: s Brightness: b)
            ].
            self).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         colorBurst = 4.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (vector copySize: 256 FillingWith: paint)'
        
         colors <- vector copySize: 256 FillingWith: paint.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         encode: color = ( |
             h.
             s.
             v.
            | 
            h: ((color hue /= 361) * 16) floor asInteger.
            s: (color saturation * 3.99) floor asInteger.
            v: (color brightness * 3.99) floor asInteger.
            (s = 0) && [v = 0] ifTrue: [h: 0]. "to not confuse with command"
            (v<<6) || (s<<4) || h).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         end = 8.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         hsync = 1.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         isValidColor: byte = ( |
             f = bootstrap stub -> 'globals' -> 'false' -> ().
             t = bootstrap stub -> 'globals' -> 'true' -> ().
            | 
            byte > 255 ifTrue: [ ^ f ].
            byte = 0 ifTrue: [ ^ t ].
            (16rF0 && byte) != 0).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         parent* = bootstrap setObjectAnnotationOf: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> 'parent' -> () From: ( |
             {} = 'ModuleInfo: Creator: globals oliver video tvMode parent.
'.
            | ) .
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> 'parent' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         colorFrom: byte = ( |
            | 
            (isValidColor: byte) ifFalse: [ ^ error: 'bad color'].
            colors at: byte).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> 'parent' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         isBurst: byte = ( |
            | colorBurst = byte).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> 'parent' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         isEnd: byte = ( |
            | 
            end = byte).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> 'parent' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         isHSync: byte = ( |
            | 
            (16rFD && byte) = hsync).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> 'parent' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         isVSync: byte = ( |
            | 
            (16rFE && byte) = vsync).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         vsync = 2.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         cacheColors = ( |
             b.
             g.
             p = bootstrap stub -> 'globals' -> 'paint' -> ().
             r.
             v = ((bootstrap stub -> 'globals') \/-> 'vector') -> ().
            | 
            colors: v copySize: 64 FillingWith: p.
            0 to: 63 Do: [ |:byte|
              r: (byte && 16r30) /= 16r30.
              g: (byte && 16r0C) /= 16r0C.
              b: (byte && 16r03) /= 3.
              colors at: byte Put: (p copyRed: r Green: g Blue: b)
            ].
            self).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         colorBurst = -1.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: InitializeToExpression: (vector copySize: 64 FillingWith: paint)'
        
         colors <- vector copySize: 64 FillingWith: paint.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         encode: color = ( |
             b.
             g.
             r.
            | 
            r: (color red * 3.99) floor asInteger.
            g: (color green * 3.99) floor asInteger.
            b: (color blue * 3.99) floor asInteger.
            (r<<4) || (g<<2) || b).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         end = 136.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         hsync = 129.
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         isValidColor: byte = ( |
            | 
            (16r3F && byte) = byte).
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         parent* = bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'tvMode' -> 'parent' -> ().
        } | ) 

 bootstrap addSlotsTo: bootstrap stub -> 'globals' -> 'oliver' -> 'video' -> 'vgaMode' -> () From: ( | {
         'ModuleInfo: Module: oliver InitialContents: FollowSlot'
        
         vsync = 130.
        } | ) 



 '-- Side effects'

 globals modules oliver postFileIn