// PeekSum.bcpl -- Peek.reports summary
// Copyright Xerox Corporation 1979, 1980
// Last modified October 29, 1980  11:15 AM by Boggs

// Bldr PeekSum Template

get "Streams.d"
get "SysDefs.d"

external
[
// Incoming procedures
OpenFile; ReadBlock; FileLength
Ws; Wss; PutTemplate
Endofs; Gets; Resets; Closes
Usc; Zero; MoveBlock; Junta; CallSwat; MyFrame; SysErr
InitializeZone; Allocate; AddToZone

// incoming statics
sysZone
]

manifest stackLimit = 335b

static
[
list1; list2; list3
AltoIITable; hashTab
netNum; hostNum
rpt; sum; dir
token; termChar
]

structure String [ length byte; char^1,1 byte ]

//----------------------------------------------------------------------------
let PeekSum() be
//----------------------------------------------------------------------------
[
let netDir = OpenFile("PUP-NETWORK.DIRECTORY", ksTypeReadOnly, wordItem)
if netDir ne 0 then
   [
   let length = vec 1; FileLength(netDir, length)
   if length!0 eq 0 then
      [
      length = length!1 rshift 1 +1
      Resets(netDir)
      ReadBlock(netDir, @stackLimit, length)
      dir = @stackLimit; @stackLimit = @stackLimit + length
      ]
   Closes(netDir)
   ]

// set up free storage zone
let freeBegin = @stackLimit
let freeEnd = MyFrame() -2000
if freeEnd - freeBegin ls 0 then freeEnd = freeBegin + 77777b
@stackLimit = freeEnd
sysZone = InitializeZone(freeBegin, freeEnd-freeBegin, SysErr, 0)

// open files
rpt = OpenFile("Peek.Reports", ksTypeReadOnly, charItem, 0, 0, 0, sysZone)
if rpt eq 0 then [ Ws("*NCan't find file Peek.Reports"); finish ] 
sum = OpenFile("PeekSummary.tx", ksTypeWriteOnly, charItem, 0, 0, 0, sysZone)
if sum eq 0 then CallSwat("Can't open PeekSummary.tx")

// dont need OS through levScan any more
Junta(levStreams, AfterJunta)
]

//----------------------------------------------------------------------------
and AfterJunta() be
//----------------------------------------------------------------------------
[
let freeBegin = @stackLimit
let freeEnd = MyFrame() - 1000
@stackLimit = freeEnd
AddToZone(sysZone, freeBegin, freeEnd-freeBegin)

// following three lists are indexed by host number
// hanging off each entry is a linked list of items
list1 = Allocate(sysZone, 256); Zero(list1, 256)  // Error Text
list2 = Allocate(sysZone, 256); Zero(list2, 256)  // Main mem errors
list3 = Allocate(sysZone, 256); Zero(list3, 256)  // Ctrl mem errors

// bit on means this host is an Alto II
AltoIITable = Allocate(sysZone, 16); Zero(AltoIITable, 16)

// error strings are kept in a hash table to detect duplicates.
// List1 items also point to the strings.
hashTab = Allocate(sysZone, 256); Zero(hashTab, 256)

token = Allocate(sysZone, 100)

until Endofs(rpt) do
   [
   ReadToken()	//read network number
   //print lines in Peek.reports that don't start with <netnumber>#
   if termChar ne $# then PutTemplate(sum, "$S*N", token)

   if netNum eq 0 then netNum = StringToNumber(8)
   ReadToken()	//read serial number
   if termChar ne $# then		//line screwed up--discard line
      [
      while termChar ne $*N do ReadToken()
      loop
      ]
   hostNum = StringToNumber(8)

   ReadToken()	//read something, hopefully a number
   if termChar ne $*S then	//if it doesn't end in <space>, discard line
      [
      while termChar ne $*N do ReadToken()
      loop
      ]
   let item = vec 5
   let FN = StringToNumber(10)

   // AfterJunta (cont'd)

   ReadToken()
   switchon termChar into
      [
      case $*N:
         [
         test token!0 gr 5	//at most 5 chars in a number
            ifso		//token is text
               [
               item!0 = HashLookup()	//->error text
               item!1 = FN		//# of errors of this type
               AddToList(list1, item, 2)
               ]
            ifnot		//token is number of RAM chip errors
               [
               item!0 = FN		// chip number
               item!1 = StringToNumber(10)  // # of errors in this chip
               AddToList(list3, item, 2)
               ]
         endcase
         ]

      case $*S:			//line describes bad main mem chip
         [				// AltoI	AltoII
         item!0 = FN			// card		card
         item!1 = StringToNumber(10)	// column	chip
         ReadToken()
         item!2 = StringToNumber(10)	// row		# of errors
         if termChar eq $*N then
            [
            SetAltoIIBit(hostNum)	//this is an Alto II
            AddToList(list2, item, 3)
            loop
            ]
         ReadToken()
         item!3 = StringToNumber(10)	// # of errors
         if termChar ne $*N loop
         AddToList(list2, item, 4)
         endcase
         ]

      default: loop
      ]
   ]

Closes(rpt)

// Generate results
let base, addr = 0, 0
if dir ne 0 then
   [
   base = dir
   addr = base + base!3
   while (@(base + @addr + 2) rshift 8) ne netNum do addr = addr +1
   ]

PutTemplate(sum, "*NNetwork number $O*N*N*N", netNum)

for host = 0 to 255 do
   [
   if list1!host eq 0 loop
   PutTemplate(sum, "$3O--", host)

   if dir ne 0 then
      [
      while (@(base + @addr + 2) & 377b) ls host do addr = addr +1
      test (@(base + @addr + 2) & 377b) eq host
         ifso
            [
            Wss(sum, base + @(base + @(base + @addr + 1) + 6))
            Wss(sum, "  ")
            Wss(sum, base + @(base + @(base + @addr + 1) + 4))
            ]
         ifnot Wss(sum, "not in PUP-NETWORK.DIRECTORY")
      ]

   // print any error strings
   let errors = false
   let link = list1!host
   until link eq 0 do
      [
      if link!2 ne 0 then errors = true
      link = link!0
      ]
   unless errors do
      [
      Wss (sum, " : NO ERRORS*N*N")
      loop
      ]
   link = list1!host
   Wss(sum, " :*N")
   until link eq 0 do
      [
      PutTemplate(sum, "$5D $S*N", link!2, (link!1)+1)
      link = link!0
      ]


   // AfterJunta (cont'd)

   // print main memory chip errors
   link = list2!host
   if link ne 0 then
      [
      Wss(sum, "*NMain memory chips ")
      test IsAltoII(host)
         ifso Wss(sum, "(Alto II):*NCard  Chip  Errors*N")
         ifnot Wss(sum, "(Alto I):*NCard  Col   Row   Errors*N")
      until link eq 0 do
         [
         for j = 1 to (2+(1-IsAltoII(host))) do
            PutTemplate(sum, "$2D    ", link!j)
         PutTemplate(sum, "$5D*N", link!(3+(1-IsAltoII(host))))
         link = link!0
         ]
      ]

   // print control memory chip errors
   link = list3!host
   if link ne 0 then Wss(sum, "*NControl memory chips:*NChip  Errors*N")
   until link eq 0 do
      [
      PutTemplate(sum, "$2D    $5D*N", link!1, link!2)
      link = link!0
      ]
   Wss(sum, "*N*N")
   ]
Closes(sum)
finish  // We Juntaed -- simply returning doesn't work anymore.
]

//----------------------------------------------------------------------------
and AddToList(list, item, len) be
//----------------------------------------------------------------------------
[
let listItem = list!hostNum
while listItem ne 0 do
   [
   let found = true
   for i = 1 to len-1 do
      if item!(i-1) ne listItem!i then [ found = false; break ] 
   if found then
      [
      //only smash current count with bigger count
      //so restart of DMT doesn't destroy record of previous errors
      //rshifts force ignorance of sign bit, with loss of bottom bit
      if Usc(listItem!len, item!(len-1)) ls 0 then
         listItem!len = item!(len-1)
      return
      ] 
   listItem = listItem!0
   ]

// Not on list.  Add it
let t = Allocate(sysZone, len+1)
MoveBlock(t+1, item, len)
t!0 = list!hostNum; list!hostNum = t
]

//----------------------------------------------------------------------------
and HashLookup() = valof
//----------------------------------------------------------------------------
[ 
let probe = 0
for i = 1 to token>>String.length do
   probe = probe + token>>String.char^i
probe = probe & 377b

let entry = hashTab!probe
let found = false
until entry eq 0 % found do
   [ 
   found = true
   for i = 1 to token>>String.length do
      if token>>String.char^i ne (entry+1)>>String.char^i then
         [ found = false; break ]
   unless found do entry = entry!0
   ]

if found resultis entry

let wordLen = token>>String.length rshift 1 +1
let t = Allocate(sysZone, wordLen +1)
MoveBlock(t+1, token, wordLen)
t!0 = hashTab!probe; hashTab!probe = t
resultis t
]

//----------------------------------------------------------------------------
and ReadToken() be
//----------------------------------------------------------------------------
[
let number = false
let first = true
token>>String.length = 0
   [
   if Endofs(rpt) return
   termChar = Gets(rpt)
   switchon termChar into
      [
      case $0 to $9:
         [
         if first then number = true
         docase -1
         ]
      case $*N: return
      case $*S: case $*T:
         [
         if first loop
         if number return
         ]
      default: if number return  // otherwise fall into case -1
      case -1:
         [
         first = false
         token>>String.length = token>>String.length+1
         token>>String.char^(token>>String.length) = termChar
         endcase
         ]
      ]
   ] repeat
]

//----------------------------------------------------------------------------
and StringToNumber(base) = valof
//----------------------------------------------------------------------------
[
let number = 0
for i = 1 to token>>String.length do
   number = number * base + (token>>String.char^i - $0)
resultis number
]

//----------------------------------------------------------------------------
and SetAltoIIBit(host) be
//----------------------------------------------------------------------------
   AltoIITable!(host rshift 4) = (AltoIITable!(host rshift 4)) %
    (#100000 rshift (host & #17))

//----------------------------------------------------------------------------
and IsAltoII(host) =
   ((AltoIITable!(host rshift 4)) & (#100000 rshift (host & #17))) eq 0? 0, 1
//----------------------------------------------------------------------------