DIRECTORY AMBridge USING [ TVToProc ], AMEvents USING [ CallDebugger ], AMTypes USING [ Error, TV ], Atom USING [ PutProp, GetPName, GetProp, PropList ], BasicTime USING [ GMT, Now, Unpack, Unpacked ], Commander USING [ CommandProc, GetProperty, Handle, Register ], FS USING [ StreamOpen, Error ], Interpreter USING [ Evaluate ], IO, Log, PrincOps USING [ BytePC, FrameHandle, GFTIndex ], PrincOpsUtils USING [ LongCOPY, GetReturnFrame ], ProcessProps USING [ GetPropList ], RefTab USING [ Create, Fetch, Ref, Store ], Rope USING [ Flatten, InlineLength, ROPE, Text ], SpyTypes USING [ DoWriteDataProc, IsActiveProc, WriteTraceProc ] ; LogImpl: CEDAR MONITOR -- for CLog IMPORTS AMBridge, AMEvents, AMTypes, Atom, BasicTime, Commander, FS, Interpreter, IO, PrincOpsUtils, ProcessProps, RefTab, Rope EXPORTS Log = { OPEN IO, SpyTypes; pd: PUBLIC REF Log.PD _ NEW[Log.PD_[]]; ROPE: TYPE = Rope.ROPE; STREAM: TYPE = IO.STREAM; ThHandle: TYPE = LONG CARDINAL; WhereToReport: TYPE = Log.WhereToReport; WhereProc: TYPE = Log.WhereProc; WP: TYPE = REF WPRec; WPRec: TYPE = RECORD [ proc: WhereProc, fixedWhereData: REF, defaultIfNotFound: Log.DNFProc_NIL ]; RegisterWhereToReport: PUBLIC PROC[ proc: WhereProc, where: WhereToReport, fixedWhereData: REF, defaultIfNotFound: Log.DNFProc] = { Atom.PutProp[$ReportStreams, where, NEW[WPRec_[proc: proc, fixedWhereData: fixedWhereData, defaultIfNotFound: defaultIfNotFound]]]; }; FindWhere: PUBLIC PROC[where: WhereToReport, whereData: REF] RETURNS [s: IO.STREAM] = { wp: WP; IF where=NIL THEN RETURN[pd.sysOut]; wp _ NARROW[Atom.GetProp[$ReportStreams, where]]; IF wp=NIL THEN RETURN[pd.sysOut]; s_wp.proc[wp.fixedWhereData, whereData]; IF s#NIL THEN RETURN[s]; RETURN[IF s#NIL THEN s ELSE IF wp.defaultIfNotFound=NIL OR wp.defaultIfNotFound[where, whereData] THEN pd.sysOut ELSE NIL]; }; Report: PUBLIC PROC[remark: ROPE, where: WhereToReport, whereData: REF _NIL] = { reportS: STREAM _ FindWhere[where, whereData]; seconds: INT; IF remark=NIL OR reportS = NIL THEN RETURN; seconds _ LogTime[reportS, where]; reportS.PutF[" %02d: %s\n", int[seconds], rope[remark]]; -- wish I could affort looking up caller. }; ReportFR: PUBLIC PROC[remark: ROPE, where: WhereToReport, whereData: REF, a1, a2: IO.Value] = { Report[IO.PutFR[remark, a1, a2], where, whereData]; }; Problem: PUBLIC PROC[ remark: ROPE, where: WhereToReport, whereData: REF] = TRUSTED { IF remark=NIL THEN remark_"Unspecified problem"; Report[remark, where, whereData]; IF pd.attended THEN AMEvents.CallDebugger[remark]; }; ProblemFR: PUBLIC PROC[ remark: ROPE, where: WhereToReport, whereData: REF, a1, a2: IO.Value] = TRUSTED { Problem[IO.PutFR[remark, a1, a2], where, whereData]; }; ProblemBool: PUBLIC PROC[ remark: ROPE, where: WhereToReport, bool: BOOL, whereData: REF] RETURNS[sameBool: BOOL] = { sameBool_bool; Problem[remark, where, whereData]; }; ProblemHandle: PUBLIC PROC[ remark: ROPE, where: WhereToReport, handle: ThHandle, whereData: REF] RETURNS[sameHandle: ThHandle] = { sameHandle_handle; Problem[remark, where, whereData]; }; CmdWhere: WhereProc = { pl: Atom.PropList _ ProcessProps.GetPropList[]; ch: Commander.Handle; IF pl=NIL THEN RETURN[NIL]; ch _ NARROW[Commander.GetProperty[$CommanderHandle, pl]]; IF ch=NIL THEN RETURN[NIL]; RETURN[ch.err]; }; SetAttended: Commander.CommandProc = { pd.attended _ TRUE; Report["Attended[TRUE]", $Cmd, NIL]; }; ClearAttended: Commander.CommandProc = { pd.attended _ FALSE; Report["Attended[FALSE]", $Cmd, NIL]; }; LogTime: PROC[s: IO.STREAM, where: ATOM] RETURNS [seconds: INT] = { oldT: REF BasicTime.Unpacked _ NARROW[RefTab.Fetch[logTimes, where].val]; now: BasicTime.GMT _ BasicTime.Now[]; nowU: BasicTime.Unpacked _ BasicTime.Unpack[now]; seconds _ nowU.second; nowU.second _ 0; nowU.secondsThisYear _ 0; IF oldT=NIL THEN { oldT_NEW[BasicTime.Unpacked]; []_RefTab.Store[logTimes, where, oldT]; }; IF nowU=oldT^ THEN RETURN; oldT^ _ nowU; s.PutF["%g\n", time[now]]; }; logTimes: RefTab.Ref _ RefTab.Create[]; loggingGroups: PUBLIC CARDINAL_0; Noop: PUBLIC PROC = {NULL}; RealLogInfo: TYPE = RECORD [ logD1: LONG CARDINAL, logD2: LONG CARDINAL, length: CARDINAL, logCode: PACKED SEQUENCE maxLength: CARDINAL OF CHAR ]; rli: REF RealLogInfo _ NEW[RealLogInfo]; WriteTrace: WriteTraceProc _ NIL; DoWriteData: DoWriteDataProc _ NIL; IsActive: IsActiveProc _ NIL; WriteData: PUBLIC PROC[info: Log.LogInfo] = TRUSTED { logCode: Rope.Text; nbytes: NAT; IF loggingGroups=0 OR info.logCode =NIL THEN RETURN; logCode_Rope.Flatten[Atom.GetPName[info.logCode]]; rli.logD1_info.logD1; rli.logD2_info.logD2; nbytes _ MIN[logCode.InlineLength[], 20]; rli.length_nbytes; PrincOpsUtils.LongCOPY[ from: LOOPHOLE[logCode, LONG POINTER]+2, to: LOOPHOLE[rli, LONG POINTER]+6, nwords: (nbytes+1)/2]; DoWriteData[type: CODE[RealLogInfo], size: SIZE[RealLogInfo[nbytes]], data: LOOPHOLE[rli]]; }; Here: PUBLIC PROC = TRUSTED { frame: PrincOps.FrameHandle; IF loggingGroups=0 OR ~IsActive[] THEN RETURN; frame _ PrincOpsUtils.GetReturnFrame[]; IF frame=NIL THEN RETURN; WriteTrace[frame.accesslink.gfi, frame.pc]; }; DoLog: PUBLIC PROC[groups: CARDINAL_177777B] = { IF WriteTrace=NIL THEN { WriteTrace _ NARROW[FetchBinding[$WriteTrace], REF WriteTraceProc]^; DoWriteData _ NARROW[FetchBinding[$WriteData], REF DoWriteDataProc]^; IsActive _ NARROW[FetchBinding[$IsActive], REF IsActiveProc]^; }; loggingGroups_ IF WriteTrace#NIL THEN groups ELSE 0; }; FetchBinding: PROC[field: ATOM] RETURNS [REF] = { RETURN[Atom.GetProp[$Interfaces, field]]; }; CLog: TYPE = Log.CLog; MakeCLog: PUBLIC PROC[fileName: ROPE, CommandProc: PROC[CLog]_NIL, new: BOOL_FALSE, keep: CARDINAL_2] RETURNS[cLog: CLog_NIL] = { logStream: IO.STREAM; logStream _ FS.StreamOpen[fileName: fileName, keep: keep, accessOptions: IF new THEN $create ELSE $append! FS.Error => logStream_NIL]; IF logStream=NIL THEN RETURN[NIL]; cLog_NEW[Log.CLogBody_[logStream: logStream, CommandProc: CommandProc]]; logStream.SetIndex[0]; }; WriteCLog: PUBLIC ENTRY PROC[cLog: CLog, entry: ROPE] = { WriteLog[cLog, entry]; }; CloseCLog: PUBLIC ENTRY PROC[cLog: CLog] RETURNS[nullCLog: CLog_NIL] = { IF cLog=NIL THEN RETURN; IF cLog.logStream#NIL THEN cLog.logStream.Close[]; cLog.logStream_NIL; }; WriteLog: INTERNAL PROC[cLog: CLog, entry: ROPE] = { cLog.logStream.SetIndex[cLog.logStream.GetLength[]]; cLog.logStream.PutRope[entry]; cLog.logStream.Flush[]; }; DoCLog: PUBLIC ENTRY PROC[cLog: CLog, entry: ROPE] = { IF entry#NIL THEN WriteLog[cLog, entry]; DO pos: INT _ cLog.logReadPos; IF pos >= cLog.logStream.GetLength[] THEN EXIT; cLog.logStream.SetIndex[cLog.logReadPos]; cLog.CommandProc[cLog]; cLog.logReadPos _ cLog.logStream.GetIndex[]; IF pos=cLog.logReadPos THEN ERROR; -- Not making progress! ENDLOOP; }; RedoCLog: PUBLIC PROC[cLog: CLog] = { cLog.logReadPos_0; DoCLog[cLog, NIL]; }; GetBinding: PUBLIC PROC[qualifiedName: ROPE] RETURNS [tv: AMTypes.TV] = { tv _ Interpreter.Evaluate[qualifiedName].result; }; GetBindingToProc: PUBLIC PROC[qualifiedProcName: ROPE] RETURNS [proc: PROC ANY RETURNS ANY] = TRUSTED { tv: AMTypes.TV = Interpreter.Evaluate[qualifiedProcName].result; IF tv=NIL THEN RETURN[NIL]; proc _ LOOPHOLE[AMBridge.TVToProc[tv!AMTypes.Error=>CONTINUE]]; }; pd.ch _ NARROW[Commander.GetProperty[$CommanderHandle, ProcessProps.GetPropList[]]]; IF pd.ch#NIL THEN { pd.sysIn _ pd.ch.in; pd.sysOut _ pd.ch.out; }; RegisterWhereToReport[CmdWhere, $Cmd, NIL, NIL]; Commander.Register["Attended", SetAttended, "Break on errors"]; Commander.Register["Unattended", ClearAttended, "Log on errors, then muddle on."]; }. œLogImpl.mesa Simple Logging output, other general utilities; support for spy log stuff. Last modified by D. Swinehart, June 16, 1984 4:53:57 pm PDT Variables Copies Reporting and Suspending Associates Where atoms with print times. Procedures for performance monitoring and debugging Command Logging, indirect execution. Originally developed as part of ThMessageDBImpl Runtime Binding Initialization Ê ˜Jšœ ™ JšœJ™JJšœ;™;J˜šÏk ˜ Jšœ œ˜Jšœ œ˜ Jšœœ˜Jšœœ*˜4Jšœ œœ˜/Jšœ œ1˜@Jšœœ˜Jšœ œ˜Jšœ˜J˜Jšœ œ#˜1Jšœœ˜1Jšœ œ˜#Jšœœ˜+Jšœœœ ˜1Jšœ œ2˜@J˜J˜—šœ œœÏc ˜"š˜J˜ J˜ J˜Jšœ˜J˜ J˜ Jšœ˜J˜ Jšœ˜Jšœ˜Jšœ ˜ J˜Jšœ˜—šœ˜Jšœœ ˜—J˜—J™ J˜š œœœœœœ˜'J˜—šœ™J˜Jšœœœ˜Jšœœœœ˜Jšœ œœœ˜Jšœœ˜(Jšœ œ˜ —J˜™J™Jšœœœ˜šœœœ˜J˜Jšœ˜Jšœ˜"J˜J˜—šÏnœœœ˜#Jšœ7˜;Jšœ#˜#Jšœ$œ\˜ƒJšœ˜—J˜šŸ œœœ"œœœœ˜WJšœœ˜Jšœœœœ ˜$Jšœœ&˜1Jšœœœœ ˜!J˜(Jšœœœœ˜Jšœœœœœœœœ(œ œœ˜{Jšœ˜—J˜š Ÿœœœ œ#œœ˜PJšœ œ˜.Jšœ œ˜ Jš œœœ œœœ˜+J˜"Jšœ;ž)˜dJ˜—J˜š Ÿœœœ œ#œ˜IJšœœ ˜Jšœœ*˜3J˜J˜—šŸœ œ˜Jšœœ#œœ˜?Jšœœœ˜0J˜!Jšœ œ˜2J˜—J˜šŸ œ œ˜Jš œœ#œœ œ˜QJšœœ*˜4J˜J˜—šŸ œ œ˜Jšœœœ œ˜?Jšœ œ˜J˜Jšœ"˜"J˜—J™šŸ œ œ œ˜@Jšœœ˜!Jšœ˜!Jšœ˜Jšœ"˜"J˜—J˜šŸœ˜Jšœ/˜/Jšœ˜Jš œœœœœ˜Jšœœ.˜9Jš œœœœœ˜Jšœ ˜J˜—J˜šŸ œ˜&Jšœœ˜Jšœœ˜$Jšœ˜—J˜šŸ œ˜(Jšœœ˜Jšœ œ˜%Jšœ˜—J˜šŸœœœœ œœ œ˜CJšœœœ$˜IJšœœ˜%J˜1J˜J˜J˜šœœœ˜Jšœœ˜J˜'J˜—Jšœ œœ˜J˜ J˜J˜J˜—˜'J™(—J™—šœ3™3J˜Jšœœœ˜!J˜JšŸœœœœ˜J˜šœ œœ˜Jšœœœ˜Jšœœœ˜Jšœœ˜Jš œ œœ œœ˜4J˜—Jšœœœ˜(J˜Jšœœ˜!Jšœœ˜#Jšœœ˜J˜šŸ œœœœ˜5Jšœ˜Jšœœ˜ Jš œœœœœ˜4J˜2J˜J˜Jšœ œ˜)Jšœ˜šœ˜šœœ œœ˜(Jšœœ œœ˜A——Jšœœœœ˜[J˜—J˜šŸœœœœ˜J˜Jšœœ œœ˜.J˜'Jšœœœœ˜J˜+J˜—J˜šŸœœœ œ ˜0šœ œœ˜Jšœ œœ˜DJšœœœ˜EJšœ œœ˜>J˜—Jš œœ œœœ˜4Jšœ˜—J˜š Ÿ œœœœœ˜1Jšœ#˜)J˜—J˜—J™$™/J™Jšœœ ˜J˜šŸœœœ œŸ œœœœœœ˜ešœ œ˜Jšœ œœ˜šœ9˜9Jšœœœ œ ˜0Jšœœ˜—Jš œ œœœœ˜"Jšœœ@˜HJ˜J˜——J˜šŸ œœœ˜9J˜J˜—J˜š Ÿ œœœœ œœ˜HJšœœœœ˜Jšœœœ˜2Jšœœ˜J˜J˜—šŸœœœœ˜4J˜4J˜J˜J˜—J˜š Ÿœœœœœ˜6Jšœœœ˜(š˜Jšœœ˜Jšœ#œœ˜/J˜)J˜Jšœ,˜,Jšœœœž˜:Jšœ˜—Jšœ˜——˜šŸœœœ˜%J˜Jšœ œ˜J˜J˜——™J™š Ÿ œœœœœœ˜IJšœ0˜0J˜—J˜šŸœœœœ˜6Jš œœœœœœ˜0Jšœ@˜@Jš œœœœœ˜Jšœœ%œ˜?J˜—J˜—™J™JšœœF˜TJšœœœ1˜BJšœ&œœ˜0J˜?J˜R—J˜J˜J˜J˜—…— *W