// CmdScanAux.bcpl -- Auxiliary command scanner utilities
// Copyright Xerox Corporation 1979, 1981, 1982
// Last modified April 9, 1982 6:02 PM by Taft
get "cmdscan.decl"
external
[
// outgoing procedures
GetNumber; GetString; GetFile; Confirm; GetKeyword; KeywordHelp
// incoming procedures
GetPhrase; TerminatingChar; CurrentPhrase; AppendChar
LookupKeyword; EnumerateKeywordTable
DefaultArgs; Gets; Puts; Endofs; Errors; Wss; Wns
Allocate; Free; OpenFile; TruePredicate; FalsePredicate; Zero; DoubleAdd
]
structure String [ length byte; char↑1,255 byte ]
//---------------------------------------------------------------------------
let GetNumber(cs, radix, lvResult; numargs na) = valof
//---------------------------------------------------------------------------
// Interprets the next phrase as a signed or unsigned number in the specified
// radix (default 10). If lvResult is supplied, accepts a 32-bit number and
// stores it in @lvResult. In any event, returns the low-order 16 bits of
// the result.
[
let digit = nil
let myResult = vec 1
DefaultArgs(lv na, -1, 10, myResult)
// Frame offsets of above args and locals used by assembly language:
manifest [ oRadix = 5; olvResult = 6; oDigit = 8 ] // na is offset 7
let digitSeen = false
let negative = false
Zero(lvResult, 2)
GetPhrase(cs, 0, 0, 0, NumberHelp, radix)
until Endofs(cs) do
[
digit = Gets(cs)-$0
if digit uge radix then
[
if (digit eq $+-$0 % digit eq $--$0) & not digitSeen then
[ negative = digit eq $--$0; loop ]
Errors(cs, ecNonNumericChar)
]
digitSeen = true
if (table
[ // @lvResult = (@lvResult)*radix + digit with overflow check
#55001 // sta 3 1 2
#155000 // mov 2 3
#11400+olvResult // isz olvResult 3
#21400+oDigit // lda 0 oDigit 3
#27400+olvResult // lda 1 @olvResult 3
#31400+oRadix // lda 2 oRadix 3
#61020 // mul
#47400+olvResult // sta 1 @olvResult 3
#15400+olvResult // dsz olvResult 3
#27400+olvResult // lda 1 @olvResult 3
#61020 // mul
#47400+olvResult // sta 1 @olvResult 3
#171000 // mov 3 2
#35001 // lda 3 1 2
#1401 // jmp 1 3
])() ne 0 then Errors(cs, ecNumberOverflow)
]
unless digitSeen do Errors(cs, ecEmptyNumber)
if lvResult!0 ne 0 & lvResult eq myResult then Errors(cs, ecNumberOverflow)
if negative then
[
lvResult!0 = not lvResult!0; lvResult!1 = not lvResult!1
DoubleAdd(lvResult, table [ 0; 1 ])
]
resultis lvResult!1
]
//---------------------------------------------------------------------------
and NumberHelp(str, radix) be
//---------------------------------------------------------------------------
[
switchon radix into
[
case 10:
[ Wss(str, "decimal"); endcase ]
case 8:
[ Wss(str, "octal"); endcase ]
default:
[ Wss(str, "base "); Wns(str, radix) ]
]
Wss(str, " number")
]
//---------------------------------------------------------------------------
and GetString(cs, PhraseTerminator, Help, helpArg, Echo; numargs na) = valof
//---------------------------------------------------------------------------
// Returns the next phrase as a bcpl string
[
DefaultArgs(lv na, -1, 0, 0, 0, 0)
let n = GetPhrase(cs, 0, PhraseTerminator, Echo, Help, helpArg)
let s = Allocate(cs>>CS.zone, n rshift 1 +1)
s>>String.length = n
for i = 1 to n do s>>String.char↑i = Gets(cs)
resultis s
]
//---------------------------------------------------------------------------
and GetFile(cs, ksType, itemSize, versionControl, hintFp, errRtn, zone,
logInfo, disk; numargs na) = valof
//---------------------------------------------------------------------------
// Returns a stream for a file whose name is the next phrase.
// All arguments except the first are passed directly to OpenFile.
[
DefaultArgs(lv na, -1, 0, 0, 0, 0, 0, 0, 0, 0)
let string = GetString(cs, 0, Wss, "file name")
let stream = OpenFile(string, ksType, itemSize, versionControl, hintFp,
errRtn, zone, logInfo, disk)
Free(cs>>CS.zone, string)
if stream eq 0 then Errors(cs, ecCantOpenFile)
resultis stream
]
//---------------------------------------------------------------------------
and Confirm(cs, string; numargs na) = valof
//---------------------------------------------------------------------------
// Inputs and returns a true or false confirmation
[
if na gr 1 & string ne 0 then Wss(cs, string)
Wss(cs, " [Confirm] ")
GetPhrase(cs, TruePredicate, TruePredicate, FalsePredicate, Wss, "y or n")
switchon TerminatingChar(cs) into
[
case $Y: case $y: case $*n:
[ Wss(cs, "yes. "); resultis true ]
case $N: case $n:
[ Wss(cs, "no. "); resultis false ]
default:
Errors(cs, ecBadConfirmingChar)
]
]
//---------------------------------------------------------------------------
and GetKeyword(cs, kt, returnOnFail, PhraseTerminator; numargs na) = valof
//---------------------------------------------------------------------------
// Looks up phrase in keyword table kt and returns pointer to corresponding
// table entry. If returnOnFail is true, returns zero on failure.
// If an abbreviated keyword is recognized, appends the remainder of the
// keyword to the command line iff the terminating character did not echo.
[
DefaultArgs(lv na, -2, false, 0)
let key = GetString(cs, PhraseTerminator, KeywordHelp, kt)
let length = key>>String.length
let tableKey = nil
let entry = LookupKeyword(kt, key, lv tableKey)
Free(cs>>CS.zone, key)
if entry eq 0 then
test tableKey eq 0 % length eq 0 // ambiguous or outright failure?
ifso resultis returnOnFail? 0, Errors(cs, ecKeyNotFound)
ifnot Errors(cs, ecKeyAmbiguous)
if length ls tableKey>>String.length then
[
let char = TerminatingChar(cs)
unless CurrentPhrase(cs)>>PD.Echo(cs, char) do
[ // append tail of keyword as if it had been typed in
cs>>CS.iChIn = cs>>CS.iChIn-1
for i = length+1 to tableKey>>String.length do
Puts(cs, tableKey>>String.char↑i)
CurrentPhrase(cs)>>PD.iLast = cs>>CS.iChIn
AppendChar(cs, char, false)
]
]
resultis entry
]
//---------------------------------------------------------------------------
and KeywordHelp(str, kt) be
//---------------------------------------------------------------------------
[
Wss(str, "one of the following:*n")
let count, str1 = 0, str
EnumerateKeywordTable(kt, PrintKeyword, lv count)
]
//---------------------------------------------------------------------------
and PrintKeyword(entry, kt, key, lvCount) be
//---------------------------------------------------------------------------
[
let count = @lvCount
let str = lvCount!1
test count+key>>String.length gr 60
ifso [ Wss(str, ",*n"); count = 0 ]
ifnot if count ne 0 then [ Wss(str, ", "); count = count+2 ]
Wss(str, key)
@lvCount = count+key>>String.length
]