blib/lib/Java/Javap/Generator/Perl6.pm untested

filter: Statementstmt 0.0% 0 / 146 Branchbran 0.0% 0 / 38 Conditioncond 0.0% 0 / 23 MC/DCmcdc 0.0% 0 / 12 Subroutinesub 0.0% 0 / 20 Podpod 0.0% 0 / 13 totaltotal 0.0% 0 / 252 CC 18 SCAR 34.4
CC
18
Cov
0%
_get_prologue
90.0
_cast_names
30.0
_get_unique_methods
30.0
CRAP 31.2
1 package Java::Javap::Generator::Perl6;
2  
3 use strict;
4 use warnings;
5  
6 use Template;
7 use Template::Filters;
8 use Java::Javap;
9 use Java::Javap::TypeCast;
10  
11 use Data::Dumper;
12  
13 # XXX This generator has way too much data processing in it
14 # It should be focussed on producing output from precomputed data.
15  
16 # XXX having this info here is suboptimal
17 # should at least be integrated with TypeCaster
18 # http://perlcabal.org/syn/S02.html#Undefined_types
19 my @perl_builtin_undefined = qw(
20 Mu
21 Failure
22 Any
23 Cool
24 );
25 # http://perlcabal.org/syn/S02.html#Immutable_types
26 my @perl_builtin_immutable = qw(
27 Str
28 !Bit
29 Int
30 Num
31 Rat
32 !FatRat
33 Complex
34 Bool
35  
36 Exception
37 Block
38 Seq
39 Range
40  
41 Set
42 !Bag
43 Enum
44 EnumMap
45 Signature
46 Parcel
47 !Slicel
48 Capture
49 !Blob
50 !Instant
51 !Duration
52 !HardRoutine
53 );
54 # http://perlcabal.org/syn/S02.html#Mutable_types
55 my @perl_builtin_mutable = qw(
56 Iterator
57 !SeqIter
58 RangeIter
59 !Scalar
60 Array
61 Hash
62 !KeySet
63 !KeyBag
64 !KeyHash
65 Pair
66 !PairSeq
67 Buf
68 IO
69 Routine
70 Sub
71 Method
72 Submethod
73 !Macro
74 Regex
75 Match
76 !Stash
77 !SoftRoutine
78  
79 DateTime
80 );
81 my @perl_builtin_roles = qw(
82 Iterable
83 );
84 my $perl_builtin_types = { map { (/^!/) ? () : ($_=>1) } (
85 @perl_builtin_undefined,
86 @perl_builtin_immutable,
87 @perl_builtin_mutable,
88 @perl_builtin_roles,
89 ) };
90  
91 if (0) { # check that types actually are built-in to current perl6
92 for my $t (keys %$perl_builtin_types) {
93 system("perl6 -e 'my $t \$v'");
94 }
95 }
96  
97 sub perl6_string_literal_filter {
98 my $value = shift;
99 $value =~ s/([^[:print:]])/ sprintf "\\u%04x", ord($1) /eg;
100 return qq{"$value"};
101 }
102  
103  
104 sub new {
105 my $class = shift;
106  
107 my $self = bless { @_ }, $class;
108  
109 my $filters = Template::Filters->new({
110 FILTERS => {
111 perl6_string_literal => \&perl6_string_literal_filter,
112 },
113 });
114
115 my $tt_args = {
116 POST_CHOMP => 1,
117 LOAD_FILTERS => [ $filters ],
118 };
119 $self->tt_args_set( $tt_args );
120  
121 return $self;
122 }
123  
124 sub tt_args_set {
125 my $self = shift;
126 my $args = shift;
127  
128 $self->{__TT_ARGS__} = $args;
129 }
130  
131 sub tt_args {
132 my $self = shift;
133 return $self->{__TT_ARGS__};
134 }
135  
136 sub generate {
137 my $self = shift;
138 my $params = shift;
139  
140 my $class_file = $params->{class_file};
141 my $ast = $params->{ast};
142 my $trace_level = defined $params->{trace_level} ? $params->{trace_level} : $self->{trace_level};
143  
144 $self->{type_caster} = $params->{type_caster} || Java::Javap::TypeCast->new();
145 $self->_cast_names( $ast );
146  
147 $ast->{method_list} = $self->_get_unique_methods( $ast );
148 #print STDERR Dumper($ast->{method_list});
149 $ast->{constant_list} = [ grep { $_->{body_element} eq 'constant' } @{$ast->{contents}} ];
150 #warn Dumper($ast->{constant_list});
151  
152 my $template = $self->_get_template( $ast );
153  
154 my @prologue = $self->_get_prologue( $ast );
155  
156 my $tt = Template->new( $self->tt_args );
157 my $tt_vars = {
158 ast => $ast,
159 gen_time => scalar localtime(),
160 version => $Java::Javap::VERSION,
161 class_file => $class_file,
162 type_caster=> $self->{type_caster},
163 javap_command=> $params->{javap_command},
164 prologue => \@prologue,
165 };
166 my $retval;
167 $tt->process( \$template, $tt_vars, \$retval )
168 or die "Error processing template: ".$tt->error();
169  
170 return $retval;
171 }
172  
173 sub _cast_names {
174 my $self = shift;
175 my $ast = shift;
176  
177 my $type_caster = $self->{type_caster};
178  
179 my $class_parent = defined $ast->{parent} ? $type_caster->cast($ast->{parent}) : '';
180 $ast->{cast_parent} = ($class_parent eq 'Mu') ? '' : $class_parent;
181  
182 my @class_implements = map { $type_caster->cast($_) } @{ $ast->{implements} };
183 $ast->{cast_implements} = \@class_implements;
184  
185 foreach my $element (@{$ast->{contents}}) {
186  
187 if ($element->{body_element} =~ /^(method|constructor)$/) {
188 foreach my $arg (@{$element->{args}}) {
189 $arg->{perl_type_name} = $type_caster->cast($arg->{name});
190 }
191 }
192 $element->{type}->{perl_type_name} = $type_caster->cast($element->{type}->{name})
193 if ref $element->{type};
194 }
195 }
196  
197 sub _get_unique_methods {
198 my $self = shift;
199 my $ast = shift;
200  
201 # identify duplicate signatures resulting from TypeCast operation
202 # ie if both foo(javatype1) and foo(javatype2) get mapped to foo(perl_type)
203 # then we only want to output foo once
204  
205 #print STDERR "methods: ", Dumper(@methods);
206 my %meth;
207 foreach my $element (@{$ast->{contents}}) {
208 next unless $element->{body_element} =~ /^(method|constructor)$/;
209  
210 my $signature = $element->{name};
211 # discard method names containing '$' XXX why?
212 next if $signature =~ /\$/;
213  
214 foreach my $arg (@{$element->{args}}) {
215 $signature .= (($arg->{array_text} =~ /Array of/) ? '@' : '$') . "$arg->{perl_type_name}, ";
216 }
217 $signature .= " --> " . ($element->{type}->{array_text} =~ /Array of/)
218 ? 'Array'
219 : $element->{type}->{perl_type_name};
220  
221 # print STDERR "signature: '$signature'\n" if $debug;
222 # de-dup via hash
223 $meth{$signature} = $element;
224 }
225 #die Dumper(\%meth);
226  
227 my @methods = sort {
228 # constructors first
229 ($b->{body_element} eq 'constructor') <=> ($a->{body_element} eq 'constructor') or
230 # then by method name
231 $a->{name} cmp $b->{name} or
232 # then by increasing arg count
233 @{$a->{args}} <=> @{$b->{args}}
234 } values %meth;
235  
236 #print STDERR Dumper(@methods);
237 return \@methods;
238 }
239  
240 sub _get_type_casts {
241 my $self = shift;
242 my $type_file = shift;
243  
244 # XXX TODO
245 }
246  
247 sub _get_prologue {
248 my $self = shift;
249 my $ast = shift;
250  
251 my $type_caster = $self->{type_caster};
252 my $trace_level = defined $self->{trace_level} ? $self->{trace_level} : 0;
253  
254 my %perl_types;
255  
256 $perl_types{ $ast->{cast_parent} }{parent} = 1 if $ast->{cast_parent};
257 $perl_types{ $_ }{implements} = 1 for @{ $ast->{cast_implements} };
258  
259 foreach my $element (@{$ast->{contents}}) {
260  
261 if ($element->{body_element} =~ /^(method|constructor)/) {
262 foreach my $arg (@{$element->{args}}) {
263 $perl_types{$arg->{perl_type_name}}{arg}++;
264 }
265 }
266  
267 $perl_types{ $element->{type}->{perl_type_name} }{return}++
268 if ref $element->{type};
269 }
270  
271 warn "$ast->{perl_qualified_name} references types: @{[ keys %perl_types ]}\n"
272 if $trace_level >= 3;
273  
274 for my $perl_type (keys %perl_types) {
275  
276 delete $perl_types{$perl_type}
277 if $perl_builtin_types->{$perl_type}
278 # our own class name
279 or $perl_type eq $ast->{perl_qualified_name}
280 # private java class
281 or $perl_type =~ /\$/
282 # void java class
283 or $perl_type eq 'void'
284 # at the moment rakudo does not support 'Array of' so don't include the
285 # dependency on the class as it will just return Array at the moment.
286 #or $element->{type}->{array_text} =~ /Array of/;
287 ;
288 }
289 warn "$ast->{perl_qualified_name} needs to load: @{[ keys %perl_types ]}\n"
290 if $trace_level >= 3;
291  
292 # XXX ideally we'd use the class or role as appropriate but we don't need
293 # to (at least for now) because: essentially "class Foo { ... }" simply
294 # declares Foo as a package-ish identifier -- per pmichaud.
295 # So we can get away with this cheat.
296 # But not for all kinds of usage: 'is' and 'does' need to 'use' first
297 my (@decl_class, @load_class);
298 while ( my ($type, $usage) = each %perl_types) {
299 if ($usage->{parent} || $usage->{implements}) {
300 push @load_class, $type;
301 next;
302 }
303 push @decl_class, $type;
304 }
305 return (
306 map({ "class $_ { ... };" } sort @decl_class),
307 map({ "use $_;" } sort @load_class)
308 );
309 }
310  
311  
312 sub _get_template {
313 my $self = shift;
314 my $ast = shift;
315  
316 my $prologue = $self->_get_template_prologue;
317 my $kind = $ast->{ class_or_interface };
318 $kind = 'interface'; # XXX only generate roles for perl6
319 my $method = "_get_template_for_$kind";
320 return $prologue . $self->$method( $ast );
321 }
322  
323 sub _get_template_prologue {
324 return << 'EO_Template';
325 [% BLOCK file_header %]
326 # *** DO NOT EDIT *** CHANGES WILL BE LOST ***
327 # This file was automatically generated
328 # by java2perl6api [% version %] from the output of
329 # [% javap_command +%]
330  
331 use v6;
332  
333 [% END %]
334 [% BLOCK method_arg %]
335 [% arg.perl_type_name %] [% arg.array_text.search('Array of') ? '@' : '$' %]v[% arg_counter %], # [% arg.name +%]
336 [% END %]
337 [% BLOCK method_all_args %]
338 [% arg_counter = 0 %]
339 [% FOREACH arg IN elem.args %][% arg_counter = arg_counter + 1 %]
340 [% INCLUDE method_arg %]
341 [% END %]
342 [% END %]
343 [% BLOCK method_returns %]
344 [%- IF ret.name != 'void' %] --> [% ret.array_text.search('Array of') ? 'Array ' : ret.perl_type_name %]
345 # [% ret.array_text %] [% ret.name +%]
346 [% END %]
347 [% END %]
348 [% BLOCK method_whole %]
349 [% ast.methods.${ elem.name } > 1 ? 'multi ' : '' -%]
350 method [% elem.name -%]
351 (
352 [% INCLUDE method_all_args elem = elem %]
353 [% INCLUDE method_returns ret = elem.type %]
354 ) { ... }
355 [%- IF elem.throws.size %] # throws [% elem.throws.join(", ") %][% END +%]
356  
357 [% END %]
358 [% BLOCK constant_whole %]
359 method [% elem.name %] (--> [% elem.type.perl_type_name %]) is export {
360 [%- IF elem.type.perl_type_name == 'Str'
361 %] [% elem.value | perl6_string_literal %]
362 [%- ELSIF elem.type.perl_type_name == 'Int' or elem.type.perl_type_name == 'Num' %] [% elem.value %]
363 [%- ELSE %] ... [% END -%] }
364 [% END %]
365 EO_Template
366 }
367  
368 sub _get_template_for_interface {
369 return << 'EO_Template';
370 [% PROCESS file_header %]
371 [% FOREACH prologue_item IN prologue %]
372 [%+ prologue_item +%]
373 [% END %]
374  
375 role [% ast.perl_qualified_name %]
376 [%- IF ast.cast_parent != '' %] does [% ast.cast_parent %] [% END -%]
377 [%- IF ast.cast_implements.size > 0 %] does [% ast.cast_implements.join(" does ") %] [% END -%]
378 {
379  
380 [% FOREACH element IN ast.constant_list %]
381 [% NEXT IF element.name.search('\$') %]
382 [% INCLUDE constant_whole elem = element %]
383 [% END; ast.constant_list.size ? "\n" : "" %]
384 [% FOREACH element IN ast.method_list %]
385 [% INCLUDE method_whole elem = element %]
386 [% END %]
387 };
388 EO_Template
389 }
390  
391 sub _get_template_for_class {
392 return << 'EO_Class_Template';
393 [% PROCESS file_header %]
394 [% FOREACH prologue_item IN prologue %]
395 [%+ prologue_item +%]
396 [% END %]
397  
398 class [% ast.perl_qualified_name %]
399 [%- ast.cast_parent == '' ? '' : ' is ' %][% ast.cast_parent -%]
400 [%- IF ast.cast_implements.size > 0 %] does [% ast.cast_implements.join(" does ") %] [% END -%]
401 {
402  
403 [% FOREACH element IN ast.constant_list %]
404 [% NEXT IF element.name.search('\$') %]
405 [% INCLUDE constant_whole elem = element %]
406 [% END; ast.constant_list.size ? "\n" : "" %]
407 [% FOREACH element IN ast.method_list %]
408 [% INCLUDE method_whole elem = element %]
409 [% END %]
410 };
411 EO_Class_Template
412 }
413  
414 1;
415  
416 __END__