-- N.Wirth  June 1, 1977
				-- S.Andler  August 24, 1977  10:52 PM
				-- C.Geschke  August 31, 1977  12:00 PM
				-- E.Satterthwaite  September 9, 1977 10:41 AM
DIRECTORY
  AltoFileDefs: FROM "AltoFileDefs",
  DirectoryDefs: FROM "DirectoryDefs",
  InlineDefs: FROM "InlineDefs",
  IODefs: FROM "IODefs",
  SegmentDefs: FROM "SegmentDefs",
  StreamDefs: FROM "StreamDefs",
  StringDefs: FROM "StringDefs",
  SystemDefs: FROM "SystemDefs",
  TeleSilDefs: FROM "TeleSilDefs",
  TeleSilProcDefs: FROM "TeleSilProcDefs";

DEFINITIONS FROM 
  StreamDefs,	-- StreamHandle, CreateWordStream, ReadBlock,
		-- WriteBlock, destroy, get, put, endof
  SegmentDefs;	-- FileHandle, InsertFile, Read, Write, Append

--------------------------------------------------------------------
TeleSilIO: PROGRAM
  IMPORTS
    DirectoryDefs, IODefs, SegmentDefs, StreamDefs, StringDefs, SystemDefs,
    TeleSilProcDefs
  EXPORTS TeleSilProcDefs =
BEGIN
OPEN
  TeleSilProcDefs,	-- Confirm, Error, FontLoaded, FontName,
			-- AllocateObject, Rover
  TeleSilDefs;

IsLetter: PROCEDURE[ch: CHARACTER] RETURNS[BOOLEAN]=
    BEGIN RETURN [ch IN ['a..'z] OR ch IN ['A..'Z]] END;

--------------------------------------------------------------------
-- INPUT/OUTPUT
-- defines Input, Output, DefaultExtension

FileCodeWord: CARDINAL= 31459;
fileName: STRING _ [40];
FileObject: TYPE= MACHINE DEPENDENT RECORD[
    kind: ObjKind,
    state: ObjState,
    fill: [0..777B],	-- keep specifics right justified
    specifics: [0..7],  -- shade for area, fontno for text
    zone: Zone,
    dummy: WORD];

Input: PUBLIC PROCEDURE=
  BEGIN OPEN IODefs;
  old: BOOLEAN;
  sh:  StreamHandle;
  fh:  FileHandle;
  fp:  AltoFileDefs.FP;
  eof: BOOLEAN _ FALSE;

  EndOfFile: PROCEDURE RETURNS[BOOLEAN] = BEGIN RETURN[eof] END;
  GetWord: PROCEDURE RETURNS[WORD]=
    BEGIN
    eof _ sh.endof[sh];
    RETURN[IF eof THEN 0 ELSE sh.get[sh]]
    END;
  GetBlock: PROCEDURE[address: POINTER, words: INTEGER]=
    BEGIN
    eof _ sh.endof[sh];
    IF eof THEN RETURN;
    []_ReadBlock[sh, address, words]
    END;

  WriteString["File: "]; ReadID[fileName];
  DefaultExtension[fileName, "telesil"]; WriteLine[""];
  old _ DirectoryDefs.DirectoryLookup[@fp, fileName, FALSE];
  IF NOT old THEN BEGIN Error["File not found"]; RETURN END;
  fh _ InsertFile[@fp, Read];
  sh _ CreateWordStream[fh, Read];
  InputFile[EndOfFile, GetWord, GetBlock];
  sh.destroy[sh]
  END;

InputFile: PUBLIC PROCEDURE[
    EndOfFile: PROCEDURE RETURNS[BOOLEAN],
    GetWord: PROCEDURE RETURNS[WORD],
    GetBlock: PROCEDURE[address: POINTER, words: INTEGER]]=
  BEGIN
  n: CARDINAL;
  ppObj: POINTER TO ObjPtr _ Rover[];
  fileObj: FileObject;

  IF GetWord[]#FileCodeWord THEN Error["Not a picture file"]
  ELSE
    DO
      GetBlock[@fileObj, SIZE[FileObject]];
      IF EndOfFile[] THEN EXIT;
      AllocateObject[fileObj.kind]; 
      ppObj.zone _ fileObj.zone;
      ppObj.state _ fileObj.state;
      WITH ppObj^ SELECT FROM
	area => shade _ fileObj.specifics;
	text =>
	  BEGIN
	  fontno _ fileObj.specifics;
	  n _ GetWord[];
	  str _ SystemDefs.AllocateHeapString[n];
	  str.length _ n;
	  IF NOT FontLoaded[fontno] THEN fontno _ 0;
	  GetBlock[str+2, StringDefs.WordsForString[n]-2]
	  END;
	ENDCASE;
      ENDLOOP;
  END;

Output: PUBLIC PROCEDURE=
  BEGIN OPEN IODefs;
  old: BOOLEAN;
  sh: StreamHandle;
  fh: FileHandle;
  fp: AltoFileDefs.FP;

  PutWord: PROCEDURE[word: WORD] = BEGIN sh.put[sh, word] END;
  PutBlock: PROCEDURE[address: POINTER, words: INTEGER]=
    BEGIN [] _ WriteBlock[sh, address, words] END;

  WriteString["File: "]; ReadID[fileName];
  DefaultExtension[fileName, "telesil"]; WriteLine[""];
  old _ DirectoryDefs.DirectoryLookup[@fp, fileName, TRUE];
  IF old THEN
    BEGIN
    WriteString["Existing file"];
    IF NOT Confirm[] THEN RETURN
    END;
  fh _ InsertFile[@fp, Write+Append];
  sh _ CreateWordStream[fh, Write+Append];
  OutputFile[PutWord, PutBlock];
  sh.destroy[sh]
  END;

OutputFile: PUBLIC PROCEDURE[
    PutWord: PROCEDURE[word: WORD],
    PutBlock: PROCEDURE[address: POINTER, words: INTEGER]]=
  BEGIN
  n: CARDINAL;
  rover: ObjPtr _ Rover[]^;
  stop: ObjPtr _ rover;
  fileObj: FileObject;

  PutWord[FileCodeWord];
  IF rover#NIL THEN
    DO
    IF rover.state#dead THEN
      BEGIN
      fileObj.kind _ rover.kind;
      fileObj.state _ rover.state;
      fileObj.fill _ 0;
      fileObj.specifics _
	  WITH rover SELECT FROM
	    area => shade,
	    text => fontno,
	    ENDCASE => 0;
      fileObj.zone _ rover.zone;
      fileObj.dummy _ 0;
      PutBlock[@fileObj, SIZE[FileObject]];
      WITH rover SELECT FROM
	text =>
	  BEGIN
	  n _ str.length;
	  PutWord[n];
	  PutBlock[str+2, StringDefs.WordsForString[n]-2]
	  END;
	ENDCASE;
      END;
    IF (rover _ rover.next)=stop THEN EXIT
    ENDLOOP;
  END;

DefaultExtension: PUBLIC PROCEDURE[fileName, extension: STRING]=
  BEGIN -- check if fileName has an extension, otherwise extend it
  i: CARDINAL;
  FOR i IN [0..fileName.length) DO IF fileName[i]='. THEN RETURN ENDLOOP;
  StringDefs.AppendString[fileName, "."]; IODefs.WriteString["."];
  StringDefs.AppendString[fileName, extension]; IODefs.WriteString[extension]
  END;

--------------------------------------------------------------------
-- HARDCOPY:  Generate press format file
-- defines HardCopy

HardCopy: PUBLIC PROCEDURE=
  BEGIN OPEN InlineDefs,  -- BITAND, BITOR, BITSHIFT
	     IODefs;
  scale: CARDINAL= 35;  -- 35 micas per unit length
  i, k, k1, pad: CARDINAL;
  n: CARDINAL _ 0;  -- no. of words written
  even: BOOLEAN _ TRUE;  -- no. of bytes written is even
  buf: UNSPECIFIED;
  old: BOOLEAN;
  rover: ObjPtr _ Rover[]^;
  stop: ObjPtr _ rover;
  sh: StreamHandle;
  fh: FileHandle;
  fp: AltoFileDefs.FP;
  PartDirPageNo, FontDirPageNo: CARDINAL;
  fchar: CHARACTER;
  fname: STRING;
  hardCopyFileName: STRING _ [40];

  PW: PROCEDURE[w: UNSPECIFIED]=
    BEGIN  -- write one word on file
    IF even THEN sh.put[sh, w]
    ELSE
      BEGIN
      sh.put[sh, BITOR[BITSHIFT[buf,8], BITSHIFT[w,-8]]];
      buf _ BITAND[w, 377B]
      END;
    n _ n+1
    END;

  PB: PROCEDURE[b: UNSPECIFIED]=
    BEGIN  -- write one byte on wordfile
    IF even THEN buf _ b
    ELSE BEGIN sh.put[sh, BITOR[BITSHIFT[buf,8], b]]; n _ n+1 END;
    even _ NOT even
    END;

  Fill: PROCEDURE=
    BEGIN
    N: CARDINAL _ 0;
    IF NOT even THEN PB[0];
    WHILE N < n DO N _ N+256 ENDLOOP;
    WHILE n < N DO sh.put[sh, 0]; n _ n+1 ENDLOOP
    END;

  Position: PROCEDURE=
    BEGIN
    PB[356B]; PW[scale * rover.zone.point.x];
    PB[357B]; PW[scale*(BMMaxHeight-rover.zone.point.y-rover.zone.h)];
    END;

  Size: PROCEDURE=
    BEGIN PB[376B]; PW[scale * rover.zone.w]; PW[scale * rover.zone.h] END;

  FOR i IN [0..fileName.length) DO
    IF fileName[i] = '. THEN EXIT
    ELSE hardCopyFileName[i] _ fileName[i]
    ENDLOOP;
  IF fileName.length = 0 THEN i _ 0;
  hardCopyFileName.length _ i;
  StringDefs.AppendString[hardCopyFileName, ".press"];
  WriteString["File: "]; ReadID[hardCopyFileName];
  DefaultExtension[hardCopyFileName, "press"]; WriteLine[""];
  old _ DirectoryDefs.DirectoryLookup[@fp, hardCopyFileName, TRUE];
  IF old THEN
    BEGIN WriteString[" Existing file"]; IF NOT Confirm[] THEN RETURN END;
  fh _ InsertFile[@fp, Write+Append];
  sh _ CreateWordStream[fh, Write+Append];

  -- 1: the printed page

  IF rover#NIL THEN
    DO
    IF rover.state#dead THEN
      WITH rover SELECT FROM
	text => FOR i IN [0..str.length) DO PB[str[i]] ENDLOOP;
	ENDCASE;
    IF (rover _ rover.next)=stop THEN EXIT
    ENDLOOP;
  IF even THEN k _ 2*n ELSE BEGIN k _ 2*n+1; PB[0] END;
  PW[0]; k1 _ n; 
  IF rover#NIL THEN
    DO
    IF rover.state#dead THEN
      WITH rover SELECT FROM
	area => BEGIN Position; PB[370B]; PB[(black - shade) * 40B]; Size END;
	ENDCASE;
    IF (rover _ rover.next)=stop THEN EXIT
    ENDLOOP;
  PB[370B]; PB[0];
  IF rover#NIL THEN
    DO
    IF rover.state#dead THEN
      WITH rover SELECT FROM
	line => BEGIN Position; Size END;
	area => NULL;
	text => BEGIN Position; PB[fontno + 160B]; PB[360B]; PB[str.length] END;
	ENDCASE;
    IF (rover _ rover.next)=stop THEN EXIT
    ENDLOOP;
  IF NOT even THEN PB[377B];
  PB[0]; PB[0]; PW[0]; PW[0]; PW[0]; PW[k];  -- entity trailer
  PW[0]; PW[0]; PW[0]; PW[0]; PW[0]; PW[0];
  PW[n-k1+1];  -- entity length
  pad _ n; Fill; pad _ n-pad;

  -- 2: the font directory

  FontDirPageNo _ n/256;
  FOR i IN FontNumber DO
    IF FontLoaded[i] THEN
      BEGIN
      PW[16]; PB[0]; PB[i]; PB[0]; PB[177B];
      fname _ FontName[i];
      FOR k _ 0, k+1 WHILE IsLetter[fname[k]] DO ENDLOOP;
      PB[k];
      FOR k1 IN [0..k) DO
	fchar _ fname[k1];
	IF fchar>'Z THEN fchar _ LOOPHOLE[BITAND[LOOPHOLE[fchar], 137B]];
	PB[fchar]
	ENDLOOP;
      THROUGH [k..19) DO PB[0] ENDLOOP;
      k1 _ 0; fchar _ fname[k];
      WHILE fchar IN ['0..'9] DO
	k1 _ 10*k1+(LOOPHOLE[fchar, CARDINAL]-60B);
	k _ k+1; fchar _ fname[k]
	ENDLOOP;
      PB[0]; PB[0]; PW[k1]; PW[0]
      END
    ENDLOOP;
  PW[0]; Fill;

  -- 3: the part directory

  PartDirPageNo _ n/256;
  PW[0]; PW[0]; PW[FontDirPageNo]; PW[pad];
  PW[1]; PW[FontDirPageNo]; PW[1]; PW[0];
  PW[0]; Fill;

  -- 4: the document directory

  PW[27183]; PW[n/256+1]; PW[2]; PW[PartDirPageNo];
  PW[1]; PW[0]; PW[-1]; PW[-1]; PW[0]; PW[0];
  Fill; sh.destroy[sh]
  END;

END.(1799)\559b12B2b16B2b9B7b10B2b7B2b3B2b3B2b5B19b10B2b10B2b4B2b5B2b6B71b9B177b65B17b8B232b12B19b8B17b10B223b5B848b9B835b6B689b10B839b16B489b8B49b6B2b5B2b8B