Constants

Git Source

CMASK_NULL

ASCII null

uint128 constant CMASK_NULL = uint128(1) << uint128(uint8(bytes1("\x00")));

CMASK_START_OF_HEADING

ASCII start of heading

uint128 constant CMASK_START_OF_HEADING = uint128(1) << uint128(uint8(bytes1("\x01")));

CMASK_START_OF_TEXT

ASCII start of text

uint128 constant CMASK_START_OF_TEXT = uint128(1) << uint128(uint8(bytes1("\x02")));

CMASK_END_OF_TEXT

ASCII end of text

uint128 constant CMASK_END_OF_TEXT = uint128(1) << uint128(uint8(bytes1("\x03")));

CMASK_END_OF_TRANSMISSION

ASCII end of transmission

uint128 constant CMASK_END_OF_TRANSMISSION = uint128(1) << uint128(uint8(bytes1("\x04")));

CMASK_ENQUIRY

ASCII enquiry

uint128 constant CMASK_ENQUIRY = uint128(1) << uint128(uint8(bytes1("\x05")));

CMASK_ACKNOWLEDGE

ASCII acknowledge

uint128 constant CMASK_ACKNOWLEDGE = uint128(1) << uint128(uint8(bytes1("\x06")));

CMASK_BELL

ASCII bell

uint128 constant CMASK_BELL = uint128(1) << uint128(uint8(bytes1("\x07")));

CMASK_BACKSPACE

ASCII backspace

uint128 constant CMASK_BACKSPACE = uint128(1) << uint128(uint8(bytes1("\x08")));

CMASK_HORIZONTAL_TAB

ASCII horizontal tab

uint128 constant CMASK_HORIZONTAL_TAB = uint128(1) << uint128(uint8(bytes1("\t")));

CMASK_LINE_FEED

ASCII line feed

uint128 constant CMASK_LINE_FEED = uint128(1) << uint128(uint8(bytes1("\n")));

CMASK_VERTICAL_TAB

ASCII vertical tab

uint128 constant CMASK_VERTICAL_TAB = uint128(1) << uint128(uint8(bytes1("\x0B")));

CMASK_FORM_FEED

ASCII form feed

uint128 constant CMASK_FORM_FEED = uint128(1) << uint128(uint8(bytes1("\x0C")));

CMASK_CARRIAGE_RETURN

ASCII carriage return

uint128 constant CMASK_CARRIAGE_RETURN = uint128(1) << uint128(uint8(bytes1("\r")));

CMASK_SHIFT_OUT

ASCII shift out

uint128 constant CMASK_SHIFT_OUT = uint128(1) << uint128(uint8(bytes1("\x0E")));

CMASK_SHIFT_IN

ASCII shift in

uint128 constant CMASK_SHIFT_IN = uint128(1) << uint128(uint8(bytes1("\x0F")));

CMASK_DATA_LINK_ESCAPE

ASCII data link escape

uint128 constant CMASK_DATA_LINK_ESCAPE = uint128(1) << uint128(uint8(bytes1("\x10")));

CMASK_DEVICE_CONTROL_1

ASCII device control 1

uint128 constant CMASK_DEVICE_CONTROL_1 = uint128(1) << uint128(uint8(bytes1("\x11")));

CMASK_DEVICE_CONTROL_2

ASCII device control 2

uint128 constant CMASK_DEVICE_CONTROL_2 = uint128(1) << uint128(uint8(bytes1("\x12")));

CMASK_DEVICE_CONTROL_3

ASCII device control 3

uint128 constant CMASK_DEVICE_CONTROL_3 = uint128(1) << uint128(uint8(bytes1("\x13")));

CMASK_DEVICE_CONTROL_4

ASCII device control 4

uint128 constant CMASK_DEVICE_CONTROL_4 = uint128(1) << uint128(uint8(bytes1("\x14")));

CMASK_NEGATIVE_ACKNOWLEDGE

ASCII negative acknowledge

uint128 constant CMASK_NEGATIVE_ACKNOWLEDGE = uint128(1) << uint128(uint8(bytes1("\x15")));

CMASK_SYNCHRONOUS_IDLE

ASCII synchronous idle

uint128 constant CMASK_SYNCHRONOUS_IDLE = uint128(1) << uint128(uint8(bytes1("\x16")));

CMASK_END_OF_TRANSMISSION_BLOCK

ASCII end of transmission block

uint128 constant CMASK_END_OF_TRANSMISSION_BLOCK = uint128(1) << uint128(uint8(bytes1("\x17")));

CMASK_CANCEL

ASCII cancel

uint128 constant CMASK_CANCEL = uint128(1) << uint128(uint8(bytes1("\x18")));

CMASK_END_OF_MEDIUM

ASCII end of medium

uint128 constant CMASK_END_OF_MEDIUM = uint128(1) << uint128(uint8(bytes1("\x19")));

CMASK_SUBSTITUTE

ASCII substitute

uint128 constant CMASK_SUBSTITUTE = uint128(1) << uint128(uint8(bytes1("\x1A")));

CMASK_ESCAPE

ASCII escape

uint128 constant CMASK_ESCAPE = uint128(1) << uint128(uint8(bytes1("\x1B")));

CMASK_FILE_SEPARATOR

ASCII file separator

uint128 constant CMASK_FILE_SEPARATOR = uint128(1) << uint128(uint8(bytes1("\x1C")));

CMASK_GROUP_SEPARATOR

ASCII group separator

uint128 constant CMASK_GROUP_SEPARATOR = uint128(1) << uint128(uint8(bytes1("\x1D")));

CMASK_RECORD_SEPARATOR

ASCII record separator

uint128 constant CMASK_RECORD_SEPARATOR = uint128(1) << uint128(uint8(bytes1("\x1E")));

CMASK_UNIT_SEPARATOR

ASCII unit separator

uint128 constant CMASK_UNIT_SEPARATOR = uint128(1) << uint128(uint8(bytes1("\x1F")));

CMASK_SPACE

ASCII space

uint128 constant CMASK_SPACE = uint128(1) << uint128(uint8(bytes1(" ")));

CMASK_EXCLAMATION_MARK

ASCII !

uint128 constant CMASK_EXCLAMATION_MARK = uint128(1) << uint128(uint8(bytes1("!")));

CMASK_QUOTATION_MARK

ASCII "

uint128 constant CMASK_QUOTATION_MARK = uint128(1) << uint128(uint8(bytes1("\"")));

CMASK_NUMBER_SIGN

ASCII #

uint128 constant CMASK_NUMBER_SIGN = uint128(1) << uint128(uint8(bytes1("#")));

CMASK_DOLLAR_SIGN

ASCII $

uint128 constant CMASK_DOLLAR_SIGN = uint128(1) << uint128(uint8(bytes1("$")));

CMASK_PERCENT_SIGN

ASCII %

uint128 constant CMASK_PERCENT_SIGN = uint128(1) << uint128(uint8(bytes1("%")));

CMASK_AMPERSAND

ASCII &

uint128 constant CMASK_AMPERSAND = uint128(1) << uint128(uint8(bytes1("&")));

CMASK_APOSTROPHE

ASCII '

uint128 constant CMASK_APOSTROPHE = uint128(1) << uint128(uint8(bytes1("'")));

CMASK_LEFT_PAREN

ASCII (

uint128 constant CMASK_LEFT_PAREN = uint128(1) << uint128(uint8(bytes1("(")));

CMASK_RIGHT_PAREN

ASCII )

uint128 constant CMASK_RIGHT_PAREN = uint128(1) << uint128(uint8(bytes1(")")));

CMASK_ASTERISK

*ASCII **

uint128 constant CMASK_ASTERISK = uint128(1) << uint128(uint8(bytes1("*")));

CMASK_PLUS_SIGN

ASCII +

uint128 constant CMASK_PLUS_SIGN = uint128(1) << uint128(uint8(bytes1("+")));

CMASK_COMMA

ASCII ,

uint128 constant CMASK_COMMA = uint128(1) << uint128(uint8(bytes1(",")));

CMASK_DASH

ASCII -

uint128 constant CMASK_DASH = uint128(1) << uint128(uint8(bytes1("-")));

CMASK_FULL_STOP

ASCII .

uint128 constant CMASK_FULL_STOP = uint128(1) << uint128(uint8(bytes1(".")));

CMASK_SLASH

ASCII /

uint128 constant CMASK_SLASH = uint128(1) << uint128(uint8(bytes1("/")));

CMASK_ZERO

ASCII 0

uint128 constant CMASK_ZERO = uint128(1) << uint128(uint8(bytes1("0")));

CMASK_ONE

ASCII 1

uint128 constant CMASK_ONE = uint128(1) << uint128(uint8(bytes1("1")));

CMASK_TWO

ASCII 2

uint128 constant CMASK_TWO = uint128(1) << uint128(uint8(bytes1("2")));

CMASK_THREE

ASCII 3

uint128 constant CMASK_THREE = uint128(1) << uint128(uint8(bytes1("3")));

CMASK_FOUR

ASCII 4

uint128 constant CMASK_FOUR = uint128(1) << uint128(uint8(bytes1("4")));

CMASK_FIVE

ASCII 5

uint128 constant CMASK_FIVE = uint128(1) << uint128(uint8(bytes1("5")));

CMASK_SIX

ASCII 6

uint128 constant CMASK_SIX = uint128(1) << uint128(uint8(bytes1("6")));

CMASK_SEVEN

ASCII 7

uint128 constant CMASK_SEVEN = uint128(1) << uint128(uint8(bytes1("7")));

CMASK_EIGHT

ASCII 8

uint128 constant CMASK_EIGHT = uint128(1) << uint128(uint8(bytes1("8")));

CMASK_NINE

ASCII 9

uint128 constant CMASK_NINE = uint128(1) << uint128(uint8(bytes1("9")));

CMASK_COLON

ASCII :

uint128 constant CMASK_COLON = uint128(1) << uint128(uint8(bytes1(":")));

CMASK_SEMICOLON

ASCII ;

uint128 constant CMASK_SEMICOLON = uint128(1) << uint128(uint8(bytes1(";")));

CMASK_LESS_THAN_SIGN

ASCII <

uint128 constant CMASK_LESS_THAN_SIGN = uint128(1) << uint128(uint8(bytes1("<")));

CMASK_EQUALS_SIGN

ASCII =

uint128 constant CMASK_EQUALS_SIGN = uint128(1) << uint128(uint8(bytes1("=")));

CMASK_GREATER_THAN_SIGN

ASCII >

uint128 constant CMASK_GREATER_THAN_SIGN = uint128(1) << uint128(uint8(bytes1(">")));

CMASK_QUESTION_MARK

ASCII ?

uint128 constant CMASK_QUESTION_MARK = uint128(1) << uint128(uint8(bytes1("?")));

CMASK_AT_SIGN

ASCII @

uint128 constant CMASK_AT_SIGN = uint128(1) << uint128(uint8(bytes1("@")));

CMASK_UPPER_A

ASCII A

uint128 constant CMASK_UPPER_A = uint128(1) << uint128(uint8(bytes1("A")));

CMASK_UPPER_B

ASCII B

uint128 constant CMASK_UPPER_B = uint128(1) << uint128(uint8(bytes1("B")));

CMASK_UPPER_C

ASCII C

uint128 constant CMASK_UPPER_C = uint128(1) << uint128(uint8(bytes1("C")));

CMASK_UPPER_D

ASCII D

uint128 constant CMASK_UPPER_D = uint128(1) << uint128(uint8(bytes1("D")));

CMASK_UPPER_E

ASCII E

uint128 constant CMASK_UPPER_E = uint128(1) << uint128(uint8(bytes1("E")));

CMASK_UPPER_F

ASCII F

uint128 constant CMASK_UPPER_F = uint128(1) << uint128(uint8(bytes1("F")));

CMASK_UPPER_G

ASCII G

uint128 constant CMASK_UPPER_G = uint128(1) << uint128(uint8(bytes1("G")));

CMASK_UPPER_H

ASCII H

uint128 constant CMASK_UPPER_H = uint128(1) << uint128(uint8(bytes1("H")));

CMASK_UPPER_I

ASCII I

uint128 constant CMASK_UPPER_I = uint128(1) << uint128(uint8(bytes1("I")));

CMASK_UPPER_J

ASCII J

uint128 constant CMASK_UPPER_J = uint128(1) << uint128(uint8(bytes1("J")));

CMASK_UPPER_K

ASCII K

uint128 constant CMASK_UPPER_K = uint128(1) << uint128(uint8(bytes1("K")));

CMASK_UPPER_L

ASCII L

uint128 constant CMASK_UPPER_L = uint128(1) << uint128(uint8(bytes1("L")));

CMASK_UPPER_M

ASCII M

uint128 constant CMASK_UPPER_M = uint128(1) << uint128(uint8(bytes1("M")));

CMASK_UPPER_N

ASCII N

uint128 constant CMASK_UPPER_N = uint128(1) << uint128(uint8(bytes1("N")));

CMASK_UPPER_O

ASCII O

uint128 constant CMASK_UPPER_O = uint128(1) << uint128(uint8(bytes1("O")));

CMASK_UPPER_P

ASCII P

uint128 constant CMASK_UPPER_P = uint128(1) << uint128(uint8(bytes1("P")));

CMASK_UPPER_Q

ASCII Q

uint128 constant CMASK_UPPER_Q = uint128(1) << uint128(uint8(bytes1("Q")));

CMASK_UPPER_R

ASCII R

uint128 constant CMASK_UPPER_R = uint128(1) << uint128(uint8(bytes1("R")));

CMASK_UPPER_S

ASCII S

uint128 constant CMASK_UPPER_S = uint128(1) << uint128(uint8(bytes1("S")));

CMASK_UPPER_T

ASCII T

uint128 constant CMASK_UPPER_T = uint128(1) << uint128(uint8(bytes1("T")));

CMASK_UPPER_U

ASCII U

uint128 constant CMASK_UPPER_U = uint128(1) << uint128(uint8(bytes1("U")));

CMASK_UPPER_V

ASCII V

uint128 constant CMASK_UPPER_V = uint128(1) << uint128(uint8(bytes1("V")));

CMASK_UPPER_W

ASCII W

uint128 constant CMASK_UPPER_W = uint128(1) << uint128(uint8(bytes1("W")));

CMASK_UPPER_X

ASCII X

uint128 constant CMASK_UPPER_X = uint128(1) << uint128(uint8(bytes1("X")));

CMASK_UPPER_Y

ASCII Y

uint128 constant CMASK_UPPER_Y = uint128(1) << uint128(uint8(bytes1("Y")));

CMASK_UPPER_Z

ASCII Z

uint128 constant CMASK_UPPER_Z = uint128(1) << uint128(uint8(bytes1("Z")));

CMASK_LEFT_SQUARE_BRACKET

ASCII [

uint128 constant CMASK_LEFT_SQUARE_BRACKET = uint128(1) << uint128(uint8(bytes1("[")));

CMASK_BACKSLASH

*ASCII *

uint128 constant CMASK_BACKSLASH = uint128(1) << uint128(uint8(bytes1("\\")));

CMASK_RIGHT_SQUARE_BRACKET

ASCII ]

uint128 constant CMASK_RIGHT_SQUARE_BRACKET = uint128(1) << uint128(uint8(bytes1("]")));

CMASK_CIRCUMFLEX_ACCENT

ASCII ^

uint128 constant CMASK_CIRCUMFLEX_ACCENT = uint128(1) << uint128(uint8(bytes1("^")));

CMASK_UNDERSCORE

ASCII _

uint128 constant CMASK_UNDERSCORE = uint128(1) << uint128(uint8(bytes1("_")));

CMASK_GRAVE_ACCENT

ASCII `

uint128 constant CMASK_GRAVE_ACCENT = uint128(1) << uint128(uint8(bytes1("`")));

CMASK_LOWER_A

ASCII a

uint128 constant CMASK_LOWER_A = uint128(1) << uint128(uint8(bytes1("a")));

CMASK_LOWER_B

ASCII b

uint128 constant CMASK_LOWER_B = uint128(1) << uint128(uint8(bytes1("b")));

CMASK_LOWER_C

ASCII c

uint128 constant CMASK_LOWER_C = uint128(1) << uint128(uint8(bytes1("c")));

CMASK_LOWER_D

ASCII d

uint128 constant CMASK_LOWER_D = uint128(1) << uint128(uint8(bytes1("d")));

CMASK_LOWER_E

ASCII e

uint128 constant CMASK_LOWER_E = uint128(1) << uint128(uint8(bytes1("e")));

CMASK_LOWER_F

ASCII f

uint128 constant CMASK_LOWER_F = uint128(1) << uint128(uint8(bytes1("f")));

CMASK_LOWER_G

ASCII g

uint128 constant CMASK_LOWER_G = uint128(1) << uint128(uint8(bytes1("g")));

CMASK_LOWER_H

ASCII h

uint128 constant CMASK_LOWER_H = uint128(1) << uint128(uint8(bytes1("h")));

CMASK_LOWER_I

ASCII i

uint128 constant CMASK_LOWER_I = uint128(1) << uint128(uint8(bytes1("i")));

CMASK_LOWER_J

ASCII j

uint128 constant CMASK_LOWER_J = uint128(1) << uint128(uint8(bytes1("j")));

CMASK_LOWER_K

ASCII k

uint128 constant CMASK_LOWER_K = uint128(1) << uint128(uint8(bytes1("k")));

CMASK_LOWER_L

ASCII l

uint128 constant CMASK_LOWER_L = uint128(1) << uint128(uint8(bytes1("l")));

CMASK_LOWER_M

ASCII m

uint128 constant CMASK_LOWER_M = uint128(1) << uint128(uint8(bytes1("m")));

CMASK_LOWER_N

ASCII n

uint128 constant CMASK_LOWER_N = uint128(1) << uint128(uint8(bytes1("n")));

CMASK_LOWER_O

ASCII o

uint128 constant CMASK_LOWER_O = uint128(1) << uint128(uint8(bytes1("o")));

CMASK_LOWER_P

ASCII p

uint128 constant CMASK_LOWER_P = uint128(1) << uint128(uint8(bytes1("p")));

CMASK_LOWER_Q

ASCII q

uint128 constant CMASK_LOWER_Q = uint128(1) << uint128(uint8(bytes1("q")));

CMASK_LOWER_R

ASCII r

uint128 constant CMASK_LOWER_R = uint128(1) << uint128(uint8(bytes1("r")));

CMASK_LOWER_S

ASCII s

uint128 constant CMASK_LOWER_S = uint128(1) << uint128(uint8(bytes1("s")));

CMASK_LOWER_T

ASCII t

uint128 constant CMASK_LOWER_T = uint128(1) << uint128(uint8(bytes1("t")));

CMASK_LOWER_U

ASCII u

uint128 constant CMASK_LOWER_U = uint128(1) << uint128(uint8(bytes1("u")));

CMASK_LOWER_V

ASCII v

uint128 constant CMASK_LOWER_V = uint128(1) << uint128(uint8(bytes1("v")));

CMASK_LOWER_W

ASCII w

uint128 constant CMASK_LOWER_W = uint128(1) << uint128(uint8(bytes1("w")));

CMASK_LOWER_X

ASCII x

uint128 constant CMASK_LOWER_X = uint128(1) << uint128(uint8(bytes1("x")));

CMASK_LOWER_Y

ASCII y

uint128 constant CMASK_LOWER_Y = uint128(1) << uint128(uint8(bytes1("y")));

CMASK_LOWER_Z

ASCII z

uint128 constant CMASK_LOWER_Z = uint128(1) << uint128(uint8(bytes1("z")));

CMASK_LEFT_CURLY_BRACKET

ASCII {

uint128 constant CMASK_LEFT_CURLY_BRACKET = uint128(1) << uint128(uint8(bytes1("{")));

CMASK_VERTICAL_BAR

ASCII |

uint128 constant CMASK_VERTICAL_BAR = uint128(1) << uint128(uint8(bytes1("|")));

CMASK_RIGHT_CURLY_BRACKET

ASCII }

uint128 constant CMASK_RIGHT_CURLY_BRACKET = uint128(1) << uint128(uint8(bytes1("}")));

CMASK_TILDE

ASCII ~

uint128 constant CMASK_TILDE = uint128(1) << uint128(uint8(bytes1("~")));

CMASK_DELETE

ASCII delete

uint128 constant CMASK_DELETE = uint128(1) << uint128(uint8(bytes1("\x7F")));

CMASK_PRINTABLE

ASCII printable characters is everything 0x20 and above, except 0x7F

uint128 constant CMASK_PRINTABLE = ~(
    CMASK_NULL | CMASK_START_OF_HEADING | CMASK_START_OF_TEXT | CMASK_END_OF_TEXT | CMASK_END_OF_TRANSMISSION
        | CMASK_ENQUIRY | CMASK_ACKNOWLEDGE | CMASK_BELL | CMASK_BACKSPACE | CMASK_HORIZONTAL_TAB | CMASK_LINE_FEED
        | CMASK_VERTICAL_TAB | CMASK_FORM_FEED | CMASK_CARRIAGE_RETURN | CMASK_SHIFT_OUT | CMASK_SHIFT_IN
        | CMASK_DATA_LINK_ESCAPE | CMASK_DEVICE_CONTROL_1 | CMASK_DEVICE_CONTROL_2 | CMASK_DEVICE_CONTROL_3
        | CMASK_DEVICE_CONTROL_4 | CMASK_NEGATIVE_ACKNOWLEDGE | CMASK_SYNCHRONOUS_IDLE | CMASK_END_OF_TRANSMISSION_BLOCK
        | CMASK_CANCEL | CMASK_END_OF_MEDIUM | CMASK_SUBSTITUTE | CMASK_ESCAPE | CMASK_FILE_SEPARATOR
        | CMASK_GROUP_SEPARATOR | CMASK_RECORD_SEPARATOR | CMASK_UNIT_SEPARATOR | CMASK_DELETE
);

CMASK_NUMERIC_0_9

numeric 0-9

uint128 constant CMASK_NUMERIC_0_9 = CMASK_ZERO | CMASK_ONE | CMASK_TWO | CMASK_THREE | CMASK_FOUR | CMASK_FIVE
    | CMASK_SIX | CMASK_SEVEN | CMASK_EIGHT | CMASK_NINE;

CMASK_E_NOTATION

e notation eE

uint128 constant CMASK_E_NOTATION = CMASK_LOWER_E | CMASK_UPPER_E;

CMASK_LOWER_ALPHA_A_Z

lower alpha a-z

uint128 constant CMASK_LOWER_ALPHA_A_Z = CMASK_LOWER_A | CMASK_LOWER_B | CMASK_LOWER_C | CMASK_LOWER_D | CMASK_LOWER_E
    | CMASK_LOWER_F | CMASK_LOWER_G | CMASK_LOWER_H | CMASK_LOWER_I | CMASK_LOWER_J | CMASK_LOWER_K | CMASK_LOWER_L
    | CMASK_LOWER_M | CMASK_LOWER_N | CMASK_LOWER_O | CMASK_LOWER_P | CMASK_LOWER_Q | CMASK_LOWER_R | CMASK_LOWER_S
    | CMASK_LOWER_T | CMASK_LOWER_U | CMASK_LOWER_V | CMASK_LOWER_W | CMASK_LOWER_X | CMASK_LOWER_Y | CMASK_LOWER_Z;

CMASK_UPPER_ALPHA_A_Z

upper alpha A-Z

uint128 constant CMASK_UPPER_ALPHA_A_Z = CMASK_UPPER_A | CMASK_UPPER_B | CMASK_UPPER_C | CMASK_UPPER_D | CMASK_UPPER_E
    | CMASK_UPPER_F | CMASK_UPPER_G | CMASK_UPPER_H | CMASK_UPPER_I | CMASK_UPPER_J | CMASK_UPPER_K | CMASK_UPPER_L
    | CMASK_UPPER_M | CMASK_UPPER_N | CMASK_UPPER_O | CMASK_UPPER_P | CMASK_UPPER_Q | CMASK_UPPER_R | CMASK_UPPER_S
    | CMASK_UPPER_T | CMASK_UPPER_U | CMASK_UPPER_V | CMASK_UPPER_W | CMASK_UPPER_X | CMASK_UPPER_Y | CMASK_UPPER_Z;

CMASK_LOWER_ALPHA_A_F

lower alpha a-f (hex)

uint128 constant CMASK_LOWER_ALPHA_A_F =
    CMASK_LOWER_A | CMASK_LOWER_B | CMASK_LOWER_C | CMASK_LOWER_D | CMASK_LOWER_E | CMASK_LOWER_F;

CMASK_UPPER_ALPHA_A_F

upper alpha A-F (hex)

uint128 constant CMASK_UPPER_ALPHA_A_F =
    CMASK_UPPER_A | CMASK_UPPER_B | CMASK_UPPER_C | CMASK_UPPER_D | CMASK_UPPER_E | CMASK_UPPER_F;

CMASK_HEX

hex 0-9 a-f A-F

uint128 constant CMASK_HEX = CMASK_NUMERIC_0_9 | CMASK_LOWER_ALPHA_A_F | CMASK_UPPER_ALPHA_A_F;

CMASK_EOL

Rainlang end of line is ,

uint128 constant CMASK_EOL = CMASK_COMMA;

CMASK_LHS_RHS_DELIMITER

Rainlang LHS/RHS delimiter is :

uint128 constant CMASK_LHS_RHS_DELIMITER = CMASK_COLON;

CMASK_EOS

Rainlang end of source is ;

uint128 constant CMASK_EOS = CMASK_SEMICOLON;

CMASK_LHS_STACK_HEAD

Rainlang stack head is lower alpha and underscore a-z _

uint128 constant CMASK_LHS_STACK_HEAD = CMASK_LOWER_ALPHA_A_Z | CMASK_UNDERSCORE;

CMASK_IDENTIFIER_HEAD

Rainlang identifier head is lower alpha a-z

uint128 constant CMASK_IDENTIFIER_HEAD = CMASK_LOWER_ALPHA_A_Z;

CMASK_RHS_WORD_HEAD

uint128 constant CMASK_RHS_WORD_HEAD = CMASK_IDENTIFIER_HEAD;

CMASK_IDENTIFIER_TAIL

Rainlang stack/identifier tail is lower alphanumeric kebab a-z 0-9 -

uint128 constant CMASK_IDENTIFIER_TAIL = CMASK_IDENTIFIER_HEAD | CMASK_NUMERIC_0_9 | CMASK_DASH;

CMASK_LHS_STACK_TAIL

uint128 constant CMASK_LHS_STACK_TAIL = CMASK_IDENTIFIER_TAIL;

CMASK_RHS_WORD_TAIL

uint128 constant CMASK_RHS_WORD_TAIL = CMASK_IDENTIFIER_TAIL;

CMASK_OPERAND_START

Rainlang operand start is <

uint128 constant CMASK_OPERAND_START = CMASK_LESS_THAN_SIGN;

CMASK_OPERAND_END

Rainlang operand end is >

uint128 constant CMASK_OPERAND_END = CMASK_GREATER_THAN_SIGN;

CMASK_NOT_IDENTIFIER_TAIL

NOT lower alphanumeric kebab

uint128 constant CMASK_NOT_IDENTIFIER_TAIL = ~CMASK_IDENTIFIER_TAIL;

CMASK_WHITESPACE

Rainlang whitespace is \n \r \t space

uint128 constant CMASK_WHITESPACE = CMASK_LINE_FEED | CMASK_CARRIAGE_RETURN | CMASK_HORIZONTAL_TAB | CMASK_SPACE;

CMASK_LHS_STACK_DELIMITER

Rainlang stack item delimiter is whitespace

uint128 constant CMASK_LHS_STACK_DELIMITER = CMASK_WHITESPACE;

CMASK_NUMERIC_LITERAL_HEAD

Rainlang supports numeric literals as anything starting with 0-9

uint128 constant CMASK_NUMERIC_LITERAL_HEAD = CMASK_NUMERIC_0_9;

CMASK_STRING_LITERAL_HEAD

Rainlang supports string literals as anything starting with "

uint128 constant CMASK_STRING_LITERAL_HEAD = CMASK_QUOTATION_MARK;

CMASK_STRING_LITERAL_END

Rainlang string end is "

uint128 constant CMASK_STRING_LITERAL_END = CMASK_QUOTATION_MARK;

CMASK_STRING_LITERAL_TAIL

Rainlang string tail is any printable ASCII except " which ends it.

uint128 constant CMASK_STRING_LITERAL_TAIL = ~CMASK_STRING_LITERAL_END & CMASK_PRINTABLE;

CMASK_LITERAL_HEAD

Rainlang literal head

uint128 constant CMASK_LITERAL_HEAD = CMASK_NUMERIC_LITERAL_HEAD | CMASK_STRING_LITERAL_HEAD;

CMASK_COMMENT_HEAD

Rainlang comment head is /

uint128 constant CMASK_COMMENT_HEAD = CMASK_SLASH;

CMASK_INTERSTITIAL_HEAD

Rainlang interstitial head could be some whitespace or a comment head.

uint128 constant CMASK_INTERSTITIAL_HEAD = CMASK_WHITESPACE | CMASK_COMMENT_HEAD;

COMMENT_START_SEQUENCE

Rainlang comment starting sequence is /*

uint256 constant COMMENT_START_SEQUENCE = uint256(uint16(bytes2("/*")));

COMMENT_END_SEQUENCE

*Rainlang comment ending sequence is /

uint256 constant COMMENT_END_SEQUENCE = uint256(uint16(bytes2("*/")));

CMASK_COMMENT_END_SEQUENCE_END

*Rainlang comment end sequence end byte is / /

uint256 constant CMASK_COMMENT_END_SEQUENCE_END = COMMENT_END_SEQUENCE & 0xFF;

CMASK_LITERAL_HEX_DISPATCH

Rainlang literal hexadecimal dispatch is 0x We compare the head and dispatch together to avoid a second comparison. This is safe because the head is prefiltered to be 0-9 due to the numeric literal head, therefore the only possible match is 0x (not x0).

uint128 constant CMASK_LITERAL_HEX_DISPATCH = CMASK_ZERO | CMASK_LOWER_X;

CMASK_LITERAL_HEX_DISPATCH_START

We may want to match the exact start of a hex literal.

uint256 constant CMASK_LITERAL_HEX_DISPATCH_START = uint256(uint16(bytes2("0x")));