NAME

Parse::Gnaw::Blocks::Letter - a linked list element that holds a single scalar payload.

new

This is the constructor for a letter object, which is part of a LinkedListObject

        Parse::Gnaw::Blocks::Letter->new($linkedlist, $lettervalue, $letterlocation);

Linkedlist is the linkedlist object that contains this letter. Lettervalue is probably a single character like 'b'. Letterlocation is a string that describes where the letter originaly came from (filename/linenum).

get_raw_address

This is a subroutine. Do NOT call this as a method. This will allow it to handle undef values.

        my $retval = get_raw_address($letterobj);

Given a letter object, get the string that looks like

        Parse::Gnaw::Blocks::Letter=ARRAY(0x850cea4)

and return something like

        0x850cea4

display

print out a formatted version of letter object.

get_more_letters

if a LETTER needs more letters, then call this and we'll have the linked list get more letters. Note that $which will be either NEXTSTART or NEXTCONN

Connections verus Next Starting Position If we want to parse a 2-D array of text, we have to step through each starting position and try to match the regular expression to the string. The regular expression can match through any connection between letters.

For example, a simple 2D list could be interconnected vertically and horizontally like this:

1---2---3 | | | | | | | | | 4---5---6 | | | | | | | | | 7---8---9

Or it could be connected on diagonals as well:

1---2---3 |\ /|\ /| | X | X | |/ \|/ \| 4---5---6 |\ /|\ /| | X | X | |/ \|/ \| 7---8---9

As we try to fit a regular expression to the linked list, we will follow the CONNECTIONS to figure out what letters are in sequential order.

As we parse, if we're at letter "3", this can connect to 2, 6, and possibly 5. But if starting from "3" does not yeild a match, then we need to move to the next starting position, which could be "4". 4 doesn't connect to 3, but it is the next starting position after 3.

simple 3D list might be connected horizontally and vertically like this:

1----2----3 |\ |\ |\ | 4--+-5--+-6 | | | | | | 7-+--8-+--9 | \| \| \| a----b----c

The "starting position" order could be 1->2->3->4->5->6->7->8->9->a->b->c

Note that 3 is not CONNECTED to 4, but if we try 3 as a starting position and it fails, then after 3 the NEXT STARTING POSITION is 4.

The NextStartingPosition and the ConnectionsBetweenLetters are two different concepts that are built into the data structures of the linked list and the letters.

And they are accessed through several methods:

Connections:

We can create a connection between two letters with: link_two_letters_via_interconnection And we can get the next connection with: next_connection

Starting Positions:

We can create a link between letters for starting connections with: link_two_letters_via_next_start We can traverse from one starting position to the next with: advance_start_position

link_two_letters_via_next_start

        $first->link_two_letters_via_next_start($second);

Create a link so that after $first, the next starting position is $second.

advance_start_position

Advance (move) the starting position to the next spot.

        my $second = $first->advance_start_position();

We tried to match the regular expression starting from $first, but it didn't match. So, now we want to advance to the $second starting position and try from there.

If nextstart points to end or null or whatever, then get more letters.

link_two_letters_via_interconnection

        $first->link_two_letters_via_interconnection($second,$axis);

Create a linkage between $first and $second so that they are INTERCONNECTED to be treated as sequential letters for parsing purposes.

The $axis defaults to 0. It represents whatever axis your linked list structure needs. For example, one axis could be the "vertical" axis. In that example, $first could be thought of as being "up" from $second. And $second could be thought of as "down" from $first.

advance_to_next_connection

        my $next_letter = $curr_letter->advance_to_next_connection($overalldirectionforrule);

We are at $curr_letter, trying to fit the regular expression to string. The next letter will be returned by advance_to_next_connection($axis) where axis is which index into the array to look for the connection.

get_list_of_connecting_letters

return a list of possible letters to try based on parsing connections array for this letter and any other rules you want to use for your grammar.

By default, this class method will return an array of any connected letter that is not already consumed.

You can override this behaviour by redefining the method to do whatever you want. You could, for example, require that the connections only go in a straight line. Or you could, as a counter example, allow any connection, including letters that have been marked as "consumed" and allow them to be used again and again.

You might even allow the current letter to be used multiple times for multiple rules without advancing.

delete

delete this letter and all previous letters

work your way back until we get to the first_start position.

Note: this assumes that object connections are symmetrical.

if A connects to B at dimension 3, then B connects to B at dimension 3 in the opposite direction.

cpanm Parse::Gnaw

perl -MCPAN -e shell
install Parse::Gnaw