; Format input lines to standard output

       INCLUDE "/include/init.i"

;      OPT     D+

; Local Equs

FormatBufSize  EQU     1500
MaxLineSize    EQU     512
MaxFormatArgs  EQU     20

; Variable storage

       STRUCT  ArgArray,(1+1)*4
       STRUCT  ArgStream,MaxFormatArgs*4
       STRUCT  FormatClipInfo,2*4
       LONG    StdIn
       LONG    StdOut
       LONG    FormatBufPtr
       SIZE

; Regs

ByteFetch      EQUR    D4
ReadBytesLeft  EQUR    D5
LineBufPtr     EQUR    D6
LineBufLeft    EQUR    D7
LineEndPtr     EQUR    A2
ErrorStrPtr    EQUR    A4

; Startup

       STACK   4000
       INIT

; Let ARP interpret the commandline

       MOVE.L  ComLineBase(GP),A0
       MOVE.L  ComLineSize(GP),D0
       LEA     HelpMsg(PC),A1
       LEA     ArgArray(GP),A2
       LEA     Template(PC),A3
       MOVE.L  A1,(A2)
       CALL    GADS
       MOVE.L  (A2),ErrorStrPtr
       TST.L   D0
       BEQ     ErrorExit
       BMI     ErrorExit

; Open the standard input & output

       CALL    Input
       MOVE.L  D0,StdIn(GP)
       CALL    Output
       MOVE.L  D0,StdOut(GP)

; Alloc tracked mem for the string format buffer.

       LEA     OutOfMem(PC),ErrorStrPtr
       MOVE.L  #FormatBufSize,D0
       MOVEQ   #0,D1
       CALL    ArpAllocMem
       MOVE.L  D0,FormatBufPtr(GP)
       BEQ     ErrorExit

; Allocate the read-line buffer

       MOVE.L  #MaxLineSize+4+MaxLineSize,D0   ; 2 part buf with 0 term space.
       MOVEQ   #0,D1
       CALL    ArpAllocMem
       MOVE.L  D0,LineBufPtr
       BEQ     ErrorExit

; Initialize the argument stream

       MOVEQ   #MaxFormatArgs-1,D0
       LEA     ArgStream(GP),A0
InitArgStreamLongs:
       MOVE.L  LineBufPtr,(A0)+
       DBRA    D0,InitArgStreamLongs


; ** This is an intelligent ReadLine routine.

       MOVEQ   #0,ReadBytesLeft

; Reinitialize the line buffer. (First part of dual buffer space)

DoForEachLine:
       LEA     ReadError(PC),ErrorStrPtr
       MOVE.L  LineBufPtr,LineEndPtr
       MOVE.L  #MaxLineSize,LineBufLeft

; Extract lines from the readbuffer into the line buffer.

       BRA.S   ExtractEntry
CopyLineBytes:
       MOVE.L  ByteFetch,A0
       ADDQ.L  #1,ByteFetch
       SUBQ.L  #1,ReadBytesLeft
       MOVE.B  (A0),D0
       CMP.B   #10,D0
       BEQ.S   GotLine
       MOVE.B  D0,(LineEndPtr)+
       SUBQ.L  #1,LineBufLeft
       BEQ.S   GotLine
ExtractEntry:
       TST.L   ReadBytesLeft
       BNE     CopyLineBytes

; Refill the read buffer.

       MOVE.L  StdIn(GP),D1
       MOVE.L  LineBufPtr,D2
       MOVE.L  #MaxLineSize,D3
       ADD.L   D3,D2
       ADDQ.L  #4,D2
       CALL    Read
       TST.L   D0
       BMI.S   ErrorExit
       BNE.S   NotYetDone
       CMP.L   LineBufPtr,LineEndPtr
       BEQ.S   Exit
NotYetDone:
       MOVE.L  D2,ByteFetch
       MOVE.L  D0,ReadBytesLeft
       BNE     CopyLineBytes

; Null terminate the line.

GotLine:
       CLR.B   (LineEndPtr)

; Format things, terminate with a LF, and write the format buffer

       BSR.S   VanillaDoFmt
       MOVE.L  FormatBufPtr(GP),A0
       MOVE.B  #10,-1(A0,D0.L)

       LEA     WriteError(PC),ErrorStrPtr
       MOVE.L  StdOut(GP),D1
       MOVE.L  A0,D2
       MOVE.L  D0,D3
       BEQ.S   WriteDone
       CALL    Write
       CMP.L   D0,D3
       BNE.S   ErrorExit
WriteDone:

; Check if user hit ^C 

       SUB.L   A1,A1
       CALL    CheckAbort
       MOVE.L  A1,ErrorStrPtr
       TST.L   D0
       BNE.S   ErrorExit
       BRA     DoForEachLine

; Done, cleanup

Exit:
       CLR.W   ReturnCode(GP)
       SUB.L   ErrorStrPtr,ErrorStrPtr
ErrorExit:

; Display error string, if any, and exit

       MOVE.L  ErrorStrPtr,D0
       BEQ.S   NoErrorMsg
       MOVE.L  D0,A1
       CALL    Puts
NoErrorMsg:
       RTS

; Subroutines

; This sub uses exec's RawDoFmt to do string formatting while clipping
; any surplus data to fit the buffer size. Arps format routines have
; no overflow checks, and since the user is not guaranteed to act
; sanely, clipping is essential.
; I : Assumes a valid format string and buffer
; O : The format buffer contain the formatted string.
;   : D0.L = Size of formatted string.

Vanilla_Regs   REG     A2/A3/A6

VanillaDoFmt:
       MOVEM.L Vanilla_Regs,-(SP)
       MOVE.L  ArgArray(GP),A0
       LEA     ArgStream(GP),A1
       LEA     DoClippedBufferFill(PC),A2
       LEA     FormatClipInfo(GP),A3
       MOVE.L  FormatBufPtr(GP),(A3)
       MOVE.L  (A3),4(A3)
       ADD.L   #FormatBufSize,4(A3)
       MOVE.L  $4.W,A6                         ; exec
       CALL    RawDoFmt
       MOVE.L  (A3),D0
       SUB.L   FormatBufPtr(GP),D0
       MOVEM.L (SP)+,Vanilla_Regs
       RTS

; Assumes A0 is usable, not clear from autodocs whether this is true.
; (Default calling conventions and ROM code suggest it is)

DoClippedBufferFill:
       MOVE.L  (A3)+,A0
       CMP.L   (A3),A0
       BNE.S   NotYetAtBufEnd
       SUBQ.L  #1,A0
NotYetAtBufEnd:
       MOVE.B  D0,(A0)+
       MOVE.L  A0,-(A3)
       RTS

; The string section

Template:
       DC.B    'FormatString/a',0
HelpMsg:
       DC.B    'PForm - Pipe formatted lines.',10
       DC.B    'Usage: PForm "prefix %[width.limit]s postfix"',0
OutOfMem:
       DC.B    'Out of memory!',0
ReadError:
       DC.B    'Error while reading',0
WriteError:
       DC.B    'Error while writing',0
       CNOP    0,2

       END