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 subroutine gets the next DFA nodes index from current index and symbol, and stores the result in next and next_set.

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 function returns the dfa transition object, that contains the destination index and the corresponding set of transitionable NFA state.

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.

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 function checks if the arguement 'state' (set of NFA state) includes state 's'.

The clear subroutine deallocates the queue.

This subroutine collects all states reachable by empty transition starting from a given state set in an NFA.

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 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 subroutine deallocates the transition array of a DFA state node.

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.

The function implemented for the regex_f function.

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

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.

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.

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

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.

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 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 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 subroutine construct an new transition object from the arguments, and invokes the type-bound procedure of dfa_state_node_t with it.

This subroutine performs deallocation of the arrays representing the DFA node transitions for every node in the DFA graph.

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 subroutine recursively marks empty transitions from a given NFA state index.

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.

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

Note that the return value of the size function on an unallocated array is undefined.

This subroutine invokes procedure for deallocation.

Interface for user-defined operator of .in.

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 .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.

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 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.

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 function constructs a tree node for carriage return (CR) and line feed (LF) characters.

This function handles shorthand escape sequences (\t, \n, \r, \d, \D, \w, \W, \s, \S).

Update c_top, which has become outdated by disjoin, to new information.

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).