[Overview][Constants][Types][Procedures and functions][Variables][Index] | Reference for unit 'go32' (#rtl)

# dosmemfillchar

Fill a region of DOS memory with a specific byte-sized value

## Declaration

Source position: go32.pp line 208

`const dosmemfillchar: procedure( = @ dpmi_dosmemfillchar;`
`seg: Word;`
`ofs: Word;`
`count: LongInt;`
`c: Char`
`)`

## Description

Sets a region of dos memory to a specific byte value.

Parameters:

seg
  real mode segment.
ofs
  real mode offset.
count
  number of bytes to set.
c
  value to set memory to.

Notes: No range check is performed.

## Errors

None.

## See also

dosmemput |  | Copy data from the heap to DOS real mode memory
dosmemget |  | Copy data from DOS memory to the heap.
dosmemmove |  | Move data between 2 DOS real mode memory locations
dosmemfillword |  | Fill a region of DOS memory with a specific word-sized value
seg_move |  | Move data between 2 locations
seg_fillchar |  | Fill segment with byte value
seg_fillword |  | Fill segment with word value

## Example

    { This example copies around some blocks of memory in DOS memory
    space.

    In more detail, the program copies a string randomly to the text
    mode screen. Aditionally it messes around a bit with the color
    attributes of the string.
    Before doing this it saves the entire screen contents to the heap
    and restores it afterwards.

    Some additional background:

    The text screen of a VGA card has it's address space at $B800:0;
    screen memory is organized in a linear fashion, e.g. the second line
    comes directly after the first, where each cell occupies 2 bytes of
    memory (1 byte character data, 1 byte attributes). It is 32 kb in
    size.

    Hence the offset of a single memory cell from its origin is:

    Y*columns*2 + X*2

    where X and Y mark the point and columns is the number of character
    cells per line
    }

    uses
            crt,
            go32;

    const
            { number of columns on screen }
            columns = 80;
            { number of rows on screen }
            rows = 25;
            screensize = rows*columns*2;

            { sample text string }
            text = '! Hello world !';

    var
            textofs : Longint;
            { this variable holds the entire screen contents }
            save_screen : array[0..screensize-1] of byte;
            { These two hold the previous cursor coordinates }
        curx, cury : Integer;

    begin
            randomize;
            { save screen contents to save_screen variable }
            dosmemget($B800, 0, save_screen, screensize);
            { save current cursor coordinates }
            curx := wherex; cury := wherey;
            { This is our demo text }
            gotoxy(1, 1); Write(text);
            { calculate the address in offscreen memory (to be sure it will
            not be overwritten by the copy process later, we don't put it
            exactly at the end of the visible screen area) }
            textofs := screensize + length(text)*2;
            { copy it to offscreen memory }
            dosmemmove($B800, 0, $B800, textofs, length(text)*2);
            { clear the screen by writing zeros on the whole visible screen}
            dosmemfillchar($B800, 0, screensize, #0);
            while (not keypressed) do begin
                    { set the attribute field (byte 2 of every cell) of the
                    text in offscreen memory to random values }
                    dosmemfillchar($B800, textofs + random(length(text))*2 + 1,
                            1, char(random(255)));
                    { copy the string from offscreen to visibly screen by calculating
                    it's destination address randomly }
                    dosmemmove($B800, textofs, $B800,
                            random(columns)*2+random(rows)*columns*2,
                            length(text)*2);
                    { small delay, else it is too fast }
                    delay(1);
            end;
            { clear the keyboard buffer }
            readkey;
            { wait for a keypress }
            readkey;
            { restore old screen contents afterwards }
            dosmemput($B800, 0, save_screen, screensize);
            gotoxy(curx, cury);
    end.

Documentation generated on: May 14 2021