Context Navigation

japi-compliance-checker.pl@ 18296

Last change on this file since 18296 was 13595, checked in by Don-vip, 7 years ago
tools update: Groovy 2.4.15, PMD 6.2.0, JAPICC 2.4
File size: 169.7 KB

Rev	Line
[10845]	1	#!/usr/bin/perl
[13595]	2	#########################################################################
	3	# Java API Compliance Checker (JAPICC) 2.4
[10845]	4	# A tool for checking backward compatibility of a Java library API
	5	#
	6	# Written by Andrey Ponomarenko
	7	#
[13595]	8	# Copyright (C) 2011-2018 Andrey Ponomarenko's ABI Laboratory
[10845]	9	#
	10	# PLATFORMS
	11	# =========
	12	# Linux, FreeBSD, Mac OS X, MS Windows
	13	#
	14	# REQUIREMENTS
	15	# ============
	16	# Linux, FreeBSD, Mac OS X
[13595]	17	# - JDK or OpenJDK - development files (javap, javac, jar, jmod)
[10845]	18	# - Perl 5 (5.8 or newer)
	19	#
	20	# MS Windows
[13595]	21	# - JDK or OpenJDK (javap, javac, jar, jmod)
[10845]	22	# - Active Perl 5 (5.8 or newer)
	23	#
[13595]	24	# This library is free software; you can redistribute it and/or
	25	# modify it under the terms of the GNU Lesser General Public
	26	# License as published by the Free Software Foundation; either
	27	# version 2.1 of the License, or (at your option) any later version.
[10845]	28	#
[13595]	29	# This library is distributed in the hope that it will be useful,
[10845]	30	# but WITHOUT ANY WARRANTY; without even the implied warranty of
[13595]	31	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	32	# Lesser General Public License for more details.
[10845]	33	#
[13595]	34	# You should have received a copy of the GNU Lesser General Public
	35	# License along with this library; if not, write to the Free Software
	36	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
	37	# MA 02110-1301 USA.
	38	#########################################################################
[10845]	39	use Getopt::Long;
	40	Getopt::Long::Configure ("posix_default", "no_ignore_case", "permute");
	41	use File::Path qw(mkpath rmtree);
	42	use File::Temp qw(tempdir);
[11682]	43	use File::Basename qw(dirname);
[10845]	44	use Cwd qw(abs_path cwd);
	45	use Data::Dumper;
	46
[13595]	47	my $TOOL_VERSION = "2.4";
	48	my $API_DUMP_VERSION = "2.4";
[12872]	49	my $API_DUMP_VERSION_MIN = "2.2";
[10845]	50
[11682]	51	# Internal modules
	52	my $MODULES_DIR = getModules();
	53	push(@INC, dirname($MODULES_DIR));
[10845]	54
[11682]	55	# Basic modules
	56	my %LoadedModules = ();
	57	loadModule("Basic");
	58	loadModule("Input");
	59	loadModule("Path");
	60	loadModule("Logging");
	61	loadModule("Utils");
	62	loadModule("TypeAttr");
	63	loadModule("Filter");
	64	loadModule("SysFiles");
	65	loadModule("Descriptor");
	66	loadModule("Mangling");
[10845]	67
[11682]	68	# Rules DB
	69	my %RULES_PATH = (
	70	"Binary" => $MODULES_DIR."/RulesBin.xml",
	71	"Source" => $MODULES_DIR."/RulesSrc.xml");
[10845]	72
[11682]	73	my $CmdName = getFilename($0);
[10845]	74
	75	my %HomePage = (
	76	"Dev"=>"https://github.com/lvc/japi-compliance-checker",
[11682]	77	"Doc"=>"https://lvc.github.io/japi-compliance-checker/"
[10845]	78	);
	79
	80	my $ShortUsage = "Java API Compliance Checker (JAPICC) $TOOL_VERSION
	81	A tool for checking backward compatibility of a Java library API
[13595]	82	Copyright (C) 2018 Andrey Ponomarenko's ABI Laboratory
	83	License: LGPLv2.1+
[10845]	84
	85	Usage: $CmdName [options]
[13595]	86	Example:
	87	$CmdName OLD.jar NEW.jar
	88	$CmdName OLD.jmod NEW.jmod
[10845]	89
	90	More info: $CmdName --help";
	91
	92	if($#ARGV==-1)
	93	{
	94	printMsg("INFO", $ShortUsage);
	95	exit(0);
	96	}
	97
[11682]	98	GetOptions("h\|help!" => \$In::Opt{"Help"},
	99	"v\|version!" => \$In::Opt{"ShowVersion"},
	100	"dumpversion!" => \$In::Opt{"DumpVersion"},
[10845]	101	# general options
[11682]	102	"l\|lib\|library=s" => \$In::Opt{"TargetLib"},
	103	"d1\|old\|o=s" => \$In::Desc{1}{"Path"},
	104	"d2\|new\|n=s" => \$In::Desc{2}{"Path"},
[10845]	105	# extra options
[11682]	106	"client\|app=s" => \$In::Opt{"ClientPath"},
	107	"binary\|bin!" => \$In::Opt{"BinaryOnly"},
	108	"source\|src!" => \$In::Opt{"SourceOnly"},
	109	"v1\|version1\|vnum=s" => \$In::Desc{1}{"TargetVersion"},
	110	"v2\|version2=s" => \$In::Desc{2}{"TargetVersion"},
	111	"s\|strict!" => \$In::Opt{"StrictCompat"},
	112	"keep-internal!" => \$In::Opt{"KeepInternal"},
	113	"skip-internal-packages\|skip-internal=s" => \$In::Opt{"SkipInternalPackages"},
	114	"skip-internal-types=s" => \$In::Opt{"SkipInternalTypes"},
	115	"dump\|dump-api=s" => \$In::Opt{"DumpAPI"},
[13595]	116	"check-annotations!" => \$In::Opt{"CheckAnnotations"},
[12872]	117	"check-packages=s" => \$In::Opt{"CheckPackages"},
[11682]	118	"classes-list=s" => \$In::Opt{"ClassListPath"},
	119	"annotations-list=s" => \$In::Opt{"AnnotationsListPath"},
	120	"skip-annotations-list=s" => \$In::Opt{"SkipAnnotationsListPath"},
	121	"skip-deprecated!" => \$In::Opt{"SkipDeprecated"},
	122	"skip-classes=s" => \$In::Opt{"SkipClassesList"},
	123	"skip-packages=s" => \$In::Opt{"SkipPackagesList"},
[13595]	124	"non-impl=s" => \$In::Opt{"NonImplClassesList"},
	125	"non-impl-all!" => \$In::Opt{"NonImplAll"},
[11682]	126	"short" => \$In::Opt{"ShortMode"},
	127	"dump-path=s" => \$In::Opt{"OutputDumpPath"},
	128	"report-path=s" => \$In::Opt{"OutputReportPath"},
	129	"bin-report-path=s" => \$In::Opt{"BinaryReportPath"},
	130	"src-report-path=s" => \$In::Opt{"SourceReportPath"},
	131	"quick!" => \$In::Opt{"Quick"},
	132	"sort!" => \$In::Opt{"SortDump"},
	133	"show-access!" => \$In::Opt{"ShowAccess"},
	134	"limit-affected=s" => \$In::Opt{"AffectLimit"},
	135	"hide-templates!" => \$In::Opt{"HideTemplates"},
	136	"show-packages!" => \$In::Opt{"ShowPackages"},
	137	"compact!" => \$In::Opt{"Compact"},
	138	"added-annotations!" => \$In::Opt{"AddedAnnotations"},
	139	"removed-annotations!" => \$In::Opt{"RemovedAnnotations"},
	140	"count-methods=s" => \$In::Opt{"CountMethods"},
	141	"dep1=s" => \$In::Desc{1}{"DepDump"},
	142	"dep2=s" => \$In::Desc{2}{"DepDump"},
	143	"old-style!" => \$In::Opt{"OldStyle"},
[10845]	144	# other options
[11682]	145	"test!" => \$In::Opt{"TestTool"},
	146	"debug!" => \$In::Opt{"Debug"},
	147	"title=s" => \$In::Opt{"TargetTitle"},
	148	"jdk-path=s" => \$In::Opt{"JdkPath"},
	149	"external-css=s" => \$In::Opt{"ExternCss"},
	150	"external-js=s" => \$In::Opt{"ExternJs"},
[10845]	151	# deprecated
[11682]	152	"minimal!" => \$In::Opt{"Minimal"},
	153	"hide-packages!" => \$In::Opt{"HidePackages"},
[10845]	154	# private
[11682]	155	"all-affected!" => \$In::Opt{"AllAffected"}
	156	) or errMsg();
[10845]	157
	158	if(@ARGV)
	159	{
	160	if($#ARGV==1)
	161	{ # japi-compliance-checker OLD.jar NEW.jar
[11682]	162	$In::Desc{1}{"Path"} = $ARGV[0];
	163	$In::Desc{2}{"Path"} = $ARGV[1];
[10845]	164	}
	165	else {
[11682]	166	errMsg();
[10845]	167	}
	168	}
	169
[11682]	170	sub errMsg()
[10845]	171	{
	172	printMsg("INFO", "\n".$ShortUsage);
[11682]	173	exit(getErrorCode("Error"));
[10845]	174	}
	175
[11682]	176	my $HelpMessage = "
[10845]	177	NAME:
	178	Java API Compliance Checker ($CmdName)
	179	Check backward compatibility of a Java library API
	180
	181	DESCRIPTION:
	182	Java API Compliance Checker (JAPICC) is a tool for checking backward
[11682]	183	binary/source compatibility of a Java library API. The tool checks class
[10845]	184	declarations of old and new versions and analyzes changes that may break
[11682]	185	compatibility: removed class members, added abstract methods, etc.
	186
	187	Break of the binary compatibility may result in crash or incorrect behavior
	188	of existing clients built with an old library version if they run with a
	189	new one. Break of the source compatibility may result in recompilation
[10845]	190	errors with a new library version.
	191
[11682]	192	The tool is intended for developers of software libraries and maintainers
	193	of operating systems who are interested in ensuring backward compatibility,
	194	i.e. allow old clients to run or to be recompiled with newer library
	195	versions.
[10845]	196
	197	This tool is free software: you can redistribute it and/or modify it
[13595]	198	under the terms of the GNU LGPL.
[10845]	199
	200	USAGE:
	201	$CmdName [options]
	202
[13595]	203	EXAMPLE (1):
[10845]	204	$CmdName OLD.jar NEW.jar
[11682]	205
[13595]	206	EXAMPLE (2):
	207	$CmdName OLD.jmod NEW.jmod
	208
	209	EXAMPLE (3):
[10845]	210	$CmdName -lib NAME -old OLD.xml -new NEW.xml
	211	OLD.xml and NEW.xml are XML-descriptors:
	212
	213	<version>
	214	1.0
	215	</version>
	216
	217	<archives>
[13595]	218	/path1/to/JAR(s) OR JMOD(s)/
	219	/path2/to/JAR(s) OR JMOD(s)/
[10845]	220	...
	221	</archives>
	222
	223	INFORMATION OPTIONS:
	224	-h\|-help
	225	Print this help.
	226
	227	-v\|-version
	228	Print version information.
	229
	230	-dumpversion
	231	Print the tool version ($TOOL_VERSION) and don't do anything else.
	232
	233	GENERAL OPTIONS:
[11682]	234	-l\|-library NAME
[10845]	235	Library name (without version).
	236
[11682]	237	-old\|-d1 PATH
	238	Descriptor of the 1st (old) library version.
[10845]	239	It may be one of the following:
	240
[13595]	241	1. Java archive (.jar or .jmod)
[10845]	242	2. XML-descriptor (VERSION.xml file):
	243
	244	<version>
	245	1.0
	246	</version>
	247
	248	<archives>
[13595]	249	/path1/to/JAR(s) OR JMOD(s)/
	250	/path2/to/JAR(s) OR JMOD(s)/
[10845]	251	...
	252	</archives>
	253
	254	...
	255
	256	3. API dump generated by -dump option
	257
[13595]	258	If you are using .jar or .jmod as a descriptor then
	259	you should specify version numbers with -v1 and -v2
	260	options too. If version numbers are not specified then
	261	the tool will try to detect them automatically.
[10845]	262
[11682]	263	-new\|-d2 PATH
	264	Descriptor of the 2nd (new) library version.
[10845]	265
	266	EXTRA OPTIONS:
	267	-client\|-app PATH
[11682]	268	This option allows to specify the client Java archive that should be
[10845]	269	checked for portability to the new library version.
[11682]	270
[10845]	271	-binary\|-bin
	272	Show \"Binary\" compatibility problems only.
	273	Generate report to \"bin_compat_report.html\".
[11682]	274
[10845]	275	-source\|-src
	276	Show \"Source\" compatibility problems only.
	277	Generate report to \"src_compat_report.html\".
[11682]	278
[10845]	279	-v1\|-version1 NUM
	280	Specify 1st API version outside the descriptor. This option is needed
	281	if you have prefered an alternative descriptor type (see -d1 option).
	282
	283	In general case you should specify it in the XML descriptor:
	284	<version>
	285	VERSION
	286	</version>
	287
	288	-v2\|-version2 NUM
	289	Specify 2nd library version outside the descriptor.
	290
	291	-vnum NUM
	292	Specify the library version in the generated API dump.
	293
	294	-s\|-strict
	295	Treat all API compatibility warnings as problems.
	296
	297	-keep-internal
	298	Do not skip checking of these packages:
	299	impl
	300	internal
	301	examples
	302
	303	-skip-internal-packages PATTERN
[12872]	304	Do not check packages matched by the regular expression.
[10845]	305
	306	-skip-internal-types PATTERN
[12872]	307	Do not check types (classes and interfaces) matched by the regular
	308	expression. It's matched against full qualified type names (e.g.
	309	'org.xyz.Name<T>'). It has to match any part of type name.
[10845]	310
	311	-dump\|-dump-api PATH
	312	Dump library API to gzipped TXT format file. You can transfer it
	313	anywhere and pass instead of the descriptor. Also it may be used
[12872]	314	for debugging the tool. PATH is the path to the Java archive or
	315	XML descriptor of the library.
	316
[13595]	317	-check-annotations
	318	Check for changes in annotations like in any other interfaces.
	319
[12872]	320	-check-packages PATTERN
	321	Check packages matched by the regular expression. Other packages
	322	will not be checked.
	323
[10845]	324	-classes-list PATH
	325	This option allows to specify a file with a list
	326	of classes that should be checked, other classes will not be checked.
	327
	328	-annotations-list PATH
	329	Specifies a file with a list of annotations. The tool will check only
	330	classes annotated by the annotations from the list. Other classes
	331	will not be checked.
	332
	333	-skip-annotations-list PATH
	334	Skip checking of classes annotated by the annotations in the list.
	335
	336	-skip-deprecated
	337	Skip analysis of deprecated methods and classes.
	338
	339	-skip-classes PATH
[13595]	340	List of classes that should not be checked.
	341
[10845]	342	-skip-packages PATH
[13595]	343	List of packages that should not be checked.
	344
	345	-non-impl PATH
	346	List of interfaces that should not be implemented by users.
	347
	348	-non-impl-all
	349	All interfaces should not be implemented by users.
	350
[10845]	351	-short
	352	Do not list added/removed methods.
	353
	354	-dump-path PATH
[11682]	355	Specify a *.dump file path where to generate an API dump.
[10845]	356	Default:
[11682]	357	api_dumps/LIB_NAME/VERSION/API.dump
[10845]	358
	359	-report-path PATH
	360	Path to compatibility report.
	361	Default:
	362	compat_reports/LIB_NAME/V1_to_V2/compat_report.html
	363
	364	-bin-report-path PATH
	365	Path to \"Binary\" compatibility report.
	366	Default:
	367	compat_reports/LIB_NAME/V1_to_V2/bin_compat_report.html
	368
	369	-src-report-path PATH
	370	Path to \"Source\" compatibility report.
	371	Default:
	372	compat_reports/LIB_NAME/V1_to_V2/src_compat_report.html
	373
	374	-quick
	375	Quick analysis.
	376	Disabled:
	377	- analysis of method parameter names
	378	- analysis of class field values
	379	- analysis of usage of added abstract methods
	380	- distinction of deprecated methods and classes
	381
	382	-sort
	383	Enable sorting of data in API dumps.
	384
	385	-show-access
	386	Show access level of non-public methods listed in the report.
	387
	388	-hide-templates
	389	Hide template parameters in the report.
	390
	391	-hide-packages
	392	-minimal
	393	Do nothing.
	394
	395	-show-packages
	396	Show package names in the report.
	397
	398	-limit-affected LIMIT
	399	The maximum number of affected methods listed under the description
	400	of the changed type in the report.
	401
	402	-compact
	403	Try to simplify formatting and reduce size of the report (for a big
	404	set of changes).
	405
	406	-added-annotations
	407	Apply filters by annotations only to new version of the library.
	408
	409	-removed-annotations
	410	Apply filters by annotations only to old version of the library.
	411
	412	-count-methods PATH
	413	Count total public methods in the API dump.
	414
	415	-dep1 PATH
	416	-dep2 PATH
	417	Path to the API dump of the required dependency archive. It will
	418	be used to resolve overwritten methods and more.
	419
	420	-old-style
	421	Generate old-style report.
	422
	423	OTHER OPTIONS:
	424	-test
	425	Run internal tests. Create two incompatible versions of a sample library
	426	and run the tool to check them for compatibility. This option allows to
	427	check if the tool works correctly in the current environment.
	428
	429	-debug
	430	Debugging mode. Print debug info on the screen. Save intermediate
	431	analysis stages in the debug directory:
	432	debug/LIB_NAME/VER/
	433
	434	Also consider using -dump option for debugging the tool.
	435
	436	-title NAME
	437	Change library name in the report title to NAME. By default
	438	will be displayed a name specified by -l option.
	439
	440	-jdk-path PATH
	441	Path to the JDK install tree (e.g. /usr/lib/jvm/java-7-openjdk-amd64).
	442
	443	-external-css PATH
	444	Generate CSS styles file to PATH. This helps to save space when
	445	generating thousands of reports.
	446
	447	-external-js PATH
	448	Generate JS script file to PATH.
	449
	450	REPORT:
	451	Compatibility report will be generated to:
	452	compat_reports/LIB_NAME/V1_to_V2/compat_report.html
	453
	454	EXIT CODES:
	455	0 - Compatible. The tool has run without any errors.
	456	non-zero - Incompatible or the tool has run with errors.
	457
[11682]	458	MORE INFO:
	459	".$HomePage{"Doc"}."
	460	".$HomePage{"Dev"};
[10845]	461
[11682]	462	sub helpMsg() {
[10845]	463	printMsg("INFO", $HelpMessage."\n");
	464	}
	465
[11682]	466	#Aliases
	467	my (%MethodInfo, %TypeInfo, %TName_Tid) = ();
[10845]	468
[12872]	469	my %TName_Tid_Generic = ();
	470
[11682]	471	#Separate checked and unchecked exceptions
[10845]	472	my %KnownRuntimeExceptions= map {$_=>1} (
	473	"java.lang.AnnotationTypeMismatchException",
	474	"java.lang.ArithmeticException",
	475	"java.lang.ArrayStoreException",
	476	"java.lang.BufferOverflowException",
	477	"java.lang.BufferUnderflowException",
	478	"java.lang.CannotRedoException",
	479	"java.lang.CannotUndoException",
	480	"java.lang.ClassCastException",
	481	"java.lang.CMMException",
	482	"java.lang.ConcurrentModificationException",
	483	"java.lang.DataBindingException",
	484	"java.lang.DOMException",
	485	"java.lang.EmptyStackException",
	486	"java.lang.EnumConstantNotPresentException",
	487	"java.lang.EventException",
	488	"java.lang.IllegalArgumentException",
	489	"java.lang.IllegalMonitorStateException",
	490	"java.lang.IllegalPathStateException",
	491	"java.lang.IllegalStateException",
	492	"java.lang.ImagingOpException",
	493	"java.lang.IncompleteAnnotationException",
	494	"java.lang.IndexOutOfBoundsException",
	495	"java.lang.JMRuntimeException",
	496	"java.lang.LSException",
	497	"java.lang.MalformedParameterizedTypeException",
	498	"java.lang.MirroredTypeException",
	499	"java.lang.MirroredTypesException",
	500	"java.lang.MissingResourceException",
	501	"java.lang.NegativeArraySizeException",
	502	"java.lang.NoSuchElementException",
	503	"java.lang.NoSuchMechanismException",
	504	"java.lang.NullPointerException",
	505	"java.lang.ProfileDataException",
	506	"java.lang.ProviderException",
	507	"java.lang.RasterFormatException",
	508	"java.lang.RejectedExecutionException",
	509	"java.lang.SecurityException",
	510	"java.lang.SystemException",
	511	"java.lang.TypeConstraintException",
	512	"java.lang.TypeNotPresentException",
	513	"java.lang.UndeclaredThrowableException",
	514	"java.lang.UnknownAnnotationValueException",
	515	"java.lang.UnknownElementException",
	516	"java.lang.UnknownEntityException",
	517	"java.lang.UnknownTypeException",
	518	"java.lang.UnmodifiableSetException",
	519	"java.lang.UnsupportedOperationException",
	520	"java.lang.WebServiceException",
	521	"java.lang.WrongMethodTypeException"
	522	);
	523
	524	#java.lang.Object
	525	my %JavaObjectMethod = (
	526
	527	"java/lang/Object.clone:()Ljava/lang/Object;" => 1,
	528	"java/lang/Object.equals:(Ljava/lang/Object;)Z" => 1,
	529	"java/lang/Object.finalize:()V" => 1,
	530	"java/lang/Object.getClass:()Ljava/lang/Class;" => 1,
	531	"java/lang/Object.hashCode:()I" => 1,
	532	"java/lang/Object.notify:()V" => 1,
	533	"java/lang/Object.notifyAll:()V" => 1,
	534	"java/lang/Object.toString:()Ljava/lang/String;" => 1,
	535	"java/lang/Object.wait:()V" => 1,
	536	"java/lang/Object.wait:(J)V" => 1,
	537	"java/lang/Object.wait:(JI)V" => 1
	538	);
	539
[11682]	540	#Global variables
	541	my %Cache;
	542	my %RESULT;
	543	my $TOP_REF = "<a class='top_ref' href='#Top'>to the top</a>";
[10845]	544
[11682]	545	#Types
	546	my %CheckedTypes;
	547
	548	#Classes
	549	my %LibArchives;
	550	my %Class_Methods;
[12872]	551	my %Class_Methods_Generic;
[11682]	552	my %Class_AbstractMethods;
	553	my %Class_Fields;
	554	my %ClassMethod_AddedUsed;
	555	my %Class_Constructed;
	556
[10845]	557	#Methods
	558	my %CheckedMethods;
[11682]	559	my %MethodUsed;
[12872]	560	my %OldMethodSignature;
[10845]	561
	562	#Merging
	563	my %AddedMethod_Abstract;
	564	my %RemovedMethod_Abstract;
	565	my %ChangedReturnFromVoid;
[11682]	566	my %CompatRules;
	567	my %IncompleteRules;
[12872]	568	my %UnknownRules;
[10845]	569
	570	#Report
	571	my %TypeChanges;
	572
	573	#Recursion locks
	574	my @RecurTypes;
	575
	576	#Problem descriptions
	577	my %CompatProblems;
	578	my %TotalAffected;
	579
	580	#Speedup
	581	my %TypeProblemsIndex;
	582
	583	#Rerort
	584	my $ContentID = 1;
	585	my $ContentSpanStart = "<span class=\"section\" onclick=\"sC(this, 'CONTENT_ID')\">\n";
	586	my $ContentSpanStart_Affected = "<span class=\"sect_aff\" onclick=\"sC(this, 'CONTENT_ID')\">\n";
	587	my $ContentSpanEnd = "</span>\n";
	588	my $ContentDivStart = "<div id=\"CONTENT_ID\" style=\"display:none;\">\n";
	589	my $ContentDivEnd = "</div>\n";
	590	my $Content_Counter = 0;
	591
[11682]	592	sub getModules()
[10845]	593	{
[11682]	594	my $TOOL_DIR = dirname($0);
	595	if(not $TOOL_DIR)
	596	{ # patch for MS Windows
	597	$TOOL_DIR = ".";
[10845]	598	}
[11682]	599	my @SEARCH_DIRS = (
	600	# tool's directory
	601	abs_path($TOOL_DIR),
	602	# relative path to modules
	603	abs_path($TOOL_DIR)."/../share/japi-compliance-checker",
	604	# install path
	605	'MODULES_INSTALL_PATH'
	606	);
	607	foreach my $DIR (@SEARCH_DIRS)
[10845]	608	{
[11682]	609	if($DIR!~/\A(\/\|\w+:[\/\\])/)
	610	{ # relative path
	611	$DIR = abs_path($TOOL_DIR)."/".$DIR;
[10845]	612	}
[11682]	613	if(-d $DIR."/modules") {
	614	return $DIR."/modules";
[10845]	615	}
	616	}
[11682]	617
	618	print STDERR "ERROR: can't find modules (Did you installed the tool by 'make install' command?)\n";
	619	exit(9); # Module_Error
[10845]	620	}
	621
[11682]	622	sub loadModule($)
[10845]	623	{
	624	my $Name = $_[0];
[11682]	625	if(defined $LoadedModules{$Name}) {
	626	return;
[10845]	627	}
[11682]	628	my $Path = $MODULES_DIR."/Internals/$Name.pm";
	629	if(not -f $Path)
[10845]	630	{
[11682]	631	print STDERR "can't access \'$Path\'\n";
	632	exit(2);
[10845]	633	}
[11682]	634	require $Path;
	635	$LoadedModules{$Name} = 1;
[10845]	636	}
	637
[11682]	638	sub readModule($$)
[10845]	639	{
[11682]	640	my ($Module, $Name) = @_;
	641	my $Path = $MODULES_DIR."/Internals/$Module/".$Name;
	642	if(not -f $Path) {
	643	exitStatus("Module_Error", "can't access \'$Path\'");
[10845]	644	}
[11682]	645	return readFile($Path);
[10845]	646	}
	647
	648	sub mergeClasses()
	649	{
	650	my %ReportedRemoved = undef;
	651
	652	foreach my $ClassName (keys(%{$Class_Methods{1}}))
	653	{
	654	next if(not $ClassName);
[12872]	655	my $Type1_Id = $TName_Tid{1}{$ClassName};
	656	my $Type1 = getType($Type1_Id, 1);
[10845]	657
[11682]	658	if($Type1->{"Type"}!~/class\|interface/) {
[10845]	659	next;
	660	}
	661
[11682]	662	if(defined $Type1->{"Access"}
	663	and $Type1->{"Access"}=~/private/) {
[10845]	664	next;
	665	}
	666
[12872]	667	if(not classFilter($Type1, 1, 1)) {
[10845]	668	next;
	669	}
	670
[12872]	671	my $GenericName = getGeneric($ClassName);
	672	my $Type2_Id = undef;
	673
	674	if(defined $TName_Tid{2}{$ClassName}) {
	675	$Type2_Id = $TName_Tid{2}{$ClassName};
	676	}
	677	elsif(defined $TName_Tid_Generic{2}{$GenericName}) {
	678	$Type2_Id = $TName_Tid_Generic{2}{$GenericName};
	679	}
	680
	681	if($Type2_Id)
	682	{
	683	my $TName1 = $Type1->{"Name"};
	684	my $TName2 = getTypeName($Type2_Id, 2);
	685
	686	my $Generic1 = (index($TName1, "<")!=-1);
	687	my $Generic2 = (index($TName2, "<")!=-1);
	688
	689	if($Generic1 ne $Generic2)
	690	{ # removed generic parameters
	691	foreach my $Method (keys(%{$Class_Methods{1}{$ClassName}}))
	692	{
	693	if(not methodFilter($Method, 1)) {
	694	next;
	695	}
	696
	697	$CheckedTypes{$ClassName} = 1;
	698	$CheckedMethods{$Method} = 1;
	699
	700	if($Type1->{"Type"} eq "class")
	701	{
	702	if($Generic1)
	703	{
	704	%{$CompatProblems{$Method}{"Class_Became_Raw"}{"this"}} = (
	705	"Type_Name"=>$ClassName,
	706	"New_Value"=>$TName2,
	707	"Target"=>$ClassName);
	708	}
	709	else
	710	{
	711	%{$CompatProblems{$Method}{"Class_Became_Generic"}{"this"}} = (
	712	"Type_Name"=>$ClassName,
	713	"New_Value"=>$TName2,
	714	"Target"=>$ClassName);
	715	}
	716	}
	717	else
	718	{
	719	if($Generic1)
	720	{
	721	%{$CompatProblems{$Method}{"Interface_Became_Raw"}{"this"}} = (
	722	"Type_Name"=>$ClassName,
	723	"New_Value"=>$TName2,
	724	"Target"=>$ClassName);
	725	}
	726	else
	727	{
	728	%{$CompatProblems{$Method}{"Interface_Became_Generic"}{"this"}} = (
	729	"Type_Name"=>$ClassName,
	730	"New_Value"=>$TName2,
	731	"Target"=>$ClassName);
	732	}
	733	}
	734	}
	735	}
	736	}
	737	else
[10845]	738	{ # classes and interfaces with public methods
	739	foreach my $Method (keys(%{$Class_Methods{1}{$ClassName}}))
	740	{
	741	if(not methodFilter($Method, 1)) {
	742	next;
	743	}
	744
	745	$CheckedTypes{$ClassName} = 1;
	746	$CheckedMethods{$Method} = 1;
	747
[11682]	748	if($Type1->{"Type"} eq "class")
[10845]	749	{
	750	%{$CompatProblems{$Method}{"Removed_Class"}{"this"}} = (
	751	"Type_Name"=>$ClassName,
[11682]	752	"Target"=>$ClassName);
[10845]	753	}
	754	else
	755	{
	756	%{$CompatProblems{$Method}{"Removed_Interface"}{"this"}} = (
	757	"Type_Name"=>$ClassName,
[11682]	758	"Target"=>$ClassName);
[10845]	759	}
	760
	761	$ReportedRemoved{$ClassName} = 1;
	762	}
	763	}
	764	}
	765
	766	foreach my $Class_Id (keys(%{$TypeInfo{1}}))
	767	{
[11682]	768	my $Class1 = getType($Class_Id, 1);
[10845]	769
[11682]	770	if($Class1->{"Type"}!~/class\|interface/) {
[10845]	771	next;
	772	}
	773
[11682]	774	if(defined $Class1->{"Access"}
	775	and $Class1->{"Access"}=~/private/) {
[10845]	776	next;
	777	}
	778
[11682]	779	if(not classFilter($Class1, 1, 1)) {
[10845]	780	next;
	781	}
	782
[11682]	783	my $ClassName = $Class1->{"Name"};
[12872]	784	my $GenericName = getGeneric($ClassName);
	785	my $Class2_Id = undef;
[10845]	786
[12872]	787	if(defined $TName_Tid{2}{$ClassName}) {
	788	$Class2_Id = $TName_Tid{2}{$ClassName};
	789	}
	790	elsif(defined $TName_Tid_Generic{2}{$GenericName}) {
	791	$Class2_Id = $TName_Tid_Generic{2}{$GenericName};
	792	}
	793
	794	if($Class2_Id)
[10845]	795	{ # classes and interfaces with public static fields
	796	if(not defined $Class_Methods{1}{$ClassName})
	797	{
[11682]	798	my $Class2 = getType($Class2_Id, 2);
[10845]	799
[11682]	800	foreach my $Field (keys(%{$Class1->{"Fields"}}))
[10845]	801	{
[11682]	802	my $FieldInfo = $Class1->{"Fields"}{$Field};
[10845]	803
	804	my $FAccess = $FieldInfo->{"Access"};
	805	if($FAccess=~/private/) {
	806	next;
	807	}
	808
	809	if($FieldInfo->{"Static"})
	810	{
	811	$CheckedTypes{$ClassName} = 1;
	812
[11682]	813	if(not defined $Class2->{"Fields"}{$Field})
[10845]	814	{
	815	%{$CompatProblems{".client_method"}{"Removed_NonConstant_Field"}{$Field}}=(
	816	"Target"=>$Field,
	817	"Type_Name"=>$ClassName,
[11682]	818	"Type_Type"=>$Class1->{"Type"},
	819	"Field_Type"=>getTypeName($FieldInfo->{"Type"}, 1));
[10845]	820	}
	821	}
	822	}
	823	}
[13595]	824
	825	if(defined $Class1->{"Annotation"})
	826	{
	827	my %AnnParam = ();
	828	foreach my $VN (1, 2)
	829	{
	830	foreach my $Method (keys(%{$Class_Methods{$VN}{$ClassName}}))
	831	{
	832	my $MInfo = $MethodInfo{$VN}{$Method};
	833	$AnnParam{$VN}{$MInfo->{"ShortName"}} = {"Default"=>$MInfo->{"Default"}, "Return"=>getTypeName($MInfo->{"Return"}, $VN)};
	834	}
	835	}
	836	foreach my $AParam (sort keys(%{$AnnParam{1}}))
	837	{
	838	my $R1 = $AnnParam{1}{$AParam}{"Return"};
	839	my $D1 = $AnnParam{1}{$AParam}{"Default"};
	840
	841	if(defined $AnnParam{2}{$AParam})
	842	{
	843	my $R2 = $AnnParam{2}{$AParam}{"Return"};
	844	my $D2 = $AnnParam{2}{$AParam}{"Default"};
	845
	846	if($R1 ne $R2)
	847	{
	848	if($R1 eq "java.lang.String" and $R2 eq "java.lang.String[]")
	849	{
	850	%{$CompatProblems{".client_method"}{"Annotation_Element_Changed_Type_Safe"}{$AParam}} = (
	851	"Type_Name"=>$ClassName,
	852	"Old_Value"=>$R1,
	853	"New_Value"=>$R2,
	854	"Target"=>$AParam);
	855	}
	856	else
	857	{
	858	%{$CompatProblems{".client_method"}{"Annotation_Element_Changed_Type"}{$AParam}} = (
	859	"Type_Name"=>$ClassName,
	860	"Old_Value"=>$R1,
	861	"New_Value"=>$R2,
	862	"Target"=>$AParam);
	863	}
	864	}
	865
	866	if(defined $D1 and not defined $D2)
	867	{
	868	%{$CompatProblems{".client_method"}{"Annotation_Element_Removed_Default_Value"}{$AParam}} = (
	869	"Type_Name"=>$ClassName,
	870	"Old_Value"=>$D1,
	871	"Target"=>$AParam);
	872	}
	873	elsif(not defined $D1 and defined $D2)
	874	{
	875	%{$CompatProblems{".client_method"}{"Annotation_Element_Added_Default_Value"}{$AParam}} = (
	876	"Type_Name"=>$ClassName,
	877	"New_Value"=>$D2,
	878	"Target"=>$AParam);
	879	}
	880	elsif($D1 ne $D2)
	881	{
	882	%{$CompatProblems{".client_method"}{"Annotation_Element_Changed_Default_Value"}{$AParam}} = (
	883	"Type_Name"=>$ClassName,
	884	"Old_Value"=>$D1,
	885	"New_Value"=>$D2,
	886	"Target"=>$AParam);
	887	}
	888	}
	889	else
	890	{
	891	if(defined $D1)
	892	{
	893	%{$CompatProblems{".client_method"}{"Removed_Annotation_Default_Element"}{$AParam}} = (
	894	"Type_Name"=>$ClassName,
	895	"Elem_Type"=>$R1,
	896	"Old_Value"=>$D1,
	897	"Target"=>$AParam);
	898	}
	899	else
	900	{
	901	%{$CompatProblems{".client_method"}{"Removed_Annotation_NonDefault_Element"}{$AParam}} = (
	902	"Type_Name"=>$ClassName,
	903	"Elem_Type"=>$R1,
	904	"Target"=>$AParam);
	905	}
	906	}
	907	}
	908
	909	foreach my $AParam (sort keys(%{$AnnParam{2}}))
	910	{
	911	if(not defined $AnnParam{1}{$AParam})
	912	{
	913	my $R2 = $AnnParam{2}{$AParam}{"Return"};
	914
	915	if(defined $AnnParam{2}{$AParam}{"Default"})
	916	{
	917	my $D2 = $AnnParam{2}{$AParam}{"Default"};
	918	%{$CompatProblems{".client_method"}{"Added_Annotation_Default_Element"}{$AParam}} = (
	919	"Type_Name"=>$ClassName,
	920	"Elem_Type"=>$R2,
	921	"New_Value"=>$D2,
	922	"Target"=>$AParam);
	923	}
	924	else
	925	{
	926	%{$CompatProblems{".client_method"}{"Added_Annotation_NonDefault_Element"}{$AParam}} = (
	927	"Type_Name"=>$ClassName,
	928	"Elem_Type"=>$R2,
	929	"Target"=>$AParam);
	930	}
	931	}
	932	}
	933	}
[10845]	934	}
	935	else
	936	{ # removed
[11682]	937	if(defined $Class1->{"Annotation"})
[10845]	938	{
	939	%{$CompatProblems{".client_method"}{"Removed_Annotation"}{"this"}} = (
	940	"Type_Name"=>$ClassName,
[11682]	941	"Target"=>$ClassName);
[10845]	942	}
	943
	944	if(not defined $Class_Methods{1}{$ClassName})
	945	{
	946	# classes and interfaces with public static fields
	947	if(not defined $ReportedRemoved{$ClassName})
	948	{
[11682]	949	foreach my $Field (keys(%{$Class1->{"Fields"}}))
[10845]	950	{
[11682]	951	my $FieldInfo = $Class1->{"Fields"}{$Field};
[10845]	952
	953	my $FAccess = $FieldInfo->{"Access"};
	954	if($FAccess=~/private/) {
	955	next;
	956	}
	957
	958	if($FieldInfo->{"Static"})
	959	{
	960	$CheckedTypes{$ClassName} = 1;
	961
[11682]	962	if($Class1->{"Type"} eq "class")
[10845]	963	{
	964	%{$CompatProblems{".client_method"}{"Removed_Class"}{"this"}} = (
	965	"Type_Name"=>$ClassName,
[11682]	966	"Target"=>$ClassName);
[10845]	967	}
	968	else
	969	{
	970	%{$CompatProblems{".client_method"}{"Removed_Interface"}{"this"}} = (
	971	"Type_Name"=>$ClassName,
[11682]	972	"Target"=>$ClassName);
[10845]	973	}
	974	}
	975	}
	976	}
	977	}
	978	}
	979	}
	980	}
	981
	982	sub findFieldPair($$)
	983	{
	984	my ($Field_Pos, $Pair_Type) = @_;
	985	foreach my $Pair_Name (sort keys(%{$Pair_Type->{"Fields"}}))
	986	{
	987	if(defined $Pair_Type->{"Fields"}{$Pair_Name})
	988	{
	989	if($Pair_Type->{"Fields"}{$Pair_Name}{"Pos"} eq $Field_Pos) {
	990	return $Pair_Name;
	991	}
	992	}
	993	}
	994	return "lost";
	995	}
	996
	997	my %Severity_Val=(
	998	"High"=>3,
	999	"Medium"=>2,
	1000	"Low"=>1,
	1001	"Safe"=>-1
	1002	);
	1003
	1004	sub isRecurType($$)
	1005	{
	1006	foreach (@RecurTypes)
	1007	{
	1008	if($_->{"Tid1"} eq $_[0]
	1009	and $_->{"Tid2"} eq $_[1])
	1010	{
	1011	return 1;
	1012	}
	1013	}
	1014	return 0;
	1015	}
	1016
	1017	sub pushType($$)
	1018	{
[11682]	1019	my %TypeDescriptor = (
[10845]	1020	"Tid1" => $_[0],
[11682]	1021	"Tid2" => $_[1]);
[10845]	1022	push(@RecurTypes, \%TypeDescriptor);
	1023	}
	1024
[11682]	1025	sub getSFormat($)
[10845]	1026	{
	1027	my $Name = $_[0];
	1028	$Name=~s/\./\//g;
	1029	return $Name;
	1030	}
	1031
[11682]	1032	sub getConstantValue($$)
[10845]	1033	{
	1034	my ($Value, $ValueType) = @_;
[11682]	1035
	1036	if(not defined $Value) {
	1037	return undef;
	1038	}
	1039
[10845]	1040	if($Value eq "\@EMPTY_STRING\@") {
	1041	return "\"\"";
	1042	}
	1043	elsif($ValueType eq "java.lang.String") {
	1044	return "\"".$Value."\"";
	1045	}
[11682]	1046
	1047	return $Value;
[10845]	1048	}
	1049
	1050	sub getInvoked($)
	1051	{
	1052	my $TName = $_[0];
	1053
	1054	if(my @Invoked = sort keys(%{$ClassMethod_AddedUsed{$TName}}))
	1055	{
	1056	my $MFirst = $Invoked[0];
	1057	my $MSignature = unmangle($MFirst);
	1058	$MSignature=~s/\A.+\.(\w+\()/$1/g; # short name
	1059	my $InvokedBy = $ClassMethod_AddedUsed{$TName}{$MFirst};
	1060	return ($MSignature, $InvokedBy);
	1061	}
	1062
	1063	return ();
	1064	}
	1065
	1066	sub mergeTypes($$)
	1067	{
	1068	my ($Type1_Id, $Type2_Id) = @_;
	1069	return {} if(not $Type1_Id or not $Type2_Id);
	1070
	1071	if(defined $Cache{"mergeTypes"}{$Type1_Id}{$Type2_Id})
	1072	{ # already merged
	1073	return $Cache{"mergeTypes"}{$Type1_Id}{$Type2_Id};
	1074	}
	1075
	1076	if(isRecurType($Type1_Id, $Type2_Id))
	1077	{ # do not follow to recursive declarations
	1078	return {};
	1079	}
[11682]	1080
	1081	my %Type1 = %{getType($Type1_Id, 1)};
	1082	my %Type2 = %{getType($Type2_Id, 2)};
	1083
[10845]	1084	return {} if(not $Type1{"Name"} or not $Type2{"Name"});
	1085	return {} if(not $Type1{"Archive"} or not $Type2{"Archive"});
[12872]	1086	if($Type1{"Name"} ne $Type2{"Name"})
	1087	{
	1088	if(getGeneric($Type1{"Name"}) ne getGeneric($Type2{"Name"}))
	1089	{ # compare type declarations if became generic or raw
	1090	return {};
	1091	}
	1092	}
[10845]	1093
[12872]	1094	if(not classFilter(\%Type1, 1, 1)) {
[10845]	1095	return {};
	1096	}
	1097
	1098	$CheckedTypes{$Type1{"Name"}} = 1;
	1099
	1100	my %SubProblems = ();
	1101
	1102	if($Type1{"BaseType"} and $Type2{"BaseType"})
	1103	{ # check base type (arrays)
	1104	return mergeTypes($Type1{"BaseType"}, $Type2{"BaseType"});
	1105	}
	1106
	1107	if($Type2{"Type"}!~/(class\|interface)/) {
	1108	return {};
	1109	}
	1110
	1111	if($Type1{"Type"} eq "class" and not $Class_Constructed{1}{$Type1_Id})
	1112	{ # class cannot be constructed or inherited by clients
	1113	return {};
	1114	}
	1115
	1116	if($Type1{"Type"} eq "class"
	1117	and $Type2{"Type"} eq "interface")
	1118	{
	1119	%{$SubProblems{"Class_Became_Interface"}{""}}=(
[11682]	1120	"Type_Name"=>$Type1{"Name"});
[10845]	1121
	1122	return ($Cache{"mergeTypes"}{$Type1_Id}{$Type2_Id} = \%SubProblems);
	1123	}
	1124	if($Type1{"Type"} eq "interface"
	1125	and $Type2{"Type"} eq "class")
	1126	{
	1127	%{$SubProblems{"Interface_Became_Class"}{""}}=(
[11682]	1128	"Type_Name"=>$Type1{"Name"});
[10845]	1129
	1130	return ($Cache{"mergeTypes"}{$Type1_Id}{$Type2_Id} = \%SubProblems);
	1131	}
	1132	if(not $Type1{"Final"}
	1133	and $Type2{"Final"})
	1134	{
	1135	%{$SubProblems{"Class_Became_Final"}{""}}=(
	1136	"Type_Name"=>$Type1{"Name"},
[11682]	1137	"Target"=>$Type1{"Name"});
[10845]	1138	}
	1139	if(not $Type1{"Abstract"}
	1140	and $Type2{"Abstract"})
	1141	{
	1142	%{$SubProblems{"Class_Became_Abstract"}{""}}=(
[11682]	1143	"Type_Name"=>$Type1{"Name"});
[10845]	1144	}
	1145
	1146	pushType($Type1_Id, $Type2_Id);
	1147
[12872]	1148	foreach my $AddedMethod (keys(%{$AddedMethod_Abstract{$Type2{"Name"}}}))
[10845]	1149	{
	1150	if($Type1{"Type"} eq "class")
	1151	{
	1152	if($Type1{"Abstract"})
	1153	{
	1154	if(my @InvokedBy = sort keys(%{$MethodUsed{2}{$AddedMethod}}))
	1155	{
[11682]	1156	%{$SubProblems{"Abstract_Class_Added_Abstract_Method_Invoked_By_Others"}{getSFormat($AddedMethod)}} = (
[10845]	1157	"Type_Name"=>$Type1{"Name"},
	1158	"Type_Type"=>$Type1{"Type"},
	1159	"Target"=>$AddedMethod,
[11682]	1160	"Invoked_By"=>$InvokedBy[0]);
[10845]	1161	}
	1162	else
	1163	{
[11682]	1164	%{$SubProblems{"Abstract_Class_Added_Abstract_Method"}{getSFormat($AddedMethod)}} = (
[10845]	1165	"Type_Name"=>$Type1{"Name"},
	1166	"Type_Type"=>$Type1{"Type"},
[11682]	1167	"Target"=>$AddedMethod);
[10845]	1168	}
	1169	}
	1170	else
	1171	{
[11682]	1172	%{$SubProblems{"NonAbstract_Class_Added_Abstract_Method"}{getSFormat($AddedMethod)}} = (
[10845]	1173	"Type_Name"=>$Type1{"Name"},
	1174	"Type_Type"=>$Type1{"Type"},
[11682]	1175	"Target"=>$AddedMethod);
[10845]	1176	}
	1177	}
	1178	else
	1179	{
[13595]	1180	if(nonImplClass(\%Type1))
[10845]	1181	{
[13595]	1182	%{$SubProblems{"NonImpl_Interface_Added_Abstract_Method"}{getSFormat($AddedMethod)}} = (
	1183	"Type_Name"=>$Type1{"Name"},
	1184	"Type_Type"=>$Type1{"Type"},
	1185	"Target"=>$AddedMethod);
	1186	}
	1187	elsif(my @InvokedBy = sort keys(%{$MethodUsed{2}{$AddedMethod}}))
	1188	{
[11682]	1189	%{$SubProblems{"Interface_Added_Abstract_Method_Invoked_By_Others"}{getSFormat($AddedMethod)}} = (
[10845]	1190	"Type_Name"=>$Type1{"Name"},
	1191	"Type_Type"=>$Type1{"Type"},
	1192	"Target"=>$AddedMethod,
[11682]	1193	"Invoked_By"=>$InvokedBy[0]);
[10845]	1194	}
	1195	else
	1196	{
[11682]	1197	%{$SubProblems{"Interface_Added_Abstract_Method"}{getSFormat($AddedMethod)}} = (
[10845]	1198	"Type_Name"=>$Type1{"Name"},
	1199	"Type_Type"=>$Type1{"Type"},
[11682]	1200	"Target"=>$AddedMethod);
[10845]	1201	}
	1202	}
	1203	}
	1204	foreach my $RemovedMethod (keys(%{$RemovedMethod_Abstract{$Type1{"Name"}}}))
	1205	{
	1206	if($Type1{"Type"} eq "class")
	1207	{
[11682]	1208	%{$SubProblems{"Class_Removed_Abstract_Method"}{getSFormat($RemovedMethod)}} = (
[10845]	1209	"Type_Name"=>$Type1{"Name"},
	1210	"Type_Type"=>$Type1{"Type"},
[11682]	1211	"Target"=>$RemovedMethod);
[10845]	1212	}
	1213	else
	1214	{
[11682]	1215	%{$SubProblems{"Interface_Removed_Abstract_Method"}{getSFormat($RemovedMethod)}} = (
[10845]	1216	"Type_Name"=>$Type1{"Name"},
	1217	"Type_Type"=>$Type1{"Type"},
[11682]	1218	"Target"=>$RemovedMethod);
[10845]	1219	}
	1220	}
	1221	if($Type1{"Type"} eq "class"
	1222	and $Type2{"Type"} eq "class")
	1223	{
[11682]	1224	my $SuperClass1 = getType($Type1{"SuperClass"}, 1);
	1225	my $SuperClass2 = getType($Type2{"SuperClass"}, 2);
	1226
	1227	my $SuperClassName1 = $SuperClass1->{"Name"};
	1228	my $SuperClassName2 = $SuperClass2->{"Name"};
	1229
[12872]	1230	# Java 6: java.lang.Object
	1231	# Java 7: none
	1232	if(not $SuperClassName1) {
	1233	$SuperClassName1 = "java.lang.Object";
	1234	}
	1235
	1236	if(not $SuperClassName2) {
	1237	$SuperClassName2 = "java.lang.Object";
	1238	}
	1239
[11682]	1240	if($SuperClassName2 ne $SuperClassName1)
[10845]	1241	{
[12872]	1242	if($SuperClassName1 eq "java.lang.Object")
[10845]	1243	{
[12872]	1244	if($SuperClass2->{"Abstract"}
	1245	and $Type1{"Abstract"} and $Type2{"Abstract"}
	1246	and keys(%{$Class_AbstractMethods{2}{$SuperClassName2}}))
[10845]	1247	{
[12872]	1248	if(my ($Invoked, $InvokedBy) = getInvoked($Type1{"Name"}))
[10845]	1249	{
[12872]	1250	%{$SubProblems{"Abstract_Class_Added_Super_Abstract_Class_Invoked_By_Others"}{""}} = (
	1251	"Type_Name"=>$Type1{"Name"},
	1252	"Target"=>$SuperClassName2,
	1253	"Invoked"=>$Invoked,
	1254	"Invoked_By"=>$InvokedBy);
[10845]	1255	}
	1256	else
	1257	{
[12872]	1258	%{$SubProblems{"Abstract_Class_Added_Super_Abstract_Class"}{""}} = (
[10845]	1259	"Type_Name"=>$Type1{"Name"},
[11682]	1260	"Target"=>$SuperClassName2);
[10845]	1261	}
	1262	}
[12872]	1263	else
[10845]	1264	{
[12872]	1265	%{$SubProblems{"Added_Super_Class"}{""}} = (
[10845]	1266	"Type_Name"=>$Type1{"Name"},
[12872]	1267	"Target"=>$SuperClassName2);
[10845]	1268	}
	1269	}
[12872]	1270	elsif($SuperClassName2 eq "java.lang.Object")
	1271	{
	1272	%{$SubProblems{"Removed_Super_Class"}{""}} = (
	1273	"Type_Name"=>$Type1{"Name"},
	1274	"Target"=>$SuperClassName1);
	1275	}
[10845]	1276	else
	1277	{
	1278	%{$SubProblems{"Changed_Super_Class"}{""}} = (
	1279	"Type_Name"=>$Type1{"Name"},
[11682]	1280	"Target"=>$SuperClassName1,
	1281	"Old_Value"=>$SuperClassName1,
	1282	"New_Value"=>$SuperClassName2);
[10845]	1283	}
	1284	}
	1285	}
[11682]	1286	my %SuperInterfaces_Old = map {getTypeName($_, 1) => 1} keys(%{$Type1{"SuperInterface"}});
	1287	my %SuperInterfaces_New = map {getTypeName($_, 2) => 1} keys(%{$Type2{"SuperInterface"}});
[10845]	1288	foreach my $SuperInterface (keys(%SuperInterfaces_New))
	1289	{
	1290	if(not $SuperInterfaces_Old{$SuperInterface})
	1291	{
	1292	my $HaveMethods = keys(%{$Class_AbstractMethods{2}{$SuperInterface}});
	1293	my $HaveFields = keys(%{$Class_Fields{2}{$SuperInterface}});
	1294
	1295	if($Type1{"Type"} eq "interface")
	1296	{
	1297	if($HaveMethods
	1298	or $SuperInterface=~/\Ajava\./)
	1299	{
	1300	if($HaveMethods and checkDefaultImpl(2, $SuperInterface, $Type2{"Name"}))
	1301	{
[11682]	1302	%{$SubProblems{"Interface_Added_Super_Interface_With_Implemented_Methods"}{getSFormat($SuperInterface)}} = (
[10845]	1303	"Type_Name"=>$Type1{"Name"},
[11682]	1304	"Target"=>$SuperInterface);
[10845]	1305	}
	1306	else
	1307	{
	1308	if(my ($Invoked, $InvokedBy) = getInvoked($Type1{"Name"}))
	1309	{
[11682]	1310	%{$SubProblems{"Interface_Added_Super_Interface_Used_By_Others"}{getSFormat($SuperInterface)}} = (
[10845]	1311	"Type_Name"=>$Type1{"Name"},
	1312	"Target"=>$SuperInterface,
	1313	"Invoked"=>$Invoked,
[11682]	1314	"Invoked_By"=>$InvokedBy);
[10845]	1315	}
	1316	else
	1317	{
[11682]	1318	%{$SubProblems{"Interface_Added_Super_Interface"}{getSFormat($SuperInterface)}} = (
[10845]	1319	"Type_Name"=>$Type1{"Name"},
[11682]	1320	"Target"=>$SuperInterface);
[10845]	1321	}
	1322	}
	1323	}
	1324	elsif($HaveFields)
	1325	{
[11682]	1326	%{$SubProblems{"Interface_Added_Super_Constant_Interface"}{getSFormat($SuperInterface)}} = (
[10845]	1327	"Type_Name"=>$Type2{"Name"},
[11682]	1328	"Target"=>$SuperInterface);
[10845]	1329	}
	1330	else
	1331	{
	1332	# empty interface
	1333	}
	1334	}
	1335	else
	1336	{
	1337	if($Type1{"Abstract"} and $Type2{"Abstract"})
	1338	{
	1339	if($HaveMethods and checkDefaultImpl(2, $SuperInterface, $Type2{"Name"}))
	1340	{
[11682]	1341	%{$SubProblems{"Abstract_Class_Added_Super_Interface_With_Implemented_Methods"}{getSFormat($SuperInterface)}} = (
[10845]	1342	"Type_Name"=>$Type1{"Name"},
[11682]	1343	"Target"=>$SuperInterface);
[10845]	1344	}
	1345	else
	1346	{
	1347	if(my ($Invoked, $InvokedBy) = getInvoked($Type1{"Name"}))
	1348	{
[11682]	1349	%{$SubProblems{"Abstract_Class_Added_Super_Interface_Invoked_By_Others"}{getSFormat($SuperInterface)}} = (
[10845]	1350	"Type_Name"=>$Type1{"Name"},
	1351	"Target"=>$SuperInterface,
	1352	"Invoked"=>$Invoked,
[11682]	1353	"Invoked_By"=>$InvokedBy);
[10845]	1354	}
	1355	else
	1356	{
[11682]	1357	%{$SubProblems{"Abstract_Class_Added_Super_Interface"}{getSFormat($SuperInterface)}} = (
[10845]	1358	"Type_Name"=>$Type1{"Name"},
[11682]	1359	"Target"=>$SuperInterface);
[10845]	1360	}
	1361	}
	1362	}
	1363	}
	1364	}
	1365	}
	1366	foreach my $SuperInterface (keys(%SuperInterfaces_Old))
	1367	{
	1368	if(not $SuperInterfaces_New{$SuperInterface})
	1369	{
	1370	my $HaveMethods = keys(%{$Class_AbstractMethods{1}{$SuperInterface}});
	1371	my $HaveFields = keys(%{$Class_Fields{1}{$SuperInterface}});
	1372
	1373	if($Type1{"Type"} eq "interface")
	1374	{
	1375	if($HaveMethods
	1376	or $SuperInterface=~/\Ajava\./)
	1377	{
[11682]	1378	%{$SubProblems{"Interface_Removed_Super_Interface"}{getSFormat($SuperInterface)}} = (
[10845]	1379	"Type_Name"=>$Type1{"Name"},
	1380	"Type_Type"=>"interface",
[11682]	1381	"Target"=>$SuperInterface);
[10845]	1382	}
	1383	elsif($HaveFields)
	1384	{
[11682]	1385	%{$SubProblems{"Interface_Removed_Super_Constant_Interface"}{getSFormat($SuperInterface)}} = (
[10845]	1386	"Type_Name"=>$Type1{"Name"},
[11682]	1387	"Target"=>$SuperInterface);
[10845]	1388	}
	1389	else {
	1390	# empty interface
	1391	}
	1392	}
	1393	else
	1394	{
[11682]	1395	%{$SubProblems{"Class_Removed_Super_Interface"}{getSFormat($SuperInterface)}} = (
[10845]	1396	"Type_Name"=>$Type1{"Name"},
	1397	"Type_Type"=>"class",
[11682]	1398	"Target"=>$SuperInterface);
[10845]	1399	}
	1400	}
	1401	}
	1402
	1403	foreach my $Field_Name (sort keys(%{$Type1{"Fields"}}))
	1404	{# check older fields
	1405	my $Access1 = $Type1{"Fields"}{$Field_Name}{"Access"};
	1406	if($Access1=~/private/) {
	1407	next;
	1408	}
	1409
	1410	my $Field_Pos1 = $Type1{"Fields"}{$Field_Name}{"Pos"};
	1411	my $FieldType1_Id = $Type1{"Fields"}{$Field_Name}{"Type"};
[11682]	1412	my $FieldType1_Name = getTypeName($FieldType1_Id, 1);
[10845]	1413
	1414	if(not $Type2{"Fields"}{$Field_Name})
	1415	{# removed fields
	1416	my $StraightPair_Name = findFieldPair($Field_Pos1, \%Type2);
	1417	if($StraightPair_Name ne "lost" and not $Type1{"Fields"}{$StraightPair_Name}
[11682]	1418	and $FieldType1_Name eq getTypeName($Type2{"Fields"}{$StraightPair_Name}{"Type"}, 2))
[10845]	1419	{
[11682]	1420	if(my $Constant = getConstantValue($Type1{"Fields"}{$Field_Name}{"Value"}, $FieldType1_Name))
[10845]	1421	{
	1422	%{$SubProblems{"Renamed_Constant_Field"}{$Field_Name}}=(
	1423	"Target"=>$Field_Name,
	1424	"Type_Name"=>$Type1{"Name"},
	1425	"Old_Value"=>$Field_Name,
	1426	"New_Value"=>$StraightPair_Name,
[11682]	1427	"Field_Type"=>$FieldType1_Name,
	1428	"Field_Value"=>$Constant);
[10845]	1429	}
	1430	else
	1431	{
	1432	%{$SubProblems{"Renamed_Field"}{$Field_Name}}=(
	1433	"Target"=>$Field_Name,
	1434	"Type_Name"=>$Type1{"Name"},
	1435	"Old_Value"=>$Field_Name,
	1436	"New_Value"=>$StraightPair_Name,
[11682]	1437	"Field_Type"=>$FieldType1_Name);
[10845]	1438	}
	1439	}
	1440	else
	1441	{
[11682]	1442	if(my $Constant = getConstantValue($Type1{"Fields"}{$Field_Name}{"Value"}, $FieldType1_Name))
[10845]	1443	{ # has a compile-time constant value
	1444	%{$SubProblems{"Removed_Constant_Field"}{$Field_Name}}=(
	1445	"Target"=>$Field_Name,
	1446	"Type_Name"=>$Type1{"Name"},
	1447	"Field_Value"=>$Constant,
[11682]	1448	"Field_Type"=>$FieldType1_Name,
	1449	"Type_Type"=>$Type1{"Type"});
[10845]	1450	}
	1451	else
	1452	{
	1453	%{$SubProblems{"Removed_NonConstant_Field"}{$Field_Name}}=(
	1454	"Target"=>$Field_Name,
	1455	"Type_Name"=>$Type1{"Name"},
	1456	"Type_Type"=>$Type1{"Type"},
[11682]	1457	"Field_Type"=>$FieldType1_Name);
[10845]	1458	}
	1459	}
	1460	next;
	1461	}
[11682]	1462
[10845]	1463	my $FieldType2_Id = $Type2{"Fields"}{$Field_Name}{"Type"};
[11682]	1464	my $FieldType2_Name = getTypeName($FieldType2_Id, 2);
[10845]	1465
	1466	if(not $Type1{"Fields"}{$Field_Name}{"Static"}
	1467	and $Type2{"Fields"}{$Field_Name}{"Static"})
	1468	{
	1469	if(not $Type1{"Fields"}{$Field_Name}{"Value"})
	1470	{
	1471	%{$SubProblems{"NonConstant_Field_Became_Static"}{$Field_Name}}=(
	1472	"Target"=>$Field_Name,
[11682]	1473	"Field_Type"=>$FieldType1_Name,
	1474	"Type_Name"=>$Type1{"Name"});
[10845]	1475	}
	1476	}
	1477	elsif($Type1{"Fields"}{$Field_Name}{"Static"}
	1478	and not $Type2{"Fields"}{$Field_Name}{"Static"})
	1479	{
	1480	if($Type1{"Fields"}{$Field_Name}{"Value"})
	1481	{
	1482	%{$SubProblems{"Constant_Field_Became_NonStatic"}{$Field_Name}}=(
	1483	"Target"=>$Field_Name,
[11682]	1484	"Field_Type"=>$FieldType1_Name,
	1485	"Type_Name"=>$Type1{"Name"});
[10845]	1486	}
	1487	else
	1488	{
	1489	%{$SubProblems{"NonConstant_Field_Became_NonStatic"}{$Field_Name}}=(
	1490	"Target"=>$Field_Name,
[11682]	1491	"Field_Type"=>$FieldType1_Name,
	1492	"Type_Name"=>$Type1{"Name"});
[10845]	1493	}
	1494	}
	1495	if(not $Type1{"Fields"}{$Field_Name}{"Final"}
	1496	and $Type2{"Fields"}{$Field_Name}{"Final"})
	1497	{
	1498	%{$SubProblems{"Field_Became_Final"}{$Field_Name}}=(
	1499	"Target"=>$Field_Name,
[11682]	1500	"Field_Type"=>$FieldType1_Name,
	1501	"Type_Name"=>$Type1{"Name"});
[10845]	1502	}
	1503	elsif($Type1{"Fields"}{$Field_Name}{"Final"}
	1504	and not $Type2{"Fields"}{$Field_Name}{"Final"})
	1505	{
	1506	%{$SubProblems{"Field_Became_NonFinal"}{$Field_Name}}=(
	1507	"Target"=>$Field_Name,
[11682]	1508	"Field_Type"=>$FieldType1_Name,
	1509	"Type_Name"=>$Type1{"Name"});
[10845]	1510	}
	1511	my $Access2 = $Type2{"Fields"}{$Field_Name}{"Access"};
	1512	if($Access1 eq "public" and $Access2=~/protected\|private/
	1513	or $Access1 eq "protected" and $Access2=~/private/)
	1514	{
[11682]	1515	if($Access2 eq "package-private")
	1516	{
	1517	%{$SubProblems{"Changed_Field_Access_To_Package_Private"}{$Field_Name}}=(
	1518	"Target"=>$Field_Name,
	1519	"Type_Name"=>$Type1{"Name"},
	1520	"Old_Value"=>$Access1,
	1521	"New_Value"=>$Access2);
	1522	}
	1523	else
	1524	{
	1525	%{$SubProblems{"Changed_Field_Access"}{$Field_Name}}=(
	1526	"Target"=>$Field_Name,
	1527	"Type_Name"=>$Type1{"Name"},
	1528	"Old_Value"=>$Access1,
	1529	"New_Value"=>$Access2);
	1530	}
[10845]	1531	}
	1532
[11682]	1533	my $Value1 = getConstantValue($Type1{"Fields"}{$Field_Name}{"Value"}, $FieldType1_Name);
	1534	my $Value2 = getConstantValue($Type2{"Fields"}{$Field_Name}{"Value"}, $FieldType2_Name);
[10845]	1535
	1536	if($Value1 ne $Value2)
	1537	{
	1538	if($Value1 and $Value2)
	1539	{
	1540	if($Type1{"Fields"}{$Field_Name}{"Final"}
	1541	and $Type2{"Fields"}{$Field_Name}{"Final"})
	1542	{
	1543	if($Field_Name=~/(\A\|_)(VERSION\|VERNUM\|BUILDNUMBER\|BUILD)(_\|\Z)/i)
	1544	{
	1545	%{$SubProblems{"Changed_Final_Version_Field_Value"}{$Field_Name}}=(
	1546	"Target"=>$Field_Name,
[11682]	1547	"Field_Type"=>$FieldType1_Name,
[10845]	1548	"Type_Name"=>$Type1{"Name"},
	1549	"Old_Value"=>$Value1,
[11682]	1550	"New_Value"=>$Value2);
[10845]	1551	}
	1552	else
	1553	{
	1554	%{$SubProblems{"Changed_Final_Field_Value"}{$Field_Name}}=(
	1555	"Target"=>$Field_Name,
[11682]	1556	"Field_Type"=>$FieldType1_Name,
[10845]	1557	"Type_Name"=>$Type1{"Name"},
	1558	"Old_Value"=>$Value1,
[11682]	1559	"New_Value"=>$Value2);
[10845]	1560	}
	1561	}
	1562	}
	1563	}
	1564
[12872]	1565	my %Sub_SubChanges = detectTypeChange(\%Type1, \%Type2, $FieldType1_Id, $FieldType2_Id, "Field");
[10845]	1566	foreach my $Sub_SubProblemType (keys(%Sub_SubChanges))
	1567	{
	1568	%{$SubProblems{$Sub_SubProblemType}{$Field_Name}}=(
	1569	"Target"=>$Field_Name,
	1570	"Type_Name"=>$Type1{"Name"});
	1571
	1572	foreach my $Attr (keys(%{$Sub_SubChanges{$Sub_SubProblemType}}))
	1573	{
	1574	$SubProblems{$Sub_SubProblemType}{$Field_Name}{$Attr} = $Sub_SubChanges{$Sub_SubProblemType}{$Attr};
	1575	}
	1576	}
	1577
	1578	if($FieldType1_Id and $FieldType2_Id)
	1579	{ # check field type change
	1580	my $Sub_SubProblems = mergeTypes($FieldType1_Id, $FieldType2_Id);
	1581	my %DupProblems = ();
	1582
	1583	foreach my $Sub_SubProblemType (sort keys(%{$Sub_SubProblems}))
	1584	{
	1585	foreach my $Sub_SubLocation (sort {length($a)<=>length($b)} sort keys(%{$Sub_SubProblems->{$Sub_SubProblemType}}))
	1586	{
[11682]	1587	if(not defined $In::Opt{"AllAffected"})
[10845]	1588	{
	1589	if(defined $DupProblems{$Sub_SubProblems->{$Sub_SubProblemType}{$Sub_SubLocation}}) {
	1590	next;
	1591	}
	1592	}
	1593
	1594	my $NewLocation = ($Sub_SubLocation)?$Field_Name.".".$Sub_SubLocation:$Field_Name;
	1595	$SubProblems{$Sub_SubProblemType}{$NewLocation} = $Sub_SubProblems->{$Sub_SubProblemType}{$Sub_SubLocation};
	1596
[11682]	1597	if(not defined $In::Opt{"AllAffected"})
[10845]	1598	{
	1599	$DupProblems{$Sub_SubProblems->{$Sub_SubProblemType}{$Sub_SubLocation}} = 1;
	1600	}
	1601	}
	1602	}
	1603	%DupProblems = ();
	1604	}
	1605	}
	1606
	1607	foreach my $Field_Name (sort keys(%{$Type2{"Fields"}}))
	1608	{ # check added fields
	1609	if($Type2{"Fields"}{$Field_Name}{"Access"}=~/private/) {
	1610	next;
	1611	}
	1612	my $FieldPos2 = $Type2{"Fields"}{$Field_Name}{"Pos"};
	1613	my $FieldType2_Id = $Type2{"Fields"}{$Field_Name}{"Type"};
[11682]	1614	my $FieldType2_Name = getTypeName($FieldType2_Id, 2);
[10845]	1615
	1616	if(not $Type1{"Fields"}{$Field_Name})
	1617	{# added fields
	1618	my $StraightPair_Name = findFieldPair($FieldPos2, \%Type1);
	1619	if($StraightPair_Name ne "lost" and not $Type2{"Fields"}{$StraightPair_Name}
[11682]	1620	and getTypeName($Type1{"Fields"}{$StraightPair_Name}{"Type"}, 1) eq $FieldType2_Name)
[10845]	1621	{
	1622	# Already reported as "Renamed_Field" or "Renamed_Constant_Field"
	1623	}
	1624	else
	1625	{
	1626	if($Type1{"Type"} eq "interface")
	1627	{
	1628	%{$SubProblems{"Interface_Added_Field"}{$Field_Name}}=(
	1629	"Target"=>$Field_Name,
[11682]	1630	"Type_Name"=>$Type1{"Name"});
[10845]	1631	}
	1632	else
	1633	{
	1634	%{$SubProblems{"Class_Added_Field"}{$Field_Name}}=(
	1635	"Target"=>$Field_Name,
[11682]	1636	"Type_Name"=>$Type1{"Name"});
[10845]	1637	}
	1638	}
	1639	}
	1640	}
	1641
	1642	pop(@RecurTypes);
	1643	return ($Cache{"mergeTypes"}{$Type1_Id}{$Type2_Id} = \%SubProblems);
	1644	}
	1645
	1646	sub checkDefaultImpl($$$)
	1647	{ # Check if all abstract methods of the super class have
	1648	# default implementations in the class
[11682]	1649	my ($LVer, $SuperClassName, $ClassName) = @_;
[10845]	1650
[11682]	1651	foreach my $Method (keys(%{$Class_AbstractMethods{$LVer}{$SuperClassName}}))
[10845]	1652	{
[11682]	1653	if(my $Overridden = findMethod_Class($Method, $ClassName, $LVer))
[10845]	1654	{
[11682]	1655	if($MethodInfo{$LVer}{$Overridden}{"Abstract"}) {
[10845]	1656	return 0;
	1657	}
	1658	}
	1659	else {
	1660	return 0;
	1661	}
	1662	}
	1663
	1664	return 1;
	1665	}
	1666
[11682]	1667	sub getMSuffix($)
[10845]	1668	{
	1669	my $Method = $_[0];
	1670	if($Method=~/($.*$)/) {
	1671	return $1;
	1672	}
	1673	return "";
	1674	}
	1675
[11682]	1676	sub getMShort($)
[10845]	1677	{
	1678	my $Method = $_[0];
	1679	if($Method=~/([^\.]+)\:\(/) {
	1680	return $1;
	1681	}
	1682	return "";
	1683	}
	1684
	1685	sub findMethod($$$$)
	1686	{
	1687	my ($Method, $MethodVersion, $ClassName, $ClassVersion) = @_;
	1688
[12872]	1689	my $GenericName = getGeneric($ClassName);
	1690	my $ClassId = undef;
	1691
	1692	if(defined $TName_Tid{$ClassVersion}{$ClassName}) {
	1693	$ClassId = $TName_Tid{$ClassVersion}{$ClassName};
	1694	}
	1695	elsif(defined $TName_Tid_Generic{$ClassVersion}{$GenericName}) {
	1696	$ClassId = $TName_Tid_Generic{$ClassVersion}{$GenericName};
	1697	}
	1698
[10845]	1699	if($ClassId)
	1700	{
	1701	my @Search = ();
[11682]	1702	if(getTypeType($ClassId, $ClassVersion) eq "class")
[10845]	1703	{
	1704	if(my $SuperClassId = $TypeInfo{$ClassVersion}{$ClassId}{"SuperClass"}) {
	1705	push(@Search, $SuperClassId);
	1706	}
	1707	}
	1708
	1709	if(not defined $MethodInfo{$MethodVersion}{$Method}
	1710	or $MethodInfo{$MethodVersion}{$Method}{"Abstract"})
	1711	{
	1712	if(my @SuperInterfaces = sort keys(%{$TypeInfo{$ClassVersion}{$ClassId}{"SuperInterface"}})) {
	1713	push(@Search, @SuperInterfaces);
	1714	}
	1715	}
	1716
	1717	foreach my $SuperId (@Search)
	1718	{
	1719	if($SuperId eq $ClassId) {
	1720	next;
	1721	}
	1722
[11682]	1723	my $SuperName = getTypeName($SuperId, $ClassVersion);
[10845]	1724
	1725	if(my $MethodInClass = findMethod_Class($Method, $SuperName, $ClassVersion)) {
	1726	return $MethodInClass;
	1727	}
	1728	elsif(my $MethodInSuperClasses = findMethod($Method, $MethodVersion, $SuperName, $ClassVersion)) {
	1729	return $MethodInSuperClasses;
	1730	}
	1731	}
	1732	}
	1733
[11682]	1734	my $TargetSuffix = getMSuffix($Method);
	1735	my $TargetShortName = getMShort($Method);
[10845]	1736
	1737	# search in java.lang.Object
	1738	foreach my $C (keys(%JavaObjectMethod))
	1739	{
[11682]	1740	if($TargetSuffix eq getMSuffix($C))
[10845]	1741	{
[11682]	1742	if($TargetShortName eq getMShort($C)) {
[10845]	1743	return $C;
	1744	}
	1745	}
	1746	}
	1747
	1748	return undef;
	1749	}
	1750
	1751	sub findMethod_Class($$$)
	1752	{
	1753	my ($Method, $ClassName, $ClassVersion) = @_;
[12872]	1754
[11682]	1755	my $TargetSuffix = getMSuffix($Method);
	1756	my $TargetShortName = getMShort($Method);
[12872]	1757	my $GenericName = getGeneric($ClassName);
[10845]	1758
[12872]	1759	my @Candidates = ();
	1760
	1761	if(defined $Class_Methods{$ClassVersion}{$ClassName}) {
	1762	@Candidates = keys(%{$Class_Methods{$ClassVersion}{$ClassName}});
	1763	}
	1764	elsif(defined $Class_Methods_Generic{$ClassVersion}{$GenericName}) {
	1765	@Candidates = keys(%{$Class_Methods_Generic{$ClassVersion}{$GenericName}});
	1766	}
	1767	else {
[10845]	1768	return undef;
	1769	}
	1770
[12872]	1771	foreach my $Candidate (sort @Candidates)
[10845]	1772	{ # search for method with the same parameters suffix
	1773	next if($MethodInfo{$ClassVersion}{$Candidate}{"Constructor"});
[12872]	1774
[11682]	1775	if($TargetSuffix eq getMSuffix($Candidate))
[10845]	1776	{
[11682]	1777	if($TargetShortName eq getMShort($Candidate)) {
[10845]	1778	return $Candidate;
	1779	}
	1780	}
	1781	}
	1782
	1783	return undef;
	1784	}
	1785
[12872]	1786	sub getBaseSignature($)
	1787	{
	1788	my $Method = $_[0];
	1789	$Method=~s/\)(.+)\Z/\)/g;
	1790	return $Method;
	1791	}
	1792
[11682]	1793	sub prepareData($)
[10845]	1794	{
[11682]	1795	my $LVer = $_[0];
	1796
	1797	if(my $MUsed = $In::API{$LVer}{"MethodUsed"})
[10845]	1798	{
[11682]	1799	foreach my $M_Id (keys(%{$MUsed}))
[10845]	1800	{
[11682]	1801	my $Name = $MUsed->{$M_Id}{"Name"};
	1802	$MethodUsed{$LVer}{$Name} = $MUsed->{$M_Id}{"Used"};
	1803	}
	1804	}
	1805
	1806	foreach my $TypeId (keys(%{$TypeInfo{$LVer}}))
	1807	{
	1808	my $TypeAttr = $TypeInfo{$LVer}{$TypeId};
	1809	my $TName = $TypeAttr->{"Name"};
	1810
	1811	$TName_Tid{$LVer}{$TName} = $TypeId;
	1812
[12872]	1813	if(defined $TypeAttr->{"Archive"})
	1814	{ # declaration
	1815	$TName_Tid_Generic{$LVer}{getGeneric($TName)} = $TypeId;
	1816	}
	1817
[11682]	1818	if(not $TypeAttr->{"Dep"})
	1819	{
	1820	if(my $Archive = $TypeAttr->{"Archive"}) {
	1821	$LibArchives{$LVer}{$Archive} = 1;
[10845]	1822	}
[11682]	1823	}
	1824
	1825	foreach my $FieldName (keys(%{$TypeAttr->{"Fields"}}))
	1826	{
	1827	if($TypeAttr->{"Fields"}{$FieldName}{"Access"}=~/public\|protected/) {
	1828	$Class_Fields{$LVer}{$TName}{$FieldName} = $TypeAttr->{"Fields"}{$FieldName}{"Type"};
	1829	}
	1830	}
	1831	}
	1832
	1833	foreach my $Method (keys(%{$MethodInfo{$LVer}}))
	1834	{
	1835	my $Name = $MethodInfo{$LVer}{$Method}{"Name"};
	1836	$MethodInfo{$LVer}{$Name} = delete($MethodInfo{$LVer}{$Method});
	1837	}
	1838
	1839	foreach my $Method (keys(%{$MethodInfo{$LVer}}))
	1840	{
	1841	my $MAttr = $MethodInfo{$LVer}{$Method};
	1842
	1843	$MAttr->{"Signature"} = getSignature($Method, $LVer, "Full");
	1844
	1845	if(my $ClassId = $MAttr->{"Class"}
	1846	and $MAttr->{"Access"}=~/public\|protected/)
	1847	{
	1848	my $CName = getTypeName($ClassId, $LVer);
	1849	$Class_Methods{$LVer}{$CName}{$Method} = 1;
[12872]	1850	$Class_Methods_Generic{$LVer}{getGeneric($CName)}{$Method} = 1;
	1851
[11682]	1852	if($MAttr->{"Abstract"}) {
	1853	$Class_AbstractMethods{$LVer}{$CName}{$Method} = 1;
	1854	}
	1855	}
	1856
	1857	if($MAttr->{"Access"}!~/private/)
	1858	{
	1859	if($MAttr->{"Constructor"}) {
	1860	registerUsage($MAttr->{"Class"}, $LVer);
	1861	}
[10845]	1862	else {
[11682]	1863	registerUsage($MAttr->{"Return"}, $LVer);
[10845]	1864	}
	1865	}
[12872]	1866
	1867	if($LVer==1 and not $MAttr->{"Constructor"}
	1868	and my $BaseSign = getBaseSignature($Method)) {
	1869	$OldMethodSignature{$BaseSign} = $Method;
	1870	}
[10845]	1871	}
	1872	}
	1873
	1874	sub mergeMethods()
	1875	{
	1876	foreach my $Method (sort keys(%{$MethodInfo{1}}))
	1877	{ # compare methods
	1878	next if(not defined $MethodInfo{2}{$Method});
	1879
	1880	if(not $MethodInfo{1}{$Method}{"Archive"}
	1881	or not $MethodInfo{2}{$Method}{"Archive"}) {
	1882	next;
	1883	}
	1884
	1885	if(not methodFilter($Method, 1)) {
	1886	next;
	1887	}
	1888
	1889	my $ClassId1 = $MethodInfo{1}{$Method}{"Class"};
[13595]	1890	my $Class1 = getType($ClassId1, 1);
[10845]	1891
[13595]	1892	if(not defined $In::Opt{"CheckAnnotations"} and $Class1->{"Annotation"}) {
	1893	next;
	1894	}
	1895
	1896	my $Class1_Name = $Class1->{"Name"};
	1897	my $Class1_Type = $Class1->{"Type"};
	1898
[11682]	1899	$CheckedTypes{$Class1_Name} = 1;
[10845]	1900	$CheckedMethods{$Method} = 1;
	1901
	1902	if(not $MethodInfo{1}{$Method}{"Static"}
[11682]	1903	and $Class1_Type eq "class" and not $Class_Constructed{1}{$ClassId1})
[10845]	1904	{ # class cannot be constructed or inherited by clients
	1905	# non-static method cannot be called
	1906	next;
	1907	}
[11682]	1908
[10845]	1909	# checking attributes
	1910	if(not $MethodInfo{1}{$Method}{"Static"}
	1911	and $MethodInfo{2}{$Method}{"Static"}) {
	1912	%{$CompatProblems{$Method}{"Method_Became_Static"}{""}} = ();
	1913	}
	1914	elsif($MethodInfo{1}{$Method}{"Static"}
	1915	and not $MethodInfo{2}{$Method}{"Static"}) {
	1916	%{$CompatProblems{$Method}{"Method_Became_NonStatic"}{""}} = ();
	1917	}
[11682]	1918
[10845]	1919	if(not $MethodInfo{1}{$Method}{"Synchronized"}
	1920	and $MethodInfo{2}{$Method}{"Synchronized"}) {
	1921	%{$CompatProblems{$Method}{"Method_Became_Synchronized"}{""}} = ();
	1922	}
	1923	elsif($MethodInfo{1}{$Method}{"Synchronized"}
	1924	and not $MethodInfo{2}{$Method}{"Synchronized"}) {
	1925	%{$CompatProblems{$Method}{"Method_Became_NonSynchronized"}{""}} = ();
	1926	}
[11682]	1927
[10845]	1928	if(not $MethodInfo{1}{$Method}{"Final"}
	1929	and $MethodInfo{2}{$Method}{"Final"})
	1930	{
	1931	if($MethodInfo{1}{$Method}{"Static"}) {
	1932	%{$CompatProblems{$Method}{"Static_Method_Became_Final"}{""}} = ();
	1933	}
	1934	else {
	1935	%{$CompatProblems{$Method}{"NonStatic_Method_Became_Final"}{""}} = ();
	1936	}
	1937	}
[11682]	1938
[10845]	1939	my $Access1 = $MethodInfo{1}{$Method}{"Access"};
	1940	my $Access2 = $MethodInfo{2}{$Method}{"Access"};
[11682]	1941
[10845]	1942	if($Access1 eq "public" and $Access2=~/protected\|private/
	1943	or $Access1 eq "protected" and $Access2=~/private/)
	1944	{
	1945	%{$CompatProblems{$Method}{"Changed_Method_Access"}{""}} = (
	1946	"Old_Value"=>$Access1,
[11682]	1947	"New_Value"=>$Access2);
[10845]	1948	}
[11682]	1949
	1950	my $Class2_Type = getTypeType($MethodInfo{2}{$Method}{"Class"}, 2);
	1951
	1952	if($Class1_Type eq "class"
	1953	and $Class2_Type eq "class")
[10845]	1954	{
	1955	if(not $MethodInfo{1}{$Method}{"Abstract"}
	1956	and $MethodInfo{2}{$Method}{"Abstract"})
	1957	{
	1958	%{$CompatProblems{$Method}{"Method_Became_Abstract"}{""}} = ();
[11682]	1959	%{$CompatProblems{$Method}{"Class_Method_Became_Abstract"}{"this.".getSFormat($Method)}} = (
	1960	"Type_Name"=>$Class1_Name,
	1961	"Target"=>$Method);
[10845]	1962	}
	1963	elsif($MethodInfo{1}{$Method}{"Abstract"}
	1964	and not $MethodInfo{2}{$Method}{"Abstract"})
	1965	{
	1966	%{$CompatProblems{$Method}{"Method_Became_NonAbstract"}{""}} = ();
[11682]	1967	%{$CompatProblems{$Method}{"Class_Method_Became_NonAbstract"}{"this.".getSFormat($Method)}} = (
	1968	"Type_Name"=>$Class1_Name,
	1969	"Target"=>$Method);
[10845]	1970	}
	1971	}
[11682]	1972	elsif($Class1_Type eq "interface"
	1973	and $Class2_Type eq "interface")
[10845]	1974	{
	1975	if(not $MethodInfo{1}{$Method}{"Abstract"}
	1976	and $MethodInfo{2}{$Method}{"Abstract"})
	1977	{
	1978	%{$CompatProblems{$Method}{"Method_Became_NonDefault"}{""}} = ();
[11682]	1979	%{$CompatProblems{$Method}{"Interface_Method_Became_NonDefault"}{"this.".getSFormat($Method)}} = (
	1980	"Type_Name"=>$Class1_Name,
	1981	"Target"=>$Method);
[10845]	1982	}
	1983	elsif($MethodInfo{1}{$Method}{"Abstract"}
	1984	and not $MethodInfo{2}{$Method}{"Abstract"})
	1985	{
	1986	%{$CompatProblems{$Method}{"Method_Became_Default"}{""}} = ();
[11682]	1987	%{$CompatProblems{$Method}{"Interface_Method_Became_Default"}{"this.".getSFormat($Method)}} = (
	1988	"Type_Name"=>$Class1_Name,
	1989	"Target"=>$Method);
[10845]	1990	}
	1991	}
	1992
[11682]	1993	my %Exceptions_Old = map {getTypeName($_, 1) => $_} keys(%{$MethodInfo{1}{$Method}{"Exceptions"}});
	1994	my %Exceptions_New = map {getTypeName($_, 2) => $_} keys(%{$MethodInfo{2}{$Method}{"Exceptions"}});
[10845]	1995	foreach my $Exception (keys(%Exceptions_Old))
	1996	{
	1997	if(not $Exceptions_New{$Exception})
	1998	{
[11682]	1999	my $EType = getType($Exceptions_Old{$Exception}, 1);
	2000	my $SuperClass = $EType->{"SuperClass"};
	2001
[10845]	2002	if($KnownRuntimeExceptions{$Exception}
[11682]	2003	or defined $SuperClass and getTypeName($SuperClass, 1) eq "java.lang.RuntimeException")
[10845]	2004	{
	2005	if(not $MethodInfo{1}{$Method}{"Abstract"}
	2006	and not $MethodInfo{2}{$Method}{"Abstract"})
	2007	{
[11682]	2008	%{$CompatProblems{$Method}{"Removed_Unchecked_Exception"}{"this.".getSFormat($Exception)}} = (
	2009	"Type_Name"=>$Class1_Name,
	2010	"Target"=>$Exception);
[10845]	2011	}
	2012	}
	2013	else
	2014	{
	2015	if($MethodInfo{1}{$Method}{"Abstract"}
	2016	and $MethodInfo{2}{$Method}{"Abstract"})
	2017	{
[11682]	2018	%{$CompatProblems{$Method}{"Abstract_Method_Removed_Checked_Exception"}{"this.".getSFormat($Exception)}} = (
	2019	"Type_Name"=>$Class1_Name,
	2020	"Target"=>$Exception);
[10845]	2021	}
	2022	else
	2023	{
[11682]	2024	%{$CompatProblems{$Method}{"NonAbstract_Method_Removed_Checked_Exception"}{"this.".getSFormat($Exception)}} = (
	2025	"Type_Name"=>$Class1_Name,
	2026	"Target"=>$Exception);
[10845]	2027	}
	2028	}
	2029	}
	2030	}
[11682]	2031
[10845]	2032	foreach my $Exception (keys(%Exceptions_New))
	2033	{
	2034	if(not $Exceptions_Old{$Exception})
	2035	{
[11682]	2036	my $EType = getType($Exceptions_New{$Exception}, 2);
	2037	my $SuperClass = $EType->{"SuperClass"};
	2038
[10845]	2039	if($KnownRuntimeExceptions{$Exception}
[11682]	2040	or defined $SuperClass and getTypeName($SuperClass, 2) eq "java.lang.RuntimeException")
[10845]	2041	{
	2042	if(not $MethodInfo{1}{$Method}{"Abstract"}
	2043	and not $MethodInfo{2}{$Method}{"Abstract"})
	2044	{
[11682]	2045	%{$CompatProblems{$Method}{"Added_Unchecked_Exception"}{"this.".getSFormat($Exception)}} = (
	2046	"Type_Name"=>$Class1_Name,
	2047	"Target"=>$Exception);
[10845]	2048	}
	2049	}
	2050	else
	2051	{
	2052	if($MethodInfo{1}{$Method}{"Abstract"}
	2053	and $MethodInfo{2}{$Method}{"Abstract"})
	2054	{
[11682]	2055	%{$CompatProblems{$Method}{"Abstract_Method_Added_Checked_Exception"}{"this.".getSFormat($Exception)}} = (
	2056	"Type_Name"=>$Class1_Name,
	2057	"Target"=>$Exception);
[10845]	2058	}
	2059	else
	2060	{
[11682]	2061	%{$CompatProblems{$Method}{"NonAbstract_Method_Added_Checked_Exception"}{"this.".getSFormat($Exception)}} = (
	2062	"Type_Name"=>$Class1_Name,
	2063	"Target"=>$Exception);
[10845]	2064	}
	2065	}
	2066	}
	2067	}
	2068
	2069	if(defined $MethodInfo{1}{$Method}{"Param"})
	2070	{
	2071	foreach my $ParamPos (sort {int($a) <=> int($b)} keys(%{$MethodInfo{1}{$Method}{"Param"}}))
	2072	{ # checking parameters
	2073	mergeParameters($Method, $ParamPos, $ParamPos);
	2074	}
	2075	}
	2076
	2077	# check object type
	2078	my $ObjectType1_Id = $MethodInfo{1}{$Method}{"Class"};
	2079	my $ObjectType2_Id = $MethodInfo{2}{$Method}{"Class"};
	2080	if($ObjectType1_Id and $ObjectType2_Id)
	2081	{
	2082	my $SubProblems = mergeTypes($ObjectType1_Id, $ObjectType2_Id);
	2083	foreach my $SubProblemType (keys(%{$SubProblems}))
	2084	{
	2085	foreach my $SubLocation (keys(%{$SubProblems->{$SubProblemType}}))
	2086	{
	2087	my $NewLocation = ($SubLocation)?"this.".$SubLocation:"this";
	2088	$CompatProblems{$Method}{$SubProblemType}{$NewLocation} = $SubProblems->{$SubProblemType}{$SubLocation};
	2089	}
	2090	}
	2091	}
	2092	# check return type
	2093	my $ReturnType1_Id = $MethodInfo{1}{$Method}{"Return"};
	2094	my $ReturnType2_Id = $MethodInfo{2}{$Method}{"Return"};
	2095	if($ReturnType1_Id and $ReturnType2_Id)
	2096	{
	2097	my $SubProblems = mergeTypes($ReturnType1_Id, $ReturnType2_Id);
	2098	foreach my $SubProblemType (keys(%{$SubProblems}))
	2099	{
	2100	foreach my $SubLocation (keys(%{$SubProblems->{$SubProblemType}}))
	2101	{
	2102	my $NewLocation = ($SubLocation)?"retval.".$SubLocation:"retval";
	2103	$CompatProblems{$Method}{$SubProblemType}{$NewLocation} = $SubProblems->{$SubProblemType}{$SubLocation};
	2104	}
	2105	}
	2106	}
	2107	}
	2108	}
	2109
	2110	sub mergeParameters($$$)
	2111	{
	2112	my ($Method, $ParamPos1, $ParamPos2) = @_;
	2113	if(not $Method or not defined $MethodInfo{1}{$Method}{"Param"}
	2114	or not defined $MethodInfo{2}{$Method}{"Param"}) {
	2115	return;
	2116	}
	2117
	2118	my $ParamType1_Id = $MethodInfo{1}{$Method}{"Param"}{$ParamPos1}{"Type"};
	2119	my $ParamType2_Id = $MethodInfo{2}{$Method}{"Param"}{$ParamPos2}{"Type"};
	2120
	2121	if(not $ParamType1_Id or not $ParamType2_Id) {
	2122	return;
	2123	}
	2124
	2125	my $Parameter_Name = $MethodInfo{1}{$Method}{"Param"}{$ParamPos1}{"Name"};
	2126	my $Parameter_Location = ($Parameter_Name)?$Parameter_Name:showPos($ParamPos1)." Parameter";
	2127
	2128	# checking type declaration changes
	2129	my $SubProblems = mergeTypes($ParamType1_Id, $ParamType2_Id);
[12872]	2130
	2131	my $Type1 = getType($ParamType1_Id, 1);
	2132	my $Type2 = getType($ParamType2_Id, 2);
	2133
	2134	if($Type1->{"Name"} ne $Type2->{"Name"})
	2135	{
	2136	if(index($Type1->{"Name"}, "...")!=-1 and index($Type2->{"Name"}, "[]")!=-1)
	2137	{
	2138	%{$CompatProblems{$Method}{"Variable_Arity_To_Array"}{$Parameter_Name}} = (
	2139	"Type_Name"=>getTypeName($MethodInfo{1}{$Method}{"Class"}, 1),
	2140	"Param_Name"=>$Parameter_Name,
	2141	"Old_Value"=>$Type1->{"Name"},
	2142	"New_Value"=>$Type2->{"Name"});
	2143	}
	2144	elsif(index($Type1->{"Name"}, "[]")!=-1 and index($Type2->{"Name"}, "...")!=-1)
	2145	{
	2146	%{$CompatProblems{$Method}{"Array_To_Variable_Arity"}{$Parameter_Name}} = (
	2147	"Type_Name"=>getTypeName($MethodInfo{1}{$Method}{"Class"}, 1),
	2148	"Param_Name"=>$Parameter_Name,
	2149	"Old_Value"=>$Type1->{"Name"},
	2150	"New_Value"=>$Type2->{"Name"});
	2151	}
	2152	}
	2153
[10845]	2154	foreach my $SubProblemType (keys(%{$SubProblems}))
	2155	{
	2156	foreach my $SubLocation (keys(%{$SubProblems->{$SubProblemType}}))
	2157	{
	2158	my $NewLocation = ($SubLocation)?$Parameter_Location.".".$SubLocation:$Parameter_Location;
	2159	$CompatProblems{$Method}{$SubProblemType}{$NewLocation} = $SubProblems->{$SubProblemType}{$SubLocation};
	2160	}
	2161	}
	2162	}
	2163
[12872]	2164	sub detectTypeChange($$$$$)
[10845]	2165	{
[12872]	2166	my ($Ct1, $Ct2, $Type1_Id, $Type2_Id, $Prefix) = @_;
[10845]	2167	my %LocalProblems = ();
[11682]	2168
	2169	my $Type1 = getType($Type1_Id, 1);
	2170	my $Type2 = getType($Type2_Id, 2);
	2171
	2172	my $Type1_Name = $Type1->{"Name"};
	2173	my $Type2_Name = $Type2->{"Name"};
	2174
[12872]	2175	my $Type1_Show = $Type1_Name;
	2176	my $Type2_Show = $Type2_Name;
	2177
	2178	if(defined $Ct1->{"GenericParam"}
	2179	and defined $Ct1->{"GenericParam"}{$Type1_Name})
	2180	{
	2181	$Type1_Name = getTypeName($Ct1->{"GenericParam"}{$Type1_Name}, 1);
	2182	$Type1_Show .= " extends ".$Type1_Name;
	2183	}
	2184
	2185	if(defined $Ct2->{"GenericParam"}
	2186	and defined $Ct2->{"GenericParam"}{$Type2_Name})
	2187	{
	2188	$Type2_Name = getTypeName($Ct2->{"GenericParam"}{$Type2_Name}, 2);
	2189	$Type2_Show .= " extends ".$Type2_Name;
	2190	}
	2191
[11682]	2192	my $Type1_Base = undef;
	2193	my $Type2_Base = undef;
	2194
	2195	if($Type1->{"Type"} eq "array") {
	2196	$Type1_Base = getOneStepBaseType($Type1_Id, 1);
	2197	}
	2198	else {
	2199	$Type1_Base = getBaseType($Type1_Id, 1);
	2200	}
	2201
	2202	if($Type2->{"Type"} eq "array") {
	2203	$Type2_Base = getOneStepBaseType($Type2_Id, 2);
	2204	}
	2205	else {
	2206	$Type2_Base = getBaseType($Type2_Id, 2);
	2207	}
	2208
	2209	return () if(not $Type1_Name or not $Type2_Name);
	2210	return () if(not $Type1_Base->{"Name"} or not $Type2_Base->{"Name"});
[12872]	2211
[11682]	2212	if($Type1_Base->{"Name"} ne $Type2_Base->{"Name"} and $Type1_Name eq $Type2_Name)
[10845]	2213	{# base type change
	2214	%{$LocalProblems{"Changed_".$Prefix."_BaseType"}}=(
[11682]	2215	"Old_Value"=>$Type1_Base->{"Name"},
	2216	"New_Value"=>$Type2_Base->{"Name"});
[10845]	2217	}
[11682]	2218	elsif($Type1_Name ne $Type2_Name)
[10845]	2219	{# type change
	2220	%{$LocalProblems{"Changed_".$Prefix."_Type"}}=(
[12872]	2221	"Old_Value"=>$Type1_Show,
	2222	"New_Value"=>$Type2_Show);
[10845]	2223	}
	2224	return %LocalProblems;
	2225	}
	2226
[11682]	2227	sub specChars($)
[10845]	2228	{
	2229	my $Str = $_[0];
	2230	if(not defined $Str
	2231	or $Str eq "") {
	2232	return "";
	2233	}
	2234	$Str=~s/\&([^#]\|\Z)/&$1/g;
	2235	$Str=~s/</</g;
	2236	$Str=~s/\-\>/->/g; # −
	2237	$Str=~s/>/>/g;
	2238	$Str=~s/([^ ])( )([^ ])/$1\@ALONE_SP\@$3/g;
	2239	$Str=~s/ / /g; #
	2240	$Str=~s/\@ALONE_SP\@/ /g;
	2241	$Str=~s/\n/<br\/>/g;
	2242	$Str=~s/\"/"/g;
	2243	$Str=~s/\'/'/g;
	2244	return $Str;
	2245	}
	2246
[11682]	2247	sub blackName($)
[10845]	2248	{
[11682]	2249	my $N = $_[0];
	2250	return "<span class='iname_b'>".$N."</span>";
[10845]	2251	}
	2252
[11682]	2253	sub highLight_ItalicColor($$)
[10845]	2254	{
	2255	my ($M, $V) = @_;
[11682]	2256	return getSignature($M, $V, "Full\|HTML\|Italic\|Color");
[10845]	2257	}
	2258
[11682]	2259	sub getSignature($$$)
[10845]	2260	{
[11682]	2261	my ($Method, $LVer, $Kind) = @_;
	2262	if(defined $Cache{"getSignature"}{$LVer}{$Method}{$Kind}) {
	2263	return $Cache{"getSignature"}{$LVer}{$Method}{$Kind};
[10845]	2264	}
	2265
	2266	# settings
	2267	my ($Full, $Html, $Simple, $Italic, $Color,
[12872]	2268	$ShowParams, $ShowClass, $ShowAttr, $Desc,
	2269	$ShowReturn, $Target) = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, undef);
[10845]	2270
	2271	if($Kind=~/Full/) {
	2272	$Full = 1;
	2273	}
	2274	if($Kind=~/HTML/) {
	2275	$Html = 1;
	2276	}
	2277	if($Kind=~/Simple/) {
	2278	$Simple = 1;
	2279	}
	2280	if($Kind=~/Italic/) {
	2281	$Italic = 1;
	2282	}
	2283	if($Kind=~/Color/) {
	2284	$Color = 1;
	2285	}
	2286	if($Kind=~/Target=(\d+)/) {
	2287	$Target = $1;
	2288	}
	2289	if($Kind=~/Param/) {
	2290	$ShowParams = 1;
	2291	}
	2292	if($Kind=~/Class/) {
	2293	$ShowClass = 1;
	2294	}
	2295	if($Kind=~/Attr/) {
	2296	$ShowAttr = 1;
	2297	}
[11682]	2298	if($Kind=~/Desc/) {
	2299	$Desc = 1;
	2300	}
[12872]	2301	if($Kind=~/Return/) {
	2302	$ShowReturn = 1;
	2303	}
[10845]	2304
[11682]	2305	if(not defined $MethodInfo{$LVer}{$Method}{"ShortName"})
[10845]	2306	{ # from java.lang.Object
[12872]	2307	if($Html) {
[11682]	2308	return specChars($Method);
[10845]	2309	}
[11682]	2310	else {
[10845]	2311	return $Method;
	2312	}
	2313	}
	2314
[12872]	2315	my $Signature = "";
	2316
	2317	my $ShortName = $MethodInfo{$LVer}{$Method}{"ShortName"};
	2318
	2319	if($Html) {
	2320	$ShortName = specChars($ShortName);
	2321	}
	2322
	2323	$Signature .= $ShortName;
	2324
[10845]	2325	if($Full or $ShowClass)
	2326	{
[11682]	2327	my $Class = getTypeName($MethodInfo{$LVer}{$Method}{"Class"}, $LVer);
[10845]	2328
[11682]	2329	if($In::Opt{"HideTemplates"}) {
[10845]	2330	$Class=~s/<.*>//g;
	2331	}
	2332
	2333	if($Html) {
[11682]	2334	$Class = specChars($Class);
[10845]	2335	}
	2336
	2337	$Signature = $Class.".".$Signature;
	2338	}
	2339	my @Params = ();
	2340
[11682]	2341	if(defined $MethodInfo{$LVer}{$Method}{"Param"})
[10845]	2342	{
	2343	foreach my $PPos (sort {int($a)<=>int($b)}
[11682]	2344	keys(%{$MethodInfo{$LVer}{$Method}{"Param"}}))
[10845]	2345	{
[11682]	2346	my $PTid = $MethodInfo{$LVer}{$Method}{"Param"}{$PPos}{"Type"};
	2347	if(my $PTName = getTypeName($PTid, $LVer))
[10845]	2348	{
[11682]	2349	if($In::Opt{"HideTemplates"}) {
[10845]	2350	$PTName=~s/<.*>//g;
	2351	}
	2352
[11682]	2353	if(not $In::Opt{"ShowPackages"}) {
[10845]	2354	$PTName=~s/(\A\|\<\s\|\,\s)[a-z0-9\.]+\./$1/g;
	2355	}
	2356
	2357	if($Html) {
[11682]	2358	$PTName = specChars($PTName);
[10845]	2359	}
	2360
	2361	if($Full or $ShowParams)
	2362	{
[11682]	2363	my $PName = $MethodInfo{$LVer}{$Method}{"Param"}{$PPos}{"Name"};
[10845]	2364
	2365	if($Simple) {
	2366	$PName = "<i>$PName</i>";
	2367	}
	2368	elsif($Html)
	2369	{
	2370	my $Style = "param";
	2371
	2372	if(defined $Target
	2373	and $Target==$PPos) {
	2374	$PName = "<span class='focus_p'>$PName</span>";
	2375	}
	2376	elsif($Color) {
	2377	$PName = "<span class='color_p'>$PName</span>";
	2378	}
	2379	else {
	2380	$PName = "<i>$PName</i>";
	2381	}
	2382	}
	2383
	2384	push(@Params, $PTName." ".$PName);
	2385	}
	2386	else {
	2387	push(@Params, $PTName);
	2388	}
	2389	}
	2390	}
	2391	}
	2392
	2393	if($Simple) {
	2394	$Signature = "<b>".$Signature."</b>";
	2395	}
	2396
	2397	if($Html and not $Simple)
	2398	{
	2399	$Signature .= " ";
[11682]	2400	if($Desc) {
	2401	$Signature .= "<span class='sym_pd'>";
	2402	}
	2403	else {
	2404	$Signature .= "<span class='sym_p'>";
	2405	}
[10845]	2406	if(@Params)
	2407	{
	2408	foreach my $Pos (0 .. $#Params)
	2409	{
	2410	my $Name = "";
	2411
	2412	if($Pos==0) {
	2413	$Name .= "( ";
	2414	}
	2415
	2416	$Name .= $Params[$Pos];
	2417
	2418	$Name = "<span>".$Name."</span>";
	2419
	2420	if($Pos==$#Params) {
	2421	$Name .= " )";
	2422	}
	2423	else {
	2424	$Name .= ", ";
	2425	}
	2426
	2427	$Signature .= $Name;
	2428	}
	2429	}
	2430	else {
	2431	$Signature .= "( )";
	2432	}
	2433	$Signature .= "</span>";
	2434	}
	2435	else
	2436	{
	2437	if(@Params) {
	2438	$Signature .= " ( ".join(", ", @Params)." )";
	2439	}
	2440	else {
	2441	$Signature .= " ( )";
	2442	}
	2443	}
	2444
	2445	if($Full or $ShowAttr)
	2446	{
[11682]	2447	if($MethodInfo{$LVer}{$Method}{"Static"}) {
[10845]	2448	$Signature .= " [static]";
	2449	}
[11682]	2450	elsif($MethodInfo{$LVer}{$Method}{"Abstract"}) {
[10845]	2451	$Signature .= " [abstract]";
	2452	}
	2453	}
	2454
	2455	if($Full)
	2456	{
[11682]	2457	if($In::Opt{"ShowAccess"})
[10845]	2458	{
[11682]	2459	if(my $Access = $MethodInfo{$LVer}{$Method}{"Access"})
[10845]	2460	{
	2461	if($Access ne "public") {
	2462	$Signature .= " [".$Access."]";
	2463	}
	2464	}
	2465	}
[12872]	2466	}
	2467
	2468	if($Full or $ShowReturn)
	2469	{
[11682]	2470	if(my $ReturnId = $MethodInfo{$LVer}{$Method}{"Return"})
[10845]	2471	{
[11682]	2472	my $RName = getTypeName($ReturnId, $LVer);
[10845]	2473
[11682]	2474	if($In::Opt{"HideTemplates"}) {
[10845]	2475	$RName=~s/<.*>//g;
	2476	}
	2477
[11682]	2478	if(not $In::Opt{"ShowPackages"}) {
[10845]	2479	$RName=~s/(\A\|\<\s\|\,\s)[a-z0-9\.]+\./$1/g;
	2480	}
	2481
[12872]	2482	if($Desc) {
	2483	$Signature = "<b>".specChars($RName)."</b> ".$Signature;
	2484	}
	2485	elsif($Simple) {
[11682]	2486	$Signature .= " <b>:</b> ".specChars($RName);
[10845]	2487	}
	2488	elsif($Html) {
[11682]	2489	$Signature .= "<span class='sym_p nowrap'>  <b>:</b>  ".specChars($RName)."</span>";
[10845]	2490	}
	2491	else {
	2492	$Signature .= " : ".$RName;
	2493	}
	2494	}
[12872]	2495	}
	2496
	2497	if($Full)
	2498	{
[11682]	2499	if(not $In::Opt{"SkipDeprecated"})
[10845]	2500	{
[11682]	2501	if($MethodInfo{$LVer}{$Method}{"Deprecated"}) {
[10845]	2502	$Signature .= " DEPRECATED";
	2503	}
	2504	}
	2505	}
	2506
	2507	$Signature=~s/java\.lang\.//g;
	2508
	2509	if($Html)
	2510	{
[11682]	2511	if(not $In::Opt{"SkipDeprecated"}) {
[10845]	2512	$Signature=~s!(\deprecated\)!<span class='deprecated'>$1</span>!ig;
	2513	}
	2514
	2515	$Signature=~s!(\[static\]\|\[abstract\]\|\[public\]\|\[private\]\|\[protected\])!<span class='attr'>$1</span>!g;
	2516	}
	2517
	2518	if($Simple) {
	2519	$Signature=~s/\[\]/\[ \]/g;
	2520	}
	2521	elsif($Html)
	2522	{
	2523	$Signature=~s!\[\]![ ]!g;
	2524	$Signature=~s!operator=!operator =!g;
	2525	}
	2526
[11682]	2527	return ($Cache{"getSignature"}{$LVer}{$Method}{$Kind} = $Signature);
[10845]	2528	}
	2529
[11682]	2530	sub getReportHeader($)
[10845]	2531	{
	2532	my $Level = $_[0];
	2533	my $Report_Header = "<h1>";
	2534	if($Level eq "Source") {
	2535	$Report_Header .= "Source compatibility";
	2536	}
	2537	elsif($Level eq "Binary") {
	2538	$Report_Header .= "Binary compatibility";
	2539	}
	2540	else {
	2541	$Report_Header .= "API compatibility";
	2542	}
[11682]	2543	$Report_Header .= " report for the <span style='color:Blue;'>".$In::Opt{"TargetTitle"}."</span> library between <span style='color:Red;'>".$In::Desc{1}{"Version"}."</span> and <span style='color:Red;'>".$In::Desc{2}{"Version"}."</span> versions";
	2544	if($In::Opt{"ClientPath"}) {
	2545	$Report_Header .= " (concerning portability of the client: <span style='color:Blue;'>".getFilename($In::Opt{"ClientPath"})."</span>)";
[10845]	2546	}
	2547	$Report_Header .= "</h1>\n";
	2548	return $Report_Header;
	2549	}
	2550
[11682]	2551	sub getSourceInfo()
[10845]	2552	{
	2553	my $CheckedArchives = "<a name='Checked_Archives'></a>";
[11682]	2554	if($In::Opt{"OldStyle"}) {
	2555	$CheckedArchives .= "<h2>Java Archives (".keys(%{$LibArchives{1}}).")</h2>";
[10845]	2556	}
	2557	else {
[11682]	2558	$CheckedArchives .= "<h2>Java Archives <span class='gray'> ".keys(%{$LibArchives{1}})." </span></h2>";
[10845]	2559	}
	2560	$CheckedArchives .= "\n<hr/><div class='jar_list'>\n";
	2561	foreach my $ArchivePath (sort {lc($a) cmp lc($b)} keys(%{$LibArchives{1}})) {
[11682]	2562	$CheckedArchives .= getFilename($ArchivePath)."<br/>\n";
[10845]	2563	}
	2564	$CheckedArchives .= "</div><br/>$TOP_REF<br/>\n";
	2565	return $CheckedArchives;
	2566	}
	2567
[11682]	2568	sub getTypeProblemsCount($$)
[10845]	2569	{
	2570	my ($TargetSeverity, $Level) = @_;
	2571	my $Type_Problems_Count = 0;
	2572
	2573	foreach my $Type_Name (sort keys(%{$TypeChanges{$Level}}))
	2574	{
	2575	my %Kinds_Target = ();
	2576	foreach my $Kind (sort keys(%{$TypeChanges{$Level}{$Type_Name}}))
	2577	{
[11682]	2578	if($CompatRules{$Level}{$Kind}{"Severity"} ne $TargetSeverity) {
[10845]	2579	next;
	2580	}
[11682]	2581
[10845]	2582	foreach my $Location (sort keys(%{$TypeChanges{$Level}{$Type_Name}{$Kind}}))
	2583	{
	2584	my $Target = $TypeChanges{$Level}{$Type_Name}{$Kind}{$Location}{"Target"};
	2585
	2586	if($Kinds_Target{$Kind}{$Target}) {
	2587	next;
	2588	}
	2589
	2590	$Kinds_Target{$Kind}{$Target} = 1;
	2591	$Type_Problems_Count += 1;
	2592	}
	2593	}
	2594	}
	2595
	2596	return $Type_Problems_Count;
	2597	}
	2598
[11682]	2599	sub showNum($)
[10845]	2600	{
	2601	if($_[0])
	2602	{
[11682]	2603	my $Num = cutNum($_[0], 2, 0);
[10845]	2604	if($Num eq "0")
	2605	{
	2606	foreach my $P (3 .. 7)
	2607	{
[11682]	2608	$Num = cutNum($_[0], $P, 1);
[10845]	2609	if($Num ne "0") {
	2610	last;
	2611	}
	2612	}
	2613	}
	2614	if($Num eq "0") {
	2615	$Num = $_[0];
	2616	}
	2617	return $Num;
	2618	}
	2619	return $_[0];
	2620	}
	2621
[11682]	2622	sub cutNum($$$)
[10845]	2623	{
	2624	my ($num, $digs_to_cut, $z) = @_;
	2625	if($num!~/\./)
	2626	{
	2627	$num .= ".";
	2628	foreach (1 .. $digs_to_cut-1) {
	2629	$num .= "0";
	2630	}
	2631	}
	2632	elsif($num=~/\.(.+)\Z/ and length($1)<$digs_to_cut-1)
	2633	{
	2634	foreach (1 .. $digs_to_cut - 1 - length($1)) {
	2635	$num .= "0";
	2636	}
	2637	}
	2638	elsif($num=~/\d+\.(\d){$digs_to_cut,}/) {
	2639	$num=sprintf("%.".($digs_to_cut-1)."f", $num);
	2640	}
	2641	$num=~s/\.[0]+\Z//g;
	2642	if($z) {
	2643	$num=~s/(\.[1-9]+)[0]+\Z/$1/g;
	2644	}
	2645	return $num;
	2646	}
	2647
[11682]	2648	sub getSummary($)
[10845]	2649	{
	2650	my $Level = $_[0];
	2651	my ($Added, $Removed, $M_Problems_High, $M_Problems_Medium, $M_Problems_Low,
[11682]	2652	$T_Problems_High, $T_Problems_Medium, $T_Problems_Low, $M_Other, $T_Other) = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
[10845]	2653
	2654	%{$RESULT{$Level}} = (
	2655	"Problems"=>0,
	2656	"Warnings"=>0,
[11682]	2657	"Affected"=>0);
[10845]	2658
[12872]	2659	# check rules
[10845]	2660	foreach my $Method (sort keys(%CompatProblems))
	2661	{
[13595]	2662	foreach my $Kind (sort keys(%{$CompatProblems{$Method}}))
[12872]	2663	{
	2664	if(not defined $CompatRules{"Binary"}{$Kind} and not defined $CompatRules{"Source"}{$Kind})
	2665	{ # unknown rule
	2666	if(not $UnknownRules{$Level}{$Kind})
	2667	{ # only one warning
	2668	printMsg("WARNING", "unknown rule \"$Kind\" (\"$Level\")");
[13595]	2669	$UnknownRules{$Level}{$Kind} = 1;
[12872]	2670	}
	2671	}
	2672	}
	2673	}
	2674
	2675	foreach my $Method (sort keys(%CompatProblems))
	2676	{
[10845]	2677	foreach my $Kind (sort keys(%{$CompatProblems{$Method}}))
	2678	{
[11682]	2679	if($CompatRules{$Level}{$Kind}{"Kind"} eq "Methods")
[10845]	2680	{
[11682]	2681	my $Severity = $CompatRules{$Level}{$Kind}{"Severity"};
	2682	foreach my $Loc (sort keys(%{$CompatProblems{$Method}{$Kind}}))
[10845]	2683	{
	2684	if($Kind eq "Added_Method")
	2685	{
	2686	if($Level eq "Source")
	2687	{
	2688	if($ChangedReturnFromVoid{$Method}) {
	2689	next;
	2690	}
	2691	}
	2692	$Added+=1;
	2693	}
	2694	elsif($Kind eq "Removed_Method")
	2695	{
	2696	if($Level eq "Source")
	2697	{
	2698	if($ChangedReturnFromVoid{$Method}) {
	2699	next;
	2700	}
	2701	}
	2702	$Removed+=1;
	2703	$TotalAffected{$Level}{$Method} = $Severity;
	2704	}
	2705	else
	2706	{
	2707	if($Severity eq "Safe") {
	2708	$M_Other += 1;
	2709	}
	2710	elsif($Severity eq "High") {
	2711	$M_Problems_High+=1;
	2712	}
	2713	elsif($Severity eq "Medium") {
	2714	$M_Problems_Medium+=1;
	2715	}
	2716	elsif($Severity eq "Low") {
	2717	$M_Problems_Low+=1;
	2718	}
[11682]	2719	if(($Severity ne "Low" or $In::Opt{"StrictCompat"})
[10845]	2720	and $Severity ne "Safe") {
	2721	$TotalAffected{$Level}{$Method} = $Severity;
	2722	}
	2723	}
	2724	}
	2725	}
	2726	}
	2727	}
	2728
	2729	my %MethodTypeIndex = ();
	2730
	2731	foreach my $Method (sort keys(%CompatProblems))
	2732	{
[11682]	2733	foreach my $Kind (sort keys(%{$CompatProblems{$Method}}))
[10845]	2734	{
[11682]	2735	if($CompatRules{$Level}{$Kind}{"Kind"} eq "Types")
[10845]	2736	{
[11682]	2737	my $Severity = $CompatRules{$Level}{$Kind}{"Severity"};
	2738	if(($Severity ne "Low" or $In::Opt{"StrictCompat"})
	2739	and $Severity ne "Safe")
[10845]	2740	{
[11682]	2741	if(my $Sev = $TotalAffected{$Level}{$Method})
	2742	{
	2743	if($Severity_Val{$Severity}>$Severity_Val{$Sev}) {
	2744	$TotalAffected{$Level}{$Method} = $Severity;
	2745	}
	2746	}
	2747	else {
	2748	$TotalAffected{$Level}{$Method} = $Severity;
	2749	}
	2750	}
	2751
	2752	my $MK = $CompatProblems{$Method}{$Kind};
	2753	my (@Locs1, @Locs2) = ();
	2754	foreach my $Loc (sort {length($a)<=>length($b)} sort keys(%{$MK}))
	2755	{
	2756	if(index($Loc, "retval")==0 or index($Loc, "this")==0) {
	2757	push(@Locs2, $Loc);
	2758	}
	2759	else {
	2760	push(@Locs1, $Loc);
	2761	}
	2762	}
	2763	foreach my $Loc (@Locs1, @Locs2)
	2764	{
	2765	my $Type = $MK->{$Loc}{"Type_Name"};
	2766	my $Target = $MK->{$Loc}{"Target"};
[10845]	2767
[11682]	2768	if(defined $MethodTypeIndex{$Method}{$Type}{$Kind}{$Target})
[10845]	2769	{ # one location for one type and target
	2770	next;
	2771	}
[11682]	2772	$MethodTypeIndex{$Method}{$Type}{$Kind}{$Target} = 1;
[10845]	2773
[11682]	2774	$TypeChanges{$Level}{$Type}{$Kind}{$Loc} = $MK->{$Loc};
	2775	$TypeProblemsIndex{$Level}{$Type}{$Kind}{$Loc}{$Method} = 1;
[10845]	2776	}
	2777	}
	2778	}
	2779	}
	2780
	2781	%MethodTypeIndex = (); # clear memory
	2782
[11682]	2783	$T_Problems_High = getTypeProblemsCount("High", $Level);
	2784	$T_Problems_Medium = getTypeProblemsCount("Medium", $Level);
	2785	$T_Problems_Low = getTypeProblemsCount("Low", $Level);
	2786	$T_Other = getTypeProblemsCount("Safe", $Level);
[10845]	2787
	2788	my $SCount = keys(%CheckedMethods)-$Added;
	2789	if($SCount)
	2790	{
	2791	my %Weight = (
	2792	"High" => 100,
	2793	"Medium" => 50,
	2794	"Low" => 25
	2795	);
	2796	foreach (keys(%{$TotalAffected{$Level}})) {
	2797	$RESULT{$Level}{"Affected"}+=$Weight{$TotalAffected{$Level}{$_}};
	2798	}
	2799	$RESULT{$Level}{"Affected"} = $RESULT{$Level}{"Affected"}/$SCount;
	2800	}
	2801	else {
	2802	$RESULT{$Level}{"Affected"} = 0;
	2803	}
[11682]	2804	$RESULT{$Level}{"Affected"} = showNum($RESULT{$Level}{"Affected"});
[10845]	2805	if($RESULT{$Level}{"Affected"}>=100) {
	2806	$RESULT{$Level}{"Affected"} = 100;
	2807	}
	2808
	2809	my ($TestInfo, $TestResults, $Problem_Summary) = ();
	2810
	2811	# test info
	2812	$TestInfo .= "<h2>Test Info</h2><hr/>\n";
	2813	$TestInfo .= "<table class='summary'>\n";
[11682]	2814	$TestInfo .= "<tr><th>Library Name</th><td>".$In::Opt{"TargetTitle"}."</td></tr>\n";
	2815	$TestInfo .= "<tr><th>Version #1</th><td>".$In::Desc{1}{"Version"}."</td></tr>\n";
	2816	$TestInfo .= "<tr><th>Version #2</th><td>".$In::Desc{2}{"Version"}."</td></tr>\n";
[10845]	2817
[11682]	2818	if($In::Opt{"JoinReport"})
[10845]	2819	{
	2820	if($Level eq "Binary") {
	2821	$TestInfo .= "<tr><th>Subject</th><td width='150px'>Binary Compatibility</td></tr>\n"; # Run-time
	2822	}
	2823	if($Level eq "Source") {
	2824	$TestInfo .= "<tr><th>Subject</th><td width='150px'>Source Compatibility</td></tr>\n"; # Build-time
	2825	}
	2826	}
	2827	$TestInfo .= "</table>\n";
	2828
	2829	# test results
[11682]	2830	$TestResults .= "<h2>Test Results</h2><hr/>\n";
	2831	$TestResults .= "<table class='summary'>\n";
[10845]	2832
	2833	my $Checked_Archives_Link = "0";
	2834	$Checked_Archives_Link = "<a href='#Checked_Archives' style='color:Blue;'>".keys(%{$LibArchives{1}})."</a>" if(keys(%{$LibArchives{1}})>0);
	2835
[13595]	2836	$TestResults .= "<tr><th>Total Java Modules</th><td>$Checked_Archives_Link</td></tr>\n";
[10845]	2837	$TestResults .= "<tr><th>Total Methods / Classes</th><td>".keys(%CheckedMethods)." / ".keys(%CheckedTypes)."</td></tr>\n";
	2838
	2839	$RESULT{$Level}{"Problems"} += $Removed+$M_Problems_High+$T_Problems_High+$T_Problems_Medium+$M_Problems_Medium;
[11682]	2840	if($In::Opt{"StrictCompat"}) {
[10845]	2841	$RESULT{$Level}{"Problems"}+=$T_Problems_Low+$M_Problems_Low;
	2842	}
	2843	else {
	2844	$RESULT{$Level}{"Warnings"}+=$T_Problems_Low+$M_Problems_Low;
	2845	}
	2846
	2847	my $META_DATA = "kind:".lc($Level).";";
	2848	$META_DATA .= $RESULT{$Level}{"Problems"}?"verdict:incompatible;":"verdict:compatible;";
	2849	$TestResults .= "<tr><th>Compatibility</th>\n";
	2850
[11682]	2851	my $BC_Rate = showNum(100 - $RESULT{$Level}{"Affected"});
[10845]	2852
	2853	if($RESULT{$Level}{"Problems"})
	2854	{
	2855	my $Cl = "incompatible";
	2856	if($BC_Rate>=90) {
	2857	$Cl = "warning";
	2858	}
	2859	elsif($BC_Rate>=80) {
	2860	$Cl = "almost_compatible";
	2861	}
	2862
	2863	$TestResults .= "<td class=\'$Cl\'>".$BC_Rate."%</td>\n";
	2864	}
	2865	else
	2866	{
	2867	$TestResults .= "<td class=\'compatible\'>100%</td>\n";
	2868	}
	2869
	2870	$TestResults .= "</tr>\n";
	2871	$TestResults .= "</table>\n";
	2872
	2873	$META_DATA .= "affected:".$RESULT{$Level}{"Affected"}.";";# in percents
	2874
	2875	# Problem Summary
[11682]	2876	$Problem_Summary .= "<h2>Problem Summary</h2><hr/>\n";
	2877	$Problem_Summary .= "<table class='summary'>\n";
	2878	$Problem_Summary .= "<tr><th></th><th style='text-align:center;'>Severity</th><th style='text-align:center;'>Count</th></tr>\n";
[10845]	2879
	2880	my $Added_Link = "0";
	2881	if($Added>0)
	2882	{
[11682]	2883	if($In::Opt{"ShortMode"}) {
[10845]	2884	$Added_Link = $Added;
	2885	}
	2886	else
	2887	{
[11682]	2888	if($In::Opt{"JoinReport"}) {
[10845]	2889	$Added_Link = "<a href='#".$Level."_Added' style='color:Blue;'>$Added</a>";
	2890	}
	2891	else {
	2892	$Added_Link = "<a href='#Added' style='color:Blue;'>$Added</a>";
	2893	}
	2894	}
	2895	}
	2896	$META_DATA .= "added:$Added;";
[11682]	2897	$Problem_Summary .= "<tr><th>Added Methods</th><td>-</td><td".getStyle("M", "Added", $Added).">$Added_Link</td></tr>\n";
[10845]	2898
	2899	my $Removed_Link = "0";
	2900	if($Removed>0)
	2901	{
[11682]	2902	if($In::Opt{"ShortMode"}) {
[10845]	2903	$Removed_Link = $Removed;
	2904	}
	2905	else
	2906	{
[11682]	2907	if($In::Opt{"JoinReport"}) {
[10845]	2908	$Removed_Link = "<a href='#".$Level."_Removed' style='color:Blue;'>$Removed</a>"
	2909	}
	2910	else {
	2911	$Removed_Link = "<a href='#Removed' style='color:Blue;'>$Removed</a>"
	2912	}
	2913	}
	2914	}
	2915	$META_DATA .= "removed:$Removed;";
	2916	$Problem_Summary .= "<tr><th>Removed Methods</th>";
[11682]	2917	$Problem_Summary .= "<td>High</td><td".getStyle("M", "Removed", $Removed).">$Removed_Link</td></tr>\n";
[10845]	2918
	2919	my $TH_Link = "0";
[11682]	2920	$TH_Link = "<a href='#".getAnchor("Type", $Level, "High")."' style='color:Blue;'>$T_Problems_High</a>" if($T_Problems_High>0);
[10845]	2921	$META_DATA .= "type_problems_high:$T_Problems_High;";
	2922	$Problem_Summary .= "<tr><th rowspan='3'>Problems with<br/>Data Types</th>";
[11682]	2923	$Problem_Summary .= "<td>High</td><td".getStyle("T", "High", $T_Problems_High).">$TH_Link</td></tr>\n";
[10845]	2924
	2925	my $TM_Link = "0";
[11682]	2926	$TM_Link = "<a href='#".getAnchor("Type", $Level, "Medium")."' style='color:Blue;'>$T_Problems_Medium</a>" if($T_Problems_Medium>0);
[10845]	2927	$META_DATA .= "type_problems_medium:$T_Problems_Medium;";
[11682]	2928	$Problem_Summary .= "<tr><td>Medium</td><td".getStyle("T", "Medium", $T_Problems_Medium).">$TM_Link</td></tr>\n";
[10845]	2929
	2930	my $TL_Link = "0";
[11682]	2931	$TL_Link = "<a href='#".getAnchor("Type", $Level, "Low")."' style='color:Blue;'>$T_Problems_Low</a>" if($T_Problems_Low>0);
[10845]	2932	$META_DATA .= "type_problems_low:$T_Problems_Low;";
[11682]	2933	$Problem_Summary .= "<tr><td>Low</td><td".getStyle("T", "Low", $T_Problems_Low).">$TL_Link</td></tr>\n";
[10845]	2934
	2935	my $MH_Link = "0";
[11682]	2936	$MH_Link = "<a href='#".getAnchor("Method", $Level, "High")."' style='color:Blue;'>$M_Problems_High</a>" if($M_Problems_High>0);
[10845]	2937	$META_DATA .= "method_problems_high:$M_Problems_High;";
	2938	$Problem_Summary .= "<tr><th rowspan='3'>Problems with<br/>Methods</th>";
[11682]	2939	$Problem_Summary .= "<td>High</td><td".getStyle("M", "High", $M_Problems_High).">$MH_Link</td></tr>\n";
[10845]	2940
	2941	my $MM_Link = "0";
[11682]	2942	$MM_Link = "<a href='#".getAnchor("Method", $Level, "Medium")."' style='color:Blue;'>$M_Problems_Medium</a>" if($M_Problems_Medium>0);
[10845]	2943	$META_DATA .= "method_problems_medium:$M_Problems_Medium;";
[11682]	2944	$Problem_Summary .= "<tr><td>Medium</td><td".getStyle("M", "Medium", $M_Problems_Medium).">$MM_Link</td></tr>\n";
[10845]	2945
	2946	my $ML_Link = "0";
[11682]	2947	$ML_Link = "<a href='#".getAnchor("Method", $Level, "Low")."' style='color:Blue;'>$M_Problems_Low</a>" if($M_Problems_Low>0);
[10845]	2948	$META_DATA .= "method_problems_low:$M_Problems_Low;";
[11682]	2949	$Problem_Summary .= "<tr><td>Low</td><td".getStyle("M", "Low", $M_Problems_Low).">$ML_Link</td></tr>\n";
[10845]	2950
	2951	# Safe Changes
	2952	if($T_Other)
	2953	{
[11682]	2954	my $TS_Link = "<a href='#".getAnchor("Type", $Level, "Safe")."' style='color:Blue;'>$T_Other</a>";
[10845]	2955	$Problem_Summary .= "<tr><th>Other Changes<br/>in Data Types</th><td>-</td><td".getStyle("T", "Safe", $T_Other).">$TS_Link</td></tr>\n";
	2956	}
	2957
	2958	if($M_Other)
	2959	{
[11682]	2960	my $MS_Link = "<a href='#".getAnchor("Method", $Level, "Safe")."' style='color:Blue;'>$M_Other</a>";
[10845]	2961	$Problem_Summary .= "<tr><th>Other Changes<br/>in Methods</th><td>-</td><td".getStyle("M", "Safe", $M_Other).">$MS_Link</td></tr>\n";
	2962	}
	2963	$META_DATA .= "checked_methods:".keys(%CheckedMethods).";";
	2964	$META_DATA .= "checked_types:".keys(%CheckedTypes).";";
	2965	$META_DATA .= "tool_version:$TOOL_VERSION";
	2966	$Problem_Summary .= "</table>\n";
[12872]	2967
	2968	my $AnyChanged = ($Added or $Removed or $M_Problems_High or $M_Problems_Medium or $M_Problems_Low or
	2969	$T_Problems_High or $T_Problems_Medium or $T_Problems_Low or $M_Other or $T_Other);
	2970
	2971	return ($TestInfo.$TestResults.$Problem_Summary, $META_DATA, $AnyChanged);
[10845]	2972	}
	2973
	2974	sub getStyle($$$)
	2975	{
	2976	my ($Subj, $Act, $Num) = @_;
	2977	my %Style = (
	2978	"Added"=>"new",
	2979	"Removed"=>"failed",
	2980	"Safe"=>"passed",
	2981	"Low"=>"warning",
	2982	"Medium"=>"failed",
	2983	"High"=>"failed"
	2984	);
	2985
	2986	if($Num>0) {
	2987	return " class='".$Style{$Act}."'";
	2988	}
	2989
	2990	return "";
	2991	}
	2992
[11682]	2993	sub getAnchor($$$)
[10845]	2994	{
	2995	my ($Kind, $Level, $Severity) = @_;
[11682]	2996	if($In::Opt{"JoinReport"})
[10845]	2997	{
	2998	if($Severity eq "Safe") {
	2999	return "Other_".$Level."_Changes_In_".$Kind."s";
	3000	}
	3001	else {
	3002	return $Kind."_".$Level."_Problems_".$Severity;
	3003	}
	3004	}
	3005	else
	3006	{
	3007	if($Severity eq "Safe") {
	3008	return "Other_Changes_In_".$Kind."s";
	3009	}
	3010	else {
	3011	return $Kind."_Problems_".$Severity;
	3012	}
	3013	}
	3014	}
	3015
[11682]	3016	sub getReportAdded($)
[10845]	3017	{
[11682]	3018	if($In::Opt{"ShortMode"}) {
[10845]	3019	return "";
	3020	}
	3021
	3022	my $Level = $_[0];
	3023	my ($ADDED_METHODS, %MethodAddedInArchiveClass);
	3024	foreach my $Method (sort keys(%CompatProblems))
	3025	{
	3026	foreach my $Kind (sort keys(%{$CompatProblems{$Method}}))
	3027	{
	3028	if($Kind eq "Added_Method")
	3029	{
	3030	my $ArchiveName = $MethodInfo{2}{$Method}{"Archive"};
[11682]	3031	my $ClassName = getShortName($MethodInfo{2}{$Method}{"Class"}, 2);
[10845]	3032	if($Level eq "Source")
	3033	{
	3034	if($ChangedReturnFromVoid{$Method}) {
	3035	next;
	3036	}
	3037	}
	3038	$MethodAddedInArchiveClass{$ArchiveName}{$ClassName}{$Method} = 1;
	3039	}
	3040	}
	3041	}
	3042	my $Added_Number = 0;
	3043	foreach my $ArchiveName (sort {lc($a) cmp lc($b)} keys(%MethodAddedInArchiveClass))
	3044	{
	3045	foreach my $ClassName (sort {lc($a) cmp lc($b)} keys(%{$MethodAddedInArchiveClass{$ArchiveName}}))
	3046	{
	3047	my %NameSpace_Method = ();
	3048	foreach my $Method (keys(%{$MethodAddedInArchiveClass{$ArchiveName}{$ClassName}})) {
	3049	$NameSpace_Method{$MethodInfo{2}{$Method}{"Package"}}{$Method} = 1;
	3050	}
	3051
	3052	my $ShowClass = $ClassName;
	3053	$ShowClass=~s/<.*>//g;
	3054
	3055	foreach my $NameSpace (sort keys(%NameSpace_Method))
	3056	{
[11682]	3057	$ADDED_METHODS .= "<span class='jar'>$ArchiveName</span>, <span class='cname'>".specChars($ShowClass).".class</span><br/>\n";
[10845]	3058
	3059	if($NameSpace) {
	3060	$ADDED_METHODS .= "<span class='pkg_t'>package</span> <span class='pkg'>$NameSpace</span><br/>\n";
	3061	}
	3062
[11682]	3063	if($In::Opt{"Compact"}) {
[10845]	3064	$ADDED_METHODS .= "<div class='symbols'>";
	3065	}
	3066
[12872]	3067	my @SortedMethods = sort {lc($MethodInfo{2}{$a}{"Signature"}) cmp lc($MethodInfo{2}{$b}{"Signature"})} sort keys(%{$NameSpace_Method{$NameSpace}});
[10845]	3068	foreach my $Method (@SortedMethods)
	3069	{
	3070	$Added_Number += 1;
	3071
	3072	my $Signature = undef;
	3073
[11682]	3074	if($In::Opt{"Compact"}) {
	3075	$Signature = getSignature($Method, 2, "Full\|HTML\|Simple");
[10845]	3076	}
	3077	else {
[11682]	3078	$Signature = highLight_ItalicColor($Method, 2);
[10845]	3079	}
	3080
	3081	if($NameSpace) {
	3082	$Signature=~s/(\W\|\A)\Q$NameSpace\E\.(\w)/$1$2/g;
	3083	}
	3084
[11682]	3085	if($In::Opt{"Compact"}) {
[10845]	3086	$ADDED_METHODS .= " ".$Signature."<br/>\n";
	3087	}
	3088	else {
[11682]	3089	$ADDED_METHODS .= insertIDs($ContentSpanStart.$Signature.$ContentSpanEnd."<br/>\n".$ContentDivStart."<span class='mngl'>".specChars($Method)."</span><br/><br/>".$ContentDivEnd."\n");
[10845]	3090	}
	3091	}
	3092
[11682]	3093	if($In::Opt{"Compact"}) {
[10845]	3094	$ADDED_METHODS .= "</div>";
	3095	}
	3096
	3097	$ADDED_METHODS .= "<br/>\n";
	3098	}
	3099
	3100	}
	3101	}
	3102	if($ADDED_METHODS)
	3103	{
	3104	my $Anchor = "<a name='Added'></a>";
[11682]	3105	if($In::Opt{"JoinReport"}) {
[10845]	3106	$Anchor = "<a name='".$Level."_Added'></a>";
	3107	}
[11682]	3108	if($In::Opt{"OldStyle"}) {
[10845]	3109	$ADDED_METHODS = "<h2>Added Methods ($Added_Number)</h2><hr/>\n".$ADDED_METHODS;
	3110	}
	3111	else {
	3112	$ADDED_METHODS = "<h2>Added Methods <span".getStyle("M", "Added", $Added_Number)."> $Added_Number </span></h2><hr/>\n".$ADDED_METHODS;
	3113	}
	3114	$ADDED_METHODS = $Anchor.$ADDED_METHODS.$TOP_REF."<br/>\n";
	3115	}
	3116	return $ADDED_METHODS;
	3117	}
	3118
[11682]	3119	sub getReportRemoved($)
[10845]	3120	{
[11682]	3121	if($In::Opt{"ShortMode"}) {
[10845]	3122	return "";
	3123	}
	3124
	3125	my $Level = $_[0];
	3126	my ($REMOVED_METHODS, %MethodRemovedFromArchiveClass);
	3127	foreach my $Method (sort keys(%CompatProblems))
	3128	{
	3129	foreach my $Kind (sort keys(%{$CompatProblems{$Method}}))
	3130	{
	3131	if($Kind eq "Removed_Method")
	3132	{
	3133	if($Level eq "Source")
	3134	{
	3135	if($ChangedReturnFromVoid{$Method}) {
	3136	next;
	3137	}
	3138	}
	3139	my $ArchiveName = $MethodInfo{1}{$Method}{"Archive"};
[11682]	3140	my $ClassName = getShortName($MethodInfo{1}{$Method}{"Class"}, 1);
[10845]	3141	$MethodRemovedFromArchiveClass{$ArchiveName}{$ClassName}{$Method} = 1;
	3142	}
	3143	}
	3144	}
	3145	my $Removed_Number = 0;
	3146	foreach my $ArchiveName (sort {lc($a) cmp lc($b)} keys(%MethodRemovedFromArchiveClass))
	3147	{
	3148	foreach my $ClassName (sort {lc($a) cmp lc($b)} keys(%{$MethodRemovedFromArchiveClass{$ArchiveName}}))
	3149	{
	3150	my %NameSpace_Method = ();
	3151	foreach my $Method (keys(%{$MethodRemovedFromArchiveClass{$ArchiveName}{$ClassName}}))
	3152	{
	3153	$NameSpace_Method{$MethodInfo{1}{$Method}{"Package"}}{$Method} = 1;
	3154	}
	3155
	3156	my $ShowClass = $ClassName;
	3157	$ShowClass=~s/<.*>//g;
	3158
	3159	foreach my $NameSpace (sort keys(%NameSpace_Method))
	3160	{
[11682]	3161	$REMOVED_METHODS .= "<span class='jar'>$ArchiveName</span>, <span class='cname'>".specChars($ShowClass).".class</span><br/>\n";
[10845]	3162
	3163	if($NameSpace) {
	3164	$REMOVED_METHODS .= "<span class='pkg_t'>package</span> <span class='pkg'>$NameSpace</span><br/>\n";
	3165	}
	3166
[11682]	3167	if($In::Opt{"Compact"}) {
[10845]	3168	$REMOVED_METHODS .= "<div class='symbols'>";
	3169	}
	3170
[12872]	3171	my @SortedMethods = sort {lc($MethodInfo{1}{$a}{"Signature"}) cmp lc($MethodInfo{1}{$b}{"Signature"})} sort keys(%{$NameSpace_Method{$NameSpace}});
[10845]	3172	foreach my $Method (@SortedMethods)
	3173	{
	3174	$Removed_Number += 1;
	3175
	3176	my $Signature = undef;
	3177
[11682]	3178	if($In::Opt{"Compact"}) {
	3179	$Signature = getSignature($Method, 1, "Full\|HTML\|Simple");
[10845]	3180	}
	3181	else {
[11682]	3182	$Signature = highLight_ItalicColor($Method, 1);
[10845]	3183	}
	3184
	3185	if($NameSpace) {
	3186	$Signature=~s/(\W\|\A)\Q$NameSpace\E\.(\w)/$1$2/g;
	3187	}
	3188
[11682]	3189	if($In::Opt{"Compact"}) {
[10845]	3190	$REMOVED_METHODS .= " ".$Signature."<br/>\n";
	3191	}
	3192	else {
[11682]	3193	$REMOVED_METHODS .= insertIDs($ContentSpanStart.$Signature.$ContentSpanEnd."<br/>\n".$ContentDivStart."<span class='mngl'>".specChars($Method)."</span><br/><br/>".$ContentDivEnd."\n");
[10845]	3194	}
	3195	}
	3196
[11682]	3197	if($In::Opt{"Compact"}) {
[10845]	3198	$REMOVED_METHODS .= "</div>";
	3199	}
	3200
	3201	$REMOVED_METHODS .= "<br/>\n";
	3202	}
	3203	}
	3204	}
	3205	if($REMOVED_METHODS)
	3206	{
	3207	my $Anchor = "<a name='Removed'></a><a name='Withdrawn'></a>";
[11682]	3208	if($In::Opt{"JoinReport"}) {
[10845]	3209	$Anchor = "<a name='".$Level."_Removed'></a><a name='".$Level."_Withdrawn'></a>";
	3210	}
[11682]	3211	if($In::Opt{"OldStyle"}) {
[10845]	3212	$REMOVED_METHODS = "<h2>Removed Methods ($Removed_Number)</h2><hr/>\n".$REMOVED_METHODS;
	3213	}
	3214	else {
	3215	$REMOVED_METHODS = "<h2>Removed Methods <span".getStyle("M", "Removed", $Removed_Number)."> $Removed_Number </span></h2><hr/>\n".$REMOVED_METHODS;
	3216	}
	3217	$REMOVED_METHODS = $Anchor.$REMOVED_METHODS.$TOP_REF."<br/>\n";
	3218	}
	3219	return $REMOVED_METHODS;
	3220	}
	3221
[11682]	3222	sub readRules($)
[10845]	3223	{
[11682]	3224	my $Kind = $_[0];
	3225	if(not -f $RULES_PATH{$Kind}) {
	3226	exitStatus("Module_Error", "can't access \'".$RULES_PATH{$Kind}."\'");
	3227	}
	3228	my $Content = readFile($RULES_PATH{$Kind});
	3229	while(my $Rule = parseTag(\$Content, "rule"))
	3230	{
	3231	my $RId = parseTag(\$Rule, "id");
	3232	my @Properties = ("Severity", "Change", "Effect", "Overcome", "Kind");
	3233	foreach my $Prop (@Properties) {
	3234	if(my $Value = parseTag(\$Rule, lc($Prop)))
	3235	{
	3236	$Value=~s/\n[ ]*//;
	3237	$CompatRules{$Kind}{$RId}{$Prop} = $Value;
	3238	}
	3239	}
	3240	if($CompatRules{$Kind}{$RId}{"Kind"}=~/\A(Methods\|Parameters)\Z/) {
	3241	$CompatRules{$Kind}{$RId}{"Kind"} = "Methods";
	3242	}
	3243	else { # Types, Fields
	3244	$CompatRules{$Kind}{$RId}{"Kind"} = "Types";
	3245	}
	3246	}
	3247	}
	3248
	3249	sub addMarkup($)
	3250	{
	3251	my $Content = $_[0];
	3252
	3253	# auto-markup
	3254	$Content=~s/\n[ ]*//; # spaces
	3255	$Content=~s!([2-9]\))!<br/>$1!g; # 1), 2), ...
	3256	if($Content=~/\ANOTE:/)
	3257	{ # notes
	3258	$Content=~s!(NOTE):!<b>$1</b>:!g;
	3259	}
	3260	else {
	3261	$Content=~s!(NOTE):!<br/><br/><b>$1</b>:!g;
	3262	}
	3263
	3264	my @Keywords = (
	3265	"static",
	3266	"abstract",
	3267	"default",
	3268	"final",
	3269	"synchronized"
	3270	);
	3271
	3272	my $MKeys = join("\|", @Keywords);
	3273	foreach (@Keywords) {
	3274	$MKeys .= "\|non-".$_;
	3275	}
	3276
	3277	$Content=~s!(became\s*)($MKeys)([^\w-]\|\Z)!$1<b>$2</b>$3!ig; # intrinsic types, modifiers
	3278
	3279	# Markdown
	3280	$Content=~s!\\([\w\-\@]+)\\!<b>$1</b>!ig;
	3281	$Content=~s!\([\w\-]+)\!<i>$1</i>!ig;
	3282
	3283	return $Content;
	3284	}
	3285
[12872]	3286	sub applyMacroses($$$$$$)
[11682]	3287	{
[12872]	3288	my ($Level, $Subj, $Kind, $Content, $Problem, $AddAttr) = @_;
[11682]	3289
	3290	$Content = addMarkup($Content);
	3291
	3292	# macros
	3293	foreach my $Attr (sort {$b cmp $a} (keys(%{$Problem}), keys(%{$AddAttr})))
	3294	{
	3295	my $Macro = "\@".lc($Attr);
	3296	my $Value = undef;
	3297
	3298	if(defined $Problem->{$Attr}) {
	3299	$Value = $Problem->{$Attr};
	3300	}
	3301	else {
	3302	$Value = $AddAttr->{$Attr};
	3303	}
	3304
	3305	if(not defined $Value
	3306	or $Value eq "") {
	3307	next;
	3308	}
	3309
	3310	if(index($Content, $Macro)==-1) {
	3311	next;
	3312	}
	3313
	3314	if($Attr eq "Param_Pos") {
	3315	$Value = showPos($Value);
	3316	}
	3317
	3318	if($Attr eq "Invoked") {
	3319	$Value = blackName(specChars($Value));
	3320	}
	3321	elsif($Value=~/\s/) {
	3322	$Value = "<span class='value'>".specChars($Value)."</span>";
	3323	}
	3324	else
	3325	{
	3326	my $Fmt = "Class\|HTML\|Desc";
	3327
	3328	if($Attr ne "Invoked_By")
	3329	{
	3330	if($Attr eq "Method_Short"
	3331	or $Kind!~/Overridden\|Moved_Up/) {
	3332	$Fmt = "HTML\|Desc";
	3333	}
	3334	}
	3335
[12872]	3336	if($Subj eq "Change") {
	3337	$Fmt .= "\|Return";
	3338	}
	3339
[11682]	3340	if(defined $MethodInfo{1}{$Value}
	3341	and defined $MethodInfo{1}{$Value}{"ShortName"}) {
	3342	$Value = blackName(getSignature($Value, 1, $Fmt));
	3343	}
	3344	elsif(defined $MethodInfo{2}{$Value}
	3345	and defined $MethodInfo{2}{$Value}{"ShortName"}) {
	3346	$Value = blackName(getSignature($Value, 2, $Fmt));
	3347	}
	3348	else
	3349	{
	3350	$Value = specChars($Value);
	3351	if($Attr ne "Type_Type") {
	3352	$Value = "<b>".$Value."</b>";
	3353	}
	3354	}
	3355	}
	3356	$Content=~s/\Q$Macro\E/$Value/g;
	3357	}
	3358
	3359	if($Content=~/(\A\|[^\@\w])(\@\w+)/)
	3360	{
	3361	if(not $IncompleteRules{$Level}{$Kind})
	3362	{ # only one warning
	3363	printMsg("WARNING", "incomplete $2 in the rule \"$Kind\" (\"$Level\")");
	3364	$IncompleteRules{$Level}{$Kind} = 1;
	3365	}
	3366	}
	3367
	3368	return $Content;
	3369	}
	3370
	3371	sub getReportMethodProblems($$)
	3372	{
[10845]	3373	my ($TargetSeverity, $Level) = @_;
	3374	my $METHOD_PROBLEMS = "";
	3375	my (%ReportMap, %MethodChanges) = ();
	3376
	3377	foreach my $Method (sort keys(%CompatProblems))
	3378	{
	3379	my $ArchiveName = $MethodInfo{1}{$Method}{"Archive"};
[11682]	3380	my $ClassName = getShortName($MethodInfo{1}{$Method}{"Class"}, 1);
[10845]	3381
	3382	foreach my $Kind (sort keys(%{$CompatProblems{$Method}}))
	3383	{
[11682]	3384	if($CompatRules{$Level}{$Kind}{"Kind"} eq "Methods")
[10845]	3385	{
[11682]	3386	if($Kind eq "Added_Method"
	3387	or $Kind eq "Removed_Method") {
[10845]	3388	next;
	3389	}
	3390
[11682]	3391	if(my $Severity = $CompatRules{$Level}{$Kind}{"Severity"})
	3392	{
	3393	if($Severity ne $TargetSeverity) {
	3394	next;
	3395	}
	3396
	3397	$MethodChanges{$Method}{$Kind} = $CompatProblems{$Method}{$Kind};
	3398	$ReportMap{$ArchiveName}{$ClassName}{$Method} = 1;
	3399	}
[10845]	3400	}
	3401	}
	3402	}
	3403	my $ProblemsNum = 0;
	3404	foreach my $ArchiveName (sort {lc($a) cmp lc($b)} keys(%ReportMap))
	3405	{
	3406	foreach my $ClassName (sort {lc($a) cmp lc($b)} keys(%{$ReportMap{$ArchiveName}}))
	3407	{
	3408	my %NameSpace_Method = ();
	3409	foreach my $Method (keys(%{$ReportMap{$ArchiveName}{$ClassName}})) {
	3410	$NameSpace_Method{$MethodInfo{1}{$Method}{"Package"}}{$Method} = 1;
	3411	}
	3412
	3413	my $ShowClass = $ClassName;
	3414	$ShowClass=~s/<.*>//g;
	3415
	3416	foreach my $NameSpace (sort keys(%NameSpace_Method))
	3417	{
[11682]	3418	$METHOD_PROBLEMS .= "<span class='jar'>$ArchiveName</span>, <span class='cname'>".specChars($ShowClass).".class</span><br/>\n";
[10845]	3419	if($NameSpace) {
	3420	$METHOD_PROBLEMS .= "<span class='pkg_t'>package</span> <span class='pkg'>$NameSpace</span><br/>\n";
	3421	}
	3422
[12872]	3423	my @SortedMethods = sort {lc($MethodInfo{1}{$a}{"Signature"}) cmp lc($MethodInfo{1}{$b}{"Signature"})} sort keys(%{$NameSpace_Method{$NameSpace}});
[10845]	3424	foreach my $Method (@SortedMethods)
	3425	{
[11682]	3426	my %AddAttr = ();
	3427
	3428	$AddAttr{"Method_Short"} = $Method;
	3429	$AddAttr{"Class"} = getTypeName($MethodInfo{1}{$Method}{"Class"}, 1);
	3430
[10845]	3431	my $METHOD_REPORT = "";
	3432	my $ProblemNum = 1;
	3433	foreach my $Kind (sort keys(%{$MethodChanges{$Method}}))
	3434	{
[11682]	3435	foreach my $Loc (sort keys(%{$MethodChanges{$Method}{$Kind}}))
[10845]	3436	{
[11682]	3437	my $ProblemAttr = $MethodChanges{$Method}{$Kind}{$Loc};
[10845]	3438
[12872]	3439	if(my $Change = applyMacroses($Level, "Change", $Kind, $CompatRules{$Level}{$Kind}{"Change"}, $ProblemAttr, \%AddAttr))
[10845]	3440	{
[12872]	3441	my $Effect = applyMacroses($Level, "Effect", $Kind, $CompatRules{$Level}{$Kind}{"Effect"}, $ProblemAttr, \%AddAttr);
[11682]	3442	$METHOD_REPORT .= "<tr>\n<th>$ProblemNum</th>\n<td>".$Change."</td>\n<td>".$Effect."</td>\n</tr>\n";
[10845]	3443	$ProblemNum += 1;
	3444	$ProblemsNum += 1;
	3445	}
	3446	}
	3447	}
	3448	$ProblemNum -= 1;
	3449	if($METHOD_REPORT)
	3450	{
[11682]	3451	my $ShowMethod = highLight_ItalicColor($Method, 1);
[10845]	3452	if($NameSpace)
	3453	{
[11682]	3454	$METHOD_REPORT = cutNs($METHOD_REPORT, $NameSpace);
	3455	$ShowMethod = cutNs($ShowMethod, $NameSpace);
[10845]	3456	}
	3457
	3458	$METHOD_PROBLEMS .= $ContentSpanStart."<span class='ext'>[+]</span> ".$ShowMethod;
[11682]	3459	if($In::Opt{"OldStyle"}) {
[10845]	3460	$METHOD_PROBLEMS .= " ($ProblemNum)";
	3461	}
	3462	else {
	3463	$METHOD_PROBLEMS .= " <span".getStyle("M", $TargetSeverity, $ProblemNum)."> $ProblemNum </span>";
	3464	}
	3465	$METHOD_PROBLEMS .= $ContentSpanEnd."<br/>\n";
	3466	$METHOD_PROBLEMS .= $ContentDivStart;
	3467
[11682]	3468	if(not $In::Opt{"Compact"}) {
	3469	$METHOD_PROBLEMS .= "<span class='mngl pleft'>".specChars($Method)."</span><br/>\n";
[10845]	3470	}
	3471
	3472	$METHOD_PROBLEMS .= "<table class='ptable'><tr><th width='2%'></th><th width='47%'>Change</th><th>Effect</th></tr>$METHOD_REPORT</table><br/>$ContentDivEnd\n";
	3473
	3474	}
	3475	}
	3476
	3477	$METHOD_PROBLEMS .= "<br/>";
	3478	}
	3479	}
	3480	}
	3481	if($METHOD_PROBLEMS)
	3482	{
	3483	$METHOD_PROBLEMS = insertIDs($METHOD_PROBLEMS);
	3484
	3485	my $Title = "Problems with Methods, $TargetSeverity Severity";
	3486	if($TargetSeverity eq "Safe")
	3487	{ # Safe Changes
	3488	$Title = "Other Changes in Methods";
	3489	}
[11682]	3490	if($In::Opt{"OldStyle"}) {
[10845]	3491	$METHOD_PROBLEMS = "<h2>$Title ($ProblemsNum)</h2><hr/>\n".$METHOD_PROBLEMS;
	3492	}
	3493	else {
	3494	$METHOD_PROBLEMS = "<h2>$Title <span".getStyle("M", $TargetSeverity, $ProblemsNum)."> $ProblemsNum </span></h2><hr/>\n".$METHOD_PROBLEMS;
	3495	}
[11682]	3496	$METHOD_PROBLEMS = "<a name='".getAnchor("Method", $Level, $TargetSeverity)."'></a>\n".$METHOD_PROBLEMS;
[10845]	3497	$METHOD_PROBLEMS .= $TOP_REF."<br/>\n";
	3498	}
	3499	return $METHOD_PROBLEMS;
	3500	}
	3501
[11682]	3502	sub showType($$$)
[10845]	3503	{
[11682]	3504	my ($Name, $Html, $LVer) = @_;
[13595]	3505	my $TInfo = $TypeInfo{$LVer}{$TName_Tid{$LVer}{$Name}};
	3506	my $TType = $TInfo->{"Type"};
	3507
	3508	if($TInfo->{"Annotation"}) {
	3509	$TType = '@'.$TType;
	3510	}
	3511
[11682]	3512	if($Html) {
	3513	$Name = "<span class='ttype'>".$TType."</span> ".specChars($Name);
	3514	}
	3515	else {
	3516	$Name = $TType." ".$Name;
	3517	}
	3518	return $Name;
	3519	}
	3520
	3521	sub getReportTypeProblems($$)
	3522	{
[10845]	3523	my ($TargetSeverity, $Level) = @_;
	3524	my $TYPE_PROBLEMS = "";
[11682]	3525
[10845]	3526	my %ReportMap = ();
	3527	my %TypeChanges_Sev = ();
	3528
	3529	foreach my $TypeName (keys(%{$TypeChanges{$Level}}))
	3530	{
	3531	my $ArchiveName = $TypeInfo{1}{$TName_Tid{1}{$TypeName}}{"Archive"};
	3532
	3533	foreach my $Kind (keys(%{$TypeChanges{$Level}{$TypeName}}))
	3534	{
[11682]	3535	if($CompatRules{$Level}{$Kind}{"Severity"} ne $TargetSeverity) {
[10845]	3536	next;
	3537	}
	3538
[11682]	3539	foreach my $Loc (keys(%{$TypeChanges{$Level}{$TypeName}{$Kind}}))
[10845]	3540	{
	3541	$ReportMap{$ArchiveName}{$TypeName} = 1;
[11682]	3542	$TypeChanges_Sev{$TypeName}{$Kind}{$Loc} = $TypeChanges{$Level}{$TypeName}{$Kind}{$Loc};
[10845]	3543	}
	3544	}
	3545	}
	3546
	3547	my $ProblemsNum = 0;
	3548	foreach my $ArchiveName (sort {lc($a) cmp lc($b)} keys(%ReportMap))
	3549	{
[11682]	3550	my %NameSpace_Type = ();
	3551	foreach my $TypeName (keys(%{$ReportMap{$ArchiveName}})) {
[10845]	3552	$NameSpace_Type{$TypeInfo{1}{$TName_Tid{1}{$TypeName}}{"Package"}}{$TypeName} = 1;
	3553	}
	3554	foreach my $NameSpace (sort keys(%NameSpace_Type))
	3555	{
	3556	$TYPE_PROBLEMS .= "<span class='jar'>$ArchiveName</span><br/>\n";
	3557	if($NameSpace) {
	3558	$TYPE_PROBLEMS .= "<span class='pkg_t'>package</span> <span class='pkg'>".$NameSpace."</span><br/>\n";
	3559	}
	3560
[11682]	3561	my @SortedTypes = sort {lc(showType($a, 0, 1)) cmp lc(showType($b, 0, 1))} keys(%{$NameSpace_Type{$NameSpace}});
[10845]	3562	foreach my $TypeName (@SortedTypes)
	3563	{
	3564	my $TypeId = $TName_Tid{1}{$TypeName};
[11682]	3565
[10845]	3566	my $ProblemNum = 1;
	3567	my $TYPE_REPORT = "";
	3568	my (%Kinds_Locations, %Kinds_Target) = ();
[11682]	3569
[10845]	3570	foreach my $Kind (sort keys(%{$TypeChanges_Sev{$TypeName}}))
	3571	{
	3572	foreach my $Location (sort keys(%{$TypeChanges_Sev{$TypeName}{$Kind}}))
	3573	{
	3574	$Kinds_Locations{$Kind}{$Location} = 1;
	3575
	3576	my $Target = $TypeChanges_Sev{$TypeName}{$Kind}{$Location}{"Target"};
	3577	if($Kinds_Target{$Kind}{$Target}) {
	3578	next;
	3579	}
	3580	$Kinds_Target{$Kind}{$Target} = 1;
	3581
[11682]	3582	my %AddAttr = ();
[10845]	3583
[11682]	3584	if($Kind=~/Method/)
[10845]	3585	{
[11682]	3586	if(defined $MethodInfo{1}{$Target} and $MethodInfo{1}{$Target}{"Name"})
[10845]	3587	{
[11682]	3588	$AddAttr{"Method_Short"} = $Target;
	3589	$AddAttr{"Class"} = getTypeName($MethodInfo{1}{$Target}{"Class"}, 1);
[10845]	3590	}
[11682]	3591	elsif(defined $MethodInfo{2}{$Target} and $MethodInfo{2}{$Target}{"Name"})
[10845]	3592	{
[11682]	3593	$AddAttr{"Method_Short"} = $Target;
	3594	$AddAttr{"Class"} = getTypeName($MethodInfo{2}{$Target}{"Class"}, 2);
[10845]	3595	}
	3596	}
[11682]	3597
	3598	my $ProblemAttr = $TypeChanges_Sev{$TypeName}{$Kind}{$Location};
	3599
[12872]	3600	if(my $Change = applyMacroses($Level, "Change", $Kind, $CompatRules{$Level}{$Kind}{"Change"}, $ProblemAttr, \%AddAttr))
[10845]	3601	{
[12872]	3602	my $Effect = applyMacroses($Level, "Effect", $Kind, $CompatRules{$Level}{$Kind}{"Effect"}, $ProblemAttr, \%AddAttr);
[11682]	3603
	3604	$TYPE_REPORT .= "<tr>\n<th>$ProblemNum</th>\n<td>".$Change."</td>\n<td>".$Effect."</td>\n</tr>\n";
[10845]	3605	$ProblemNum += 1;
	3606	$ProblemsNum += 1;
	3607	}
	3608	}
	3609	}
	3610	$ProblemNum -= 1;
	3611	if($TYPE_REPORT)
	3612	{
	3613	my $Affected = "";
	3614	if(not defined $TypeInfo{1}{$TypeId}{"Annotation"}) {
	3615	$Affected = getAffectedMethods($Level, $TypeName, \%Kinds_Locations);
	3616	}
	3617
[11682]	3618	my $ShowType = showType($TypeName, 1, 1);
[10845]	3619	if($NameSpace)
	3620	{
[11682]	3621	$TYPE_REPORT = cutNs($TYPE_REPORT, $NameSpace);
	3622	$ShowType = cutNs($ShowType, $NameSpace);
	3623	$Affected = cutNs($Affected, $NameSpace);
[10845]	3624	}
	3625
[11682]	3626	$TYPE_PROBLEMS .= $ContentSpanStart."<span class='ext'>[+]</span> ".$ShowType;
	3627	if($In::Opt{"OldStyle"}) {
[10845]	3628	$TYPE_PROBLEMS .= " ($ProblemNum)";
	3629	}
	3630	else {
	3631	$TYPE_PROBLEMS .= " <span".getStyle("T", $TargetSeverity, $ProblemNum)."> $ProblemNum </span>";
	3632	}
	3633	$TYPE_PROBLEMS .= $ContentSpanEnd."<br/>\n";
	3634	$TYPE_PROBLEMS .= $ContentDivStart."<table class='ptable'><tr>";
	3635	$TYPE_PROBLEMS .= "<th width='2%'></th><th width='47%'>Change</th><th>Effect</th>";
	3636	$TYPE_PROBLEMS .= "</tr>$TYPE_REPORT</table>".$Affected."<br/><br/>$ContentDivEnd\n";
	3637	}
	3638	}
	3639
	3640	$TYPE_PROBLEMS .= "<br/>";
	3641	}
	3642	}
	3643	if($TYPE_PROBLEMS)
	3644	{
	3645	$TYPE_PROBLEMS = insertIDs($TYPE_PROBLEMS);
	3646
	3647	my $Title = "Problems with Data Types, $TargetSeverity Severity";
	3648	if($TargetSeverity eq "Safe")
	3649	{ # Safe Changes
	3650	$Title = "Other Changes in Data Types";
	3651	}
[11682]	3652	if($In::Opt{"OldStyle"}) {
[10845]	3653	$TYPE_PROBLEMS = "<h2>$Title ($ProblemsNum)</h2><hr/>\n".$TYPE_PROBLEMS;
	3654	}
	3655	else {
	3656	$TYPE_PROBLEMS = "<h2>$Title <span".getStyle("T", $TargetSeverity, $ProblemsNum)."> $ProblemsNum </span></h2><hr/>\n".$TYPE_PROBLEMS;
	3657	}
[11682]	3658	$TYPE_PROBLEMS = "<a name='".getAnchor("Type", $Level, $TargetSeverity)."'></a>\n".$TYPE_PROBLEMS;
[10845]	3659	$TYPE_PROBLEMS .= $TOP_REF."<br/>\n";
	3660	}
	3661	return $TYPE_PROBLEMS;
	3662	}
	3663
[11682]	3664	sub cutNs($$)
[10845]	3665	{
	3666	my ($N, $Ns) = @_;
	3667	$N=~s/(\W\|\A)\Q$Ns\E\.(\w)/$1$2/g;
	3668	return $N;
	3669	}
	3670
	3671	sub getAffectedMethods($$$)
	3672	{
	3673	my ($Level, $Target_TypeName, $Kinds_Locations) = @_;
	3674
	3675	my $LIMIT = 10;
[11682]	3676	if(defined $In::Opt{"AffectLimit"}) {
	3677	$LIMIT = $In::Opt{"AffectLimit"};
[10845]	3678	}
	3679
[11682]	3680	my %SymSel = ();
[10845]	3681
[11682]	3682	foreach my $Kind (sort keys(%{$Kinds_Locations}))
[10845]	3683	{
[11682]	3684	my @Locs = sort {(index($a, "retval")!=-1) cmp (index($b, "retval")!=-1)} sort {length($a)<=>length($b)} sort keys(%{$Kinds_Locations->{$Kind}});
[10845]	3685
[11682]	3686	foreach my $Loc (@Locs)
[10845]	3687	{
[11682]	3688	foreach my $Method (keys(%{$TypeProblemsIndex{$Level}{$Target_TypeName}{$Kind}{$Loc}}))
[10845]	3689	{
[11682]	3690	if($Method eq ".client_method") {
[10845]	3691	next;
	3692	}
	3693
[11682]	3694	if(not defined $SymSel{$Method})
	3695	{
	3696	$SymSel{$Method}{"Kind"} = $Kind;
	3697	$SymSel{$Method}{"Loc"} = $Loc;
[10845]	3698	}
	3699	}
	3700	}
	3701	}
	3702
[11682]	3703	my $Total = keys(%SymSel);
[10845]	3704
[11682]	3705	if(not $Total) {
[10845]	3706	return "";
	3707	}
	3708
	3709	my $Affected = "";
[11682]	3710	my $SNum = 0;
[10845]	3711
	3712	foreach my $Method (sort {lc($a) cmp lc($b)} keys(%SymSel))
	3713	{
	3714	my $Kind = $SymSel{$Method}{"Kind"};
	3715	my $Loc = $SymSel{$Method}{"Loc"};
	3716
	3717	my $Desc = getAffectDesc($Method, $Kind, $Loc, $Level);
	3718	my $PName = getParamName($Loc);
	3719	my $Pos = getParamPos($PName, $Method, 1);
	3720
[11682]	3721	$Affected .= "<span class='iname_a'>".getSignature($Method, 1, "HTML\|Italic\|Param\|Class\|Target=".$Pos)."</span><br/>";
[10845]	3722	$Affected .= "<div class='affect'>".$Desc."</div>\n";
[11682]	3723
	3724	if(++$SNum>=$LIMIT) {
	3725	last;
	3726	}
[10845]	3727	}
	3728
[11682]	3729	if($Total>$LIMIT) {
[10845]	3730	$Affected .= " <b>...</b>\n<br/>\n"; # and others ...
	3731	}
	3732
	3733	$Affected = "<div class='affected'>".$Affected."</div>";
	3734	if($Affected)
	3735	{
[11682]	3736	my $Per = showNum($Total*100/keys(%CheckedMethods));
[10845]	3737	$Affected = $ContentDivStart.$Affected.$ContentDivEnd;
[11682]	3738	$Affected = $ContentSpanStart_Affected."[+] affected methods: $Total ($Per\%)".$ContentSpanEnd.$Affected;
[10845]	3739	}
	3740
[11682]	3741	return $Affected;
[10845]	3742	}
	3743
	3744	sub getAffectDesc($$$$)
	3745	{
	3746	my ($Method, $Kind, $Location, $Level) = @_;
	3747	my %Affect = %{$CompatProblems{$Method}{$Kind}{$Location}};
	3748	my $New_Value = $Affect{"New_Value"};
	3749	my $Type_Name = $Affect{"Type_Name"};
	3750	my @Sentence_Parts = ();
	3751
	3752	$Location=~s/\.[^.]+?\Z//;
	3753
[11682]	3754	my $TypeAttr = getType($MethodInfo{1}{$Method}{"Class"}, 1);
	3755	my $Type_Type = $TypeAttr->{"Type"};
[10845]	3756
	3757	my $ABSTRACT_M = $MethodInfo{1}{$Method}{"Abstract"}?" abstract":"";
[11682]	3758	my $ABSTRACT_C = $TypeAttr->{"Abstract"}?" abstract":"";
[10845]	3759	my $METHOD_TYPE = $MethodInfo{1}{$Method}{"Constructor"}?"constructor":"method";
	3760
	3761	if($Kind eq "Class_Overridden_Method" or $Kind eq "Class_Method_Moved_Up_Hierarchy") {
[11682]	3762	return "Method '".getSignature($New_Value, 2, "Class\|HTML\|Italic")."' will be called instead of this method in a client program.";
[10845]	3763	}
[11682]	3764	elsif($CompatRules{$Level}{$Kind}{"Kind"} eq "Types")
[10845]	3765	{
	3766	my %MInfo = %{$MethodInfo{1}{$Method}};
	3767
	3768	if($Location eq "this") {
[11682]	3769	return "This$ABSTRACT_M $METHOD_TYPE is from \'".specChars($Type_Name)."\'$ABSTRACT_C $Type_Type.";
[10845]	3770	}
	3771
	3772	my $TypeID = undef;
	3773
	3774	if($Location=~/retval/)
	3775	{ # return value
	3776	if($Location=~/\./) {
[11682]	3777	push(@Sentence_Parts, "Field \'".specChars($Location)."\' in the return value");
[10845]	3778	}
	3779	else {
	3780	push(@Sentence_Parts, "Return value");
	3781	}
	3782
	3783	$TypeID = $MInfo{"Return"};
	3784	}
	3785	elsif($Location=~/this/)
	3786	{ # "this" reference
[11682]	3787	push(@Sentence_Parts, "Field \'".specChars($Location)."\' in the object");
[10845]	3788
	3789	$TypeID = $MInfo{"Class"};
	3790	}
	3791	else
	3792	{ # parameters
	3793	my $PName = getParamName($Location);
	3794	my $PPos = getParamPos($PName, $Method, 1);
	3795
	3796	if($Location=~/\./) {
[11682]	3797	push(@Sentence_Parts, "Field \'".specChars($Location)."\' in ".showPos($PPos)." parameter");
[10845]	3798	}
	3799	else {
	3800	push(@Sentence_Parts, showPos($PPos)." parameter");
	3801	}
	3802	if($PName) {
	3803	push(@Sentence_Parts, "\'$PName\'");
	3804	}
	3805
	3806	if(defined $MInfo{"Param"}) {
	3807	$TypeID = $MInfo{"Param"}{$PPos}{"Type"};
	3808	}
	3809	}
	3810	push(@Sentence_Parts, " of this$ABSTRACT_M method");
	3811
	3812	my $Location_T = $Location;
	3813	$Location_T=~s/\A\w+(\.\|\Z)//; # location in type
	3814
	3815	my $TypeID_Problem = $TypeID;
	3816	if($Location_T) {
	3817	$TypeID_Problem = getFieldType($Location_T, $TypeID, 1);
	3818	}
	3819
	3820	if($TypeInfo{1}{$TypeID_Problem}{"Name"} eq $Type_Name) {
[11682]	3821	push(@Sentence_Parts, "is of type \'".specChars($Type_Name)."\'.");
[10845]	3822	}
	3823	else {
[11682]	3824	push(@Sentence_Parts, "has base type \'".specChars($Type_Name)."\'.");
[10845]	3825	}
	3826	}
	3827	return join(" ", @Sentence_Parts);
	3828	}
	3829
	3830	sub getParamPos($$$)
	3831	{
[11682]	3832	my ($Name, $Method, $LVer) = @_;
[10845]	3833
[11682]	3834	if(defined $MethodInfo{$LVer}{$Method}
	3835	and defined $MethodInfo{$LVer}{$Method}{"Param"})
[10845]	3836	{
[11682]	3837	my $Info = $MethodInfo{$LVer}{$Method};
[10845]	3838	foreach (keys(%{$Info->{"Param"}}))
	3839	{
	3840	if($Info->{"Param"}{$_}{"Name"} eq $Name)
	3841	{
	3842	return $_;
	3843	}
	3844	}
	3845	}
	3846
	3847	return undef;
	3848	}
	3849
	3850	sub getParamName($)
	3851	{
	3852	my $Loc = $_[0];
	3853	$Loc=~s/\..*//g;
	3854	return $Loc;
	3855	}
	3856
	3857	sub getFieldType($$$)
	3858	{
[11682]	3859	my ($Location, $TypeId, $LVer) = @_;
[10845]	3860
	3861	my @Fields = split(/\./, $Location);
	3862
	3863	foreach my $Name (@Fields)
	3864	{
[11682]	3865	my $TInfo = getBaseType($TypeId, $LVer);
[10845]	3866
[11682]	3867	foreach my $N (keys(%{$TInfo->{"Fields"}}))
[10845]	3868	{
	3869	if($N eq $Name)
	3870	{
[11682]	3871	$TypeId = $TInfo->{"Fields"}{$N}{"Type"};
[10845]	3872	last;
	3873	}
	3874	}
	3875	}
	3876
	3877	return $TypeId;
	3878	}
	3879
	3880	sub writeReport($$)
	3881	{
	3882	my ($Level, $Report) = @_;
	3883	my $RPath = getReportPath($Level);
	3884	writeFile($RPath, $Report);
	3885	}
	3886
	3887	sub createReport()
	3888	{
[11682]	3889	if($In::Opt{"JoinReport"}) {
[10845]	3890	writeReport("Join", getReport("Join"));
	3891	}
[11682]	3892	elsif($In::Opt{"DoubleReport"})
[10845]	3893	{ # default
	3894	writeReport("Binary", getReport("Binary"));
	3895	writeReport("Source", getReport("Source"));
	3896	}
[11682]	3897	elsif($In::Opt{"BinaryOnly"})
[10845]	3898	{ # --binary
	3899	writeReport("Binary", getReport("Binary"));
	3900	}
[11682]	3901	elsif($In::Opt{"SourceOnly"})
[10845]	3902	{ # --source
	3903	writeReport("Source", getReport("Source"));
	3904	}
	3905	}
	3906
[11682]	3907	sub getCssStyles($)
[10845]	3908	{
[11682]	3909	my $Level = $_[0];
[10845]	3910
[11682]	3911	my $CssStyles = readModule("Css", "Report.css");
[10845]	3912
[11682]	3913	if($Level eq "Join" or $In::Opt{"ExternCss"}) {
	3914	$CssStyles .= readModule("Css", "Tabs.css");
[10845]	3915	}
	3916
	3917	return $CssStyles;
	3918	}
	3919
[11682]	3920	sub getJsScript($)
[10845]	3921	{
[11682]	3922	my $Level = $_[0];
[10845]	3923
[11682]	3924	my $JScripts = readModule("Js", "Sections.js");
	3925
	3926	if($Level eq "Join" or $In::Opt{"ExternJs"}) {
	3927	$JScripts .= readModule("Js", "Tabs.js");
[10845]	3928	}
	3929
	3930	return $JScripts;
	3931	}
	3932
	3933	sub getReport($)
	3934	{
	3935	my $Level = $_[0];
	3936
[11682]	3937	my $CssStyles = getCssStyles($Level);
	3938	my $JScripts = getJsScript($Level);
[10845]	3939
[11682]	3940	if(defined $In::Opt{"ExternCss"}) {
	3941	writeFile($In::Opt{"ExternCss"}, $CssStyles);
[10845]	3942	}
	3943
[11682]	3944	if(defined $In::Opt{"ExternJs"}) {
	3945	writeFile($In::Opt{"ExternJs"}, $JScripts);
[10845]	3946	}
	3947
	3948	if($Level eq "Join")
	3949	{
[11682]	3950	my $Title = $In::Opt{"TargetTitle"}.": ".$In::Desc{1}{"Version"}." to ".$In::Desc{2}{"Version"}." compatibility report";
	3951	my $Keywords = $In::Opt{"TargetTitle"}.", compatibility";
	3952	my $Description = "Compatibility report for the ".$In::Opt{"TargetTitle"}." library between ".$In::Desc{1}{"Version"}." and ".$In::Desc{2}{"Version"}." versions";
	3953
[12872]	3954	my ($BSummary, $BMetaData, $BAnyChanged) = getSummary("Binary");
	3955	my ($SSummary, $SMetaData, $SAnyChanged) = getSummary("Source");
[11682]	3956
[12872]	3957	my $Report = "<!-\- $BMetaData -\->\n<!-\- $SMetaData -\->\n".composeHTML_Head($Level, $Title, $Keywords, $Description, $CssStyles, $JScripts, ($BAnyChanged or $SAnyChanged))."<body><a name='Source'></a><a name='Binary'></a><a name='Top'></a>";
[11682]	3958
	3959	$Report .= getReportHeader("Join");
	3960	$Report .= "<br/><div class='tabset'>\n";
	3961	$Report .= "<a id='BinaryID' href='#BinaryTab' class='tab active'>Binary<br/>Compatibility</a>\n";
	3962	$Report .= "<a id='SourceID' href='#SourceTab' style='margin-left:3px' class='tab disabled'>Source<br/>Compatibility</a>\n";
	3963	$Report .= "</div>\n";
	3964
	3965	$Report .= "<div id='BinaryTab' class='tab'>\n$BSummary\n".getReportAdded("Binary").getReportRemoved("Binary").getReportProblems("High", "Binary").getReportProblems("Medium", "Binary").getReportProblems("Low", "Binary").getReportProblems("Safe", "Binary").getSourceInfo()."<br/><br/><br/></div>";
	3966
	3967	$Report .= "<div id='SourceTab' class='tab'>\n$SSummary\n".getReportAdded("Source").getReportRemoved("Source").getReportProblems("High", "Source").getReportProblems("Medium", "Source").getReportProblems("Low", "Source").getReportProblems("Safe", "Source").getSourceInfo()."<br/><br/><br/></div>";
	3968
[10845]	3969	$Report .= getReportFooter();
	3970	$Report .= "\n</body></html>";
	3971	return $Report;
	3972	}
	3973	else
	3974	{
[12872]	3975	my ($Summary, $MetaData, $AnyChanged) = getSummary($Level);
[10845]	3976
[11682]	3977	my $Title = $In::Opt{"TargetTitle"}.": ".$In::Desc{1}{"Version"}." to ".$In::Desc{2}{"Version"}." ".lc($Level)." compatibility report";
	3978	my $Keywords = $In::Opt{"TargetTitle"}.", ".lc($Level).", compatibility";
	3979	my $Description = "$Level compatibility report for the ".$In::Opt{"TargetTitle"}." library between ".$In::Desc{1}{"Version"}." and ".$In::Desc{2}{"Version"}." versions";
	3980
[12872]	3981	my $Report = "<!-\- $MetaData -\->\n".composeHTML_Head($Level, $Title, $Keywords, $Description, $CssStyles, $JScripts, $AnyChanged)."<body><a name='Top'></a>";
[11682]	3982	$Report .= getReportHeader($Level)."\n".$Summary."\n";
	3983	$Report .= getReportAdded($Level).getReportRemoved($Level);
	3984	$Report .= getReportProblems("High", $Level).getReportProblems("Medium", $Level).getReportProblems("Low", $Level).getReportProblems("Safe", $Level);
	3985	$Report .= getSourceInfo()."<br/><br/><br/>\n";
[10845]	3986	$Report .= getReportFooter();
	3987	$Report .= "\n</body></html>";
	3988	return $Report;
	3989	}
	3990	}
	3991
	3992	sub getReportFooter()
	3993	{
	3994	my $Footer = "";
	3995	$Footer .= "<hr/>";
	3996	$Footer .= "<div class='footer' align='right'><i>Generated by ";
	3997	$Footer .= "<a href='".$HomePage{"Dev"}."'>Java API Compliance Checker</a> $TOOL_VERSION  ";
	3998	$Footer .= "</i></div>";
	3999	$Footer .= "<br/>";
	4000	return $Footer;
	4001	}
	4002
[11682]	4003	sub getReportProblems($$)
[10845]	4004	{
	4005	my ($Priority, $Level) = @_;
[11682]	4006	my $Report = getReportTypeProblems($Priority, $Level);
	4007	if(my $MProblems = getReportMethodProblems($Priority, $Level)) {
[10845]	4008	$Report .= $MProblems;
	4009	}
	4010	if($Report)
	4011	{
[11682]	4012	if($In::Opt{"JoinReport"})
[10845]	4013	{
	4014	if($Priority eq "Safe") {
	4015	$Report = "<a name=\'Other_".$Level."_Changes\'></a>".$Report;
	4016	}
	4017	else {
	4018	$Report = "<a name=\'".$Priority."_Risk_".$Level."_Problems\'></a>".$Report;
	4019	}
	4020	}
	4021	else
	4022	{
	4023	if($Priority eq "Safe") {
	4024	$Report = "<a name=\'Other_Changes\'></a>".$Report;
	4025	}
	4026	else {
	4027	$Report = "<a name=\'".$Priority."_Risk_Problems\'></a>".$Report;
	4028	}
	4029	}
	4030	}
	4031	return $Report;
	4032	}
	4033
[12872]	4034	sub composeHTML_Head($$$$$$$)
[10845]	4035	{
[12872]	4036	my ($Level, $Title, $Keywords, $Description, $Styles, $Scripts, $AnyChanged) = @_;
[10845]	4037
	4038	my $Head = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
	4039	$Head .= "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">\n";
	4040	$Head .= "<head>\n";
	4041	$Head .= "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n";
[13595]	4042	$Head .= "<meta name=\"viewport\" content=\"width=device-width,initial-scale=1\" />\n";
[10845]	4043	$Head .= "<meta name=\"keywords\" content=\"$Keywords\" />\n";
	4044	$Head .= "<meta name=\"description\" content=\"$Description\" />\n";
	4045
[12872]	4046	if(not $AnyChanged) {
	4047	$Head .= "<meta name=\"robots\" content=\"noindex\" />\n";
	4048	}
	4049
[10845]	4050	my $RPath = getReportPath($Level);
	4051
[11682]	4052	if(defined $In::Opt{"ExternCss"}) {
	4053	$Head .= "<link rel=\"stylesheet\" type=\"text/css\" href=\"".getRelPath($In::Opt{"ExternCss"}, $RPath)."\" />\n";
[10845]	4054	}
	4055
[11682]	4056	if(defined $In::Opt{"ExternJs"}) {
	4057	$Head .= "<script type=\"text/javascript\" src=\"".getRelPath($In::Opt{"ExternJs"}, $RPath)."\"></script>\n";
[10845]	4058	}
	4059
	4060	$Head .= "<title>$Title</title>\n";
	4061
[11682]	4062	if(not defined $In::Opt{"ExternCss"}) {
[10845]	4063	$Head .= "<style type=\"text/css\">\n$Styles\n</style>\n";
	4064	}
	4065
[11682]	4066	if(not defined $In::Opt{"ExternJs"}) {
[10845]	4067	$Head .= "<script type=\"text/javascript\" language=\"JavaScript\">\n<!--\n$Scripts\n-->\n</script>\n";
	4068	}
	4069
	4070	$Head .= "</head>\n";
	4071
	4072	return $Head;
	4073	}
	4074
	4075	sub insertIDs($)
	4076	{
	4077	my $Text = $_[0];
	4078	while($Text=~/CONTENT_ID/)
	4079	{
	4080	if(int($Content_Counter)%2)
	4081	{
	4082	$ContentID -= 1;
	4083	}
	4084	$Text=~s/CONTENT_ID/c_$ContentID/;
	4085	$ContentID += 1;
	4086	$Content_Counter += 1;
	4087	}
	4088	return $Text;
	4089	}
	4090
	4091	sub registerUsage($$)
	4092	{
[11682]	4093	my ($TypeId, $LVer) = @_;
	4094	$Class_Constructed{$LVer}{$TypeId} = 1;
	4095	if(my $BaseId = $TypeInfo{$LVer}{$TypeId}{"BaseType"}) {
	4096	$Class_Constructed{$LVer}{$BaseId} = 1;
[10845]	4097	}
	4098	}
	4099
	4100	sub checkVoidMethod($)
	4101	{
	4102	my $Method = $_[0];
[11682]	4103
[10845]	4104	if($Method=~s/\)(.+)\Z/\)V/g) {
	4105	return $Method;
	4106	}
[11682]	4107
	4108	return undef;
[10845]	4109	}
	4110
	4111	sub detectAdded()
	4112	{
	4113	foreach my $Method (keys(%{$MethodInfo{2}}))
	4114	{
	4115	if(not defined $MethodInfo{1}{$Method})
	4116	{
	4117	if(not methodFilter($Method, 2)) {
	4118	next;
	4119	}
	4120
[12872]	4121	my $Class = getType($MethodInfo{2}{$Method}{"Class"}, 2);
[10845]	4122
[13595]	4123	if(not defined $In::Opt{"CheckAnnotations"} and $Class->{"Annotation"}) {
	4124	next;
	4125	}
	4126
[12872]	4127	$CheckedTypes{$Class->{"Name"}} = 1;
[10845]	4128	$CheckedMethods{$Method} = 1;
	4129
	4130	if(not $MethodInfo{2}{$Method}{"Constructor"}
[12872]	4131	and my $Overridden = findMethod($Method, 2, $Class->{"Name"}, 2))
[10845]	4132	{
	4133	if(defined $MethodInfo{1}{$Overridden}
[12872]	4134	and $Class->{"Type"} eq "class"
	4135	and ($TName_Tid{1}{$Class->{"Name"}} or $TName_Tid_Generic{1}{getGeneric($Class->{"Name"})}))
[10845]	4136	{ # class should exist in previous version
[11682]	4137	%{$CompatProblems{$Overridden}{"Class_Overridden_Method"}{"this.".getSFormat($Method)}}=(
[12872]	4138	"Type_Name"=>$Class->{"Name"},
[10845]	4139	"Target"=>$MethodInfo{2}{$Method}{"Signature"},
	4140	"Old_Value"=>$Overridden,
[11682]	4141	"New_Value"=>$Method);
[10845]	4142	}
	4143	}
	4144	if($MethodInfo{2}{$Method}{"Abstract"}) {
[12872]	4145	$AddedMethod_Abstract{$Class->{"Name"}}{$Method} = 1;
[10845]	4146	}
	4147
[12872]	4148	if(not ($MethodInfo{2}{$Method}{"Access"} eq "protected" and $Class->{"Final"})) {
	4149	%{$CompatProblems{$Method}{"Added_Method"}{""}} = ();
	4150	}
[10845]	4151
	4152	if(not $MethodInfo{2}{$Method}{"Constructor"})
	4153	{
[12872]	4154	my $VoidMethod = checkVoidMethod($Method);
	4155	my $ReturnType = getTypeName($MethodInfo{2}{$Method}{"Return"}, 2);
	4156
	4157	if(defined $Class->{"GenericParam"}
	4158	and defined $Class->{"GenericParam"}{$ReturnType}) {
	4159	$ReturnType = getTypeName($Class->{"GenericParam"}{$ReturnType}, 2);
	4160	}
	4161
	4162	if(defined $MethodInfo{1}{$VoidMethod}
	4163	and $ReturnType ne "void")
	4164	{ # return value type changed from void
	4165	$ChangedReturnFromVoid{$VoidMethod} = 1;
	4166	$ChangedReturnFromVoid{$Method} = 1;
	4167
	4168	%{$CompatProblems{$VoidMethod}{"Changed_Method_Return_From_Void"}{""}}=(
	4169	"New_Value"=>getTypeName($MethodInfo{2}{$Method}{"Return"}, 2)
	4170	);
	4171	}
	4172	elsif(my $OldMethod = $OldMethodSignature{getBaseSignature($Method)})
[10845]	4173	{
[12872]	4174	if($OldMethod ne $Method)
	4175	{
	4176	my $OldReturnType = getTypeName($MethodInfo{1}{$OldMethod}{"Return"}, 1);
[10845]	4177
[12872]	4178	%{$CompatProblems{$OldMethod}{"Changed_Method_Return"}{""}}=(
	4179	"Old_Value"=>$OldReturnType,
	4180	"New_Value"=>$ReturnType
[10845]	4181	);
	4182	}
	4183	}
	4184	}
	4185	}
	4186	}
	4187	}
	4188
	4189	sub detectRemoved()
	4190	{
	4191	foreach my $Method (keys(%{$MethodInfo{1}}))
	4192	{
	4193	if(not defined $MethodInfo{2}{$Method})
	4194	{
	4195	if(not methodFilter($Method, 1)) {
	4196	next;
	4197	}
	4198
[12872]	4199	my $Class = getType($MethodInfo{1}{$Method}{"Class"}, 1);
[10845]	4200
[13595]	4201	if(not defined $In::Opt{"CheckAnnotations"} and $Class->{"Annotation"}) {
	4202	next;
	4203	}
	4204
[12872]	4205	$CheckedTypes{$Class->{"Name"}} = 1;
[10845]	4206	$CheckedMethods{$Method} = 1;
	4207
	4208	if(not $MethodInfo{1}{$Method}{"Constructor"}
[12872]	4209	and my $MovedUp = findMethod($Method, 1, $Class->{"Name"}, 2))
[10845]	4210	{
[12872]	4211	if($Class->{"Type"} eq "class"
	4212	and not $MethodInfo{1}{$Method}{"Abstract"}
	4213	and ($TName_Tid{2}{$Class->{"Name"}} or $TName_Tid_Generic{2}{getGeneric($Class->{"Name"})}))
[10845]	4214	{# class should exist in newer version
[11682]	4215	%{$CompatProblems{$Method}{"Class_Method_Moved_Up_Hierarchy"}{"this.".getSFormat($MovedUp)}}=(
[12872]	4216	"Type_Name"=>$Class->{"Name"},
[10845]	4217	"Target"=>$MethodInfo{2}{$MovedUp}{"Signature"},
	4218	"Old_Value"=>$Method,
[11682]	4219	"New_Value"=>$MovedUp);
[10845]	4220	}
	4221	}
	4222	else
	4223	{
	4224	if($MethodInfo{1}{$Method}{"Abstract"}) {
[12872]	4225	$RemovedMethod_Abstract{$Class->{"Name"}}{$Method} = 1;
[10845]	4226	}
[12872]	4227
	4228	if(not ($MethodInfo{1}{$Method}{"Access"} eq "protected" and $Class->{"Final"})) {
	4229	%{$CompatProblems{$Method}{"Removed_Method"}{""}} = ();
	4230	}
[10845]	4231	}
	4232	}
	4233	}
	4234	}
	4235
[11682]	4236	sub isCyclical($$) {
[10845]	4237	return (grep {$_ eq $_[1]} @{$_[0]});
	4238	}
	4239
[11682]	4240	sub mergeAPIs($$)
[10845]	4241	{
[11682]	4242	my ($LVer, $Dep) = @_;
	4243
	4244	foreach my $TId (keys(%{$Dep->{"TypeInfo"}}))
[10845]	4245	{
[11682]	4246	$TypeInfo{$LVer}{$TId} = $Dep->{"TypeInfo"}{$TId};
	4247	$TypeInfo{$LVer}{$TId}{"Dep"} = 1;
[10845]	4248	}
[11682]	4249
	4250	my $MInfo = $Dep->{"MethodInfo"};
	4251	foreach my $M_Id (keys(%{$MInfo}))
[10845]	4252	{
[11682]	4253	if(my $Name = $MInfo->{$M_Id}{"Name"})
	4254	{
	4255	$MethodInfo{$LVer}{$Name} = $MInfo->{$M_Id};
	4256	$MethodInfo{$LVer}{$Name}{"Dep"} = 1;
[10845]	4257	}
	4258	}
	4259	}
	4260
[11682]	4261	sub readAPIDump($$$)
[10845]	4262	{
[11682]	4263	my ($LVer, $Path, $Subj) = @_;
	4264
	4265	if(not $In::Opt{"CountMethods"}) {
	4266	printMsg("INFO", "Reading API dump ($LVer) ...");
[10845]	4267	}
[11682]	4268
	4269	my $FilePath = "";
	4270	if(isDump_U($Path))
	4271	{ # input *.dump
	4272	$FilePath = $Path;
	4273	}
[10845]	4274	else
[11682]	4275	{ # input *.dump.tar.gz
	4276	$FilePath = unpackDump($Path);
	4277	if(not isDump_U($FilePath)) {
	4278	exitStatus("Invalid_Dump", "specified API dump \'$Path\' is not valid, try to recreate it");
	4279	}
[10845]	4280	}
	4281
[11682]	4282	my $APIRef = {};
	4283
	4284	open(DUMP, $FilePath);
	4285	local $/ = undef;
	4286	my $Content = <DUMP>;
	4287	close(DUMP);
	4288
	4289	if(getDirname($FilePath) eq $In::Opt{"Tmp"}."/unpack")
	4290	{ # remove temp file
	4291	unlink($FilePath);
[10845]	4292	}
	4293
	4294	if($Content!~/};\s*\Z/) {
	4295	exitStatus("Invalid_Dump", "specified API dump \'$Path\' is not valid, try to recreate it");
	4296	}
	4297
[11682]	4298	$APIRef = eval($Content);
[10845]	4299
[11682]	4300	if(not $APIRef) {
	4301	exitStatus("Error", "internal error - eval() procedure seem to not working correctly, try to remove 'use strict' and try again");
[10845]	4302	}
	4303
[11682]	4304	my $APIVer = $APIRef->{"API_DUMP_VERSION"};
[10845]	4305
[11682]	4306	if($APIVer)
[10845]	4307	{
[11682]	4308	if(cmpVersions($APIVer, $API_DUMP_VERSION)>0)
	4309	{ # future formats
[12872]	4310	exitStatus("Dump_Version", "version of the API dump is newer than version of the tool");
[10845]	4311	}
[12872]	4312
	4313	if(cmpVersions($APIVer, $API_DUMP_VERSION)<0)
	4314	{ # old formats
	4315	printMsg("WARNING", "version of the API dump is older than version of the tool");
	4316	}
[10845]	4317	}
	4318
[12872]	4319	if(cmpVersions($APIVer, $API_DUMP_VERSION_MIN)<0)
	4320	{ # obsolete formats
	4321	exitStatus("Dump_Version", "version of the API dump is too old and unsupported anymore, please regenerate it");
[10845]	4322	}
	4323
[11682]	4324	if($Subj ne "Dep")
[10845]	4325	{
[11682]	4326	$In::Desc{$LVer}{"Version"} = $APIRef->{"LibraryVersion"};
	4327	$In::Desc{$LVer}{"Dump"} = 1;
[10845]	4328	}
	4329
[11682]	4330	return $APIRef;
[10845]	4331	}
	4332
	4333	sub checkVersionNum($$)
	4334	{
[11682]	4335	my ($LVer, $Path) = @_;
[10845]	4336
[11682]	4337	if($In::Desc{$LVer}{"TargetVersion"}) {
[10845]	4338	return;
	4339	}
	4340
[13595]	4341	if($Path!~/\.(jar\|jmod)\Z/i) {
[10845]	4342	return;
	4343	}
	4344
	4345	my $Ver = undef;
	4346
[13595]	4347	if($Path=~/\.jar\Z/i)
	4348	{
	4349	if(not defined $Ver) {
	4350	$Ver = getManifestVersion(getAbsPath($Path));
	4351	}
[10845]	4352	}
	4353
	4354	if(not defined $Ver) {
[11682]	4355	$Ver = getPkgVersion(getFilename($Path));
[10845]	4356	}
	4357
	4358	if(not defined $Ver) {
	4359	$Ver = parseVersion($Path);
	4360	}
	4361
	4362	if(not defined $Ver)
	4363	{
[11682]	4364	if($In::Opt{"DumpAPI"})
[10845]	4365	{
	4366	$Ver = "XYZ";
	4367	}
	4368	else
	4369	{
[11682]	4370	if($LVer==1) {
[10845]	4371	$Ver = "X";
	4372	}
	4373	else {
	4374	$Ver = "Y";
	4375	}
	4376	}
	4377	}
	4378
[11682]	4379	$In::Desc{$LVer}{"TargetVersion"} = $Ver;
[10845]	4380
[11682]	4381	if($In::Opt{"DumpAPI"}) {
[10845]	4382	printMsg("WARNING", "set version number to $Ver (use -vnum option to change it)");
	4383	}
	4384	else {
[11682]	4385	printMsg("WARNING", "set #$LVer version number to $Ver (use --v$LVer=NUM option to change it)");
[10845]	4386	}
	4387	}
	4388
	4389	sub getManifestVersion($)
	4390	{
	4391	my $Path = $_[0];
	4392
[11682]	4393	my $JarCmd = getCmdPath("jar");
[10845]	4394	if(not $JarCmd) {
	4395	exitStatus("Not_Found", "can't find \"jar\" command");
	4396	}
[11682]	4397
	4398	my $TmpDir = $In::Opt{"Tmp"};
	4399
	4400	chdir($TmpDir);
[10845]	4401	system($JarCmd." -xf \"$Path\" META-INF 2>null");
[11682]	4402	chdir($In::Opt{"OrigDir"});
	4403
	4404	my $Manifest = $TmpDir."/META-INF/MANIFEST.MF";
	4405
	4406	if(-f $Manifest)
[10845]	4407	{
[11682]	4408	if(my $Content = readFile($Manifest))
	4409	{
	4410	if($Content=~/(\A\|\s)Implementation\-Version:\s*(.+)(\s\|\Z)/i) {
	4411	return $2;
	4412	}
[10845]	4413	}
	4414	}
	4415	return undef;
	4416	}
	4417
	4418	sub parseVersion($)
	4419	{
	4420	my $Str = $_[0];
	4421
	4422	if(not $Str) {
	4423	return undef;
	4424	}
	4425
	4426	if($Str=~/(\/\|\\\|\w\|\A)[\-\_]*(\d+[\d\.\-]+\d+\|\d+)/) {
	4427	return $2;
	4428	}
	4429	return undef;
	4430	}
	4431
	4432	sub getPkgVersion($)
	4433	{
	4434	my $Name = $_[0];
	4435	$Name=~s/\.\w+\Z//;
	4436	if($Name=~/\A(.+[a-z])[\-\_](v\|ver\|)(\d.+?)\Z/i)
	4437	{ # libsample-N
	4438	# libsample-vN
	4439	return ($1, $3);
	4440	}
	4441	elsif($Name=~/\A(.+?)(\d[\d\.]*)\Z/i)
	4442	{ # libsampleN
	4443	return ($1, $2);
	4444	}
	4445	elsif($Name=~/\A(.+)[\-\_](v\|ver\|)(\d.+?)\Z/i)
	4446	{ # libsample-N
	4447	# libsample-vN
	4448	return ($1, $3);
	4449	}
	4450	elsif($Name=~/\A([a-z_\-]+)(\d.+?)\Z/i)
	4451	{ # libsampleNb
	4452	return ($1, $2);
	4453	}
	4454	return (undef, undef);
	4455	}
	4456
[11682]	4457	sub dumpSorting($)
[10845]	4458	{
	4459	my $Hash = $_[0];
	4460	return [] if(not $Hash);
	4461	my @Keys = keys(%{$Hash});
	4462	return [] if($#Keys<0);
	4463	if($Keys[0]=~/\A\d+\Z/)
	4464	{ # numbers
	4465	return [sort {int($a)<=>int($b)} @Keys];
	4466	}
	4467	else
	4468	{ # strings
	4469	return [sort {$a cmp $b} @Keys];
	4470	}
	4471	}
	4472
	4473	sub printStatMsg($)
	4474	{
	4475	my $Level = $_[0];
[11682]	4476	printMsg("INFO", "Total ".lc($Level)." compatibility problems: ".$RESULT{$Level}{"Problems"}.", warnings: ".$RESULT{$Level}{"Warnings"});
[10845]	4477	}
	4478
	4479	sub printReport()
	4480	{
[11682]	4481	printMsg("INFO", "Creating compatibility report ...");
[10845]	4482	createReport();
[11682]	4483	if($In::Opt{"JoinReport"} or $In::Opt{"DoubleReport"})
[10845]	4484	{
	4485	if($RESULT{"Binary"}{"Problems"}
	4486	or $RESULT{"Source"}{"Problems"})
	4487	{
[11682]	4488	printMsg("INFO", "Binary compatibility: ".(100-$RESULT{"Binary"}{"Affected"})."\%");
	4489	printMsg("INFO", "Source compatibility: ".(100-$RESULT{"Source"}{"Affected"})."\%");
[10845]	4490	}
	4491	else
	4492	{
[11682]	4493	printMsg("INFO", "Binary compatibility: 100\%");
	4494	printMsg("INFO", "Source compatibility: 100\%");
[10845]	4495	}
	4496	printStatMsg("Binary");
	4497	printStatMsg("Source");
	4498	}
[11682]	4499	elsif($In::Opt{"BinaryOnly"})
[10845]	4500	{
	4501	if($RESULT{"Binary"}{"Problems"}) {
[11682]	4502	printMsg("INFO", "Binary compatibility: ".(100-$RESULT{"Binary"}{"Affected"})."\%");
[10845]	4503	}
	4504	else {
[11682]	4505	printMsg("INFO", "Binary compatibility: 100\%");
[10845]	4506	}
	4507	printStatMsg("Binary");
	4508	}
[11682]	4509	elsif($In::Opt{"SourceOnly"})
[10845]	4510	{
	4511	if($RESULT{"Source"}{"Problems"}) {
[11682]	4512	printMsg("INFO", "Source compatibility: ".(100-$RESULT{"Source"}{"Affected"})."\%");
[10845]	4513	}
	4514	else {
[11682]	4515	printMsg("INFO", "Source compatibility: 100\%");
[10845]	4516	}
	4517	printStatMsg("Source");
	4518	}
[11682]	4519	if($In::Opt{"JoinReport"})
[10845]	4520	{
[11682]	4521	printMsg("INFO", "Report: ".getReportPath("Join"));
[10845]	4522	}
[11682]	4523	elsif($In::Opt{"DoubleReport"})
[10845]	4524	{ # default
[11682]	4525	printMsg("INFO", "Report (BC): ".getReportPath("Binary"));
	4526	printMsg("INFO", "Report (SC): ".getReportPath("Source"));
[10845]	4527	}
[11682]	4528	elsif($In::Opt{"BinaryOnly"})
[10845]	4529	{ # --binary
[11682]	4530	printMsg("INFO", "Report: ".getReportPath("Binary"));
[10845]	4531	}
[11682]	4532	elsif($In::Opt{"SourceOnly"})
[10845]	4533	{ # --source
[11682]	4534	printMsg("INFO", "Report: ".getReportPath("Source"));
[10845]	4535	}
	4536	}
	4537
	4538	sub getReportPath($)
	4539	{
	4540	my $Level = $_[0];
[11682]	4541	my $Dir = "compat_reports/".$In::Opt{"TargetLib"}."/".$In::Desc{1}{"Version"}."_to_".$In::Desc{2}{"Version"};
[10845]	4542	if($Level eq "Binary")
	4543	{
[11682]	4544	if($In::Opt{"BinaryReportPath"})
[10845]	4545	{ # --bin-report-path
[11682]	4546	return $In::Opt{"BinaryReportPath"};
[10845]	4547	}
[11682]	4548	elsif($In::Opt{"OutputReportPath"})
[10845]	4549	{ # --report-path
[11682]	4550	return $In::Opt{"OutputReportPath"};
[10845]	4551	}
	4552	else
	4553	{ # default
	4554	return $Dir."/bin_compat_report.html";
	4555	}
	4556	}
	4557	elsif($Level eq "Source")
	4558	{
[11682]	4559	if($In::Opt{"SourceReportPath"})
[10845]	4560	{ # --src-report-path
[11682]	4561	return $In::Opt{"SourceReportPath"};
[10845]	4562	}
[11682]	4563	elsif($In::Opt{"OutputReportPath"})
[10845]	4564	{ # --report-path
[11682]	4565	return $In::Opt{"OutputReportPath"};
[10845]	4566	}
	4567	else
	4568	{ # default
	4569	return $Dir."/src_compat_report.html";
	4570	}
	4571	}
	4572	else
	4573	{
[11682]	4574	if($In::Opt{"OutputReportPath"})
[10845]	4575	{ # --report-path
[11682]	4576	return $In::Opt{"OutputReportPath"};
[10845]	4577	}
	4578	else
	4579	{ # default
	4580	return $Dir."/compat_report.html";
	4581	}
	4582	}
	4583	}
	4584
[11682]	4585	sub unpackDump($)
[10845]	4586	{
[11682]	4587	my $Path = $_[0];
	4588
	4589	if(isDump_U($Path)) {
	4590	return $Path;
	4591	}
	4592
	4593	my $TmpDir = $In::Opt{"Tmp"};
	4594
	4595	$Path = getAbsPath($Path);
	4596	$Path = pathFmt($Path);
	4597
	4598	my ($Dir, $FileName) = sepPath($Path);
	4599	my $UnpackDir = $TmpDir."/unpack";
	4600	if(-d $UnpackDir) {
	4601	rmtree($UnpackDir);
	4602	}
	4603	mkpath($UnpackDir);
	4604
	4605	if($FileName=~s/\Q.zip\E\Z//g)
	4606	{ # *.zip
	4607	my $UnzipCmd = getCmdPath("unzip");
	4608	if(not $UnzipCmd) {
	4609	exitStatus("Not_Found", "can't find \"unzip\" command");
[10845]	4610	}
[11682]	4611	chdir($UnpackDir);
	4612	system("$UnzipCmd \"$Path\" >contents.txt");
[12872]	4613	chdir($In::Opt{"OrigDir"});
[11682]	4614	if($?) {
	4615	exitStatus("Error", "can't extract \'$Path\'");
	4616	}
[12872]	4617
[11682]	4618	my @Contents = ();
	4619	foreach (split("\n", readFile("$UnpackDir/contents.txt")))
	4620	{
	4621	if(/inflating:\s*([^\s]+)/) {
	4622	push(@Contents, $1);
	4623	}
	4624	}
	4625	if(not @Contents) {
	4626	exitStatus("Error", "can't extract \'$Path\'");
	4627	}
	4628	return join_P($UnpackDir, $Contents[0]);
[10845]	4629	}
[11682]	4630	elsif($FileName=~s/\Q.tar.gz\E\Z//g)
	4631	{ # *.tar.gz
	4632	if($In::Opt{"OS"} eq "windows")
	4633	{ # -xvzf option is not implemented in tar.exe (2003)
	4634	# use "gzip.exe -k -d -f" + "tar.exe -xvf" instead
	4635	my $TarCmd = getCmdPath("tar");
	4636	if(not $TarCmd) {
	4637	exitStatus("Not_Found", "can't find \"tar\" command");
	4638	}
	4639	my $GzipCmd = getCmdPath("gzip");
	4640	if(not $GzipCmd) {
	4641	exitStatus("Not_Found", "can't find \"gzip\" command");
	4642	}
	4643	chdir($UnpackDir);
	4644	qx/$GzipCmd -k -d -f "$Path"/; # keep input files (-k)
	4645	if($?) {
	4646	exitStatus("Error", "can't extract \'$Path\'");
	4647	}
	4648	my @Contents = qx/$TarCmd -xvf "$Dir\\$FileName.tar"/;
[12872]	4649	chdir($In::Opt{"OrigDir"});
[11682]	4650	if($? or not @Contents) {
	4651	exitStatus("Error", "can't extract \'$Path\'");
	4652	}
	4653	unlink($Dir."/".$FileName.".tar");
	4654	chomp $Contents[0];
	4655	return join_P($UnpackDir, $Contents[0]);
	4656	}
	4657	else
	4658	{ # Linux, Unix, OS X
	4659	my $TarCmd = getCmdPath("tar");
	4660	if(not $TarCmd) {
	4661	exitStatus("Not_Found", "can't find \"tar\" command");
	4662	}
	4663	chdir($UnpackDir);
	4664	my @Contents = qx/$TarCmd -xvzf "$Path" 2>&1/;
[12872]	4665	chdir($In::Opt{"OrigDir"});
[11682]	4666	if($? or not @Contents) {
	4667	exitStatus("Error", "can't extract \'$Path\'");
	4668	}
	4669	$Contents[0]=~s/^x //; # OS X
	4670	chomp $Contents[0];
	4671	return join_P($UnpackDir, $Contents[0]);
	4672	}
	4673	}
[10845]	4674	}
	4675
	4676	sub createArchive($$)
	4677	{
	4678	my ($Path, $To) = @_;
	4679	if(not $To) {
	4680	$To = ".";
	4681	}
[11682]	4682
	4683	my $TmpDir = $In::Opt{"Tmp"};
	4684
	4685	my ($From, $Name) = sepPath($Path);
	4686	if($In::Opt{"OS"} eq "windows")
[10845]	4687	{ # *.zip
[11682]	4688	my $ZipCmd = getCmdPath("zip");
[10845]	4689	if(not $ZipCmd) {
	4690	exitStatus("Not_Found", "can't find \"zip\"");
	4691	}
	4692	my $Pkg = $To."/".$Name.".zip";
	4693	unlink($Pkg);
	4694	chdir($To);
[11682]	4695	system("$ZipCmd -j \"$Name.zip\" \"$Path\" >\"$TmpDir/null\"");
[10845]	4696	if($?)
	4697	{ # cannot allocate memory (or other problems with "zip")
[12872]	4698	chdir($In::Opt{"OrigDir"});
[10845]	4699	exitStatus("Error", "can't pack the API dump: ".$!);
	4700	}
[11682]	4701	chdir($In::Opt{"OrigDir"});
[10845]	4702	unlink($Path);
	4703	return $Pkg;
	4704	}
	4705	else
	4706	{ # *.tar.gz
[11682]	4707	my $TarCmd = getCmdPath("tar");
[10845]	4708	if(not $TarCmd) {
	4709	exitStatus("Not_Found", "can't find \"tar\"");
	4710	}
[11682]	4711	my $GzipCmd = getCmdPath("gzip");
[10845]	4712	if(not $GzipCmd) {
	4713	exitStatus("Not_Found", "can't find \"gzip\"");
	4714	}
	4715	my $Pkg = abs_path($To)."/".$Name.".tar.gz";
[12872]	4716	if(-e $Pkg) {
	4717	unlink($Pkg);
	4718	}
	4719	system($TarCmd, "-C", $From, "-czf", $Pkg, $Name);
[10845]	4720	if($?)
	4721	{ # cannot allocate memory (or other problems with "tar")
	4722	exitStatus("Error", "can't pack the API dump: ".$!);
	4723	}
	4724	unlink($Path);
	4725	return $To."/".$Name.".tar.gz";
	4726	}
	4727	}
	4728
[11682]	4729	sub initAliases($)
[10845]	4730	{
[11682]	4731	my $LVer = $_[0];
	4732
	4733	initAPI($LVer);
	4734
	4735	$MethodInfo{$LVer} = $In::API{$LVer}{"MethodInfo"};
	4736	$TypeInfo{$LVer} = $In::API{$LVer}{"TypeInfo"};
	4737	$TName_Tid{$LVer} = $In::API{$LVer}{"TName_Tid"};
	4738
	4739	initAliases_TypeAttr($LVer);
[10845]	4740	}
	4741
[11682]	4742	sub createAPIFile($$)
	4743	{
	4744	my ($LVer, $DescPath) = @_;
	4745
	4746	if(not -e $DescPath) {
	4747	exitStatus("Access_Error", "can't access \'$DescPath\'");
	4748	}
	4749
	4750	detectDefaultPaths("bin", "java");
	4751
	4752	if(isDump($DescPath))
	4753	{
	4754	$In::API{$LVer} = readAPIDump($LVer, $DescPath, "Main");
	4755	initAliases($LVer);
	4756
	4757	if(my $V = $In::Desc{$LVer}{"TargetVersion"}) {
	4758	$In::Desc{$LVer}{"Version"} = $V;
	4759	}
	4760	else {
	4761	$In::Desc{$LVer}{"Version"} = $In::API{$LVer}{"LibraryVersion"};
	4762	}
	4763	}
	4764	else
	4765	{
	4766	loadModule("APIDump");
	4767
	4768	checkVersionNum($LVer, $DescPath);
	4769	readDesc(createDesc($DescPath, $LVer), $LVer);
	4770
	4771	initLogging($LVer);
	4772
	4773	createAPIDump($LVer);
	4774	}
	4775
	4776	if(my $Dep = $In::Desc{$LVer}{"DepDump"}) {
	4777	mergeAPIs($LVer, readAPIDump($LVer, $Dep, "Dep"));
	4778	}
	4779
	4780	printMsg("INFO", "Creating library API dump ...");
	4781
	4782	$In::API{$LVer}{"API_DUMP_VERSION"} = $API_DUMP_VERSION;
	4783	$In::API{$LVer}{"JAPI_COMPLIANCE_CHECKER_VERSION"} = $TOOL_VERSION;
	4784
	4785	foreach ("TName_Tid") {
	4786	delete($In::API{$LVer}{$_});
	4787	}
	4788
	4789	my $DumpPath = "api_dumps/".$In::Opt{"TargetLib"}."/".$In::Desc{$LVer}{"Version"}."/API.dump";
	4790	if($In::Opt{"OutputDumpPath"})
	4791	{ # user defined path
	4792	$DumpPath = $In::Opt{"OutputDumpPath"};
	4793	}
	4794
	4795	my $ArExt = $In::Opt{"Ar"};
	4796	my $Archive = ($DumpPath=~s/\Q.$ArExt\E\Z//g);
	4797
	4798	if($Archive)
	4799	{
	4800	my $TarCmd = getCmdPath("tar");
	4801	if(not $TarCmd) {
	4802	exitStatus("Not_Found", "can't find \"tar\"");
	4803	}
	4804	my $GzipCmd = getCmdPath("gzip");
	4805	if(not $GzipCmd) {
	4806	exitStatus("Not_Found", "can't find \"gzip\"");
	4807	}
	4808	}
	4809
	4810	my ($DDir, $DName) = sepPath($DumpPath);
	4811	my $DPath = $In::Opt{"Tmp"}."/".$DName;
	4812	if(not $Archive) {
	4813	$DPath = $DumpPath;
	4814	}
	4815
	4816	mkpath($DDir);
	4817
	4818	open(DUMP, ">", $DPath) \|\| die ("can't open file \'$DPath\': $!\n");
	4819	print DUMP Dumper($In::API{$LVer});
	4820	close(DUMP);
	4821
	4822	if(not -s $DPath) {
	4823	exitStatus("Error", "can't create API dump because something is going wrong with the Data::Dumper module");
	4824	}
	4825
	4826	if($Archive) {
	4827	$DumpPath = createArchive($DPath, $DDir);
	4828	}
	4829
	4830	if($In::Opt{"OutputDumpPath"}) {
	4831	printMsg("INFO", "Dump path: ".$In::Opt{"OutputDumpPath"});
	4832	}
	4833	else {
	4834	printMsg("INFO", "Dump path: $DumpPath");
	4835	}
	4836	exit(0);
	4837	}
	4838
	4839	sub compareInit()
	4840	{
	4841	if(not $In::Desc{1}{"Path"}) {
	4842	exitStatus("Error", "-old option is not specified");
	4843	}
	4844	if(not -e $In::Desc{1}{"Path"}) {
	4845	exitStatus("Access_Error", "can't access \'".$In::Desc{1}{"Path"}."\'");
	4846	}
	4847	if(not $In::Desc{2}{"Path"}) {
	4848	exitStatus("Error", "-new option is not specified");
	4849	}
	4850	if(not -e $In::Desc{2}{"Path"}) {
	4851	exitStatus("Access_Error", "can't access \'".$In::Desc{2}{"Path"}."\'");
	4852	}
	4853
	4854	if($In::Opt{"Quick"})
	4855	{
	4856	$CompatRules{"Binary"}{"Interface_Added_Super_Interface"}{"Severity"} = "Low";
	4857	$CompatRules{"Binary"}{"Abstract_Class_Added_Super_Abstract_Class"}{"Severity"} = "Low";
	4858	$CompatRules{"Binary"}{"Abstract_Class_Added_Super_Interface"}{"Severity"} = "Low";
	4859	$CompatRules{"Binary"}{"Abstract_Class_Added_Abstract_Method"}{"Severity"} = "Low";
	4860	$CompatRules{"Binary"}{"Interface_Added_Abstract_Method"}{"Severity"} = "Low";
	4861	}
	4862
	4863	printMsg("INFO", "Preparing, please wait ...");
	4864
	4865	detectDefaultPaths("bin", undef);
	4866
	4867	if(isDump($In::Desc{1}{"Path"}))
	4868	{
	4869	$In::API{1} = readAPIDump(1, $In::Desc{1}{"Path"}, "Main");
	4870	initAliases(1);
	4871
	4872	if(my $V = $In::Desc{1}{"TargetVersion"}) {
	4873	$In::Desc{1}{"Version"} = $V;
	4874	}
	4875	else {
	4876	$In::Desc{1}{"Version"} = $In::API{1}{"LibraryVersion"};
	4877	}
	4878	}
	4879	else
	4880	{
	4881	loadModule("APIDump");
	4882
	4883	checkVersionNum(1, $In::Desc{1}{"Path"});
	4884	readDesc(createDesc($In::Desc{1}{"Path"}, 1), 1);
	4885
	4886	initLogging(1);
	4887	detectDefaultPaths(undef, "java");
	4888	createAPIDump(1);
	4889	}
	4890
	4891	if(my $Dep = $In::Desc{1}{"DepDump"}) {
	4892	mergeAPIs(1, readAPIDump(1, $Dep, "Dep"));
	4893	}
	4894
	4895	if(isDump($In::Desc{2}{"Path"}))
	4896	{
	4897	$In::API{2} = readAPIDump(2, $In::Desc{2}{"Path"}, "Main");
	4898	initAliases(2);
	4899
	4900	if(my $V = $In::Desc{2}{"TargetVersion"}) {
	4901	$In::Desc{2}{"Version"} = $V;
	4902	}
	4903	else {
	4904	$In::Desc{2}{"Version"} = $In::API{2}{"LibraryVersion"};
	4905	}
	4906	}
	4907	else
	4908	{
	4909	loadModule("APIDump");
	4910
	4911	checkVersionNum(2, $In::Desc{2}{"Path"});
	4912	readDesc(createDesc($In::Desc{2}{"Path"}, 2), 2);
	4913
	4914	initLogging(2);
	4915	detectDefaultPaths(undef, "java");
	4916	createAPIDump(2);
	4917	}
	4918
	4919	if(my $Dep = $In::Desc{2}{"DepDump"}) {
	4920	mergeAPIs(2, readAPIDump(2, $Dep, "Dep"));
	4921	}
	4922
	4923	prepareData(1);
	4924	prepareData(2);
	4925
	4926	foreach my $Inv (keys(%{$MethodUsed{2}}))
	4927	{
	4928	foreach my $M (keys(%{$MethodUsed{2}{$Inv}}))
	4929	{
	4930	my $InvType = $MethodUsed{2}{$Inv}{$M};
	4931
	4932	if($InvType ne "static"
	4933	and index($Inv, "<init>")==-1)
	4934	{
	4935	my $CName = $Inv;
	4936	$CName=~s/\A\"\[L(.+);"/$1/g;
	4937	$CName=~s/#/./g;
	4938
	4939	if($CName=~/\A(.+?)\./)
	4940	{
	4941	$CName = $1;
	4942	if($CName!~/\"/)
	4943	{
	4944	$CName=~s!/!.!g;
	4945	$ClassMethod_AddedUsed{$CName}{$Inv} = $M;
	4946	}
	4947	}
	4948	}
	4949
	4950	if(not defined $MethodInfo{1}{$M}) {
	4951	delete($MethodUsed{2}{$Inv}{$M});
	4952	}
	4953	}
	4954	}
	4955
	4956	foreach my $ClassName (keys(%ClassMethod_AddedUsed))
	4957	{
	4958	foreach my $MethodName (keys(%{$ClassMethod_AddedUsed{$ClassName}}))
	4959	{
	4960	if(defined $MethodInfo{1}{$MethodName}
	4961	or defined $MethodInfo{2}{$MethodName}
	4962	or defined $MethodUsed{1}{$MethodName}
	4963	or findMethod($MethodName, 2, $ClassName, 1))
	4964	{ # abstract method added by the new super-class (abstract) or super-interface
	4965	delete($ClassMethod_AddedUsed{$ClassName}{$MethodName});
	4966	}
	4967	}
	4968	if(not keys(%{$ClassMethod_AddedUsed{$ClassName}})) {
	4969	delete($ClassMethod_AddedUsed{$ClassName});
	4970	}
	4971	}
	4972	}
	4973
[10845]	4974	sub scenario()
	4975	{
[11682]	4976	setTarget("default");
	4977
	4978	initAliases(1);
	4979	initAliases(2);
	4980
	4981	$In::Opt{"OrigDir"} = cwd();
	4982	$In::Opt{"Tmp"} = tempdir(CLEANUP=>1);
	4983	$In::Opt{"Reproducible"} = 1;
	4984
	4985	$In::Opt{"JoinReport"} = 1;
	4986	$In::Opt{"DoubleReport"} = 0;
	4987
	4988	if($In::Opt{"BinaryOnly"} and $In::Opt{"SourceOnly"})
[10845]	4989	{ # both --binary and --source
	4990	# is the default mode
[11682]	4991	$In::Opt{"DoubleReport"} = 1;
	4992	$In::Opt{"JoinReport"} = 0;
	4993	$In::Opt{"BinaryOnly"} = 0;
	4994	$In::Opt{"SourceOnly"} = 0;
	4995	if($In::Opt{"OutputReportPath"})
[10845]	4996	{ # --report-path
[11682]	4997	$In::Opt{"DoubleReport"} = 0;
	4998	$In::Opt{"JoinReport"} = 1;
[10845]	4999	}
	5000	}
[11682]	5001	elsif($In::Opt{"BinaryOnly"} or $In::Opt{"SourceOnly"})
[10845]	5002	{ # --binary or --source
[11682]	5003	$In::Opt{"DoubleReport"} = 0;
	5004	$In::Opt{"JoinReport"} = 0;
[10845]	5005	}
[11682]	5006	if(defined $In::Opt{"Help"})
[10845]	5007	{
[11682]	5008	helpMsg();
[10845]	5009	exit(0);
	5010	}
[11682]	5011	if(defined $In::Opt{"ShowVersion"})
[10845]	5012	{
[13595]	5013	printMsg("INFO", "Java API Compliance Checker (JAPICC) $TOOL_VERSION\nCopyright (C) 2018 Andrey Ponomarenko's ABI Laboratory\nLicense: LGPLv2.1+ <http://www.gnu.org/licenses/>\nThis program is free software: you can redistribute it and/or modify it.\n\nWritten by Andrey Ponomarenko.");
[10845]	5014	exit(0);
	5015	}
[11682]	5016	if(defined $In::Opt{"DumpVersion"})
[10845]	5017	{
	5018	printMsg("INFO", $TOOL_VERSION);
	5019	exit(0);
	5020	}
	5021	$Data::Dumper::Sortkeys = 1;
	5022
[11682]	5023	# FIXME: can't pass \&dumpSorting - cause a segfault sometimes
	5024	if($In::Opt{"SortDump"})
[10845]	5025	{
	5026	$Data::Dumper::Useperl = 1;
[11682]	5027	$Data::Dumper::Sortkeys = \&dumpSorting;
[10845]	5028	}
	5029
[11682]	5030	if(defined $In::Opt{"TestTool"})
[10845]	5031	{
[11682]	5032	detectDefaultPaths("bin", "java");
	5033	loadModule("RegTests");
	5034	testTool();
[10845]	5035	exit(0);
	5036	}
	5037
[11682]	5038	if(defined $In::Opt{"ShortMode"})
[10845]	5039	{
[11682]	5040	if(not defined $In::Opt{"AffectLimit"}) {
	5041	$In::Opt{"AffectLimit"} = 10;
[10845]	5042	}
	5043	}
	5044
[11682]	5045	if(not $In::Opt{"TargetLib"} and not $In::Opt{"CountMethods"})
[10845]	5046	{
[11682]	5047	if($In::Opt{"DumpAPI"})
[10845]	5048	{
[13595]	5049	if($In::Opt{"DumpAPI"}=~/\.(jar\|jmod)\Z/)
[10845]	5050	{ # short usage
[11682]	5051	my ($Name, $Version) = getPkgVersion(getFilename($In::Opt{"DumpAPI"}));
[10845]	5052	if($Name and $Version ne "")
	5053	{
[11682]	5054	$In::Opt{"TargetLib"} = $Name;
	5055	if(not $In::Desc{1}{"TargetVersion"}) {
	5056	$In::Desc{1}{"TargetVersion"} = $Version;
[10845]	5057	}
	5058	}
	5059	}
	5060	}
	5061	else
	5062	{
[13595]	5063	if($In::Desc{1}{"Path"}=~/\.(jar\|jmod)\Z/ and $In::Desc{2}{"Path"}=~/\.(jar\|jmod)\Z/)
[10845]	5064	{ # short usage
[11682]	5065	my ($Name1, $Version1) = getPkgVersion(getFilename($In::Desc{1}{"Path"}));
	5066	my ($Name2, $Version2) = getPkgVersion(getFilename($In::Desc{2}{"Path"}));
[10845]	5067
	5068	if($Name1 and $Version1 ne ""
	5069	and $Version2 ne "")
	5070	{
[11682]	5071	$In::Opt{"TargetLib"} = $Name1;
	5072	if(not $In::Desc{1}{"TargetVersion"}) {
	5073	$In::Desc{1}{"TargetVersion"} = $Version1;
[10845]	5074	}
[11682]	5075	if(not $In::Desc{2}{"TargetVersion"}) {
	5076	$In::Desc{2}{"TargetVersion"} = $Version2;
[10845]	5077	}
	5078	}
	5079	}
	5080	}
	5081
[11682]	5082	if(not $In::Opt{"TargetLib"}) {
[10845]	5083	exitStatus("Error", "library name is not selected (option --lib=NAME)");
	5084	}
	5085	}
	5086	else
	5087	{ # validate library name
[11682]	5088	if($In::Opt{"TargetLib"}=~/[\*\/\\]/) {
[10845]	5089	exitStatus("Error", "\"\\\", \"\/\" and \"*\" symbols are not allowed in the library name");
	5090	}
	5091	}
[11682]	5092	if(not $In::Opt{"TargetTitle"}) {
	5093	$In::Opt{"TargetTitle"} = $In::Opt{"TargetLib"};
[10845]	5094	}
[11682]	5095	if(my $ClassListPath = $In::Opt{"ClassListPath"})
[10845]	5096	{
	5097	if(not -f $ClassListPath) {
	5098	exitStatus("Access_Error", "can't access file \'$ClassListPath\'");
	5099	}
	5100	foreach my $Class (split(/\n/, readFile($ClassListPath)))
	5101	{
	5102	$Class=~s/\//./g;
[11682]	5103	$In::Opt{"ClassList_User"}{$Class} = 1;
[10845]	5104	}
	5105	}
[11682]	5106	if(my $AnnotationsListPath = $In::Opt{"AnnotationsListPath"})
[10845]	5107	{
	5108	if(not -f $AnnotationsListPath) {
	5109	exitStatus("Access_Error", "can't access file \'$AnnotationsListPath\'");
	5110	}
	5111	foreach my $Annotation (split(/\n/, readFile($AnnotationsListPath)))
	5112	{
[11682]	5113	$In::Opt{"AnnotationList_User"}{$Annotation} = 1;
[10845]	5114	}
	5115	}
[11682]	5116	if(my $SkipAnnotationsListPath = $In::Opt{"SkipAnnotationsListPath"})
[10845]	5117	{
	5118	if(not -f $SkipAnnotationsListPath) {
	5119	exitStatus("Access_Error", "can't access file \'$SkipAnnotationsListPath\'");
	5120	}
	5121	foreach my $Annotation (split(/\n/, readFile($SkipAnnotationsListPath)))
	5122	{
[11682]	5123	$In::Opt{"SkipAnnotationList_User"}{$Annotation} = 1;
[10845]	5124	}
	5125	}
[11682]	5126	if(my $SkipClassesList = $In::Opt{"SkipClassesList"})
[10845]	5127	{
	5128	if(not -f $SkipClassesList) {
	5129	exitStatus("Access_Error", "can't access file \'$SkipClassesList\'");
	5130	}
	5131	foreach my $Class (split(/\n/, readFile($SkipClassesList)))
	5132	{
	5133	$Class=~s/\//./g;
[11682]	5134	$In::Opt{"SkipClasses"}{$Class} = 1;
[10845]	5135	}
	5136	}
[13595]	5137	if(my $NonImplClassesList = $In::Opt{"NonImplClassesList"})
	5138	{
	5139	if(not -f $NonImplClassesList) {
	5140	exitStatus("Access_Error", "can't access file \'$NonImplClassesList\'");
	5141	}
	5142	foreach my $Class (split(/\n/, readFile($NonImplClassesList)))
	5143	{
	5144	$Class=~s/\//./g;
	5145	$In::Opt{"NonImplClasses"}{$Class} = 1;
	5146	}
	5147	}
[11682]	5148	if(my $SkipPackagesList = $In::Opt{"SkipPackagesList"})
[10845]	5149	{
	5150	if(not -f $SkipPackagesList) {
	5151	exitStatus("Access_Error", "can't access file \'$SkipPackagesList\'");
	5152	}
	5153	foreach my $Package (split(/\n/, readFile($SkipPackagesList)))
	5154	{
[11682]	5155	$In::Desc{1}{"SkipPackages"}{$Package} = 1;
	5156	$In::Desc{2}{"SkipPackages"}{$Package} = 1;
[10845]	5157	}
	5158	}
[11682]	5159	if(my $ClientPath = $In::Opt{"ClientPath"})
[10845]	5160	{
	5161	if($ClientPath=~/\.class\Z/) {
	5162	exitStatus("Error", "input file is not a java archive");
	5163	}
	5164
	5165	if(-f $ClientPath)
	5166	{
[11682]	5167	detectDefaultPaths("bin", undef);
[12872]	5168	loadModule("APIDump");
	5169
[10845]	5170	readArchive(0, $ClientPath)
	5171	}
	5172	else {
	5173	exitStatus("Access_Error", "can't access file \'$ClientPath\'");
	5174	}
	5175	}
	5176
[11682]	5177	if(my $DPath = $In::Opt{"CountMethods"})
[10845]	5178	{
[11682]	5179	if(not -e $DPath) {
	5180	exitStatus("Access_Error", "can't access \'$DPath\'");
[10845]	5181	}
	5182
[11682]	5183	$In::API{1} = readAPIDump(1, $DPath, "Main");
	5184	initAliases(1);
[10845]	5185
	5186	my $Count = 0;
[12872]	5187	foreach my $Method (keys(%{$MethodInfo{1}}))
	5188	{
[10845]	5189	$Count += methodFilter($Method, 1);
	5190	}
	5191
	5192	printMsg("INFO", $Count);
	5193	exit(0);
	5194	}
	5195
[11682]	5196	if($In::Opt{"DumpAPI"})
[10845]	5197	{
[11682]	5198	createAPIFile(1, $In::Opt{"DumpAPI"});
[10845]	5199	exit(0);
	5200	}
	5201
[11682]	5202	compareInit();
[10845]	5203
[11682]	5204	readRules("Binary");
	5205	readRules("Source");
[10845]	5206
	5207	detectAdded();
	5208	detectRemoved();
	5209
[11682]	5210	printMsg("INFO", "Comparing classes ...");
[10845]	5211	mergeClasses();
	5212	mergeMethods();
	5213
	5214	printReport();
	5215
	5216	if($RESULT{"Source"}{"Problems"} + $RESULT{"Binary"}{"Problems"}) {
[11682]	5217	exit(getErrorCode("Incompatible"));
[10845]	5218	}
	5219	else {
[11682]	5220	exit(getErrorCode("Compatible"));
[10845]	5221	}
	5222	}
	5223
	5224	scenario();

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: josm/trunk/tools/japicc/japi-compliance-checker.pl@ 18296

Download in other formats: