// CmdScanEdit.bcpl -- Command Scanner Package editing functions
// Copyright Xerox Corporation 1979

//	Last modified July 11, 1977  3:25 PM

get "CmdScan.decl"

external
[
//outgoing procedures
GetPhrase; AppendChar; EraseInput

//incoming procedures
NextPhrase; CurrentPhrase; BackupPhrase
Gets; Puts; Errors; Wss
DefaultArgs; Allocate; Free; Zero
]


//---------------------------------------------------------------------------
let GetPhrase(cs, WordBreak, PhraseTerminator, Echo,
    Help, helpArg; numargs na) = valof
//---------------------------------------------------------------------------
//Readies the next phrase to be taken, inputting one from the
//keyboard if necessary and updating the phrase state.
//Sets up cs>>CS.iChOut to point to the first character of the
//phrase, and returns the number of characters in the phrase,
//not including the terminator.
[
DefaultArgs(lv na, -1, cs>>CS.pd^0.WordBreak,
 cs>>CS.pd^0.PhraseTerminator, cs>>CS.pd^0.Echo, 0, 0)
let pd = NextPhrase(cs)
pd>>PD.WordBreak = WordBreak
pd>>PD.PhraseTerminator = PhraseTerminator
pd>>PD.Echo = Echo

if cs>>CS.iPhIn eq cs>>CS.iPhOut then cs>>CS.reparse = false
unless cs>>CS.reparse % cs>>CS.reuse do EditPhrase(cs, Help, helpArg)

cs>>CS.reuse = false
cs>>CS.phraseRead = true
cs>>CS.iChOut = pd>>PD.iFirst  //ready to take first char
resultis pd>>PD.iLast-pd>>PD.iFirst
]

//---------------------------------------------------------------------------
and EditPhrase(cs, Help, helpArg) be
//---------------------------------------------------------------------------
//Edits the current phrase (the current input and output phrases
//are assumed to be the same), returning when a terminating
//character is input.
//The disposition of the existing contents of the phrase (if any)
//is controlled by cs>>CS.editControl, which is one of:
// editNew	New phrase -- fill it in (this is the default).
// editAppend	Phrase exists -- remove terminating character
//		and append more characters to it.
// editReplace	Phrase exists -- if the first character input is
//		not a terminating character, erase it and start
//		over;  if it is, just return the phrase as-is.
//If cs>>CS.putbackChar is nonzero, it is used as the first
//character of the phrase as if it had been typed in.
[
let pd = CurrentPhrase(cs)

   [ //repeat
   let char = cs>>CS.putbackChar ne 0? cs>>CS.putbackChar, Gets(cs>>CS.keyS)
   cs>>CS.putbackChar = 0
   if cs>>CS.editControl ne editNew & cs>>CS.iChIn gr pd>>PD.iLast then
      EraseInput(cs, pd>>PD.iLast, eraseTerminator)
   switchon char into
      [
      case $*010: case $*001:  //backspace, control-A
         [ EraseBackTo(cs, BackupChars(cs, false), eraseChar); endcase ]
      case $*027:  //control-W
         [ EraseBackTo(cs, BackupChars(cs, true), eraseWord); endcase ]
      case $*177:  //delete
         [ Errors(cs, ecCmdDelete); loop ]
      case $*022:  //control-R
         [ RetypeCmd(cs); loop ]
      case $?:
         [
         if Help ne 0 then
            [
            Wss(cs>>CS.dspS, "? ")
            Help(cs>>CS.dspS, helpArg)
            RetypeCmd(cs)
            loop
            ]
         //if no help, fall thru to default case
         ]
      default:
         [
         if cs>>CS.editControl eq editReplace &
          not pd>>PD.PhraseTerminator(cs, char) then
            EraseBackTo(cs, pd>>PD.iFirst, eraseWord)
         if AppendChar(cs, char, pd>>PD.Echo(cs, char)) &
          pd>>PD.PhraseTerminator(cs, char) then
            [
            pd>>PD.iLast = cs>>CS.iChIn-1
            test char eq $*s & pd>>PD.iLast eq pd>>PD.iFirst
               ifso pd>>PD.iFirst = pd>>PD.iFirst+1
               ifnot [ cs>>CS.editControl = editNew; break ]
            ]
         ]
      ]
   cs>>CS.editControl = editNew
   ] repeat
]

//---------------------------------------------------------------------------
and AppendChar(cs, char, echo) = valof
//---------------------------------------------------------------------------
//Appends a character to the command buffer, and also echos it if echo
//is true.  If echo is false, #200 is added to the character as a signal
//that the character is non-printing.  Returns true normally.
//If the buffer overflows, Errors is called;  if Errors returns, AppendChar
//returns false having done nothing.
[
let i = cs>>CS.iChIn
if i ge cs>>CS.maxChars then [ Errors(cs, ecCmdTooLong); resultis false ]
test echo
   ifso Puts(cs>>CS.dspS, char)
   ifnot char = char+#200
cs>>CS.buf>>Buf^i = char
cs>>CS.iChIn = i+1
resultis true
]


//---------------------------------------------------------------------------
and BackupChars(cs, backupWord) = valof
//---------------------------------------------------------------------------
//If backupWord is false, returns the index of the last character input.
//if true, returns the index of the first character of the current word.
[
let iCh = cs>>CS.iChIn
let pd = lv cs>>CS.pd^(FindPhrase(cs, iCh))
let nonBreakSeen = false
   [ //repeat
   let iNew = iCh-1
   if iCh eq pd>>PD.iFirst then
      [ //back up to previous phrase
      pd = pd-lenPD
      if pd eq lv cs>>CS.pd^0 then break
      iNew = pd>>PD.iLast
      ]
   unless backupWord resultis iNew
   test pd>>PD.WordBreak(cs, cs>>CS.buf>>Buf^iNew & #177)
      ifso if nonBreakSeen then break
      ifnot nonBreakSeen = true
   iCh = iNew
   ] repeat
resultis iCh
]

//---------------------------------------------------------------------------
and EraseInput(cs, i, context) be
//---------------------------------------------------------------------------
//Erases characters from the one most recently input back to i
//(inclusive) and resets the input pointer to the beginning of
//the erased portion.
[
if i ls cs>>CS.iChIn then cs>>CS.Erase(cs, i, cs>>CS.iChIn-1, context)
cs>>CS.iChIn = i
cs>>CS.iPhIn = FindPhrase(cs, i)
]


//---------------------------------------------------------------------------
and EraseBackTo(cs, i, context) be
//---------------------------------------------------------------------------
//Same as EraseInput;  additionally, if characters before the current
//phrase are erased, initiates a reparse of preceding phrases.
[
EraseInput(cs, i, context)
if cs>>CS.iPhIn ls cs>>CS.iPhOut then
   BackupPhrase(cs, cs>>CS.iPhOut-cs>>CS.iPhIn, editAppend)
]


//---------------------------------------------------------------------------
and FindPhrase(cs, iCh) = valof
//---------------------------------------------------------------------------
//Returns index of phrase to which character iCh belongs
[
let iPh = cs>>CS.iPhIn
while iCh ls cs>>CS.pd^iPh.iFirst do iPh = iPh-1
resultis iPh
]


//---------------------------------------------------------------------------
and RetypeCmd(cs) be
//---------------------------------------------------------------------------
[
Puts(cs>>CS.dspS, $*n)
for i = 0 to cs>>CS.iChIn-1 do
   [
   let char = cs>>CS.buf>>Buf^i
   if char ls #200 then Puts(cs>>CS.dspS, char)
   ]
]