Kryptostack
Operators Section Analogous

Intenionally cloned red book implementations.

This operators are entries in the systemdict dictionary.

]

Stack:
$ M\ X_1\ ...\ X_n\ --\ A $

Red book operator creates an array from operand stack.

>>

Stack:
$ M\ X_1\ ...\ X_n\ --\ D $

Red book operator creates a dictionary from operand stack.

}

Stack:
$ M\ X_1\ ...\ X_n\ --\ a $

Red book operator creates a procedure from operand stack.

=

Stack:
$ X\ -- $

Red book operator pops an object from the operand stack, produces a text representation of that
object’s value, and writes the result to the standard output, followed by a new line.
The text is that produced by the cvs operator.

==

Stack:
$ X\ -- $

Red book operator pops an object from the operand stack, produces a text representation of that object,
and writes the result to the standard output, followed by a new line.
This operator attempts to produce a result that resembles the red book syntax for creating the object.

{

Stack:
$ --\ M $

Red book begin procedure operator.

abs

Stack:
$ z\ --\ z $

Red book operator returns the absolute value of n. The type of the result is
the same as the type of z unless z is the smallest integer, in which case the result is a real number.

Type Conversion:
Implicit if I is equal to MIN_INT then conversion takes place I to R

aload

Stack:
$ A|a\ --\ X_1\ ...\ X_n\ A|a $

Successively pushes all n elements of the array A on the operand stack
(where n is the length of A), and then pushes the operand itself.

anchorsearch

Stack:
$ S_{str}\ S_{seek}\ --\ S_{post}\ S_{match}\ B_{true} $
$ S_{str}\ S_{seek}\ --\ S_{str}\ B_{false} $

Red book operator determines whether the string seek matches the initial substring of str.
If it matches, anchorsearch splits string into two segments
match, the portion of str that matches seek, and post, the remainder of str
and returns the string objects post and match followed by the boolean value true.
Otherwise, it returns the original str followed by false. anchorsearch is a special case of the search operator.

and

Stack:
$ B\ B\ --\ B $
$ I\ I\ --\ I $

Logical conjunction for B operands or bitwise "and" for I operands.

array

Stack:
$ I\ --\ A $

Red book operator creates an array of length I, each of whose elements is initialized with a null object.
The I operand must be nonnegative.

astore

Stack:
$ X_0\ ...\ X_{n-1}\ A|a\ --\ A|a $

Red book operator stores the objects $ X_0 $ to $ X_{n-1} $ from the operand stack into array,
where n is the length of A|a.

begin

Stack:
$ D\ -- $

Red book operator pushes D on the dictionary stack, making it the current dictionary.

bitshift

Stack:
$ I_1\ I_2\ --\ I $

Red book operator shifts the binary representation of $ I_1 $ left by $ I_2 $ bits and returns the result.

ceiling

Stack:
$ z\ --\ z $

Returns the least integer value greater than or equal to z.

clear

Stack:
$ \rangle\ X\ ...\ X\ -- $

Red book operator pops all objects from operator stack.

cleardictstack

Stack:
$ -- $

Red book operator pops all nonpermanent dictionaries off dictionary stack.

cleartomark

Stack:
$ M\ X\ ...\ X\ -- $

Red book operator pops all objects from operator stack until it encounters a mark, which is also pops.

count

Stack:
$ \rangle\ X_1\ ...\ X_I\ --\ \rangle\ X_1\ ...\ X_I\ I $

Red book operator counts objects on the operand stack.

countdictstack

Stack:
$ --\ I $

Red book operator counts the number of dictionaries currently on the dictionary stack.

countexecstack

Stack:
$ --\ I $

Red book operator counts objects on the execution stack.

counttomark

Stack:
$ --\ I $

Red book operator counts the number of objects on the operand stack, starting with the top element
and continuing down to but not including the first mark encountered.

currentdict

Stack:
$ --\ D $

Red book operator pushes the current dictionary (the dictionary on the top of the dictionary stack)
onto the operand stack. currentdict does not pop the dictionary stack; it just pushes
a duplicate of its top element on the operand stack.

cvlit

Stack:
$ X\ --\ X $

Makes object non-executable aka literal.

cvn

Stack:
$ S\ --\ N $

Converts a string to a name object.

Type Conversion:
Explicit conversion from S to N|n.

cvs

Stack:
$ X\ S\ --\ S $

Creates a string representation of X and stores it at the beginning of S.
Pushes a new String with the representation onto the stack.

cvx

Stack:
$ X\ --\ X $

Makes object executable.

def

Stack:
$ X_{key}\ X_{value}\ -- $

Red book operator associates key and value in the current dictionary.

dict

Stack:
$ I\ --\ D $

Red book operator generates a dictionary. The size value I will be ignored.

dictstack

Stack:
$ A|a\ --\ A|a $

Copies the dictionary stack into an array.

See also
dictstack$

div

Stack:
$ z_1\ z_2\ --\ R$

Red book operator divides $ z_1 $ by $ z_2 $,
producing a result that is always a R even if both operands are I.
Use idiv instead if the operands are I and an I result is desired.

See also
idiv

dup

Stack:
$ X\ --\ X\ X $

Red book operator duplicates the top object X on the operand stack. dup copies only the object;
the value of a composite object is not copied but is shared.

end

Stack:
$ -- $

Red book operator pops the current dictionary off dictionary stack,
but throws a dictstackunderflow, if there are only 3 dictionaries left on the stack.

exch

Stack:
$ X_1\ X_2\ --\ X_2\ X_1 $

Exchanges the top two objects on the operand stack.

execstack

Stack:
$ A|a\ --\ A|a $

Copies execution stack into an array.

See also
execstack$

exit

Stack:
$ -- $

Terminates execution of the innermost, dynamically enclosing
instance of a looping context without regard to lexical relationship.
A looping context is a procedure invoked repeatedly by one of the
following control operators:

  • for
  • forall
  • loop
  • repeat

exit pops the execution stack down to the level of that operator.
The interpreter then resumes execution at the next object in normal
sequence after that operator.

exit does not affect the operand stack or dictionary stack.
Any objects pushed on these stacks during execution of the looping
context remain after the context is exited.

exp

Stack:
$ z_{base}\ z_{exponent}\ --\ R $

Red book operator exp raises base to the exponent power.
If the exponent has a fractional part, the result is meaningful only
if the base is nonnegative. The result is always a R.

floor

Stack:
$ z\ --\ z $

Returns the greatest integer value less than or equal to z.

get

Stack:
$ A|a|K|S\ I\ --\ X $
$ D\ X\ --\ X $

Red book operator returns a single element from the value of the first operand.
If the first operand is an array, stack or a string, get treats the second operand as an index and returns the element identified by I,
counting from 0. I must be in the range 0 to n - 1, where n is the length of the array, stack or string.
If the first operand is a dictionary, get looks up X as a key in the dictionary and returns the associated value.

getinterval

Stack:
$ A|S\ I_{index}\ I_{count}\ --\ A|S $

Red book operator creates a new array or string object whose value consists of some subsequence of the original array or string.
The subsequence consists of count elements starting at the specified index in the original object.
The elements in the subsequence array are shared between the original and new array.

idiv

Stack:
$ I_1\ I_2\ --\ I $

Red book operator divides $ I_1 $ by $ I_2 $ and returns
the I part of the quotient, with any fractional part discarded. Both operands
of idiv must be I and the result is an I.

if

Stack:
$ B\ a\ -- $

Red book operator removes both operands from the stack,
then executes proc if bool is true. The if operator pushes no results
of its own on the operand stack, but proc may do so.

ifelse

Stack:
$ B\ a_1\ a_2\ -- $

Red book operator removes all three operands from the stack,
then executes $ a_1 $ if B is true or $ a_2 $ if B is false.
The ifelse operator pushes no results of its own on the operand stack,
but the procedure it executes may do so.

index

Stack:
$ X_I\ ...\ X_1\ X_0\ I\ --\ X_I\ ...\ X_1\ X_0\ X_I $

Red book operator removes the I from the operand stack, counts down
to the I-th element from the top of the stack, and pushes a copy of that
element on the stack.

known

Stack:
$ D\ X_{key}\ known\ B $

Red book operator tests whether key is in D.

ln

Stack:
$ z\ --\ R $

Red book operator ln returns the natural logarithm of z.
The result is a real number.

load

Stack:
$ X_{key}\ --\ X_{value} $

Red book operator searches dictionary stack for $ X_{key} $ and returns associated $ X_{value} $.
Results in an undefined error, if $ X_{key} $ can not be found.

log

Stack:
$ z\ --\ R $

Red book operator log returns the logarithm base 10 of z.
The result is a real number.

mark

Stack:
$ --\ M $

Pushes a mark object onto the operand stack.

[

Stack:
$ --\ M $

Pushes a mark object onto the operand stack.

<<

Stack:
$ --\ M $

Pushes a mark object onto the operand stack.

neg

Stack:
$ z_1\ --\ z_2 $

returns the negative of $ z_1 $. The type of the result is the same as the type of $ z_1 $
unless $ z_1 $ is equal to MIN_INT, in which case the result is a R.

Type Conversion:
Implicit if $ z_1 $ is equal to MIN_INT then conversion takes place I to R.

not

Stack:
$ B\ --\ B $
$ I\ --\ I $

returns the logical negation of the operand if it is B. If the operand is an
I, not returns the bitwise complement (ones complement) of its binary representation.

or

Stack:
$ B\ B\ --\ B $
$ I\ I\ --\ I $

returns the logical disjunction of the operands if they are B. If the operands
are I, or returns the bitwise "inclusive or" of their binary representations.

print

Stack:
$ S\ -- $

Red book operator prints S. S will be poped from the stack. No extra new line will be printed.

See also
__print

pstack

Stack:
$ -- $

printes text representations of every object on the stack,
but leaves the stack unchanged. pstack applies the == operator to each element
of the stack, starting with the topmost element.

put

Stack:
$ A|a|K\ I\ X\ -- $
$ S\ I\ I\ -- $
$ D\ X_{key}\ X_{any}\ -- $

Red book operator replaces a single element of the value of the first operand.
If the first operand is an array, stack or a string, put treats the second
operand as an index and stores the third operand at the position identified
by the index, counting from 0. I must be in the range 0 to n - 1, where n is
the length of the array, stack or string. If the first operand is a
dictionary, put uses the second operand as a key and the third operand
as a value, and stores this key-value pair into dict. If key is already
present as a key in dict, put simply replaces its value by $ X_{any} $.
Otherwise, put creates a new entry for key and associates $ X_{any} $ with it.

putinterval

Stack:
$ A_1\ I\ A_2\ --\ $
$ S_1\ I\ S_2\ --\ $

Red book operator replaces a subsequence of the elements of
the first operand by the entire contents of the third operand.
The subsequence that is replaced begins at index I in the first operand;
its length is the same as the length of the third operand.
The objects are copied from the third operand to the first,
as if by a sequence of individual get and put operations.

pop

Stack:
$ X\ -- $

removes the top element from the operand stack and discards it.

rand

Stack:
$ --\ I $

Red book operator returns a random I in the range 0 to $ 2^{31} - 1 $,
produced by a pseudo-random number generator.
The random number generator’s state can be reset by srand and interrogated by rrand.

See also
rrand srand

realtime

Stack:
$ --\ I $

Red book operator returns the value of a clock that counts in real time.
independently of the execution of the interpreter. The unit of time is one millisecond.
We use the Unix epoch as the starting point, deviating from the red book definition.

roll

Stack:
$ X_{I-1}\ ...\ X_0\ I\ J\ --\ X_{(J-1)\ mod\ I}\ ...\ X_0\ X_{I-1}\ ...\ X_{J\ mod\ I} $

Performs a circular shift of the objects $ X_{I-1} $
through $ X_0 $ on the operand stack by the amount J.

round

Stack:
$ z\ --\ z $

Returns the integer value nearest to z. If z is equally close to its
two nearest integers, round returns the greater of the two.

rrand

Stack:
$ --\ I $

Red book operator returns an I representing the current state
of the random number generator used by rand. This may later be presented
as an operand to srand to reset the random number generator
to the current position in the sequence of numbers produced.

See also
rand srand

search

Stack:
$ S_{str}\ S_{seek}\ --\ S_{post}\ S_{match}\ S_{pre}\ B_{true} $
$ S_{str}\ S_{seek}\ --\ S_{str}\ B_{false} $

Red book operator looks for the first occurrence of the string $ S_{seek} $ within $ S_{str} $ and
returns the results of this search on the operand stack.
The topmost result is a boolean literal that indicates whether the search succeeded.

If search finds a subsequence of $ S_{str} $ whose elements are equal to the elements of $ S_{seek} $,
it splits $ S_{str} $ into three segments:

  • $ S_{pre} $: the portion of string preceding the match,
  • $ S_{match} $: the portion of $ S_{str} $ that matches $ S_{seek} $ and
  • $ S_{post} $: the remainder of $ S_{str} $.

It then pushes the string objects $ S_{post} $, $ S_{match} $, and $ S_{pre} $ on the operand stack,
followed by the boolean literal true.

If search does not find a match, it pushes the original $ S_{str} $ followed by false.

sqrt

Stack:
$ z\ --\ R $

Square root.

srand

Stack:
$ I\ -- $

Red book operator initializes the random number generator with the seed int, which may be any I value.
Executing srand with a particular value causes subsequent invocations of rand to generate a reproducible sequence of results.
The random number state is maintained separately for each Context.

See also
rand rrand

stack

Stack:
$ -- $

Red book operator prints text representations of every object on the stack,
but leaves the stack unchanged. stack applies the = operator to each element of the
stack, starting with the topmost element.

store

Stack:
$ X_{key}\ X_{value}\ -- $

Replace topmost definition of key.
Changes to systemdict and kryptodict are possible.

string

Stack:
$ I\ --\ S $

Red book operator creates a string of length I, each of whose elements is initialized with the integer 0,
and pushes this string on the operand stack.

truncate

Stack:
$ z\ --\ z $

Truncates z toward 0 by removing its fractional part.

type

Stack:
$ X\ --\ N $

Red book operator returns a N that identifies the type of X.

undef

Stack:
$ D\ X_{key}\ -- $

Red book operator removes key and its value from D.

usertime

Stack:
$ --\ I$

Red book operator returns the value of a clock that is incremented by 1
for every millisecond of execution by the interpreter.

where

Stack:
$ X\ --\ D\ true $
$ X\ --\ false $

Red book operator determines which dictionary on the dictionary stack, if any,
contains a key whose name is X.

xcheck

Stack:
$ X\ --\ B$

Returns the executable attribute of X as B.

xor

Stack:
$ B\ B\ --\ B $
$ I\ I\ --\ I $

returns the logical “exclusive or” of the operands if they are boolean. If the operands
are integers, xor returns the bitwise “exclusive or” of their binary representations.

Generated by doxygen 1.9.4