text:
<!DOCTYPE html>

    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>PyshGP Core Instruction Set — PyshGP 0.1.8 documentation</title>
    <link rel="stylesheet" href="_static/nature.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />

    <link rel="index" title="Index" href="genindex.html" />
    <link rel="search" title="Search" href="search.html" />
    <link rel="next" title="Push Types" href="push_types.html" />
    <link rel="prev" title="Push Instructions" href="instructions.html" />

Navigation

          index

          modules |

          next |

          previous |

PyshGP 0.1.8 documentation »

Push Instructions »

PyshGP Core Instruction Set

PyshGP Core Instruction Set¶

int_add¶

Takes: [int, int] - Produces: [int]

Adds the top two ints and pushes the result.

int_sub¶

Takes: [int, int] - Produces: [int]

Subtracts the top two ints and pushes the result.

int_mult¶

Takes: [int, int] - Produces: [int]

Multiplies the top two ints and pushes the result.

int_div¶

Takes: [int, int] - Produces: [int]

Divides the top two ints and pushes the result.

int_mod¶

Takes: [int, int] - Produces: [int]

Computes the modulus of the top two ints and pushes the result.

int_min¶

Takes: [int, int] - Produces: [int]

Pushes the minimum of two int.

int_max¶

Takes: [int, int] - Produces: [int]

Pushes the maximum of two int.

int_inc¶

Takes: [int] - Produces: [int]

Increments the top int by 1.

int_dec¶

Takes: [int] - Produces: [int]

Decrements the top int by 1.

int_lt¶

Takes: [int, int] - Produces: [bool]

Pushes true if the top int is less than the second. Pushes false otherwise.

int_lte¶

Takes: [int, int] - Produces: [bool]

Pushes true if the top int is less than, or equal to, the second. Pushes false otherwise.

int_gt¶

Takes: [int, int] - Produces: [bool]

Pushes true if the top int is greater than the second.. Pushes false otherwise.

int_gte¶

Takes: [int, int] - Produces: [bool]

Pushes true if the top int is greater than, or equal to, the second. Pushes false otherwise.

float_add¶

Takes: [float, float] - Produces: [float]

Adds the top two floats and pushes the result.

float_sub¶

Takes: [float, float] - Produces: [float]

Subtracts the top two floats and pushes the result.

float_mult¶

Takes: [float, float] - Produces: [float]

Multiplies the top two floats and pushes the result.

float_div¶

Takes: [float, float] - Produces: [float]

Divides the top two floats and pushes the result.

float_mod¶

Takes: [float, float] - Produces: [float]

Computes the modulus of the top two floats and pushes the result.

float_min¶

Takes: [float, float] - Produces: [float]

Pushes the minimum of two float.

float_max¶

Takes: [float, float] - Produces: [float]

Pushes the maximum of two float.

float_inc¶

Takes: [float] - Produces: [float]

Increments the top float by 1.

float_dec¶

Takes: [float] - Produces: [float]

Decrements the top float by 1.

float_lt¶

Takes: [float, float] - Produces: [bool]

Pushes true if the top float is less than the second. Pushes false otherwise.

float_lte¶

Takes: [float, float] - Produces: [bool]

Pushes true if the top float is less than, or equal to, the second. Pushes false otherwise.

float_gt¶

Takes: [float, float] - Produces: [bool]

Pushes true if the top float is greater than the second.. Pushes false otherwise.

float_gte¶

Takes: [float, float] - Produces: [bool]

Pushes true if the top float is greater than, or equal to, the second. Pushes false otherwise.

float_sin¶

Takes: [float] - Produces: [float]

Pushes the sin of the top float.

float_cos¶

Takes: [float] - Produces: [float]

Pushes the cos of the top float.

float_tan¶

Takes: [float] - Produces: [float]

Pushes the tan of the top float.

int_from_bool¶

Takes: [bool] - Produces: [int]

Pushes 1 in the top boolean is true. Pushes 0 if the top boolean is false.

float_from_bool¶

Takes: [bool] - Produces: [float]

Pushes 1.0 in the top boolean is true. Pushes 0.0 if the top boolean is false.

int_from_float¶

Takes: [float] - Produces: [int]

Casts the top float to an integer and pushes the result.

float_from_int¶

Takes: [int] - Produces: [float]

Casts the top integer to a float and pushes the result.

str_concat¶

Takes: [str, str] - Produces: [str]

Concatenates the top two strs and pushes the resulting string.

str_insert_str¶

Takes: [str, str, int] - Produces: [str]

Inserts str into the top str at index n and pushes

the resulting string. The value for n is taken from the int stack.

str_from_first_char¶

Takes: [str] - Produces: [str]

Pushes a str of the first character of the top string.

str_from_last_char¶

Takes: [str] - Produces: [str]

Pushes a str of the last character of the top string.

str_from_nth_char¶

Takes: [str, int] - Produces: [str]

Pushes a str of the nth character of the top string. The top integer denotes nth position.

str_contains_str¶

Takes: [str, str] - Produces: [bool]

Pushes true if the next str is in the top string. Pushes false otherwise.

str_index_of_str¶

Takes: [str, str] - Produces: [int]

Pushes the index of the next str in the top string. If not found, pushes -1.

str_split_on_str¶

Takes: [str, str] - Produces: Arbitrary number of str values.

Pushes multiple strs produced by splitting the top str on the top str.

str_replace_first_str¶

Takes: [str, str, str] - Produces: [str]

Pushes the str produced by replaceing the first occurrence of the

top str with the second str.

str_replace_n_str¶

Takes: [str, str, str, int] - Produces: [str]

Pushes the str produced by replaceing the first n occurrences of the

top str with the second str. The value for n is the top int.

str_replace_all_str¶

Takes: [str, str, str] - Produces: [str]

Pushes the str produced by replaceing all occurrences of the

top str with the second str.

str_remove_first_str¶

Takes: [str, str] - Produces: [str]

Pushes the str produced by removing the first occurrence of the top str.

str_remove_n_str¶

Takes: [str, str, int] - Produces: [str]

Pushes the str produced by remvoing the first n occurrences of the

top str. The value for n is the top int.

str_remove_all_str¶

Takes: [str, str] - Produces: [str]

Pushes the str produced by removing all occurrences of the top str.

str_occurrences_of_str¶

Takes: [str, str] - Produces: [int]

Pushes the number of times the top str occurs in the top str to the int stack.

char_concat¶

Takes: [char, char] - Produces: [str]

Concatenates the top two chars and pushes the resulting string.

str_insert_char¶

Takes: [str, char, int] - Produces: [str]

Inserts char into the top str at index n and pushes

the resulting string. The value for n is taken from the int stack.

char_from_first_char¶

Takes: [str] - Produces: [char]

Pushes a char of the first character of the top string.

char_from_last_char¶

Takes: [str] - Produces: [char]

Pushes a char of the last character of the top string.

char_from_nth_char¶

Takes: [str, int] - Produces: [char]

Pushes a char of the nth character of the top string. The top integer denotes nth position.

str_contains_char¶

Takes: [str, char] - Produces: [bool]

Pushes true if the next char is in the top string. Pushes false otherwise.

str_index_of_char¶

Takes: [str, char] - Produces: [int]

Pushes the index of the next char in the top string. If not found, pushes -1.

str_split_on_char¶

Takes: [str, char] - Produces: Arbitrary number of str values.

Pushes multiple strs produced by splitting the top str on the top char.

str_replace_first_char¶

Takes: [str, char, char] - Produces: [str]

Pushes the str produced by replaceing the first occurrence of the

top char with the second char.

str_replace_n_char¶

Takes: [str, char, char, int] - Produces: [str]

Pushes the str produced by replaceing the first n occurrences of the

top char with the second char. The value for n is the top int.

str_replace_all_char¶

Takes: [str, char, char] - Produces: [str]

Pushes the str produced by replaceing all occurrences of the

top char with the second char.

str_remove_first_char¶

Takes: [str, char] - Produces: [str]

Pushes the str produced by removing the first occurrence of the top char.

str_remove_n_char¶

Takes: [str, char, int] - Produces: [str]

Pushes the str produced by remvoing the first n occurrences of the

top char. The value for n is the top int.

str_remove_all_char¶

Takes: [str, char] - Produces: [str]

Pushes the str produced by removing all occurrences of the top char.

str_occurrences_of_char¶

Takes: [str, char] - Produces: [int]

Pushes the number of times the top char occurs in the top str to the int stack.

str_reverse¶

Takes: [str] - Produces: [str]

Takes the top string and pushes it reversed.

str_head¶

Takes: [str, int] - Produces: [str]

Pushes a string of the first n characters from the top string. The value

for n is the top int mod the length of the string.

str_tail¶

Takes: [str, int] - Produces: [str]

Pushes a string of the last n characters from the top string. The value

for n is the top int mod the length of the string.

str_append_char¶

Takes: [str, char] - Produces: [str]

Appends the top char to the top string pushes the resulting string.

str_rest¶

Takes: [str] - Produces: [str]

Pushes the top str without its first character.

str_but_last¶

Takes: [str] - Produces: [str]

Pushes the top str without its last character.

str_drop¶

Takes: [str, int] - Produces: [str]

Pushes the top str without its first n character. The value for n

is the top int mod the length of the string.

str_but_last_n¶

Takes: [str, int] - Produces: [str]

Pushes the top str without its last n character. The value for n

is the top int mod the length of the string.

str_length¶

Takes: [str] - Produces: [int]

Pushes the length of the top str to the int stack.

str_make_empty¶

Takes: [] - Produces: [str]

Pushes an empty string.

str_is_empty_string¶

Takes: [str] - Produces: [bool]

Pushes True if top string is empty. Pushes False otherwise.

str_remove_nth¶

Takes: [str, int] - Produces: [str]

Pushes the top str with the nth character removed.

str_set_nth¶

Takes: [str, char, int] - Produces: [str]

Pushes the top str with the nth character set to the top character.

str_strip_whitespace¶

Takes: [str] - Produces: [str]

Pushes the top str with trailing and leading whitespace stripped.

char_is_whitespace¶

Takes: [char] - Produces: [bool]

Pushes True if the top Char is whitespace. Pushes False otherwise.

char_is_letter¶

Takes: [char] - Produces: [bool]

Pushes True if the top Char is a letter. Pushes False otherwise.

char_is_digit¶

Takes: [char] - Produces: [bool]

Pushes True if the top Char is a numeric digit. Pushes False otherwise.

str_from_bool¶

Takes: [bool] - Produces: [str]

Pushes the top bool converted into a str.

str_from_int¶

Takes: [int] - Produces: [str]

Pushes the top int converted into a str.

str_from_float¶

Takes: [float] - Produces: [str]

Pushes the top float converted into a str.

str_from_char¶

Takes: [char] - Produces: [str]

Pushes the top char converted into a str.

char_from_bool¶

Takes: [bool] - Produces: [char]

Pushes the char "T" if the top bool is True. If the top

bool is False, pushes the char "F".

char_from_ascii_int¶

Takes: [int] - Produces: [char]

Pushes the top int converted into a Character by using the int mod 128 as an ascii value.

char_from_float¶

Takes: [float] - Produces: [char]

Pushes the top float converted into a Character by flooring

the float to an int, taking the int mod 128, and using it as an ascii value.

chars_from_str¶

Takes: [str] - Produces: Arbitrary number of char values.

Pushes each character of the top str to the char stack in reverse order.

bool_and¶

Takes: [bool, bool] - Produces: [bool]

Pushes the result of and-ing the top two booleans.

bool_or¶

Takes: [bool, bool] - Produces: [bool]

Pushes the result of or-ing the top two booleans.

bool_not¶

Takes: [bool] - Produces: [bool]

Pushes the inverse of the boolean.

bool_xor¶

Takes: [bool, bool] - Produces: [bool]

Pushes the result of xor-ing the top two booleans.

bool_invert_first_then_and¶

Takes: [bool, bool] - Produces: [bool]

"Pushes the result of and-ing the top two booleans after inverting the

top boolean.

bool_second_first_then_and¶

Takes: [bool, bool] - Produces: [bool]

"Pushes the result of and-ing the top two booleans after inverting the

second boolean.

bool_from_int¶

Takes: [int] - Produces: [bool]

If the top int is 0, pushes False. Pushes True for any other int value.

bool_from_float¶

Takes: [float] - Produces: [bool]

If the top float is 0.0, pushes False. Pushes True for any other float value.

noop¶

Takes: [] - Produces: []

A noop SimpleInstruction which does nothing.

noop_open¶

Takes: [] - Produces: [] - Opens 1 code blocks

A noop SimpleInstruction which does nothing. Opens a code block.

code_is_code_block¶

Takes: [code] - Produces: [bool]

Push True if top item on code stack is a CodeBlock. False otherwise.

code_is_singular¶

Takes: [code] - Produces: [bool]

Push True if top item on code stack is a not CodeBlock. False otherwise.

code_length¶

Takes: [code] - Produces: [int]

If the top code item is a CodeBlock, pushes its length, otherwise pushes 1.

code_first¶

Takes: [code] - Produces: [code]

If the top code item is a CodeBlock, pushes its first element.

code_last¶

Takes: [code] - Produces: [code]

If the top code item is a CodeBlock, pushes its last element.

code_rest¶

Takes: [code] - Produces: [code]

If the top code item is a CodeBlock, pushes it to the code stack without its first element.

code_but_last¶

Takes: [code] - Produces: [code]

If the top code item is a CodeBlock, pushes it to the code stack without its last element.

code_wrap¶

Takes: [code] - Produces: [code]

Wraps the top item on the code stack in a CodeBlock.

code_list¶

Takes: [code, code] - Produces: [code]

Wraps the top two items on the code stack in a CodeBlock.

code_combine¶

Takes: [code, code] - Produces: [code]

Combines the top two items on the code stack in a CodeBlock.

If one items is a CodeBlock, the other item is appended to it. If both
items are CodeBlocks, they are concatenated together.

code_do¶

Takes: [code] - Produces: [exec]

Moves the top element of the code stack to the exec stack for execution.

code_do_dup¶

Takes: [code] - Produces: [exec, code]

Copies the top element of the code stack to the exec stack for execution.

code_do_then_pop¶

Takes: PushState - Produces: PushState

Pushes a code_pop InstructionMeta and the top item of the

code stack to the exec stack. Result is the top code item executing before
it is removed from the code stack.

code_do_range¶

Takes: PushState - Produces: PushState

Evaluates the top item on the code stack for each step along

the range i to j. Both i and j are taken from the int stack.

exec_do_range¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Evaluates the top item on the exec stack for each step along

the range i to j. Both i and j are taken from the int stack.
Differs from code_do_range only in the source of the code and the
recursive call.

code_do_count¶

Takes: PushState - Produces: PushState

Evaluates the top item on the code stack n times, where

n comes from the n comes from the top of the int stack.

exec_do_count¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Evaluates the top item on the exec stack n times, where

n comes from the n comes from the top of the int stack. Differs from
code.do*count only in the source of the code and the recursive call.

code_do_times¶

Takes: PushState - Produces: PushState

Evaluates the top item on the code stack n times, where

n comes from the n comes from the top of the int stack.

exec_do_times¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Evaluates the top item on the code stack n times, where

n comes from the n comes from the top of the int stack.

exec_while¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Evaluates the top item on the exec stack repeated until the top

bool is no longer True.

exec_do_while¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Evaluates the top item on the exec stack repeated until the top

bool is no longer True.

code_map¶

Takes: PushState - Produces: PushState

Evaluates the top item on the exec stack for each element of the top

CodeBlock on the code stack. If the top code item is not a CodeBlock, it is wrapped
into one.

code_if¶

Takes: [bool, code, code] - Produces: [exec]

If the top boolean is true, execute the top element of the code

stack and skip the second. Otherwise, skip the top element of the
code stack and execute the second.

exec_if¶

Takes: [bool, exec, exec] - Produces: [exec] - Opens 2 code blocks

If the top boolean is true, execute the top element of the exec

stack and skip the second. Otherwise, skip the top element of the
exec stack and execute the second.

code_when¶

Takes: PushState - Produces: PushState

Evalutates the top code item if the top bool is True.

Otherwise the top code is popped.

exec_when¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Pops the next item on the exec stack without evaluating it

if the top bool is False. Otherwise, has no effect.

code_member¶

Takes: [code, code] - Produces: [bool]

Pushes True if the second code item is a found within the top code item.

If the top code item is not a CodeBlock, it is wrapped.

code_nth¶

Takes: [code, int] - Produces: [code]

Pushes nth item of the top element on the code stack. If

the top item is not a CodeBlock it is wrapped in a CodeBlock.

make_empty_code_block¶

Takes: [] - Produces: [code]

Pushes an empty CodeBlock to the code stack.

is_empty_code_block¶

Takes: [code] - Produces: [bool]

Pushes true if top code item is an empty CodeBlock. Pushes

false otherwise.

code_size¶

Takes: [code] - Produces: [int]

Pushes the total size of the top item on the code stack. If

the top item is a CodeBlock, this includes the size of all the CodeBlock's
elements recusively.

code_extract¶

Takes: [code, int] - Produces: [code]

Traverses the top code item depth first and returns the nth

item based on the top int.

code_insert¶

Takes: [code, code, int] - Produces: [code]

Traverses the top code item depth first and inserts the

second code item at position n. The value of n is the top int.

code_first_position¶

Takes: [code, code] - Produces: [int]

Pushes the first position of the second code item within

the top code item. If not found, pushes -1. If the top code item is not
a CodeBlock, this instruction returns 0 if the top two code elements are
equal and -1 otherwise.

code_reverse¶

Takes: [code] - Produces: [code]

Pushes the top code item reversed. No effect if top code

item is not a CodeBlock.

vector_int_concat¶

Takes: [vector_int, vector_int] - Produces: [vector_int]

Concatenates the top two vector_int.

vector_int_conj¶

Takes: [vector_int, int] - Produces: [vector_int]

Appends the top int to the top vector_int.

vector_int_take¶

Takes: [vector_int, int] - Produces: [vector_int]

Creates a new vector_int from the first N elements of the top vector_int. N is top int.

vector_int_subvec¶

Takes: [vector_int, int, int] - Produces: [vector_int]

Creates a new vector_int from a slice of the top vector_int. Start and end indices are the top two ints.

vector_int_first¶

Takes: [vector_int] - Produces: [int]

Takes the first element of the top vector_int and pushes it to the int stack.

vector_int_last¶

Takes: [vector_int] - Produces: [int]

Takes the last element of the top vector_int and pushes it to the int stack.

vector_int_nth¶

Takes: [vector_int, int] - Produces: [int]

Takes the nth element of the top vector_int and pushes it to the int stack. N is the top int.

vector_int_rest¶

Takes: [vector_int] - Produces: [vector_int]

Drops the first element of the top vector_int.

vector_int_but_last¶

Takes: [vector_int] - Produces: [vector_int]

Drops the last element of the top vector_int.

vector_int_length¶

Takes: [vector_int] - Produces: [int]

Pushes the length of the top vector_int to the int stack.

vector_int_reverse¶

Takes: [vector_int] - Produces: [vector_int]

Reverses the top vector_int.

vector_int_push_all¶

Takes: [vector_int] - Produces: Arbitrary number of int values.

Pushes all elements of the top vector_int to the int.

vector_int_empty_vector¶

Takes: [vector_int] - Produces: [bool]

Pushes True to the bool stack if the top vector_int is empty. Pushes False otherwise.

vector_int_contains¶

Takes: [vector_int, int] - Produces: [bool]

Pushes True to the bool stack if the top int is found in the top vector_int. Pushes False otherwise.

vector_int_index_of¶

Takes: [vector_int, int] - Produces: [int]

Pushes the index top int is top vector_int to int stack. Pushes -1 if not found.

vector_int_occurrences_of¶

Takes: [vector_int, int] - Produces: [int]

Pushes the number of time the top int is found in the top vector_int to int stack.

vector_int_set_nth¶

Takes: [vector_int, int, int] - Produces: [vector_int]

Sets the nth element of the top vector_int to be the top int. N is the top int.

vector_int_replace¶

Takes: [vector_int, int, int] - Produces: [vector_int]

Replaces all instances of the top int from the top vector_int.

vector_int_replace_first¶

Takes: [vector_int, int, int] - Produces: [vector_int]

Replaces the first instance of the top int from the top vector_int.

vector_int_remove¶

Takes: [vector_int, int] - Produces: [vector_int]

Removes all instances of the top int from the top vector_int.

vector_int_iterate¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Iterates over the top vector_int using the code on top of the exec stack.

vector_float_concat¶

Takes: [vector_float, vector_float] - Produces: [vector_float]

Concatenates the top two vector_float.

vector_float_conj¶

Takes: [vector_float, float] - Produces: [vector_float]

Appends the top float to the top vector_float.

vector_float_take¶

Takes: [vector_float, int] - Produces: [vector_float]

Creates a new vector_float from the first N elements of the top vector_float. N is top int.

vector_float_subvec¶

Takes: [vector_float, int, int] - Produces: [vector_float]

Creates a new vector_float from a slice of the top vector_float. Start and end indices are the top two ints.

vector_float_first¶

Takes: [vector_float] - Produces: [float]

Takes the first element of the top vector_float and pushes it to the float stack.

vector_float_last¶

Takes: [vector_float] - Produces: [float]

Takes the last element of the top vector_float and pushes it to the float stack.

vector_float_nth¶

Takes: [vector_float, int] - Produces: [float]

Takes the nth element of the top vector_float and pushes it to the float stack. N is the top int.

vector_float_rest¶

Takes: [vector_float] - Produces: [vector_float]

Drops the first element of the top vector_float.

vector_float_but_last¶

Takes: [vector_float] - Produces: [vector_float]

Drops the last element of the top vector_float.

vector_float_length¶

Takes: [vector_float] - Produces: [int]

Pushes the length of the top vector_float to the int stack.

vector_float_reverse¶

Takes: [vector_float] - Produces: [vector_float]

Reverses the top vector_float.

vector_float_push_all¶

Takes: [vector_float] - Produces: Arbitrary number of float values.

Pushes all elements of the top vector_float to the float.

vector_float_empty_vector¶

Takes: [vector_float] - Produces: [bool]

Pushes True to the bool stack if the top vector_float is empty. Pushes False otherwise.

vector_float_contains¶

Takes: [vector_float, float] - Produces: [bool]

Pushes True to the bool stack if the top float is found in the top vector_float. Pushes False otherwise.

vector_float_index_of¶

Takes: [vector_float, float] - Produces: [int]

Pushes the index top float is top vector_float to int stack. Pushes -1 if not found.

vector_float_occurrences_of¶

Takes: [vector_float, float] - Produces: [int]

Pushes the number of time the top float is found in the top vector_float to int stack.

vector_float_set_nth¶

Takes: [vector_float, int, float] - Produces: [vector_float]

Sets the nth element of the top vector_float to be the top float. N is the top int.

vector_float_replace¶

Takes: [vector_float, float, float] - Produces: [vector_float]

Replaces all instances of the top float from the top vector_float.

vector_float_replace_first¶

Takes: [vector_float, float, float] - Produces: [vector_float]

Replaces the first instance of the top float from the top vector_float.

vector_float_remove¶

Takes: [vector_float, float] - Produces: [vector_float]

Removes all instances of the top float from the top vector_float.

vector_float_iterate¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Iterates over the top vector_float using the code on top of the exec stack.

vector_str_concat¶

Takes: [vector_str, vector_str] - Produces: [vector_str]

Concatenates the top two vector_str.

vector_str_conj¶

Takes: [vector_str, str] - Produces: [vector_str]

Appends the top str to the top vector_str.

vector_str_take¶

Takes: [vector_str, int] - Produces: [vector_str]

Creates a new vector_str from the first N elements of the top vector_str. N is top int.

vector_str_subvec¶

Takes: [vector_str, int, int] - Produces: [vector_str]

Creates a new vector_str from a slice of the top vector_str. Start and end indices are the top two ints.

vector_str_first¶

Takes: [vector_str] - Produces: [str]

Takes the first element of the top vector_str and pushes it to the str stack.

vector_str_last¶

Takes: [vector_str] - Produces: [str]

Takes the last element of the top vector_str and pushes it to the str stack.

vector_str_nth¶

Takes: [vector_str, int] - Produces: [str]

Takes the nth element of the top vector_str and pushes it to the str stack. N is the top int.

vector_str_rest¶

Takes: [vector_str] - Produces: [vector_str]

Drops the first element of the top vector_str.

vector_str_but_last¶

Takes: [vector_str] - Produces: [vector_str]

Drops the last element of the top vector_str.

vector_str_length¶

Takes: [vector_str] - Produces: [int]

Pushes the length of the top vector_str to the int stack.

vector_str_reverse¶

Takes: [vector_str] - Produces: [vector_str]

Reverses the top vector_str.

vector_str_push_all¶

Takes: [vector_str] - Produces: Arbitrary number of str values.

Pushes all elements of the top vector_str to the str.

vector_str_empty_vector¶

Takes: [vector_str] - Produces: [bool]

Pushes True to the bool stack if the top vector_str is empty. Pushes False otherwise.

vector_str_contains¶

Takes: [vector_str, str] - Produces: [bool]

Pushes True to the bool stack if the top str is found in the top vector_str. Pushes False otherwise.

vector_str_index_of¶

Takes: [vector_str, str] - Produces: [int]

Pushes the index top str is top vector_str to int stack. Pushes -1 if not found.

vector_str_occurrences_of¶

Takes: [vector_str, str] - Produces: [int]

Pushes the number of time the top str is found in the top vector_str to int stack.

vector_str_set_nth¶

Takes: [vector_str, int, str] - Produces: [vector_str]

Sets the nth element of the top vector_str to be the top str. N is the top int.

vector_str_replace¶

Takes: [vector_str, str, str] - Produces: [vector_str]

Replaces all instances of the top str from the top vector_str.

vector_str_replace_first¶

Takes: [vector_str, str, str] - Produces: [vector_str]

Replaces the first instance of the top str from the top vector_str.

vector_str_remove¶

Takes: [vector_str, str] - Produces: [vector_str]

Removes all instances of the top str from the top vector_str.

vector_str_iterate¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Iterates over the top vector_str using the code on top of the exec stack.

vector_bool_concat¶

Takes: [vector_bool, vector_bool] - Produces: [vector_bool]

Concatenates the top two vector_bool.

vector_bool_conj¶

Takes: [vector_bool, bool] - Produces: [vector_bool]

Appends the top bool to the top vector_bool.

vector_bool_take¶

Takes: [vector_bool, int] - Produces: [vector_bool]

Creates a new vector_bool from the first N elements of the top vector_bool. N is top int.

vector_bool_subvec¶

Takes: [vector_bool, int, int] - Produces: [vector_bool]

Creates a new vector_bool from a slice of the top vector_bool. Start and end indices are the top two ints.

vector_bool_first¶

Takes: [vector_bool] - Produces: [bool]

Takes the first element of the top vector_bool and pushes it to the bool stack.

vector_bool_last¶

Takes: [vector_bool] - Produces: [bool]

Takes the last element of the top vector_bool and pushes it to the bool stack.

vector_bool_nth¶

Takes: [vector_bool, int] - Produces: [bool]

Takes the nth element of the top vector_bool and pushes it to the bool stack. N is the top int.

vector_bool_rest¶

Takes: [vector_bool] - Produces: [vector_bool]

Drops the first element of the top vector_bool.

vector_bool_but_last¶

Takes: [vector_bool] - Produces: [vector_bool]

Drops the last element of the top vector_bool.

vector_bool_length¶

Takes: [vector_bool] - Produces: [int]

Pushes the length of the top vector_bool to the int stack.

vector_bool_reverse¶

Takes: [vector_bool] - Produces: [vector_bool]

Reverses the top vector_bool.

vector_bool_push_all¶

Takes: [vector_bool] - Produces: Arbitrary number of bool values.

Pushes all elements of the top vector_bool to the bool.

vector_bool_empty_vector¶

Takes: [vector_bool] - Produces: [bool]

Pushes True to the bool stack if the top vector_bool is empty. Pushes False otherwise.

vector_bool_contains¶

Takes: [vector_bool, bool] - Produces: [bool]

Pushes True to the bool stack if the top bool is found in the top vector_bool. Pushes False otherwise.

vector_bool_index_of¶

Takes: [vector_bool, bool] - Produces: [int]

Pushes the index top bool is top vector_bool to int stack. Pushes -1 if not found.

vector_bool_occurrences_of¶

Takes: [vector_bool, bool] - Produces: [int]

Pushes the number of time the top bool is found in the top vector_bool to int stack.

vector_bool_set_nth¶

Takes: [vector_bool, int, bool] - Produces: [vector_bool]

Sets the nth element of the top vector_bool to be the top bool. N is the top int.

vector_bool_replace¶

Takes: [vector_bool, bool, bool] - Produces: [vector_bool]

Replaces all instances of the top bool from the top vector_bool.

vector_bool_replace_first¶

Takes: [vector_bool, bool, bool] - Produces: [vector_bool]

Replaces the first instance of the top bool from the top vector_bool.

vector_bool_remove¶

Takes: [vector_bool, bool] - Produces: [vector_bool]

Removes all instances of the top bool from the top vector_bool.

vector_bool_iterate¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Iterates over the top vector_bool using the code on top of the exec stack.

vector_char_concat¶

Takes: [vector_char, vector_char] - Produces: [vector_char]

Concatenates the top two vector_char.

vector_char_conj¶

Takes: [vector_char, char] - Produces: [vector_char]

Appends the top char to the top vector_char.

vector_char_take¶

Takes: [vector_char, int] - Produces: [vector_char]

Creates a new vector_char from the first N elements of the top vector_char. N is top int.

vector_char_subvec¶

Takes: [vector_char, int, int] - Produces: [vector_char]

Creates a new vector_char from a slice of the top vector_char. Start and end indices are the top two ints.

vector_char_first¶

Takes: [vector_char] - Produces: [char]

Takes the first element of the top vector_char and pushes it to the char stack.

vector_char_last¶

Takes: [vector_char] - Produces: [char]

Takes the last element of the top vector_char and pushes it to the char stack.

vector_char_nth¶

Takes: [vector_char, int] - Produces: [char]

Takes the nth element of the top vector_char and pushes it to the char stack. N is the top int.

vector_char_rest¶

Takes: [vector_char] - Produces: [vector_char]

Drops the first element of the top vector_char.

vector_char_but_last¶

Takes: [vector_char] - Produces: [vector_char]

Drops the last element of the top vector_char.

vector_char_length¶

Takes: [vector_char] - Produces: [int]

Pushes the length of the top vector_char to the int stack.

vector_char_reverse¶

Takes: [vector_char] - Produces: [vector_char]

Reverses the top vector_char.

vector_char_push_all¶

Takes: [vector_char] - Produces: Arbitrary number of char values.

Pushes all elements of the top vector_char to the char.

vector_char_empty_vector¶

Takes: [vector_char] - Produces: [bool]

Pushes True to the bool stack if the top vector_char is empty. Pushes False otherwise.

vector_char_contains¶

Takes: [vector_char, char] - Produces: [bool]

Pushes True to the bool stack if the top char is found in the top vector_char. Pushes False otherwise.

vector_char_index_of¶

Takes: [vector_char, char] - Produces: [int]

Pushes the index top char is top vector_char to int stack. Pushes -1 if not found.

vector_char_occurrences_of¶

Takes: [vector_char, char] - Produces: [int]

Pushes the number of time the top char is found in the top vector_char to int stack.

vector_char_set_nth¶

Takes: [vector_char, int, char] - Produces: [vector_char]

Sets the nth element of the top vector_char to be the top char. N is the top int.

vector_char_replace¶

Takes: [vector_char, char, char] - Produces: [vector_char]

Replaces all instances of the top char from the top vector_char.

vector_char_replace_first¶

Takes: [vector_char, char, char] - Produces: [vector_char]

Replaces the first instance of the top char from the top vector_char.

vector_char_remove¶

Takes: [vector_char, char] - Produces: [vector_char]

Removes all instances of the top char from the top vector_char.

vector_char_iterate¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Iterates over the top vector_char using the code on top of the exec stack.

print_bool¶

Takes: [bool] - Produces: [stdout]

Prints the top bool.

println_bool¶

Takes: [bool] - Produces: [stdout]

Prints the top bool.

print_int¶

Takes: [int] - Produces: [stdout]

Prints the top int.

println_int¶

Takes: [int] - Produces: [stdout]

Prints the top int.

print_char¶

Takes: [char] - Produces: [stdout]

Prints the top char.

println_char¶

Takes: [char] - Produces: [stdout]

Prints the top char.

print_float¶

Takes: [float] - Produces: [stdout]

Prints the top float.

println_float¶

Takes: [float] - Produces: [stdout]

Prints the top float.

print_str¶

Takes: [str] - Produces: [stdout]

Prints the top str.

println_str¶

Takes: [str] - Produces: [stdout]

Prints the top str.

print_vector_int¶

Takes: [vector_int] - Produces: [stdout]

Prints the top vector_int.

println_vector_int¶

Takes: [vector_int] - Produces: [stdout]

Prints the top vector_int.

print_vector_float¶

Takes: [vector_float] - Produces: [stdout]

Prints the top vector_float.

println_vector_float¶

Takes: [vector_float] - Produces: [stdout]

Prints the top vector_float.

print_vector_str¶

Takes: [vector_str] - Produces: [stdout]

Prints the top vector_str.

println_vector_str¶

Takes: [vector_str] - Produces: [stdout]

Prints the top vector_str.

print_vector_bool¶

Takes: [vector_bool] - Produces: [stdout]

Prints the top vector_bool.

println_vector_bool¶

Takes: [vector_bool] - Produces: [stdout]

Prints the top vector_bool.

print_vector_char¶

Takes: [vector_char] - Produces: [stdout]

Prints the top vector_char.

println_vector_char¶

Takes: [vector_char] - Produces: [stdout]

Prints the top vector_char.

print_code¶

Takes: [code] - Produces: [stdout]

Prints the top code.

println_code¶

Takes: [code] - Produces: [stdout]

Prints the top code.

print_exec¶

Takes: [exec] - Produces: [stdout]

Prints the top exec.

println_exec¶

Takes: [exec] - Produces: [stdout]

Prints the top exec.

bool_pop¶

Takes: [bool] - Produces: []

Pops the top bool.

bool_dup¶

Takes: [bool] - Produces: [bool, bool]

Duplicates the top bool.

bool_dup_times¶

Takes: [int, bool] - Produces: Arbitrary number of bool values.

Duplicates the top bool n times where n is from the int stack.

bool_swap¶

Takes: [bool, bool] - Produces: [bool, bool]

Swaps the top two bools.

bool_rot¶

Takes: [bool, bool, bool] - Produces: [bool, bool, bool]

Rotates the top three bools.

bool_flush¶

Takes: PushState - Produces: PushState

Empties the bool stack.

bool_eq¶

Takes: [bool, bool] - Produces: [bool]

Pushes True if the top two bool are equal. Otherwise pushes False.

bool_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the bool stack to the int stack.

bool_yank¶

Takes: PushState - Produces: PushState

Yanks a bool from deep in the stack based on an index from the int stack and puts it on top.

bool_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a bool deep in the stack based on an index from the int stack and puts it on top.

bool_shove¶

Takes: PushState - Produces: PushState

Shoves the top bool deep in the stack based on an index from the int stack.

bool_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top bool deep in the stack based on an index from the int stack.

bool_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the bool stack is empty. Pushes False otherwise.

int_pop¶

Takes: [int] - Produces: []

Pops the top int.

int_dup¶

Takes: [int] - Produces: [int, int]

Duplicates the top int.

int_dup_times¶

Takes: [int, int] - Produces: Arbitrary number of int values.

Duplicates the top int n times where n is from the int stack.

int_swap¶

Takes: [int, int] - Produces: [int, int]

Swaps the top two ints.

int_rot¶

Takes: [int, int, int] - Produces: [int, int, int]

Rotates the top three ints.

int_flush¶

Takes: PushState - Produces: PushState

Empties the int stack.

int_eq¶

Takes: [int, int] - Produces: [bool]

Pushes True if the top two int are equal. Otherwise pushes False.

int_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the int stack to the int stack.

int_yank¶

Takes: PushState - Produces: PushState

Yanks a int from deep in the stack based on an index from the int stack and puts it on top.

int_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a int deep in the stack based on an index from the int stack and puts it on top.

int_shove¶

Takes: PushState - Produces: PushState

Shoves the top int deep in the stack based on an index from the int stack.

int_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top int deep in the stack based on an index from the int stack.

int_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the int stack is empty. Pushes False otherwise.

char_pop¶

Takes: [char] - Produces: []

Pops the top char.

char_dup¶

Takes: [char] - Produces: [char, char]

Duplicates the top char.

char_dup_times¶

Takes: [int, char] - Produces: Arbitrary number of char values.

Duplicates the top char n times where n is from the int stack.

char_swap¶

Takes: [char, char] - Produces: [char, char]

Swaps the top two chars.

char_rot¶

Takes: [char, char, char] - Produces: [char, char, char]

Rotates the top three chars.

char_flush¶

Takes: PushState - Produces: PushState

Empties the char stack.

char_eq¶

Takes: [char, char] - Produces: [bool]

Pushes True if the top two char are equal. Otherwise pushes False.

char_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the char stack to the int stack.

char_yank¶

Takes: PushState - Produces: PushState

Yanks a char from deep in the stack based on an index from the int stack and puts it on top.

char_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a char deep in the stack based on an index from the int stack and puts it on top.

char_shove¶

Takes: PushState - Produces: PushState

Shoves the top char deep in the stack based on an index from the int stack.

char_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top char deep in the stack based on an index from the int stack.

char_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the char stack is empty. Pushes False otherwise.

float_pop¶

Takes: [float] - Produces: []

Pops the top float.

float_dup¶

Takes: [float] - Produces: [float, float]

Duplicates the top float.

float_dup_times¶

Takes: [int, float] - Produces: Arbitrary number of float values.

Duplicates the top float n times where n is from the int stack.

float_swap¶

Takes: [float, float] - Produces: [float, float]

Swaps the top two floats.

float_rot¶

Takes: [float, float, float] - Produces: [float, float, float]

Rotates the top three floats.

float_flush¶

Takes: PushState - Produces: PushState

Empties the float stack.

float_eq¶

Takes: [float, float] - Produces: [bool]

Pushes True if the top two float are equal. Otherwise pushes False.

float_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the float stack to the int stack.

float_yank¶

Takes: PushState - Produces: PushState

Yanks a float from deep in the stack based on an index from the int stack and puts it on top.

float_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a float deep in the stack based on an index from the int stack and puts it on top.

float_shove¶

Takes: PushState - Produces: PushState

Shoves the top float deep in the stack based on an index from the int stack.

float_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top float deep in the stack based on an index from the int stack.

float_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the float stack is empty. Pushes False otherwise.

str_pop¶

Takes: [str] - Produces: []

Pops the top str.

str_dup¶

Takes: [str] - Produces: [str, str]

Duplicates the top str.

str_dup_times¶

Takes: [int, str] - Produces: Arbitrary number of str values.

Duplicates the top str n times where n is from the int stack.

str_swap¶

Takes: [str, str] - Produces: [str, str]

Swaps the top two strs.

str_rot¶

Takes: [str, str, str] - Produces: [str, str, str]

Rotates the top three strs.

str_flush¶

Takes: PushState - Produces: PushState

Empties the str stack.

str_eq¶

Takes: [str, str] - Produces: [bool]

Pushes True if the top two str are equal. Otherwise pushes False.

str_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the str stack to the int stack.

str_yank¶

Takes: PushState - Produces: PushState

Yanks a str from deep in the stack based on an index from the int stack and puts it on top.

str_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a str deep in the stack based on an index from the int stack and puts it on top.

str_shove¶

Takes: PushState - Produces: PushState

Shoves the top str deep in the stack based on an index from the int stack.

str_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top str deep in the stack based on an index from the int stack.

str_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the str stack is empty. Pushes False otherwise.

vector_int_pop¶

Takes: [vector_int] - Produces: []

Pops the top vector_int.

vector_int_dup¶

Takes: [vector_int] - Produces: [vector_int, vector_int]

Duplicates the top vector_int.

vector_int_dup_times¶

Takes: [int, vector_int] - Produces: Arbitrary number of vector_int values.

Duplicates the top vector_int n times where n is from the int stack.

vector_int_swap¶

Takes: [vector_int, vector_int] - Produces: [vector_int, vector_int]

Swaps the top two vector_ints.

vector_int_rot¶

Takes: [vector_int, vector_int, vector_int] - Produces: [vector_int, vector_int, vector_int]

Rotates the top three vector_ints.

vector_int_flush¶

Takes: PushState - Produces: PushState

Empties the vector_int stack.

vector_int_eq¶

Takes: [vector_int, vector_int] - Produces: [bool]

Pushes True if the top two vector_int are equal. Otherwise pushes False.

vector_int_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the vector_int stack to the int stack.

vector_int_yank¶

Takes: PushState - Produces: PushState

Yanks a vector_int from deep in the stack based on an index from the int stack and puts it on top.

vector_int_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a vector_int deep in the stack based on an index from the int stack and puts it on top.

vector_int_shove¶

Takes: PushState - Produces: PushState

Shoves the top vector_int deep in the stack based on an index from the int stack.

vector_int_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top vector_int deep in the stack based on an index from the int stack.

vector_int_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the vector_int stack is empty. Pushes False otherwise.

vector_float_pop¶

Takes: [vector_float] - Produces: []

Pops the top vector_float.

vector_float_dup¶

Takes: [vector_float] - Produces: [vector_float, vector_float]

Duplicates the top vector_float.

vector_float_dup_times¶

Takes: [int, vector_float] - Produces: Arbitrary number of vector_float values.

Duplicates the top vector_float n times where n is from the int stack.

vector_float_swap¶

Takes: [vector_float, vector_float] - Produces: [vector_float, vector_float]

Swaps the top two vector_floats.

vector_float_rot¶

Takes: [vector_float, vector_float, vector_float] - Produces: [vector_float, vector_float, vector_float]

Rotates the top three vector_floats.

vector_float_flush¶

Takes: PushState - Produces: PushState

Empties the vector_float stack.

vector_float_eq¶

Takes: [vector_float, vector_float] - Produces: [bool]

Pushes True if the top two vector_float are equal. Otherwise pushes False.

vector_float_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the vector_float stack to the int stack.

vector_float_yank¶

Takes: PushState - Produces: PushState

Yanks a vector_float from deep in the stack based on an index from the int stack and puts it on top.

vector_float_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a vector_float deep in the stack based on an index from the int stack and puts it on top.

vector_float_shove¶

Takes: PushState - Produces: PushState

Shoves the top vector_float deep in the stack based on an index from the int stack.

vector_float_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top vector_float deep in the stack based on an index from the int stack.

vector_float_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the vector_float stack is empty. Pushes False otherwise.

vector_str_pop¶

Takes: [vector_str] - Produces: []

Pops the top vector_str.

vector_str_dup¶

Takes: [vector_str] - Produces: [vector_str, vector_str]

Duplicates the top vector_str.

vector_str_dup_times¶

Takes: [int, vector_str] - Produces: Arbitrary number of vector_str values.

Duplicates the top vector_str n times where n is from the int stack.

vector_str_swap¶

Takes: [vector_str, vector_str] - Produces: [vector_str, vector_str]

Swaps the top two vector_strs.

vector_str_rot¶

Takes: [vector_str, vector_str, vector_str] - Produces: [vector_str, vector_str, vector_str]

Rotates the top three vector_strs.

vector_str_flush¶

Takes: PushState - Produces: PushState

Empties the vector_str stack.

vector_str_eq¶

Takes: [vector_str, vector_str] - Produces: [bool]

Pushes True if the top two vector_str are equal. Otherwise pushes False.

vector_str_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the vector_str stack to the int stack.

vector_str_yank¶

Takes: PushState - Produces: PushState

Yanks a vector_str from deep in the stack based on an index from the int stack and puts it on top.

vector_str_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a vector_str deep in the stack based on an index from the int stack and puts it on top.

vector_str_shove¶

Takes: PushState - Produces: PushState

Shoves the top vector_str deep in the stack based on an index from the int stack.

vector_str_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top vector_str deep in the stack based on an index from the int stack.

vector_str_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the vector_str stack is empty. Pushes False otherwise.

vector_bool_pop¶

Takes: [vector_bool] - Produces: []

Pops the top vector_bool.

vector_bool_dup¶

Takes: [vector_bool] - Produces: [vector_bool, vector_bool]

Duplicates the top vector_bool.

vector_bool_dup_times¶

Takes: [int, vector_bool] - Produces: Arbitrary number of vector_bool values.

Duplicates the top vector_bool n times where n is from the int stack.

vector_bool_swap¶

Takes: [vector_bool, vector_bool] - Produces: [vector_bool, vector_bool]

Swaps the top two vector_bools.

vector_bool_rot¶

Takes: [vector_bool, vector_bool, vector_bool] - Produces: [vector_bool, vector_bool, vector_bool]

Rotates the top three vector_bools.

vector_bool_flush¶

Takes: PushState - Produces: PushState

Empties the vector_bool stack.

vector_bool_eq¶

Takes: [vector_bool, vector_bool] - Produces: [bool]

Pushes True if the top two vector_bool are equal. Otherwise pushes False.

vector_bool_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the vector_bool stack to the int stack.

vector_bool_yank¶

Takes: PushState - Produces: PushState

Yanks a vector_bool from deep in the stack based on an index from the int stack and puts it on top.

vector_bool_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a vector_bool deep in the stack based on an index from the int stack and puts it on top.

vector_bool_shove¶

Takes: PushState - Produces: PushState

Shoves the top vector_bool deep in the stack based on an index from the int stack.

vector_bool_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top vector_bool deep in the stack based on an index from the int stack.

vector_bool_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the vector_bool stack is empty. Pushes False otherwise.

vector_char_pop¶

Takes: [vector_char] - Produces: []

Pops the top vector_char.

vector_char_dup¶

Takes: [vector_char] - Produces: [vector_char, vector_char]

Duplicates the top vector_char.

vector_char_dup_times¶

Takes: [int, vector_char] - Produces: Arbitrary number of vector_char values.

Duplicates the top vector_char n times where n is from the int stack.

vector_char_swap¶

Takes: [vector_char, vector_char] - Produces: [vector_char, vector_char]

Swaps the top two vector_chars.

vector_char_rot¶

Takes: [vector_char, vector_char, vector_char] - Produces: [vector_char, vector_char, vector_char]

Rotates the top three vector_chars.

vector_char_flush¶

Takes: PushState - Produces: PushState

Empties the vector_char stack.

vector_char_eq¶

Takes: [vector_char, vector_char] - Produces: [bool]

Pushes True if the top two vector_char are equal. Otherwise pushes False.

vector_char_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the vector_char stack to the int stack.

vector_char_yank¶

Takes: PushState - Produces: PushState

Yanks a vector_char from deep in the stack based on an index from the int stack and puts it on top.

vector_char_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a vector_char deep in the stack based on an index from the int stack and puts it on top.

vector_char_shove¶

Takes: PushState - Produces: PushState

Shoves the top vector_char deep in the stack based on an index from the int stack.

vector_char_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top vector_char deep in the stack based on an index from the int stack.

vector_char_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the vector_char stack is empty. Pushes False otherwise.

code_pop¶

Takes: [code] - Produces: []

Pops the top code.

code_dup¶

Takes: [code] - Produces: [code, code]

Duplicates the top code.

code_dup_times¶

Takes: [int, code] - Produces: Arbitrary number of code values.

Duplicates the top code n times where n is from the int stack.

code_swap¶

Takes: [code, code] - Produces: [code, code]

Swaps the top two codes.

code_rot¶

Takes: [code, code, code] - Produces: [code, code, code]

Rotates the top three codes.

code_flush¶

Takes: PushState - Produces: PushState

Empties the code stack.

code_eq¶

Takes: [code, code] - Produces: [bool]

Pushes True if the top two code are equal. Otherwise pushes False.

code_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the code stack to the int stack.

code_yank¶

Takes: PushState - Produces: PushState

Yanks a code from deep in the stack based on an index from the int stack and puts it on top.

code_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a code deep in the stack based on an index from the int stack and puts it on top.

code_shove¶

Takes: PushState - Produces: PushState

Shoves the top code deep in the stack based on an index from the int stack.

code_shove_dup¶

Takes: PushState - Produces: PushState

Shoves a copy of the top code deep in the stack based on an index from the int stack.

code_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the code stack is empty. Pushes False otherwise.

exec_pop¶

Takes: [exec] - Produces: [] - Opens 1 code blocks

Pops the top exec.

exec_dup¶

Takes: [exec] - Produces: [exec, exec] - Opens 1 code blocks

Duplicates the top exec.

exec_dup_times¶

Takes: [int, exec] - Produces: Arbitrary number of exec values. - Opens 1 code blocks

Duplicates the top exec n times where n is from the int stack.

exec_swap¶

Takes: [exec, exec] - Produces: [exec, exec] - Opens 2 code blocks

Swaps the top two execs.

exec_rot¶

Takes: [exec, exec, exec] - Produces: [exec, exec, exec] - Opens 3 code blocks

Rotates the top three execs.

exec_flush¶

Takes: PushState - Produces: PushState

Empties the exec stack.

exec_eq¶

Takes: [exec, exec] - Produces: [bool]

Pushes True if the top two exec are equal. Otherwise pushes False.

exec_stack_depth¶

Takes: PushState - Produces: [int]

Pushes the size of the exec stack to the int stack.

exec_yank¶

Takes: PushState - Produces: PushState

Yanks a exec from deep in the stack based on an index from the int stack and puts it on top.

exec_yank_dup¶

Takes: PushState - Produces: PushState

Yanks a copy of a exec deep in the stack based on an index from the int stack and puts it on top.

exec_shove¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Shoves the top exec deep in the stack based on an index from the int stack.

exec_shove_dup¶

Takes: PushState - Produces: PushState - Opens 1 code blocks

Shoves a copy of the top exec deep in the stack based on an index from the int stack.

exec_is_empty¶

Takes: PushState - Produces: [bool]

Pushes True if the exec stack is empty. Pushes False otherwise.

code_from_bool¶

Takes: [bool] - Produces: [code]

Moves the top bool to the code stack.

code_from_int¶

Takes: [int] - Produces: [code]

Moves the top int to the code stack.

code_from_char¶

Takes: [char] - Produces: [code]

Moves the top char to the code stack.

code_from_float¶

Takes: [float] - Produces: [code]

Moves the top float to the code stack.

code_from_str¶

Takes: [str] - Produces: [code]

Moves the top str to the code stack.

code_from_vector_int¶

Takes: [vector_int] - Produces: [code]

Moves the top vector_int to the code stack.

code_from_vector_float¶

Takes: [vector_float] - Produces: [code]

Moves the top vector_float to the code stack.

code_from_vector_str¶

Takes: [vector_str] - Produces: [code]

Moves the top vector_str to the code stack.

code_from_vector_bool¶

Takes: [vector_bool] - Produces: [code]

Moves the top vector_bool to the code stack.

code_from_vector_char¶

Takes: [vector_char] - Produces: [code]

Moves the top vector_char to the code stack.

code_from_exec¶

Takes: [exec] - Produces: [code] - Opens 1 code blocks

Moves the top exec to the code stack.

Table of Contents

PyshGP Core Instruction Set

int_add

int_sub

int_mult

int_div

int_mod

int_min

int_max

int_inc

int_dec

int_lt

int_lte

int_gt

int_gte

float_add

float_sub

float_mult

float_div

float_mod

float_min

float_max

float_inc

float_dec

float_lt

float_lte

float_gt

float_gte

float_sin

float_cos

float_tan

int_from_bool

float_from_bool

int_from_float

float_from_int

str_concat

str_insert_str

str_from_first_char

str_from_last_char

str_from_nth_char

str_contains_str

str_index_of_str

str_split_on_str

str_replace_first_str

str_replace_n_str

str_replace_all_str

str_remove_first_str

str_remove_n_str

str_remove_all_str

str_occurrences_of_str

char_concat

str_insert_char

char_from_first_char

char_from_last_char

char_from_nth_char

str_contains_char

str_index_of_char

str_split_on_char

str_replace_first_char

str_replace_n_char

str_replace_all_char

str_remove_first_char

str_remove_n_char

str_remove_all_char

str_occurrences_of_char

str_reverse

str_head

str_tail

str_append_char

str_rest

str_but_last

str_drop

str_but_last_n

str_length

str_make_empty

str_is_empty_string

str_remove_nth

str_set_nth

str_strip_whitespace

char_is_whitespace

char_is_letter

char_is_digit

str_from_bool

str_from_int

str_from_float

str_from_char

char_from_bool

char_from_ascii_int

char_from_float

chars_from_str

bool_and

bool_or

bool_not

bool_xor

bool_invert_first_then_and

bool_second_first_then_and

bool_from_int

bool_from_float

noop

noop_open

code_is_code_block

code_is_singular

code_length

code_first

code_last

code_rest

code_but_last

code_wrap

code_list

code_combine

code_do

code_do_dup

code_do_then_pop

code_do_range

exec_do_range

code_do_count

exec_do_count

code_do_times

exec_do_times

exec_while

exec_do_while

code_map

code_if

exec_if

code_when

exec_when

code_member

code_nth

make_empty_code_block

is_empty_code_block

code_size

code_extract

code_insert

code_first_position

code_reverse

vector_int_concat

vector_int_conj

vector_int_take

vector_int_subvec

vector_int_first

vector_int_last

vector_int_nth

vector_int_rest

vector_int_but_last

vector_int_length

vector_int_reverse

vector_int_push_all

vector_int_empty_vector

vector_int_contains

vector_int_index_of

vector_int_occurrences_of

vector_int_set_nth

vector_int_replace

vector_int_replace_first

vector_int_remove

vector_int_iterate

vector_float_concat

vector_float_conj

vector_float_take

vector_float_subvec

vector_float_first

vector_float_last

vector_float_nth

vector_float_rest

vector_float_but_last

vector_float_length

vector_float_reverse

vector_float_push_all

vector_float_empty_vector

vector_float_contains

vector_float_index_of

vector_float_occurrences_of

vector_float_set_nth

vector_float_replace

vector_float_replace_first

vector_float_remove

vector_float_iterate

vector_str_concat

vector_str_conj

vector_str_take

vector_str_subvec

vector_str_first

vector_str_last

vector_str_nth

vector_str_rest

vector_str_but_last

vector_str_length

vector_str_reverse

vector_str_push_all

vector_str_empty_vector

vector_str_contains

vector_str_index_of

vector_str_occurrences_of

vector_str_set_nth

vector_str_replace

vector_str_replace_first

vector_str_remove

vector_str_iterate

vector_bool_concat

vector_bool_conj

vector_bool_take

vector_bool_subvec

vector_bool_first

vector_bool_last

vector_bool_nth

vector_bool_rest

vector_bool_but_last

vector_bool_length

vector_bool_reverse

vector_bool_push_all

vector_bool_empty_vector

vector_bool_contains

vector_bool_index_of

vector_bool_occurrences_of

vector_bool_set_nth

vector_bool_replace

vector_bool_replace_first

vector_bool_remove

vector_bool_iterate

vector_char_concat

vector_char_conj

vector_char_take

vector_char_subvec

vector_char_first

vector_char_last

vector_char_nth

vector_char_rest

vector_char_but_last

vector_char_length

vector_char_reverse

vector_char_push_all

vector_char_empty_vector

vector_char_contains

vector_char_index_of

vector_char_occurrences_of

vector_char_set_nth

vector_char_replace

vector_char_replace_first

vector_char_remove

vector_char_iterate

print_bool

println_bool

print_int

println_int

print_char

println_char

print_float

println_float

print_str

println_str

print_vector_int

println_vector_int

print_vector_float

println_vector_float

print_vector_str

println_vector_str

print_vector_bool

println_vector_bool

print_vector_char

println_vector_char

print_code

println_code

print_exec

println_exec

bool_pop

bool_dup

bool_dup_times

bool_swap

bool_rot

bool_flush

bool_eq

bool_stack_depth

bool_yank

bool_yank_dup

bool_shove

bool_shove_dup

bool_is_empty

int_pop

int_dup

int_dup_times

int_swap

int_rot

int_flush

int_eq

int_stack_depth

int_yank

int_yank_dup

int_shove

int_shove_dup

int_is_empty

char_pop

char_dup

char_dup_times

char_swap

char_rot

char_flush

char_eq

char_stack_depth

char_yank

char_yank_dup

char_shove

char_shove_dup

char_is_empty

float_pop

float_dup

float_dup_times

float_swap

float_rot

float_flush

float_eq

float_stack_depth

float_yank

float_yank_dup

float_shove

float_shove_dup

float_is_empty

str_pop

str_dup

str_dup_times

str_swap

str_rot

str_flush

str_eq

str_stack_depth

str_yank

str_yank_dup

str_shove

str_shove_dup

str_is_empty

vector_int_pop

vector_int_dup

vector_int_dup_times

vector_int_swap

vector_int_rot

vector_int_flush

vector_int_eq

vector_int_stack_depth

vector_int_yank

vector_int_yank_dup

vector_int_shove

vector_int_shove_dup

vector_int_is_empty

vector_float_pop

vector_float_dup

vector_float_dup_times

vector_float_swap

vector_float_rot

vector_float_flush

vector_float_eq

vector_float_stack_depth

vector_float_yank

vector_float_yank_dup

vector_float_shove

vector_float_shove_dup

vector_float_is_empty

vector_str_pop

vector_str_dup

vector_str_dup_times

vector_str_swap

vector_str_rot

vector_str_flush

vector_str_eq

vector_str_stack_depth

vector_str_yank

vector_str_yank_dup

vector_str_shove

vector_str_shove_dup

vector_str_is_empty

vector_bool_pop

vector_bool_dup

vector_bool_dup_times

vector_bool_swap

vector_bool_rot

vector_bool_flush

vector_bool_eq

vector_bool_stack_depth

vector_bool_yank

vector_bool_yank_dup

vector_bool_shove

vector_bool_shove_dup

vector_bool_is_empty

vector_char_pop

vector_char_dup

vector_char_dup_times

vector_char_swap

vector_char_rot

vector_char_flush

vector_char_eq

vector_char_stack_depth

vector_char_yank

vector_char_yank_dup

vector_char_shove

vector_char_shove_dup

vector_char_is_empty

code_pop

code_dup

code_dup_times

code_swap

code_rot

code_flush

code_eq

code_stack_depth

code_yank

code_yank_dup

code_shove

code_shove_dup

code_is_empty

exec_pop

exec_dup

exec_dup_times

exec_swap

exec_rot

exec_flush

exec_eq

exec_stack_depth

exec_yank

exec_yank_dup

exec_shove

exec_shove_dup

exec_is_empty

code_from_bool

code_from_int

code_from_char

code_from_float

code_from_str

code_from_vector_int

code_from_vector_float

code_from_vector_str

code_from_vector_bool

code_from_vector_char

code_from_exec

Previous topic

Push Instructions

Next topic

Push Types

This Page

Show Source

Quick search

    <form class="search" action="search.html" method="get">
      <input type="text" name="q" aria-labelledby="searchlabel" />
      <input type="submit" value="Go" />
    </form>

Navigation

          index

          modules |

          next |

          previous |

PyshGP 0.1.8 documentation »

Push Instructions »

PyshGP Core Instruction Set

        © Copyright 2020, Edward Pantridge.
      Created using Sphinx 3.2.1.


text:
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.telcolab</groupId>
    <artifactId>telcolab-firewall</artifactId>
    <version>1.0</version>
    <packaging>bundle</packaging>

    <description>Applicazione di forwarding e firewall che utilizza il servizio di intent.</description>

    <properties>
        <onos.version>1.2.1</onos.version>
        <onos.app.name>org.telcolab.firewall</onos.app.name>
        <onos.app.origin>telcolab, UNIMIB</onos.app.origin>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.onosproject</groupId>
            <artifactId>onos-api</artifactId>
            <version>${onos.version}</version>
        </dependency>

        <dependency>
            <groupId>org.onosproject</groupId>
            <artifactId>onlab-osgi</artifactId>
            <version>${onos.version}</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.onosproject</groupId>
            <artifactId>onos-api</artifactId>
            <version>${onos.version}</version>
            <scope>test</scope>
            <classifier>tests</classifier>
        </dependency>

        <dependency>
            <groupId>org.apache.felix</groupId>
            <artifactId>org.apache.felix.scr.annotations</artifactId>
            <version>1.9.8</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-bundle-plugin</artifactId>
                <version>2.5.3</version>
                <extensions>true</extensions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-scr-plugin</artifactId>
                <version>1.20.0</version>
                <executions>
                    <execution>
                        <id>generate-scr-srcdescriptor</id>
                        <goals>
                            <goal>scr</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <supportedProjectTypes>
                        <supportedProjectType>bundle</supportedProjectType>
                        <supportedProjectType>war</supportedProjectType>
                    </supportedProjectTypes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.onosproject</groupId>
                <artifactId>onos-maven-plugin</artifactId>
                <version>1.4</version>
                <executions>
                    <execution>
                        <id>cfg</id>
                        <phase>generate-resources</phase>
                        <goals>
                            <goal>cfg</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>app</id>
                        <phase>package</phase>
                        <goals>
                            <goal>app</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

redpajama_set_name: RedPajamaGithub


text:
{% load staticfiles %}

<!DOCTYPE html>

	<meta charset="utf-8">
	<title>งานฟุตบอลประเพณีธรรมศาสตร์–จุฬาฯ ครั้งที่ 71</title>
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta name="description" content="">
	<meta name="author" content="">

	<link href="{% static 'css/bootstrap.min.css' %}" rel="stylesheet">

	<link href="{% static 'css/cropper.min.css' %}" rel="stylesheet">

      <link href="{% static 'css/tucuball.css' %}" rel="stylesheet">

    {% block extra_css %}{% endblock extra_css %}

			<button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
				Toggle navigation

			</button>
			 หน้าหลัก

เปลี่ยนรูปโปรไฟล์

สร้างเพลท

ผลลัพธ์

				กรุณารอสักครู่

		<canvas id="plateCanvas" style="display:none;" width="1912" height="1010"></canvas>


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- Generated Jun 17, 2015 12:30:00 PM by Hibernate Tools 4.3.1 -->
<hibernate-mapping>
  <class name="com.models.Mblfscyllah" optimistic-lock="version" schema="USCYLLA5" table="MBLFSCYLLAH">
    <id name="id" type="big_decimal">
      <column name="ID" precision="22" scale="0"/>
      <generator class="assigned"/>
    </id>
    <property name="kode" type="string">
      <column length="30" name="KODE"/>
    </property>
    <property name="tgl" type="string">
      <column length="8" name="TGL"/>
    </property>
    <property name="slsno" type="string">
      <column length="20" name="SLSNO"/>
    </property>
    <property name="distri" type="string">
      <column length="20" name="DISTRI"/>
    </property>
    <property name="status" type="string">
      <column length="1" name="STATUS"/>
    </property>
    <property name="stprs" type="string">
      <column length="1" name="STPRS"/>
    </property>
  </class>
</hibernate-mapping>


text:
import tempfile

from airflow.hooks.hive_hooks import HiveServer2Hook
from airflow.hooks.samba_hook import SambaHook
from airflow.models import BaseOperator
from airflow.utils.decorators import apply_defaults

class Hive2SambaOperator(BaseOperator):
    """
    Executes hql code in a specific Hive database and loads the
    results of the query as a csv to a Samba location.

    :param hql: the hql to be exported
    :type hql: string
    :param hiveserver2_conn_id: reference to the hiveserver2 service
    :type hiveserver2_conn_id: string
    :param samba_conn_id: reference to the samba destination
    :type samba_conn_id: string
    """

    template_fields = ('hql', 'destination_filepath')
    template_ext = ('.hql', '.sql',)

    @apply_defaults
    def __init__(
            self, hql,
            destination_filepath,
            samba_conn_id='samba_default',
            hiveserver2_conn_id='hiveserver2_default',
            *args, **kwargs):
        super(Hive2SambaOperator, self).__init__(*args, **kwargs)

        self.hiveserver2_conn_id = hiveserver2_conn_id
        self.samba_conn_id = samba_conn_id
        self.destination_filepath = destination_filepath
        self.hql = hql.strip().rstrip(';')

    def execute(self, context):
        samba = SambaHook(samba_conn_id=self.samba_conn_id)
        hive = HiveServer2Hook(hiveserver2_conn_id=self.hiveserver2_conn_id)
        tmpfile = tempfile.NamedTemporaryFile()
        self.log.info("Fetching file from Hive")
        hive.to_csv(hql=self.hql, csv_filepath=tmpfile.name)
        self.log.info("Pushing to samba")
        samba.push_from_local(self.destination_filepath, tmpfile.name)


text:
@interface FeedChooserTitleView ()

@property (nonatomic) UIButton *invisibleHeaderButton;
@property (nonatomic, strong) UIFontDescriptor *fontDescriptor;

@end

@implementation FeedChooserTitleView

- (void)drawRect:(CGRect)rect {
    CGContextRef context = UIGraphicsGetCurrentContext();
    for (UIView *subview in self.subviews) {
        [subview removeFromSuperview];
    }

    // Create the parent view that will hold header Label
    UIView *customView = [[UIView alloc] initWithFrame:rect];

    // Background
    [NewsBlurAppDelegate fillGradient:rect
                           startColor:UIColorFromLightSepiaMediumDarkRGB(0xEAECE5, 0xffffc6, 0x6A6A6A, 0x444444)
                             endColor:UIColorFromLightSepiaMediumDarkRGB(0xDCDFD6, 0xffffc0, 0x666666, 0x333333)];

    // Borders
    UIColor *topColor = UIColorFromLightSepiaMediumDarkRGB(0xFDFDFD, 0xFDFDF6, 0x878B8A, 0x474B4A);
    CGContextSetStrokeColor(context, CGColorGetComponents([topColor CGColor]));

    CGContextBeginPath(context);
    CGContextMoveToPoint(context, 0, 0.25f);
    CGContextAddLineToPoint(context, rect.size.width, 0.25f);
    CGContextStrokePath(context);

    // bottom border
    UIColor *bottomColor = UIColorFromLightSepiaMediumDarkRGB(0xB7BBAA, 0xe0e0a6, 0x404040, 0x0D0D0D);
    CGContextSetStrokeColor(context, CGColorGetComponents([bottomColor CGColor]));
    CGContextBeginPath(context);
    CGContextMoveToPoint(context, 0, rect.size.height-0.25f);
    CGContextAddLineToPoint(context, rect.size.width, rect.size.height-0.25f);
    CGContextStrokePath(context);

    // Folder title
    UIColor *textColor = UIColorFromRGB(0x4C4D4A);
    UIFont *font = [UIFont fontWithDescriptor:self.fontDescriptor size:0.0];
    NSInteger titleOffsetY = ((rect.size.height - font.pointSize) / 2) - 1;
    UIColor *shadowColor = UIColorFromRGB(0xF0F2E9);
    CGContextSetShadowWithColor(context, CGSizeMake(0, 1), 0, [shadowColor CGColor]);

    NSMutableParagraphStyle *paragraphStyle = [[NSMutableParagraphStyle defaultParagraphStyle] mutableCopy];
    paragraphStyle.lineBreakMode = NSLineBreakByTruncatingTail;
    paragraphStyle.alignment = NSTextAlignmentLeft;
    [self.title drawInRect:CGRectMake(36.0, titleOffsetY, rect.size.width - 36 - 36, font.pointSize)
     withAttributes:@{NSFontAttributeName: font,
                      NSForegroundColorAttributeName: textColor,
                      NSParagraphStyleAttributeName: paragraphStyle}];

    self.invisibleHeaderButton = [UIButton buttonWithType:UIButtonTypeCustom];
    self.invisibleHeaderButton.frame = CGRectMake(0, 0, customView.frame.size.width, customView.frame.size.height);
    self.invisibleHeaderButton.alpha = 0.1;
    self.invisibleHeaderButton.tag = self.section;
    self.invisibleHeaderButton.accessibilityLabel = [NSString stringWithFormat:@"%@ folder", self.title];
    self.invisibleHeaderButton.accessibilityTraits = UIAccessibilityTraitNone;
    [self.invisibleHeaderButton addTarget:self.delegate
                              action:@selector(didSelectTitleView:)
                    forControlEvents:UIControlEventTouchUpInside];
    [customView addSubview:self.invisibleHeaderButton];

    UIImage *folderImage = [UIImage imageNamed:@"folder-open"];
    CGFloat folderImageViewX = 10.0;

    if ([[UIDevice currentDevice] userInterfaceIdiom] != UIUserInterfaceIdiomPad) {
        folderImageViewX = 7.0;
    }

    [folderImage drawInRect:CGRectMake(folderImageViewX, 8.0, 20.0, 20.0)];

    [self addSubview:customView];
}

- (UIFontDescriptor *)fontDescriptor {
    if (!_fontDescriptor) {
        UIFontDescriptor *captionFontDescriptor = [UIFontDescriptor preferredFontDescriptorWithTextStyle:UIFontTextStyleCaption1];
        UIFontDescriptor *boldFontDescriptor = [captionFontDescriptor fontDescriptorWithSymbolicTraits:UIFontDescriptorTraitBold];
        self.fontDescriptor = [boldFontDescriptor fontDescriptorWithSize:12.0];
    }

    return _fontDescriptor;
}

@end


text:
<!DOCTYPE html>

    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <link rel="icon"
          type="image/x-icon"
          href="/tc-static/src/resources/images/favicon.ico"/>
    <title>502</title>
    <link href="/tc-static/src/resources/libs/core/normalize.min.css"
          type="text/css"
          rel="stylesheet"/>
    <link href="/tc-static/src/resources/libs/layui/css/layui.css"
          type="text/css"
          rel="stylesheet"/>
    <link href="/tc-static/src/resources/styles/global/header_menu_footer.css"
          type="text/css"
          rel="stylesheet"/>

              这只是一个实验工程而已

    <fieldset>
        <legend>  抱歉,服务器正在维护中,请稍后再试。  </legend>

The server is in maintenance. Please try again later.

            重试

    </fieldset>


text:
require "fileutils"
require "rubygems"
require 'minimal-http-ruby'

puts "minimal-http-ruby Initializer"

target=ARGV[0]||"./http"

if File.directory? target
  puts "Error: #{target} Already Exists -- Cannot create!"
  exit(-1)
end

Dir.mkdir target
if File.directory? target
  puts "Copying Files..."
  path=File.join( Gem.loaded_specs['minimal-http-ruby'].full_gem_path, 'http/')
  FileUtils.cp_r "#{path}/.", "#{target}"
  puts "Created OK!"
  puts "Next, please edit file: #{target}/haml/index.haml to get started!"
  system "tree #{target}"
end


text:
// Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.firebase.appcheck.debug.internal;

import static com.google.common.truth.Truth.assertThat;

import android.content.Context;
import android.content.SharedPreferences;
import androidx.test.core.app.ApplicationProvider;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;

/** Tests for {@link StorageHelper} */
@RunWith(RobolectricTestRunner.class)
public class StorageHelperTest {

  private static final String PERSISTENCE_KEY = "persistenceKey";
  private static final String DEBUG_SECRET = "debugSecret";

  private StorageHelper storageHelper;
  private SharedPreferences sharedPreferences;

  @Before
  public void setUp() {
    storageHelper = new StorageHelper(ApplicationProvider.getApplicationContext(), PERSISTENCE_KEY);
    sharedPreferences =
        ApplicationProvider.getApplicationContext()
            .getSharedPreferences(
                String.format(StorageHelper.PREFS_TEMPLATE, PERSISTENCE_KEY), Context.MODE_PRIVATE);
  }

  @After
  public void tearDown() {
    sharedPreferences.edit().clear().commit();
  }

  @Test
  public void testSaveDebugSecret_sharedPrefsWritten() {
    storageHelper.saveDebugSecret(DEBUG_SECRET);
    String debugSecret = sharedPreferences.getString(StorageHelper.DEBUG_SECRET_KEY, null);
    assertThat(debugSecret).isNotEmpty();
    assertThat(debugSecret).isEqualTo(DEBUG_SECRET);
  }

  @Test
  public void testSaveDebugSecret_expectEquivalentToken() {
    storageHelper.saveDebugSecret(DEBUG_SECRET);
    String debugSecret = storageHelper.retrieveDebugSecret();
    assertThat(debugSecret).isNotEmpty();
    assertThat(debugSecret).isEqualTo(DEBUG_SECRET);
  }

  @Test
  public void testRetrieveDebugSecret_defaultNull() {
    String debugSecret = storageHelper.retrieveDebugSecret();
    assertThat(debugSecret).isNull();
  }
}


text:
from insights.core import JSONParser
from insights.core.plugins import parser
from insights.specs import Specs

@parser(Specs.tags)
class Tags(JSONParser):
    """ Class for parsing the content of ``tags.json``."""
    pass


text:
package io.druid.indexer;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import io.druid.data.input.InputRow;
import io.druid.data.input.impl.DimensionsSpec;
import io.druid.data.input.impl.JSONParseSpec;
import io.druid.data.input.impl.TimestampSpec;
import io.druid.indexer.path.StaticPathSpec;
import io.druid.java.util.common.granularity.Granularities;
import io.druid.java.util.common.jackson.JacksonUtils;
import io.druid.java.util.common.parsers.JSONPathSpec;
import io.druid.math.expr.ExprMacroTable;
import io.druid.query.aggregation.AggregatorFactory;
import io.druid.query.aggregation.CountAggregatorFactory;
import io.druid.query.filter.SelectorDimFilter;
import io.druid.segment.TestHelper;
import io.druid.segment.indexing.DataSchema;
import io.druid.segment.transform.ExpressionTransform;
import io.druid.segment.transform.TransformSpec;
import io.druid.segment.indexing.granularity.UniformGranularitySpec;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.easymock.EasyMock;
import org.junit.Assert;
import org.junit.Test;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class HadoopDruidIndexerMapperTest
{
  private static final ObjectMapper JSON_MAPPER = TestHelper.makeJsonMapper();
  private static final DataSchema DATA_SCHEMA = new DataSchema(
      "test_ds",
      JSON_MAPPER.convertValue(
          new HadoopyStringInputRowParser(
              new JSONParseSpec(
                  new TimestampSpec("t", "auto", null),
                  new DimensionsSpec(
                      DimensionsSpec.getDefaultSchemas(ImmutableList.of("dim1", "dim1t", "dim2")),
                      null,
                      null
                  ),
                  new JSONPathSpec(true, ImmutableList.of()),
                  ImmutableMap.of()
              )
          ),
          JacksonUtils.TYPE_REFERENCE_MAP_STRING_OBJECT
      ),
      new AggregatorFactory[]{new CountAggregatorFactory("rows")},
      new UniformGranularitySpec(Granularities.DAY, Granularities.NONE, null),
      null,
      JSON_MAPPER
  );

  private static final HadoopIOConfig IO_CONFIG = new HadoopIOConfig(
      JSON_MAPPER.convertValue(
          new StaticPathSpec("dummyPath", null),
          JacksonUtils.TYPE_REFERENCE_MAP_STRING_OBJECT
      ),
      null,
      "dummyOutputPath"
  );

  private static final HadoopTuningConfig TUNING_CONFIG = HadoopTuningConfig
      .makeDefaultTuningConfig()
      .withWorkingPath("dummyWorkingPath");

  @Test
  public void testHadoopyStringParser() throws Exception
  {
    final HadoopDruidIndexerConfig config = new HadoopDruidIndexerConfig(
        new HadoopIngestionSpec(DATA_SCHEMA, IO_CONFIG, TUNING_CONFIG)
    );

    final MyMapper mapper = new MyMapper();
    final Configuration hadoopConfig = new Configuration();
    hadoopConfig.set(
        HadoopDruidIndexerConfig.CONFIG_PROPERTY,
        HadoopDruidIndexerConfig.JSON_MAPPER.writeValueAsString(config)
    );
    final Mapper.Context mapContext = EasyMock.mock(Mapper.Context.class);
    EasyMock.expect(mapContext.getConfiguration()).andReturn(hadoopConfig).once();
    EasyMock.replay(mapContext);
    mapper.setup(mapContext);
    final List<Map<String, Object>> rows = ImmutableList.of(
        ImmutableMap.of("t", "2000-01-01T00:00:00.000Z", "dim1", "x", "m1", 1.0),
        ImmutableMap.of("t", "2000-01-01T00:00:00.000Z", "dim2", "y", "m1", 1.0)
    );
    for (Map<String, Object> row : rows) {
      mapper.map(NullWritable.get(), new Text(JSON_MAPPER.writeValueAsString(row)), mapContext);
    }
    assertRowListEquals(rows, mapper.getRows());
  }

  @Test
  public void testHadoopyStringParserWithTransformSpec() throws Exception
  {
    final HadoopDruidIndexerConfig config = new HadoopDruidIndexerConfig(
        new HadoopIngestionSpec(
            DATA_SCHEMA.withTransformSpec(
                new TransformSpec(
                    new SelectorDimFilter("dim1", "foo", null),
                    ImmutableList.of(
                        new ExpressionTransform("dim1t", "concat(dim1,dim1)", ExprMacroTable.nil())
                    )
                )
            ),
            IO_CONFIG,
            TUNING_CONFIG
        )
    );

    final MyMapper mapper = new MyMapper();
    final Configuration hadoopConfig = new Configuration();
    hadoopConfig.set(
        HadoopDruidIndexerConfig.CONFIG_PROPERTY,
        HadoopDruidIndexerConfig.JSON_MAPPER.writeValueAsString(config)
    );
    final Mapper.Context mapContext = EasyMock.mock(Mapper.Context.class);
    EasyMock.expect(mapContext.getConfiguration()).andReturn(hadoopConfig).once();
    EasyMock.replay(mapContext);
    mapper.setup(mapContext);
    final List<Map<String, Object>> rows = ImmutableList.of(
        ImmutableMap.of("t", "2000-01-01T00:00:00.000Z", "dim1", "foo", "dim2", "x", "m1", 1.0),
        ImmutableMap.of("t", "2000-01-01T00:00:00.000Z", "dim1", "bar", "dim2", "y", "m1", 1.0),
        ImmutableMap.of("t", "2000-01-01T00:00:00.000Z", "dim1", "foo", "dim2", "z", "m1", 1.0)
    );
    for (Map<String, Object> row : rows) {
      mapper.map(NullWritable.get(), new Text(JSON_MAPPER.writeValueAsString(row)), mapContext);
    }
    assertRowListEquals(
        ImmutableList.of(
            ImmutableMap.of("t", "2000-01-01T00:00:00.000Z", "dim1", "foo", "dim1t", "foofoo", "dim2", "x", "m1", 1.0),
            ImmutableMap.of("t", "2000-01-01T00:00:00.000Z", "dim1", "foo", "dim1t", "foofoo", "dim2", "z", "m1", 1.0)
        ),
        mapper.getRows()
    );
  }

  private static void assertRowListEquals(final List<Map<String, Object>> expected, final List<InputRow> actual)
  {
    Assert.assertEquals(
        expected,
        actual.stream().map(HadoopDruidIndexerMapperTest::rowToMap).collect(Collectors.toList())
    );
  }

  private static Map<String, Object> rowToMap(final InputRow row)
  {
    // Normalize input row for the purposes of testing.
    final ImmutableMap.Builder<String, Object> builder = ImmutableMap.<String, Object>builder()
        .put("t", row.getTimestamp().toString());

    for (String dim : row.getDimensions()) {
      final Object val = row.getRaw(dim);
      if (val != null) {
        builder.put(dim, val);
      }
    }

    // other, non-dimension fields are not self describing so much be specified individually
    builder.put("m1", row.getRaw("m1"));
    return builder.build();
  }

  public static class MyMapper extends HadoopDruidIndexerMapper
  {
    private final List<InputRow> rows = new ArrayList<>();

    @Override
    protected void innerMap(
        final InputRow inputRow,
        final Context context,
        final boolean reportParseExceptions
    ) throws IOException, InterruptedException
    {
      rows.add(inputRow);
    }

    public List<InputRow> getRows()
    {
      return rows;
    }
  }
}


text:
namespace crypto {
namespace tink {
namespace subtle {

class DilithiumAvx2Verify : public PublicKeyVerify {
 public:
  static crypto::tink::util::StatusOr<std::unique_ptr<PublicKeyVerify>> New(
      DilithiumPublicKeyPqclean public_key);

  // Verifies that 'signature' is a digital signature for 'data'.
  crypto::tink::util::Status Verify(absl::string_view signature,
                                    absl::string_view data) const override;

  static constexpr crypto::tink::internal::FipsCompatibility kFipsStatus =
      crypto::tink::internal::FipsCompatibility::kNotFips;

 private:
  explicit DilithiumAvx2Verify(DilithiumPublicKeyPqclean public_key)
      : public_key_(public_key) {}

  DilithiumPublicKeyPqclean public_key_;
};

}  // namespace subtle
}  // namespace tink
}  // namespace crypto

#endif  // TINK_EXPERIMENTAL_PQCRYPTO_SIGNATURE_SUBTLE_DILITHIUM_AVX2_VERIFY_H_


text:
svn-merge-shell
===============

slell of merging svn code convincely
change list
1.init the git repository


text:
.. This work is licensed under a Creative Commons Attribution 4.0 International
.. License.
.. http://creativecommons.org/licenses/by/4.0
.. (c) OPNFV, Huawei Technologies Co.,Ltd and others.

*************************************
Yardstick Test Case Description TC043
*************************************

.. _cirros-image: https://download.cirros-cloud.net

+-----------------------------------------------------------------------------+
|Network Latency Between NFVI Nodes                                           |
|                                                                             |
+--------------+--------------------------------------------------------------+
|test case id  | OPNFV_YARDSTICK_TC043_Latency_between_NFVI_nodes_            |
|              | measurements                                                 |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|metric        | RTT, Round Trip Time                                         |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|test purpose  | To do a basic verification that network latency is within    |
|              | acceptable boundaries when packets travel between different  |
|              | nodes.                                                       |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|configuration | file: opnfv_yardstick_tc043.yaml                             |
|              |                                                              |
|              | Packet size 100 bytes. Total test duration 600 seconds.      |
|              | One ping each 10 seconds. SLA RTT is set to maximum 10 ms.   |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|test tool     | ping                                                         |
|              |                                                              |
|              | Ping is normally part of any Linux distribution, hence it    |
|              | doesn't need to be installed. It is also part of the         |
|              | Yardstick Docker image.                                      |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|references    | Ping man page                                                |
|              |                                                              |
|              | ETSI-NFV-TST001                                              |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|applicability | Test case can be configured with different packet sizes,     |
|              | burst sizes, ping intervals and test duration.               |
|              | SLA is optional. The SLA in this test case serves as an      |
|              | example. Considerably lower RTT is expected, and             |
|              | also normal to achieve in balanced L2 environments. However, |
|              | to cover most configurations, both bare metal and fully      |
|              | virtualized ones, this value should be possible to achieve   |
|              | and acceptable for black box testing. Many real time         |
|              | applications start to suffer badly if the RTT time is higher |
|              | than this. Some may suffer bad also close to this RTT, while |
|              | others may not suffer at all. It is a compromise that may    |
|              | have to be tuned for different configuration purposes.       |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|pre_test      | Each pod node must have ping included in it.                 |
|conditions    |                                                              |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|test sequence | description and expected result                              |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|step 1        | The pod is available. Two nodes as server and client.        |
|              | Ping is invoked and logs are produced and stored.            |
|              |                                                              |
|              | Result: Logs are stored.                                     |
|              |                                                              |
+--------------+--------------------------------------------------------------+
|test verdict  | Test should not PASS if any RTT is above the optional SLA    |
|              | value, or if there is a test case execution problem.         |
|              |                                                              |
+--------------+--------------------------------------------------------------+


text:
<?php

use yii\helpers\Html;
use yii\widgets\ActiveForm;

/* @var $this yii\web\View */
/* @var $model frontend\models\CommentSearch */
/* @var $form yii\widgets\ActiveForm */
?>

    <?php $form = ActiveForm::begin([
        'action' => ['index'],
        'method' => 'get',
    ]); ?>

    <?= $form->field($model, 'id') ?>

    <?= $form->field($model, 'section_id') ?>

    <?= $form->field($model, 'parent') ?>

    <?= $form->field($model, 'status') ?>

    <?= $form->field($model, 'thumbsup') ?>

    <?php // echo $form->field($model, 'thumbsdown') ?>

    <?php // echo $form->field($model, 'content') ?>

    <?php // echo $form->field($model, 'created_at') ?>

    <?php // echo $form->field($model, 'updated_at') ?>

    <?php // echo $form->field($model, 'created_by') ?>

    <?php // echo $form->field($model, 'updated_by') ?>

        <?= Html::submitButton(Yii::t('frontend/comment', 'Search'), ['class' => 'btn btn-primary']) ?>
        <?= Html::resetButton(Yii::t('frontend/comment', 'Reset'), ['class' => 'btn btn-default']) ?>

    <?php ActiveForm::end(); ?>


text:
package org.apereo.cas.ticket;

import org.apereo.cas.authentication.ContextualAuthenticationPolicy;

import lombok.Getter;
import lombok.NonNull;

/**
 * Error condition arising at ticket creation or validation time when a ticketing operation relying on authentication
 * cannot proceed due to unsatisfied authentication security policy.
 *
 * @author Marvin S. Addison
 * @since 4.0.0
 */
@Getter
public class UnsatisfiedAuthenticationPolicyException extends AbstractTicketException {

    /**
     * Serializable ID for unique id.
     */
    private static final long serialVersionUID = -827432780367197133L;

    /**
     * Code description.
     */
    private static final String CODE = "UNSATISFIED_AUTHN_POLICY";

    /**
     * Unfulfilled policy that caused this exception.
     */
    private final ContextualAuthenticationPolicy<?> policy;

    /**
     * Creates a new instance with no cause.
     *
     * @param policy Non-null unfulfilled security policy that caused exception.
     */
    public UnsatisfiedAuthenticationPolicyException(@NonNull final ContextualAuthenticationPolicy<?> policy) {
        super(policy.getCode().orElse(CODE));
        this.policy = policy;
    }

}


text:
{% extends "template.html" %}
    {% block body %}
            <form class="form-horizontal" action="/user/update/" method="post">
                <input type="hidden" name="id" value="{{id}}" />
                {% if error %}

                    错误说明:

{{error}}

                {% endif %}

                    用户名:

                        <input type="text" class="form-control" name="username" value="{{username}}" readonly="readonly"/>

                    年龄:

                        <input class="form-control" type="text" name="age" value="{{age}}" />

                    <button type="submit" class="btn btn-default">修改</button>

            </form>
    {% endblock %}