Regexp/Visualize/Simple.pm

package Regexp::Visualize::Simple;
use strict;
use warnings;

use Graph::Easy;

use Scalar::Util qw/refaddr/;

my $default_map = {};
for (qw/. \C \w \W \s \S \d \D \X \1 \2 \3 \4 \5 \6 \7 \8 \9
        \A ^ \B \b \G \Z \z $/) {
  $default_map->{$_} = qq[Perl /$_/];
}

my $assertion_map = {
    ifmatch => '(?=)',
    '<ifmatch' => '(?<=)',
    unlessm => '(?!)',
    '<unlessm' => '(?<!)',
};

sub new ($) {
  my $self = bless {}, shift;
  $self->{next_index} = 0;
  $self->{regexp_nodes} = [];
  return $self;
} # new

sub _escape_value ($) {
  my $v = shift;
  $v =~ s/(\W)/sprintf '\x{%04X}', ord $1/ge;
  $v;
} # _escape_value

sub _escape_code ($) {
  my $v = shift;
  $v =~ s/([^\x20-\x5B\x5D-\x7E])/sprintf '\x{%04X}', ord $1/ge;
  $v;
} # _escape_code

sub push_regexp_node ($$) {
  my $self = shift;
  my $nodes = shift; # Regexp::Parser's node or array ref of nodes
  push @{$self->{regexp}}, $nodes;
  return $self->get_graph_index ($nodes);
} # push_regexp_node

sub shift_regexp_node ($) {
  my $self = shift;
  return shift @{$self->{regexp}};
} # shift_regexp_node

sub has_regexp_node ($) {
  my $self = shift;
  return scalar @{$self->{regexp}};
} # has_regexp_node

sub get_graph_index ($$) {
  my $self = shift;
  my $nodes = shift;
  $self->{index}->{$nodes} //= $self->{next_index}++;
  return $self->{index}->{$nodes};
} # get_graph_index

sub next_graph ($) {
  my $self = shift;
  my $root_nodes = $self->shift_regexp_node;
  return (undef, undef) unless $root_nodes;

  my $g = Graph::Easy->new;

  $g->set_attributes ('node.start' => {fill => 'blue', color => 'white'});
  $g->set_attributes ('node.success' => {fill => 'green', color => 'white'});
  $g->set_attributes ('node.fail' => {fill => 'red', color => 'white'});
  $g->set_attributes ('edge.fail' => {color => 'gray'});
  
  my $start_n = $g->add_node ('START');
  $start_n->set_attribute (class => 'start');
  my $success_n = $g->add_node ('SUCCESS');
  $success_n->set_attribute (class => 'success');
  my $fail_n = $g->add_node ('FAIL');
  $fail_n->set_attribute (class => 'fail');

  my ($first_ns, $last_ns, $is_optional)
      = $self->_add_to_graph ($root_nodes => $g);
  $g->add_edge ($start_n => $_) for @$first_ns;
  $g->add_edge ($_ => $success_n) for @$last_ns;
  $g->add_edge ($start_n => $success_n) if $is_optional;

  $g->del_node ($success_n) unless $success_n->incoming;
  $g->del_node ($fail_n) unless $fail_n->incoming;
  $_->set_attribute ('class' => 'fail') for $fail_n->outgoing;
  
  return ($g, $self->get_graph_index ($root_nodes));
} # next_graph

sub _add_to_graph ($$$) {
  my ($self, $node, $g) = @_;

  my $family = ref $node eq 'ARRAY' ? '' : $node->family;
  my $type = ref $node eq 'ARRAY' ? '' : $node->type;
  if ($family eq 'quant') {
    my ($min, $max) = ($node->min, $node->max);
    return ([], [], 1) if $max eq '0';
    my ($first_ns, $last_ns, $is_optional)
        = $self->_add_to_graph ($node->data => $g);

    my $label;
    if ($max eq '') {
      if ($min == 0) {
        $is_optional = 1;
        $label = '';
        
      } elsif ($min == 1) {
        $label = '';
        
      } else {
        $label = 'at least ' . ($min - 1);
        
      }
    } elsif ($max == 1) {
      if ($min == 0) {
        $is_optional = 1;
        
      } else {
        
      }
    } else {
      $label = 'at most ' . ($max - 1);
      if ($min == 0) {
        $is_optional = 1;
        

      } elsif ($min == 1) {
        
      } else {
        $label = 'at least ' . ($min - 1) . ', ' . $label;

      }
    }
    
    if (@$first_ns != 1 or @$last_ns != 1) {
      my $n = $g->add_node (refaddr $first_ns);
      $n->set_attribute (label => '');
      my $m = $n;
      unless ($is_optional) {
        $m = $g->add_node (refaddr $last_ns);
        $m->set_attribute (label => '');
      } else {
        $is_optional = 0;
      }
      $g->add_edge ($n => $_) for @$first_ns;
      $g->add_edge ($_ => $m) for @$last_ns;
      $first_ns = [$n];
      $last_ns = [$m];
    }

    if (defined $label) {
      my $e = $g->add_edge ($last_ns->[0] => $first_ns->[0]);
      $e->set_attribute (label => $label);
    }

    return ($first_ns, $last_ns, $is_optional);
  } elsif ($type eq 'branch') {
    my @first_n;
    my @last_n;
    my $is_optional = 0;
    for (@{$node->data}) {
      my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($_ => $g);
      push @first_n, @$f_ns;
      push @last_n, @$l_ns;
      $is_optional |= $is_opt;
    }
    return (\@first_n, \@last_n, $is_optional);
  } elsif ($type eq 'anyof') {
    my $data = $node->data;
    if ($node->neg) {
      if (@$data) {
        my $nodes = Regexp::Parser::branch->new ($node->{rx});
        $nodes->{data} = $node->data;
        
        $self->push_regexp_node ($nodes);
        
        my $n = $g->add_node (refaddr $nodes);
        my $label = 'NOT #' . $self->get_graph_index ($nodes);
        $n->set_attribute (label => $label);
        
        return ([$n], [$n], 0);      
      } else {
        my $n = $g->add_node (refaddr $node);
        my $label = 'Any character';
        $n->set_attribute (label => $label);

        return ([$n], [$n], 0);
      }
    } else {
      if (@$data) {
        my @first_n;
        my @last_n;
        for (@{$node->data}) {
          my ($f_ns, $l_ns) = $self->_add_to_graph ($_ => $g);
          push @first_n, @$f_ns;
          push @last_n, @$l_ns;
        }
        return (\@first_n, \@last_n, 0);
      } else {
        my $fail_n = $g->node ('FAIL');
        return ([$fail_n], [$fail_n], 0);
      }
    }
  } elsif ($type eq '') {
    my $prev_ns;
    my $first_ns;
    my $is_optional = 1;
    for (@{$node}) {
      my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($_ => $g);
      if ($prev_ns) {
        if (@$prev_ns > 1 and @$f_ns > 1) {
          my $n = $g->add_node (refaddr $f_ns);
          $n->set_attribute (label => '');
          $g->add_edge ($_ => $n) for @$prev_ns;
          $g->add_edge ($n => $_) for @$f_ns;
        } else {
          for my $prev_n (@$prev_ns) {
            for my $f_n (@$f_ns) {
              $g->add_edge ($prev_n => $f_n);
            }
          }
        }
        if ($is_optional) {
          push @$first_ns, @$f_ns;
        }
        if ($is_opt) {
          push @$prev_ns, @$l_ns;
        } else {
          $prev_ns = $l_ns if @$l_ns;
        }
      } else {
        $first_ns = $f_ns;
        $prev_ns = $l_ns if @$l_ns;
      }
      $is_optional &= $is_opt;
    }
    return ($first_ns || [], $prev_ns || [], $is_optional);
  } elsif ($family eq 'group' or $family eq 'open' or $type eq 'suspend') {
    ## TODO: (?:) vs () vs (?>), (?:)->on, (?:)->off
    my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($node->data => $g);
    return ($f_ns, $l_ns, $is_opt);
  } elsif ($type eq 'ifthen') {
    my $nodes = $node->data;
    
    my $groupp = $nodes->[0];
    my $label = $groupp ? '(?' . $groupp->visual . ')' : '';
    my $n = $g->add_node (refaddr $groupp);
    $n->set_attribute (label => $label);

    my $l = $g->add_node (refaddr $nodes);
    $l->set_attribute (label => '');
    
    my $branch = $nodes->[1];
    my $branches = $branch ? $branch->data : [];
    
    my $true = $branches->[0];
    if ($true) {
      my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($true => $g);
      $g->add_edge ($n => $_)->set_attribute (label => 'true') for @$f_ns;
      $g->add_edge ($_ => $l) for @$l_ns;
      $g->add_edge ($n => $l)->set_attribute (label => 'true') if $is_opt;
    }

    my $false = $branches->[1];
    if ($false) {
      my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($false => $g);
      $g->add_edge ($n => $_)->set_attribute (label => 'false') for @$f_ns;
      $g->add_edge ($_ => $l) for @$l_ns;
      $g->add_edge ($n => $l)->set_attribute (label => 'false') if $is_opt;
    }
    
    return ([$n], [$l], 0);
  } elsif ($type eq 'eval' or $type eq 'logical') {
    my $n = $g->add_node (refaddr $node);
    my $label = $type eq 'eval' ? '(?{})' : '(??{})';
    $label .= ' ' . _escape_code $node->data;
    $n->set_attribute (label => $label);
    return ([$n], [$n], 0);
  } elsif ($family eq 'assertion') {
    my $nodes = $node->data;
    $self->push_regexp_node ($nodes);
    
    my $n = $g->add_node (refaddr $nodes);
    $type = '<' . $type if $node->dir < 0;
    my $label = $assertion_map->{$type} // $type;
    $label .= ' #' . $self->get_graph_index ($nodes);
    $n->set_attribute (label => $label);
    
    return ([$n], [$n], 0);
  } elsif ($family eq 'anyof_class') {
    my $data = $node->data;
    my $label;
    if ($data eq 'POSIX') {
      my $how = ${$node->{how}};
      if ($how eq ':') {
        $label = 'POSIX ' . $node->{type};
        $label = 'NOT ' . $label if $node->neg;
      } else {
        $label = $how . $node->neg . $node->{type} . $how;
      }
    } else {
      my $data_family = $data->family;
      if ($data_family eq 'prop') {
        $label = 'property ' . $node->type;
        $label = 'NOT ' . $label if $node->neg;
      } elsif ($data_family eq 'space') {
        $label = $data->neg ? 'Perl /\S/' : 'Perl /\s/';
      } elsif ($data_family eq 'alnum') {
        $label = $data->neg ? 'Perl /\W/' : 'Perl /\w/';
      } elsif ($data_family eq 'digit') {
        $label = $data->neg ? 'Perl /\D/' : 'Perl /\d/';
      } else {
        $label = $data->visual;
      }
    }
  
    my $n = $g->add_node (refaddr $node);
    $n->set_attribute (label => $label);
    
    return ([$n] => [$n]);
  } elsif ($family eq 'exact' or $type eq 'anyof_char') {
    my $n = $g->add_node (refaddr $node);

    my $label = _escape_value $node->data;
    $n->set_attribute (label => qq[ "$label" ]);

    return ([$n] => [$n]);
  } elsif ($family eq 'flags') {
    ## TODO: scope
    my $n = $g->add_node (refaddr $node);

    my $label = $node->visual;
    $n->set_attribute (label => $label);

    return ([$n] => [$n], 0);
  } elsif ($family eq 'minmod') {
    my $nodes = $node->data;
    $self->push_regexp_node ($nodes);

    my $n = $g->add_node (refaddr $nodes);
    my $label = 'non-greedy #' . $self->get_graph_index ($nodes);
    $n->set_attribute (label => $label);

    return ([$n], [$n], 0);
  } elsif ($family eq 'anyof_range') {
    my $n = $g->add_node (refaddr $node);

    my $start = _escape_value $node->data->[0]->data;
    my $end = _escape_value $node->data->[1]->data;
    my $label = qq[ one of "$start" .. "$end" ];
    $n->set_attribute (label => $label);

    return ([$n] => [$n], 0);
  } else {
    # anyof_char
    # anyof_range

    my $n = $g->add_node (refaddr $node);
    
    my $label = $node->visual;
    $label = $default_map->{$label} // _escape_value $label;
    $label .= ' (' . $type . ')';
    $n->set_attribute (label => $label);
    
    return ([$n] => [$n], 0);
  }
} # _add_to_graph

1;
1	package Regexp::Visualize::Simple;
2	use strict;
3	use warnings;
4
5	use Graph::Easy;
6
7	use Scalar::Util qw/refaddr/;
8
9	my $default_map = {};
10	for (qw/. \C \w \W \s \S \d \D \X \1 \2 \3 \4 \5 \6 \7 \8 \9
11	\A ^ \B \b \G \Z \z $/) {
12	$default_map->{$_} = qq[Perl /$_/];
13	}
14
15	my $assertion_map = {
16	ifmatch => '(?=)',
17	'<ifmatch' => '(?<=)',
18	unlessm => '(?!)',
19	'<unlessm' => '(?<!)',
20	};
21
22	sub new ($) {
23	my $self = bless {}, shift;
24	$self->{next_index} = 0;
25	$self->{regexp_nodes} = [];
26	return $self;
27	} # new
28
29	sub _escape_value ($) {
30	my $v = shift;
31	$v =~ s/(\W)/sprintf '\x{%04X}', ord $1/ge;
32	$v;
33	} # _escape_value
34
35	sub _escape_code ($) {
36	my $v = shift;
37	$v =~ s/([^\x20-\x5B\x5D-\x7E])/sprintf '\x{%04X}', ord $1/ge;
38	$v;
39	} # _escape_code
40
41	sub push_regexp_node ($$) {
42	my $self = shift;
43	my $nodes = shift; # Regexp::Parser's node or array ref of nodes
44	push @{$self->{regexp}}, $nodes;
45	return $self->get_graph_index ($nodes);
46	} # push_regexp_node
47
48	sub shift_regexp_node ($) {
49	my $self = shift;
50	return shift @{$self->{regexp}};
51	} # shift_regexp_node
52
53	sub has_regexp_node ($) {
54	my $self = shift;
55	return scalar @{$self->{regexp}};
56	} # has_regexp_node
57
58	sub get_graph_index ($$) {
59	my $self = shift;
60	my $nodes = shift;
61	$self->{index}->{$nodes} //= $self->{next_index}++;
62	return $self->{index}->{$nodes};
63	} # get_graph_index
64
65	sub next_graph ($) {
66	my $self = shift;
67	my $root_nodes = $self->shift_regexp_node;
68	return (undef, undef) unless $root_nodes;
69
70	my $g = Graph::Easy->new;
71
72	$g->set_attributes ('node.start' => {fill => 'blue', color => 'white'});
73	$g->set_attributes ('node.success' => {fill => 'green', color => 'white'});
74	$g->set_attributes ('node.fail' => {fill => 'red', color => 'white'});
75	$g->set_attributes ('edge.fail' => {color => 'gray'});
76
77	my $start_n = $g->add_node ('START');
78	$start_n->set_attribute (class => 'start');
79	my $success_n = $g->add_node ('SUCCESS');
80	$success_n->set_attribute (class => 'success');
81	my $fail_n = $g->add_node ('FAIL');
82	$fail_n->set_attribute (class => 'fail');
83
84	my ($first_ns, $last_ns, $is_optional)
85	= $self->_add_to_graph ($root_nodes => $g);
86	$g->add_edge ($start_n => $_) for @$first_ns;
87	$g->add_edge ($_ => $success_n) for @$last_ns;
88	$g->add_edge ($start_n => $success_n) if $is_optional;
89
90	$g->del_node ($success_n) unless $success_n->incoming;
91	$g->del_node ($fail_n) unless $fail_n->incoming;
92	$_->set_attribute ('class' => 'fail') for $fail_n->outgoing;
93
94	return ($g, $self->get_graph_index ($root_nodes));
95	} # next_graph
96
97	sub _add_to_graph ($$$) {
98	my ($self, $node, $g) = @_;
99
100	my $family = ref $node eq 'ARRAY' ? '' : $node->family;
101	my $type = ref $node eq 'ARRAY' ? '' : $node->type;
102	if ($family eq 'quant') {
103	my ($min, $max) = ($node->min, $node->max);
104	return ([], [], 1) if $max eq '0';
105	my ($first_ns, $last_ns, $is_optional)
106	= $self->_add_to_graph ($node->data => $g);
107
108	my $label;
109	if ($max eq '') {
110	if ($min == 0) {
111	$is_optional = 1;
112	$label = '';
113
114	} elsif ($min == 1) {
115	$label = '';
116
117	} else {
118	$label = 'at least ' . ($min - 1);
119
120	}
121	} elsif ($max == 1) {
122	if ($min == 0) {
123	$is_optional = 1;
124
125	} else {
126
127	}
128	} else {
129	$label = 'at most ' . ($max - 1);
130	if ($min == 0) {
131	$is_optional = 1;
132
133
134	} elsif ($min == 1) {
135
136	} else {
137	$label = 'at least ' . ($min - 1) . ', ' . $label;
138
139	}
140	}
141
142	if (@$first_ns != 1 or @$last_ns != 1) {
143	my $n = $g->add_node (refaddr $first_ns);
144	$n->set_attribute (label => '');
145	my $m = $n;
146	unless ($is_optional) {
147	$m = $g->add_node (refaddr $last_ns);
148	$m->set_attribute (label => '');
149	} else {
150	$is_optional = 0;
151	}
152	$g->add_edge ($n => $_) for @$first_ns;
153	$g->add_edge ($_ => $m) for @$last_ns;
154	$first_ns = [$n];
155	$last_ns = [$m];
156	}
157
158	if (defined $label) {
159	my $e = $g->add_edge ($last_ns->[0] => $first_ns->[0]);
160	$e->set_attribute (label => $label);
161	}
162
163	return ($first_ns, $last_ns, $is_optional);
164	} elsif ($type eq 'branch') {
165	my @first_n;
166	my @last_n;
167	my $is_optional = 0;
168	for (@{$node->data}) {
169	my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($_ => $g);
170	push @first_n, @$f_ns;
171	push @last_n, @$l_ns;
172	$is_optional \|= $is_opt;
173	}
174	return (\@first_n, \@last_n, $is_optional);
175	} elsif ($type eq 'anyof') {
176	my $data = $node->data;
177	if ($node->neg) {
178	if (@$data) {
179	my $nodes = Regexp::Parser::branch->new ($node->{rx});
180	$nodes->{data} = $node->data;
181
182	$self->push_regexp_node ($nodes);
183
184	my $n = $g->add_node (refaddr $nodes);
185	my $label = 'NOT #' . $self->get_graph_index ($nodes);
186	$n->set_attribute (label => $label);
187
188	return ([$n], [$n], 0);
189	} else {
190	my $n = $g->add_node (refaddr $node);
191	my $label = 'Any character';
192	$n->set_attribute (label => $label);
193
194	return ([$n], [$n], 0);
195	}
196	} else {
197	if (@$data) {
198	my @first_n;
199	my @last_n;
200	for (@{$node->data}) {
201	my ($f_ns, $l_ns) = $self->_add_to_graph ($_ => $g);
202	push @first_n, @$f_ns;
203	push @last_n, @$l_ns;
204	}
205	return (\@first_n, \@last_n, 0);
206	} else {
207	my $fail_n = $g->node ('FAIL');
208	return ([$fail_n], [$fail_n], 0);
209	}
210	}
211	} elsif ($type eq '') {
212	my $prev_ns;
213	my $first_ns;
214	my $is_optional = 1;
215	for (@{$node}) {
216	my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($_ => $g);
217	if ($prev_ns) {
218	if (@$prev_ns > 1 and @$f_ns > 1) {
219	my $n = $g->add_node (refaddr $f_ns);
220	$n->set_attribute (label => '');
221	$g->add_edge ($_ => $n) for @$prev_ns;
222	$g->add_edge ($n => $_) for @$f_ns;
223	} else {
224	for my $prev_n (@$prev_ns) {
225	for my $f_n (@$f_ns) {
226	$g->add_edge ($prev_n => $f_n);
227	}
228	}
229	}
230	if ($is_optional) {
231	push @$first_ns, @$f_ns;
232	}
233	if ($is_opt) {
234	push @$prev_ns, @$l_ns;
235	} else {
236	$prev_ns = $l_ns if @$l_ns;
237	}
238	} else {
239	$first_ns = $f_ns;
240	$prev_ns = $l_ns if @$l_ns;
241	}
242	$is_optional &= $is_opt;
243	}
244	return ($first_ns \|\| [], $prev_ns \|\| [], $is_optional);
245	} elsif ($family eq 'group' or $family eq 'open' or $type eq 'suspend') {
246	## TODO: (?:) vs () vs (?>), (?:)->on, (?:)->off
247	my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($node->data => $g);
248	return ($f_ns, $l_ns, $is_opt);
249	} elsif ($type eq 'ifthen') {
250	my $nodes = $node->data;
251
252	my $groupp = $nodes->[0];
253	my $label = $groupp ? '(?' . $groupp->visual . ')' : '';
254	my $n = $g->add_node (refaddr $groupp);
255	$n->set_attribute (label => $label);
256
257	my $l = $g->add_node (refaddr $nodes);
258	$l->set_attribute (label => '');
259
260	my $branch = $nodes->[1];
261	my $branches = $branch ? $branch->data : [];
262
263	my $true = $branches->[0];
264	if ($true) {
265	my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($true => $g);
266	$g->add_edge ($n => $_)->set_attribute (label => 'true') for @$f_ns;
267	$g->add_edge ($_ => $l) for @$l_ns;
268	$g->add_edge ($n => $l)->set_attribute (label => 'true') if $is_opt;
269	}
270
271	my $false = $branches->[1];
272	if ($false) {
273	my ($f_ns, $l_ns, $is_opt) = $self->_add_to_graph ($false => $g);
274	$g->add_edge ($n => $_)->set_attribute (label => 'false') for @$f_ns;
275	$g->add_edge ($_ => $l) for @$l_ns;
276	$g->add_edge ($n => $l)->set_attribute (label => 'false') if $is_opt;
277	}
278
279	return ([$n], [$l], 0);
280	} elsif ($type eq 'eval' or $type eq 'logical') {
281	my $n = $g->add_node (refaddr $node);
282	my $label = $type eq 'eval' ? '(?{})' : '(??{})';
283	$label .= ' ' . _escape_code $node->data;
284	$n->set_attribute (label => $label);
285	return ([$n], [$n], 0);
286	} elsif ($family eq 'assertion') {
287	my $nodes = $node->data;
288	$self->push_regexp_node ($nodes);
289
290	my $n = $g->add_node (refaddr $nodes);
291	$type = '<' . $type if $node->dir < 0;
292	my $label = $assertion_map->{$type} // $type;
293	$label .= ' #' . $self->get_graph_index ($nodes);
294	$n->set_attribute (label => $label);
295
296	return ([$n], [$n], 0);
297	} elsif ($family eq 'anyof_class') {
298	my $data = $node->data;
299	my $label;
300	if ($data eq 'POSIX') {
301	my $how = ${$node->{how}};
302	if ($how eq ':') {
303	$label = 'POSIX ' . $node->{type};
304	$label = 'NOT ' . $label if $node->neg;
305	} else {
306	$label = $how . $node->neg . $node->{type} . $how;
307	}
308	} else {
309	my $data_family = $data->family;
310	if ($data_family eq 'prop') {
311	$label = 'property ' . $node->type;
312	$label = 'NOT ' . $label if $node->neg;
313	} elsif ($data_family eq 'space') {
314	$label = $data->neg ? 'Perl /\S/' : 'Perl /\s/';
315	} elsif ($data_family eq 'alnum') {
316	$label = $data->neg ? 'Perl /\W/' : 'Perl /\w/';
317	} elsif ($data_family eq 'digit') {
318	$label = $data->neg ? 'Perl /\D/' : 'Perl /\d/';
319	} else {
320	$label = $data->visual;
321	}
322	}
323
324	my $n = $g->add_node (refaddr $node);
325	$n->set_attribute (label => $label);
326
327	return ([$n] => [$n]);
328	} elsif ($family eq 'exact' or $type eq 'anyof_char') {
329	my $n = $g->add_node (refaddr $node);
330
331	my $label = _escape_value $node->data;
332	$n->set_attribute (label => qq[ "$label" ]);
333
334	return ([$n] => [$n]);
335	} elsif ($family eq 'flags') {
336	## TODO: scope
337	my $n = $g->add_node (refaddr $node);
338
339	my $label = $node->visual;
340	$n->set_attribute (label => $label);
341
342	return ([$n] => [$n], 0);
343	} elsif ($family eq 'minmod') {
344	my $nodes = $node->data;
345	$self->push_regexp_node ($nodes);
346
347	my $n = $g->add_node (refaddr $nodes);
348	my $label = 'non-greedy #' . $self->get_graph_index ($nodes);
349	$n->set_attribute (label => $label);
350
351	return ([$n], [$n], 0);
352	} elsif ($family eq 'anyof_range') {
353	my $n = $g->add_node (refaddr $node);
354
355	my $start = _escape_value $node->data->[0]->data;
356	my $end = _escape_value $node->data->[1]->data;
357	my $label = qq[ one of "$start" .. "$end" ];
358	$n->set_attribute (label => $label);
359
360	return ([$n] => [$n], 0);
361	} else {
362	# anyof_char
363	# anyof_range
364
365	my $n = $g->add_node (refaddr $node);
366
367	my $label = $node->visual;
368	$label = $default_map->{$label} // _escape_value $label;
369	$label .= ' (' . $type . ')';
370	$n->set_attribute (label => $label);
371
372	return ([$n] => [$n], 0);
373	}
374	} # _add_to_graph
375
376	1;