cache_internal_entries.diff

Hynek Cihlar, 05/04/2023 09:37 AM

           return true;
+       }
        public static class ObjectInternalEntryCacheKey
+       {
           private Class aClass;
           private String modes;
           private Class[] argsClasses;
           private int hashCode;
           public ObjectInternalEntryCacheKey(Class aClass, String modes, Class[] argsClasses)
+          {
              this.aClass = aClass;
              this.modes = modes;
              this.argsClasses = argsClasses;
              int result = Objects.hash(aClass, modes);
              result = 31 * result + Arrays.hashCode(argsClasses);
              this.hashCode = result;
+          }
           @Override
           public boolean equals(Object o)
+          {
              if (this == o)
+             {
                 return true;
+             }
              if (o == null)
+             {
                 return false;
+             }
              ObjectInternalEntryCacheKey that = (ObjectInternalEntryCacheKey) o;
              return Objects.equals(aClass, that.aClass) &&
                 Objects.equals(modes, that.modes) &&
                 Arrays.equals(argsClasses, that.argsClasses);
+          }
           @Override
           public int hashCode()
+          {
              return hashCode;
+          }
           @Override
           public String toString()
+          {
              return "ObjectInternalEntryCacheKey{" +
                 "aClass=" + aClass +
                 ", modes='" + modes + '\'' +
                 ", argsClasses=" + Arrays.toString(argsClasses) +
                 '}';
+          }
+       }
        /**
         * Given a legacy class instance, execute the initialization methods.  These are comprised from
         * the synthetic execute methods (for all super-classes), and the synthetic constructor method
-...
           wa.pm.addProcedure(phandle, name, true);
           BufferManager.get().resolvePendingBufferClasses(referent);
           List<InternalEntry> ctors = SourceNameMapper.getConstructors((Class) referent.getClass());
           InternalEntry ie = resolveLegacyEntry(wa, false, referent.getClass(), name, null, modes, ctors, args);
           Class refClass = referent.getClass();
           List<InternalEntry> ctors = SourceNameMapper.getConstructors(refClass);
           Class[] argsClasses = new Class[args == null ? 0 : args.length];
           for (int i = 0; i < argsClasses.length; i++)
+          {
              argsClasses[i] = args[i].getClass();
+          }
           ObjectInternalEntryCacheKey key = new ObjectInternalEntryCacheKey(refClass, modes, argsClasses);
           InternalEntry ie = wa.cachedObjectIEntries.get(key);
           System.out.println(key + " -> " + ie);
           if (ie == null)
+          {
              ie = resolveLegacyEntry(wa, false, refClass, name, null, modes, ctors, args);
              if (ie == null)
+             {
                 ie = InternalEntry.NULL;
+             }
              wa.cachedObjectIEntries.put(key, ie);
              System.out.println(key + " put " + ie);
+          }
           if (ie == InternalEntry.NULL)
+          {
              // not found
              return false;
+          }
-...
                 // use the method resolved after arg validation.
                 ctorCaller.mthd = ie.getMethod();
                 InternalEntry finalIe = ie;
                 Runnable push = () ->
+                {
                    Class<?> def = ie.getMethod().getDeclaringClass();
                    Class<?> def = finalIe.getMethod().getDeclaringClass();
                    wa.pm.pushCalleeInfo(def, false, referent, referent, "CONSTRUCTOR", relName, false, false);
                 };
-...
           /** Cached resolved procedure internal entries */
           private HashMap<InternalResolver.InternalEntryCacheKey, InternalEntry> cachedIEntries = new HashMap<>();
           private HashMap<ObjectInternalEntryCacheKey, InternalEntry> cachedObjectIEntries = new HashMap<>();
           private WorkArea()
+          {

      */
     public class InternalEntry
+    {
        @Override
        public String toString()
+       {
           return "InternalEntry{" +
              "pname='" + pname + '\'' +
              ", jname='" + jname + '\'' +
              ", type=" + type +
              ", signature='" + signature + '\'' +
              ", parameterModes='" + parameterModes + '\'' +
              ", isSuper=" + isSuper +
              ", inHandle=" + inHandle +
              ", isPrivate=" + isPrivate +
              ", extent=" + extent +
              ", method=" + method +
              ", libname='" + libname + '\'' +
              '}';
+       }
        /** Type of internal entry */
        public static enum Type
+       {
-...
              return name;
+          }
        };
        /** Represents null InternalEntry value */
        public static final InternalEntry NULL = new InternalEntry();
        public static enum SerializeMode {
           DEFAULT,
           VISIBLE,
-...
         */
        private ExternalProgram extprog;
        /** Represents null InternalEntry value */
        public static final InternalEntry NULL = new InternalEntry();
        /**
         * Private constructor for the internal implementation.
         */

src/com/goldencode/p2j/util/SourceNameMapper.java 2023-05-04 13:39:44 +0000
1136	1136	*
1137	1137	* @param type
1138	1138	* The legacy class.
1139		* @param static_
1140		* If the static or instance constructors are required.
1141	1139	*/
1142	1140	public static List<InternalEntry> getConstructors(Class<? extends _BaseObject_> type)
1143	1141	{

Project

General

Profile

FWD » Core Development » Base Language

cache_internal_entries.diff