Forum libero

        include rc
        include text
        nameset text


        to From ByteString r    "binaural fn
        to From ByteString      "monaural fn
        
            creates a text object from a byte-aligned null-terminated string,
            such as those built by the compiler e.g. when you type @8:{ Hello! },
            or generally read from ASCII files (does not support UTF-8; another
            function will probably be developed for that, once someone provides
            means to render the characters outside the historical ASCII range...)

                --> m = firstByte       (byte select mask)
                --> n = R               (first unit in source buffer)
                --> p = r               (start address in source buffer)
                --> q                   (future start address in target buffer)
                --> r = 0               (source bytes counter, starts at zero)
                
                repeat if n has m       (as long as no null terminator found)

                        r + 1           (increment bytes counter)
                        m ] 8           (rotate mask, e.g. FF000000 -> 00FF0000)
                        
                        if m eq firstByte
                        
                                p + 1   (access next unit in source buffer)
                                n = P   (load new source buffer unit)

                <-- p                   (p = entry r, i.e. initial source address)

                q <- rc::Pick r Units   (q = target buffer)
                r <- rc::Size Of q      (r = back to abovely determined byte-size)
                
                --> q                   (will be returned to caller)
                --> v = firstByte       (free register v, use as byte select mask)
                
                m = 0                   (rotation magnitude, starts at zero)
                
                r times                 (each byte in source)

                        m + 8           (increase rotation: make that 8 for first byte)
                        n = P           (read current source unit)
                        n & v           (mask off all bytes except the relevant one)
                        n [ m           (rotate the relevant byte to its place, i.e...)
                        Q = n           (left-most of the target unit, hereby written)
                        
                        if m eq bitsPerUnit
                        
                                p + 1   (full circle? ok, access next unit in source)
                                m = 0   (and reset rotation magnitude)

                        q + 1           (access next unit in target buffer)
                        v ] 8           (rotate mask, e.g. FF000000 -> 00FF0000)
                
                <-- v                   (restore v - it's callers' vicinity pointer)
                <-- r                   (we had stacked target buffer before v)
                <-- q                   (callee-saved)
                <-- p                   (callee-saved)
                <-- n                   (callee-saved)
                <-- m                   (callee-saved)
                
                return r                (we return the target buffer address)

	startup displayStatus engage
	include text fromByteString
	include text say
	include util pause


	to Begin

		text::From ByteString @8:{ Hello } -> Say

		each P inside \

		[

			@8:{ _Mercury		},
			@8:{ _Venus		},
			@8:{ _Earth		},
			@8:{ _Mars		},
			@8:{ _Jupiter		},
			@8:{ _Saturn		},
			@8:{ _Uranus		},
			@8:{ _Neptune		},
			@8:{ _and_maybe_Pluto	}

		]

			text::From ByteString P -> Say

		util::Pause
		leave