//MIOC.BCPL

get "mdecl.d"

external [
// OS
Puts; Zero

// MIDAS
PutField; GetField

// MSYM
EvalAText

// MCMD
DisplayError

// Machine Dependent
@MEMFORMS; @REGFORMS; @REGWID; @MEMWID; AltRForms; AltMForms

// Defined here
RTexttoData; MTexttoData; SimpleTexttoDVec
RDatatoStream; MDatatoStream; SimpleDVectoStream
]

//Subroutines for converting TextVec’s to DataVec’s.
//RTexttoData(RegX,TextVec,DataVec) and MTexttoData(RegX,TextVec,DataVec)
//convert a TextVec to a DataVec where the width is gotten from the table
//of register widths or of memory widths, respectively. These routines
//use SimpleTexttoDVec(TextVec,NBits,DataVec) to do the work.

//GenlTexttoDVec(TextVec,Form,DataVec) is not presently used.

let RTexttoData(RegX,TV,DVec) be SimpleTexttoDVec(TV,REGWID!RegX,DVec)


and MTexttoData(MemX,TV,DVec) be SimpleTexttoDVec(TV,MEMWID!MemX,DVec)


and SimpleTexttoDVec(TV,NBits,DVec) be
[let Bit1 = NBits-3
Zero(DVec,(NBits+15) rshift 4)
if TV!0 eq 0 then return
for I = TV!0 to 1 by -1 do
[ let X = TV!I
if X ne $ do
[ if (X < $0) % (X > $7) do
[ Zero(DVec,(NBits+15) rshift 4)
let AVal = vec size AVal/16; X = 1
if EvalAText(TV,lv X,AVal,false) then
[ if AVal>>AVal.TypeStorage eq MemTypeStorage do
[ let SBit1,DBit1,MBits = nil,nil,nil
test NBits ge 32
ifso [ SBit1,DBit1,MBits = 0,NBits-32,32 ]
ifnot [ SBit1,DBit1,MBits = 32-NBits,0,NBits ]
MoveLongField(lv AVal>>AVal.Addr,SBit1,MBits,DVec,DBit1)
return
]
]
DisplayError("Bad value")
]
test Bit1 < 0
ifso
[ let T = Bit1+3; if T > 0 then
PutField(0,T,DVec,(X-$0) & (table [ 1; 3; 7 ] !T))
return
]
ifnot [ PutField(Bit1,3,DVec,X-$0); Bit1=Bit1-3 ]
]
]
]

//and GenlTexttoDVec(TV, Form, DVec) be
//[let Field,Ngrps,InGap = vec 5,0,true
//Count the groups
//for I = 1 to TV!0 do
// test InGap
// ifso
//if TV!I ne $ then
//[ InGap = false; Ngrps = Ngrps+1 ]
// ifnot
//if TV!I eq $ then InGap = true
//if Ngrps > Form!0 then Ngrps = Form!0

// now put out initial missing groups
//let FormX = 1
//Zero(Field,6)
//for I = 1 to Form!0 - Ngrps do
//[ MoveLongField(Field,0,Form!(FormX+1),DVec,Form!FormX)
// FormX = FormX+2
//]

// now handle groups with text
//let TVX = 1
//for I = Form!0-Ngrps+1 to Form!0 do
//[ let TempTV = vec 30
// while TV!TVX eq $ do TVX = TVX+1
// let X = 0
// while TV!TVX ne $ logand TVX le TV!0 do
// [ X = X+1
// if X le 30 then TempTV!X = TV!TVX
// TVX = TVX+1
// ]
// TempTV!0 = X
// SimpleTexttoDVec(TempTV, Form!(FormX+1), Field)
// MoveLongField(Field,0,Form!(FormX+1),DVec,Form!FormX)
// FormX = FormX+2
//]
//]

//RDatatoStream(Stream,RegX,DataVec) and MDatatoStream(Stream,MemX,DataVec)
//are used, respetively, for outputting register values and memory values
//to a stream. The format table for the register or memory is obtained
//from REGFORMS or MEMFORMS. If this is 0, then SimpleDVectoStream is
//used to output a right-justified octal string with leading blank fill
//of a size equal to the width of the register/3. If the REGFORMS or
//MEMFORMS entry is not 0, then GenlDVectoStream is used to do the work.

//GenlDVectoStream accepts a format table whose first entry is the
//number of format groups. This is followed by pairs of integers
//which stand for the left-bit in the DataVec for a group and the
//number of bits in the group.

//SimpleDVectoStream accept a fill character as its last argument.
//If this character is 0, then no fillers are output for leading zeroes
//in the output. The value of the output is the original fill character
//if all of the NBits are 0; otherwise it is 60B = "0". If the fill
//character is 40B = " ", then blank fill is used; if 60B = "0" then
//0-fill is used.

//Note: Leading blanks must be suppressed for mmprgn.bcpl


and RDatatoStream(Stream,RegX,DVec) be
[test REGFORMS!RegX eq 0
ifso RegX = SimpleDVectoStream(Stream,REGWID!RegX,DVec,0,true)
ifnot GenlDVectoStream(Stream,REGFORMS!RegX,DVec)
]

and MDatatoStream(Stream,MemX,DVec) be
[test MEMFORMS!MemX eq 0
ifso MemX = SimpleDVectoStream(Stream,MEMWID!MemX,DVec,0,true)
ifnot GenlDVectoStream(Stream,MEMFORMS!MemX,DVec)
]

and SimpleDVectoStream(Stream,NBits,DVec,flush0,LastFlag) = valof
[let Bit1,Size1,Byte = 0,NBits rem 3,nil
if Size1 eq 0 then Size1 = 3
while Bit1 < NBits-3 do
[ Byte = GetField(Bit1,Size1,DVec)
if Byte ne 0 then flush0 = $0
if flush0 ne 0 then Puts(Stream,Byte+flush0)
Bit1 = Bit1+Size1; Size1 = 3
]
Byte = GetField(Bit1,Size1,DVec)
if Byte ne 0 then flush0 = $0
if (flush0 ne 0) % LastFlag then Puts(Stream,Byte+$0)
resultis flush0
]

and MoveLongField(Source,SBit1,NBits,Dest,DBit1) be
[while NBits ge 16 do
[ PutField(DBit1,16,Dest,GetField(SBit1,16,Source))
DBit1,SBit1,NBits = DBit1+16,SBit1+16,NBits-16
]
if NBits > 0 then
PutField(DBit1,NBits,Dest,GetField(SBit1,NBits,Source))
]

and GenlDVectoStream(Stream,Form,DVec) be
[let Field,Foo,flush0 = vec 5,(Form!0)+(Form!0)-1,0
for FormX = 1 to Foo by 2 do
[ if (FormX > 1) & (flush0 ne 0) then Puts(Stream,$ )
MoveLongField(DVec,Form!FormX,Form!(FormX+1),Field,0)
flush0 = SimpleDVectoStream(Stream,Form!(FormX+1),Field,
flush0,((FormX eq Foo) ? true,false))

]
]