REXS

REXS is an esoteric programming language created by User:Uellenberg built to simplify reading and writing regular expressions (especially complex ones).
== Description ==
Every action in REXS consists of a function, of which two types exist: bodied and non-bodied functions. All functions consist of a function name (which is always lowercase), followed by an opening parenthesis and optional parameters, then finally a closing parenthesis (for example, NAME(PARAMETERS)). Bodied functions will be followed by braces (NAME(PARAMETERS) {}) and non-bodied functions will be followed by a semicolon (NAME(PARAMETERS);).
== Specifications ==
=== Parameters ===
The parameters a function can take will depend on the specific function, and if multiple parameters exist, they will be separated by a comma (param1, param2). In general, parameters can be split up into three distinct types (although they might not always fall into these categories, as it is entirely dependent on the specific function):
==== Control ====
Control parameters are specific, per-function parameters that do certain things. For example, assert(START); has the parameter START, which is a control parameter. In general, control parameters will be comprised of only uppercase characters and can be thought of as enums.
==== String ====
String parameters are, as their name suggests, strings. They are surrounded by double quotes on both sides. For example, match("t"); has the parameter "t", which is a string parameter. When this parameter is used by the function, the double quotes on either end will be stripped. It is also important to note that strings allow every character except double quotes within them. If you wish to use a double quote in a function, there will likely be an option to use a control parameter (such as QUOTE) to achieve it.
==== Integer ====
Integer parameters are integer numbers. For example, repeat(10) {} has the parameter 10, which is an integer parameter.
=== Functions ===
Here, the different classes of functions, discussed in the description, will be explained in greater detail.
==== Bodied Functions ====
Bodied functions are used to do some action on their body (which is everything between their braces), based on their parameters. Their body can consist of both bodied and non-bodied functions, although some functions have specific limits on which functions can appear inside their body.
==== Non-bodied Functions ====
Non-bodied functions are used to do some action based on their parameters.
== Functions ==
=== Match ===
Match (non-bodied) is one of the most essential functions in REXS. It represents a match of a literal string in a regular expression.
 Parameters
Type 	Allowed Values 	Descriptions 	Required
String or Control	Strings or Match controls	The value being matched 	Yes
Integer 	Integers 	An input value for specific controls	No
=== Assert ===
Assert (non-bodied) another important function in REXS, and is similar to a match, except it does not include the match result.
 Parameters
Type 	Allowed Values 	Descriptions 	Required
Control	Assert controls	The value being asserted	Yes
=== Flag ===
Flag (non-bodied) sets a flag in the regular expression.
 Parameters
Type 	Allowed Values	Descriptions 	Required
Control	i/g/m/s/u/y 	The flag being set	Yes
=== Group ===
Group (bodied) defines a capturing group around everything inside its body.
=== Backref ===
Backref (non-bodied) matches the value of a capturing group, by its index.
 Parameters
Type 	Allowed Values	Descriptions 	Required
Integer	Integers 	The index of the capturing group	Yes
=== Repeat ===
Repeat (bodied) repeats its body a specified amount of times.
 Parameters
Type 	Allowed Values 	Descriptions 	Required
Integer	Integers 	The minimum amount of repeats needed to match 	Yes
Integer	Integers or inf/infinity/forever	The maximum amount of repeats that can be matched 	Yes
Control	nongreedy 	If specified, makes the repeat non-greedy and repeats the least amount of times possible	No
=== Set ===
Set (bodied) creates a character set and puts its body inside the set. Additionally, only the match and to functions are allowed inside its body.
=== To ===
To (non-bodied) is to be used inside of set and represents the to (-) character in a regex set.
=== Or ===
Or (bodied) creates an or-expression, matching anything inside its body. It will only match one group in its body. Additionally, only the orpart functions are allowed inside its body.
=== OrPart ===
OrPart (bodied) is to be used inside of or and creates a possible option for the or to use.
=== Before ===
Before (bodied) is similar to assert in that it matches something but does not include the match. This function can be used to assert that its body matches (or doesn't match) before the main expression.
 Parameters
Type 	Allowed Values	Descriptions 	Required
Control	not 	If used, will assert that the body doesn't match instead of asserting that it does match	No
=== After ===
After (bodied) is similar to assert in that it matches something but does not include the match. This function can be used to assert that its body matches (or doesn't match) after the main expression.
 Parameters
Type 	Allowed Values	Descriptions 	Required
Control	not 	If used, will assert that the body doesn't match instead of asserting that it does match	No
== Control Sets ==
Below is a list of the possible control values for specific functions:
=== Match Controls ===
* ANY - Matches any character.
* DIGIT - Matches any digit (0-9).
* NON_DIGIT - Matches any non-digit (not 0-9).
* ALPHANUM - Matches any alphanum (0-9 or a-z or A-Z).
* NON_ALPHANUM - Matches any non-alphanum (not 0-9 or a-z or A-Z).
* SPACE - Matches any space ( ).
* NON_SPACE - Matches any non-spcae (not ).
* HTAB - Matches any horizontal tab (	 or \t).
* VTAB - Matches any vertical tab (\v).
* RETURN - Matches any return (\r).
* LINEFEED - Matches any linefeed (\n).
* FORMFEED - Matches any formfeed (\f).
* BACKSPACE - Matches any backspace (\b).
* NULL - Matches any null (\0).
* QUOTE - Matches any quote (").
* *CONTROL - Matches a specific control character. The second parameter of match must be a value A-Z, specifying the control character that this matches.
* *HEX - Matches a specific character by its hex code. The second parameter of match must be a hex string with a length of either 2 or 4, indicating the hex character being matched.
*=requires second parameter to be used.
=== Assert Controls ===
* START - Asserts the start of the string being matched on or a line (depending on the flags).
* END - Asserts the end of the string being matched on or a line (depending on the flags).
* WORD_BOUNDARY - Asserts a word boundary (the character before or after the start or end of a word).
* NOT_WORD_BOUNDARY - Asserts not a word boundary (the character before or after the start or end of a word).
== Examples ==
=== IRC ===
Let's take a look at a basic IRC message:
 name!email PRIVMSG #channel :message
If we want to parse all of the details from this, we can build a regular expression in REXS like this:
 assert(START);
 
 group() {
 repeat(0, inf, nongreedy) {
 match(ANY);
 }
 }
 
 match("!");
 
 group() {
 repeat(0, inf, nongreedy) {
 match(ANY);
 }
 }
 
 match(" PRIVMSG #");
 group() {
 repeat(0, inf, nongreedy) {
 match(ANY);
 }
 }
 
 match(" :");
 group() {
 repeat(0, inf) {
 match(ANY);
 }
 }
 
 assert(END);
This code will then be compiled to:
 /^(.*?)!(.*?) PRIVMSG \#(.*?) :(.*)$/
== External Resources ==
Compiler and Decompiler
Category: 2021
Category: Languages
Category: High-level
Category: Implemented
Category: Output only