Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package parboiled for openSUSE:Factory checked in at 2023-10-11 23:55:39 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/parboiled (Old) and /work/SRC/openSUSE:Factory/.parboiled.new.1807 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "parboiled" Wed Oct 11 23:55:39 2023 rev:6 rq:1116885 version:1.4.1 Changes: -------- --- /work/SRC/openSUSE:Factory/parboiled/parboiled.changes 2022-03-20 20:56:43.278627701 +0100 +++ /work/SRC/openSUSE:Factory/.parboiled.new.1807/parboiled.changes 2023-10-12 11:48:22.906699076 +0200 @@ -1,0 +2,49 @@ +Wed Oct 11 07:22:30 UTC 2023 - Fridrich Strba <[email protected]> + +- Do not build the scala subpackage, since it is not needed by any + package + +------------------------------------------------------------------- +Fri Oct 6 11:26:05 UTC 2023 - Fridrich Strba <[email protected]> + +- Upgrade to upstream version 1.4.1 + * Changes of 1.4.1 + + Improved support for Java 16+ + + Dropped support for Java 8 + * Changes of 1.4.0 + + Support Java 17 + + Upgraded to ASM 9.2 + + Dropped support for Scala 2.11 + * Changes of 1.3.1 + + Upgraded to ASM 7.1 + + Fixed class loader in parser generation + + Added cross-build for Scala 2.13.0 + + Dropped support for Scala 2.10 + * Changes of 1.3.0 + + Upgraded to ASM 7.0 + + Added Scala 2.13.0-M5 build + * Changes of 1.2.0 + + Added support for '~~>' and friends in ReductionRules + + Added support for PushRules to chain after ReductionRules + + Upgraded to ASM 6.2.1 + + Added Scala 2.13.0-M4 build + + Dropped support for Java 1.5 + * Changes of 1.1.8 + + Cross build for Scala 2.10, 2.11 and 2.12 + + Upgrade to ASM 5.2 + + Fixed "Utils.findConstructor doesn't match boolean parameter" + + Added method for clearing class cache in AsmUtil + * Changes of 1.1.7 + + Upgrade to Scala 2.11.4, cross build for Scala 2.9.2, 2.9.3, + 2.10 and 2.11 + + Upgrade to ASM 5.0.3, closed #76 + + Make parboiled-java relocatable, closed #80 +- Added patch: + * restore-java8-compatibility.patch + + revert upstream commit making changes incompatible with + Java 8 +- Removed patch: + * parboiled-port-to-objectweb-asm-5.0.1.patch + + not needed with this version + +------------------------------------------------------------------- Old: ---- 1.1.6.tar.gz _multibuild parboiled-1.1.6-build.tar.xz parboiled-core-1.1.6.pom parboiled-java-1.1.6.pom parboiled-port-to-objectweb-asm-5.0.1.patch parboiled-scala_2.10-1.1.6.pom New: ---- 1.4.1.tar.gz parboiled-build.tar.xz parboiled-core-1.4.1.pom parboiled-java-1.4.1.pom restore-java8-compatibility.patch ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ parboiled.spec ++++++ --- /var/tmp/diff_new_pack.vhZpJS/_old 2023-10-12 11:48:23.498721029 +0200 +++ /var/tmp/diff_new_pack.vhZpJS/_new 2023-10-12 11:48:23.502721177 +0200 @@ -1,7 +1,7 @@ # -# spec file +# spec file for package parboiled # -# Copyright (c) 2022 SUSE LLC +# Copyright (c) 2023 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -16,58 +16,28 @@ # -%global flavor @BUILD_FLAVOR@%{nil} -%if "%{flavor}" == "scala" -%bcond_without scala -%else -%bcond_with scala -%endif -%global scala_short_version 2.10 -%global base_name parboiled -%if %{with scala} -Name: %{base_name}-scala -Summary: Parboiled for Scala -License: Apache-2.0 -Group: Development/Libraries/Java -%else -Name: %{base_name} -Summary: Java/Scala library providing parsing of input text based on PEGs +Name: parboiled +Version: 1.4.1 +Release: 0 +Summary: Java library providing parsing of input text based on PEGs License: Apache-2.0 Group: Development/Libraries/Java -%endif -Version: 1.1.6 -Release: 0 URL: http://parboiled.org/ Source0: https://github.com/sirthias/parboiled/archive/%{version}.tar.gz -Source1: %{base_name}-%{version}-build.tar.xz +Source1: %{name}-build.tar.xz # for build see https://github.com/sirthias/parboiled/wiki/Building-parboiled -Source2: http://repo1.maven.org/maven2/org/parboiled/%{base_name}-core/%{version}/%{base_name}-core-%{version}.pom -Source3: http://repo1.maven.org/maven2/org/parboiled/%{base_name}-java/%{version}/%{base_name}-java-%{version}.pom -Source4: http://repo1.maven.org/maven2/org/parboiled/%{base_name}-scala_%{scala_short_version}/%{version}/%{base_name}-scala_%{scala_short_version}-%{version}.pom -Patch0: parboiled-port-to-objectweb-asm-5.0.1.patch +Source2: https://repo1.maven.org/maven2/org/parboiled/%{name}-core/%{version}/%{name}-core-%{version}.pom +Source3: https://repo1.maven.org/maven2/org/parboiled/%{name}-java/%{version}/%{name}-java-%{version}.pom +Patch0: restore-java8-compatibility.patch BuildRequires: ant BuildRequires: fdupes +BuildRequires: java-devel >= 1.8 BuildRequires: javapackages-local -%if %{with scala} -BuildRequires: ant-scala >= 2.10.7 -BuildRequires: parboiled -Requires: mvn(org.parboiled:parboiled-core) = %{version} -Requires: mvn(org.scala-lang:scala-library) -%else BuildRequires: objectweb-asm -Requires: mvn(org.ow2.asm:asm) -Requires: mvn(org.ow2.asm:asm-analysis) -Requires: mvn(org.ow2.asm:asm-tree) -Requires: mvn(org.ow2.asm:asm-util) -%endif BuildArch: noarch %description -%if %{with scala} -An internal Scala DSL for efficiently defining your parser rules. - -%endif -parboiled is a mixed Java/Scala library providing parsing of +parboiled is a mixed Java library providing parsing of arbitrary input text based on Parsing expression grammars (PEGs). PEGs are an alternative to context free grammars (CFGs) for formally specifying syntax, they make a replacement for regular expressions @@ -82,49 +52,32 @@ This package contains javadoc for %{name}. %prep -%setup -q -n %{base_name}-%{version} -a1 - -find . -name "*.class" -delete -find . -name "*.jar" -delete - +%setup -q -n %{name}-%{version} -a1 %patch0 -p1 -cp %{SOURCE2} %{base_name}-core/pom.xml -cp %{SOURCE3} %{base_name}-java/pom.xml -cp %{SOURCE4} %{base_name}-scala/pom.xml +cp %{SOURCE2} %{name}-core/pom.xml +cp %{SOURCE3} %{name}-java/pom.xml %build mkdir -p lib build-jar-repository -s lib \ -%if %{with scala} - %{base_name} -%else objectweb-asm -%endif %{ant} \ -%if %{with scala} - -Dscala.libDir=%{_datadir}/scala/lib \ - -f build-scala.xml \ -%endif package javadoc %install -%if %{with scala} -%global modules scala -%else %global modules core java -%endif -install -dm 0755 %{buildroot}%{_javadir}/%{base_name} -install -dm 0755 %{buildroot}%{_mavenpomdir}/%{base_name} +install -dm 0755 %{buildroot}%{_javadir}/%{name} +install -dm 0755 %{buildroot}%{_mavenpomdir}/%{name} for i in %{modules}; do # jar - install -pm 0644 %{base_name}-${i}/target/%{base_name}-${i}*%{version}.jar %{buildroot}%{_javadir}/%{base_name}/${i}.jar + install -pm 0644 %{name}-${i}/target/%{name}-${i}*%{version}.jar %{buildroot}%{_javadir}/%{name}/${i}.jar # pom - install -pm 0644 %{base_name}-${i}/pom.xml %{buildroot}%{_mavenpomdir}/%{base_name}/${i}.pom - %add_maven_depmap %{base_name}/${i}.pom %{base_name}/${i}.jar + %{mvn_install_pom} %{name}-${i}/pom.xml %{buildroot}%{_mavenpomdir}/%{name}/${i}.pom + %add_maven_depmap %{name}/${i}.pom %{name}/${i}.jar # javadoc - install -dm 0755 %{buildroot}%{_javadocdir}/%{base_name}/${i} - cp -pr %{base_name}-${i}/target/site/apidocs/* %{buildroot}%{_javadocdir}/%{base_name}/${i}/ + install -dm 0755 %{buildroot}%{_javadocdir}/%{name}/${i} + cp -pr %{name}-${i}/target/site/apidocs/* %{buildroot}%{_javadocdir}/%{name}/${i}/ done %fdupes -s %{buildroot}%{_javadocdir} @@ -134,5 +87,5 @@ %files javadoc %license LICENSE -%{_javadocdir}/%{base_name} +%{_javadocdir}/%{name} ++++++ 1.1.6.tar.gz -> 1.4.1.tar.gz ++++++ ++++ 5892 lines of diff (skipped) ++++++ parboiled-1.1.6-build.tar.xz -> parboiled-build.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/common.xml new/common.xml --- old/common.xml 2022-03-20 16:23:54.132311416 +0100 +++ new/common.xml 2023-09-29 18:26:14.714874288 +0200 @@ -5,13 +5,14 @@ <property file="build.properties"/> <property name="project.groupId" value="org.parboiled"/> - <property name="project.version" value="1.1.6"/> + <property name="project.version" value="1.4.1"/> <property name="project.description" value="Elegant parsing in Java and Scala - lightweight, easy-to-use, powerful"/> <property name="project.organization.name" value="${project.groupId}"/> <property name="project.organization.url" value="http://parboiled.org"/> <property name="project.license.url" value="http://www.apache.org/licenses/LICENSE-2.0.txt"/> - <property name="compiler.source" value="1.8"/> + <property name="compiler.release" value="8"/> + <property name="compiler.source" value="1.${compiler.release}"/> <property name="compiler.target" value="${compiler.source}"/> </project> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parboiled-core/build.xml new/parboiled-core/build.xml --- old/parboiled-core/build.xml 2019-11-27 07:35:37.832134136 +0100 +++ new/parboiled-core/build.xml 2023-10-11 09:49:53.696984580 +0200 @@ -50,6 +50,7 @@ debug="true" optimize="false" deprecation="true" + release="${compiler.release}" target="${compiler.target}" verbose="false" fork="false" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parboiled-java/build.xml new/parboiled-java/build.xml --- old/parboiled-java/build.xml 2019-02-15 12:58:41.375071554 +0100 +++ new/parboiled-java/build.xml 2023-10-11 09:50:04.643719416 +0200 @@ -51,6 +51,7 @@ debug="true" optimize="false" deprecation="true" + release="${compiler.release}" target="${compiler.target}" verbose="false" fork="false" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parboiled-scala/build.xml new/parboiled-scala/build.xml --- old/parboiled-scala/build.xml 2019-11-27 07:35:10.288010357 +0100 +++ new/parboiled-scala/build.xml 2023-09-29 18:41:36.221329060 +0200 @@ -1,6 +1,6 @@ <?xml version="1.0" encoding="UTF-8"?> -<project name="parboiled-scala_2.10" default="package" basedir="."> +<project name="parboiled-scala_2.13" default="package" basedir="."> <!-- ====================================================================== --> <!-- Build environment properties --> @@ -12,7 +12,7 @@ <property file="build.properties"/> <property name="project.fragment" value="scala"/> - <property name="project.artifactId" value="parboiled-${project.fragment}_2.10"/> + <property name="project.artifactId" value="parboiled-${project.fragment}_2.13"/> <property name="scala.home" value="${env.SCALA_HOME}"/> <property name="scala.libDir" value="${scala.home}/lib"/> ++++++ parboiled-core-1.1.6.pom -> parboiled-core-1.4.1.pom ++++++ --- /work/SRC/openSUSE:Factory/parboiled/parboiled-core-1.1.6.pom 2019-04-05 12:04:00.598599032 +0200 +++ /work/SRC/openSUSE:Factory/.parboiled.new.1807/parboiled-core-1.4.1.pom 2023-10-12 11:48:22.886698335 +0200 @@ -3,10 +3,10 @@ <modelVersion>4.0.0</modelVersion> <groupId>org.parboiled</groupId> <artifactId>parboiled-core</artifactId> - <packaging>bundle</packaging> + <packaging>jar</packaging> <description>Elegant parsing in Java and Scala - lightweight, easy-to-use, powerful</description> <url>http://parboiled.org</url> - <version>1.1.6</version> + <version>1.4.1</version> <licenses> <license> <name>Apache 2</name> @@ -32,15 +32,15 @@ </developers> <dependencies> <dependency> - <groupId>org.testng</groupId> - <artifactId>testng</artifactId> - <version>5.14.1</version> + <groupId>org.scalatestplus</groupId> + <artifactId>testng-7-5_2.13</artifactId> + <version>3.2.11.0</version> <scope>test</scope> </dependency> <dependency> <groupId>org.scalatest</groupId> - <artifactId>scalatest_2.9.3</artifactId> - <version>1.9.1</version> + <artifactId>scalatest_2.13</artifactId> + <version>3.2.11</version> <scope>test</scope> </dependency> </dependencies> ++++++ parboiled-java-1.1.6.pom -> parboiled-java-1.4.1.pom ++++++ --- /work/SRC/openSUSE:Factory/parboiled/parboiled-java-1.1.6.pom 2019-04-05 12:04:00.654599051 +0200 +++ /work/SRC/openSUSE:Factory/.parboiled.new.1807/parboiled-java-1.4.1.pom 2023-10-12 11:48:22.898698780 +0200 @@ -3,10 +3,10 @@ <modelVersion>4.0.0</modelVersion> <groupId>org.parboiled</groupId> <artifactId>parboiled-java</artifactId> - <packaging>bundle</packaging> + <packaging>jar</packaging> <description>Elegant parsing in Java and Scala - lightweight, easy-to-use, powerful</description> <url>http://parboiled.org</url> - <version>1.1.6</version> + <version>1.4.1</version> <licenses> <license> <name>Apache 2</name> @@ -34,39 +34,39 @@ <dependency> <groupId>org.parboiled</groupId> <artifactId>parboiled-core</artifactId> - <version>1.1.6</version> + <version>1.4.1</version> </dependency> <dependency> - <groupId>org.testng</groupId> - <artifactId>testng</artifactId> - <version>5.14.1</version> + <groupId>org.scalatestplus</groupId> + <artifactId>testng-7-5_2.13</artifactId> + <version>3.2.11.0</version> <scope>test</scope> </dependency> <dependency> <groupId>org.scalatest</groupId> - <artifactId>scalatest_2.9.3</artifactId> - <version>1.9.1</version> + <artifactId>scalatest_2.13</artifactId> + <version>3.2.11</version> <scope>test</scope> </dependency> <dependency> <groupId>org.ow2.asm</groupId> <artifactId>asm</artifactId> - <version>4.1</version> + <version>9.2</version> </dependency> <dependency> <groupId>org.ow2.asm</groupId> <artifactId>asm-tree</artifactId> - <version>4.1</version> + <version>9.2</version> </dependency> <dependency> <groupId>org.ow2.asm</groupId> <artifactId>asm-analysis</artifactId> - <version>4.1</version> + <version>9.2</version> </dependency> <dependency> <groupId>org.ow2.asm</groupId> <artifactId>asm-util</artifactId> - <version>4.1</version> + <version>9.2</version> </dependency> </dependencies> </project> \ No newline at end of file ++++++ restore-java8-compatibility.patch ++++++ --- parboiled-1.4.1/parboiled-java/src/main/java/org/parboiled/transform/AsmUtils.java 2023-10-11 09:54:38.742121727 +0200 +++ parboiled-1.4.1/parboiled-java/src/main/java/org/parboiled/transform/AsmUtils.java 2023-10-11 09:54:51.432202375 +0200 @@ -35,7 +35,6 @@ import java.io.IOException; import java.io.InputStream; -import java.lang.invoke.MethodHandles; import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Field; @@ -47,8 +46,6 @@ class AsmUtils { - private static final LookupFactory lookupFactory = new LookupFactory(); - public static ClassReader createClassReader(Class<?> clazz) throws IOException { checkArgNotNull(clazz, "clazz"); String classFilename = clazz.getName().replace('.', '/') + ".class"; @@ -199,17 +196,22 @@ * Otherwise the method returns null. * * @param className the full name of the class to be loaded - * @param parentClass the parent class of the class with the given className + * @param classLoader the class loader to use * @return the class instance or null */ - public static Class<?> loadClass(String className, Class<?> parentClass) { + public static Class<?> findLoadedClass(String className, ClassLoader classLoader) { checkArgNotNull(className, "className"); - checkArgNotNull(parentClass, "parentClass"); + checkArgNotNull(classLoader, "classLoader"); try { + Class<?> classLoaderBaseClass = Class.forName("java.lang.ClassLoader"); + Method findLoadedClassMethod = classLoaderBaseClass.getDeclaredMethod("findLoadedClass", String.class); + + // protected method invocation + findLoadedClassMethod.setAccessible(true); try { - return parentClass.getClassLoader().loadClass(className); - } catch (ClassNotFoundException cnfe) { - return null; + return (Class<?>) findLoadedClassMethod.invoke(classLoader, className); + } finally { + findLoadedClassMethod.setAccessible(false); } } catch (Exception e) { throw new RuntimeException("Could not determine whether class '" + className + @@ -218,30 +220,22 @@ } /** - * Defines a new class with the given name and bytecode within the package of the given parent class. - * Since package and class identity includes the ClassLoader instance used to load a class we use reflection + * Loads the class defined with the given name and bytecode using the given class loader. + * Since package and class idendity includes the ClassLoader instance used to load a class we use reflection * on the given class loader to define generated classes. If we used our own class loader (in order to be able * to access the protected "defineClass" method) we would likely still be able to load generated classes, * however, they would not have access to package-private classes and members of their super classes. * * @param className the full name of the class to be loaded * @param code the bytecode of the class to load - * @param parentClass the parent class of the new class + * @param classLoader the class loader to use * @return the class instance */ - public static Class<?> defineClass(String className, byte[] code, Class<?> parentClass) { + public static Class<?> loadClass(String className, byte[] code, ClassLoader classLoader) { checkArgNotNull(className, "className"); checkArgNotNull(code, "code"); - checkArgNotNull(parentClass, "parentClass"); - + checkArgNotNull(classLoader, "classLoader"); try { - if (lookupFactory != null) { - MethodHandles.Lookup lookup = lookupFactory.lookupFor(parentClass); - if (lookup != null) { - return lookup.defineClass(code); - } - } - Class<?> classLoaderBaseClass = Class.forName("java.lang.ClassLoader"); Method defineClassMethod = classLoaderBaseClass.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class); @@ -249,7 +243,7 @@ // protected method invocation defineClassMethod.setAccessible(true); try { - return (Class<?>) defineClassMethod.invoke(parentClass.getClassLoader(), className, code, 0, code.length); + return (Class<?>) defineClassMethod.invoke(classLoader, className, code, 0, code.length); } finally { defineClassMethod.setAccessible(false); } --- parboiled-1.4.1/parboiled-java/src/main/java/org/parboiled/transform/GroupClassGenerator.java 2023-10-11 09:54:38.758788500 +0200 +++ parboiled-1.4.1/parboiled-java/src/main/java/org/parboiled/transform/GroupClassGenerator.java 2023-10-11 09:58:14.413389233 +0200 @@ -23,7 +23,8 @@ import org.objectweb.asm.tree.*; import static org.objectweb.asm.Opcodes.*; -import static org.parboiled.transform.AsmUtils.defineClass; +import static org.parboiled.transform.AsmUtils.findLoadedClass; +import static org.parboiled.transform.AsmUtils.loadClass; abstract class GroupClassGenerator implements RuleMethodProcessor { @@ -53,15 +54,16 @@ private void loadGroupClass(InstructionGroup group) { createGroupClassType(group); String className = group.getGroupClassType().getClassName(); + ClassLoader classLoader = classNode.getParentClass().getClassLoader(); Class<?> groupClass; synchronized (lock) { - groupClass = AsmUtils.loadClass(className, classNode.getParentClass()); + groupClass = findLoadedClass(className, classLoader); if (groupClass == null || forceCodeBuilding) { byte[] groupClassCode = generateGroupClassCode(group); group.setGroupClassCode(groupClassCode); if (groupClass == null) { - AsmUtils.defineClass(className, groupClassCode, classNode.getParentClass()); + loadClass(className, groupClassCode, classLoader); } } } @@ -71,7 +73,7 @@ String s = classNode.name; int lastSlash = classNode.name.lastIndexOf('/'); // do not prepend a slash if class is in the default package (lastSlash == -1) - String groupClassInternalName = (lastSlash >= 0 ? s.substring(0, lastSlash) + '/' : "") + group.getName(); + String groupClassInternalName = (lastSlash >= 0 ? s.substring(0, lastSlash) : s)+ '/' + group.getName(); group.setGroupClassType(Type.getObjectType(groupClassInternalName)); } --- parboiled-1.4.1/parboiled-java/src/main/java/org/parboiled/transform/LookupFactory.java 2023-10-11 09:54:38.758788500 +0200 +++ parboiled-1.4.1/parboiled-java/src/main/java/org/parboiled/transform/LookupFactory.java 1970-01-01 01:00:00.000000000 +0100 @@ -1,105 +0,0 @@ -/* - * Copyright (C) 2022 parboiled contributors - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.parboiled.transform; - -import java.lang.invoke.MethodHandles.Lookup; -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.util.WeakHashMap; - -/** - * Helper that can be used to create {@link Lookup} instances for - * specific classes. - */ -final class LookupFactory { - - private WeakHashMap<Class<?>, Lookup> lookups = new WeakHashMap<>(); - private Lookup trustedLookup; - - LookupFactory() { - loadTrustedLookup(); - } - - /** - * Tries to load a trusted {@link Lookup} instance. - * - * <p> - * Adapted from <a href="https://github.com/google/guice/blob/cf759d44c78e8490e3d54df6a27918e0811bbdf9/core/src/com/google/inject/internal/aop/HiddenClassDefiner.java#L40";>HiddenClassDefiner</a> - * of Google Guice. - * </p> - */ - private void loadTrustedLookup() { - try { - Class<?> unsafeType = Class.forName("sun.misc.Unsafe"); - Field theUnsafeField = unsafeType.getDeclaredField("theUnsafe"); - theUnsafeField.setAccessible(true); - Object unsafeInstance = theUnsafeField.get(null); - Field trustedLookupField = Lookup.class.getDeclaredField("IMPL_LOOKUP"); - Method baseMethod = unsafeType.getMethod("staticFieldBase", Field.class); - Object trustedLookupBase = baseMethod.invoke(unsafeInstance, trustedLookupField); - Method offsetMethod = unsafeType.getMethod("staticFieldOffset", Field.class); - Object trustedLookupOffset = offsetMethod.invoke(unsafeInstance, trustedLookupField); - Method getObjectMethod = unsafeType.getMethod("getObject", Object.class, long.class); - this.trustedLookup = - (Lookup) getObjectMethod.invoke(unsafeInstance, trustedLookupBase, trustedLookupOffset); - } catch (Exception e) { - // Unsafe and trusted lookup is not available - } - } - - /** - * Determines a {@link Lookup} instance for the given hostClass. - * <p> - * The method first tries to use a static method of the hostClass with the - * following signature: - * </p> - * <p> - * <code> - * public static {@link Lookup} lookup(); - * </code> - * </p> - * <p> - * If this fails then it tries to use a trusted lookup - * instance created via sun.misc.Unsafe. - * </p> - * - * @param hostClass The target class of the lookup instance - * @return a lookup instance or <code>null</code> if not found - */ - Lookup lookupFor(Class<?> hostClass) { - Lookup lookup = lookups.get(hostClass); - if (lookup == null) { - try { - // try to find a lookup() method first - Method lookupMethod = hostClass.getMethod("lookup"); - lookup = (Lookup) lookupMethod.invoke(null); - } catch (Exception e) { - // failed to use lookup() method - } - - if (lookup == null && trustedLookup != null) { - // use trusted lookup instance if available - lookup = trustedLookup.in(hostClass); - } - - if (lookup != null) { - lookups.put(hostClass, lookup); - } - } - return lookup; - } -} \ No newline at end of file --- parboiled-1.4.1/parboiled-java/src/main/java/org/parboiled/transform/ParserTransformer.java 2023-10-11 09:54:38.758788500 +0200 +++ parboiled-1.4.1/parboiled-java/src/main/java/org/parboiled/transform/ParserTransformer.java 2023-10-11 09:55:09.205648662 +0200 @@ -32,8 +32,8 @@ public static synchronized <T> Class<? extends T> transformParser(Class<T> parserClass) throws Exception { checkArgNotNull(parserClass, "parserClass"); // first check whether we did not already create and load the extension of the given parser class - Class<?> extendedClass = AsmUtils.loadClass( - getExtendedParserClassName(parserClass.getName()), parserClass + Class<?> extendedClass = findLoadedClass( + getExtendedParserClassName(parserClass.getName()), parserClass.getClassLoader() ); return (Class<? extends T>) (extendedClass != null ? extendedClass : extendParserClass(parserClass).getExtendedClass()); @@ -102,10 +102,10 @@ }; classNode.accept(classWriter); classNode.setClassCode(classWriter.toByteArray()); - classNode.setExtendedClass(defineClass( + classNode.setExtendedClass(loadClass( classNode.name.replace('/', '.'), classNode.getClassCode(), - classNode.getParentClass() + classNode.getParentClass().getClassLoader() )); }
