DIRECTORY Imager, IP; IPOperatorImpl: CEDAR PROGRAM IMPORTS Imager, IP EXPORTS IP ~ BEGIN OPEN IP; NewMarker: PROC[self: State] RETURNS[Marker] ~ { last: Marker ~ self.lastMarker; IF last self.context _ caller]; self.context _ caller; }; Frame: PUBLIC PROC[self: State] RETURNS[Vector] ~ { context: Context ~ self.context; IF context.frame=NIL THEN RETURN[context.initialFrame] ELSE RETURN[VectorFromArray[ACopy[context.frame]]]; }; FGet: PUBLIC PROC[self: State, j: Integer] RETURNS[Any] ~ { context: Context ~ self.context; IF context.frame=NIL THEN RETURN[Get[context.initialFrame, j]] ELSE RETURN[AGet[context.frame, j]] }; FSet: PUBLIC PROC[self: State, x: Any, j: Integer] ~ { context: Context ~ self.context; IF context.frame=NIL THEN context.frame _ ArrayFromVector[context.initialFrame]; ASet[context.frame, x, j]; }; PoolOp: PUBLIC PROC[self: State] RETURNS[Pool] ~ { RETURN[self.context.pool] }; PGet: PUBLIC PROC[self: State, j: Integer] RETURNS[Any] ~ { pool: Pool ~ self.context.pool; RETURN[AGet[pool.array, j]]; }; PSet: PUBLIC PROC[self: State, x: Any, j: Integer] ~ { pool: Pool ~ self.context.pool; -- SavePool[self, pool, ...]; -- ASet[pool.array, x, j]; }; Env: PUBLIC PROC[self: State] RETURNS[Vector] ~ { RETURN[self.context.env]; }; MakePool: PUBLIC PROC[v: Vector, persistent: BOOL] RETURNS[Pool] ~ { RETURN[NEW[PoolRep _ [persistent: persistent, array: ArrayFromVector[v]]]]; }; noPool: Pool ~ MakePool[v: NullVector[shape: [l: 0, n: 0]], persistent: FALSE]; NoPool: PUBLIC PROC RETURNS[Pool] ~ { RETURN[noPool] }; PoolValue: PUBLIC PROC[pool: Pool] RETURNS[Vector] ~ { RETURN[VectorFromArray[pool.array]]; }; poolClass: OperatorClass ~ NEW[OperatorClassRep _ [type: $Pool, apply: PoolApply]]; PoolApply: PROC[op: Operator, state: State] ~ { PushVector[state, PoolValue[op.pool]]; }; OperatorFromPool: PUBLIC PROC[pool: Pool] RETURNS[Operator] ~ { RETURN[NEW[OperatorRep _ [class: poolClass, data: NIL, pool: pool]]]; }; PoolFromOperator: PUBLIC PROC[op: Operator] RETURNS[Pool] ~ { IF op.pool#NIL THEN RETURN[op.pool] ELSE { MasterError[$wrongType, "Operator is not a Pool."]; ERROR Error; }; }; DoWithSaveEffect: PUBLIC PROC[self: State, action: PROC, saveEffect: SaveEffect] ~ { IF saveEffect=$nil THEN action[] ELSE { showVec: Vector ~ self.showVec; mediumSize: VEC ~ self.mediumSize; fieldMin: VEC ~ self.fieldMin; fieldMax: VEC ~ self.fieldMax; Restore: PROC ~ { self.showVec _ showVec; self.mediumSize _ mediumSize; self.fieldMin _ fieldMin; self.fieldMax _ fieldMax; }; SELECT saveEffect FROM $nil => action[]; $save => { self.imager.DoSave[action ! UNWIND => Restore[]]; Restore[] }; $saveAll => { self.imager.DoSaveAll[action ! UNWIND => Restore[]]; Restore[] }; ENDCASE => ERROR; }; }; coClass: OperatorClass ~ NEW[OperatorClassRep _ [type: $CO, apply: COApply]]; COData: TYPE ~ REF CODataRep; CODataRep: TYPE ~ RECORD[ frame: Vector, -- initial frame pool: Pool, -- shared pool env: Vector, -- environment body: Index -- starting index of body ]; COApply: PROC[op: Operator, state: State] ~ { data: COData ~ NARROW[op.data]; body: PROC ~ { ExecuteBody[state, data.body] }; Call[self: state, action: body, frame: data.frame, pool: data.pool, env: data.env]; }; MakeCO: PUBLIC PROC[self: State, pool: Pool, f: Vector] RETURNS[Operator] ~ { body: Index ~ ReadNextBody[self]; data: COData ~ NEW[CODataRep _ [frame: f, pool: pool, env: Env[self], body: body]]; RETURN[NEW[OperatorRep _ [class: coClass, data: data]]]; }; MakeSimpleCO: PUBLIC PROC[self: State] RETURNS[Operator] ~ { RETURN[MakeCO[self: self, pool: noPool, f: Frame[self]]]; }; compiledImageClass: OperatorClass ~ NEW[OperatorClassRep _ [ type: $CompiledImage, apply: CompiledImageApply]]; CompiledImageData: TYPE ~ REF CompiledImageDataRep; CompiledImageDataRep: TYPE ~ RECORD[f: Vector, env: Vector, body: Index]; CompiledImageApply: PROC[op: Operator, state: State] ~ { data: CompiledImageData ~ NARROW[op.data]; body: PROC ~ { ExecuteBody[state, data.body] }; Call[self: state, action: body, frame: data.f, pool: NoPool[], env: data.env]; }; MakeCompiledImage: PUBLIC PROC[self: State, f: Vector] RETURNS[Operator] ~ { body: Index ~ ReadNextBody[self]; data: CompiledImageData ~ NEW[CompiledImageDataRep _ [f: f, env: Env[self], body: body]]; RETURN[NEW[OperatorRep _ [class: compiledImageClass, data: data]]]; }; Do: PUBLIC PROC[self: State, o: Operator, saveEffect: SaveEffect _ $nil] ~ { action: PROC ~ { o.class.apply[o, self] }; DoWithSaveEffect[self, action, saveEffect]; }; DoBody: PUBLIC PROC[self: State, pool: Pool, f: Vector, saveEffect: SaveEffect _ $nil] ~ { nextBody: PROC ~ { ExecuteNextBody[self] }; action: PROC ~ { Call[self: self, action: nextBody, frame: f, pool: pool, env: Env[self]] }; DoWithSaveEffect[self, action, saveEffect]; }; DoSimpleBody: PUBLIC PROC[self: State, saveEffect: SaveEffect _ $nil] ~ { DoBody[self, noPool, Frame[self], saveEffect]; }; END. ÆIPOperatorImpl.mesa Copyright c 1984 Xerox Corporation. All rights reserved. Doug Wyatt, August 20, 1984 1:20:50 pm PDT Eventually, this should worry about pools other than the Imager pool Ê„˜šœ™Jšœ Ïmœ.™9Jšœ*™*—J™šÏk ˜ J˜Jšžœ˜J˜—Jšœžœž˜Jšžœ ž˜Jšžœž˜ Jšœžœžœžœ˜J˜šÏn œžœžœ˜0Jšœ˜Jšžœ žœžœžœ˜9Jšžœžœ"˜,J˜J˜—šŸœžœžœžœ-˜XJšœ˜Jšœ"Ïc˜;šœžœ ˜=Jšœ˜Jšœžœ+˜5Jšœ˜—J˜Jšœ žœ˜*Jšœ˜J˜J˜—J˜šŸœžœžœžœ˜3J˜ Jšžœžœžœžœ˜6Jšžœžœ(˜3J˜J˜—šŸœžœžœžœ ˜;J˜ Jšžœžœžœžœ˜>Jšžœžœ˜#J˜J˜—šŸœžœžœ%˜6J˜ Jšžœžœžœ7˜PJšœ˜J˜J˜—J˜š Ÿœžœžœžœžœ˜OJ˜—šŸœžœžœžœ ˜;J˜Jšžœ˜J˜J˜—šŸœžœžœ%˜6J˜Jš ˜ Jšœ˜J˜J˜—J˜šŸœžœžœžœ˜1Jšžœ˜Jšœ˜J˜—J˜š Ÿœžœžœžœžœ ˜DJšžœžœA˜KJ˜J˜—JšœHžœ˜OJ˜Jš Ÿœžœžœžœžœ˜7J˜šŸ œžœžœ žœ˜6Jšžœ˜$J˜J˜—Jšœžœ5˜SJ˜šŸ œžœ ˜/Jšœ&˜&J˜J˜—šŸœžœžœ žœ˜?Jšžœžœ(žœ˜EJ˜J˜—šŸœžœžœžœ ˜=Jšžœ žœžœžœ ˜#šžœ˜Jšœ3˜3Jšžœ˜J˜—J˜J˜—J˜šŸœžœžœžœ˜TJšœD™DJšžœžœ ˜ šžœ˜Jšœ˜Jšœžœ˜"Jšœ žœ˜Jšœ žœ˜šŸœžœ˜Jšœ˜Jšœ˜Jšœ˜Jšœ˜J˜—šžœž˜Jšœ˜Jšœ'žœ˜IJšœ-žœ˜OJšžœžœ˜—J˜—J˜J˜—J˜Jšœžœ1˜MJšœžœžœ˜šœžœžœ˜Jšœ ˜Jšœ ˜Jšœ ˜Jšœ ˜%J˜—J˜šŸœžœ ˜-Jšœžœ ˜Jšœžœ%˜/JšœS˜SJ˜J˜—šŸœžœžœ%žœ˜MJ˜!JšœžœA˜SJšžœžœ.˜8J˜—J˜šŸœžœžœžœ˜