IntToString doesn't support negative numbers

[hlabrand]

As it currently stands, IntToString doesn't support negative numbers, i.e. doesn't print a minus sign in front of the integer. This should be changed.

(To be honest, the function is really not optimal; instead of a for loop, why not a while? Then we wouldn't have to compute the number of leading zeros to trim...)

[Natrium729]

I may be misunderstanding something, but IntToString simply stringifies the number, right? So why not just print the number directly into the array?

I haven't tested the following in the context of Vorple, but it works in a bare Inform project (there may be edge cases I forgot).

! 10 for the length of the biggest Glulx number + 1 for the minus sign.
Constant Vorple_intarraylength = 11; 

! A simple byte array because the minus sign and digits characters are all less than 256.
! Plus 1 because the zeroth entry will contain the length (which will also always be less than 256).
Array integer -> Vorple_intarraylength + 1;

! Glk will write the read and write counts into this array.
Array integer_result --> 2;

[ IntToString num  saved_stream integer_stream;
    ! Save the current stream.
    saved_stream = glk($48); ! glk_stream_get_current

    ! Open a memory stream pointing to the integer array.
    ! We add 1 to the array address to skip the zeroth entry, where we will write the length.
    integer_stream = glk($43, integer + 1, Vorple_intarraylength, $1, 0); ! glk_stream_open_memory with writing mode and a rock of 0.

    ! Set the current stream to the newly opened one.
    glk($47, integer_stream); ! glk_stream_set_current

    ! Print the number.
    print num;

    ! Set back the current stream to the saved one.
    glk($47, saved_stream); ! glk_stream_set_current

    ! Close the integer stream and put its read and write counts into the integer_result array.
    glk($44, integer_stream, integer_result); ! glk_stream_close

    ! Set the zeroth entry of the integer array to the write count.
    integer->0 = integer_result-->1;

    return integer;
];

[ Main int i;
    int = IntToString(-729);
    for (i=1 : i<=int->0 : i++) {
        print (char) int->i;
    }
];

integer_result is needed because that's how Glk works, but we also put the length of the string in the zeroth entry of integer so that all that a user needs is in a single place. In the case it's OK to have the length of the string in a separate array, we can remove all the + 1 needed to skip the zeroth entry.

Finally, if we call the routine with a big number then a small number, I think the end of the big number will be remain in the integer array. We could fill the end of the array with zeroes, but since we have the length I think it's OK if we just let it be.

[Natrium729]

Looking closer at the repository, I see that it includes InfGlk.h, so you can replace my manual glk() calls with the corresponding functions from InfGlk, it'll be clearer.

Or actually, since Vorple also includes bp_output_stream from JustEnoughGlulx, you could just replace my glk() calls with it:

! 10 for the length of the biggest Glulx number + 1 for the minus sign.
Constant Vorple_intarraylength = 11; 
Array integer buffer Vorple_intarraylength;

[ IntToString num;
    ! Open memory stream.
    bp_output_stream(3, integer, Vorple_intarraylength);

    ! Print the number.
    print num;

    ! Close the memory stream.
    bp_output_stream(-3);

    return integer;
];

However, I must say I'm not a fan of the big monolithic bp_output_stream that was design to mimic the Z-machine @output_stream opcode. Since it's only used by Vorple for memory streams (with argument 3), it can easily be removed and replaced by smaller routines that do the same thing. (And since it seems the calls never nest, you don't need an array to track previous current streams, only one variable is enough.) Also, bp_output_stream can't open Unicode memory streams, which could be useful when printing Unicode characters.

But that should go in another issue!