Return to mipsreal.nw CVS log

Up to [Research Unix] / researchv10no / cmd / sml / src / mips

Annotation of researchv10no/cmd/sml/src/mips/mipsreal.nw, revision 1.1

1.1     ! root        1: \subsection{Handling IEEE floating point constants}
        !             2: Here we take care of converting floating point constants from
        !             3: string representation to 64-bit IEEE representation.
        !             4: We use the machinery developed for the Sparc by John Reppy.
        !             5: 
        !             6: Reppy's functor accepts a simple structure with a single value,
        !             7: [[emitWord : int -> unit]], which emits a 16-bit word.
        !             8: It produces a [[PRIMREAL]].
        !             9: When [[RealConst]] is applied to the result, it produces a 
        !            10: structure containing a single function, [[val realconst : string -> unit]].
        !            11: This function, when applied to a string, emits the four sixteen-bit words
        !            12: of the IEEE representation, most significant first.
        !            13: 
        !            14: Our job will be to convert this to something that emits the two 32-bit
        !            15: words of the constant, least significant word first.
        !            16: First, let's consider the state information that has to be retained
        !            17: while the halfwords are being emitted, and functions that change that state.
        !            18: <<state info>>=
        !            19: val halfwords = ref nil : int list ref         (* halfwords already out *)
        !            20: val count = ref 0                              (* length of halfwords *)
        !            21: fun reset_state () = (halfwords := nil; count := 0)
        !            22: fun add_half h = (count := !count + 1; halfwords := h :: (!halfwords))
        !            23: 
        !            24: <<emitting a halfword>>=
        !            25: fun emit_half h = 
        !            26:     if !count = 3 then (emit_four (h::(!halfwords)); reset_state())
        !            27:     else add_half h
        !            28: 
        !            29: @ To emit the whole list, we have to emit the words, one at a time.
        !            30: We use descriptive names to remind ourselves what is signficant
        !            31: (highest is most significant).
        !            32: <<emitting four halfwords>>=
        !            33: fun emit_four [lowest,low,high,highest] = 
        !            34:                        (emit_word(low,lowest);emit_word(highest,high))
        !            35:   | emit_four _ = ErrorMsg.impossible "bad floating pt constant in mips"
        !            36: 
        !            37: @ Now, we bundle up the whole thing in a functor that
        !            38: gets passed a structure holding [[emit_word]] and returns 
        !            39: one containing [[realconst]].
        !            40: <<*>>=
        !            41: functor MipsReal(E: sig val emit_word : int * int -> unit end) : REALCONST = 
        !            42: struct
        !            43:     open E
        !            44:     <<state info>>
        !            45:     <<emitting four halfwords>>
        !            46:     <<emitting a halfword>>
        !            47:     structure IEEERealConst =
        !            48:        RealConst(IEEEReal(struct val emitWord = emit_half end))
        !            49:     val realconst = IEEERealConst.realconst
        !            50: end
        !            51: 
        !            52: 
        !            53: 
        !            54: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.