Procedures

This subroutine adds a specified state (s) to an NFA state set state_set by setting the corresponding element in state%vec to true.

Checks if the given integer is within the specified segment.

Check if the ginve integer is within any of specified segments in a list.

This function calculates a set of possible NFA states from the current DFA state by the input character symbol.

This subroutine gets the destination index of DFA nodes from the current index with given symbol, adding a DFA node if necessary.

This function returns the dfa transition object, that contains the destination index and the corresponding set of transitionable NFA state.

Compute the ε-closure for a set of NFA states.

This subroutine reads tree and tree_top variable, constructs the NFA graph, and then initializes the DFA graph.

This subroutine prints DFA states and transitions to a given unit number.

This subroutine provides the automata' summarized information.

This subroutine takes a nfa_state_set_t type argument as input and register the set as a DFA state node in the DFA graph.

This is recursive procedure to tour a given syntax tree.

Implementing insertion sort instead of this algorithm is considered.

The char_utf8 function takes a code point as integer in Unicode character set, and returns the corresponding character as UTF-8 binary string.

This subroutine parses a pattern string for character class, and outputs character_array_t type array. When it encounters invalid value along the way, it returns.

This function checks if the arguement 'state' (set of NFA state) includes state 's'.

The clear subroutine deallocates the queue.

This function calculates a set of possible NFA states from the current DFA state.

This subroutine convert an NFA into a fully compiled DFA.

This subroutine converts escaped character of the argument chara into segment seg_list.

This subroutine copies the data of a specified transition into the variables of another dfa_transition_t.

This function counts the occurrence of a spcified character(token) in a given string.

This subroutine deallocate the syntax tree.

The dequeue function takes out and returns the prior segment from the queue.

This subroutine gets the next DFA nodes index from current index, and stores the result in next and next_set. If the DFA state is already registered, it returns the index, otherwise it returns DFA_INVALID_INDEX.

This subroutine processes to add the given transition to the list which dfa_state_node_t has.

This function returns the index of top transition in the list dfa_state_node_t has.

This subroutine increments the value of top transition index.

This subroutine initialize the top index of the transition array of the dfa node with the value of the given argument.

This subroutine performs allocating initial or additional transition arrays.

Interface for the procedure disjoin_kernel.

Disjoins overlapping segments and creates a new list of non-overlapping segments.

This subroutine updates the NFA state transitions by disjoining the segments.

This subroutine is intended to be called from the forgex API module.

This procedure reads a text, performs regular expression matching using an automaton, and stores the string index in the argument if it contains a match.

The enqueue subroutine is responsible for allocating heap structure and holding the disjoined segment data with ascending priority order.

This function determines if two NFA state sets (logical vectors) are equivalent.

This is the public procedure of this module to obtain each literal from AST.

The function implemented for the regex_f function.

This function accepts integer error status code and then return error messagge corresponding to it. !

This procedure find first comma and number of it in the given pattern. It aims to parse repetation times of the expression.

This subroutine creates an array containing a list of the positions of the prefixes that exist in the text

Wrapping function to retrieve literals: all, prefix, suffix, factor.

Get the currently focused character (1 to 4 bytes) from the entire string inside the type_t derived-type, and store the enumerator's numeric value in the current_token component. This is a type-bound procedure of tape_t.

This subroutine converts character string that represents hexadecimal value to the segment corresponding its integer type.

Take a UTF-8 character as an argument and return the integer (also known as "code point" in Unicode) representing its UTF-8 binary string.

This function returns the index of the end of the (multibyte) character, given the string str and the current index curr. Class of invalid UTF-8 characters 1. invalid lead byte 2. invalid trail byte 3. overrun 4. over long encoding 5. incomplete multibyte sequence 6. invalid character range (U+D800-U+DFFF) 7. BOM appears in the middle 8. isolated trail byte

Extracts a sorted list of unique indices from a list of segments.

This subroutine parses a pattern string and outputs a list of segment_t type.

This subroutine inverts a list of segment ranges representing Unicode characters. It compute the complement of the given ranges and modifies the list accordingly.

This function determines if a given character is the first byte of a UTF-8 multibyte character. It takes a 1-byte character as input and returns a logical value indicating if it is the first byte of an UTF-8 binary string.

This subroutine determines if each character in a given string is the first byte of a UTF-8 multibyte character. It takes a UTF-8 string and return a logical array indicating for each position if it is the first byte.

This function determines whether the input character string can be parsed into an integer.

Checks if a segment overlaps with any segments in a list.

Checks if a segment is a prime segment within a disjoined list.

This function returns .true. if the pattern contains the caret character at the top that matches the beginning of a line.

This funciton returns .true. if the pattern contains the doller character at the end that matches the ending of a line.

This function checks whether it returns the correct error for a given pattern and text.

This function checks if a pattern is found within a string and compares the result to the correct_answer.

This function checks if a pattern matches exactly a string and compares the result to the correct answer.

This function checks if the given pattern is valid as a regex pattern and compares the result to the correct_answer.

This function checks whether the correct prefix is extracted for a given pattern.

This function checks if a pattern matches a string using the regex function and compares the result to the expected answer.

This function checks whether the correct suffix is extracted for a given pattern.

This function checks the input byte string is valid as a single UTF-8 character.

The generic name for the is_valid_regex function implemented as is_valid_regex_pattern.

The function validating a given regex patten.

This function converts two isolated segments into single fused segment and returns it.

This subroutine construct an new transition object from the arguments, and invokes the type-bound procedure of dfa_state_node_t with it.

This subroutine determines the number of DFA nodes the graph has and allocate the array.

This subroutine performs reallocating array that represents the DFA graph.

Returns whether the DFA state is already registered by index, or DFA_INVALID_INDEX if it is not registered.

This function calculates the length of a UTF-8 string excluding tailing spaces.

This function calculates the length of a UTF-8 string.

This procedure reads a text, performs regular expression matching using compiled DFA, and returns .true. if it matches exactly.

This procedure reads a text, performs regular expression matching using an automaton, and stores the string index in the argument if it contains a match.

This function returns the dfa transition object, that contains the destination index and the corresponding set of transitionable NFA state.

nchar means 'negative char'.

This function returns the index of the next character, given the string str and the current index curr. If the current index is for the last character, it returns the invalid value.

This subroutine returns the index of the next UTF-8 character conteined in str. This is used to handle strings that may not be encoded by UTF-8.

This function returns the index of the destination DFA state from the index of the current automaton DFA state array and the input symbol.

This interface block provides the .in. operator, which checks whether an integer and a segment, an integer and a list of segments, or a segment and a segment, is contained in the latter, respectively.

Interface for user-defined operator of .in.

Interface for user-defined operator of .match.

This interface block provides a not equal operator for comparing segments.

This interface block provides a equal operator for comparing segments.

The function implemented for the .in. operator.

The function implemented for the .match. operator.

This subroutine processes a character array, and outputs the corresponding flagged array. It removes backslash and hyphen characters, and then flags the current element in character_array_t type array.

This subroutine assigns the expected segment size from the character c of the current array element to its seg_size.

The generic name for the regex subroutine implemented as procedure__regex.

The generic name for the regex_f function implemented as function__regex.

Registers a new segment into a list if it is valid.

This procedure registers given segment_t value to segment_t type array, increments counter of the actual size of the array, and initializes temporary variable.

This function generates a string by repeating a given pattern a specified number of times.

This subroutine runs is_valid_error function and prints its result.

This subroutine runs the is_valid__in function and prints the result.

This subroutine runs the is_valid__match function and prints the result.

This subroutine runs the is_valid_prefix function and prints the result.

This subroutine runs the is_valid__regex function and prints the result.

This function runs the is_valid_suffix function and prints the result.

This subroutine runs the is_valid__pattern function and prints the result.

Check if the one segment is completely within another segment.

Check if the one segment is exactly equal to another segment.

Converts a segment to a printable string representation.

Checks if a segment is valid.

Check if two segments are not equivalent.

This function take one byte, set the first two bits to 10, and returns one byte of the continuation part.

The function implemented for the regex subroutine.

This function convert an input symbol into the segment corresponding it.

This procedure builds an AST corresponding to a given (regular expression) pattern from it.

This subroutine treats character class expression, and does not call any other recursive procedures.

This procedure deallocates nodes of tree_t

This procedure handles a escape sequence with '\x'.

This function constructs a tree node for carriage return (CR) and line feed (LF) characters.

This procedure handles the reallcation of the tree_node_t type array within the component of the tree_t object. However, it is not be used in v4.2.

This function handles shorthand escape sequences (\t, \n, \r, \d, \D, \w, \W, \s, \S). It does not call any other recursive procedures.

This subroutine handles a quantifier range, and does not call any other recursive procedures.

This function takes an array of segments and a character as arguments, and returns the segment as rank=1 array to which symbol belongs (included in the segment interval).