cattle_tape_new ()

CattleTape *
cattle_tape_new (void);

Create and initialize a new memory tape.

cattle_tape_set_current_value ()

void
cattle_tape_set_current_value (CattleTape *tape,
                               gchar value);

Set the value of the current cell.

Accepted values are ASCII values or EOF.

cattle_tape_get_current_value ()

gchar
cattle_tape_get_current_value (CattleTape *tape);

Get the value of the current cell. See cattle_tape_set_current_value().

cattle_tape_increase_current_value ()

void
cattle_tape_increase_current_value (CattleTape *tape);

Increase the value in the current cell by one.

If the value in the current cell has ASCII code 127, the new value will have ASCII code 0.

cattle_tape_increase_current_value_by ()

void
cattle_tape_increase_current_value_by (CattleTape *tape,
                                       gint value);

Increase the value in the current cell by value .

The value is wrapped if needed to keep it in the ASCII code.

Increasing the value this way is much faster than calling cattle_tape_increase_current_value() multiple times.

cattle_tape_decrease_current_value ()

void
cattle_tape_decrease_current_value (CattleTape *tape);

Decrease the value in the current cell by one.

If the value in the current cell has ASCII value 0, the new value will have ASCII value 127.

cattle_tape_decrease_current_value_by ()

void
cattle_tape_decrease_current_value_by (CattleTape *tape,
                                       gint value);

Decrease the value in the current cell by value .

The value is wrapped if needed to keep it in the ASCII code.

Decreasing the value this way is much faster than calling cattle_tape_decrease_current_value() multiple times.

cattle_tape_move_left ()

void
cattle_tape_move_left (CattleTape *tape);

Move tape one cell to the left.

If there are no memory cells on the left of the current one, one will be created on the fly.

cattle_tape_move_left_by ()

void
cattle_tape_move_left_by (CattleTape *tape,
                          gint steps);

Move tape steps cells to the left.

Moving this way is much faster than calling cattle_tape_move_left() multiple times.

cattle_tape_move_right ()

void
cattle_tape_move_right (CattleTape *tape);

Move tape one cell to the right.

If there are no memory cells on the right of the current one, one will be created on the fly.

cattle_tape_move_right_by ()

void
cattle_tape_move_right_by (CattleTape *tape,
                           gint steps);

Move tape steps cells to the right.

Moving this way is much faster than calling cattle_tape_move_right() multiple times.

cattle_tape_is_at_beginning ()

gboolean
cattle_tape_is_at_beginning (CattleTape *tape);

Check if the current cell is the first one of tape .

Since the tape grows automatically as more cells are needed, it is possible to move left from the first cell.

cattle_tape_is_at_end ()

gboolean
cattle_tape_is_at_end (CattleTape *tape);

Check if the current cell is the last one of tape .

Since the tape grows automatically as more cells are needed, it is possible to move right from the last cell.

cattle_tape_push_bookmark ()

void
cattle_tape_push_bookmark (CattleTape *tape);

Create a bookmark to the current tape position and save it on the bookmark stack.

cattle_tape_pop_bookmark ()

gboolean
cattle_tape_pop_bookmark (CattleTape *tape);

Restore the previously-saved tape position. See cattle_tape_push_bookmark().

struct CattleTape

struct CattleTape;

Opaque data structure representing a memory tape. It should never be accessed directly; use the methods below instead.

The “current-value” property

  “current-value”            gchar

Value of the current cell.

Changes to this property are not notified.

Flags: Read / Write

Allowed values: >= -1

Default value: 0