1 /*
2  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.  Oracle designates this
8  * particular file as subject to the "Classpath" exception as provided
9  * by Oracle in the LICENSE file that accompanied this code.
10  *
11  * This code is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14  * version 2 for more details (a copy is included in the LICENSE file that
15  * accompanied this code).
16  *
17  * You should have received a copy of the GNU General Public License version
18  * 2 along with this work; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20  *
21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22  * or visit www.oracle.com if you need additional information or have any
23  * questions.
24  */
25 
26 package java.util.regex;
27 
28 import java.util.HashMap;
29 import java.util.regex.Pattern.CharPredicate;
30 import static java.util.regex.ASCII.*;
31 
32 /**
33  * A utility class to print out the pattern node tree.
34  */
35 
36 class PrintPattern {
37 
38     private static HashMap<Pattern.Node, Integer> ids = new HashMap<>();
39 
print(Pattern.Node node, String text, int depth)40     private static void print(Pattern.Node node, String text, int depth) {
41         if (!ids.containsKey(node))
42             ids.put(node, ids.size());
43         print("%6d:%" + (depth==0? "": depth<<1) + "s<%s>", ids.get(node), "", text);
44         if (ids.containsKey(node.next))
45             print(" (=>%d)", ids.get(node.next));
46         print("%n");
47     }
48 
print(String s, int depth)49     private static void print(String s, int depth) {
50         print("       %" + (depth==0?"":depth<<1) + "s<%s>%n", "", s);
51     }
52 
print(String fmt, Object ... args)53     private static void print(String fmt, Object ... args) {
54         System.err.printf(fmt, args);
55     }
56 
toStringCPS(int[] cps)57     private static String toStringCPS(int[] cps) {
58         StringBuilder sb = new StringBuilder(cps.length);
59         for (int cp : cps)
60             sb.append(toStringCP(cp));
61         return sb.toString();
62     }
63 
toStringCP(int cp)64     private static String toStringCP(int cp) {
65         return (isPrint(cp) ? "" + (char)cp
66                             : "\\u" + Integer.toString(cp, 16));
67     }
68 
toStringRange(int min, int max)69     private static String toStringRange(int min, int max) {
70        if (max == Pattern.MAX_REPS) {
71            if (min == 0)
72                return " * ";
73            else if (min == 1)
74                return " + ";
75            return "{" + min + ", max}";
76        }
77        return "{" + min + ", " +  max + "}";
78     }
79 
toStringCtype(int type)80     private static String toStringCtype(int type) {
81         switch(type) {
82         case UPPER:  return "ASCII.UPPER";
83         case LOWER:  return "ASCII.LOWER";
84         case DIGIT:  return "ASCII.DIGIT";
85         case SPACE:  return "ASCII.SPACE";
86         case PUNCT:  return "ASCII.PUNCT";
87         case CNTRL:  return "ASCII.CNTRL";
88         case BLANK:  return "ASCII.BLANK";
89         case UNDER:  return "ASCII.UNDER";
90         case ASCII:  return "ASCII.ASCII";
91         case ALPHA:  return "ASCII.ALPHA";
92         case ALNUM:  return "ASCII.ALNUM";
93         case GRAPH:  return "ASCII.GRAPH";
94         case WORD:   return "ASCII.WORD";
95         case XDIGIT: return "ASCII.XDIGIT";
96         default: return "ASCII ?";
97         }
98     }
99 
toString(Pattern.Node node)100     private static String toString(Pattern.Node node) {
101         String name = node.getClass().getName();
102         return name.substring(name.lastIndexOf('$') + 1);
103     }
104 
105     static HashMap<CharPredicate, String> pmap;
106     static {
107         pmap = new HashMap<>();
Pattern.ALL()108         pmap.put(Pattern.ALL(), "All");
Pattern.DOT()109         pmap.put(Pattern.DOT(), "Dot");
Pattern.UNIXDOT()110         pmap.put(Pattern.UNIXDOT(), "UnixDot");
Pattern.VertWS()111         pmap.put(Pattern.VertWS(), "VertWS");
Pattern.HorizWS()112         pmap.put(Pattern.HorizWS(), "HorizWS");
113 
CharPredicates.ASCII_DIGIT()114         pmap.put(CharPredicates.ASCII_DIGIT(), "ASCII.DIGIT");
CharPredicates.ASCII_WORD()115         pmap.put(CharPredicates.ASCII_WORD(),  "ASCII.WORD");
CharPredicates.ASCII_SPACE()116         pmap.put(CharPredicates.ASCII_SPACE(), "ASCII.SPACE");
117     }
118 
walk(Pattern.Node node, int depth)119     static void walk(Pattern.Node node, int depth) {
120         depth++;
121         while(node != null) {
122             String name = toString(node);
123             String str;
124             if (node instanceof Pattern.Prolog) {
125                 print(node, name, depth);
126                 // print the loop here
127                 Pattern.Loop loop = ((Pattern.Prolog)node).loop;
128                 name = toString(loop);
129                 str = name + " " + toStringRange(loop.cmin, loop.cmax);
130                 print(loop, str, depth);
131                 walk(loop.body, depth);
132                 print("/" + name, depth);
133                 node = loop;
134             } else if (node instanceof Pattern.Loop) {
135                 return;  // stop here, body.next -> loop
136             } else if (node instanceof Pattern.Curly) {
137                 Pattern.Curly c = (Pattern.Curly)node;
138                 str = "Curly " + c.type + " " + toStringRange(c.cmin, c.cmax);
139                 print(node, str, depth);
140                 walk(c.atom, depth);
141                 print("/Curly", depth);
142             } else if (node instanceof Pattern.GroupCurly) {
143                 Pattern.GroupCurly gc = (Pattern.GroupCurly)node;
144                 str = "GroupCurly " + gc.groupIndex / 2 +
145                       ", " + gc.type + " " + toStringRange(gc.cmin, gc.cmax);
146                 print(node, str, depth);
147                 walk(gc.atom, depth);
148                 print("/GroupCurly", depth);
149             } else if (node instanceof Pattern.GroupHead) {
150                 Pattern.GroupHead head = (Pattern.GroupHead)node;
151                 Pattern.GroupTail tail = head.tail;
152                 print(head, "Group.head " + (tail.groupIndex / 2), depth);
153                 walk(head.next, depth);
154                 print(tail, "/Group.tail " + (tail.groupIndex / 2), depth);
155                 node = tail;
156             } else if (node instanceof Pattern.GroupTail) {
157                 return;  // stopper
158             } else if (node instanceof Pattern.Ques) {
159                 print(node, "Ques " + ((Pattern.Ques)node).type, depth);
160                 walk(((Pattern.Ques)node).atom, depth);
161                 print("/Ques", depth);
162             } else if (node instanceof Pattern.Branch) {
163                 Pattern.Branch b = (Pattern.Branch)node;
164                 print(b, name, depth);
165                 int i = 0;
166                 while (true) {
167                     if (b.atoms[i] != null) {
168                         walk(b.atoms[i], depth);
169                     } else {
170                         print("  (accepted)", depth);
171                     }
172                     if (++i == b.size)
173                         break;
174                     print("-branch.separator-", depth);
175                 }
176                 node = b.conn;
177                 print(node, "/Branch", depth);
178             } else if (node instanceof Pattern.BranchConn) {
179                 return;
180             } else if (node instanceof Pattern.CharProperty) {
181                 str = pmap.get(((Pattern.CharProperty)node).predicate);
182                 if (str == null)
183                     str = toString(node);
184                 else
185                     str = "Single \"" + str + "\"";
186                 print(node, str, depth);
187             } else if (node instanceof Pattern.SliceNode) {
188                 str = name + "  \"" +
189                       toStringCPS(((Pattern.SliceNode)node).buffer) + "\"";
190                 print(node, str, depth);
191             } else if (node instanceof Pattern.CharPropertyGreedy) {
192                 Pattern.CharPropertyGreedy gcp = (Pattern.CharPropertyGreedy)node;
193                 String pstr = pmap.get(gcp.predicate);
194                 if (pstr == null)
195                     pstr = gcp.predicate.toString();
196                 else
197                     pstr = "Single \"" + pstr + "\"";
198                 str = name + " " + pstr + ((gcp.cmin == 0) ? "*" : "+");
199                 print(node, str, depth);
200             } else if (node instanceof Pattern.BackRef) {
201                 str = "GroupBackRef " + ((Pattern.BackRef)node).groupIndex / 2;
202                 print(node, str, depth);
203             } else if (node instanceof Pattern.LastNode) {
204                 print(node, "END", depth);
205             } else if (node == Pattern.accept) {
206                 return;
207             } else {
208                 print(node, name, depth);
209             }
210             node = node.next;
211         }
212     }
213 
main(String[] args)214     public static void main(String[] args) {
215         Pattern p = Pattern.compile(args[0]);
216         System.out.println("   Pattern: " + p);
217         walk(p.root, 0);
218     }
219 }
220