source: josm/trunk/tools/japicc/modules/Internals/APIDump.pm @ 12872

Last change on this file since 12872 was 12872, checked in by Don-vip, 3 years ago

update to JAPICC 2.3

File size: 32.1 KB
Line 
1###########################################################################
2# A module to create API dump from disassembled code
3#
4# Copyright (C) 2016-2017 Andrey Ponomarenko's ABI Laboratory
5#
6# Written by Andrey Ponomarenko
7#
8# This program is free software: you can redistribute it and/or modify
9# it under the terms of the GNU General Public License or the GNU Lesser
10# General Public License as published by the Free Software Foundation.
11#
12# This program is distributed in the hope that it will be useful,
13# but WITHOUT ANY WARRANTY; without even the implied warranty of
14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15# GNU General Public License for more details.
16#
17# You should have received a copy of the GNU General Public License
18# and the GNU Lesser General Public License along with this program.
19# If not, see <http://www.gnu.org/licenses/>.
20###########################################################################
21use strict;
22use IPC::Open3;
23
24my $ExtractCounter = 0;
25
26my %MName_Mid;
27my %Mid_MName;
28
29my $T_ID = 0;
30my $M_ID = 0;
31my $U_ID = 0;
32
33# Aliases
34my (%MethodInfo, %TypeInfo, %TName_Tid) = ();
35
36foreach (1, 2)
37{
38    $MethodInfo{$_} = $In::API{$_}{"MethodInfo"};
39    $TypeInfo{$_} = $In::API{$_}{"TypeInfo"};
40    $TName_Tid{$_} = $In::API{$_}{"TName_Tid"};
41}
42
43sub createAPIDump($)
44{
45    my $LVer = $_[0];
46   
47    readArchives($LVer);
48   
49    if(not keys(%{$MethodInfo{$LVer}})) {
50        printMsg("WARNING", "empty dump");
51    }
52   
53    $In::API{$LVer}{"LibraryVersion"} = $In::Desc{$LVer}{"Version"};
54    $In::API{$LVer}{"LibraryName"} = $In::Opt{"TargetLib"};
55    $In::API{$LVer}{"Language"} = "Java";
56}
57
58sub readArchives($)
59{
60    my $LVer = $_[0];
61    my @ArchivePaths = getArchives($LVer);
62    if($#ArchivePaths==-1) {
63        exitStatus("Error", "Java archives are not found in ".$In::Desc{$LVer}{"Version"});
64    }
65    printMsg("INFO", "Reading classes ".$In::Desc{$LVer}{"Version"}." ...");
66   
67    $T_ID = 0;
68    $M_ID = 0;
69    $U_ID = 0;
70   
71    %MName_Mid = ();
72    %Mid_MName = ();
73   
74    foreach my $ArchivePath (sort {length($a)<=>length($b)} @ArchivePaths) {
75        readArchive($LVer, $ArchivePath);
76    }
77    foreach my $TName (keys(%{$TName_Tid{$LVer}}))
78    {
79        my $Tid = $TName_Tid{$LVer}{$TName};
80        if(not $TypeInfo{$LVer}{$Tid}{"Type"})
81        {
82            if($TName=~/\A(void|boolean|char|byte|short|int|float|long|double)\Z/) {
83                $TypeInfo{$LVer}{$Tid}{"Type"} = "primitive";
84            }
85            else {
86                $TypeInfo{$LVer}{$Tid}{"Type"} = "class";
87            }
88        }
89    }
90}
91
92sub getArchives($)
93{
94    my $LVer = $_[0];
95    my @Paths = ();
96    foreach my $Path (keys(%{$In::Desc{$LVer}{"Archives"}}))
97    {
98        if(not -e $Path) {
99            exitStatus("Access_Error", "can't access \'$Path\'");
100        }
101       
102        foreach (getArchivePaths($Path, $LVer)) {
103            push(@Paths, $_);
104        }
105    }
106    return @Paths;
107}
108
109sub readArchive($$)
110{ # 1, 2 - library, 0 - client
111    my ($LVer, $Path) = @_;
112   
113    $Path = getAbsPath($Path);
114    my $JarCmd = getCmdPath("jar");
115    if(not $JarCmd) {
116        exitStatus("Not_Found", "can't find \"jar\" command");
117    }
118    my $ExtractPath = join_P($In::Opt{"Tmp"}, $ExtractCounter);
119    if(-d $ExtractPath) {
120        rmtree($ExtractPath);
121    }
122    mkpath($ExtractPath);
123    chdir($ExtractPath);
124    system($JarCmd." -xf \"$Path\"");
125    if($?) {
126        exitStatus("Error", "can't extract \'$Path\'");
127    }
128    chdir($In::Opt{"OrigDir"});
129    my @Classes = ();
130    foreach my $ClassPath (cmdFind($ExtractPath, "", "*\\.class"))
131    {
132        if($In::Opt{"OS"} ne "windows") {
133            $ClassPath=~s/\.class\Z//g;
134        }
135       
136        my $ClassName = getFilename($ClassPath);
137        if($ClassName=~/\$\d/ or $ClassName eq "module-info") {
138            next;
139        }
140       
141        $ClassPath = cutPrefix($ClassPath, $ExtractPath); # javap decompiler accepts relative paths only
142       
143        my $ClassDir = getDirname($ClassPath);
144        if($ClassDir=~/\./)
145        { # jaxb-osgi.jar/1.0/org/apache
146            next;
147        }
148       
149        my $Package = getPFormat($ClassDir);
150        if($LVer)
151        {
152            if(skipPackage($Package, $LVer))
153            { # internal packages
154                next;
155            }
156        }
157       
158        push(@Classes, $ClassPath);
159    }
160   
161    if($#Classes!=-1)
162    {
163        foreach my $PartRef (divideArray(\@Classes))
164        {
165            if($LVer) {
166                readClasses($PartRef, $LVer, getFilename($Path));
167            }
168            else {
169                readClasses_Usage($PartRef);
170            }
171        }
172    }
173   
174    $ExtractCounter += 1;
175   
176    if($LVer)
177    {
178        foreach my $SubArchive (cmdFind($ExtractPath, "", "*\\.jar"))
179        { # recursive step
180            readArchive($LVer, $SubArchive);
181        }
182    }
183   
184    rmtree($ExtractPath);
185}
186
187sub sepParams($$$)
188{
189    my ($Params, $Comma, $Sp) = @_;
190    my @Parts = ();
191    my %B = ( "("=>0, "<"=>0, ")"=>0, ">"=>0 );
192    my $Part = 0;
193    foreach my $Pos (0 .. length($Params) - 1)
194    {
195        my $S = substr($Params, $Pos, 1);
196        if(defined $B{$S}) {
197            $B{$S} += 1;
198        }
199        if($S eq "," and
200        $B{"("}==$B{")"} and $B{"<"}==$B{">"})
201        {
202            if($Comma)
203            { # include comma
204                $Parts[$Part] .= $S;
205            }
206            $Part += 1;
207        }
208        else {
209            $Parts[$Part] .= $S;
210        }
211    }
212    if(not $Sp)
213    { # remove spaces
214        foreach (@Parts)
215        {
216            s/\A //g;
217            s/ \Z//g;
218        }
219    }
220    return @Parts;
221}
222
223sub simpleDecl($$)
224{
225    my ($Line, $LVer) = @_;
226   
227    my %B = ( "<"=>0, ">"=>0 );
228    my @Chars = split("", $Line);
229   
230    my $Extends = undef;
231    my ($Pre, $Post) = ("", "");
232    my @Replace = ();
233   
234    foreach my $Pos (0 .. $#Chars)
235    {
236        my $S = $Chars[$Pos];
237        if(defined $B{$S}) {
238            $B{$S} += 1;
239        }
240       
241        if($B{"<"}!=0)
242        {
243            if(defined $Extends)
244            {
245                my $E = 0;
246               
247                if($S eq ",")
248                {
249                    if($B{"<"}-$B{">"}==$Extends) {
250                        $E = 1;
251                    }
252                }
253                elsif($S eq ">")
254                {
255                    if($B{"<"}==$B{">"} or $B{"<"}-$B{">"}+1==$Extends) {
256                        $E = 1;
257                    }
258                }
259               
260                if($E)
261                {
262                    if($Post) {
263                        push(@Replace, $Post);
264                    }
265                   
266                    $Extends = undef;
267                    ($Pre, $Post) = ("", "");
268                }
269            }
270            elsif($B{"<"}!=$B{">"})
271            {
272                if(substr($Pre, -9) eq " extends ")
273                {
274                    $Extends = $B{"<"}-$B{">"};
275                }
276            }
277        }
278       
279        $Pre .= $S;
280        if(defined $Extends) {
281            $Post .= $S;
282        }
283    }
284   
285    my %Tmpl = ();
286   
287    foreach my $R (@Replace)
288    {
289        if($Line=~s/([A-Za-z\d\?]+) extends \Q$R\E/$1/) {
290            $Tmpl{$1} = registerType($R, $LVer);
291        }
292    }
293   
294    return ($Line, \%Tmpl);
295}
296
297sub readClasses($$$)
298{
299    my ($Paths, $LVer, $ArchiveName) = @_;
300   
301    my $JavapCmd = getCmdPath("javap");
302    if(not $JavapCmd) {
303        exitStatus("Not_Found", "can't find \"javap\" command");
304    }
305   
306    my $TmpDir = $In::Opt{"Tmp"};
307   
308    # ! private info should be processed
309    my @Cmd = ($JavapCmd, "-s", "-private");
310    if(not $In::Opt{"Quick"}) {
311        @Cmd = (@Cmd, "-c", "-verbose");
312    }
313   
314    @Cmd = (@Cmd, @{$Paths});
315   
316    chdir($TmpDir."/".$ExtractCounter);
317    my $Pid = open3(*IN, *OUT, *ERR, @Cmd);
318    close(IN);
319   
320    my (%TypeAttr, $CurrentMethod, $CurrentPackage, $CurrentClass, $CurrentClass_Short) = ();
321    my ($InParamTable, $InVarTypeTable, $InExceptionTable, $InCode) = (0, 0, 0, 0);
322   
323    my $InAnnotations = undef;
324    my $InAnnotations_Class = undef;
325    my $InAnnotations_Method = undef;
326    my %AnnotationName = ();
327    my %AnnotationNum = (); # support for Java 7
328   
329    my ($ParamPos, $FieldPos) = (0, 0);
330    my ($LINE, $Stay, $Run, $NonEmpty) = (undef, 0, 1, undef);
331   
332    my $DContent = "";
333    my $Debug = (defined $In::Opt{"Debug"});
334   
335    while($Run)
336    {
337        if(not $Stay)
338        {
339            $LINE = <OUT>;
340           
341            if(not defined $NonEmpty and $LINE) {
342                $NonEmpty = 1;
343            }
344           
345            if($Debug) {
346                $DContent .= $LINE;
347            }
348        }
349       
350        if(not $LINE)
351        {
352            $Run = 0;
353            last;
354        }
355       
356        $Stay = 0;
357       
358        if($LINE=~/\A\s*const/) {
359            next;
360        }
361       
362        if(index($LINE, 'Start  Length')!=-1
363        or index($LINE, 'Compiled from')!=-1
364        or index($LINE, 'Last modified')!=-1
365        or index($LINE, 'MD5 checksum')!=-1
366        or index($LINE, 'Classfile /')==0
367        or index($LINE, 'Classfile jar')==0)
368        {
369            next;
370        }
371       
372        if(index($LINE, '=')!=-1)
373        {
374            if(index($LINE, ' stack=')!=-1
375            or index($LINE, 'frame_type =')!=-1
376            or index($LINE, 'offset_delta =')!=-1)
377            {
378                next;
379            }
380        }
381       
382        if(index($LINE, ':')!=-1)
383        {
384            if(index($LINE, ' LineNumberTable:')!=-1
385            or index($LINE, 'SourceFile:')==0
386            or index($LINE, ' StackMapTable:')!=-1
387            or index($LINE, ' Exceptions:')!=-1
388            or index($LINE, 'Constant pool:')!=-1
389            or index($LINE, 'minor version:')!=-1
390            or index($LINE, 'major version:')!=-1
391            or index($LINE, ' AnnotationDefault:')!=-1)
392            {
393                next;
394            }
395        }
396       
397        if(index($LINE, " of ")!=-1
398        or index($LINE, "= [")!=-1) {
399            next;
400        }
401       
402        if($LINE=~/ line \d+:|\[\s*class|\$\d|\._\d/)
403        { # artificial methods and code
404            next;
405        }
406       
407        # $LINE=~s/ \$(\w)/ $1/g;
408       
409        if(index($LINE, '$')!=-1)
410        {
411            if(index($LINE, ' class$')!=-1
412            or index($LINE, '$eq')!=-1
413            or index($LINE, '.$')!=-1
414            or index($LINE, '/$')!=-1
415            or index($LINE, '$$')!=-1
416            or index($LINE, '$(')!=-1
417            or index($LINE, '$:')!=-1
418            or index($LINE, '$.')!=-1
419            or index($LINE, '$;')!=-1) {
420                next;
421            }
422           
423            if($LINE=~/ (\w+\$|)\w+\$\w+[\(:]/) {
424                next;
425            }
426           
427            if(not $InParamTable and not $InVarTypeTable)
428            {
429                if(index($LINE, ' $')!=-1) {
430                    next;
431                }
432            }
433           
434            $LINE=~s/\$([\> ]|\s*\Z)/$1/g;
435        }
436       
437        my $EndBr = ($LINE eq "}\n" or $LINE eq "}\r\n");
438       
439        if($EndBr) {
440            $InAnnotations_Class = 1;
441        }
442       
443        if($EndBr or $LINE eq "\n" or $LINE eq "\r\n")
444        {
445            $CurrentMethod = undef;
446            $InCode = 0;
447            $InAnnotations_Method = 0;
448            $InParamTable = 0;
449            $InVarTypeTable = 0;
450            next;
451        }
452       
453        if(index($LINE, '#')!=-1)
454        {
455            if($LINE=~/\A\s*#(\d+)/)
456            { # Constant pool
457                my $CNum = $1;
458                if($LINE=~/\s+([^ ]+?);/)
459                {
460                    my $AName = $1;
461                    $AName=~s/\AL//;
462                    $AName=~s/\$/./g;
463                    $AName=~s/\//./g;
464                   
465                    $AnnotationName{$CNum} = $AName;
466                   
467                    if(defined $AnnotationNum{$CNum})
468                    { # support for Java 7
469                        if($InAnnotations_Class) {
470                            $TypeAttr{"Annotations"}{registerType($AName, $LVer)} = 1;
471                        }
472                        delete($AnnotationNum{$CNum});
473                    }
474                }
475               
476                next;
477            }
478           
479            if(index($LINE, ": #")!=-1 and index($LINE, "//")!=-1) {
480                next;
481            }
482        }
483       
484        my $TmplP = undef;
485       
486        # Java 7: templates
487        if(index($LINE, "<")!=-1)
488        { # <T extends java.lang.Object>
489          # <KEYIN extends java.lang.Object ...
490            if($LINE=~/<[A-Z\d\?]+ /i) {
491                ($LINE, $TmplP) = simpleDecl($LINE, $LVer);
492            }
493        }
494       
495        if(index($LINE, ',')!=-1) {
496            $LINE=~s/\s*,\s*/,/g;
497        }
498       
499        if(index($LINE, '$')!=-1) {
500            $LINE=~s/\$/#/g;
501        }
502       
503        if(index($LINE, "LocalVariableTable")!=-1) {
504            $InParamTable += 1;
505        }
506        elsif(index($LINE, "LocalVariableTypeTable")!=-1) {
507            $InVarTypeTable += 1;
508        }
509        elsif(index($LINE, "Exception table")!=-1) {
510            $InExceptionTable = 1;
511        }
512        elsif(index($LINE, " Code:")!=-1)
513        {
514            $InCode += 1;
515            $InAnnotations = undef;
516        }
517        elsif(index($LINE, ':')!=-1
518        and $LINE=~/\A\s*\d+:\s*/)
519        { # read Code
520            if($InCode==1)
521            {
522                if($CurrentMethod)
523                {
524                    if(index($LINE, "invoke")!=-1)
525                    {
526                        if($LINE=~/ invoke(\w+) .* \/\/\s*(Method|InterfaceMethod)\s+(.+?)\s*\Z/)
527                        { # 3:   invokevirtual   #2; //Method "[Lcom/sleepycat/je/Database#DbState;".clone:()Ljava/lang/Object;
528                            my ($InvokeType, $InvokedName) = ($1, $3);
529                           
530                            if($InvokedName!~/\A(\w+:|java\/(lang|util|io)\/)/
531                            and index($InvokedName, '"<init>":')!=0)
532                            {
533                                $InvokedName=~s/#/\$/g;
534                               
535                                my $ID = undef;
536                                if($In::Opt{"Reproducible"}) {
537                                    $ID = getMd5($InvokedName);
538                                }
539                                else {
540                                    $ID = ++$U_ID;
541                                }
542                               
543                                $In::API{$LVer}{"MethodUsed"}{$ID}{"Name"} = $InvokedName;
544                                $In::API{$LVer}{"MethodUsed"}{$ID}{"Used"}{$CurrentMethod} = $InvokeType;
545                            }
546                        }
547                    }
548                    # elsif($LINE=~/ (getstatic|putstatic) .* \/\/\s*Field\s+(.+?)\s*\Z/)
549                    # {
550                    #     my $UsedFieldName = $2;
551                    #     $In::API{$LVer}{"FieldUsed"}{$UsedFieldName}{$CurrentMethod} = 1;
552                    # }
553                }
554            }
555            elsif(defined $InAnnotations)
556            {
557                if($LINE=~/\A\s*\d+\:\s*#(\d+)/)
558                {
559                    if(my $AName = $AnnotationName{$1})
560                    {
561                        if($InAnnotations_Class) {
562                            $TypeAttr{"Annotations"}{registerType($AName, $LVer)} = 1;
563                        }
564                        elsif($InAnnotations_Method) {
565                            $MethodInfo{$LVer}{$MName_Mid{$CurrentMethod}}{"Annotations"}{registerType($AName, $LVer)} = 1;
566                        }
567                    }
568                    else
569                    { # suport for Java 7
570                        $AnnotationNum{$1} = 1;
571                    }
572                }
573            }
574        }
575        elsif($InParamTable==1 and $LINE=~/\A\s+\d/)
576        { # read parameter names from LocalVariableTable
577            if($CurrentMethod and $LINE=~/\A\s+0\s+\d+\s+\d+\s+(\#?)(\w+)/)
578            {
579                my $Art = $1;
580                my $PName = $2;
581               
582                if(($PName ne "this" or $Art) and $PName=~/[a-z]/i)
583                {
584                    if($CurrentMethod)
585                    {
586                        my $ID = $MName_Mid{$CurrentMethod};
587                       
588                        if(defined $MethodInfo{$LVer}{$ID}
589                        and defined $MethodInfo{$LVer}{$ID}{"Param"}
590                        and defined $MethodInfo{$LVer}{$ID}{"Param"}{$ParamPos}
591                        and defined $MethodInfo{$LVer}{$ID}{"Param"}{$ParamPos}{"Type"})
592                        {
593                            $MethodInfo{$LVer}{$ID}{"Param"}{$ParamPos}{"Name"} = $PName;
594                            $ParamPos++;
595                        }
596                    }
597                }
598            }
599        }
600        elsif($InVarTypeTable==1 and $LINE=~/\A\s+\d/)
601        {
602            # skip
603        }
604        elsif($CurrentClass and index($LINE, '(')!=-1
605        and $LINE=~/(\A|\s+)([^\s]+)\s+([^\s]+)\s*\((.*)\)\s*(throws\s*([^\s]+)|)\s*;\s*\Z/)
606        { # attributes of methods and constructors
607            my (%MethodAttr, $ParamsLine, $Exceptions) = ();
608           
609            $InParamTable = 0; # read the first local variable table
610            $InVarTypeTable = 0;
611            $InCode = 0; # read the first code
612            $InAnnotations_Method = 1;
613            $InAnnotations_Class = 0;
614           
615            ($MethodAttr{"Return"}, $MethodAttr{"ShortName"}, $ParamsLine, $Exceptions) = ($2, $3, $4, $6);
616            $MethodAttr{"ShortName"}=~s/#/./g;
617           
618            if($Exceptions)
619            {
620                foreach my $E (split(/,/, $Exceptions)) {
621                    $MethodAttr{"Exceptions"}{registerType($E, $LVer)} = 1;
622                }
623            }
624            if($LINE=~/(\A|\s+)(public|protected|private)\s+/) {
625                $MethodAttr{"Access"} = $2;
626            }
627            else {
628                $MethodAttr{"Access"} = "package-private";
629            }
630            $MethodAttr{"Class"} = registerType($TypeAttr{"Name"}, $LVer);
631            if($MethodAttr{"ShortName"}=~/\A(|(.+)\.)(\Q$CurrentClass\E|\Q$CurrentClass_Short\E)\Z/)
632            {
633                if($2)
634                {
635                    $MethodAttr{"Package"} = $2;
636                    $CurrentPackage = $MethodAttr{"Package"};
637                    $MethodAttr{"ShortName"} = $CurrentClass;
638                }
639                $MethodAttr{"Constructor"} = 1;
640                delete($MethodAttr{"Return"});
641            }
642            else
643            {
644                $MethodAttr{"Return"} = registerType($MethodAttr{"Return"}, $LVer);
645            }
646           
647            my @Params = sepParams($ParamsLine, 0, 1);
648           
649            $ParamPos = 0;
650            foreach my $ParamTName (@Params)
651            {
652                %{$MethodAttr{"Param"}{$ParamPos}} = ("Type"=>registerType($ParamTName, $LVer), "Name"=>"p".($ParamPos+1));
653                $ParamPos++;
654            }
655            $ParamPos = 0;
656            if(not $MethodAttr{"Constructor"})
657            { # methods
658                if($CurrentPackage) {
659                    $MethodAttr{"Package"} = $CurrentPackage;
660                }
661                if($LINE=~/(\A|\s+)abstract\s+/) {
662                    $MethodAttr{"Abstract"} = 1;
663                }
664                if($LINE=~/(\A|\s+)final\s+/) {
665                    $MethodAttr{"Final"} = 1;
666                }
667                if($LINE=~/(\A|\s+)static\s+/) {
668                    $MethodAttr{"Static"} = 1;
669                }
670                if($LINE=~/(\A|\s+)native\s+/) {
671                    $MethodAttr{"Native"} = 1;
672                }
673                if($LINE=~/(\A|\s+)synchronized\s+/) {
674                    $MethodAttr{"Synchronized"} = 1;
675                }
676            }
677           
678            my $LINE_N = <OUT>;
679           
680            if($Debug) {
681                $DContent .= $LINE_N;
682            }
683           
684            # $LINE_N=~s/ \$(\w)/ $1/g;
685            $LINE_N=~s/\$([\> ]|\s*\Z)/$1/g;
686           
687            # read the Signature
688            if(index($LINE_N, ": #")==-1
689            and $LINE_N=~/(Signature|descriptor):\s*(.+?)\s*\Z/i)
690            { # create run-time unique name ( java/io/PrintStream.println (Ljava/lang/String;)V )
691                my $SignParams = $2;
692               
693                # Generic classes
694                my $ShortClass = $CurrentClass;
695                $ShortClass=~s/<.*>//g;
696               
697                if($MethodAttr{"Constructor"}) {
698                    $CurrentMethod = $ShortClass.".\"<init>\":".$SignParams;
699                }
700                else {
701                    $CurrentMethod = $ShortClass.".".$MethodAttr{"ShortName"}.":".$SignParams;
702                }
703                if(my $PackageName = getSFormat($CurrentPackage)) {
704                    $CurrentMethod = $PackageName."/".$CurrentMethod;
705                }
706            }
707            else {
708                exitStatus("Error", "internal error - can't read method signature");
709            }
710           
711            $MethodAttr{"Archive"} = $ArchiveName;
712            if($CurrentMethod)
713            {
714                my $ID = undef;
715                if($In::Opt{"Reproducible"}) {
716                    $ID = getMd5($CurrentMethod);
717                }
718                else {
719                    $ID = ++$M_ID;
720                }
721               
722                $MName_Mid{$CurrentMethod} = $ID;
723               
724                if(defined $Mid_MName{$ID} and $Mid_MName{$ID} ne $CurrentMethod) {
725                    printMsg("ERROR", "md5 collision on \'$ID\', please increase ID length (MD5_LEN in Basic.pm)");
726                }
727               
728                $Mid_MName{$ID} = $CurrentMethod;
729               
730                $MethodAttr{"Name"} = $CurrentMethod;
731                $MethodInfo{$LVer}{$ID} = \%MethodAttr;
732            }
733        }
734        elsif($CurrentClass and $LINE=~/(\A|\s+)([^\s]+)\s+(\w+);\s*\Z/)
735        { # fields
736            my ($TName, $FName) = ($2, $3);
737            $TypeAttr{"Fields"}{$FName}{"Type"} = registerType($TName, $LVer);
738            if($LINE=~/(\A|\s+)final\s+/) {
739                $TypeAttr{"Fields"}{$FName}{"Final"} = 1;
740            }
741            if($LINE=~/(\A|\s+)static\s+/) {
742                $TypeAttr{"Fields"}{$FName}{"Static"} = 1;
743            }
744            if($LINE=~/(\A|\s+)transient\s+/) {
745                $TypeAttr{"Fields"}{$FName}{"Transient"} = 1;
746            }
747            if($LINE=~/(\A|\s+)volatile\s+/) {
748                $TypeAttr{"Fields"}{$FName}{"Volatile"} = 1;
749            }
750            if($LINE=~/(\A|\s+)(public|protected|private)\s+/) {
751                $TypeAttr{"Fields"}{$FName}{"Access"} = $2;
752            }
753            else {
754                $TypeAttr{"Fields"}{$FName}{"Access"} = "package-private";
755            }
756           
757            $TypeAttr{"Fields"}{$FName}{"Pos"} = $FieldPos++;
758           
759            my $LINE_NP = <OUT>;
760            if($Debug) {
761                $DContent .= $LINE_NP;
762            }
763           
764            # read the Signature
765            if(index($LINE_NP, ": #")==-1
766            and $LINE_NP=~/(Signature|descriptor):\s*(.+?)\s*\Z/i)
767            {
768                my $FSignature = $2;
769                if(my $PackageName = getSFormat($CurrentPackage)) {
770                    $TypeAttr{"Fields"}{$FName}{"Mangled"} = $PackageName."/".$CurrentClass.".".$FName.":".$FSignature;
771                }
772            }
773           
774            $LINE_NP = <OUT>;
775            if($Debug) {
776                $DContent .= $LINE_NP;
777            }
778           
779            if($LINE_NP=~/flags:/i)
780            { # flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ANNOTATION
781                $LINE_NP = <OUT>;
782                if($Debug) {
783                    $DContent .= $LINE_NP;
784                }
785            }
786            else
787            {
788                $LINE = $LINE_NP;
789                $Stay = 1;
790            }
791           
792            # read the Value
793            if($LINE_NP=~/Constant\s*value:\s*([^\s]+)\s(.*?)\s*\Z/i)
794            {
795              # Java 6: Constant value: ...
796              # Java 7: ConstantValue: ...
797                my ($TName, $Value) = ($1, $2);
798                if($Value)
799                {
800                    if($Value=~s/Deprecated:\s*true\Z//g) {
801                        # deprecated values: ?
802                    }
803                    $TypeAttr{"Fields"}{$FName}{"Value"} = $Value;
804                }
805                elsif($TName eq "String") {
806                    $TypeAttr{"Fields"}{$FName}{"Value"} = "\@EMPTY_STRING\@";
807                }
808            }
809            else
810            {
811                $LINE = $LINE_NP;
812                $Stay = 1;
813            }
814        }
815        elsif($LINE=~/(\A|\s+)(class|interface)\s+([^\s\{]+)(\s+|\{|\s*\Z)/)
816        { # properties of classes and interfaces
817            if($TypeAttr{"Name"})
818            { # register previous
819                %{$TypeInfo{$LVer}{registerType($TypeAttr{"Name"}, $LVer)}} = %TypeAttr;
820            }
821           
822            %TypeAttr = ("Type"=>$2, "Name"=>$3); # reset previous class
823            %AnnotationName = (); # reset annotations of the class
824            %AnnotationNum = (); # support for Java 7
825            $InAnnotations_Class = 1;
826           
827            $FieldPos = 0; # reset field position
828            $CurrentMethod = ""; # reset current method
829            $TypeAttr{"Archive"} = $ArchiveName;
830            if($TypeAttr{"Name"}=~/\A(.+)\.([^.]+)\Z/)
831            {
832                $CurrentClass = $2;
833                $TypeAttr{"Package"} = $1;
834                $CurrentPackage = $TypeAttr{"Package"};
835            }
836            else
837            {
838                $CurrentClass = $TypeAttr{"Name"};
839                $CurrentPackage = "";
840            }
841           
842            if($CurrentClass=~s/#/./g)
843            { # javax.swing.text.GlyphView.GlyphPainter <=> GlyphView$GlyphPainter
844                $TypeAttr{"Name"}=~s/#/./g;
845            }
846           
847            $CurrentClass_Short = $CurrentClass;
848            if(index($CurrentClass_Short, "<")!=-1) {
849                $CurrentClass_Short=~s/<.+>//g;
850            }
851           
852            if($LINE=~/(\A|\s+)(public|protected|private)\s+/) {
853                $TypeAttr{"Access"} = $2;
854            }
855            else {
856                $TypeAttr{"Access"} = "package-private";
857            }
858            if($LINE=~/\s+extends\s+([^\s\{]+)/)
859            {
860                my $Extended = $1;
861               
862                if($TypeAttr{"Type"} eq "class")
863                {
864                    if($Extended ne $CurrentPackage.".".$CurrentClass) {
865                        $TypeAttr{"SuperClass"} = registerType($Extended, $LVer);
866                    }
867                }
868                elsif($TypeAttr{"Type"} eq "interface")
869                {
870                    my @Elems = sepParams($Extended, 0, 0);
871                    foreach my $SuperInterface (@Elems)
872                    {
873                        if($SuperInterface ne $CurrentPackage.".".$CurrentClass) {
874                            $TypeAttr{"SuperInterface"}{registerType($SuperInterface, $LVer)} = 1;
875                        }
876                       
877                        if($SuperInterface eq "java.lang.annotation.Annotation") {
878                            $TypeAttr{"Annotation"} = 1;
879                        }
880                    }
881                }
882            }
883            if($LINE=~/\s+implements\s+([^\s\{]+)/)
884            {
885                my $Implemented = $1;
886                my @Elems = sepParams($Implemented, 0, 0);
887               
888                foreach my $SuperInterface (@Elems) {
889                    $TypeAttr{"SuperInterface"}{registerType($SuperInterface, $LVer)} = 1;
890                }
891            }
892            if($LINE=~/(\A|\s+)abstract\s+/) {
893                $TypeAttr{"Abstract"} = 1;
894            }
895            if($LINE=~/(\A|\s+)final\s+/) {
896                $TypeAttr{"Final"} = 1;
897            }
898            if($LINE=~/(\A|\s+)static\s+/) {
899                $TypeAttr{"Static"} = 1;
900            }
901           
902            if($TmplP) {
903                $TypeAttr{"GenericParam"} = $TmplP;
904            }
905        }
906        elsif(index($LINE, "Deprecated: true")!=-1
907        or index($LINE, "Deprecated: length")!=-1)
908        { # deprecated method or class
909            if($CurrentMethod) {
910                $MethodInfo{$LVer}{$MName_Mid{$CurrentMethod}}{"Deprecated"} = 1;
911            }
912            elsif($CurrentClass) {
913                $TypeAttr{"Deprecated"} = 1;
914            }
915        }
916        elsif(index($LINE, "RuntimeInvisibleAnnotations")!=-1
917        or index($LINE, "RuntimeVisibleAnnotations")!=-1)
918        {
919            $InAnnotations = 1;
920            $InCode = 0;
921        }
922        elsif(defined $InAnnotations and index($LINE, "InnerClasses")!=-1) {
923            $InAnnotations = undef;
924        }
925        else
926        {
927            # unparsed
928        }
929    }
930   
931    if($TypeAttr{"Name"})
932    { # register last
933        %{$TypeInfo{$LVer}{registerType($TypeAttr{"Name"}, $LVer)}} = %TypeAttr;
934    }
935   
936    waitpid($Pid, 0);
937    chdir($In::Opt{"OrigDir"});
938   
939    if(my $Err = $?>>8) {
940        exitStatus("Error", "failed to run javap");
941    }
942   
943    if(not $NonEmpty) {
944        exitStatus("Error", "internal error in parser");
945    }
946   
947    if($Debug) {
948        appendFile(getDebugDir($LVer)."/class-dump.txt", $DContent);
949    }
950}
951
952sub registerType($$)
953{
954    my ($TName, $LVer) = @_;
955   
956    if(not $TName) {
957        return 0;
958    }
959   
960    $TName=~s/#/./g;
961    if($TName_Tid{$LVer}{$TName}) {
962        return $TName_Tid{$LVer}{$TName};
963    }
964   
965    if(not $TName_Tid{$LVer}{$TName})
966    {
967        my $ID = undef;
968        if($In::Opt{"Reproducible"}) {
969            $ID = getMd5($TName);
970        }
971        else {
972            $ID = ++$T_ID;
973        }
974        $TName_Tid{$LVer}{$TName} = "$ID";
975    }
976   
977    my $Tid = $TName_Tid{$LVer}{$TName};
978    $TypeInfo{$LVer}{$Tid}{"Name"} = $TName;
979    if($TName=~/(.+)\[\]\Z/)
980    {
981        if(my $BaseTypeId = registerType($1, $LVer))
982        {
983            $TypeInfo{$LVer}{$Tid}{"BaseType"} = $BaseTypeId;
984            $TypeInfo{$LVer}{$Tid}{"Type"} = "array";
985        }
986    }
987    elsif($TName=~/(.+)\.\.\.\Z/)
988    {
989        if(my $BaseTypeId = registerType($1, $LVer))
990        {
991            $TypeInfo{$LVer}{$Tid}{"BaseType"} = $BaseTypeId;
992            $TypeInfo{$LVer}{$Tid}{"Type"} = "variable-arity";
993        }
994    }
995   
996    return $Tid;
997}
998
999sub readClasses_Usage($)
1000{
1001    my $Paths = $_[0];
1002   
1003    my $JavapCmd = getCmdPath("javap");
1004    if(not $JavapCmd) {
1005        exitStatus("Not_Found", "can't find \"javap\" command");
1006    }
1007   
1008    my $Input = join(" ", @{$Paths});
1009    if($In::Opt{"OS"} ne "windows")
1010    { # on unix ensure that the system does not try and interpret the $, by escaping it
1011        $Input=~s/\$/\\\$/g;
1012    }
1013   
1014    my $TmpDir = $In::Opt{"Tmp"};
1015   
1016    chdir($TmpDir."/".$ExtractCounter);
1017    open(CONTENT, "$JavapCmd -c -private $Input 2>\"$TmpDir/warn\" |");
1018    while(<CONTENT>)
1019    {
1020        if(/\/\/\s*(Method|InterfaceMethod)\s+(.+)\s*\Z/)
1021        {
1022            my $M = $2;
1023            $In::Opt{"UsedMethods_Client"}{$M} = 1;
1024           
1025            if($M=~/\A(.*)+\.\w+\:\(/)
1026            {
1027                my $C = $1;
1028                $C=~s/\//./g;
1029                $In::Opt{"UsedClasses_Client"}{$C} = 1;
1030            }
1031        }
1032        elsif(/\/\/\s*Field\s+(.+)\s*\Z/)
1033        {
1034            # my $FieldName = $1;
1035            # if(/\s+(putfield|getfield|getstatic|putstatic)\s+/) {
1036            #     $UsedFields_Client{$FieldName} = $1;
1037            # }
1038        }
1039        elsif(/ ([^\s]+) [^: ]+\(([^()]+)\)/)
1040        {
1041            my ($Ret, $Params) = ($1, $2);
1042           
1043            $Ret=~s/\[\]//g; # quals
1044            $In::Opt{"UsedClasses_Client"}{$Ret} = 1;
1045           
1046            foreach my $Param (split(/\s*,\s*/, $Params))
1047            {
1048                $Param=~s/\[\]//g; # quals
1049                $In::Opt{"UsedClasses_Client"}{$Param} = 1;
1050            }
1051        }
1052        elsif(/ class /)
1053        {
1054            if(/extends ([^\s{]+)/)
1055            {
1056                foreach my $Class (split(/\s*,\s*/, $1)) {
1057                    $In::Opt{"UsedClasses_Client"}{$Class} = 1;
1058                }
1059            }
1060           
1061            if(/implements ([^\s{]+)/)
1062            {
1063                foreach my $Interface (split(/\s*,\s*/, $1)) {
1064                    $In::Opt{"UsedClasses_Client"}{$Interface} = 1;
1065                }
1066            }
1067        }
1068    }
1069    close(CONTENT);
1070    chdir($In::Opt{"OrigDir"});
1071}
1072
1073return 1;
Note: See TracBrowser for help on using the repository browser.