1 ------------------------------------------------------------------------------
3 -- GNAT LIBRARY COMPONENTS --
5 -- G N A T . S P I T B O L . P A T T E R N S --
9 -- Copyright (C) 1998-2005, Ada Core Technologies, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 2, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
22 -- As a special exception, if other files instantiate generics from this --
23 -- unit, or you link this unit with other files to produce an executable, --
24 -- this unit does not by itself cause the resulting executable to be --
25 -- covered by the GNU General Public License. This exception does not --
26 -- however invalidate any other reasons why the executable file might be --
27 -- covered by the GNU Public License. --
29 -- GNAT was originally developed by the GNAT team at New York University. --
30 -- Extensive contributions were provided by Ada Core Technologies Inc. --
32 ------------------------------------------------------------------------------
34 -- Note: the data structures and general approach used in this implementation
35 -- are derived from the original MINIMAL sources for SPITBOL. The code is not
36 -- a direct translation, but the approach is followed closely. In particular,
37 -- we use the one stack approach developed in the SPITBOL implementation.
39 with Ada.Exceptions; use Ada.Exceptions;
40 with Ada.Strings.Maps; use Ada.Strings.Maps;
41 with Ada.Strings.Unbounded.Aux; use Ada.Strings.Unbounded.Aux;
43 with GNAT.Debug_Utilities; use GNAT.Debug_Utilities;
45 with System; use System;
47 with Unchecked_Conversion;
48 with Unchecked_Deallocation;
50 package body GNAT.Spitbol.Patterns is
52 ------------------------
53 -- Internal Debugging --
54 ------------------------
56 Internal_Debug : constant Boolean := False;
57 -- Set this flag to True to activate some built-in debugging traceback
58 -- These are all lines output with PutD and Put_LineD.
61 pragma Inline (New_LineD);
62 -- Output new blank line with New_Line if Internal_Debug is True
64 procedure PutD (Str : String);
66 -- Output string with Put if Internal_Debug is True
68 procedure Put_LineD (Str : String);
69 pragma Inline (Put_LineD);
70 -- Output string with Put_Line if Internal_Debug is True
72 -----------------------------
73 -- Local Type Declarations --
74 -----------------------------
76 subtype String_Ptr is Ada.Strings.Unbounded.String_Access;
77 subtype File_Ptr is Ada.Text_IO.File_Access;
79 function To_Address is new Unchecked_Conversion (PE_Ptr, Address);
80 -- Used only for debugging output purposes
82 subtype AFC is Ada.Finalization.Controlled;
84 N : constant PE_Ptr := null;
85 -- Shorthand used to initialize Copy fields to null
87 type Natural_Ptr is access all Natural;
88 type Pattern_Ptr is access all Pattern;
90 --------------------------------------------------
91 -- Description of Algorithm and Data Structures --
92 --------------------------------------------------
94 -- A pattern structure is represented as a linked graph of nodes
95 -- with the following structure:
97 -- +------------------------------------+
99 -- +------------------------------------+
101 -- +------------------------------------+
103 -- +------------------------------------+
105 -- +------------------------------------+
107 -- Pcode is a code value indicating the type of the patterm node. This
108 -- code is used both as the discriminant value for the record, and as
109 -- the case index in the main match routine that branches to the proper
110 -- match code for the given element.
112 -- Index is a serial index number. The use of these serial index
113 -- numbers is described in a separate section.
115 -- Pthen is a pointer to the successor node, i.e the node to be matched
116 -- if the attempt to match the node succeeds. If this is the last node
117 -- of the pattern to be matched, then Pthen points to a dummy node
118 -- of kind PC_EOP (end of pattern), which initiales pattern exit.
120 -- The parameter or parameters are present for certain node types,
121 -- and the type varies with the pattern code.
123 type Pattern_Code is (
216 type IndexT is range 0 .. +(2 **15 - 1);
218 type PE (Pcode : Pattern_Code) is record
221 -- Serial index number of pattern element within pattern.
224 -- Successor element, to be matched after this one
244 PC_Unanchored => null;
249 PC_Arbno_X => Alt : PE_Ptr;
251 when PC_Rpat => PP : Pattern_Ptr;
253 when PC_Pred_Func => BF : Boolean_Func;
263 PC_String_VP => VP : VString_Ptr;
266 PC_Write_OnM => FP : File_Ptr;
268 when PC_String => Str : String_Ptr;
270 when PC_String_2 => Str2 : String (1 .. 2);
272 when PC_String_3 => Str3 : String (1 .. 3);
274 when PC_String_4 => Str4 : String (1 .. 4);
276 when PC_String_5 => Str5 : String (1 .. 5);
278 when PC_String_6 => Str6 : String (1 .. 6);
280 when PC_Setcur => Var : Natural_Ptr;
288 PC_Span_CH => Char : Character;
295 PC_Span_CS => CS : Character_Set;
302 PC_Tab_Nat => Nat : Natural;
308 PC_Tab_NF => NF : Natural_Func;
314 PC_Tab_NP => NP : Natural_Ptr;
322 PC_String_VF => VF : VString_Func;
327 subtype PC_Has_Alt is Pattern_Code range PC_Alt .. PC_Arbno_X;
328 -- Range of pattern codes that has an Alt field. This is used in the
329 -- recursive traversals, since these links must be followed.
331 EOP_Element : aliased constant PE := (PC_EOP, 0, N);
332 -- This is the end of pattern element, and is thus the representation of
333 -- a null pattern. It has a zero index element since it is never placed
334 -- inside a pattern. Furthermore it does not need a successor, since it
335 -- marks the end of the pattern, so that no more successors are needed.
337 EOP : constant PE_Ptr := EOP_Element'Unrestricted_Access;
338 -- This is the end of pattern pointer, that is used in the Pthen pointer
339 -- of other nodes to signal end of pattern.
341 -- The following array is used to determine if a pattern used as an
342 -- argument for Arbno is eligible for treatment using the simple Arbno
343 -- structure (i.e. it is a pattern that is guaranteed to match at least
344 -- one character on success, and not to make any entries on the stack.
346 OK_For_Simple_Arbno : constant array (Pattern_Code) of Boolean :=
369 -------------------------------
370 -- The Pattern History Stack --
371 -------------------------------
373 -- The pattern history stack is used for controlling backtracking when
374 -- a match fails. The idea is to stack entries that give a cursor value
375 -- to be restored, and a node to be reestablished as the current node to
376 -- attempt an appropriate rematch operation. The processing for a pattern
377 -- element that has rematch alternatives pushes an appropriate entry or
378 -- entry on to the stack, and the proceeds. If a match fails at any point,
379 -- the top element of the stack is popped off, resetting the cursor and
380 -- the match continues by accessing the node stored with this entry.
382 type Stack_Entry is record
385 -- Saved cursor value that is restored when this entry is popped
386 -- from the stack if a match attempt fails. Occasionally, this
387 -- field is used to store a history stack pointer instead of a
388 -- cursor. Such cases are noted in the documentation and the value
389 -- stored is negative since stack pointer values are always negative.
392 -- This pattern element reference is reestablished as the current
393 -- Node to be matched (which will attempt an appropriate rematch).
397 subtype Stack_Range is Integer range -Stack_Size .. -1;
399 type Stack_Type is array (Stack_Range) of Stack_Entry;
400 -- The type used for a history stack. The actual instance of the stack
401 -- is declared as a local variable in the Match routine, to properly
402 -- handle recursive calls to Match. All stack pointer values are negative
403 -- to distinguish them from normal cursor values.
405 -- Note: the pattern matching stack is used only to handle backtracking.
406 -- If no backtracking occurs, its entries are never accessed, and never
407 -- popped off, and in particular it is normal for a successful match
408 -- to terminate with entries on the stack that are simply discarded.
410 -- Note: in subsequent diagrams of the stack, we always place element
411 -- zero (the deepest element) at the top of the page, then build the
412 -- stack down on the page with the most recent (top of stack) element
413 -- being the bottom-most entry on the page.
415 -- Stack checking is handled by labeling every pattern with the maximum
416 -- number of stack entries that are required, so a single check at the
417 -- start of matching the pattern suffices. There are two exceptions.
419 -- First, the count does not include entries for recursive pattern
420 -- references. Such recursions must therefore perform a specific
421 -- stack check with respect to the number of stack entries required
422 -- by the recursive pattern that is accessed and the amount of stack
423 -- that remains unused.
425 -- Second, the count includes only one iteration of an Arbno pattern,
426 -- so a specific check must be made on subsequent iterations that there
427 -- is still enough stack space left. The Arbno node has a field that
428 -- records the number of stack entries required by its argument for
431 ---------------------------------------------------
432 -- Use of Serial Index Field in Pattern Elements --
433 ---------------------------------------------------
435 -- The serial index numbers for the pattern elements are assigned as
436 -- a pattern is consructed from its constituent elements. Note that there
437 -- is never any sharing of pattern elements between patterns (copies are
438 -- always made), so the serial index numbers are unique to a particular
439 -- pattern as referenced from the P field of a value of type Pattern.
441 -- The index numbers meet three separate invariants, which are used for
442 -- various purposes as described in this section.
444 -- First, the numbers uniquely identify the pattern elements within a
445 -- pattern. If Num is the number of elements in a given pattern, then
446 -- the serial index numbers for the elements of this pattern will range
447 -- from 1 .. Num, so that each element has a separate value.
449 -- The purpose of this assignment is to provide a convenient auxiliary
450 -- data structure mechanism during operations which must traverse a
451 -- pattern (e.g. copy and finalization processing). Once constructed
452 -- patterns are strictly read only. This is necessary to allow sharing
453 -- of patterns between tasks. This means that we cannot go marking the
454 -- pattern (e.g. with a visited bit). Instead we cosntuct a separate
455 -- vector that contains the necessary information indexed by the Index
456 -- values in the pattern elements. For this purpose the only requirement
457 -- is that they be uniquely assigned.
459 -- Second, the pattern element referenced directly, i.e. the leading
460 -- pattern element, is always the maximum numbered element and therefore
461 -- indicates the total number of elements in the pattern. More precisely,
462 -- the element referenced by the P field of a pattern value, or the
463 -- element returned by any of the internal pattern construction routines
464 -- in the body (that return a value of type PE_Ptr) always is this
467 -- The purpose of this requirement is to allow an immediate determination
468 -- of the number of pattern elements within a pattern. This is used to
469 -- properly size the vectors used to contain auxiliary information for
470 -- traversal as described above.
472 -- Third, as compound pattern structures are constructed, the way in which
473 -- constituent parts of the pattern are constructed is stylized. This is
474 -- an automatic consequence of the way that these compounjd structures
475 -- are constructed, and basically what we are doing is simply documenting
476 -- and specifying the natural result of the pattern construction. The
477 -- section describing compound pattern structures gives details of the
478 -- numbering of each compound pattern structure.
480 -- The purpose of specifying the stylized numbering structures for the
481 -- compound patterns is to help simplify the processing in the Image
482 -- function, since it eases the task of retrieving the original recursive
483 -- structure of the pattern from the flat graph structure of elements.
484 -- This use in the Image function is the only point at which the code
485 -- makes use of the stylized structures.
487 type Ref_Array is array (IndexT range <>) of PE_Ptr;
488 -- This type is used to build an array whose N'th entry references the
489 -- element in a pattern whose Index value is N. See Build_Ref_Array.
491 procedure Build_Ref_Array (E : PE_Ptr; RA : out Ref_Array);
492 -- Given a pattern element which is the leading element of a pattern
493 -- structure, and a Ref_Array with bounds 1 .. E.Index, fills in the
494 -- Ref_Array so that its N'th entry references the element of the
495 -- referenced pattern whose Index value is N.
497 -------------------------------
498 -- Recursive Pattern Matches --
499 -------------------------------
501 -- The pattern primitive (+P) where P is a Pattern_Ptr or Pattern_Func
502 -- causes a recursive pattern match. This cannot be handled by an actual
503 -- recursive call to the outer level Match routine, since this would not
504 -- allow for possible backtracking into the region matched by the inner
505 -- pattern. Indeed this is the classical clash between recursion and
506 -- backtracking, and a simple recursive stack structure does not suffice.
508 -- This section describes how this recursion and the possible associated
509 -- backtracking is handled. We still use a single stack, but we establish
510 -- the concept of nested regions on this stack, each of which has a stack
511 -- base value pointing to the deepest stack entry of the region. The base
512 -- value for the outer level is zero.
514 -- When a recursive match is established, two special stack entries are
515 -- made. The first entry is used to save the original node that starts
516 -- the recursive match. This is saved so that the successor field of
517 -- this node is accessible at the end of the match, but it is never
518 -- popped and executed.
520 -- The second entry corresponds to a standard new region action. A
521 -- PC_R_Remove node is stacked, whose cursor field is used to store
522 -- the outer stack base, and the stack base is reset to point to
523 -- this PC_R_Remove node. Then the recursive pattern is matched and
524 -- it can make history stack entries in the normal matter, so now
525 -- the stack looks like:
527 -- (stack entries made by outer level)
529 -- (Special entry, node is (+P) successor
530 -- cursor entry is not used)
532 -- (PC_R_Remove entry, "cursor" value is (negative) <-- Stack base
533 -- saved base value for the enclosing region)
535 -- (stack entries made by inner level)
537 -- If a subsequent failure occurs and pops the PC_R_Remove node, it
538 -- removes itself and the special entry immediately underneath it,
539 -- restores the stack base value for the enclosing region, and then
540 -- again signals failure to look for alternatives that were stacked
541 -- before the recursion was initiated.
543 -- Now we need to consider what happens if the inner pattern succeeds, as
544 -- signalled by accessing the special PC_EOP pattern primitive. First we
545 -- recognize the nested case by looking at the Base value. If this Base
546 -- value is Stack'First, then the entire match has succeeded, but if the
547 -- base value is greater than Stack'First, then we have successfully
548 -- matched an inner pattern, and processing continues at the outer level.
550 -- There are two cases. The simple case is when the inner pattern has made
551 -- no stack entries, as recognized by the fact that the current stack
552 -- pointer is equal to the current base value. In this case it is fine to
553 -- remove all trace of the recursion by restoring the outer base value and
554 -- using the special entry to find the appropriate successor node.
556 -- The more complex case arises when the inner match does make stack
557 -- entries. In this case, the PC_EOP processing stacks a special entry
558 -- whose cursor value saves the saved inner base value (the one that
559 -- references the corresponding PC_R_Remove value), and whose node
560 -- pointer references a PC_R_Restore node, so the stack looks like:
562 -- (stack entries made by outer level)
564 -- (Special entry, node is (+P) successor,
565 -- cursor entry is not used)
567 -- (PC_R_Remove entry, "cursor" value is (negative)
568 -- saved base value for the enclosing region)
570 -- (stack entries made by inner level)
572 -- (PC_Region_Replace entry, "cursor" value is (negative)
573 -- stack pointer value referencing the PC_R_Remove entry).
575 -- If the entire match succeeds, then these stack entries are, as usual,
576 -- ignored and abandoned. If on the other hand a subsequent failure
577 -- causes the PC_Region_Replace entry to be popped, it restores the
578 -- inner base value from its saved "cursor" value and then fails again.
579 -- Note that it is OK that the cursor is temporarily clobbered by this
580 -- pop, since the second failure will reestablish a proper cursor value.
582 ---------------------------------
583 -- Compound Pattern Structures --
584 ---------------------------------
586 -- This section discusses the compound structures used to represent
587 -- constructed patterns. It shows the graph structures of pattern
588 -- elements that are constructed, and in the case of patterns that
589 -- provide backtracking possibilities, describes how the history
590 -- stack is used to control the backtracking. Finally, it notes the
591 -- way in which the Index numbers are assigned to the structure.
593 -- In all diagrams, solid lines (built witth minus signs or vertical
594 -- bars, represent successor pointers (Pthen fields) with > or V used
595 -- to indicate the direction of the pointer. The initial node of the
596 -- structure is in the upper left of the diagram. A dotted line is an
597 -- alternative pointer from the element above it to the element below
598 -- it. See individual sections for details on how alternatives are used.
604 -- In the pattern structures listed in this section, a line that looks
605 -- lile ----> with nothing to the right indicates an end of pattern
606 -- (EOP) pointer that represents the end of the match.
608 -- When a pattern concatenation (L & R) occurs, the resulting structure
609 -- is obtained by finding all such EOP pointers in L, and replacing
610 -- them to point to R. This is the most important flattening that
611 -- occurs in constructing a pattern, and it means that the pattern
612 -- matching circuitry does not have to keep track of the structure
613 -- of a pattern with respect to concatenation, since the appropriate
614 -- succesor is always at hand.
616 -- Concatenation itself generates no additional possibilities for
617 -- backtracking, but the constituent patterns of the concatenated
618 -- structure will make stack entries as usual. The maximum amount
619 -- of stack required by the structure is thus simply the sum of the
620 -- maximums required by L and R.
622 -- The index numbering of a concatenation structure works by leaving
623 -- the numbering of the right hand pattern, R, unchanged and adjusting
624 -- the numbers in the left hand pattern, L up by the count of elements
625 -- in R. This ensures that the maximum numbered element is the leading
626 -- element as required (given that it was the leading element in L).
632 -- A pattern (L or R) constructs the structure:
635 -- | A |---->| L |---->
643 -- The A element here is a PC_Alt node, and the dotted line represents
644 -- the contents of the Alt field. When the PC_Alt element is matched,
645 -- it stacks a pointer to the leading element of R on the history stack
646 -- so that on subsequent failure, a match of R is attempted.
648 -- The A node is the higest numbered element in the pattern. The
649 -- original index numbers of R are unchanged, but the index numbers
650 -- of the L pattern are adjusted up by the count of elements in R.
652 -- Note that the difference between the index of the L leading element
653 -- the index of the R leading element (after building the alt structure)
654 -- indicates the number of nodes in L, and this is true even after the
655 -- structure is incorporated into some larger structure. For example,
656 -- if the A node has index 16, and L has index 15 and R has index
657 -- 5, then we know that L has 10 (15-5) elements in it.
659 -- Suppose that we now concatenate this structure to another pattern
660 -- with 9 elements in it. We will now have the A node with an index
661 -- of 25, L with an index of 24 and R with an index of 14. We still
662 -- know that L has 10 (24-14) elements in it, numbered 15-24, and
663 -- consequently the successor of the alternation structure has an
664 -- index with a value less than 15. This is used in Image to figure
665 -- out the original recursive structure of a pattern.
667 -- To clarify the interaction of the alternation and concatenation
668 -- structures, here is a more complex example of the structure built
671 -- (V or W or X) (Y or Z)
673 -- where A,B,C,D,E are all single element patterns:
675 -- +---+ +---+ +---+ +---+
676 -- I A I---->I V I---+-->I A I---->I Y I---->
677 -- +---+ +---+ I +---+ +---+
680 -- +---+ +---+ I +---+
681 -- I A I---->I W I-->I I Z I---->
682 -- +---+ +---+ I +---+
686 -- I X I------------>+
689 -- The numbering of the nodes would be as follows:
691 -- +---+ +---+ +---+ +---+
692 -- I 8 I---->I 7 I---+-->I 3 I---->I 2 I---->
693 -- +---+ +---+ I +---+ +---+
696 -- +---+ +---+ I +---+
697 -- I 6 I---->I 5 I-->I I 1 I---->
698 -- +---+ +---+ I +---+
702 -- I 4 I------------>+
705 -- Note: The above structure actually corresponds to
707 -- (A or (B or C)) (D or E)
711 -- ((A or B) or C) (D or E)
713 -- which is the more natural interpretation, but in fact alternation
714 -- is associative, and the construction of an alternative changes the
715 -- left grouped pattern to the right grouped pattern in any case, so
716 -- that the Image function produces a more natural looking output.
722 -- An Arb pattern builds the structure
733 -- The X node is a PC_Arb_X node, which matches null, and stacks a
734 -- pointer to Y node, which is the PC_Arb_Y node that matches one
735 -- extra character and restacks itself.
737 -- The PC_Arb_X node is numbered 2, and the PC_Arb_Y node is 1.
739 -------------------------
740 -- Arbno (simple case) --
741 -------------------------
743 -- The simple form of Arbno can be used where the pattern always
744 -- matches at least one character if it succeeds, and it is known
745 -- not to make any history stack entries. In this case, Arbno (P)
746 -- can construct the following structure:
760 -- The S (PC_Arbno_S) node matches null stacking a pointer to the
761 -- pattern P. If a subsequent failure causes P to be matched and
762 -- this match succeeds, then node A gets restacked to try another
763 -- instance if needed by a subsequent failure.
765 -- The node numbering of the constituent pattern P is not affected.
766 -- The S node has a node number of P.Index + 1.
768 --------------------------
769 -- Arbno (complex case) --
770 --------------------------
772 -- A call to Arbno (P), where P can match null (or at least is not
773 -- known to require a non-null string) and/or P requires pattern stack
774 -- entries, constructs the following structure:
776 -- +--------------------------+
784 -- +---+ +---+ +---+ |
785 -- | E |---->| P |---->| Y |--->+
788 -- The node X (PC_Arbno_X) matches null, stacking a pointer to the
789 -- E-P-X structure used to match one Arbno instance.
791 -- Here E is the PC_R_Enter node which matches null and creates two
792 -- stack entries. The first is a special entry whose node field is
793 -- not used at all, and whose cursor field has the initial cursor.
795 -- The second entry corresponds to a standard new region action. A
796 -- PC_R_Remove node is stacked, whose cursor field is used to store
797 -- the outer stack base, and the stack base is reset to point to
798 -- this PC_R_Remove node. Then the pattern P is matched, and it can
799 -- make history stack entries in the normal manner, so now the stack
802 -- (stack entries made before assign pattern)
804 -- (Special entry, node field not used,
805 -- used only to save initial cursor)
807 -- (PC_R_Remove entry, "cursor" value is (negative) <-- Stack Base
808 -- saved base value for the enclosing region)
810 -- (stack entries made by matching P)
812 -- If the match of P fails, then the PC_R_Remove entry is popped and
813 -- it removes both itself and the special entry underneath it,
814 -- restores the outer stack base, and signals failure.
816 -- If the match of P succeeds, then node Y, the PC_Arbno_Y node, pops
817 -- the inner region. There are two possibilities. If matching P left
818 -- no stack entries, then all traces of the inner region can be removed.
819 -- If there are stack entries, then we push an PC_Region_Replace stack
820 -- entry whose "cursor" value is the inner stack base value, and then
821 -- restore the outer stack base value, so the stack looks like:
823 -- (stack entries made before assign pattern)
825 -- (Special entry, node field not used,
826 -- used only to save initial cursor)
828 -- (PC_R_Remove entry, "cursor" value is (negative)
829 -- saved base value for the enclosing region)
831 -- (stack entries made by matching P)
833 -- (PC_Region_Replace entry, "cursor" value is (negative)
834 -- stack pointer value referencing the PC_R_Remove entry).
836 -- Now that we have matched another instance of the Arbno pattern,
837 -- we need to move to the successor. There are two cases. If the
838 -- Arbno pattern matched null, then there is no point in seeking
839 -- alternatives, since we would just match a whole bunch of nulls.
840 -- In this case we look through the alternative node, and move
841 -- directly to its successor (i.e. the successor of the Arbno
842 -- pattern). If on the other hand a non-null string was matched,
843 -- we simply follow the successor to the alternative node, which
844 -- sets up for another possible match of the Arbno pattern.
846 -- As noted in the section on stack checking, the stack count (and
847 -- hence the stack check) for a pattern includes only one iteration
848 -- of the Arbno pattern. To make sure that multiple iterations do not
849 -- overflow the stack, the Arbno node saves the stack count required
850 -- by a single iteration, and the Concat function increments this to
851 -- include stack entries required by any successor. The PC_Arbno_Y
852 -- node uses this count to ensure that sufficient stack remains
853 -- before proceeding after matching each new instance.
855 -- The node numbering of the constituent pattern P is not affected.
856 -- Where N is the number of nodes in P, the Y node is numbered N + 1,
857 -- the E node is N + 2, and the X node is N + 3.
859 ----------------------
860 -- Assign Immediate --
861 ----------------------
863 -- Immediate assignment (P * V) constructs the following structure
866 -- | E |---->| P |---->| A |---->
869 -- Here E is the PC_R_Enter node which matches null and creates two
870 -- stack entries. The first is a special entry whose node field is
871 -- not used at all, and whose cursor field has the initial cursor.
873 -- The second entry corresponds to a standard new region action. A
874 -- PC_R_Remove node is stacked, whose cursor field is used to store
875 -- the outer stack base, and the stack base is reset to point to
876 -- this PC_R_Remove node. Then the pattern P is matched, and it can
877 -- make history stack entries in the normal manner, so now the stack
880 -- (stack entries made before assign pattern)
882 -- (Special entry, node field not used,
883 -- used only to save initial cursor)
885 -- (PC_R_Remove entry, "cursor" value is (negative) <-- Stack Base
886 -- saved base value for the enclosing region)
888 -- (stack entries made by matching P)
890 -- If the match of P fails, then the PC_R_Remove entry is popped
891 -- and it removes both itself and the special entry underneath it,
892 -- restores the outer stack base, and signals failure.
894 -- If the match of P succeeds, then node A, which is the actual
895 -- PC_Assign_Imm node, executes the assignment (using the stack
896 -- base to locate the entry with the saved starting cursor value),
897 -- and the pops the inner region. There are two possibilities, if
898 -- matching P left no stack entries, then all traces of the inner
899 -- region can be removed. If there are stack entries, then we push
900 -- an PC_Region_Replace stack entry whose "cursor" value is the
901 -- inner stack base value, and then restore the outer stack base
902 -- value, so the stack looks like:
904 -- (stack entries made before assign pattern)
906 -- (Special entry, node field not used,
907 -- used only to save initial cursor)
909 -- (PC_R_Remove entry, "cursor" value is (negative)
910 -- saved base value for the enclosing region)
912 -- (stack entries made by matching P)
914 -- (PC_Region_Replace entry, "cursor" value is the (negative)
915 -- stack pointer value referencing the PC_R_Remove entry).
917 -- If a subsequent failure occurs, the PC_Region_Replace node restores
918 -- the inner stack base value and signals failure to explore rematches
921 -- The node numbering of the constituent pattern P is not affected.
922 -- Where N is the number of nodes in P, the A node is numbered N + 1,
923 -- and the E node is N + 2.
925 ---------------------
926 -- Assign On Match --
927 ---------------------
929 -- The assign on match (**) pattern is quite similar to the assign
930 -- immediate pattern, except that the actual assignment has to be
931 -- delayed. The following structure is constructed:
934 -- | E |---->| P |---->| A |---->
937 -- The operation of this pattern is identical to that described above
938 -- for deferred assignment, up to the point where P has been matched.
940 -- The A node, which is the PC_Assign_OnM node first pushes a
941 -- PC_Assign node onto the history stack. This node saves the ending
942 -- cursor and acts as a flag for the final assignment, as further
945 -- It then stores a pointer to itself in the special entry node field.
946 -- This was otherwise unused, and is now used to retrive the address
947 -- of the variable to be assigned at the end of the pattern.
949 -- After that the inner region is terminated in the usual manner,
950 -- by stacking a PC_R_Restore entry as described for the assign
951 -- immediate case. Note that the optimization of completely
952 -- removing the inner region does not happen in this case, since
953 -- we have at least one stack entry (the PC_Assign one we just made).
954 -- The stack now looks like:
956 -- (stack entries made before assign pattern)
958 -- (Special entry, node points to copy of
959 -- the PC_Assign_OnM node, and the
960 -- cursor field saves the initial cursor).
962 -- (PC_R_Remove entry, "cursor" value is (negative)
963 -- saved base value for the enclosing region)
965 -- (stack entries made by matching P)
967 -- (PC_Assign entry, saves final cursor)
969 -- (PC_Region_Replace entry, "cursor" value is (negative)
970 -- stack pointer value referencing the PC_R_Remove entry).
972 -- If a subsequent failure causes the PC_Assign node to execute it
973 -- simply removes itself and propagates the failure.
975 -- If the match succeeds, then the history stack is scanned for
976 -- PC_Assign nodes, and the assignments are executed (examination
977 -- of the above diagram will show that all the necessary data is
978 -- at hand for the assignment).
980 -- To optimize the common case where no assign-on-match operations
981 -- are present, a global flag Assign_OnM is maintained which is
982 -- initialize to False, and gets set True as part of the execution
983 -- of the PC_Assign_OnM node. The scan of the history stack for
984 -- PC_Assign entries is done only if this flag is set.
986 -- The node numbering of the constituent pattern P is not affected.
987 -- Where N is the number of nodes in P, the A node is numbered N + 1,
988 -- and the E node is N + 2.
994 -- Bal builds a single node:
1000 -- The node B is the PC_Bal node which matches a parentheses balanced
1001 -- string, starting at the current cursor position. It then updates
1002 -- the cursor past this matched string, and stacks a pointer to itself
1003 -- with this updated cursor value on the history stack, to extend the
1004 -- matched string on a subequent failure.
1006 -- Since this is a single node it is numbered 1 (the reason we include
1007 -- it in the compound patterns section is that it backtracks).
1013 -- BreakX builds the structure
1016 -- | B |---->| A |---->
1024 -- Here the B node is the BreakX_xx node that performs a normal Break
1025 -- function. The A node is an alternative (PC_Alt) node that matches
1026 -- null, but stacks a pointer to node X (the PC_BreakX_X node) which
1027 -- extends the match one character (to eat up the previously detected
1028 -- break character), and then rematches the break.
1030 -- The B node is numbered 3, the alternative node is 1, and the X
1037 -- Fence builds a single node:
1043 -- The element F, PC_Fence, matches null, and stacks a pointer to a
1044 -- PC_Cancel element which will abort the match on a subsequent failure.
1046 -- Since this is a single element it is numbered 1 (the reason we
1047 -- include it in the compound patterns section is that it backtracks).
1049 --------------------
1050 -- Fence Function --
1051 --------------------
1053 -- A call to the Fence function builds the structure:
1055 -- +---+ +---+ +---+
1056 -- | E |---->| P |---->| X |---->
1057 -- +---+ +---+ +---+
1059 -- Here E is the PC_R_Enter node which matches null and creates two
1060 -- stack entries. The first is a special entry which is not used at
1061 -- all in the fence case (it is present merely for uniformity with
1062 -- other cases of region enter operations).
1064 -- The second entry corresponds to a standard new region action. A
1065 -- PC_R_Remove node is stacked, whose cursor field is used to store
1066 -- the outer stack base, and the stack base is reset to point to
1067 -- this PC_R_Remove node. Then the pattern P is matched, and it can
1068 -- make history stack entries in the normal manner, so now the stack
1071 -- (stack entries made before fence pattern)
1073 -- (Special entry, not used at all)
1075 -- (PC_R_Remove entry, "cursor" value is (negative) <-- Stack Base
1076 -- saved base value for the enclosing region)
1078 -- (stack entries made by matching P)
1080 -- If the match of P fails, then the PC_R_Remove entry is popped
1081 -- and it removes both itself and the special entry underneath it,
1082 -- restores the outer stack base, and signals failure.
1084 -- If the match of P succeeds, then node X, the PC_Fence_X node, gets
1085 -- control. One might be tempted to think that at this point, the
1086 -- history stack entries made by matching P can just be removed since
1087 -- they certainly are not going to be used for rematching (that is
1088 -- whole point of Fence after all!) However, this is wrong, because
1089 -- it would result in the loss of possible assign-on-match entries
1090 -- for deferred pattern assignments.
1092 -- Instead what we do is to make a special entry whose node references
1093 -- PC_Fence_Y, and whose cursor saves the inner stack base value, i.e.
1094 -- the pointer to the PC_R_Remove entry. Then the outer stack base
1095 -- pointer is restored, so the stack looks like:
1097 -- (stack entries made before assign pattern)
1099 -- (Special entry, not used at all)
1101 -- (PC_R_Remove entry, "cursor" value is (negative)
1102 -- saved base value for the enclosing region)
1104 -- (stack entries made by matching P)
1106 -- (PC_Fence_Y entry, "cursor" value is (negative) stack
1107 -- pointer value referencing the PC_R_Remove entry).
1109 -- If a subsequent failure occurs, then the PC_Fence_Y entry removes
1110 -- the entire inner region, including all entries made by matching P,
1111 -- and alternatives prior to the Fence pattern are sought.
1113 -- The node numbering of the constituent pattern P is not affected.
1114 -- Where N is the number of nodes in P, the X node is numbered N + 1,
1115 -- and the E node is N + 2.
1121 -- Succeed builds a single node:
1127 -- The node S is the PC_Succeed node which matches null, and stacks
1128 -- a pointer to itself on the history stack, so that a subsequent
1129 -- failure repeats the same match.
1131 -- Since this is a single node it is numbered 1 (the reason we include
1132 -- it in the compound patterns section is that it backtracks).
1134 ---------------------
1135 -- Write Immediate --
1136 ---------------------
1138 -- The structure built for a write immediate operation (P * F, where
1139 -- F is a file access value) is:
1141 -- +---+ +---+ +---+
1142 -- | E |---->| P |---->| W |---->
1143 -- +---+ +---+ +---+
1145 -- Here E is the PC_R_Enter node and W is the PC_Write_Imm node. The
1146 -- handling is identical to that described above for Assign Immediate,
1147 -- except that at the point where a successful match occurs, the matched
1148 -- substring is written to the referenced file.
1150 -- The node numbering of the constituent pattern P is not affected.
1151 -- Where N is the number of nodes in P, the W node is numbered N + 1,
1152 -- and the E node is N + 2.
1154 --------------------
1155 -- Write On Match --
1156 --------------------
1158 -- The structure built for a write on match operation (P ** F, where
1159 -- F is a file access value) is:
1161 -- +---+ +---+ +---+
1162 -- | E |---->| P |---->| W |---->
1163 -- +---+ +---+ +---+
1165 -- Here E is the PC_R_Enter node and W is the PC_Write_OnM node. The
1166 -- handling is identical to that described above for Assign On Match,
1167 -- except that at the point where a successful match has completed,
1168 -- the matched substring is written to the referenced file.
1170 -- The node numbering of the constituent pattern P is not affected.
1171 -- Where N is the number of nodes in P, the W node is numbered N + 1,
1172 -- and the E node is N + 2.
1173 -----------------------
1174 -- Constant Patterns --
1175 -----------------------
1177 -- The following pattern elements are referenced only from the pattern
1178 -- history stack. In each case the processing for the pattern element
1179 -- results in pattern match abort, or futher failure, so there is no
1180 -- need for a successor and no need for a node number
1182 CP_Assign : aliased PE := (PC_Assign, 0, N);
1183 CP_Cancel : aliased PE := (PC_Cancel, 0, N);
1184 CP_Fence_Y : aliased PE := (PC_Fence_Y, 0, N);
1185 CP_R_Remove : aliased PE := (PC_R_Remove, 0, N);
1186 CP_R_Restore : aliased PE := (PC_R_Restore, 0, N);
1188 -----------------------
1189 -- Local Subprograms --
1190 -----------------------
1192 function Alternate (L, R : PE_Ptr) return PE_Ptr;
1193 function "or" (L, R : PE_Ptr) return PE_Ptr renames Alternate;
1194 -- Build pattern structure corresponding to the alternation of L, R.
1195 -- (i.e. try to match L, and if that fails, try to match R).
1197 function Arbno_Simple (P : PE_Ptr) return PE_Ptr;
1198 -- Build simple Arbno pattern, P is a pattern that is guaranteed to
1199 -- match at least one character if it succeeds and to require no
1200 -- stack entries under all circumstances. The result returned is
1201 -- a simple Arbno structure as previously described.
1203 function Bracket (E, P, A : PE_Ptr) return PE_Ptr;
1204 -- Given two single node pattern elements E and A, and a (possible
1205 -- complex) pattern P, construct the concatenation E-->P-->A and
1206 -- return a pointer to E. The concatenation does not affect the
1207 -- node numbering in P. A has a number one higher than the maximum
1208 -- number in P, and E has a number two higher than the maximum
1209 -- number in P (see for example the Assign_Immediate structure to
1210 -- understand a typical use of this function).
1212 function BreakX_Make (B : PE_Ptr) return Pattern;
1213 -- Given a pattern element for a Break patternx, returns the
1214 -- corresponding BreakX compound pattern structure.
1216 function Concat (L, R : PE_Ptr; Incr : Natural) return PE_Ptr;
1217 -- Creates a pattern eelement that represents a concatenation of the
1218 -- two given pattern elements (i.e. the pattern L followed by R).
1219 -- The result returned is always the same as L, but the pattern
1220 -- referenced by L is modified to have R as a successor. This
1221 -- procedure does not copy L or R, so if a copy is required, it
1222 -- is the responsibility of the caller. The Incr parameter is an
1223 -- amount to be added to the Nat field of any P_Arbno_Y node that is
1224 -- in the left operand, it represents the additional stack space
1225 -- required by the right operand.
1227 function C_To_PE (C : PChar) return PE_Ptr;
1228 -- Given a character, constructs a pattern element that matches
1229 -- the single character.
1231 function Copy (P : PE_Ptr) return PE_Ptr;
1232 -- Creates a copy of the pattern element referenced by the given
1233 -- pattern element reference. This is a deep copy, which means that
1234 -- it follows the Next and Alt pointers.
1236 function Image (P : PE_Ptr) return String;
1237 -- Returns the image of the address of the referenced pattern element.
1238 -- This is equivalent to Image (To_Address (P));
1240 function Is_In (C : Character; Str : String) return Boolean;
1241 pragma Inline (Is_In);
1242 -- Determines if the character C is in string Str.
1244 procedure Logic_Error;
1245 -- Called to raise Program_Error with an appropriate message if an
1246 -- internal logic error is detected.
1248 function Str_BF (A : Boolean_Func) return String;
1249 function Str_FP (A : File_Ptr) return String;
1250 function Str_NF (A : Natural_Func) return String;
1251 function Str_NP (A : Natural_Ptr) return String;
1252 function Str_PP (A : Pattern_Ptr) return String;
1253 function Str_VF (A : VString_Func) return String;
1254 function Str_VP (A : VString_Ptr) return String;
1255 -- These are debugging routines, which return a representation of the
1256 -- given access value (they are called only by Image and Dump)
1258 procedure Set_Successor (Pat : PE_Ptr; Succ : PE_Ptr);
1259 -- Adjusts all EOP pointers in Pat to point to Succ. No other changes
1260 -- are made. In particular, Succ is unchanged, and no index numbers
1261 -- are modified. Note that Pat may not be equal to EOP on entry.
1263 function S_To_PE (Str : PString) return PE_Ptr;
1264 -- Given a string, constructs a pattern element that matches the string
1266 procedure Uninitialized_Pattern;
1267 pragma No_Return (Uninitialized_Pattern);
1268 -- Called to raise Program_Error with an appropriate error message if
1269 -- an uninitialized pattern is used in any pattern construction or
1270 -- pattern matching operation.
1276 Start : out Natural;
1277 Stop : out Natural);
1278 -- This is the common pattern match routine. It is passed a string and
1279 -- a pattern, and it indicates success or failure, and on success the
1280 -- section of the string matched. It does not perform any assignments
1281 -- to the subject string, so pattern replacement is for the caller.
1283 -- Subject The subject string. The lower bound is always one. In the
1284 -- Match procedures, it is fine to use strings whose lower bound
1285 -- is not one, but we perform a one time conversion before the
1286 -- call to XMatch, so that XMatch does not have to be bothered
1287 -- with strange lower bounds.
1289 -- Pat_P Points to initial pattern element of pattern to be matched
1291 -- Pat_S Maximum required stack entries for pattern to be matched
1293 -- Start If match is successful, starting index of matched section.
1294 -- This value is always non-zero. A value of zero is used to
1295 -- indicate a failed match.
1297 -- Stop If match is successful, ending index of matched section.
1298 -- This can be zero if we match the null string at the start,
1299 -- in which case Start is set to zero, and Stop to one. If the
1300 -- Match fails, then the contents of Stop is undefined.
1306 Start : out Natural;
1307 Stop : out Natural);
1308 -- Identical in all respects to XMatch, except that trace information is
1309 -- output on Standard_Ouput during execution of the match. This is the
1310 -- version that is called if the original Match call has Debug => True.
1316 function "&" (L : PString; R : Pattern) return Pattern is
1318 return (AFC with R.Stk, Concat (S_To_PE (L), Copy (R.P), R.Stk));
1321 function "&" (L : Pattern; R : PString) return Pattern is
1323 return (AFC with L.Stk, Concat (Copy (L.P), S_To_PE (R), 0));
1326 function "&" (L : PChar; R : Pattern) return Pattern is
1328 return (AFC with R.Stk, Concat (C_To_PE (L), Copy (R.P), R.Stk));
1331 function "&" (L : Pattern; R : PChar) return Pattern is
1333 return (AFC with L.Stk, Concat (Copy (L.P), C_To_PE (R), 0));
1336 function "&" (L : Pattern; R : Pattern) return Pattern is
1338 return (AFC with L.Stk + R.Stk, Concat (Copy (L.P), Copy (R.P), R.Stk));
1347 -- +---+ +---+ +---+
1348 -- | E |---->| P |---->| A |---->
1349 -- +---+ +---+ +---+
1351 -- The node numbering of the constituent pattern P is not affected.
1352 -- Where N is the number of nodes in P, the A node is numbered N + 1,
1353 -- and the E node is N + 2.
1355 function "*" (P : Pattern; Var : VString_Var) return Pattern is
1356 Pat : constant PE_Ptr := Copy (P.P);
1357 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1358 A : constant PE_Ptr :=
1359 new PE'(PC_Assign_Imm, 0, EOP, Var'Unrestricted_Access);
1362 return (AFC with P.Stk + 3, Bracket (E, Pat, A));
1365 function "*" (P : PString; Var : VString_Var) return Pattern is
1366 Pat : constant PE_Ptr := S_To_PE (P);
1367 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1368 A : constant PE_Ptr :=
1369 new PE'(PC_Assign_Imm, 0, EOP, Var'Unrestricted_Access);
1372 return (AFC with 3, Bracket (E, Pat, A));
1375 function "*" (P : PChar; Var : VString_Var) return Pattern is
1376 Pat : constant PE_Ptr := C_To_PE (P);
1377 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1378 A : constant PE_Ptr :=
1379 new PE'(PC_Assign_Imm, 0, EOP, Var'Unrestricted_Access);
1382 return (AFC with 3, Bracket (E, Pat, A));
1387 -- +---+ +---+ +---+
1388 -- | E |---->| P |---->| W |---->
1389 -- +---+ +---+ +---+
1391 -- The node numbering of the constituent pattern P is not affected.
1392 -- Where N is the number of nodes in P, the W node is numbered N + 1,
1393 -- and the E node is N + 2.
1395 function "*" (P : Pattern; Fil : File_Access) return Pattern is
1396 Pat : constant PE_Ptr := Copy (P.P);
1397 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1398 W : constant PE_Ptr := new PE'(PC_Write_Imm, 0, EOP, Fil);
1401 return (AFC with 3, Bracket (E, Pat, W));
1404 function "*" (P : PString; Fil : File_Access) return Pattern is
1405 Pat : constant PE_Ptr := S_To_PE (P);
1406 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1407 W : constant PE_Ptr := new PE'(PC_Write_Imm, 0, EOP, Fil);
1410 return (AFC with 3, Bracket (E, Pat, W));
1413 function "*" (P : PChar; Fil : File_Access) return Pattern is
1414 Pat : constant PE_Ptr := C_To_PE (P);
1415 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1416 W : constant PE_Ptr := new PE'(PC_Write_Imm, 0, EOP, Fil);
1419 return (AFC with 3, Bracket (E, Pat, W));
1428 -- +---+ +---+ +---+
1429 -- | E |---->| P |---->| A |---->
1430 -- +---+ +---+ +---+
1432 -- The node numbering of the constituent pattern P is not affected.
1433 -- Where N is the number of nodes in P, the A node is numbered N + 1,
1434 -- and the E node is N + 2.
1436 function "**" (P : Pattern; Var : VString_Var) return Pattern is
1437 Pat : constant PE_Ptr := Copy (P.P);
1438 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1439 A : constant PE_Ptr :=
1440 new PE'(PC_Assign_OnM, 0, EOP, Var'Unrestricted_Access);
1443 return (AFC with P.Stk + 3, Bracket (E, Pat, A));
1446 function "**" (P : PString; Var : VString_Var) return Pattern is
1447 Pat : constant PE_Ptr := S_To_PE (P);
1448 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1449 A : constant PE_Ptr :=
1450 new PE'(PC_Assign_OnM, 0, EOP, Var'Unrestricted_Access);
1453 return (AFC with 3, Bracket (E, Pat, A));
1456 function "**" (P : PChar; Var : VString_Var) return Pattern is
1457 Pat : constant PE_Ptr := C_To_PE (P);
1458 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1459 A : constant PE_Ptr :=
1460 new PE'(PC_Assign_OnM, 0, EOP, Var'Unrestricted_Access);
1463 return (AFC with 3, Bracket (E, Pat, A));
1468 -- +---+ +---+ +---+
1469 -- | E |---->| P |---->| W |---->
1470 -- +---+ +---+ +---+
1472 -- The node numbering of the constituent pattern P is not affected.
1473 -- Where N is the number of nodes in P, the W node is numbered N + 1,
1474 -- and the E node is N + 2.
1476 function "**" (P : Pattern; Fil : File_Access) return Pattern is
1477 Pat : constant PE_Ptr := Copy (P.P);
1478 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1479 W : constant PE_Ptr := new PE'(PC_Write_OnM, 0, EOP, Fil);
1482 return (AFC with P.Stk + 3, Bracket (E, Pat, W));
1485 function "**" (P : PString; Fil : File_Access) return Pattern is
1486 Pat : constant PE_Ptr := S_To_PE (P);
1487 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1488 W : constant PE_Ptr := new PE'(PC_Write_OnM, 0, EOP, Fil);
1491 return (AFC with 3, Bracket (E, Pat, W));
1494 function "**" (P : PChar; Fil : File_Access) return Pattern is
1495 Pat : constant PE_Ptr := C_To_PE (P);
1496 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1497 W : constant PE_Ptr := new PE'(PC_Write_OnM, 0, EOP, Fil);
1500 return (AFC with 3, Bracket (E, Pat, W));
1507 function "+" (Str : VString_Var) return Pattern is
1511 new PE'(PC_String_VP, 1, EOP, Str'Unrestricted_Access));
1514 function "+" (Str : VString_Func) return Pattern is
1516 return (AFC with 0, new PE'(PC_String_VF, 1, EOP, Str));
1519 function "+" (P : Pattern_Var) return Pattern is
1523 new PE'(PC_Rpat, 1, EOP, P'Unrestricted_Access));
1526 function "+" (P : Boolean_Func) return Pattern is
1528 return (AFC with 3, new PE'(PC_Pred_Func, 1, EOP, P));
1535 function "or" (L : PString; R : Pattern) return Pattern is
1537 return (AFC with R.Stk + 1, S_To_PE (L) or Copy (R.P));
1540 function "or" (L : Pattern; R : PString) return Pattern is
1542 return (AFC with L.Stk + 1, Copy (L.P) or S_To_PE (R));
1545 function "or" (L : PString; R : PString) return Pattern is
1547 return (AFC with 1, S_To_PE (L) or S_To_PE (R));
1550 function "or" (L : Pattern; R : Pattern) return Pattern is
1553 Natural'Max (L.Stk, R.Stk) + 1, Copy (L.P) or Copy (R.P));
1556 function "or" (L : PChar; R : Pattern) return Pattern is
1558 return (AFC with 1, C_To_PE (L) or Copy (R.P));
1561 function "or" (L : Pattern; R : PChar) return Pattern is
1563 return (AFC with 1, Copy (L.P) or C_To_PE (R));
1566 function "or" (L : PChar; R : PChar) return Pattern is
1568 return (AFC with 1, C_To_PE (L) or C_To_PE (R));
1571 function "or" (L : PString; R : PChar) return Pattern is
1573 return (AFC with 1, S_To_PE (L) or C_To_PE (R));
1576 function "or" (L : PChar; R : PString) return Pattern is
1578 return (AFC with 1, C_To_PE (L) or S_To_PE (R));
1585 -- No two patterns share the same pattern elements, so the adjust
1586 -- procedure for a Pattern assignment must do a deep copy of the
1587 -- pattern element structure.
1589 procedure Adjust (Object : in out Pattern) is
1591 Object.P := Copy (Object.P);
1598 function Alternate (L, R : PE_Ptr) return PE_Ptr is
1600 -- If the left pattern is null, then we just add the alternation
1601 -- node with an index one greater than the right hand pattern.
1604 return new PE'(PC_Alt, R.Index + 1, EOP, R);
1606 -- If the left pattern is non-null, then build a reference vector
1607 -- for its elements, and adjust their index values to acccomodate
1608 -- the right hand elements. Then add the alternation node.
1612 Refs : Ref_Array (1 .. L.Index);
1615 Build_Ref_Array (L, Refs);
1617 for J in Refs'Range loop
1618 Refs (J).Index := Refs (J).Index + R.Index;
1622 return new PE'(PC_Alt, L.Index + 1, L, R);
1630 function Any (Str : String) return Pattern is
1632 return (AFC with 0, new PE'(PC_Any_CS, 1, EOP, To_Set (Str)));
1635 function Any (Str : VString) return Pattern is
1637 return Any (S (Str));
1640 function Any (Str : Character) return Pattern is
1642 return (AFC with 0, new PE'(PC_Any_CH, 1, EOP, Str));
1645 function Any (Str : Character_Set) return Pattern is
1647 return (AFC with 0, new PE'(PC_Any_CS, 1, EOP, Str));
1650 function Any (Str : access VString) return Pattern is
1652 return (AFC with 0, new PE'(PC_Any_VP, 1, EOP, VString_Ptr (Str)));
1655 function Any (Str : VString_Func) return Pattern is
1657 return (AFC with 0, new PE'(PC_Any_VF, 1, EOP, Str));
1673 -- The PC_Arb_X element is numbered 2, and the PC_Arb_Y element is 1.
1675 function Arb return Pattern is
1676 Y : constant PE_Ptr := new PE'(PC_Arb_Y, 1, EOP);
1677 X : constant PE_Ptr := new PE'(PC_Arb_X, 2, EOP, Y);
1680 return (AFC with 1, X);
1687 function Arbno (P : PString) return Pattern is
1689 if P'Length = 0 then
1690 return (AFC with 0, EOP);
1693 return (AFC with 0, Arbno_Simple (S_To_PE (P)));
1697 function Arbno (P : PChar) return Pattern is
1699 return (AFC with 0, Arbno_Simple (C_To_PE (P)));
1702 function Arbno (P : Pattern) return Pattern is
1703 Pat : constant PE_Ptr := Copy (P.P);
1707 and then OK_For_Simple_Arbno (Pat.Pcode)
1709 return (AFC with 0, Arbno_Simple (Pat));
1712 -- This is the complex case, either the pattern makes stack entries
1713 -- or it is possible for the pattern to match the null string (more
1714 -- accurately, we don't know that this is not the case).
1716 -- +--------------------------+
1724 -- +---+ +---+ +---+ |
1725 -- | E |---->| P |---->| Y |--->+
1726 -- +---+ +---+ +---+
1728 -- The node numbering of the constituent pattern P is not affected.
1729 -- Where N is the number of nodes in P, the Y node is numbered N + 1,
1730 -- the E node is N + 2, and the X node is N + 3.
1733 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
1734 X : constant PE_Ptr := new PE'(PC_Arbno_X, 0, EOP, E);
1735 Y : constant PE_Ptr := new PE'(PC_Arbno_Y, 0, X, P.Stk + 3);
1736 EPY : constant PE_Ptr := Bracket (E, Pat, Y);
1740 X.Index := EPY.Index + 1;
1741 return (AFC with P.Stk + 3, X);
1758 -- | P |---------->+
1761 -- The node numbering of the constituent pattern P is not affected.
1762 -- The S node has a node number of P.Index + 1.
1764 -- Note that we know that P cannot be EOP, because a null pattern
1765 -- does not meet the requirements for simple Arbno.
1767 function Arbno_Simple (P : PE_Ptr) return PE_Ptr is
1768 S : constant PE_Ptr := new PE'(PC_Arbno_S, P.Index + 1, EOP, P);
1771 Set_Successor (P, S);
1779 function Bal return Pattern is
1781 return (AFC with 1, new PE'(PC_Bal, 1, EOP));
1788 function Bracket (E, P, A : PE_Ptr) return PE_Ptr is
1797 Set_Successor (P, A);
1798 E.Index := P.Index + 2;
1799 A.Index := P.Index + 1;
1809 function Break (Str : String) return Pattern is
1811 return (AFC with 0, new PE'(PC_Break_CS, 1, EOP, To_Set (Str)));
1814 function Break (Str : VString) return Pattern is
1816 return Break (S (Str));
1819 function Break (Str : Character) return Pattern is
1821 return (AFC with 0, new PE'(PC_Break_CH, 1, EOP, Str));
1824 function Break (Str : Character_Set) return Pattern is
1826 return (AFC with 0, new PE'(PC_Break_CS, 1, EOP, Str));
1829 function Break (Str : access VString) return Pattern is
1831 return (AFC with 0, new PE'(PC_Break_VP, 1, EOP, VString_Ptr (Str)));
1834 function Break (Str : VString_Func) return Pattern is
1836 return (AFC with 0, new PE'(PC_Break_VF, 1, EOP, Str));
1843 function BreakX (Str : String) return Pattern is
1845 return BreakX_Make (new PE'(PC_BreakX_CS, 3, N, To_Set (Str)));
1848 function BreakX (Str : VString) return Pattern is
1850 return BreakX (S (Str));
1853 function BreakX (Str : Character) return Pattern is
1855 return BreakX_Make (new PE'(PC_BreakX_CH, 3, N, Str));
1858 function BreakX (Str : Character_Set) return Pattern is
1860 return BreakX_Make (new PE'(PC_BreakX_CS, 3, N, Str));
1863 function BreakX (Str : access VString) return Pattern is
1865 return BreakX_Make (new PE'(PC_BreakX_VP, 3, N, VString_Ptr (Str)));
1868 function BreakX (Str : VString_Func) return Pattern is
1870 return BreakX_Make (new PE'(PC_BreakX_VF, 3, N, Str));
1878 -- | B |---->| A |---->
1886 -- The B node is numbered 3, the alternative node is 1, and the X
1889 function BreakX_Make (B : PE_Ptr) return Pattern is
1890 X : constant PE_Ptr := new PE'(PC_BreakX_X, 2, B);
1891 A : constant PE_Ptr := new PE'(PC_Alt, 1, EOP, X);
1895 return (AFC with 2, B);
1898 ---------------------
1899 -- Build_Ref_Array --
1900 ---------------------
1902 procedure Build_Ref_Array (E : PE_Ptr; RA : out Ref_Array) is
1904 procedure Record_PE (E : PE_Ptr);
1905 -- Record given pattern element if not already recorded in RA,
1906 -- and also record any referenced pattern elements recursively.
1908 procedure Record_PE (E : PE_Ptr) is
1910 PutD (" Record_PE called with PE_Ptr = " & Image (E));
1912 if E = EOP or else RA (E.Index) /= null then
1913 Put_LineD (", nothing to do");
1917 Put_LineD (", recording" & IndexT'Image (E.Index));
1919 Record_PE (E.Pthen);
1921 if E.Pcode in PC_Has_Alt then
1927 -- Start of processing for Build_Ref_Array
1931 Put_LineD ("Entering Build_Ref_Array");
1934 end Build_Ref_Array;
1940 function C_To_PE (C : PChar) return PE_Ptr is
1942 return new PE'(PC_Char, 1, EOP, C);
1949 function Cancel return Pattern is
1951 return (AFC with 0, new PE'(PC_Cancel, 1, EOP));
1958 -- Concat needs to traverse the left operand performing the following
1961 -- a) Any successor pointers (Pthen fields) that are set to EOP are
1962 -- reset to point to the second operand.
1964 -- b) Any PC_Arbno_Y node has its stack count field incremented
1965 -- by the parameter Incr provided for this purpose.
1967 -- d) Num fields of all pattern elements in the left operand are
1968 -- adjusted to include the elements of the right operand.
1970 -- Note: we do not use Set_Successor in the processing for Concat, since
1971 -- there is no point in doing two traversals, we may as well do everything
1972 -- at the same time.
1974 function Concat (L, R : PE_Ptr; Incr : Natural) return PE_Ptr is
1984 Refs : Ref_Array (1 .. L.Index);
1985 -- We build a reference array for L whose N'th element points to
1986 -- the pattern element of L whose original Index value is N.
1991 Build_Ref_Array (L, Refs);
1993 for J in Refs'Range loop
1996 P.Index := P.Index + R.Index;
1998 if P.Pcode = PC_Arbno_Y then
1999 P.Nat := P.Nat + Incr;
2002 if P.Pthen = EOP then
2006 if P.Pcode in PC_Has_Alt and then P.Alt = EOP then
2020 function Copy (P : PE_Ptr) return PE_Ptr is
2023 Uninitialized_Pattern;
2027 Refs : Ref_Array (1 .. P.Index);
2028 -- References to elements in P, indexed by Index field
2030 Copy : Ref_Array (1 .. P.Index);
2031 -- Holds copies of elements of P, indexed by Index field.
2036 Build_Ref_Array (P, Refs);
2038 -- Now copy all nodes
2040 for J in Refs'Range loop
2041 Copy (J) := new PE'(Refs (J).all);
2044 -- Adjust all internal references
2046 for J in Copy'Range loop
2049 -- Adjust successor pointer to point to copy
2051 if E.Pthen /= EOP then
2052 E.Pthen := Copy (E.Pthen.Index);
2055 -- Adjust Alt pointer if there is one to point to copy
2057 if E.Pcode in PC_Has_Alt and then E.Alt /= EOP then
2058 E.Alt := Copy (E.Alt.Index);
2061 -- Copy referenced string
2063 if E.Pcode = PC_String then
2064 E.Str := new String'(E.Str.all);
2068 return Copy (P.Index);
2077 procedure Dump (P : Pattern) is
2079 subtype Count is Ada.Text_IO.Count;
2081 -- Used to keep track of column in dump output
2083 Refs : Ref_Array (1 .. P.P.Index);
2084 -- We build a reference array whose N'th element points to the
2085 -- pattern element whose Index value is N.
2087 Cols : Natural := 2;
2088 -- Number of columns used for pattern numbers, minimum is 2
2092 procedure Write_Node_Id (E : PE_Ptr);
2093 -- Writes out a string identifying the given pattern element.
2095 procedure Write_Node_Id (E : PE_Ptr) is
2100 for J in 4 .. Cols loop
2106 Str : String (1 .. Cols);
2107 N : Natural := Natural (E.Index);
2112 for J in reverse Str'Range loop
2113 Str (J) := Character'Val (48 + N mod 10);
2124 Put ("Pattern Dump Output (pattern at " &
2126 ", S = " & Natural'Image (P.Stk) & ')');
2131 while Col < Scol loop
2137 -- If uninitialized pattern, dump line and we are done
2140 Put_Line ("Uninitialized pattern value");
2144 -- If null pattern, just dump it and we are all done
2147 Put_Line ("EOP (null pattern)");
2151 Build_Ref_Array (P.P, Refs);
2153 -- Set number of columns required for node numbers
2155 while 10 ** Cols - 1 < Integer (P.P.Index) loop
2159 -- Now dump the nodes in reverse sequence. We output them in reverse
2160 -- sequence since this corresponds to the natural order used to
2161 -- construct the patterns.
2163 for J in reverse Refs'Range loop
2166 Set_Col (Count (Cols) + 4);
2169 Put (Pattern_Code'Image (E.Pcode));
2171 Set_Col (21 + Count (Cols) + Address_Image_Length);
2172 Write_Node_Id (E.Pthen);
2173 Set_Col (24 + 2 * Count (Cols) + Address_Image_Length);
2181 Write_Node_Id (E.Alt);
2184 Put (Str_PP (E.PP));
2186 when PC_Pred_Func =>
2187 Put (Str_BF (E.BF));
2189 when PC_Assign_Imm |
2198 Put (Str_VP (E.VP));
2202 Put (Str_FP (E.FP));
2205 Put (Image (E.Str.all));
2208 Put (Image (E.Str2));
2211 Put (Image (E.Str3));
2214 Put (Image (E.Str4));
2217 Put (Image (E.Str5));
2220 Put (Image (E.Str6));
2223 Put (Str_NP (E.Var));
2232 Put (''' & E.Char & ''');
2240 Put ('"' & To_Sequence (E.CS) & '"');
2255 Put (Str_NF (E.NF));
2262 Put (Str_NP (E.NP));
2271 Put (Str_VF (E.VF));
2273 when others => null;
2287 function Fail return Pattern is
2289 return (AFC with 0, new PE'(PC_Fail, 1, EOP));
2298 function Fence return Pattern is
2300 return (AFC with 1, new PE'(PC_Fence, 1, EOP));
2305 -- +---+ +---+ +---+
2306 -- | E |---->| P |---->| X |---->
2307 -- +---+ +---+ +---+
2309 -- The node numbering of the constituent pattern P is not affected.
2310 -- Where N is the number of nodes in P, the X node is numbered N + 1,
2311 -- and the E node is N + 2.
2313 function Fence (P : Pattern) return Pattern is
2314 Pat : constant PE_Ptr := Copy (P.P);
2315 E : constant PE_Ptr := new PE'(PC_R_Enter, 0, EOP);
2316 X : constant PE_Ptr := new PE'(PC_Fence_X, 0, EOP);
2319 return (AFC with P.Stk + 1, Bracket (E, Pat, X));
2326 procedure Finalize (Object : in out Pattern) is
2328 procedure Free is new Unchecked_Deallocation (PE, PE_Ptr);
2329 procedure Free is new Unchecked_Deallocation (String, String_Ptr);
2332 -- Nothing to do if already freed
2334 if Object.P = null then
2337 -- Otherwise we must free all elements
2341 Refs : Ref_Array (1 .. Object.P.Index);
2342 -- References to elements in pattern to be finalized
2345 Build_Ref_Array (Object.P, Refs);
2347 for J in Refs'Range loop
2348 if Refs (J).Pcode = PC_String then
2349 Free (Refs (J).Str);
2364 function Image (P : PE_Ptr) return String is
2366 return Image (To_Address (P));
2369 function Image (P : Pattern) return String is
2371 return S (Image (P));
2374 function Image (P : Pattern) return VString is
2376 Kill_Ampersand : Boolean := False;
2377 -- Set True to delete next & to be output to Result
2379 Result : VString := Nul;
2380 -- The result is accumulated here, using Append
2382 Refs : Ref_Array (1 .. P.P.Index);
2383 -- We build a reference array whose N'th element points to the
2384 -- pattern element whose Index value is N.
2386 procedure Delete_Ampersand;
2387 -- Deletes the ampersand at the end of Result
2389 procedure Image_Seq (E : PE_Ptr; Succ : PE_Ptr; Paren : Boolean);
2390 -- E refers to a pattern structure whose successor is given by Succ.
2391 -- This procedure appends to Result a representation of this pattern.
2392 -- The Paren parameter indicates whether parentheses are required if
2393 -- the output is more than one element.
2395 procedure Image_One (E : in out PE_Ptr);
2396 -- E refers to a pattern structure. This procedure appends to Result
2397 -- a representation of the single simple or compound pattern structure
2398 -- at the start of E and updates E to point to its successor.
2400 ----------------------
2401 -- Delete_Ampersand --
2402 ----------------------
2404 procedure Delete_Ampersand is
2405 L : constant Natural := Length (Result);
2409 Delete (Result, L - 1, L);
2411 end Delete_Ampersand;
2417 procedure Image_One (E : in out PE_Ptr) is
2419 ER : PE_Ptr := E.Pthen;
2420 -- Successor set as result in E unless reset
2426 Append (Result, "Cancel");
2428 when PC_Alt => Alt : declare
2430 Elmts_In_L : constant IndexT := E.Pthen.Index - E.Alt.Index;
2431 -- Number of elements in left pattern of alternation.
2433 Lowest_In_L : constant IndexT := E.Index - Elmts_In_L;
2434 -- Number of lowest index in elements of left pattern
2439 -- The successor of the alternation node must have a lower
2440 -- index than any node that is in the left pattern or a
2441 -- higher index than the alternation node itself.
2444 and then ER.Index >= Lowest_In_L
2445 and then ER.Index < E.Index
2450 Append (Result, '(');
2454 Image_Seq (E1.Pthen, ER, False);
2455 Append (Result, " or ");
2457 exit when E1.Pcode /= PC_Alt;
2460 Image_Seq (E1, ER, False);
2461 Append (Result, ')');
2465 Append (Result, "Any (" & Image (To_Sequence (E.CS)) & ')');
2468 Append (Result, "Any (" & Str_VF (E.VF) & ')');
2471 Append (Result, "Any (" & Str_VP (E.VP) & ')');
2474 Append (Result, "Arb");
2477 Append (Result, "Arbno (");
2478 Image_Seq (E.Alt, E, False);
2479 Append (Result, ')');
2482 Append (Result, "Arbno (");
2483 Image_Seq (E.Alt.Pthen, Refs (E.Index - 2), False);
2484 Append (Result, ')');
2486 when PC_Assign_Imm =>
2488 Append (Result, "* " & Str_VP (Refs (E.Index - 1).VP));
2490 when PC_Assign_OnM =>
2492 Append (Result, "** " & Str_VP (Refs (E.Index - 1).VP));
2495 Append (Result, "Any ('" & E.Char & "')");
2498 Append (Result, "Bal");
2501 Append (Result, "Break ('" & E.Char & "')");
2504 Append (Result, "Break (" & Image (To_Sequence (E.CS)) & ')');
2507 Append (Result, "Break (" & Str_VF (E.VF) & ')');
2510 Append (Result, "Break (" & Str_VP (E.VP) & ')');
2512 when PC_BreakX_CH =>
2513 Append (Result, "BreakX ('" & E.Char & "')");
2516 when PC_BreakX_CS =>
2517 Append (Result, "BreakX (" & Image (To_Sequence (E.CS)) & ')');
2520 when PC_BreakX_VF =>
2521 Append (Result, "BreakX (" & Str_VF (E.VF) & ')');
2524 when PC_BreakX_VP =>
2525 Append (Result, "BreakX (" & Str_VP (E.VP) & ')');
2529 Append (Result, ''' & E.Char & ''');
2532 Append (Result, "Fail");
2535 Append (Result, "Fence");
2538 Append (Result, "Fence (");
2539 Image_Seq (E.Pthen, Refs (E.Index - 1), False);
2540 Append (Result, ")");
2541 ER := Refs (E.Index - 1).Pthen;
2544 Append (Result, "Len (" & E.Nat & ')');
2547 Append (Result, "Len (" & Str_NF (E.NF) & ')');
2550 Append (Result, "Len (" & Str_NP (E.NP) & ')');
2552 when PC_NotAny_CH =>
2553 Append (Result, "NotAny ('" & E.Char & "')");
2555 when PC_NotAny_CS =>
2556 Append (Result, "NotAny (" & Image (To_Sequence (E.CS)) & ')');
2558 when PC_NotAny_VF =>
2559 Append (Result, "NotAny (" & Str_VF (E.VF) & ')');
2561 when PC_NotAny_VP =>
2562 Append (Result, "NotAny (" & Str_VP (E.VP) & ')');
2565 Append (Result, "NSpan ('" & E.Char & "')");
2568 Append (Result, "NSpan (" & Image (To_Sequence (E.CS)) & ')');
2571 Append (Result, "NSpan (" & Str_VF (E.VF) & ')');
2574 Append (Result, "NSpan (" & Str_VP (E.VP) & ')');
2577 Append (Result, """""");
2580 Append (Result, "Pos (" & E.Nat & ')');
2583 Append (Result, "Pos (" & Str_NF (E.NF) & ')');
2586 Append (Result, "Pos (" & Str_NP (E.NP) & ')');
2589 Kill_Ampersand := True;
2592 Append (Result, "Rest");
2595 Append (Result, "(+ " & Str_PP (E.PP) & ')');
2597 when PC_Pred_Func =>
2598 Append (Result, "(+ " & Str_BF (E.BF) & ')');
2601 Append (Result, "RPos (" & E.Nat & ')');
2604 Append (Result, "RPos (" & Str_NF (E.NF) & ')');
2607 Append (Result, "RPos (" & Str_NP (E.NP) & ')');
2610 Append (Result, "RTab (" & E.Nat & ')');
2613 Append (Result, "RTab (" & Str_NF (E.NF) & ')');
2616 Append (Result, "RTab (" & Str_NP (E.NP) & ')');
2619 Append (Result, "Setcur (" & Str_NP (E.Var) & ')');
2622 Append (Result, "Span ('" & E.Char & "')");
2625 Append (Result, "Span (" & Image (To_Sequence (E.CS)) & ')');
2628 Append (Result, "Span (" & Str_VF (E.VF) & ')');
2631 Append (Result, "Span (" & Str_VP (E.VP) & ')');
2634 Append (Result, Image (E.Str.all));
2637 Append (Result, Image (E.Str2));
2640 Append (Result, Image (E.Str3));
2643 Append (Result, Image (E.Str4));
2646 Append (Result, Image (E.Str5));
2649 Append (Result, Image (E.Str6));
2651 when PC_String_VF =>
2652 Append (Result, "(+" & Str_VF (E.VF) & ')');
2654 when PC_String_VP =>
2655 Append (Result, "(+" & Str_VP (E.VP) & ')');
2658 Append (Result, "Succeed");
2661 Append (Result, "Tab (" & E.Nat & ')');
2664 Append (Result, "Tab (" & Str_NF (E.NF) & ')');
2667 Append (Result, "Tab (" & Str_NP (E.NP) & ')');
2669 when PC_Write_Imm =>
2670 Append (Result, '(');
2671 Image_Seq (E, Refs (E.Index - 1), True);
2672 Append (Result, " * " & Str_FP (Refs (E.Index - 1).FP));
2673 ER := Refs (E.Index - 1).Pthen;
2675 when PC_Write_OnM =>
2676 Append (Result, '(');
2677 Image_Seq (E.Pthen, Refs (E.Index - 1), True);
2678 Append (Result, " ** " & Str_FP (Refs (E.Index - 1).FP));
2679 ER := Refs (E.Index - 1).Pthen;
2681 -- Other pattern codes should not appear as leading elements
2692 Append (Result, "???");
2703 procedure Image_Seq (E : PE_Ptr; Succ : PE_Ptr; Paren : Boolean) is
2704 Indx : constant Natural := Length (Result);
2706 Mult : Boolean := False;
2709 -- The image of EOP is "" (the null string)
2712 Append (Result, """""");
2714 -- Else generate appropriate concatenation sequence
2719 exit when E1 = Succ;
2723 if Kill_Ampersand then
2724 Kill_Ampersand := False;
2726 Append (Result, " & ");
2731 if Mult and Paren then
2732 Insert (Result, Indx + 1, "(");
2733 Append (Result, ")");
2737 -- Start of processing for Image
2740 Build_Ref_Array (P.P, Refs);
2741 Image_Seq (P.P, EOP, False);
2749 function Is_In (C : Character; Str : String) return Boolean is
2751 for J in Str'Range loop
2764 function Len (Count : Natural) return Pattern is
2766 -- Note, the following is not just an optimization, it is needed
2767 -- to ensure that Arbno (Len (0)) does not generate an infinite
2768 -- matching loop (since PC_Len_Nat is OK_For_Simple_Arbno).
2771 return (AFC with 0, new PE'(PC_Null, 1, EOP));
2774 return (AFC with 0, new PE'(PC_Len_Nat, 1, EOP, Count));
2778 function Len (Count : Natural_Func) return Pattern is
2780 return (AFC with 0, new PE'(PC_Len_NF, 1, EOP, Count));
2783 function Len (Count : access Natural) return Pattern is
2785 return (AFC with 0, new PE'(PC_Len_NP, 1, EOP, Natural_Ptr (Count)));
2792 procedure Logic_Error is
2795 (Program_Error'Identity,
2796 "Internal logic error in GNAT.Spitbol.Patterns");
2805 Pat : Pattern) return Boolean
2813 Get_String (Subject, S, L);
2816 XMatchD (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2818 XMatch (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2826 Pat : Pattern) return Boolean
2828 Start, Stop : Natural;
2829 subtype String1 is String (1 .. Subject'Length);
2833 XMatchD (String1 (Subject), Pat.P, Pat.Stk, Start, Stop);
2835 XMatch (String1 (Subject), Pat.P, Pat.Stk, Start, Stop);
2842 (Subject : VString_Var;
2844 Replace : VString) return Boolean
2852 Get_String (Subject, S, L);
2855 XMatchD (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2857 XMatch (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2863 Get_String (Replace, S, L);
2865 (Subject'Unrestricted_Access.all, Start, Stop, S (1 .. L));
2871 (Subject : VString_Var;
2873 Replace : String) return Boolean
2881 Get_String (Subject, S, L);
2884 XMatchD (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2886 XMatch (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2893 (Subject'Unrestricted_Access.all, Start, Stop, Replace);
2908 Get_String (Subject, S, L);
2911 XMatchD (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2913 XMatch (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2921 Start, Stop : Natural;
2922 subtype String1 is String (1 .. Subject'Length);
2925 XMatchD (String1 (Subject), Pat.P, Pat.Stk, Start, Stop);
2927 XMatch (String1 (Subject), Pat.P, Pat.Stk, Start, Stop);
2932 (Subject : in out VString;
2942 Get_String (Subject, S, L);
2945 XMatchD (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2947 XMatch (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2951 Get_String (Replace, S, L);
2952 Replace_Slice (Subject, Start, Stop, S (1 .. L));
2957 (Subject : in out VString;
2967 Get_String (Subject, S, L);
2970 XMatchD (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2972 XMatch (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
2976 Replace_Slice (Subject, Start, Stop, Replace);
2982 Pat : PString) return Boolean
2984 Pat_Len : constant Natural := Pat'Length;
2989 Get_String (Subject, S, L);
2991 if Anchored_Mode then
2995 return Pat = S (1 .. Pat_Len);
2999 for J in 1 .. L - Pat_Len + 1 loop
3000 if Pat = S (J .. J + (Pat_Len - 1)) then
3011 Pat : PString) return Boolean
3013 Pat_Len : constant Natural := Pat'Length;
3014 Sub_Len : constant Natural := Subject'Length;
3015 SFirst : constant Natural := Subject'First;
3018 if Anchored_Mode then
3019 if Pat_Len > Sub_Len then
3022 return Pat = Subject (SFirst .. SFirst + Pat_Len - 1);
3026 for J in SFirst .. SFirst + Sub_Len - Pat_Len loop
3027 if Pat = Subject (J .. J + (Pat_Len - 1)) then
3037 (Subject : VString_Var;
3039 Replace : VString) return Boolean
3047 Get_String (Subject, S, L);
3050 XMatchD (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3052 XMatch (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3058 Get_String (Replace, S, L);
3060 (Subject'Unrestricted_Access.all, Start, Stop, S (1 .. L));
3066 (Subject : VString_Var;
3068 Replace : String) return Boolean
3076 Get_String (Subject, S, L);
3079 XMatchD (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3081 XMatch (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3088 (Subject'Unrestricted_Access.all, Start, Stop, Replace);
3103 Get_String (Subject, S, L);
3106 XMatchD (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3108 XMatch (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3116 Start, Stop : Natural;
3117 subtype String1 is String (1 .. Subject'Length);
3121 XMatchD (String1 (Subject), S_To_PE (Pat), 0, Start, Stop);
3123 XMatch (String1 (Subject), S_To_PE (Pat), 0, Start, Stop);
3128 (Subject : in out VString;
3138 Get_String (Subject, S, L);
3141 XMatchD (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3143 XMatch (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3147 Get_String (Replace, S, L);
3148 Replace_Slice (Subject, Start, Stop, S (1 .. L));
3153 (Subject : in out VString;
3163 Get_String (Subject, S, L);
3166 XMatchD (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3168 XMatch (S (1 .. L), S_To_PE (Pat), 0, Start, Stop);
3172 Replace_Slice (Subject, Start, Stop, Replace);
3177 (Subject : VString_Var;
3179 Result : Match_Result_Var) return Boolean
3187 Get_String (Subject, S, L);
3190 XMatchD (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
3192 XMatch (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
3196 Result'Unrestricted_Access.all.Var := null;
3200 Result'Unrestricted_Access.all.Var := Subject'Unrestricted_Access;
3201 Result'Unrestricted_Access.all.Start := Start;
3202 Result'Unrestricted_Access.all.Stop := Stop;
3208 (Subject : in out VString;
3210 Result : out Match_Result)
3218 Get_String (Subject, S, L);
3221 XMatchD (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
3223 XMatch (S (1 .. L), Pat.P, Pat.Stk, Start, Stop);
3229 Result.Var := Subject'Unrestricted_Access;
3230 Result.Start := Start;
3231 Result.Stop := Stop;
3239 procedure New_LineD is
3241 if Internal_Debug then
3250 function NotAny (Str : String) return Pattern is
3252 return (AFC with 0, new PE'(PC_NotAny_CS, 1, EOP, To_Set (Str)));
3255 function NotAny (Str : VString) return Pattern is
3257 return NotAny (S (Str));
3260 function NotAny (Str : Character) return Pattern is
3262 return (AFC with 0, new PE'(PC_NotAny_CH, 1, EOP, Str));
3265 function NotAny (Str : Character_Set) return Pattern is
3267 return (AFC with 0, new PE'(PC_NotAny_CS, 1, EOP, Str));
3270 function NotAny (Str : access VString) return Pattern is
3272 return (AFC with 0, new PE'(PC_NotAny_VP, 1, EOP, VString_Ptr (Str)));
3275 function NotAny (Str : VString_Func) return Pattern is
3277 return (AFC with 0, new PE'(PC_NotAny_VF, 1, EOP, Str));
3284 function NSpan (Str : String) return Pattern is
3286 return (AFC with 0, new PE'(PC_NSpan_CS, 1, EOP, To_Set (Str)));
3289 function NSpan (Str : VString) return Pattern is
3291 return NSpan (S (Str));
3294 function NSpan (Str : Character) return Pattern is
3296 return (AFC with 0, new PE'(PC_NSpan_CH, 1, EOP, Str));
3299 function NSpan (Str : Character_Set) return Pattern is
3301 return (AFC with 0, new PE'(PC_NSpan_CS, 1, EOP, Str));
3304 function NSpan (Str : access VString) return Pattern is
3306 return (AFC with 0, new PE'(PC_NSpan_VP, 1, EOP, VString_Ptr (Str)));
3309 function NSpan (Str : VString_Func) return Pattern is
3311 return (AFC with 0, new PE'(PC_NSpan_VF, 1, EOP, Str));
3318 function Pos (Count : Natural) return Pattern is
3320 return (AFC with 0, new PE'(PC_Pos_Nat, 1, EOP, Count));
3323 function Pos (Count : Natural_Func) return Pattern is
3325 return (AFC with 0, new PE'(PC_Pos_NF, 1, EOP, Count));
3328 function Pos (Count : access Natural) return Pattern is
3330 return (AFC with 0, new PE'(PC_Pos_NP, 1, EOP, Natural_Ptr (Count)));
3337 procedure PutD (Str : String) is
3339 if Internal_Debug then
3348 procedure Put_LineD (Str : String) is
3350 if Internal_Debug then
3360 (Result : in out Match_Result;
3367 Get_String (Replace, S, L);
3369 if Result.Var /= null then
3370 Replace_Slice (Result.Var.all, Result.Start, Result.Stop, S (1 .. L));
3379 function Rest return Pattern is
3381 return (AFC with 0, new PE'(PC_Rest, 1, EOP));
3388 function Rpos (Count : Natural) return Pattern is
3390 return (AFC with 0, new PE'(PC_RPos_Nat, 1, EOP, Count));
3393 function Rpos (Count : Natural_Func) return Pattern is
3395 return (AFC with 0, new PE'(PC_RPos_NF, 1, EOP, Count));
3398 function Rpos (Count : access Natural) return Pattern is
3400 return (AFC with 0, new PE'(PC_RPos_NP, 1, EOP, Natural_Ptr (Count)));
3407 function Rtab (Count : Natural) return Pattern is
3409 return (AFC with 0, new PE'(PC_RTab_Nat, 1, EOP, Count));
3412 function Rtab (Count : Natural_Func) return Pattern is
3414 return (AFC with 0, new PE'(PC_RTab_NF, 1, EOP, Count));
3417 function Rtab (Count : access Natural) return Pattern is
3419 return (AFC with 0, new PE'(PC_RTab_NP, 1, EOP, Natural_Ptr (Count)));
3426 function S_To_PE (Str : PString) return PE_Ptr is
3427 Len : constant Natural := Str'Length;
3432 return new PE'(PC_Null, 1, EOP);
3435 return new PE'(PC_Char, 1, EOP, Str (1));
3438 return new PE'(PC_String_2, 1, EOP, Str);
3441 return new PE'(PC_String_3, 1, EOP, Str);
3444 return new PE'(PC_String_4, 1, EOP, Str);
3447 return new PE'(PC_String_5, 1, EOP, Str);
3450 return new PE'(PC_String_6, 1, EOP, Str);
3453 return new PE'(PC_String, 1, EOP, new String'(Str));
3462 -- Note: this procedure is not used by the normal concatenation circuit,
3463 -- since other fixups are required on the left operand in this case, and
3464 -- they might as well be done all together.
3466 procedure Set_Successor (Pat : PE_Ptr; Succ : PE_Ptr) is
3469 Uninitialized_Pattern;
3471 elsif Pat = EOP then
3476 Refs : Ref_Array (1 .. Pat.Index);
3477 -- We build a reference array for L whose N'th element points to
3478 -- the pattern element of L whose original Index value is N.
3483 Build_Ref_Array (Pat, Refs);
3485 for J in Refs'Range loop
3488 if P.Pthen = EOP then
3492 if P.Pcode in PC_Has_Alt and then P.Alt = EOP then
3504 function Setcur (Var : access Natural) return Pattern is
3506 return (AFC with 0, new PE'(PC_Setcur, 1, EOP, Natural_Ptr (Var)));
3513 function Span (Str : String) return Pattern is
3515 return (AFC with 0, new PE'(PC_Span_CS, 1, EOP, To_Set (Str)));
3518 function Span (Str : VString) return Pattern is
3520 return Span (S (Str));
3523 function Span (Str : Character) return Pattern is
3525 return (AFC with 0, new PE'(PC_Span_CH, 1, EOP, Str));
3528 function Span (Str : Character_Set) return Pattern is
3530 return (AFC with 0, new PE'(PC_Span_CS, 1, EOP, Str));
3533 function Span (Str : access VString) return Pattern is
3535 return (AFC with 0, new PE'(PC_Span_VP, 1, EOP, VString_Ptr (Str)));
3538 function Span (Str : VString_Func) return Pattern is
3540 return (AFC with 0, new PE'(PC_Span_VF, 1, EOP, Str));
3547 function Str_BF (A : Boolean_Func) return String is
3548 function To_A is new Unchecked_Conversion (Boolean_Func, Address);
3550 return "BF(" & Image (To_A (A)) & ')';
3557 function Str_FP (A : File_Ptr) return String is
3559 return "FP(" & Image (A.all'Address) & ')';
3566 function Str_NF (A : Natural_Func) return String is
3567 function To_A is new Unchecked_Conversion (Natural_Func, Address);
3569 return "NF(" & Image (To_A (A)) & ')';
3576 function Str_NP (A : Natural_Ptr) return String is
3578 return "NP(" & Image (A.all'Address) & ')';
3585 function Str_PP (A : Pattern_Ptr) return String is
3587 return "PP(" & Image (A.all'Address) & ')';
3594 function Str_VF (A : VString_Func) return String is
3595 function To_A is new Unchecked_Conversion (VString_Func, Address);
3597 return "VF(" & Image (To_A (A)) & ')';
3604 function Str_VP (A : VString_Ptr) return String is
3606 return "VP(" & Image (A.all'Address) & ')';
3613 function Succeed return Pattern is
3615 return (AFC with 1, new PE'(PC_Succeed, 1, EOP));
3622 function Tab (Count : Natural) return Pattern is
3624 return (AFC with 0, new PE'(PC_Tab_Nat, 1, EOP, Count));
3627 function Tab (Count : Natural_Func) return Pattern is
3629 return (AFC with 0, new PE'(PC_Tab_NF, 1, EOP, Count));
3632 function Tab (Count : access Natural) return Pattern is
3634 return (AFC with 0, new PE'(PC_Tab_NP, 1, EOP, Natural_Ptr (Count)));
3637 ---------------------------
3638 -- Uninitialized_Pattern --
3639 ---------------------------
3641 procedure Uninitialized_Pattern is
3644 (Program_Error'Identity,
3645 "uninitialized value of type GNAT.Spitbol.Patterns.Pattern");
3646 end Uninitialized_Pattern;
3656 Start : out Natural;
3660 -- Pointer to current pattern node. Initialized from Pat_P, and then
3661 -- updated as the match proceeds through its constituent elements.
3663 Length : constant Natural := Subject'Length;
3664 -- Length of string (= Subject'Last, since Subject'First is always 1)
3666 Cursor : Integer := 0;
3667 -- If the value is non-negative, then this value is the index showing
3668 -- the current position of the match in the subject string. The next
3669 -- character to be matched is at Subject (Cursor + 1). Note that since
3670 -- our view of the subject string in XMatch always has a lower bound
3671 -- of one, regardless of original bounds, that this definition exactly
3672 -- corresponds to the cursor value as referenced by functions like Pos.
3674 -- If the value is negative, then this is a saved stack pointer,
3675 -- typically a base pointer of an inner or outer region. Cursor
3676 -- temporarily holds such a value when it is popped from the stack
3677 -- by Fail. In all cases, Cursor is reset to a proper non-negative
3678 -- cursor value before the match proceeds (e.g. by propagating the
3679 -- failure and popping a "real" cursor value from the stack.
3681 PE_Unanchored : aliased PE := (PC_Unanchored, 0, Pat_P);
3682 -- Dummy pattern element used in the unanchored case.
3685 -- The pattern matching failure stack for this call to Match
3687 Stack_Ptr : Stack_Range;
3688 -- Current stack pointer. This points to the top element of the stack
3689 -- that is currently in use. At the outer level this is the special
3690 -- entry placed on the stack according to the anchor mode.
3692 Stack_Init : constant Stack_Range := Stack'First + 1;
3693 -- This is the initial value of the Stack_Ptr and Stack_Base. The
3694 -- initial (Stack'First) element of the stack is not used so that
3695 -- when we pop the last element off, Stack_Ptr is still in range.
3697 Stack_Base : Stack_Range;
3698 -- This value is the stack base value, i.e. the stack pointer for the
3699 -- first history stack entry in the current stack region. See separate
3700 -- section on handling of recursive pattern matches.
3702 Assign_OnM : Boolean := False;
3703 -- Set True if assign-on-match or write-on-match operations may be
3704 -- present in the history stack, which must then be scanned on a
3705 -- successful match.
3707 procedure Pop_Region;
3708 pragma Inline (Pop_Region);
3709 -- Used at the end of processing of an inner region. if the inner
3710 -- region left no stack entries, then all trace of it is removed.
3711 -- Otherwise a PC_Restore_Region entry is pushed to ensure proper
3712 -- handling of alternatives in the inner region.
3714 procedure Push (Node : PE_Ptr);
3715 pragma Inline (Push);
3716 -- Make entry in pattern matching stack with current cursor valeu
3718 procedure Push_Region;
3719 pragma Inline (Push_Region);
3720 -- This procedure makes a new region on the history stack. The
3721 -- caller first establishes the special entry on the stack, but
3722 -- does not push the stack pointer. Then this call stacks a
3723 -- PC_Remove_Region node, on top of this entry, using the cursor
3724 -- field of the PC_Remove_Region entry to save the outer level
3725 -- stack base value, and resets the stack base to point to this
3726 -- PC_Remove_Region node.
3732 procedure Pop_Region is
3734 -- If nothing was pushed in the inner region, we can just get
3735 -- rid of it entirely, leaving no traces that it was ever there
3737 if Stack_Ptr = Stack_Base then
3738 Stack_Ptr := Stack_Base - 2;
3739 Stack_Base := Stack (Stack_Ptr + 2).Cursor;
3741 -- If stuff was pushed in the inner region, then we have to
3742 -- push a PC_R_Restore node so that we properly handle possible
3743 -- rematches within the region.
3746 Stack_Ptr := Stack_Ptr + 1;
3747 Stack (Stack_Ptr).Cursor := Stack_Base;
3748 Stack (Stack_Ptr).Node := CP_R_Restore'Access;
3749 Stack_Base := Stack (Stack_Base).Cursor;
3757 procedure Push (Node : PE_Ptr) is
3759 Stack_Ptr := Stack_Ptr + 1;
3760 Stack (Stack_Ptr).Cursor := Cursor;
3761 Stack (Stack_Ptr).Node := Node;
3768 procedure Push_Region is
3770 Stack_Ptr := Stack_Ptr + 2;
3771 Stack (Stack_Ptr).Cursor := Stack_Base;
3772 Stack (Stack_Ptr).Node := CP_R_Remove'Access;
3773 Stack_Base := Stack_Ptr;
3776 -- Start of processing for XMatch
3779 if Pat_P = null then
3780 Uninitialized_Pattern;
3783 -- Check we have enough stack for this pattern. This check deals with
3784 -- every possibility except a match of a recursive pattern, where we
3785 -- make a check at each recursion level.
3787 if Pat_S >= Stack_Size - 1 then
3788 raise Pattern_Stack_Overflow;
3791 -- In anchored mode, the bottom entry on the stack is an abort entry
3793 if Anchored_Mode then
3794 Stack (Stack_Init).Node := CP_Cancel'Access;
3795 Stack (Stack_Init).Cursor := 0;
3797 -- In unanchored more, the bottom entry on the stack references
3798 -- the special pattern element PE_Unanchored, whose Pthen field
3799 -- points to the initial pattern element. The cursor value in this
3800 -- entry is the number of anchor moves so far.
3803 Stack (Stack_Init).Node := PE_Unanchored'Unchecked_Access;
3804 Stack (Stack_Init).Cursor := 0;
3807 Stack_Ptr := Stack_Init;
3808 Stack_Base := Stack_Ptr;
3813 -----------------------------------------
3814 -- Main Pattern Matching State Control --
3815 -----------------------------------------
3817 -- This is a state machine which uses gotos to change state. The
3818 -- initial state is Match, to initiate the matching of the first
3819 -- element, so the goto Match above starts the match. In the
3820 -- following descriptions, we indicate the global values that
3821 -- are relevant for the state transition.
3823 -- Come here if entire match fails
3830 -- Come here if entire match succeeds
3832 -- Cursor current position in subject string
3835 Start := Stack (Stack_Init).Cursor + 1;
3838 -- Scan history stack for deferred assignments or writes
3841 for S in Stack_Init .. Stack_Ptr loop
3842 if Stack (S).Node = CP_Assign'Access then
3844 Inner_Base : constant Stack_Range :=
3845 Stack (S + 1).Cursor;
3846 Special_Entry : constant Stack_Range :=
3848 Node_OnM : constant PE_Ptr :=
3849 Stack (Special_Entry).Node;
3850 Start : constant Natural :=
3851 Stack (Special_Entry).Cursor + 1;
3852 Stop : constant Natural := Stack (S).Cursor;
3855 if Node_OnM.Pcode = PC_Assign_OnM then
3856 Set_String (Node_OnM.VP.all, Subject (Start .. Stop));
3858 elsif Node_OnM.Pcode = PC_Write_OnM then
3859 Put_Line (Node_OnM.FP.all, Subject (Start .. Stop));
3871 -- Come here if attempt to match current element fails
3873 -- Stack_Base current stack base
3874 -- Stack_Ptr current stack pointer
3877 Cursor := Stack (Stack_Ptr).Cursor;
3878 Node := Stack (Stack_Ptr).Node;
3879 Stack_Ptr := Stack_Ptr - 1;
3882 -- Come here if attempt to match current element succeeds
3884 -- Cursor current position in subject string
3885 -- Node pointer to node successfully matched
3886 -- Stack_Base current stack base
3887 -- Stack_Ptr current stack pointer
3892 -- Come here to match the next pattern element
3894 -- Cursor current position in subject string
3895 -- Node pointer to node to be matched
3896 -- Stack_Base current stack base
3897 -- Stack_Ptr current stack pointer
3901 --------------------------------------------------
3902 -- Main Pattern Match Element Matching Routines --
3903 --------------------------------------------------
3905 -- Here is the case statement that processes the current node. The
3906 -- processing for each element does one of five things:
3908 -- goto Succeed to move to the successor
3909 -- goto Match_Succeed if the entire match succeeds
3910 -- goto Match_Fail if the entire match fails
3911 -- goto Fail to signal failure of current match
3913 -- Processing is NOT allowed to fall through
3929 -- Any (one character case)
3933 and then Subject (Cursor + 1) = Node.Char
3935 Cursor := Cursor + 1;
3941 -- Any (character set case)
3945 and then Is_In (Subject (Cursor + 1), Node.CS)
3947 Cursor := Cursor + 1;
3953 -- Any (string function case)
3955 when PC_Any_VF => declare
3956 U : constant VString := Node.VF.all;
3961 Get_String (U, S, L);
3964 and then Is_In (Subject (Cursor + 1), S (1 .. L))
3966 Cursor := Cursor + 1;
3973 -- Any (string pointer case)
3975 when PC_Any_VP => declare
3976 U : constant VString := Node.VP.all;
3981 Get_String (U, S, L);
3984 and then Is_In (Subject (Cursor + 1), S (1 .. L))
3986 Cursor := Cursor + 1;
3993 -- Arb (initial match)
4003 if Cursor < Length then
4004 Cursor := Cursor + 1;
4011 -- Arbno_S (simple Arbno initialize). This is the node that
4012 -- initiates the match of a simple Arbno structure.
4019 -- Arbno_X (Arbno initialize). This is the node that initiates
4020 -- the match of a complex Arbno structure.
4027 -- Arbno_Y (Arbno rematch). This is the node that is executed
4028 -- following successful matching of one instance of a complex
4031 when PC_Arbno_Y => declare
4032 Null_Match : constant Boolean :=
4033 Cursor = Stack (Stack_Base - 1).Cursor;
4038 -- If arbno extension matched null, then immediately fail
4044 -- Here we must do a stack check to make sure enough stack
4045 -- is left. This check will happen once for each instance of
4046 -- the Arbno pattern that is matched. The Nat field of a
4047 -- PC_Arbno pattern contains the maximum stack entries needed
4048 -- for the Arbno with one instance and the successor pattern
4050 if Stack_Ptr + Node.Nat >= Stack'Last then
4051 raise Pattern_Stack_Overflow;
4057 -- Assign. If this node is executed, it means the assign-on-match
4058 -- or write-on-match operation will not happen after all, so we
4059 -- is propagate the failure, removing the PC_Assign node.
4064 -- Assign immediate. This node performs the actual assignment.
4066 when PC_Assign_Imm =>
4069 Subject (Stack (Stack_Base - 1).Cursor + 1 .. Cursor));
4073 -- Assign on match. This node sets up for the eventual assignment
4075 when PC_Assign_OnM =>
4076 Stack (Stack_Base - 1).Node := Node;
4077 Push (CP_Assign'Access);
4085 if Cursor >= Length or else Subject (Cursor + 1) = ')' then
4088 elsif Subject (Cursor + 1) = '(' then
4090 Paren_Count : Natural := 1;
4094 Cursor := Cursor + 1;
4096 if Cursor >= Length then
4099 elsif Subject (Cursor + 1) = '(' then
4100 Paren_Count := Paren_Count + 1;
4102 elsif Subject (Cursor + 1) = ')' then
4103 Paren_Count := Paren_Count - 1;
4104 exit when Paren_Count = 0;
4110 Cursor := Cursor + 1;
4114 -- Break (one character case)
4117 while Cursor < Length loop
4118 if Subject (Cursor + 1) = Node.Char then
4121 Cursor := Cursor + 1;
4127 -- Break (character set case)
4130 while Cursor < Length loop
4131 if Is_In (Subject (Cursor + 1), Node.CS) then
4134 Cursor := Cursor + 1;
4140 -- Break (string function case)
4142 when PC_Break_VF => declare
4143 U : constant VString := Node.VF.all;
4148 Get_String (U, S, L);
4150 while Cursor < Length loop
4151 if Is_In (Subject (Cursor + 1), S (1 .. L)) then
4154 Cursor := Cursor + 1;
4161 -- Break (string pointer case)
4163 when PC_Break_VP => declare
4164 U : constant VString := Node.VP.all;
4169 Get_String (U, S, L);
4171 while Cursor < Length loop
4172 if Is_In (Subject (Cursor + 1), S (1 .. L)) then
4175 Cursor := Cursor + 1;
4182 -- BreakX (one character case)
4184 when PC_BreakX_CH =>
4185 while Cursor < Length loop
4186 if Subject (Cursor + 1) = Node.Char then
4189 Cursor := Cursor + 1;
4195 -- BreakX (character set case)
4197 when PC_BreakX_CS =>
4198 while Cursor < Length loop
4199 if Is_In (Subject (Cursor + 1), Node.CS) then
4202 Cursor := Cursor + 1;
4208 -- BreakX (string function case)
4210 when PC_BreakX_VF => declare
4211 U : constant VString := Node.VF.all;
4216 Get_String (U, S, L);
4218 while Cursor < Length loop
4219 if Is_In (Subject (Cursor + 1), S (1 .. L)) then
4222 Cursor := Cursor + 1;
4229 -- BreakX (string pointer case)
4231 when PC_BreakX_VP => declare
4232 U : constant VString := Node.VP.all;
4237 Get_String (U, S, L);
4239 while Cursor < Length loop
4240 if Is_In (Subject (Cursor + 1), S (1 .. L)) then
4243 Cursor := Cursor + 1;
4250 -- BreakX_X (BreakX extension). See section on "Compound Pattern
4251 -- Structures". This node is the alternative that is stacked to
4252 -- skip past the break character and extend the break.
4255 Cursor := Cursor + 1;
4258 -- Character (one character string)
4262 and then Subject (Cursor + 1) = Node.Char
4264 Cursor := Cursor + 1;
4273 if Stack_Base = Stack_Init then
4276 -- End of recursive inner match. See separate section on
4277 -- handing of recursive pattern matches for details.
4280 Node := Stack (Stack_Base - 1).Node;
4290 -- Fence (built in pattern)
4293 Push (CP_Cancel'Access);
4296 -- Fence function node X. This is the node that gets control
4297 -- after a successful match of the fenced pattern.
4300 Stack_Ptr := Stack_Ptr + 1;
4301 Stack (Stack_Ptr).Cursor := Stack_Base;
4302 Stack (Stack_Ptr).Node := CP_Fence_Y'Access;
4303 Stack_Base := Stack (Stack_Base).Cursor;
4306 -- Fence function node Y. This is the node that gets control on
4307 -- a failure that occurs after the fenced pattern has matched.
4309 -- Note: the Cursor at this stage is actually the inner stack
4310 -- base value. We don't reset this, but we do use it to strip
4311 -- off all the entries made by the fenced pattern.
4314 Stack_Ptr := Cursor - 2;
4317 -- Len (integer case)
4320 if Cursor + Node.Nat > Length then
4323 Cursor := Cursor + Node.Nat;
4327 -- Len (Integer function case)
4329 when PC_Len_NF => declare
4330 N : constant Natural := Node.NF.all;
4333 if Cursor + N > Length then
4336 Cursor := Cursor + N;
4341 -- Len (integer pointer case)
4344 if Cursor + Node.NP.all > Length then
4347 Cursor := Cursor + Node.NP.all;
4351 -- NotAny (one character case)
4353 when PC_NotAny_CH =>
4355 and then Subject (Cursor + 1) /= Node.Char
4357 Cursor := Cursor + 1;
4363 -- NotAny (character set case)
4365 when PC_NotAny_CS =>
4367 and then not Is_In (Subject (Cursor + 1), Node.CS)
4369 Cursor := Cursor + 1;
4375 -- NotAny (string function case)
4377 when PC_NotAny_VF => declare
4378 U : constant VString := Node.VF.all;
4383 Get_String (U, S, L);
4387 not Is_In (Subject (Cursor + 1), S (1 .. L))
4389 Cursor := Cursor + 1;
4396 -- NotAny (string pointer case)
4398 when PC_NotAny_VP => declare
4399 U : constant VString := Node.VP.all;
4404 Get_String (U, S, L);
4408 not Is_In (Subject (Cursor + 1), S (1 .. L))
4410 Cursor := Cursor + 1;
4417 -- NSpan (one character case)
4420 while Cursor < Length
4421 and then Subject (Cursor + 1) = Node.Char
4423 Cursor := Cursor + 1;
4428 -- NSpan (character set case)
4431 while Cursor < Length
4432 and then Is_In (Subject (Cursor + 1), Node.CS)
4434 Cursor := Cursor + 1;
4439 -- NSpan (string function case)
4441 when PC_NSpan_VF => declare
4442 U : constant VString := Node.VF.all;
4447 Get_String (U, S, L);
4449 while Cursor < Length
4450 and then Is_In (Subject (Cursor + 1), S (1 .. L))
4452 Cursor := Cursor + 1;
4458 -- NSpan (string pointer case)
4460 when PC_NSpan_VP => declare
4461 U : constant VString := Node.VP.all;
4466 Get_String (U, S, L);
4468 while Cursor < Length
4469 and then Is_In (Subject (Cursor + 1), S (1 .. L))
4471 Cursor := Cursor + 1;
4482 -- Pos (integer case)
4485 if Cursor = Node.Nat then
4491 -- Pos (Integer function case)
4493 when PC_Pos_NF => declare
4494 N : constant Natural := Node.NF.all;
4504 -- Pos (integer pointer case)
4507 if Cursor = Node.NP.all then
4513 -- Predicate function
4515 when PC_Pred_Func =>
4522 -- Region Enter. Initiate new pattern history stack region
4525 Stack (Stack_Ptr + 1).Cursor := Cursor;
4529 -- Region Remove node. This is the node stacked by an R_Enter.
4530 -- It removes the special format stack entry right underneath, and
4531 -- then restores the outer level stack base and signals failure.
4533 -- Note: the cursor value at this stage is actually the (negative)
4534 -- stack base value for the outer level.
4537 Stack_Base := Cursor;
4538 Stack_Ptr := Stack_Ptr - 1;
4541 -- Region restore node. This is the node stacked at the end of an
4542 -- inner level match. Its function is to restore the inner level
4543 -- region, so that alternatives in this region can be sought.
4545 -- Note: the Cursor at this stage is actually the negative of the
4546 -- inner stack base value, which we use to restore the inner region.
4548 when PC_R_Restore =>
4549 Stack_Base := Cursor;
4558 -- Initiate recursive match (pattern pointer case)
4561 Stack (Stack_Ptr + 1).Node := Node.Pthen;
4564 if Stack_Ptr + Node.PP.all.Stk >= Stack_Size then
4565 raise Pattern_Stack_Overflow;
4567 Node := Node.PP.all.P;
4571 -- RPos (integer case)
4574 if Cursor = (Length - Node.Nat) then
4580 -- RPos (integer function case)
4582 when PC_RPos_NF => declare
4583 N : constant Natural := Node.NF.all;
4586 if Length - Cursor = N then
4593 -- RPos (integer pointer case)
4596 if Cursor = (Length - Node.NP.all) then
4602 -- RTab (integer case)
4605 if Cursor <= (Length - Node.Nat) then
4606 Cursor := Length - Node.Nat;
4612 -- RTab (integer function case)
4614 when PC_RTab_NF => declare
4615 N : constant Natural := Node.NF.all;
4618 if Length - Cursor >= N then
4619 Cursor := Length - N;
4626 -- RTab (integer pointer case)
4629 if Cursor <= (Length - Node.NP.all) then
4630 Cursor := Length - Node.NP.all;
4636 -- Cursor assignment
4639 Node.Var.all := Cursor;
4642 -- Span (one character case)
4644 when PC_Span_CH => declare
4645 P : Natural := Cursor;
4649 and then Subject (P + 1) = Node.Char
4662 -- Span (character set case)
4664 when PC_Span_CS => declare
4665 P : Natural := Cursor;
4669 and then Is_In (Subject (P + 1), Node.CS)
4682 -- Span (string function case)
4684 when PC_Span_VF => declare
4685 U : constant VString := Node.VF.all;
4691 Get_String (U, S, L);
4695 and then Is_In (Subject (P + 1), S (1 .. L))
4708 -- Span (string pointer case)
4710 when PC_Span_VP => declare
4711 U : constant VString := Node.VP.all;
4717 Get_String (U, S, L);
4721 and then Is_In (Subject (P + 1), S (1 .. L))
4734 -- String (two character case)
4737 if (Length - Cursor) >= 2
4738 and then Subject (Cursor + 1 .. Cursor + 2) = Node.Str2
4740 Cursor := Cursor + 2;
4746 -- String (three character case)
4749 if (Length - Cursor) >= 3
4750 and then Subject (Cursor + 1 .. Cursor + 3) = Node.Str3
4752 Cursor := Cursor + 3;
4758 -- String (four character case)
4761 if (Length - Cursor) >= 4
4762 and then Subject (Cursor + 1 .. Cursor + 4) = Node.Str4
4764 Cursor := Cursor + 4;
4770 -- String (five character case)
4773 if (Length - Cursor) >= 5
4774 and then Subject (Cursor + 1 .. Cursor + 5) = Node.Str5
4776 Cursor := Cursor + 5;
4782 -- String (six character case)
4785 if (Length - Cursor) >= 6
4786 and then Subject (Cursor + 1 .. Cursor + 6) = Node.Str6
4788 Cursor := Cursor + 6;
4794 -- String (case of more than six characters)
4796 when PC_String => declare
4797 Len : constant Natural := Node.Str'Length;
4800 if (Length - Cursor) >= Len
4801 and then Node.Str.all = Subject (Cursor + 1 .. Cursor + Len)
4803 Cursor := Cursor + Len;
4810 -- String (function case)
4812 when PC_String_VF => declare
4813 U : constant VString := Node.VF.all;
4818 Get_String (U, S, L);
4820 if (Length - Cursor) >= L
4821 and then S (1 .. L) = Subject (Cursor + 1 .. Cursor + L)
4823 Cursor := Cursor + L;
4830 -- String (pointer case)
4832 when PC_String_VP => declare
4833 U : constant VString := Node.VP.all;
4838 Get_String (U, S, L);
4840 if (Length - Cursor) >= L
4841 and then S (1 .. L) = Subject (Cursor + 1 .. Cursor + L)
4843 Cursor := Cursor + L;
4856 -- Tab (integer case)
4859 if Cursor <= Node.Nat then
4866 -- Tab (integer function case)
4868 when PC_Tab_NF => declare
4869 N : constant Natural := Node.NF.all;
4880 -- Tab (integer pointer case)
4883 if Cursor <= Node.NP.all then
4884 Cursor := Node.NP.all;
4890 -- Unanchored movement
4892 when PC_Unanchored =>
4894 -- All done if we tried every position
4896 if Cursor > Length then
4899 -- Otherwise extend the anchor point, and restack ourself
4902 Cursor := Cursor + 1;
4907 -- Write immediate. This node performs the actual write
4909 when PC_Write_Imm =>
4912 Subject (Stack (Stack_Base - 1).Cursor + 1 .. Cursor));
4916 -- Write on match. This node sets up for the eventual write
4918 when PC_Write_OnM =>
4919 Stack (Stack_Base - 1).Node := Node;
4920 Push (CP_Assign'Access);
4927 -- We are NOT allowed to fall though this case statement, since every
4928 -- match routine must end by executing a goto to the appropriate point
4929 -- in the finite state machine model.
4931 pragma Warnings (Off);
4933 pragma Warnings (On);
4940 -- Maintenance note: There is a LOT of code duplication between XMatch
4941 -- and XMatchD. This is quite intentional, the point is to avoid any
4942 -- unnecessary debugging overhead in the XMatch case, but this does mean
4943 -- that any changes to XMatchD must be mirrored in XMatch. In case of
4944 -- any major changes, the proper approach is to delete XMatch, make the
4945 -- changes to XMatchD, and then make a copy of XMatchD, removing all
4946 -- calls to Dout, and all Put and Put_Line operations. This copy becomes
4953 Start : out Natural;
4957 -- Pointer to current pattern node. Initialized from Pat_P, and then
4958 -- updated as the match proceeds through its constituent elements.
4960 Length : constant Natural := Subject'Length;
4961 -- Length of string (= Subject'Last, since Subject'First is always 1)
4963 Cursor : Integer := 0;
4964 -- If the value is non-negative, then this value is the index showing
4965 -- the current position of the match in the subject string. The next
4966 -- character to be matched is at Subject (Cursor + 1). Note that since
4967 -- our view of the subject string in XMatch always has a lower bound
4968 -- of one, regardless of original bounds, that this definition exactly
4969 -- corresponds to the cursor value as referenced by functions like Pos.
4971 -- If the value is negative, then this is a saved stack pointer,
4972 -- typically a base pointer of an inner or outer region. Cursor
4973 -- temporarily holds such a value when it is popped from the stack
4974 -- by Fail. In all cases, Cursor is reset to a proper non-negative
4975 -- cursor value before the match proceeds (e.g. by propagating the
4976 -- failure and popping a "real" cursor value from the stack.
4978 PE_Unanchored : aliased PE := (PC_Unanchored, 0, Pat_P);
4979 -- Dummy pattern element used in the unanchored case.
4981 Region_Level : Natural := 0;
4982 -- Keeps track of recursive region level. This is used only for
4983 -- debugging, it is the number of saved history stack base values.
4986 -- The pattern matching failure stack for this call to Match
4988 Stack_Ptr : Stack_Range;
4989 -- Current stack pointer. This points to the top element of the stack
4990 -- that is currently in use. At the outer level this is the special
4991 -- entry placed on the stack according to the anchor mode.
4993 Stack_Init : constant Stack_Range := Stack'First + 1;
4994 -- This is the initial value of the Stack_Ptr and Stack_Base. The
4995 -- initial (Stack'First) element of the stack is not used so that
4996 -- when we pop the last element off, Stack_Ptr is still in range.
4998 Stack_Base : Stack_Range;
4999 -- This value is the stack base value, i.e. the stack pointer for the
5000 -- first history stack entry in the current stack region. See separate
5001 -- section on handling of recursive pattern matches.
5003 Assign_OnM : Boolean := False;
5004 -- Set True if assign-on-match or write-on-match operations may be
5005 -- present in the history stack, which must then be scanned on a
5006 -- successful match.
5008 procedure Dout (Str : String);
5009 -- Output string to standard error with bars indicating region level.
5011 procedure Dout (Str : String; A : Character);
5012 -- Calls Dout with the string S ('A')
5014 procedure Dout (Str : String; A : Character_Set);
5015 -- Calls Dout with the string S ("A")
5017 procedure Dout (Str : String; A : Natural);
5018 -- Calls Dout with the string S (A)
5020 procedure Dout (Str : String; A : String);
5021 -- Calls Dout with the string S ("A")
5023 function Img (P : PE_Ptr) return String;
5024 -- Returns a string of the form #nnn where nnn is P.Index
5026 procedure Pop_Region;
5027 pragma Inline (Pop_Region);
5028 -- Used at the end of processing of an inner region. if the inner
5029 -- region left no stack entries, then all trace of it is removed.
5030 -- Otherwise a PC_Restore_Region entry is pushed to ensure proper
5031 -- handling of alternatives in the inner region.
5033 procedure Push (Node : PE_Ptr);
5034 pragma Inline (Push);
5035 -- Make entry in pattern matching stack with current cursor valeu
5037 procedure Push_Region;
5038 pragma Inline (Push_Region);
5039 -- This procedure makes a new region on the history stack. The
5040 -- caller first establishes the special entry on the stack, but
5041 -- does not push the stack pointer. Then this call stacks a
5042 -- PC_Remove_Region node, on top of this entry, using the cursor
5043 -- field of the PC_Remove_Region entry to save the outer level
5044 -- stack base value, and resets the stack base to point to this
5045 -- PC_Remove_Region node.
5051 procedure Dout (Str : String) is
5053 for J in 1 .. Region_Level loop
5060 procedure Dout (Str : String; A : Character) is
5062 Dout (Str & " ('" & A & "')");
5065 procedure Dout (Str : String; A : Character_Set) is
5067 Dout (Str & " (" & Image (To_Sequence (A)) & ')');
5070 procedure Dout (Str : String; A : Natural) is
5072 Dout (Str & " (" & A & ')');
5075 procedure Dout (Str : String; A : String) is
5077 Dout (Str & " (" & Image (A) & ')');
5084 function Img (P : PE_Ptr) return String is
5086 return "#" & Integer (P.Index) & " ";
5093 procedure Pop_Region is
5095 Region_Level := Region_Level - 1;
5097 -- If nothing was pushed in the inner region, we can just get
5098 -- rid of it entirely, leaving no traces that it was ever there
5100 if Stack_Ptr = Stack_Base then
5101 Stack_Ptr := Stack_Base - 2;
5102 Stack_Base := Stack (Stack_Ptr + 2).Cursor;
5104 -- If stuff was pushed in the inner region, then we have to
5105 -- push a PC_R_Restore node so that we properly handle possible
5106 -- rematches within the region.
5109 Stack_Ptr := Stack_Ptr + 1;
5110 Stack (Stack_Ptr).Cursor := Stack_Base;
5111 Stack (Stack_Ptr).Node := CP_R_Restore'Access;
5112 Stack_Base := Stack (Stack_Base).Cursor;
5120 procedure Push (Node : PE_Ptr) is
5122 Stack_Ptr := Stack_Ptr + 1;
5123 Stack (Stack_Ptr).Cursor := Cursor;
5124 Stack (Stack_Ptr).Node := Node;
5131 procedure Push_Region is
5133 Region_Level := Region_Level + 1;
5134 Stack_Ptr := Stack_Ptr + 2;
5135 Stack (Stack_Ptr).Cursor := Stack_Base;
5136 Stack (Stack_Ptr).Node := CP_R_Remove'Access;
5137 Stack_Base := Stack_Ptr;
5140 -- Start of processing for XMatchD
5144 Put_Line ("Initiating pattern match, subject = " & Image (Subject));
5145 Put ("--------------------------------------");
5147 for J in 1 .. Length loop
5152 Put_Line ("subject length = " & Length);
5154 if Pat_P = null then
5155 Uninitialized_Pattern;
5158 -- Check we have enough stack for this pattern. This check deals with
5159 -- every possibility except a match of a recursive pattern, where we
5160 -- make a check at each recursion level.
5162 if Pat_S >= Stack_Size - 1 then
5163 raise Pattern_Stack_Overflow;
5166 -- In anchored mode, the bottom entry on the stack is an abort entry
5168 if Anchored_Mode then
5169 Stack (Stack_Init).Node := CP_Cancel'Access;
5170 Stack (Stack_Init).Cursor := 0;
5172 -- In unanchored more, the bottom entry on the stack references
5173 -- the special pattern element PE_Unanchored, whose Pthen field
5174 -- points to the initial pattern element. The cursor value in this
5175 -- entry is the number of anchor moves so far.
5178 Stack (Stack_Init).Node := PE_Unanchored'Unchecked_Access;
5179 Stack (Stack_Init).Cursor := 0;
5182 Stack_Ptr := Stack_Init;
5183 Stack_Base := Stack_Ptr;
5188 -----------------------------------------
5189 -- Main Pattern Matching State Control --
5190 -----------------------------------------
5192 -- This is a state machine which uses gotos to change state. The
5193 -- initial state is Match, to initiate the matching of the first
5194 -- element, so the goto Match above starts the match. In the
5195 -- following descriptions, we indicate the global values that
5196 -- are relevant for the state transition.
5198 -- Come here if entire match fails
5201 Dout ("match fails");
5207 -- Come here if entire match succeeds
5209 -- Cursor current position in subject string
5212 Dout ("match succeeds");
5213 Start := Stack (Stack_Init).Cursor + 1;
5215 Dout ("first matched character index = " & Start);
5216 Dout ("last matched character index = " & Stop);
5217 Dout ("matched substring = " & Image (Subject (Start .. Stop)));
5219 -- Scan history stack for deferred assignments or writes
5222 for S in Stack'First .. Stack_Ptr loop
5223 if Stack (S).Node = CP_Assign'Access then
5225 Inner_Base : constant Stack_Range :=
5226 Stack (S + 1).Cursor;
5227 Special_Entry : constant Stack_Range :=
5229 Node_OnM : constant PE_Ptr :=
5230 Stack (Special_Entry).Node;
5231 Start : constant Natural :=
5232 Stack (Special_Entry).Cursor + 1;
5233 Stop : constant Natural := Stack (S).Cursor;
5236 if Node_OnM.Pcode = PC_Assign_OnM then
5237 Set_String (Node_OnM.VP.all, Subject (Start .. Stop));
5239 (Img (Stack (S).Node) &
5240 "deferred assignment of " &
5241 Image (Subject (Start .. Stop)));
5243 elsif Node_OnM.Pcode = PC_Write_OnM then
5244 Put_Line (Node_OnM.FP.all, Subject (Start .. Stop));
5246 (Img (Stack (S).Node) &
5247 "deferred write of " &
5248 Image (Subject (Start .. Stop)));
5261 -- Come here if attempt to match current element fails
5263 -- Stack_Base current stack base
5264 -- Stack_Ptr current stack pointer
5267 Cursor := Stack (Stack_Ptr).Cursor;
5268 Node := Stack (Stack_Ptr).Node;
5269 Stack_Ptr := Stack_Ptr - 1;
5272 Dout ("failure, cursor reset to " & Cursor);
5277 -- Come here if attempt to match current element succeeds
5279 -- Cursor current position in subject string
5280 -- Node pointer to node successfully matched
5281 -- Stack_Base current stack base
5282 -- Stack_Ptr current stack pointer
5285 Dout ("success, cursor = " & Cursor);
5288 -- Come here to match the next pattern element
5290 -- Cursor current position in subject string
5291 -- Node pointer to node to be matched
5292 -- Stack_Base current stack base
5293 -- Stack_Ptr current stack pointer
5297 --------------------------------------------------
5298 -- Main Pattern Match Element Matching Routines --
5299 --------------------------------------------------
5301 -- Here is the case statement that processes the current node. The
5302 -- processing for each element does one of five things:
5304 -- goto Succeed to move to the successor
5305 -- goto Match_Succeed if the entire match succeeds
5306 -- goto Match_Fail if the entire match fails
5307 -- goto Fail to signal failure of current match
5309 -- Processing is NOT allowed to fall through
5316 Dout (Img (Node) & "matching Cancel");
5323 (Img (Node) & "setting up alternative " & Img (Node.Alt));
5328 -- Any (one character case)
5331 Dout (Img (Node) & "matching Any", Node.Char);
5334 and then Subject (Cursor + 1) = Node.Char
5336 Cursor := Cursor + 1;
5342 -- Any (character set case)
5345 Dout (Img (Node) & "matching Any", Node.CS);
5348 and then Is_In (Subject (Cursor + 1), Node.CS)
5350 Cursor := Cursor + 1;
5356 -- Any (string function case)
5358 when PC_Any_VF => declare
5359 U : constant VString := Node.VF.all;
5364 Get_String (U, S, L);
5366 Dout (Img (Node) & "matching Any", S (1 .. L));
5369 and then Is_In (Subject (Cursor + 1), S (1 .. L))
5371 Cursor := Cursor + 1;
5378 -- Any (string pointer case)
5380 when PC_Any_VP => declare
5381 U : constant VString := Node.VP.all;
5386 Get_String (U, S, L);
5387 Dout (Img (Node) & "matching Any", S (1 .. L));
5390 and then Is_In (Subject (Cursor + 1), S (1 .. L))
5392 Cursor := Cursor + 1;
5399 -- Arb (initial match)
5402 Dout (Img (Node) & "matching Arb");
5410 Dout (Img (Node) & "extending Arb");
5412 if Cursor < Length then
5413 Cursor := Cursor + 1;
5420 -- Arbno_S (simple Arbno initialize). This is the node that
5421 -- initiates the match of a simple Arbno structure.
5425 "setting up Arbno alternative " & Img (Node.Alt));
5430 -- Arbno_X (Arbno initialize). This is the node that initiates
5431 -- the match of a complex Arbno structure.
5435 "setting up Arbno alternative " & Img (Node.Alt));
5440 -- Arbno_Y (Arbno rematch). This is the node that is executed
5441 -- following successful matching of one instance of a complex
5444 when PC_Arbno_Y => declare
5445 Null_Match : constant Boolean :=
5446 Cursor = Stack (Stack_Base - 1).Cursor;
5449 Dout (Img (Node) & "extending Arbno");
5452 -- If arbno extension matched null, then immediately fail
5455 Dout ("Arbno extension matched null, so fails");
5459 -- Here we must do a stack check to make sure enough stack
5460 -- is left. This check will happen once for each instance of
5461 -- the Arbno pattern that is matched. The Nat field of a
5462 -- PC_Arbno pattern contains the maximum stack entries needed
5463 -- for the Arbno with one instance and the successor pattern
5465 if Stack_Ptr + Node.Nat >= Stack'Last then
5466 raise Pattern_Stack_Overflow;
5472 -- Assign. If this node is executed, it means the assign-on-match
5473 -- or write-on-match operation will not happen after all, so we
5474 -- is propagate the failure, removing the PC_Assign node.
5477 Dout (Img (Node) & "deferred assign/write cancelled");
5480 -- Assign immediate. This node performs the actual assignment.
5482 when PC_Assign_Imm =>
5484 (Img (Node) & "executing immediate assignment of " &
5485 Image (Subject (Stack (Stack_Base - 1).Cursor + 1 .. Cursor)));
5488 Subject (Stack (Stack_Base - 1).Cursor + 1 .. Cursor));
5492 -- Assign on match. This node sets up for the eventual assignment
5494 when PC_Assign_OnM =>
5495 Dout (Img (Node) & "registering deferred assignment");
5496 Stack (Stack_Base - 1).Node := Node;
5497 Push (CP_Assign'Access);
5505 Dout (Img (Node) & "matching or extending Bal");
5506 if Cursor >= Length or else Subject (Cursor + 1) = ')' then
5509 elsif Subject (Cursor + 1) = '(' then
5511 Paren_Count : Natural := 1;
5515 Cursor := Cursor + 1;
5517 if Cursor >= Length then
5520 elsif Subject (Cursor + 1) = '(' then
5521 Paren_Count := Paren_Count + 1;
5523 elsif Subject (Cursor + 1) = ')' then
5524 Paren_Count := Paren_Count - 1;
5525 exit when Paren_Count = 0;
5531 Cursor := Cursor + 1;
5535 -- Break (one character case)
5538 Dout (Img (Node) & "matching Break", Node.Char);
5540 while Cursor < Length loop
5541 if Subject (Cursor + 1) = Node.Char then
5544 Cursor := Cursor + 1;
5550 -- Break (character set case)
5553 Dout (Img (Node) & "matching Break", Node.CS);
5555 while Cursor < Length loop
5556 if Is_In (Subject (Cursor + 1), Node.CS) then
5559 Cursor := Cursor + 1;
5565 -- Break (string function case)
5567 when PC_Break_VF => declare
5568 U : constant VString := Node.VF.all;
5573 Get_String (U, S, L);
5574 Dout (Img (Node) & "matching Break", S (1 .. L));
5576 while Cursor < Length loop
5577 if Is_In (Subject (Cursor + 1), S (1 .. L)) then
5580 Cursor := Cursor + 1;
5587 -- Break (string pointer case)
5589 when PC_Break_VP => declare
5590 U : constant VString := Node.VP.all;
5595 Get_String (U, S, L);
5596 Dout (Img (Node) & "matching Break", S (1 .. L));
5598 while Cursor < Length loop
5599 if Is_In (Subject (Cursor + 1), S (1 .. L)) then
5602 Cursor := Cursor + 1;
5609 -- BreakX (one character case)
5611 when PC_BreakX_CH =>
5612 Dout (Img (Node) & "matching BreakX", Node.Char);
5614 while Cursor < Length loop
5615 if Subject (Cursor + 1) = Node.Char then
5618 Cursor := Cursor + 1;
5624 -- BreakX (character set case)
5626 when PC_BreakX_CS =>
5627 Dout (Img (Node) & "matching BreakX", Node.CS);
5629 while Cursor < Length loop
5630 if Is_In (Subject (Cursor + 1), Node.CS) then
5633 Cursor := Cursor + 1;
5639 -- BreakX (string function case)
5641 when PC_BreakX_VF => declare
5642 U : constant VString := Node.VF.all;
5647 Get_String (U, S, L);
5648 Dout (Img (Node) & "matching BreakX", S (1 .. L));
5650 while Cursor < Length loop
5651 if Is_In (Subject (Cursor + 1), S (1 .. L)) then
5654 Cursor := Cursor + 1;
5661 -- BreakX (string pointer case)
5663 when PC_BreakX_VP => declare
5664 U : constant VString := Node.VP.all;
5669 Get_String (U, S, L);
5670 Dout (Img (Node) & "matching BreakX", S (1 .. L));
5672 while Cursor < Length loop
5673 if Is_In (Subject (Cursor + 1), S (1 .. L)) then
5676 Cursor := Cursor + 1;
5683 -- BreakX_X (BreakX extension). See section on "Compound Pattern
5684 -- Structures". This node is the alternative that is stacked
5685 -- to skip past the break character and extend the break.
5688 Dout (Img (Node) & "extending BreakX");
5689 Cursor := Cursor + 1;
5692 -- Character (one character string)
5695 Dout (Img (Node) & "matching '" & Node.Char & ''');
5698 and then Subject (Cursor + 1) = Node.Char
5700 Cursor := Cursor + 1;
5709 if Stack_Base = Stack_Init then
5710 Dout ("end of pattern");
5713 -- End of recursive inner match. See separate section on
5714 -- handing of recursive pattern matches for details.
5717 Dout ("terminating recursive match");
5718 Node := Stack (Stack_Base - 1).Node;
5726 Dout (Img (Node) & "matching Fail");
5729 -- Fence (built in pattern)
5732 Dout (Img (Node) & "matching Fence");
5733 Push (CP_Cancel'Access);
5736 -- Fence function node X. This is the node that gets control
5737 -- after a successful match of the fenced pattern.
5740 Dout (Img (Node) & "matching Fence function");
5741 Stack_Ptr := Stack_Ptr + 1;
5742 Stack (Stack_Ptr).Cursor := Stack_Base;
5743 Stack (Stack_Ptr).Node := CP_Fence_Y'Access;
5744 Stack_Base := Stack (Stack_Base).Cursor;
5745 Region_Level := Region_Level - 1;
5748 -- Fence function node Y. This is the node that gets control on
5749 -- a failure that occurs after the fenced pattern has matched.
5751 -- Note: the Cursor at this stage is actually the inner stack
5752 -- base value. We don't reset this, but we do use it to strip
5753 -- off all the entries made by the fenced pattern.
5756 Dout (Img (Node) & "pattern matched by Fence caused failure");
5757 Stack_Ptr := Cursor - 2;
5760 -- Len (integer case)
5763 Dout (Img (Node) & "matching Len", Node.Nat);
5765 if Cursor + Node.Nat > Length then
5768 Cursor := Cursor + Node.Nat;
5772 -- Len (Integer function case)
5774 when PC_Len_NF => declare
5775 N : constant Natural := Node.NF.all;
5778 Dout (Img (Node) & "matching Len", N);
5780 if Cursor + N > Length then
5783 Cursor := Cursor + N;
5788 -- Len (integer pointer case)
5791 Dout (Img (Node) & "matching Len", Node.NP.all);
5793 if Cursor + Node.NP.all > Length then
5796 Cursor := Cursor + Node.NP.all;
5800 -- NotAny (one character case)
5802 when PC_NotAny_CH =>
5803 Dout (Img (Node) & "matching NotAny", Node.Char);
5806 and then Subject (Cursor + 1) /= Node.Char
5808 Cursor := Cursor + 1;
5814 -- NotAny (character set case)
5816 when PC_NotAny_CS =>
5817 Dout (Img (Node) & "matching NotAny", Node.CS);
5820 and then not Is_In (Subject (Cursor + 1), Node.CS)
5822 Cursor := Cursor + 1;
5828 -- NotAny (string function case)
5830 when PC_NotAny_VF => declare
5831 U : constant VString := Node.VF.all;
5836 Get_String (U, S, L);
5837 Dout (Img (Node) & "matching NotAny", S (1 .. L));
5841 not Is_In (Subject (Cursor + 1), S (1 .. L))
5843 Cursor := Cursor + 1;
5850 -- NotAny (string pointer case)
5852 when PC_NotAny_VP => declare
5853 U : constant VString := Node.VP.all;
5858 Get_String (U, S, L);
5859 Dout (Img (Node) & "matching NotAny", S (1 .. L));
5863 not Is_In (Subject (Cursor + 1), S (1 .. L))
5865 Cursor := Cursor + 1;
5872 -- NSpan (one character case)
5875 Dout (Img (Node) & "matching NSpan", Node.Char);
5877 while Cursor < Length
5878 and then Subject (Cursor + 1) = Node.Char
5880 Cursor := Cursor + 1;
5885 -- NSpan (character set case)
5888 Dout (Img (Node) & "matching NSpan", Node.CS);
5890 while Cursor < Length
5891 and then Is_In (Subject (Cursor + 1), Node.CS)
5893 Cursor := Cursor + 1;
5898 -- NSpan (string function case)
5900 when PC_NSpan_VF => declare
5901 U : constant VString := Node.VF.all;
5906 Get_String (U, S, L);
5907 Dout (Img (Node) & "matching NSpan", S (1 .. L));
5909 while Cursor < Length
5910 and then Is_In (Subject (Cursor + 1), S (1 .. L))
5912 Cursor := Cursor + 1;
5918 -- NSpan (string pointer case)
5920 when PC_NSpan_VP => declare
5921 U : constant VString := Node.VP.all;
5926 Get_String (U, S, L);
5927 Dout (Img (Node) & "matching NSpan", S (1 .. L));
5929 while Cursor < Length
5930 and then Is_In (Subject (Cursor + 1), S (1 .. L))
5932 Cursor := Cursor + 1;
5939 Dout (Img (Node) & "matching null");
5942 -- Pos (integer case)
5945 Dout (Img (Node) & "matching Pos", Node.Nat);
5947 if Cursor = Node.Nat then
5953 -- Pos (Integer function case)
5955 when PC_Pos_NF => declare
5956 N : constant Natural := Node.NF.all;
5959 Dout (Img (Node) & "matching Pos", N);
5968 -- Pos (integer pointer case)
5971 Dout (Img (Node) & "matching Pos", Node.NP.all);
5973 if Cursor = Node.NP.all then
5979 -- Predicate function
5981 when PC_Pred_Func =>
5982 Dout (Img (Node) & "matching predicate function");
5990 -- Region Enter. Initiate new pattern history stack region
5993 Dout (Img (Node) & "starting match of nested pattern");
5994 Stack (Stack_Ptr + 1).Cursor := Cursor;
5998 -- Region Remove node. This is the node stacked by an R_Enter.
5999 -- It removes the special format stack entry right underneath, and
6000 -- then restores the outer level stack base and signals failure.
6002 -- Note: the cursor value at this stage is actually the (negative)
6003 -- stack base value for the outer level.
6006 Dout ("failure, match of nested pattern terminated");
6007 Stack_Base := Cursor;
6008 Region_Level := Region_Level - 1;
6009 Stack_Ptr := Stack_Ptr - 1;
6012 -- Region restore node. This is the node stacked at the end of an
6013 -- inner level match. Its function is to restore the inner level
6014 -- region, so that alternatives in this region can be sought.
6016 -- Note: the Cursor at this stage is actually the negative of the
6017 -- inner stack base value, which we use to restore the inner region.
6019 when PC_R_Restore =>
6020 Dout ("failure, search for alternatives in nested pattern");
6021 Region_Level := Region_Level + 1;
6022 Stack_Base := Cursor;
6028 Dout (Img (Node) & "matching Rest");
6032 -- Initiate recursive match (pattern pointer case)
6035 Stack (Stack_Ptr + 1).Node := Node.Pthen;
6037 Dout (Img (Node) & "initiating recursive match");
6039 if Stack_Ptr + Node.PP.all.Stk >= Stack_Size then
6040 raise Pattern_Stack_Overflow;
6042 Node := Node.PP.all.P;
6046 -- RPos (integer case)
6049 Dout (Img (Node) & "matching RPos", Node.Nat);
6051 if Cursor = (Length - Node.Nat) then
6057 -- RPos (integer function case)
6059 when PC_RPos_NF => declare
6060 N : constant Natural := Node.NF.all;
6063 Dout (Img (Node) & "matching RPos", N);
6065 if Length - Cursor = N then
6072 -- RPos (integer pointer case)
6075 Dout (Img (Node) & "matching RPos", Node.NP.all);
6077 if Cursor = (Length - Node.NP.all) then
6083 -- RTab (integer case)
6086 Dout (Img (Node) & "matching RTab", Node.Nat);
6088 if Cursor <= (Length - Node.Nat) then
6089 Cursor := Length - Node.Nat;
6095 -- RTab (integer function case)
6097 when PC_RTab_NF => declare
6098 N : constant Natural := Node.NF.all;
6101 Dout (Img (Node) & "matching RPos", N);
6103 if Length - Cursor >= N then
6104 Cursor := Length - N;
6111 -- RTab (integer pointer case)
6114 Dout (Img (Node) & "matching RPos", Node.NP.all);
6116 if Cursor <= (Length - Node.NP.all) then
6117 Cursor := Length - Node.NP.all;
6123 -- Cursor assignment
6126 Dout (Img (Node) & "matching Setcur");
6127 Node.Var.all := Cursor;
6130 -- Span (one character case)
6132 when PC_Span_CH => declare
6133 P : Natural := Cursor;
6136 Dout (Img (Node) & "matching Span", Node.Char);
6139 and then Subject (P + 1) = Node.Char
6152 -- Span (character set case)
6154 when PC_Span_CS => declare
6155 P : Natural := Cursor;
6158 Dout (Img (Node) & "matching Span", Node.CS);
6161 and then Is_In (Subject (P + 1), Node.CS)
6174 -- Span (string function case)
6176 when PC_Span_VF => declare
6177 U : constant VString := Node.VF.all;
6183 Get_String (U, S, L);
6184 Dout (Img (Node) & "matching Span", S (1 .. L));
6188 and then Is_In (Subject (P + 1), S (1 .. L))
6201 -- Span (string pointer case)
6203 when PC_Span_VP => declare
6204 U : constant VString := Node.VP.all;
6210 Get_String (U, S, L);
6211 Dout (Img (Node) & "matching Span", S (1 .. L));
6215 and then Is_In (Subject (P + 1), S (1 .. L))
6228 -- String (two character case)
6231 Dout (Img (Node) & "matching " & Image (Node.Str2));
6233 if (Length - Cursor) >= 2
6234 and then Subject (Cursor + 1 .. Cursor + 2) = Node.Str2
6236 Cursor := Cursor + 2;
6242 -- String (three character case)
6245 Dout (Img (Node) & "matching " & Image (Node.Str3));
6247 if (Length - Cursor) >= 3
6248 and then Subject (Cursor + 1 .. Cursor + 3) = Node.Str3
6250 Cursor := Cursor + 3;
6256 -- String (four character case)
6259 Dout (Img (Node) & "matching " & Image (Node.Str4));
6261 if (Length - Cursor) >= 4
6262 and then Subject (Cursor + 1 .. Cursor + 4) = Node.Str4
6264 Cursor := Cursor + 4;
6270 -- String (five character case)
6273 Dout (Img (Node) & "matching " & Image (Node.Str5));
6275 if (Length - Cursor) >= 5
6276 and then Subject (Cursor + 1 .. Cursor + 5) = Node.Str5
6278 Cursor := Cursor + 5;
6284 -- String (six character case)
6287 Dout (Img (Node) & "matching " & Image (Node.Str6));
6289 if (Length - Cursor) >= 6
6290 and then Subject (Cursor + 1 .. Cursor + 6) = Node.Str6
6292 Cursor := Cursor + 6;
6298 -- String (case of more than six characters)
6300 when PC_String => declare
6301 Len : constant Natural := Node.Str'Length;
6304 Dout (Img (Node) & "matching " & Image (Node.Str.all));
6306 if (Length - Cursor) >= Len
6307 and then Node.Str.all = Subject (Cursor + 1 .. Cursor + Len)
6309 Cursor := Cursor + Len;
6316 -- String (function case)
6318 when PC_String_VF => declare
6319 U : constant VString := Node.VF.all;
6324 Get_String (U, S, L);
6325 Dout (Img (Node) & "matching " & Image (S (1 .. L)));
6327 if (Length - Cursor) >= L
6328 and then S (1 .. L) = Subject (Cursor + 1 .. Cursor + L)
6330 Cursor := Cursor + L;
6337 -- String (vstring pointer case)
6339 when PC_String_VP => declare
6340 U : constant VString := Node.VP.all;
6345 Get_String (U, S, L);
6346 Dout (Img (Node) & "matching " & Image (S (1 .. L)));
6348 if (Length - Cursor) >= L
6349 and then S (1 .. L) = Subject (Cursor + 1 .. Cursor + L)
6351 Cursor := Cursor + L;
6361 Dout (Img (Node) & "matching Succeed");
6365 -- Tab (integer case)
6368 Dout (Img (Node) & "matching Tab", Node.Nat);
6370 if Cursor <= Node.Nat then
6377 -- Tab (integer function case)
6379 when PC_Tab_NF => declare
6380 N : constant Natural := Node.NF.all;
6383 Dout (Img (Node) & "matching Tab ", N);
6393 -- Tab (integer pointer case)
6396 Dout (Img (Node) & "matching Tab ", Node.NP.all);
6398 if Cursor <= Node.NP.all then
6399 Cursor := Node.NP.all;
6405 -- Unanchored movement
6407 when PC_Unanchored =>
6408 Dout ("attempting to move anchor point");
6410 -- All done if we tried every position
6412 if Cursor > Length then
6415 -- Otherwise extend the anchor point, and restack ourself
6418 Cursor := Cursor + 1;
6423 -- Write immediate. This node performs the actual write
6425 when PC_Write_Imm =>
6426 Dout (Img (Node) & "executing immediate write of " &
6427 Subject (Stack (Stack_Base - 1).Cursor + 1 .. Cursor));
6431 Subject (Stack (Stack_Base - 1).Cursor + 1 .. Cursor));
6435 -- Write on match. This node sets up for the eventual write
6437 when PC_Write_OnM =>
6438 Dout (Img (Node) & "registering deferred write");
6439 Stack (Stack_Base - 1).Node := Node;
6440 Push (CP_Assign'Access);
6447 -- We are NOT allowed to fall though this case statement, since every
6448 -- match routine must end by executing a goto to the appropriate point
6449 -- in the finite state machine model.
6451 pragma Warnings (Off);
6453 pragma Warnings (On);
6456 end GNAT.Spitbol.Patterns;