rootNodeFunction, Class extends Node> nodeClass1, Class> nodeClass2, PythonBuiltinClassType type, String name) {
+ // for slot wrappers: the type is used for validation of "self" type
+ return createCachedCallTargetUnsafe(rootNodeFunction, true, nodeClass1, nodeClass2, type, name);
+ }
+
/**
* Caches call targets for external C functions created by extensions at runtime.
*
@@ -1174,28 +1180,12 @@ private RootCallTarget createCachedCallTargetUnsafe(Function {
- T boundToObject(PythonBuiltinClassType binding, PythonObjectFactory factory);
+ T boundToObject(PythonBuiltinClassType binding, PythonLanguage language);
}
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtin.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtin.java
index 18ac9d4ed0..a99c4ccccd 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtin.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtin.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2017, 2024, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2025, Oracle and/or its affiliates.
* Copyright (c) 2013, Regents of the University of California
*
* All rights reserved.
@@ -45,10 +45,6 @@
*/
PythonOS os() default PythonOS.PLATFORM_ANY;
- PythonBuiltinClassType constructsClass() default PythonBuiltinClassType.nil;
-
- PythonBuiltinClassType[] base() default {};
-
int minNumOfPositionalArgs() default 0;
int maxNumOfPositionalArgs() default -1;
@@ -63,16 +59,12 @@
boolean takesVarArgs() default false;
- boolean varArgsMarker() default false;
-
boolean takesVarKeywordArgs() default false;
String[] parameterNames() default {};
String[] keywordOnlyNames() default {};
- boolean isPublic() default true;
-
boolean isClassmethod() default false;
boolean isStaticmethod() default false;
@@ -97,15 +89,6 @@
*/
boolean declaresExplicitSelf() default false;
- /**
- * Declares that this builtin needs to reverse the first and second argument it receives. This
- * implements the reverse operation wrappers from CPython. This only applies to binary and
- * ternary nodes.
- *
- * @see com.oracle.graal.python.nodes.function.BuiltinFunctionRootNode BuiltinFunctionRootNode
- */
- boolean reverseOperation() default false;
-
String raiseErrorName() default StringLiterals.J_EMPTY_STRING;
boolean forceSplitDirectCalls() default false;
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/CoreFunctions.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/CoreFunctions.java
index fedb82582b..9e9bf4955b 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/CoreFunctions.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/CoreFunctions.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2025, Oracle and/or its affiliates.
* Copyright (c) 2013, Regents of the University of California
*
* All rights reserved.
@@ -40,11 +40,7 @@
*/
PythonOS os() default PythonOS.PLATFORM_ANY;
- String publicName() default "";
-
PythonBuiltinClassType[] extendClasses() default {};
- String pythonFile() default "";
-
boolean isEager() default false;
}
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Python3Core.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Python3Core.java
index 97405a14f7..20b24d7a73 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Python3Core.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Python3Core.java
@@ -32,15 +32,20 @@
import static com.oracle.graal.python.nodes.BuiltinNames.T_NT;
import static com.oracle.graal.python.nodes.BuiltinNames.T_STDERR;
import static com.oracle.graal.python.nodes.BuiltinNames.T_SYS;
+import static com.oracle.graal.python.nodes.BuiltinNames.T_UNICODEDATA;
import static com.oracle.graal.python.nodes.BuiltinNames.T_ZIPIMPORT;
+import static com.oracle.graal.python.nodes.BuiltinNames.T__SRE;
+import static com.oracle.graal.python.nodes.BuiltinNames.T__SYSCONFIG;
import static com.oracle.graal.python.nodes.BuiltinNames.T__WEAKREF;
import static com.oracle.graal.python.nodes.BuiltinNames.T___BUILTINS__;
+import static com.oracle.graal.python.nodes.BuiltinNames.T___GRAALPYTHON__;
import static com.oracle.graal.python.nodes.BuiltinNames.T___IMPORT__;
+import static com.oracle.graal.python.nodes.SpecialAttributeNames.T___DOC__;
import static com.oracle.graal.python.nodes.SpecialAttributeNames.T___PACKAGE__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.T___REPR__;
import static com.oracle.graal.python.nodes.StringLiterals.J_PY_EXTENSION;
import static com.oracle.graal.python.nodes.StringLiterals.T_DOT;
import static com.oracle.graal.python.nodes.StringLiterals.T_GRAALPYTHON;
+import static com.oracle.graal.python.nodes.StringLiterals.T_JAVA;
import static com.oracle.graal.python.nodes.StringLiterals.T_REF;
import static com.oracle.graal.python.util.PythonUtils.toTruffleStringUncached;
import static com.oracle.graal.python.util.PythonUtils.tsLiteral;
@@ -56,21 +61,14 @@
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.ServiceLoader;
import java.util.logging.Level;
-import com.oracle.graal.python.builtins.objects.foreign.ForeignExecutableBuiltins;
-import com.oracle.graal.python.builtins.objects.foreign.ForeignInstantiableBuiltins;
-import com.oracle.graal.python.builtins.objects.foreign.ForeignIterableBuiltins;
-import org.graalvm.nativeimage.ImageInfo;
-
import com.oracle.graal.python.PythonLanguage;
import com.oracle.graal.python.builtins.modules.AbcModuleBuiltins;
import com.oracle.graal.python.builtins.modules.ArrayModuleBuiltins;
import com.oracle.graal.python.builtins.modules.AsyncioModuleBuiltins;
import com.oracle.graal.python.builtins.modules.AtexitModuleBuiltins;
import com.oracle.graal.python.builtins.modules.BinasciiModuleBuiltins;
-import com.oracle.graal.python.builtins.modules.BuiltinConstructors;
import com.oracle.graal.python.builtins.modules.BuiltinFunctions;
import com.oracle.graal.python.builtins.modules.CmathModuleBuiltins;
import com.oracle.graal.python.builtins.modules.CodecsModuleBuiltins;
@@ -82,16 +80,12 @@
import com.oracle.graal.python.builtins.modules.FaulthandlerModuleBuiltins;
import com.oracle.graal.python.builtins.modules.FcntlModuleBuiltins;
import com.oracle.graal.python.builtins.modules.GcModuleBuiltins;
-import com.oracle.graal.python.builtins.modules.GraalHPyDebugModuleBuiltins;
-import com.oracle.graal.python.builtins.modules.GraalHPyTraceModuleBuiltins;
-import com.oracle.graal.python.builtins.modules.GraalHPyUniversalModuleBuiltins;
import com.oracle.graal.python.builtins.modules.GraalPythonModuleBuiltins;
import com.oracle.graal.python.builtins.modules.ImpModuleBuiltins;
import com.oracle.graal.python.builtins.modules.ItertoolsModuleBuiltins;
import com.oracle.graal.python.builtins.modules.JArrayModuleBuiltins;
import com.oracle.graal.python.builtins.modules.JavaModuleBuiltins;
import com.oracle.graal.python.builtins.modules.LocaleModuleBuiltins;
-import com.oracle.graal.python.builtins.modules.LsprofModuleBuiltins;
import com.oracle.graal.python.builtins.modules.MMapModuleBuiltins;
import com.oracle.graal.python.builtins.modules.MarshalModuleBuiltins;
import com.oracle.graal.python.builtins.modules.MathModuleBuiltins;
@@ -112,6 +106,7 @@
import com.oracle.graal.python.builtins.modules.SelectModuleBuiltins;
import com.oracle.graal.python.builtins.modules.SignalModuleBuiltins;
import com.oracle.graal.python.builtins.modules.SocketModuleBuiltins;
+import com.oracle.graal.python.builtins.modules.StatResultBuiltins;
import com.oracle.graal.python.builtins.modules.StringModuleBuiltins;
import com.oracle.graal.python.builtins.modules.StructModuleBuiltins;
import com.oracle.graal.python.builtins.modules.SysModuleBuiltins;
@@ -171,7 +166,6 @@
import com.oracle.graal.python.builtins.modules.functools.PartialBuiltins;
import com.oracle.graal.python.builtins.modules.hashlib.Blake2ModuleBuiltins;
import com.oracle.graal.python.builtins.modules.hashlib.Blake2bObjectBuiltins;
-import com.oracle.graal.python.builtins.modules.hashlib.Blake2sObjectBuiltins;
import com.oracle.graal.python.builtins.modules.hashlib.DigestObjectBuiltins;
import com.oracle.graal.python.builtins.modules.hashlib.HashObjectBuiltins;
import com.oracle.graal.python.builtins.modules.hashlib.HashlibModuleBuiltins;
@@ -202,6 +196,8 @@
import com.oracle.graal.python.builtins.modules.json.JSONEncoderBuiltins;
import com.oracle.graal.python.builtins.modules.json.JSONModuleBuiltins;
import com.oracle.graal.python.builtins.modules.json.JSONScannerBuiltins;
+import com.oracle.graal.python.builtins.modules.lsprof.LsprofModuleBuiltins;
+import com.oracle.graal.python.builtins.modules.lsprof.ProfilerBuiltins;
import com.oracle.graal.python.builtins.modules.lzma.LZMACompressorBuiltins;
import com.oracle.graal.python.builtins.modules.lzma.LZMADecompressorBuiltins;
import com.oracle.graal.python.builtins.modules.lzma.LZMAModuleBuiltins;
@@ -240,6 +236,8 @@
import com.oracle.graal.python.builtins.objects.contextvars.TokenBuiltins;
import com.oracle.graal.python.builtins.objects.deque.DequeBuiltins;
import com.oracle.graal.python.builtins.objects.deque.DequeIterBuiltins;
+import com.oracle.graal.python.builtins.objects.deque.DequeIterCommonBuiltins;
+import com.oracle.graal.python.builtins.objects.deque.DequeRevIterBuiltins;
import com.oracle.graal.python.builtins.objects.dict.DefaultDictBuiltins;
import com.oracle.graal.python.builtins.objects.dict.DictBuiltins;
import com.oracle.graal.python.builtins.objects.dict.DictReprBuiltin;
@@ -248,6 +246,7 @@
import com.oracle.graal.python.builtins.objects.dict.PDict;
import com.oracle.graal.python.builtins.objects.ellipsis.EllipsisBuiltins;
import com.oracle.graal.python.builtins.objects.enumerate.EnumerateBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.AttributeErrorBuiltins;
import com.oracle.graal.python.builtins.objects.exception.BaseExceptionBuiltins;
import com.oracle.graal.python.builtins.objects.exception.BaseExceptionGroupBuiltins;
import com.oracle.graal.python.builtins.objects.exception.ImportErrorBuiltins;
@@ -264,6 +263,9 @@
import com.oracle.graal.python.builtins.objects.floats.PFloat;
import com.oracle.graal.python.builtins.objects.foreign.ForeignAbstractClassBuiltins;
import com.oracle.graal.python.builtins.objects.foreign.ForeignBooleanBuiltins;
+import com.oracle.graal.python.builtins.objects.foreign.ForeignExecutableBuiltins;
+import com.oracle.graal.python.builtins.objects.foreign.ForeignInstantiableBuiltins;
+import com.oracle.graal.python.builtins.objects.foreign.ForeignIterableBuiltins;
import com.oracle.graal.python.builtins.objects.foreign.ForeignNumberBuiltins;
import com.oracle.graal.python.builtins.objects.foreign.ForeignObjectBuiltins;
import com.oracle.graal.python.builtins.objects.frame.FrameBuiltins;
@@ -283,11 +285,12 @@
import com.oracle.graal.python.builtins.objects.ints.IntBuiltins;
import com.oracle.graal.python.builtins.objects.ints.PInt;
import com.oracle.graal.python.builtins.objects.iterator.IteratorBuiltins;
-import com.oracle.graal.python.builtins.objects.iterator.PZipBuiltins;
import com.oracle.graal.python.builtins.objects.iterator.SentinelIteratorBuiltins;
+import com.oracle.graal.python.builtins.objects.iterator.ZipBuiltins;
import com.oracle.graal.python.builtins.objects.itertools.AccumulateBuiltins;
import com.oracle.graal.python.builtins.objects.itertools.ChainBuiltins;
import com.oracle.graal.python.builtins.objects.itertools.CombinationsBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.CombinationsWithReplacementBuiltins;
import com.oracle.graal.python.builtins.objects.itertools.CompressBuiltins;
import com.oracle.graal.python.builtins.objects.itertools.CountBuiltins;
import com.oracle.graal.python.builtins.objects.itertools.CycleBuiltins;
@@ -315,6 +318,7 @@
import com.oracle.graal.python.builtins.objects.method.BuiltinClassmethodBuiltins;
import com.oracle.graal.python.builtins.objects.method.BuiltinFunctionOrMethodBuiltins;
import com.oracle.graal.python.builtins.objects.method.ClassmethodBuiltins;
+import com.oracle.graal.python.builtins.objects.method.ClassmethodCommonBuiltins;
import com.oracle.graal.python.builtins.objects.method.DecoratedMethodBuiltins;
import com.oracle.graal.python.builtins.objects.method.InstancemethodBuiltins;
import com.oracle.graal.python.builtins.objects.method.MethodBuiltins;
@@ -352,17 +356,18 @@
import com.oracle.graal.python.builtins.objects.struct.StructBuiltins;
import com.oracle.graal.python.builtins.objects.struct.StructUnpackIteratorBuiltins;
import com.oracle.graal.python.builtins.objects.superobject.SuperBuiltins;
-import com.oracle.graal.python.builtins.objects.thread.LockBuiltins;
+import com.oracle.graal.python.builtins.objects.thread.CommonLockBuiltins;
+import com.oracle.graal.python.builtins.objects.thread.LockTypeBuiltins;
import com.oracle.graal.python.builtins.objects.thread.RLockBuiltins;
-import com.oracle.graal.python.builtins.objects.thread.ThreadBuiltins;
import com.oracle.graal.python.builtins.objects.thread.ThreadLocalBuiltins;
import com.oracle.graal.python.builtins.objects.tokenize.TokenizerIterBuiltins;
import com.oracle.graal.python.builtins.objects.traceback.TracebackBuiltins;
+import com.oracle.graal.python.builtins.objects.tuple.InstantiableStructSequenceBuiltins;
+import com.oracle.graal.python.builtins.objects.tuple.StructSequenceBuiltins;
import com.oracle.graal.python.builtins.objects.tuple.TupleBuiltins;
import com.oracle.graal.python.builtins.objects.tuple.TupleGetterBuiltins;
import com.oracle.graal.python.builtins.objects.type.PythonBuiltinClass;
import com.oracle.graal.python.builtins.objects.type.PythonManagedClass;
-import com.oracle.graal.python.builtins.objects.type.SpecialMethodSlot;
import com.oracle.graal.python.builtins.objects.type.TpSlots;
import com.oracle.graal.python.builtins.objects.type.TypeBuiltins;
import com.oracle.graal.python.builtins.objects.types.GenericAliasBuiltins;
@@ -373,7 +378,7 @@
import com.oracle.graal.python.nodes.BuiltinNames;
import com.oracle.graal.python.nodes.attributes.ReadAttributeFromPythonObjectNode;
import com.oracle.graal.python.nodes.attributes.WriteAttributeToPythonObjectNode;
-import com.oracle.graal.python.nodes.call.GenericInvokeNode;
+import com.oracle.graal.python.nodes.call.CallDispatchers;
import com.oracle.graal.python.nodes.object.GetForeignObjectClassNode;
import com.oracle.graal.python.nodes.statement.AbstractImportNode;
import com.oracle.graal.python.pegparser.FutureFeature;
@@ -384,7 +389,7 @@
import com.oracle.graal.python.runtime.exception.ExceptionUtils;
import com.oracle.graal.python.runtime.exception.PException;
import com.oracle.graal.python.runtime.interop.PythonMapScope;
-import com.oracle.graal.python.runtime.object.PythonObjectSlowPathFactory;
+import com.oracle.graal.python.runtime.object.PFactory;
import com.oracle.graal.python.runtime.sequence.storage.SequenceStorage;
import com.oracle.graal.python.util.Supplier;
import com.oracle.truffle.api.CallTarget;
@@ -393,9 +398,12 @@
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.RootCallTarget;
import com.oracle.truffle.api.TruffleFile;
+import com.oracle.truffle.api.TruffleLanguage;
import com.oracle.truffle.api.TruffleLanguage.Env;
import com.oracle.truffle.api.TruffleLogger;
+import com.oracle.truffle.api.TruffleOptions;
import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.object.Shape;
import com.oracle.truffle.api.source.Source;
import com.oracle.truffle.api.strings.TruffleString;
@@ -416,40 +424,32 @@ public abstract class Python3Core {
private static TruffleString[] initializeCoreFiles() {
// Order matters!
- List coreFiles = new ArrayList<>(Arrays.asList(
- toTruffleStringUncached("__graalpython__"),
- toTruffleStringUncached("_weakref"),
- toTruffleStringUncached("unicodedata"),
- toTruffleStringUncached("_sre"),
- toTruffleStringUncached("_sysconfig"),
- toTruffleStringUncached("java"),
- toTruffleStringUncached("pip_hook")));
- // add service loader defined python file extensions
- if (!ImageInfo.inImageRuntimeCode()) {
- ServiceLoader providers = ServiceLoader.load(PythonBuiltins.class, Python3Core.class.getClassLoader());
- PythonOS currentOs = PythonOS.getPythonOS();
- for (PythonBuiltins builtin : providers) {
- CoreFunctions annotation = builtin.getClass().getAnnotation(CoreFunctions.class);
- if (!annotation.pythonFile().isEmpty() &&
- (annotation.os() == PythonOS.PLATFORM_ANY || annotation.os() == currentOs)) {
- coreFiles.add(toTruffleStringUncached(annotation.pythonFile()));
- }
- }
+ List coreFiles = List.of(
+ T___GRAALPYTHON__,
+ T__WEAKREF,
+ T_UNICODEDATA,
+ T__SRE,
+ T__SYSCONFIG,
+ T_JAVA,
+ toTruffleStringUncached("pip_hook"));
+ if (PythonOS.getPythonOS() == PythonOS.PLATFORM_WIN32) {
+ coreFiles = new ArrayList<>(coreFiles);
+ coreFiles.add(toTruffleStringUncached("_nt"));
}
- coreFiles.removeAll(Arrays.asList(new TruffleString[]{null}));
- return coreFiles.toArray(new TruffleString[coreFiles.size()]);
+
+ return coreFiles.toArray(new TruffleString[0]);
}
private final PythonBuiltins[] builtins;
- private static final boolean hasProfilerTool;
+ public static final boolean HAS_PROFILER_TOOL;
static {
Class> c = null;
try {
c = Class.forName("com.oracle.truffle.tools.profiler.CPUSampler");
} catch (LinkageError | ClassNotFoundException e) {
}
- hasProfilerTool = c != null;
+ HAS_PROFILER_TOOL = c != null;
c = null;
}
@@ -469,12 +469,13 @@ private static void filterBuiltins(List builtins) {
builtins.removeAll(toRemove);
}
- private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed, boolean socketIOAllowed) {
- List builtins = new ArrayList<>(Arrays.asList(new BuiltinConstructors(),
+ private static PythonBuiltins[] initializeBuiltins(TruffleLanguage.Env env) {
+ List builtins = new ArrayList<>(Arrays.asList(
new AbcModuleBuiltins(),
new BuiltinFunctions(),
new DecoratedMethodBuiltins(),
new ClassmethodBuiltins(),
+ new ClassmethodCommonBuiltins(),
new StaticmethodBuiltins(),
new InstancemethodBuiltins(),
new SimpleNamespaceBuiltins(),
@@ -504,13 +505,15 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
new RangeBuiltins(),
new SliceBuiltins(),
new TupleBuiltins(),
+ new StructSequenceBuiltins(),
+ new InstantiableStructSequenceBuiltins(),
new StringBuiltins(),
new BaseSetBuiltins(),
new SetBuiltins(),
new FrozenSetBuiltins(),
new IteratorBuiltins(),
new ReversedBuiltins(),
- new PZipBuiltins(),
+ new ZipBuiltins(),
new EnumerateBuiltins(),
new MapBuiltins(),
new NotImplementedBuiltins(),
@@ -549,6 +552,7 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
new CryptModuleBuiltins(),
new ScandirIteratorBuiltins(),
new DirEntryBuiltins(),
+ new StatResultBuiltins(),
new ImpModuleBuiltins(),
new ArrayModuleBuiltins(),
new ArrayBuiltins(),
@@ -572,6 +576,7 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
new GenericAliasIteratorBuiltins(),
new com.oracle.graal.python.builtins.objects.types.UnionTypeBuiltins(),
// exceptions
+ new AttributeErrorBuiltins(),
new SystemExitBuiltins(),
new ImportErrorBuiltins(),
new StopIterationBuiltins(),
@@ -631,7 +636,9 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
new CodecsModuleBuiltins(),
new CodecsTruffleModuleBuiltins(),
new DequeBuiltins(),
+ new DequeIterCommonBuiltins(),
new DequeIterBuiltins(),
+ new DequeRevIterBuiltins(),
new OrderedDictBuiltins(),
new OrderedDictKeysBuiltins(),
new OrderedDictValuesBuiltins(),
@@ -646,9 +653,9 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
new JSONModuleBuiltins(),
new SREModuleBuiltins(),
new AstModuleBuiltins(),
- PythonImageBuildOptions.WITHOUT_NATIVE_POSIX && (PythonImageBuildOptions.WITHOUT_JAVA_INET || !socketIOAllowed) ? null : new SelectModuleBuiltins(),
- PythonImageBuildOptions.WITHOUT_NATIVE_POSIX && (PythonImageBuildOptions.WITHOUT_JAVA_INET || !socketIOAllowed) ? null : new SocketModuleBuiltins(),
- PythonImageBuildOptions.WITHOUT_NATIVE_POSIX && (PythonImageBuildOptions.WITHOUT_JAVA_INET || !socketIOAllowed) ? null : new SocketBuiltins(),
+ PythonImageBuildOptions.WITHOUT_NATIVE_POSIX && (PythonImageBuildOptions.WITHOUT_JAVA_INET || !env.isSocketIOAllowed()) ? null : new SelectModuleBuiltins(),
+ PythonImageBuildOptions.WITHOUT_NATIVE_POSIX && (PythonImageBuildOptions.WITHOUT_JAVA_INET || !env.isSocketIOAllowed()) ? null : new SocketModuleBuiltins(),
+ PythonImageBuildOptions.WITHOUT_NATIVE_POSIX && (PythonImageBuildOptions.WITHOUT_JAVA_INET || !env.isSocketIOAllowed()) ? null : new SocketBuiltins(),
PythonImageBuildOptions.WITHOUT_PLATFORM_ACCESS ? null : new SignalModuleBuiltins(),
new TracebackBuiltins(),
new GcModuleBuiltins(),
@@ -681,12 +688,12 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
PythonImageBuildOptions.WITHOUT_DIGEST ? null : new HashObjectBuiltins(),
PythonImageBuildOptions.WITHOUT_DIGEST ? null : new ShakeDigestObjectBuiltins(),
PythonImageBuildOptions.WITHOUT_DIGEST ? null : new Blake2bObjectBuiltins(),
- PythonImageBuildOptions.WITHOUT_DIGEST ? null : new Blake2sObjectBuiltins(),
PythonImageBuildOptions.WITHOUT_DIGEST ? null : new HashlibModuleBuiltins(),
// itertools
new AccumulateBuiltins(),
new CombinationsBuiltins(),
+ new CombinationsWithReplacementBuiltins(),
new CompressBuiltins(),
new DropwhileBuiltins(),
new ChainBuiltins(),
@@ -717,9 +724,9 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
new SimpleQueueBuiltins(),
new QueueModuleBuiltins(),
new ThreadModuleBuiltins(),
- new ThreadBuiltins(),
new ThreadLocalBuiltins(),
- new LockBuiltins(),
+ new CommonLockBuiltins(),
+ new LockTypeBuiltins(),
new RLockBuiltins(),
new PwdModuleBuiltins(),
new ResourceModuleBuiltins(),
@@ -780,11 +787,6 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
new PyCPointerBuiltins(),
new CDataBuiltins(),
- // _hpy_universal, _hpy_debug, and _hpy_trace
- new GraalHPyUniversalModuleBuiltins(),
- new GraalHPyDebugModuleBuiltins(),
- new GraalHPyTraceModuleBuiltins(),
-
new StructModuleBuiltins(),
new StructBuiltins(),
new StructUnpackIteratorBuiltins(),
@@ -798,19 +800,15 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
// _tokenizer
new TokenizeModuleBuiltins(),
new TokenizerIterBuiltins()));
- if (hasProfilerTool) {
+ if (HAS_PROFILER_TOOL) {
builtins.add(new LsprofModuleBuiltins());
- builtins.add(LsprofModuleBuiltins.newProfilerBuiltins());
+ builtins.add(new ProfilerBuiltins());
}
- if (!PythonImageBuildOptions.WITHOUT_COMPRESSION_LIBRARIES && (nativeAccessAllowed || ImageInfo.inImageBuildtimeCode())) {
+ if (!PythonImageBuildOptions.WITHOUT_COMPRESSION_LIBRARIES && (env.isNativeAccessAllowed() || env.isPreInitialization())) {
builtins.add(new BZ2CompressorBuiltins());
builtins.add(new BZ2DecompressorBuiltins());
builtins.add(new BZ2ModuleBuiltins());
}
- ServiceLoader providers = ServiceLoader.load(PythonBuiltins.class, Python3Core.class.getClassLoader());
- for (PythonBuiltins builtin : providers) {
- builtins.add(builtin);
- }
filterBuiltins(builtins);
return builtins.toArray(new PythonBuiltins[builtins.size()]);
}
@@ -842,17 +840,16 @@ private static PythonBuiltins[] initializeBuiltins(boolean nativeAccessAllowed,
private volatile boolean initialized;
private final PythonLanguage language;
- @CompilationFinal private PythonObjectSlowPathFactory objectFactory;
- public Python3Core(PythonLanguage language, boolean isNativeSupportAllowed, boolean socketIOAllowed) {
+ public Python3Core(PythonLanguage language, TruffleLanguage.Env env) {
this.language = language;
- this.builtins = initializeBuiltins(isNativeSupportAllowed, socketIOAllowed);
+ this.builtins = initializeBuiltins(env);
this.coreFiles = initializeCoreFiles();
}
@CompilerDirectives.ValueType
public static class SysModuleState {
- private int recursionLimit = ImageInfo.inImageCode() ? NATIVE_REC_LIM : REC_LIM;
+ private int recursionLimit = TruffleOptions.AOT ? NATIVE_REC_LIM : REC_LIM;
private int checkInterval = 100;
private double switchInterval = 0.005;
@@ -906,11 +903,12 @@ public final PythonLanguage getLanguage() {
* multi-context mode. Can be null.
*/
public final PythonLanguage getLanguage(Node node) {
- if (CompilerDirectives.inCompiledCode() && node != null && CompilerDirectives.isPartialEvaluationConstant(node) && node.getRootNode() != null) {
- // This will make it PE-constant in multi-context mode
- return PythonLanguage.get(node);
+ // The condition is always true in the interpreter
+ if (CompilerDirectives.isPartialEvaluationConstant(language)) {
+ return language;
}
- return language;
+ // This will make it PE-constant in multi-context mode
+ return PythonLanguage.get(node);
}
/**
@@ -924,19 +922,16 @@ public final boolean isCoreInitialized() {
* Load the core library and prepare all builtin classes and modules.
*/
public final void initialize(PythonContext context) {
- objectFactory = new PythonObjectSlowPathFactory(context.getAllocationReporter(), context.getLanguage());
initializeJavaCore();
initializeImportlib();
context.applyModuleOptions();
initializePython3Core(context.getCoreHomeOrFail());
- assert SpecialMethodSlot.checkSlotOverrides(this);
initialized = true;
}
private void initializeJavaCore() {
initializeTypes();
populateBuiltins();
- SpecialMethodSlot.initializeBuiltinsSpecialMethodSlots(this);
publishBuiltinModules();
builtinsModule = builtinModules.get(BuiltinNames.T_BUILTINS);
}
@@ -979,11 +974,6 @@ private void initializeImportlib() {
importFunc = (PFunction) __import__;
importlib = bootstrap;
- PythonBuiltinClass moduleType = lookupType(PythonBuiltinClassType.PythonModule);
- writeNode.execute(moduleType, T___REPR__, readNode.execute(bootstrap, toTruffleStringUncached("_module_repr")));
-
- SpecialMethodSlot.reinitializeSpecialMethodSlots(moduleType, getLanguage());
-
// see CPython's init_importlib_external
callNode.execute(null, null, bootstrap, toTruffleStringUncached("_install_external_importers"));
if (!PythonImageBuildOptions.WITHOUT_COMPRESSION_LIBRARIES) {
@@ -1040,10 +1030,10 @@ private void initializePython3Core(TruffleString coreHome) {
/**
* Run post-initialization code that needs a fully working Python environment. This will be run
* eagerly when the context is initialized on the JVM or a new context is created on SVM, but is
- * omitted when the native image is generated.
+ * omitted when creating a pre-initialized context.
*/
- public final void postInitialize() {
- if (!ImageInfo.inImageBuildtimeCode() || ImageInfo.inImageRuntimeCode()) {
+ public final void postInitialize(Env env) {
+ if (!env.isPreInitialization()) {
initialized = false;
for (PythonBuiltins builtin : builtins) {
@@ -1060,9 +1050,9 @@ public final void postInitialize() {
* fallback to another _bz2 implementation (e.g. LLVM or maybe some Java lib). This
* needs to be done here and cannot be done in 'initializeBuiltins' because then we
* would never include the intrinsified _bz2 module in the native image since native
- * access is never allowed during native image build time.
+ * access is never allowed during context pre-initialization.
*/
- if (!PythonImageBuildOptions.WITHOUT_COMPRESSION_LIBRARIES && ImageInfo.inImageCode() && !getContext().isNativeAccessAllowed()) {
+ if (!PythonImageBuildOptions.WITHOUT_COMPRESSION_LIBRARIES && TruffleOptions.AOT && !getContext().isNativeAccessAllowed()) {
removeBuiltinModule(BuiltinNames.T_BZ2);
}
@@ -1083,9 +1073,6 @@ public void run() {
}
}
- // import polyglot decorators and special interop predefined behavior
- loadFile(toTruffleStringUncached("_polyglot"), getContext().getCoreHomeOrFail());
-
initialized = true;
}
}
@@ -1219,9 +1206,11 @@ private void initializeTypes() {
}
}
// now initialize well-known objects
- pyTrue = factory().createInt(PythonBuiltinClassType.Boolean, BigInteger.ONE);
- pyFalse = factory().createInt(PythonBuiltinClassType.Boolean, BigInteger.ZERO);
- pyNaN = factory().createFloat(Double.NaN);
+ PythonBuiltinClassType booleanType = PythonBuiltinClassType.Boolean;
+ Shape booleanShape = booleanType.getInstanceShape(getLanguage());
+ pyTrue = PFactory.createInt(getLanguage(), booleanType, booleanShape, BigInteger.ONE);
+ pyFalse = PFactory.createInt(getLanguage(), booleanType, booleanShape, BigInteger.ZERO);
+ pyNaN = PFactory.createFloat(getLanguage(), Double.NaN);
}
private void populateBuiltins() {
@@ -1246,11 +1235,12 @@ private void populateBuiltins() {
}
}
- Map> wrapped = new HashMap<>();
for (PythonBuiltinClassType klass : PythonBuiltinClassType.VALUES) {
- wrapped.clear();
- TpSlots.addOperatorsToBuiltin(wrapped, this, klass);
- PythonBuiltins.addFunctionsToModuleObject(wrapped, lookupType(klass), factory());
+ PythonBuiltinClass pbc = lookupType(klass);
+ TpSlots.addOperatorsToBuiltin(this, klass, pbc);
+ if (klass.getDoc() != null && pbc.getAttribute(T___DOC__) instanceof PNone) {
+ pbc.setAttribute(T___DOC__, klass.getDoc());
+ }
}
// core machinery
@@ -1272,7 +1262,7 @@ private void addBuiltinModule(TruffleString name, PythonModule module) {
private PythonModule createModule(TruffleString name, PythonBuiltins moduleBuiltins) {
PythonModule mod = builtinModules.get(name);
if (mod == null) {
- mod = factory().createPythonModule(name);
+ mod = PFactory.createPythonModule(getLanguage(), name);
if (moduleBuiltins != null) {
mod.setBuiltins(moduleBuiltins);
}
@@ -1283,7 +1273,7 @@ private PythonModule createModule(TruffleString name, PythonBuiltins moduleBuilt
private void addBuiltinsTo(PythonObject obj, PythonBuiltins builtinsForObj) {
builtinsForObj.addConstantsToModuleObject(obj);
- builtinsForObj.addFunctionsToModuleObject(obj, objectFactory);
+ builtinsForObj.addFunctionsToModuleObject(obj, getLanguage());
}
@TruffleBoundary
@@ -1309,7 +1299,7 @@ private void loadFile(TruffleString s, TruffleString prefix) {
PythonModule mod = lookupBuiltinModule(s);
if (mod == null) {
// use an anonymous module for the side-effects
- mod = factory().createPythonModule(T___ANONYMOUS__);
+ mod = PFactory.createPythonModule(getLanguage(), T___ANONYMOUS__);
}
loadFile(s, prefix, mod);
}
@@ -1319,16 +1309,14 @@ private void loadFile(TruffleString s, TruffleString prefix, PythonModule mod) {
LOGGER.log(Level.FINE, () -> "import '" + s + "' # ");
return;
}
+
+ LOGGER.log(Level.FINE, () -> "import '" + s + "'");
Supplier getCode = () -> {
Source source = getInternalSource(s, prefix);
return getLanguage().parse(getContext(), source, InputType.FILE, false, 0, false, null, EnumSet.noneOf(FutureFeature.class));
};
RootCallTarget callTarget = (RootCallTarget) getLanguage().cacheCode(s, getCode);
- GenericInvokeNode.getUncached().execute(callTarget, PArguments.withGlobals(mod));
- }
-
- public final PythonObjectSlowPathFactory factory() {
- return objectFactory;
+ CallDispatchers.SimpleIndirectInvokeNode.executeUncached(callTarget, PArguments.withGlobals(mod));
}
public final PInt getTrue() {
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltinClassType.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltinClassType.java
index 8d586cc758..0b6b90a9b1 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltinClassType.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltinClassType.java
@@ -25,50 +25,6 @@
*/
package com.oracle.graal.python.builtins;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.ARRAY_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.ASYNC_GENERATOR_ASEND_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.ASYNC_GENERATOR_ATHROW_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.ASYNC_GENERATOR_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.BOOLEAN_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.BYTES_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.BYTE_ARRAY_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.COMPLEX_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.CONTEXT_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.COROUTINE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.DEFAULTDICT_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.DEFAULT_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.DEQUE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.DICTITEMSVIEW_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.DICTKEYSVIEW_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.DICTVALUESVIEW_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.DICT_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.FLOAT_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.FOREIGNNUMBER_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.FROZENSET_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.GENERATOR_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.GENERIC_ALIAS_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.INT_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.LIST_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.MAPPINGPROXY_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.MEMORYVIEW_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.MMAP_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.NONE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.PYCARRAYTYPE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.PYCARRAY_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.PYCFUNCPTRTYPE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.PYCFUNCPTR_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.PYCPOINTERTYPE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.PYCPOINTER_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.PYCSIMPLETYPE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.PYCSTRUCTTYPE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.RANGE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.SET_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.SIMPLECDATA_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.STRING_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.TUPLE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.TYPE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.UNIONTYPE_M_FLAGS;
-import static com.oracle.graal.python.builtins.objects.type.MethodsFlags.UNION_TYPE_M_FLAGS;
import static com.oracle.graal.python.nodes.BuiltinNames.J_BUILTINS;
import static com.oracle.graal.python.nodes.BuiltinNames.J_DEFAULTDICT;
import static com.oracle.graal.python.nodes.BuiltinNames.J_DEQUE;
@@ -111,69 +67,207 @@
import java.util.stream.Collectors;
import com.oracle.graal.python.PythonLanguage;
+import com.oracle.graal.python.annotations.HashNotImplemented;
import com.oracle.graal.python.annotations.Slot;
+import com.oracle.graal.python.builtins.modules.StatResultBuiltins;
import com.oracle.graal.python.builtins.modules.WeakRefModuleBuiltins;
+import com.oracle.graal.python.builtins.modules.ast.AstBuiltins;
+import com.oracle.graal.python.builtins.modules.bz2.BZ2CompressorBuiltins;
+import com.oracle.graal.python.builtins.modules.bz2.BZ2DecompressorBuiltins;
+import com.oracle.graal.python.builtins.modules.cjkcodecs.MultibyteIncrementalDecoderBuiltins;
+import com.oracle.graal.python.builtins.modules.cjkcodecs.MultibyteIncrementalEncoderBuiltins;
+import com.oracle.graal.python.builtins.modules.cjkcodecs.MultibyteStreamReaderBuiltins;
+import com.oracle.graal.python.builtins.modules.cjkcodecs.MultibyteStreamWriterBuiltins;
+import com.oracle.graal.python.builtins.modules.csv.CSVDialectBuiltins;
+import com.oracle.graal.python.builtins.modules.csv.CSVReaderBuiltins;
+import com.oracle.graal.python.builtins.modules.ctypes.CArgObjectBuiltins;
+import com.oracle.graal.python.builtins.modules.ctypes.CDataBuiltins;
import com.oracle.graal.python.builtins.modules.ctypes.CDataTypeSequenceBuiltins;
import com.oracle.graal.python.builtins.modules.ctypes.CFieldBuiltins;
import com.oracle.graal.python.builtins.modules.ctypes.PyCArrayBuiltins;
+import com.oracle.graal.python.builtins.modules.ctypes.PyCArrayTypeBuiltins;
import com.oracle.graal.python.builtins.modules.ctypes.PyCFuncPtrBuiltins;
+import com.oracle.graal.python.builtins.modules.ctypes.PyCFuncPtrTypeBuiltins;
import com.oracle.graal.python.builtins.modules.ctypes.PyCPointerBuiltins;
+import com.oracle.graal.python.builtins.modules.ctypes.PyCPointerTypeBuiltins;
+import com.oracle.graal.python.builtins.modules.ctypes.PyCSimpleTypeBuiltins;
import com.oracle.graal.python.builtins.modules.ctypes.PyCStructTypeBuiltins;
import com.oracle.graal.python.builtins.modules.ctypes.SimpleCDataBuiltins;
import com.oracle.graal.python.builtins.modules.ctypes.StgDictBuiltins;
+import com.oracle.graal.python.builtins.modules.ctypes.StructUnionTypeBuiltins;
+import com.oracle.graal.python.builtins.modules.ctypes.StructureBuiltins;
+import com.oracle.graal.python.builtins.modules.functools.KeyWrapperBuiltins;
import com.oracle.graal.python.builtins.modules.functools.LruCacheWrapperBuiltins;
+import com.oracle.graal.python.builtins.modules.functools.PartialBuiltins;
+import com.oracle.graal.python.builtins.modules.hashlib.Blake2bObjectBuiltins;
+import com.oracle.graal.python.builtins.modules.hashlib.HashObjectBuiltins;
+import com.oracle.graal.python.builtins.modules.hashlib.Sha3Builtins;
+import com.oracle.graal.python.builtins.modules.io.BufferedIOMixinBuiltins;
+import com.oracle.graal.python.builtins.modules.io.BufferedRWPairBuiltins;
+import com.oracle.graal.python.builtins.modules.io.BufferedRandomBuiltins;
+import com.oracle.graal.python.builtins.modules.io.BufferedReaderBuiltins;
+import com.oracle.graal.python.builtins.modules.io.BufferedReaderMixinBuiltins;
+import com.oracle.graal.python.builtins.modules.io.BufferedWriterBuiltins;
+import com.oracle.graal.python.builtins.modules.io.BytesIOBuiltins;
+import com.oracle.graal.python.builtins.modules.io.FileIOBuiltins;
+import com.oracle.graal.python.builtins.modules.io.IOBaseBuiltins;
+import com.oracle.graal.python.builtins.modules.io.IncrementalNewlineDecoderBuiltins;
+import com.oracle.graal.python.builtins.modules.io.StringIOBuiltins;
+import com.oracle.graal.python.builtins.modules.io.TextIOWrapperBuiltins;
+import com.oracle.graal.python.builtins.modules.json.JSONEncoderBuiltins;
+import com.oracle.graal.python.builtins.modules.json.JSONScannerBuiltins;
+import com.oracle.graal.python.builtins.modules.lsprof.ProfilerBuiltins;
+import com.oracle.graal.python.builtins.modules.lzma.LZMACompressorBuiltins;
+import com.oracle.graal.python.builtins.modules.lzma.LZMADecompressorBuiltins;
+import com.oracle.graal.python.builtins.modules.multiprocessing.GraalPySemLockBuiltins;
+import com.oracle.graal.python.builtins.modules.multiprocessing.SemLockBuiltins;
+import com.oracle.graal.python.builtins.modules.pickle.PickleBufferBuiltins;
+import com.oracle.graal.python.builtins.modules.pickle.PicklerBuiltins;
+import com.oracle.graal.python.builtins.modules.pickle.PicklerMemoProxyBuiltins;
+import com.oracle.graal.python.builtins.modules.pickle.UnpicklerBuiltins;
+import com.oracle.graal.python.builtins.modules.pickle.UnpicklerMemoProxyBuiltins;
import com.oracle.graal.python.builtins.objects.NoneBuiltins;
+import com.oracle.graal.python.builtins.objects.NotImplementedBuiltins;
import com.oracle.graal.python.builtins.objects.array.ArrayBuiltins;
+import com.oracle.graal.python.builtins.objects.asyncio.ANextAwaitableBuiltins;
+import com.oracle.graal.python.builtins.objects.asyncio.AsyncGenSendBuiltins;
+import com.oracle.graal.python.builtins.objects.asyncio.AsyncGenThrowBuiltins;
+import com.oracle.graal.python.builtins.objects.asyncio.AsyncGeneratorBuiltins;
+import com.oracle.graal.python.builtins.objects.asyncio.CoroutineWrapperBuiltins;
import com.oracle.graal.python.builtins.objects.bool.BoolBuiltins;
import com.oracle.graal.python.builtins.objects.bytes.ByteArrayBuiltins;
import com.oracle.graal.python.builtins.objects.bytes.BytesBuiltins;
import com.oracle.graal.python.builtins.objects.bytes.BytesCommonBuiltins;
+import com.oracle.graal.python.builtins.objects.cell.CellBuiltins;
+import com.oracle.graal.python.builtins.objects.code.CodeBuiltins;
import com.oracle.graal.python.builtins.objects.complex.ComplexBuiltins;
import com.oracle.graal.python.builtins.objects.contextvars.ContextBuiltins;
+import com.oracle.graal.python.builtins.objects.contextvars.ContextIteratorBuiltins;
+import com.oracle.graal.python.builtins.objects.contextvars.ContextVarBuiltins;
+import com.oracle.graal.python.builtins.objects.contextvars.TokenBuiltins;
import com.oracle.graal.python.builtins.objects.deque.DequeBuiltins;
+import com.oracle.graal.python.builtins.objects.deque.DequeIterBuiltins;
+import com.oracle.graal.python.builtins.objects.deque.DequeIterCommonBuiltins;
+import com.oracle.graal.python.builtins.objects.deque.DequeRevIterBuiltins;
import com.oracle.graal.python.builtins.objects.dict.DefaultDictBuiltins;
import com.oracle.graal.python.builtins.objects.dict.DictBuiltins;
+import com.oracle.graal.python.builtins.objects.dict.DictReprBuiltin;
import com.oracle.graal.python.builtins.objects.dict.DictValuesBuiltins;
import com.oracle.graal.python.builtins.objects.dict.DictViewBuiltins;
+import com.oracle.graal.python.builtins.objects.ellipsis.EllipsisBuiltins;
+import com.oracle.graal.python.builtins.objects.enumerate.EnumerateBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.AttributeErrorBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.BaseExceptionBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.BaseExceptionGroupBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.ImportErrorBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.KeyErrorBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.OsErrorBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.StopIterationBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.SyntaxErrorBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.SystemExitBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.UnicodeDecodeErrorBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.UnicodeEncodeErrorBuiltins;
+import com.oracle.graal.python.builtins.objects.exception.UnicodeTranslateErrorBuiltins;
import com.oracle.graal.python.builtins.objects.floats.FloatBuiltins;
import com.oracle.graal.python.builtins.objects.foreign.ForeignBooleanBuiltins;
+import com.oracle.graal.python.builtins.objects.foreign.ForeignExecutableBuiltins;
+import com.oracle.graal.python.builtins.objects.foreign.ForeignInstantiableBuiltins;
+import com.oracle.graal.python.builtins.objects.foreign.ForeignIterableBuiltins;
import com.oracle.graal.python.builtins.objects.foreign.ForeignNumberBuiltins;
import com.oracle.graal.python.builtins.objects.foreign.ForeignObjectBuiltins;
-import com.oracle.graal.python.builtins.objects.function.BuiltinMethodDescriptor;
+import com.oracle.graal.python.builtins.objects.frame.FrameBuiltins;
+import com.oracle.graal.python.builtins.objects.function.AbstractFunctionBuiltins;
import com.oracle.graal.python.builtins.objects.function.FunctionBuiltins;
import com.oracle.graal.python.builtins.objects.function.MethodDescriptorBuiltins;
import com.oracle.graal.python.builtins.objects.function.WrapperDescriptorBuiltins;
+import com.oracle.graal.python.builtins.objects.generator.CoroutineBuiltins;
+import com.oracle.graal.python.builtins.objects.generator.GeneratorBuiltins;
import com.oracle.graal.python.builtins.objects.getsetdescriptor.GetSetDescriptorTypeBuiltins;
import com.oracle.graal.python.builtins.objects.getsetdescriptor.MemberDescriptorBuiltins;
import com.oracle.graal.python.builtins.objects.ints.IntBuiltins;
+import com.oracle.graal.python.builtins.objects.iterator.IteratorBuiltins;
+import com.oracle.graal.python.builtins.objects.iterator.SentinelIteratorBuiltins;
+import com.oracle.graal.python.builtins.objects.iterator.ZipBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.AccumulateBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.ChainBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.CombinationsBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.CombinationsWithReplacementBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.CompressBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.CountBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.CycleBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.DropwhileBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.FilterfalseBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.GroupByBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.GrouperBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.IsliceBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.PairwiseBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.PermutationsBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.ProductBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.RepeatBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.StarmapBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.TakewhileBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.TeeBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.TeeDataObjectBuiltins;
+import com.oracle.graal.python.builtins.objects.itertools.ZipLongestBuiltins;
import com.oracle.graal.python.builtins.objects.list.ListBuiltins;
+import com.oracle.graal.python.builtins.objects.map.MapBuiltins;
import com.oracle.graal.python.builtins.objects.mappingproxy.MappingproxyBuiltins;
import com.oracle.graal.python.builtins.objects.memoryview.MemoryViewBuiltins;
+import com.oracle.graal.python.builtins.objects.method.AbstractMethodBuiltins;
+import com.oracle.graal.python.builtins.objects.method.BuiltinClassmethodBuiltins;
+import com.oracle.graal.python.builtins.objects.method.BuiltinFunctionOrMethodBuiltins;
import com.oracle.graal.python.builtins.objects.method.ClassmethodBuiltins;
+import com.oracle.graal.python.builtins.objects.method.ClassmethodCommonBuiltins;
import com.oracle.graal.python.builtins.objects.method.InstancemethodBuiltins;
import com.oracle.graal.python.builtins.objects.method.MethodBuiltins;
+import com.oracle.graal.python.builtins.objects.method.MethodWrapperBuiltins;
import com.oracle.graal.python.builtins.objects.method.StaticmethodBuiltins;
import com.oracle.graal.python.builtins.objects.mmap.MMapBuiltins;
import com.oracle.graal.python.builtins.objects.module.ModuleBuiltins;
+import com.oracle.graal.python.builtins.objects.namespace.SimpleNamespaceBuiltins;
import com.oracle.graal.python.builtins.objects.object.ObjectBuiltins;
import com.oracle.graal.python.builtins.objects.ordereddict.OrderedDictBuiltins;
+import com.oracle.graal.python.builtins.objects.ordereddict.OrderedDictItemsBuiltins;
+import com.oracle.graal.python.builtins.objects.ordereddict.OrderedDictIteratorBuiltins;
+import com.oracle.graal.python.builtins.objects.ordereddict.OrderedDictKeysBuiltins;
+import com.oracle.graal.python.builtins.objects.ordereddict.OrderedDictValuesBuiltins;
+import com.oracle.graal.python.builtins.objects.posix.DirEntryBuiltins;
+import com.oracle.graal.python.builtins.objects.posix.ScandirIteratorBuiltins;
import com.oracle.graal.python.builtins.objects.property.PropertyBuiltins;
+import com.oracle.graal.python.builtins.objects.queue.SimpleQueueBuiltins;
+import com.oracle.graal.python.builtins.objects.random.RandomBuiltins;
import com.oracle.graal.python.builtins.objects.range.RangeBuiltins;
+import com.oracle.graal.python.builtins.objects.referencetype.ReferenceTypeBuiltins;
+import com.oracle.graal.python.builtins.objects.reversed.ReversedBuiltins;
import com.oracle.graal.python.builtins.objects.set.BaseSetBuiltins;
+import com.oracle.graal.python.builtins.objects.set.FrozenSetBuiltins;
+import com.oracle.graal.python.builtins.objects.set.SetBuiltins;
+import com.oracle.graal.python.builtins.objects.slice.SliceBuiltins;
+import com.oracle.graal.python.builtins.objects.socket.SocketBuiltins;
+import com.oracle.graal.python.builtins.objects.ssl.MemoryBIOBuiltins;
+import com.oracle.graal.python.builtins.objects.ssl.SSLContextBuiltins;
+import com.oracle.graal.python.builtins.objects.ssl.SSLErrorBuiltins;
import com.oracle.graal.python.builtins.objects.str.StringBuiltins;
+import com.oracle.graal.python.builtins.objects.struct.StructBuiltins;
+import com.oracle.graal.python.builtins.objects.struct.StructUnpackIteratorBuiltins;
import com.oracle.graal.python.builtins.objects.superobject.SuperBuiltins;
+import com.oracle.graal.python.builtins.objects.thread.CommonLockBuiltins;
+import com.oracle.graal.python.builtins.objects.thread.LockTypeBuiltins;
+import com.oracle.graal.python.builtins.objects.thread.RLockBuiltins;
import com.oracle.graal.python.builtins.objects.thread.ThreadLocalBuiltins;
+import com.oracle.graal.python.builtins.objects.tokenize.TokenizerIterBuiltins;
+import com.oracle.graal.python.builtins.objects.traceback.TracebackBuiltins;
+import com.oracle.graal.python.builtins.objects.tuple.InstantiableStructSequenceBuiltins;
+import com.oracle.graal.python.builtins.objects.tuple.StructSequenceBuiltins;
import com.oracle.graal.python.builtins.objects.tuple.TupleBuiltins;
import com.oracle.graal.python.builtins.objects.tuple.TupleGetterBuiltins;
-import com.oracle.graal.python.builtins.objects.type.SpecialMethodSlot;
import com.oracle.graal.python.builtins.objects.type.TpSlots;
-import com.oracle.graal.python.builtins.objects.type.TpSlots.Builder;
import com.oracle.graal.python.builtins.objects.type.TypeBuiltins;
import com.oracle.graal.python.builtins.objects.types.GenericAliasBuiltins;
+import com.oracle.graal.python.builtins.objects.types.GenericAliasIteratorBuiltins;
import com.oracle.graal.python.builtins.objects.types.UnionTypeBuiltins;
import com.oracle.graal.python.runtime.PythonContext;
import com.oracle.truffle.api.CompilerAsserts;
-import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
import com.oracle.truffle.api.TruffleOptions;
import com.oracle.truffle.api.interop.TruffleObject;
@@ -189,405 +283,954 @@
@ExportLibrary(ReflectionLibrary.class)
public enum PythonBuiltinClassType implements TruffleObject {
- Boolean("bool", J_BUILTINS, Flags.PUBLIC_DERIVED_WODICT, BOOLEAN_M_FLAGS, BoolBuiltins.SLOTS),
- PArray("array", "array", ARRAY_M_FLAGS, ArrayBuiltins.SLOTS),
- PArrayIterator("arrayiterator", Flags.PRIVATE_DERIVED_WODICT),
- PIterator("iterator", Flags.PRIVATE_DERIVED_WODICT),
+ PythonObject("object", null, newBuilder().publishInModule(J_BUILTINS).basetype().slots(ObjectBuiltins.SLOTS).doc("""
+ The base class of the class hierarchy.
+
+ When called, it accepts no arguments and returns a new featureless
+ instance that has no instance attributes and cannot be given any.
+ """)),
+ PythonClass("type", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(TypeBuiltins.SLOTS).doc("""
+ type(object) -> the object's type
+ type(name, bases, dict, **kwds) -> a new type""")),
+ PArray("array", PythonObject, newBuilder().publishInModule("array").basetype().slots(ArrayBuiltins.SLOTS)),
+ PArrayIterator("arrayiterator", PythonObject, newBuilder().disallowInstantiation().slots(IteratorBuiltins.SLOTS)),
+ PIterator("iterator", PythonObject, newBuilder().disallowInstantiation().slots(IteratorBuiltins.SLOTS)),
/** See {@link com.oracle.graal.python.builtins.objects.function.PBuiltinFunction} */
- PBuiltinFunction("method_descriptor", Flags.PRIVATE_DERIVED_WODICT, MethodDescriptorBuiltins.SLOTS),
+ PBuiltinFunction("method_descriptor", PythonObject, newBuilder().disallowInstantiation().slots(AbstractFunctionBuiltins.SLOTS, MethodDescriptorBuiltins.SLOTS)),
/** See {@link com.oracle.graal.python.builtins.objects.method.PBuiltinMethod} */
- PBuiltinFunctionOrMethod("builtin_function_or_method", Flags.PRIVATE_DERIVED_WODICT),
+ PBuiltinFunctionOrMethod(
+ "builtin_function_or_method",
+ PythonObject,
+ newBuilder().disallowInstantiation().slots(AbstractMethodBuiltins.SLOTS, BuiltinFunctionOrMethodBuiltins.SLOTS)),
/** See {@link com.oracle.graal.python.builtins.objects.function.PBuiltinFunction} */
- WrapperDescriptor(J_WRAPPER_DESCRIPTOR, Flags.PRIVATE_DERIVED_WODICT, WrapperDescriptorBuiltins.SLOTS),
+ WrapperDescriptor(J_WRAPPER_DESCRIPTOR, PythonObject, newBuilder().disallowInstantiation().slots(AbstractFunctionBuiltins.SLOTS, WrapperDescriptorBuiltins.SLOTS)),
/** See {@link com.oracle.graal.python.builtins.objects.method.PBuiltinMethod} */
- MethodWrapper("method-wrapper", Flags.PRIVATE_DERIVED_WODICT),
+ MethodWrapper("method-wrapper", PythonObject, newBuilder().slots(AbstractMethodBuiltins.SLOTS, MethodWrapperBuiltins.SLOTS)),
/** See {@link com.oracle.graal.python.builtins.objects.method.PBuiltinMethod} */
- PBuiltinMethod("builtin_method", Flags.PRIVATE_DERIVED_WODICT),
- PBuiltinClassMethod("classmethod_descriptor", Flags.PRIVATE_DERIVED_WODICT, ClassmethodBuiltins.SLOTS),
- GetSetDescriptor("getset_descriptor", Flags.PRIVATE_DERIVED_WODICT, GetSetDescriptorTypeBuiltins.SLOTS),
- MemberDescriptor(J_MEMBER_DESCRIPTOR, Flags.PRIVATE_DERIVED_WODICT, MemberDescriptorBuiltins.SLOTS),
- PByteArray("bytearray", J_BUILTINS, BYTE_ARRAY_M_FLAGS, TpSlots.merge(BytesCommonBuiltins.SLOTS, ByteArrayBuiltins.SLOTS)),
- PBytes("bytes", J_BUILTINS, BYTES_M_FLAGS, TpSlots.merge(BytesCommonBuiltins.SLOTS, BytesBuiltins.SLOTS)),
- PCell("cell", Flags.PRIVATE_DERIVED_WODICT),
- PSimpleNamespace("SimpleNamespace", null, "types", Flags.PUBLIC_BASE_WDICT),
- PKeyWrapper("KeyWrapper", "_functools", "functools", Flags.PUBLIC_DERIVED_WODICT),
- PPartial(J_PARTIAL, "_functools", "functools", Flags.PUBLIC_BASE_WDICT),
- PLruListElem("_lru_list_elem", null, "functools", Flags.PUBLIC_DERIVED_WODICT),
- PLruCacheWrapper(J_LRU_CACHE_WRAPPER, "_functools", "functools", Flags.PUBLIC_BASE_WDICT, LruCacheWrapperBuiltins.SLOTS),
- PDefaultDict(J_DEFAULTDICT, "_collections", "collections", Flags.PUBLIC_BASE_WODICT, DEFAULTDICT_M_FLAGS, DefaultDictBuiltins.SLOTS),
- PDeque(J_DEQUE, "_collections", Flags.PUBLIC_BASE_WODICT, DEQUE_M_FLAGS, DequeBuiltins.SLOTS),
- PTupleGetter(J_TUPLE_GETTER, "_collections", Flags.PUBLIC_BASE_WODICT, TupleGetterBuiltins.SLOTS),
- PDequeIter(J_DEQUE_ITER, "_collections", Flags.PUBLIC_DERIVED_WODICT),
- PDequeRevIter(J_DEQUE_REV_ITER, "_collections", Flags.PUBLIC_DERIVED_WODICT),
- POrderedDict(J_ORDERED_DICT, "_collections", Flags.PUBLIC_BASE_WDICT, DICT_M_FLAGS, OrderedDictBuiltins.SLOTS),
- POrderedDictKeys("odict_keys", Flags.PRIVATE_DERIVED_WODICT, DICTKEYSVIEW_M_FLAGS),
- POrderedDictValues("odict_values", Flags.PRIVATE_DERIVED_WODICT, DICTVALUESVIEW_M_FLAGS),
- POrderedDictItems("odict_items", Flags.PRIVATE_DERIVED_WODICT, DICTITEMSVIEW_M_FLAGS),
- POrderedDictIterator("odict_iterator", Flags.PRIVATE_DERIVED_WODICT),
- PComplex("complex", J_BUILTINS, COMPLEX_M_FLAGS, ComplexBuiltins.SLOTS),
- PDict("dict", J_BUILTINS, DICT_M_FLAGS, DictBuiltins.SLOTS),
- PDictItemIterator(J_DICT_ITEMITERATOR, Flags.PRIVATE_DERIVED_WODICT),
- PDictReverseItemIterator(J_DICT_REVERSE_ITEMITERATOR, Flags.PRIVATE_DERIVED_WODICT),
- PDictItemsView(J_DICT_ITEMS, Flags.PRIVATE_DERIVED_WODICT, DICTITEMSVIEW_M_FLAGS, DictViewBuiltins.SLOTS),
- PDictKeyIterator(J_DICT_KEYITERATOR, Flags.PRIVATE_DERIVED_WODICT),
- PDictReverseKeyIterator(J_DICT_REVERSE_KEYITERATOR, Flags.PRIVATE_DERIVED_WODICT),
- PDictKeysView(J_DICT_KEYS, Flags.PRIVATE_DERIVED_WODICT, DICTKEYSVIEW_M_FLAGS, DictViewBuiltins.SLOTS),
- PDictValueIterator(J_DICT_VALUEITERATOR, Flags.PRIVATE_DERIVED_WODICT),
- PDictReverseValueIterator(J_DICT_REVERSE_VALUEITERATOR, Flags.PRIVATE_DERIVED_WODICT),
- PDictValuesView(J_DICT_VALUES, Flags.PRIVATE_DERIVED_WODICT, DICTVALUESVIEW_M_FLAGS, DictValuesBuiltins.SLOTS),
- PEllipsis("ellipsis", Flags.PRIVATE_DERIVED_WODICT),
- PEnumerate("enumerate", J_BUILTINS),
- PMap("map", J_BUILTINS),
- PFloat("float", J_BUILTINS, FLOAT_M_FLAGS, FloatBuiltins.SLOTS),
- PFrame("frame", Flags.PRIVATE_DERIVED_WODICT),
- PFrozenSet("frozenset", J_BUILTINS, FROZENSET_M_FLAGS, BaseSetBuiltins.SLOTS),
- PFunction("function", Flags.PRIVATE_DERIVED_WDICT, FunctionBuiltins.SLOTS),
- PGenerator("generator", Flags.PRIVATE_DERIVED_WODICT, GENERATOR_M_FLAGS),
- PCoroutine("coroutine", Flags.PRIVATE_DERIVED_WODICT, COROUTINE_M_FLAGS),
- PCoroutineWrapper("coroutine_wrapper", Flags.PRIVATE_DERIVED_WODICT),
- PAsyncGenerator("async_generator", Flags.PRIVATE_DERIVED_WODICT, ASYNC_GENERATOR_M_FLAGS),
- PInt("int", J_BUILTINS, INT_M_FLAGS, IntBuiltins.SLOTS),
- PList("list", J_BUILTINS, LIST_M_FLAGS, ListBuiltins.SLOTS),
- PMappingproxy("mappingproxy", Flags.PRIVATE_DERIVED_WODICT, MAPPINGPROXY_M_FLAGS, MappingproxyBuiltins.SLOTS),
- PMemoryView("memoryview", J_BUILTINS, Flags.PUBLIC_DERIVED_WODICT, MEMORYVIEW_M_FLAGS, MemoryViewBuiltins.SLOTS),
- PAsyncGenASend("async_generator_asend", Flags.PRIVATE_DERIVED_WODICT, ASYNC_GENERATOR_ASEND_M_FLAGS),
- PAsyncGenAThrow("async_generator_athrow", Flags.PRIVATE_DERIVED_WODICT, ASYNC_GENERATOR_ATHROW_M_FLAGS),
- PAsyncGenAWrappedValue("async_generator_wrapped_value", Flags.PRIVATE_DERIVED_WODICT),
- PMethod("method", Flags.PRIVATE_DERIVED_WODICT, MethodBuiltins.SLOTS),
- PMMap("mmap", "mmap", MMAP_M_FLAGS, MMapBuiltins.SLOTS),
- PNone("NoneType", Flags.PRIVATE_DERIVED_WODICT, NONE_M_FLAGS, NoneBuiltins.SLOTS),
- PNotImplemented("NotImplementedType", Flags.PRIVATE_DERIVED_WODICT),
- PProperty(J_PROPERTY, J_BUILTINS, Flags.PUBLIC_BASE_WODICT, PropertyBuiltins.SLOTS),
- PSimpleQueue(J_SIMPLE_QUEUE, "_queue", Flags.PUBLIC_BASE_WODICT),
- PRandom("Random", "_random"),
- PRange("range", J_BUILTINS, Flags.PUBLIC_DERIVED_WODICT, RANGE_M_FLAGS, RangeBuiltins.SLOTS),
- PReferenceType("ReferenceType", "_weakref"),
- PSentinelIterator("callable_iterator", Flags.PRIVATE_DERIVED_WODICT),
- PReverseIterator("reversed", J_BUILTINS),
- PSet("set", J_BUILTINS, SET_M_FLAGS, BaseSetBuiltins.SLOTS),
- PSlice("slice", J_BUILTINS),
- PString("str", J_BUILTINS, STRING_M_FLAGS, StringBuiltins.SLOTS),
- PTraceback("traceback"),
- PTuple("tuple", J_BUILTINS, TUPLE_M_FLAGS, TupleBuiltins.SLOTS),
- PythonClass("type", J_BUILTINS, Flags.PUBLIC_BASE_WDICT, TYPE_M_FLAGS, TypeBuiltins.SLOTS),
- PythonModule("module", Flags.PRIVATE_BASE_WDICT, ModuleBuiltins.SLOTS),
- PythonModuleDef("moduledef", Flags.PRIVATE_DERIVED_WODICT),
- PythonObject("object", J_BUILTINS, ObjectBuiltins.SLOTS),
- Super("super", J_BUILTINS, SuperBuiltins.SLOTS),
- PCode("code", Flags.PRIVATE_DERIVED_WODICT),
- PGenericAlias("GenericAlias", J_TYPES, Flags.PUBLIC_BASE_WODICT, GENERIC_ALIAS_M_FLAGS, GenericAliasBuiltins.SLOTS),
- PGenericAliasIterator("generic_alias_iterator", Flags.PRIVATE_DERIVED_WODICT),
- PUnionType("UnionType", J_TYPES, Flags.PUBLIC_DERIVED_WODICT, UNION_TYPE_M_FLAGS, UnionTypeBuiltins.SLOTS),
- PZip("zip", J_BUILTINS),
- PThread("start_new_thread", J__THREAD),
- PThreadLocal("_local", J__THREAD, ThreadLocalBuiltins.SLOTS),
- PLock("LockType", J__THREAD),
- PRLock("RLock", J__THREAD),
- PSemLock("SemLock", "_multiprocessing"),
- PGraalPySemLock("SemLock", "_multiprocessing_graalpy"),
- PSocket("socket", J__SOCKET),
- PStaticmethod("staticmethod", J_BUILTINS, Flags.PUBLIC_BASE_WDICT, StaticmethodBuiltins.SLOTS),
- PClassmethod("classmethod", J_BUILTINS, Flags.PUBLIC_BASE_WDICT, ClassmethodBuiltins.SLOTS),
- PInstancemethod("instancemethod", Flags.PUBLIC_BASE_WDICT, InstancemethodBuiltins.SLOTS),
- PScandirIterator("ScandirIterator", J_POSIX, Flags.PRIVATE_DERIVED_WODICT),
- PDirEntry("DirEntry", J_POSIX, Flags.PUBLIC_DERIVED_WODICT),
- LsprofProfiler("Profiler", "_lsprof"),
- PStruct("Struct", J__STRUCT),
- PStructUnpackIterator("unpack_iterator", J__STRUCT),
- Pickler("Pickler", "_pickle"),
- PicklerMemoProxy("PicklerMemoProxy", "_pickle"),
- UnpicklerMemoProxy("UnpicklerMemoProxy", "_pickle"),
- Unpickler("Unpickler", "_pickle"),
- PickleBuffer("PickleBuffer", "_pickle"),
+ PBuiltinMethod("builtin_method", PBuiltinFunctionOrMethod, newBuilder()),
+ PBuiltinClassMethod("classmethod_descriptor", PythonObject, newBuilder().slots(ClassmethodCommonBuiltins.SLOTS, BuiltinClassmethodBuiltins.SLOTS)),
+ GetSetDescriptor("getset_descriptor", PythonObject, newBuilder().disallowInstantiation().slots(GetSetDescriptorTypeBuiltins.SLOTS)),
+ MemberDescriptor(J_MEMBER_DESCRIPTOR, PythonObject, newBuilder().disallowInstantiation().slots(MemberDescriptorBuiltins.SLOTS)),
+ PByteArray(
+ "bytearray",
+ PythonObject,
+ newBuilder().publishInModule(J_BUILTINS).basetype().slots(BytesCommonBuiltins.SLOTS, ByteArrayBuiltins.SLOTS).doc("""
+ bytearray(iterable_of_ints) -> bytearray
+ bytearray(string, encoding[, errors]) -> bytearray
+ bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
+ bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
+ bytearray() -> empty bytes array
+
+ Construct a mutable bytearray object from:
+ - an iterable yielding integers in range(256)
+ - a text string encoded using the specified encoding
+ - a bytes or a buffer object
+ - any object implementing the buffer API.
+ - an integer""")),
+ PBytes("bytes", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(BytesCommonBuiltins.SLOTS, BytesBuiltins.SLOTS).doc("""
+ bytes(iterable_of_ints) -> bytes
+ bytes(string, encoding[, errors]) -> bytes
+ bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
+ bytes(int) -> bytes object of size given by the parameter initialized with null bytes
+ bytes() -> empty bytes object
+
+ Construct an immutable array of bytes from:
+ - an iterable yielding integers in range(256)
+ - a text string encoded using the specified encoding
+ - any object implementing the buffer API.
+ - an integer""")),
+ PCell("cell", PythonObject, newBuilder().slots(CellBuiltins.SLOTS)),
+ PSimpleNamespace("SimpleNamespace", PythonObject, newBuilder().publishInModule("types").basetype().addDict().slots(SimpleNamespaceBuiltins.SLOTS).doc("""
+ A simple attribute-based namespace.
+
+ SimpleNamespace(**kwargs)""")),
+ PKeyWrapper("KeyWrapper", PythonObject, newBuilder().moduleName("functools").publishInModule("_functools").disallowInstantiation().slots(KeyWrapperBuiltins.SLOTS)),
+ PPartial(J_PARTIAL, PythonObject, newBuilder().moduleName("functools").publishInModule("_functools").basetype().addDict().slots(PartialBuiltins.SLOTS).doc("""
+ partial(func, *args, **keywords) - new function with partial application
+ of the given arguments and keywords.
+ """)),
+ PLruListElem("_lru_list_elem", PythonObject, newBuilder().publishInModule("functools").disallowInstantiation()),
+ PLruCacheWrapper(J_LRU_CACHE_WRAPPER, PythonObject, newBuilder().moduleName("functools").publishInModule("_functools").basetype().addDict().slots(LruCacheWrapperBuiltins.SLOTS).doc("""
+ Create a cached callable that wraps another function.
+
+ user_function: the function being cached
+
+ maxsize: 0 for no caching
+ None for unlimited cache size
+ n for a bounded cache
+
+ typed: False cache f(3) and f(3.0) as identical calls
+ True cache f(3) and f(3.0) as distinct calls
+
+ cache_info_type: namedtuple class with the fields:
+ hits misses currsize maxsize
+ """)),
+ PDeque(J_DEQUE, PythonObject, newBuilder().publishInModule("_collections").basetype().slots(DequeBuiltins.SLOTS)),
+ PTupleGetter(J_TUPLE_GETTER, PythonObject, newBuilder().publishInModule("_collections").basetype().slots(TupleGetterBuiltins.SLOTS)),
+ PDequeIter(J_DEQUE_ITER, PythonObject, newBuilder().publishInModule("_collections").slots(DequeIterCommonBuiltins.SLOTS, DequeIterBuiltins.SLOTS)),
+ PDequeRevIter(J_DEQUE_REV_ITER, PythonObject, newBuilder().publishInModule("_collections").slots(DequeIterCommonBuiltins.SLOTS, DequeRevIterBuiltins.SLOTS)),
+ PComplex("complex", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(ComplexBuiltins.SLOTS).doc("""
+ Create a complex number from a real part and an optional imaginary part.
+
+ This is equivalent to (real + imag*1j) where imag defaults to 0.""")),
+ PDict("dict", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(DictBuiltins.SLOTS, DictReprBuiltin.SLOTS).doc("""
+ dict() -> new empty dictionary
+ dict(mapping) -> new dictionary initialized from a mapping object's
+ (key, value) pairs
+ dict(iterable) -> new dictionary initialized as if via:
+ d = {}
+ for k, v in iterable:
+ d[k] = v
+ dict(**kwargs) -> new dictionary initialized with the name=value pairs
+ in the keyword argument list. For example: dict(one=1, two=2)""")),
+ PDefaultDict(J_DEFAULTDICT, PDict, newBuilder().moduleName("collections").publishInModule("_collections").basetype().slots(DefaultDictBuiltins.SLOTS)),
+ POrderedDict(J_ORDERED_DICT, PDict, newBuilder().publishInModule("_collections").basetype().addDict().slots(OrderedDictBuiltins.SLOTS)),
+ PDictItemIterator(J_DICT_ITEMITERATOR, PythonObject, newBuilder().disallowInstantiation().slots(IteratorBuiltins.SLOTS)),
+ PDictReverseItemIterator(J_DICT_REVERSE_ITEMITERATOR, PythonObject, newBuilder().slots(IteratorBuiltins.SLOTS)),
+ PDictItemsView(J_DICT_ITEMS, PythonObject, newBuilder().disallowInstantiation().slots(DictViewBuiltins.SLOTS, DictReprBuiltin.SLOTS)),
+ PDictKeyIterator(J_DICT_KEYITERATOR, PythonObject, newBuilder().disallowInstantiation().slots(IteratorBuiltins.SLOTS)),
+ PDictReverseKeyIterator(J_DICT_REVERSE_KEYITERATOR, PythonObject, newBuilder().slots(IteratorBuiltins.SLOTS)),
+ PDictKeysView(J_DICT_KEYS, PythonObject, newBuilder().disallowInstantiation().slots(DictViewBuiltins.SLOTS, DictReprBuiltin.SLOTS)),
+ PDictValueIterator(J_DICT_VALUEITERATOR, PythonObject, newBuilder().disallowInstantiation().slots(IteratorBuiltins.SLOTS)),
+ PDictReverseValueIterator(J_DICT_REVERSE_VALUEITERATOR, PythonObject, newBuilder().slots(IteratorBuiltins.SLOTS)),
+ PDictValuesView(J_DICT_VALUES, PythonObject, newBuilder().disallowInstantiation().slots(DictValuesBuiltins.SLOTS, DictReprBuiltin.SLOTS)),
+ POrderedDictKeys("odict_keys", PDictKeysView, newBuilder().slots(OrderedDictKeysBuiltins.SLOTS)),
+ POrderedDictValues("odict_values", PDictValuesView, newBuilder().slots(OrderedDictValuesBuiltins.SLOTS)),
+ POrderedDictItems("odict_items", PDictItemsView, newBuilder().slots(OrderedDictItemsBuiltins.SLOTS)),
+ POrderedDictIterator("odict_iterator", PythonObject, newBuilder().slots(OrderedDictIteratorBuiltins.SLOTS)),
+ PEllipsis("ellipsis", PythonObject, newBuilder().slots(EllipsisBuiltins.SLOTS)),
+ PEnumerate("enumerate", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(EnumerateBuiltins.SLOTS).doc("""
+ Return an enumerate object.
+
+ iterable
+ an object supporting iteration
+
+ The enumerate object yields pairs containing a count (from start, which
+ defaults to zero) and a value yielded by the iterable argument.
+
+ enumerate is useful for obtaining an indexed list:
+ (0, seq[0]), (1, seq[1]), (2, seq[2]), ...""")),
+ PMap("map", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(MapBuiltins.SLOTS).doc("""
+ map(func, *iterables) --> map object
+
+ Make an iterator that computes the function using arguments from
+ each of the iterables. Stops when the shortest iterable is exhausted.""")),
+ PFloat(
+ "float",
+ PythonObject,
+ newBuilder().publishInModule(J_BUILTINS).basetype().slots(FloatBuiltins.SLOTS).doc("""
+ Convert a string or number to a floating point number, if possible.""")),
+ PFrame("frame", PythonObject, newBuilder().disallowInstantiation().slots(FrameBuiltins.SLOTS)),
+ PFrozenSet(
+ "frozenset",
+ PythonObject,
+ newBuilder().publishInModule(J_BUILTINS).basetype().slots(BaseSetBuiltins.SLOTS, FrozenSetBuiltins.SLOTS).doc("""
+ frozenset() -> empty frozenset object
+ frozenset(iterable) -> frozenset object
+
+ Build an immutable unordered collection of unique elements.""")),
+ PFunction("function", PythonObject, newBuilder().addDict().slots(AbstractFunctionBuiltins.SLOTS, FunctionBuiltins.SLOTS)),
+ PGenerator("generator", PythonObject, newBuilder().disallowInstantiation().slots(GeneratorBuiltins.SLOTS)),
+ PCoroutine("coroutine", PythonObject, newBuilder().slots(CoroutineBuiltins.SLOTS)),
+ PCoroutineWrapper("coroutine_wrapper", PythonObject, newBuilder().slots(CoroutineWrapperBuiltins.SLOTS)),
+ PAsyncGenerator("async_generator", PythonObject, newBuilder().slots(AsyncGeneratorBuiltins.SLOTS)),
+ PAnextAwaitable("anext_awaitable", PythonObject, newBuilder().slots(ANextAwaitableBuiltins.SLOTS)),
+ PInt("int", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(IntBuiltins.SLOTS).doc("""
+ int([x]) -> integer
+ int(x, base=10) -> integer
+
+ Convert a number or string to an integer, or return 0 if no arguments
+ are given. If x is a number, return x.__int__(). For floating point
+ numbers, this truncates towards zero.
+
+ If x is not a number or if base is given, then x must be a string,
+ bytes, or bytearray instance representing an integer literal in the
+ given base. The literal can be preceded by '+' or '-' and be surrounded
+ by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
+ Base 0 means to interpret the base from the string as an integer literal.""")),
+ Boolean("bool", PInt, newBuilder().publishInModule(J_BUILTINS).slots(BoolBuiltins.SLOTS).doc("""
+ bool(x) -> bool
+
+ Returns True when the argument x is true, False otherwise.
+ The builtins True and False are the only two instances of the class bool.
+ The class bool is a subclass of the class int, and cannot be subclassed.""")),
+ PList("list", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(ListBuiltins.SLOTS).doc("""
+ Built-in mutable sequence.
+
+ If no argument is given, the constructor creates a new empty list.
+ The argument must be an iterable if specified.""")),
+ PMappingproxy("mappingproxy", PythonObject, newBuilder().slots(MappingproxyBuiltins.SLOTS)),
+ PMemoryView(
+ "memoryview",
+ PythonObject,
+ newBuilder().publishInModule(J_BUILTINS).slots(MemoryViewBuiltins.SLOTS).doc("""
+ Create a new memoryview object which references the given object.""")),
+ PAsyncGenASend("async_generator_asend", PythonObject, newBuilder().slots(AsyncGenSendBuiltins.SLOTS)),
+ PAsyncGenAThrow("async_generator_athrow", PythonObject, newBuilder().slots(AsyncGenThrowBuiltins.SLOTS)),
+ PAsyncGenAWrappedValue("async_generator_wrapped_value", PythonObject, newBuilder()),
+ PMethod("method", PythonObject, newBuilder().slots(AbstractMethodBuiltins.SLOTS, MethodBuiltins.SLOTS).doc("""
+ Create a bound instance method object.""")),
+ PMMap("mmap", PythonObject, newBuilder().publishInModule("mmap").basetype().slots(MMapBuiltins.SLOTS)),
+ PNone("NoneType", PythonObject, newBuilder().slots(NoneBuiltins.SLOTS)),
+ PNotImplemented("NotImplementedType", PythonObject, newBuilder().slots(NotImplementedBuiltins.SLOTS)),
+ PProperty(J_PROPERTY, PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(PropertyBuiltins.SLOTS).doc("""
+ Property attribute.
+
+ fget
+ function to be used for getting an attribute value
+ fset
+ function to be used for setting an attribute value
+ fdel
+ function to be used for del'ing an attribute
+ doc
+ docstring
+
+ Typical use is to define a managed attribute x:
+
+ class C(object):
+ def getx(self): return self._x
+ def setx(self, value): self._x = value
+ def delx(self): del self._x
+ x = property(getx, setx, delx, "I'm the 'x' property.")
+
+ Decorators make defining new properties or modifying existing ones easy:
+
+ class C(object):
+ @property
+ def x(self):
+ "I am the 'x' property."
+ return self._x
+ @x.setter
+ def x(self, value):
+ self._x = value
+ @x.deleter
+ def x(self):
+ del self._x""")),
+ PSimpleQueue(
+ J_SIMPLE_QUEUE,
+ PythonObject,
+ newBuilder().publishInModule("_queue").basetype().slots(SimpleQueueBuiltins.SLOTS).doc("""
+ SimpleQueue()
+ --
+
+ Simple, unbounded, reentrant FIFO queue.""")),
+ PRandom("Random", PythonObject, newBuilder().publishInModule("_random").basetype().slots(RandomBuiltins.SLOTS)),
+ PRange("range", PythonObject, newBuilder().publishInModule(J_BUILTINS).slots(RangeBuiltins.SLOTS).doc("""
+ range(stop) -> range object
+ range(start, stop[, step]) -> range object
+
+ Return an object that produces a sequence of integers from start (inclusive)
+ to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j-1.
+ start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3.
+ These are exactly the valid indices for a list of 4 elements.
+ When step is given, it specifies the increment (or decrement).""")),
+ PReferenceType("ReferenceType", PythonObject, newBuilder().publishInModule("_weakref").basetype().slots(ReferenceTypeBuiltins.SLOTS)),
+ PSentinelIterator("callable_iterator", PythonObject, newBuilder().disallowInstantiation().slots(SentinelIteratorBuiltins.SLOTS)),
+ PReverseIterator("reversed", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(ReversedBuiltins.SLOTS).doc("""
+ Return a reverse iterator over the values of the given sequence.""")),
+ PSet("set", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(BaseSetBuiltins.SLOTS, SetBuiltins.SLOTS).doc("""
+ set() -> new empty set object
+ set(iterable) -> new set object
+
+ Build an unordered collection of unique elements.""")),
+ PSlice("slice", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(SliceBuiltins.SLOTS).doc("""
+ slice(stop)
+ slice(start, stop[, step])
+
+ Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).""")),
+ PString("str", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(StringBuiltins.SLOTS).doc("""
+ str(object='') -> str
+ str(bytes_or_buffer[, encoding[, errors]]) -> str
+
+ Create a new string object from the given object. If encoding or
+ errors is specified, then the object must expose a data buffer
+ that will be decoded using the given encoding and error handler.
+ Otherwise, returns the result of object.__str__() (if defined)
+ or repr(object).
+ encoding defaults to sys.getdefaultencoding().
+ errors defaults to 'strict'.""")),
+ PTraceback("traceback", PythonObject, newBuilder().basetype().slots(TracebackBuiltins.SLOTS)),
+ PTuple("tuple", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(TupleBuiltins.SLOTS).doc("""
+ Built-in immutable sequence.
+
+ If no argument is given, the constructor returns an empty tuple.
+ If iterable is specified the tuple is initialized from iterable's items.
+
+ If the argument is a tuple, the return value is the same object.""")),
+ PythonModule("module", PythonObject, newBuilder().basetype().addDict().slots(ModuleBuiltins.SLOTS).doc("""
+ Create a module object.
+
+ The name must be a string; the optional doc argument can have any type.""")),
+ PythonModuleDef("moduledef", PythonObject, newBuilder()),
+ Super("super", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().slots(SuperBuiltins.SLOTS).doc("""
+ super() -> same as super(__class__, )
+ super(type) -> unbound super object
+ super(type, obj) -> bound super object; requires isinstance(obj, type)
+ super(type, type2) -> bound super object; requires issubclass(type2, type)
+ Typical use to call a cooperative superclass method:
+ class C(B):
+ def meth(self, arg):
+ super().meth(arg)
+ This works for class methods too:
+ class C(B):
+ @classmethod
+ def cmeth(cls, arg):
+ super().cmeth(arg)""")),
+ PCode("code", PythonObject, newBuilder().slots(CodeBuiltins.SLOTS)),
+ PGenericAlias("GenericAlias", PythonObject, newBuilder().publishInModule(J_TYPES).basetype().slots(GenericAliasBuiltins.SLOTS)),
+ PGenericAliasIterator("generic_alias_iterator", PythonObject, newBuilder().slots(GenericAliasIteratorBuiltins.SLOTS)),
+ PUnionType("UnionType", PythonObject, newBuilder().publishInModule(J_TYPES).slots(UnionTypeBuiltins.SLOTS)),
+ PZip(
+ "zip",
+ PythonObject,
+ newBuilder().publishInModule(J_BUILTINS).basetype().slots(ZipBuiltins.SLOTS).doc("""
+ zip(*iterables, strict=False) --> Yield tuples until an input is exhausted.
+
+ >>> list(zip('abcdefg', range(3), range(4)))
+ [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+
+ The zip object yields n-length tuples, where n is the number of iterables
+ passed as positional arguments to zip(). The i-th element in every tuple
+ comes from the i-th iterable argument to zip(). This continues until the
+ shortest argument is exhausted.
+
+ If strict is true and one of the arguments is exhausted before the others,
+ raise a ValueError.""")),
+ PThreadLocal("_local", PythonObject, newBuilder().publishInModule(J__THREAD).basetype().slots(ThreadLocalBuiltins.SLOTS)),
+ PLock("LockType", PythonObject, newBuilder().publishInModule(J__THREAD).disallowInstantiation().slots(CommonLockBuiltins.SLOTS, LockTypeBuiltins.SLOTS)),
+ PRLock("RLock", PythonObject, newBuilder().publishInModule(J__THREAD).basetype().slots(CommonLockBuiltins.SLOTS, RLockBuiltins.SLOTS)),
+ PSemLock("SemLock", PythonObject, newBuilder().publishInModule("_multiprocessing").basetype().slots(SemLockBuiltins.SLOTS)),
+ PGraalPySemLock("SemLock", PythonObject, newBuilder().publishInModule("_multiprocessing_graalpy").basetype().slots(GraalPySemLockBuiltins.SLOTS)),
+ PSocket("socket", PythonObject, newBuilder().publishInModule(J__SOCKET).basetype().slots(SocketBuiltins.SLOTS)),
+ PStaticmethod("staticmethod", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(StaticmethodBuiltins.SLOTS).doc("""
+ staticmethod(function) -> method
+
+ Convert a function to be a static method.
+
+ A static method does not receive an implicit first argument.
+ To declare a static method, use this idiom:
+
+ class C:
+ @staticmethod
+ def f(arg1, arg2, argN):
+ ...
+
+ It can be called either on the class (e.g. C.f()) or on an instance
+ (e.g. C().f()). Both the class and the instance are ignored, and
+ neither is passed implicitly as the first argument to the method.
+
+ Static methods in Python are similar to those found in Java or C++.
+ For a more advanced concept, see the classmethod builtin.""")),
+ PClassmethod("classmethod", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(ClassmethodCommonBuiltins.SLOTS, ClassmethodBuiltins.SLOTS).doc("""
+ classmethod(function) -> method
+
+ Convert a function to be a class method.
+
+ A class method receives the class as implicit first argument,
+ just like an instance method receives the instance.
+ To declare a class method, use this idiom:
+
+ class C:
+ @classmethod
+ def f(cls, arg1, arg2, argN):
+ ...
+
+ It can be called either on the class (e.g. C.f()) or on an instance
+ (e.g. C().f()). The instance is ignored except for its class.
+ If a class method is called for a derived class, the derived class
+ object is passed as the implied first argument.
+
+ Class methods are different than C++ or Java static methods.
+ If you want those, see the staticmethod builtin.""")),
+ PInstancemethod("instancemethod", PythonObject, newBuilder().basetype().addDict().slots(InstancemethodBuiltins.SLOTS).doc("""
+ instancemethod(function)
+
+ Bind a function to a class.""")),
+ PScandirIterator("ScandirIterator", PythonObject, newBuilder().moduleName(J_POSIX).disallowInstantiation().slots(ScandirIteratorBuiltins.SLOTS)),
+ PDirEntry("DirEntry", PythonObject, newBuilder().publishInModule(J_POSIX).disallowInstantiation().slots(DirEntryBuiltins.SLOTS)),
+ LsprofProfiler("Profiler", PythonObject, newBuilder().publishInModule("_lsprof").basetype().slots(ProfilerBuiltins.SLOTS)),
+ PStruct("Struct", PythonObject, newBuilder().publishInModule(J__STRUCT).basetype().slots(StructBuiltins.SLOTS)),
+ PStructUnpackIterator("unpack_iterator", PythonObject, newBuilder().publishInModule(J__STRUCT).basetype().slots(StructUnpackIteratorBuiltins.SLOTS)),
+ Pickler("Pickler", PythonObject, newBuilder().publishInModule("_pickle").basetype().slots(PicklerBuiltins.SLOTS)),
+ PicklerMemoProxy("PicklerMemoProxy", PythonObject, newBuilder().publishInModule("_pickle").basetype().slots(PicklerMemoProxyBuiltins.SLOTS)),
+ UnpicklerMemoProxy("UnpicklerMemoProxy", PythonObject, newBuilder().publishInModule("_pickle").basetype().slots(UnpicklerMemoProxyBuiltins.SLOTS)),
+ Unpickler("Unpickler", PythonObject, newBuilder().publishInModule("_pickle").basetype().slots(UnpicklerBuiltins.SLOTS)),
+ PickleBuffer("PickleBuffer", PythonObject, newBuilder().publishInModule("_pickle").basetype().slots(PickleBufferBuiltins.SLOTS)),
+
+ // Errors and exceptions:
+
+ // everything after BaseException is considered to be an exception
+ PBaseException("BaseException", PythonObject, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(BaseExceptionBuiltins.SLOTS).doc("""
+ Common base class for all exceptions""")),
+ PBaseExceptionGroup("BaseExceptionGroup", PBaseException, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(BaseExceptionGroupBuiltins.SLOTS).doc("""
+ A combination of multiple unrelated exceptions.""")),
+ SystemExit("SystemExit", PBaseException, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(SystemExitBuiltins.SLOTS)),
+ KeyboardInterrupt("KeyboardInterrupt", PBaseException, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ GeneratorExit("GeneratorExit", PBaseException, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ Exception("Exception", PBaseException, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ReferenceError("ReferenceError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ RuntimeError("RuntimeError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ NotImplementedError("NotImplementedError", RuntimeError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ SyntaxError("SyntaxError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(SyntaxErrorBuiltins.SLOTS)),
+ IndentationError("IndentationError", SyntaxError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(SyntaxErrorBuiltins.SLOTS)),
+ TabError("TabError", IndentationError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(SyntaxErrorBuiltins.SLOTS)),
+ SystemError("SystemError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ TypeError("TypeError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ValueError("ValueError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ StopIteration("StopIteration", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(StopIterationBuiltins.SLOTS)),
+ StopAsyncIteration("StopAsyncIteration", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ArithmeticError("ArithmeticError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ FloatingPointError("FloatingPointError", ArithmeticError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ OverflowError("OverflowError", ArithmeticError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ZeroDivisionError("ZeroDivisionError", ArithmeticError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ AssertionError("AssertionError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ AttributeError("AttributeError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(AttributeErrorBuiltins.SLOTS)),
+ BufferError("BufferError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ EOFError("EOFError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ImportError("ImportError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(ImportErrorBuiltins.SLOTS)),
+ ModuleNotFoundError("ModuleNotFoundError", ImportError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ LookupError("LookupError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ IndexError("IndexError", LookupError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ KeyError("KeyError", LookupError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(KeyErrorBuiltins.SLOTS)),
+ MemoryError("MemoryError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ NameError("NameError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ UnboundLocalError("UnboundLocalError", NameError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ OSError("OSError", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(OsErrorBuiltins.SLOTS)),
+ BlockingIOError("BlockingIOError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ChildProcessError("ChildProcessError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ConnectionError("ConnectionError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ BrokenPipeError("BrokenPipeError", ConnectionError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ConnectionAbortedError("ConnectionAbortedError", ConnectionError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ConnectionRefusedError("ConnectionRefusedError", ConnectionError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ConnectionResetError("ConnectionResetError", ConnectionError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ FileExistsError("FileExistsError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ FileNotFoundError("FileNotFoundError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ InterruptedError("InterruptedError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ IsADirectoryError("IsADirectoryError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ NotADirectoryError("NotADirectoryError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ PermissionError("PermissionError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ProcessLookupError("ProcessLookupError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ TimeoutError("TimeoutError", OSError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ZLibError("error", Exception, newBuilder().publishInModule("zlib").basetype().addDict()),
+ CSVError("Error", Exception, newBuilder().publishInModule("_csv").basetype().addDict()),
+ LZMAError("LZMAError", Exception, newBuilder().publishInModule("_lzma").basetype().addDict()),
+ StructError("StructError", Exception, newBuilder().publishInModule(J__STRUCT).basetype().addDict()),
+ PickleError("PickleError", Exception, newBuilder().publishInModule("_pickle").basetype().addDict()),
+ PicklingError("PicklingError", PickleError, newBuilder().publishInModule("_pickle").basetype().addDict()),
+ UnpicklingError("UnpicklingError", PickleError, newBuilder().publishInModule("_pickle").basetype().addDict()),
+ SocketGAIError("gaierror", OSError, newBuilder().publishInModule(J__SOCKET).basetype().addDict()),
+ SocketHError("herror", OSError, newBuilder().publishInModule(J__SOCKET).basetype().addDict()),
+ BinasciiError("Error", ValueError, newBuilder().publishInModule("binascii").basetype().addDict()),
+ BinasciiIncomplete("Incomplete", Exception, newBuilder().publishInModule("binascii").basetype().addDict()),
+ SSLError("SSLError", OSError, newBuilder().publishInModule(J__SSL).basetype().addDict().slots(SSLErrorBuiltins.SLOTS)),
+ SSLZeroReturnError("SSLZeroReturnError", SSLError, newBuilder().publishInModule(J__SSL).basetype().addDict()),
+ SSLWantReadError("SSLWantReadError", SSLError, newBuilder().publishInModule(J__SSL).basetype().addDict()),
+ SSLWantWriteError("SSLWantWriteError", SSLError, newBuilder().publishInModule(J__SSL).basetype().addDict()),
+ SSLSyscallError("SSLSyscallError", SSLError, newBuilder().publishInModule(J__SSL).basetype().addDict()),
+ SSLEOFError("SSLEOFError", SSLError, newBuilder().publishInModule(J__SSL).basetype().addDict()),
+ SSLCertVerificationError("SSLCertVerificationError", SSLError, newBuilder().publishInModule(J__SSL).basetype().addDict()),
+
+ // todo: all OS errors
+
+ UnicodeError("UnicodeError", ValueError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ UnicodeDecodeError("UnicodeDecodeError", UnicodeError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(UnicodeDecodeErrorBuiltins.SLOTS)),
+ UnicodeEncodeError("UnicodeEncodeError", UnicodeError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(UnicodeEncodeErrorBuiltins.SLOTS)),
+ UnicodeTranslateError("UnicodeTranslateError", UnicodeError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict().slots(UnicodeTranslateErrorBuiltins.SLOTS)),
+ RecursionError("RecursionError", RuntimeError, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+
+ /*
+ * _io.UnsupportedOperation inherits from ValueError and OSError done currently within
+ * IOModuleBuiltins class
+ */
+ IOUnsupportedOperation("UnsupportedOperation", OSError, newBuilder().publishInModule("io").basetype().addDict()),
+
+ Empty("Empty", Exception, newBuilder().publishInModule("_queue").basetype().addDict()),
+
+ UnsupportedMessage("UnsupportedMessage", Exception, newBuilder().publishInModule(J_POLYGLOT).basetype().addDict()),
+
+ // warnings
+ Warning("Warning", Exception, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ BytesWarning("BytesWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ DeprecationWarning("DeprecationWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ FutureWarning("FutureWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ImportWarning("ImportWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ PendingDeprecationWarning("PendingDeprecationWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ ResourceWarning("ResourceWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ RuntimeWarning("RuntimeWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ SyntaxWarning("SyntaxWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ UnicodeWarning("UnicodeWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ UserWarning("UserWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
+ EncodingWarning("EncodingWarning", Warning, newBuilder().publishInModule(J_BUILTINS).basetype().addDict()),
// Foreign
- ForeignObject("ForeignObject", J_POLYGLOT, Flags.PUBLIC_BASE_WDICT, ForeignObjectBuiltins.SLOTS),
- ForeignNumber("ForeignNumber", J_POLYGLOT, ForeignObject, Flags.PUBLIC_BASE_WDICT, FOREIGNNUMBER_M_FLAGS, ForeignNumberBuiltins.SLOTS),
- ForeignBoolean("ForeignBoolean", J_POLYGLOT, ForeignNumber, Flags.PUBLIC_BASE_WDICT, FOREIGNNUMBER_M_FLAGS, ForeignBooleanBuiltins.SLOTS),
- ForeignAbstractClass("ForeignAbstractClass", J_POLYGLOT, ForeignObject, Flags.PUBLIC_BASE_WDICT),
- ForeignExecutable("ForeignExecutable", J_POLYGLOT, ForeignObject, Flags.PUBLIC_BASE_WDICT),
- ForeignInstantiable("ForeignInstantiable", J_POLYGLOT, ForeignObject, Flags.PUBLIC_BASE_WDICT),
- ForeignIterable("ForeignIterable", J_POLYGLOT, ForeignObject, Flags.PUBLIC_BASE_WDICT),
+ ForeignObject("ForeignObject", PythonObject, newBuilder().publishInModule(J_POLYGLOT).basetype().addDict().disallowInstantiation().slots(ForeignObjectBuiltins.SLOTS)),
+ ForeignNumber(
+ "ForeignNumber",
+ ForeignObject,
+ newBuilder().publishInModule(J_POLYGLOT).basetype().addDict().disallowInstantiation().slots(ForeignNumberBuiltins.SLOTS)),
+ ForeignBoolean(
+ "ForeignBoolean",
+ ForeignNumber,
+ newBuilder().publishInModule(J_POLYGLOT).basetype().addDict().disallowInstantiation().slots(ForeignBooleanBuiltins.SLOTS)),
+ ForeignAbstractClass("ForeignAbstractClass", ForeignObject, newBuilder().publishInModule(J_POLYGLOT).basetype().addDict().disallowInstantiation()),
+ ForeignExecutable("ForeignExecutable", ForeignObject, newBuilder().publishInModule(J_POLYGLOT).basetype().addDict().disallowInstantiation().slots(ForeignExecutableBuiltins.SLOTS)),
+ ForeignInstantiable("ForeignInstantiable", ForeignObject, newBuilder().publishInModule(J_POLYGLOT).basetype().addDict().slots(ForeignInstantiableBuiltins.SLOTS)),
+ ForeignIterable("ForeignIterable", ForeignObject, newBuilder().publishInModule(J_POLYGLOT).basetype().addDict().disallowInstantiation().slots(ForeignIterableBuiltins.SLOTS)),
// bz2
- BZ2Compressor("BZ2Compressor", "_bz2"),
- BZ2Decompressor("BZ2Decompressor", "_bz2"),
+ BZ2Compressor("BZ2Compressor", PythonObject, newBuilder().publishInModule("_bz2").basetype().slots(BZ2CompressorBuiltins.SLOTS)),
+ BZ2Decompressor("BZ2Decompressor", PythonObject, newBuilder().publishInModule("_bz2").basetype().slots(BZ2DecompressorBuiltins.SLOTS)),
// lzma
- PLZMACompressor("LZMACompressor", "_lzma"),
- PLZMADecompressor("LZMADecompressor", "_lzma"),
+ PLZMACompressor("LZMACompressor", PythonObject, newBuilder().publishInModule("_lzma").basetype().slots(LZMACompressorBuiltins.SLOTS)),
+ PLZMADecompressor("LZMADecompressor", PythonObject, newBuilder().publishInModule("_lzma").basetype().slots(LZMADecompressorBuiltins.SLOTS)),
// zlib
- ZlibCompress("Compress", "zlib"),
- ZlibDecompress("Decompress", "zlib"),
+ ZlibCompress("Compress", PythonObject, newBuilder().publishInModule("zlib").disallowInstantiation()),
+ ZlibDecompress("Decompress", PythonObject, newBuilder().publishInModule("zlib").disallowInstantiation()),
// io
- PIOBase("_IOBase", "_io", Flags.PUBLIC_BASE_WDICT),
- PRawIOBase("_RawIOBase", "_io"),
- PTextIOBase("_TextIOBase", "_io"),
- PBufferedIOBase("_BufferedIOBase", "_io"),
- PBufferedReader("BufferedReader", "_io", Flags.PUBLIC_BASE_WDICT),
- PBufferedWriter("BufferedWriter", "_io", Flags.PUBLIC_BASE_WDICT),
- PBufferedRWPair("BufferedRWPair", "_io", Flags.PUBLIC_BASE_WDICT),
- PBufferedRandom("BufferedRandom", "_io", Flags.PUBLIC_BASE_WDICT),
- PFileIO("FileIO", "_io", Flags.PUBLIC_BASE_WDICT),
- PTextIOWrapper("TextIOWrapper", "_io", Flags.PUBLIC_BASE_WDICT),
- PIncrementalNewlineDecoder("IncrementalNewlineDecoder", "_io", Flags.PUBLIC_BASE_WODICT),
- PStringIO("StringIO", "_io", Flags.PUBLIC_BASE_WDICT),
- PBytesIO("BytesIO", "_io", Flags.PUBLIC_BASE_WDICT),
- PBytesIOBuf("_BytesIOBuffer", "_io", Flags.PRIVATE_BASE_WODICT),
-
- PStatResult("stat_result", "os", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PStatvfsResult("statvfs_result", "os", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PTerminalSize("terminal_size", "os", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PUnameResult("uname_result", J_POSIX, Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PStructTime("struct_time", "time", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PProfilerEntry("profiler_entry", "_lsprof", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PProfilerSubentry("profiler_subentry", "_lsprof", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PStructPasswd("struct_passwd", "pwd", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PStructRusage("struct_rusage", "resource", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PVersionInfo("version_info", "sys", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PWindowsVersion("windowsversion", "sys", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PFlags("flags", "sys", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PFloatInfo("float_info", "sys", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PIntInfo("int_info", "sys", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PHashInfo("hash_info", "sys", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PThreadInfo("thread_info", "sys", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
- PUnraisableHookArgs("UnraisableHookArgs", "sys", Flags.PUBLIC_DERIVED_WODICT, TUPLE_M_FLAGS),
-
- PSSLSession("SSLSession", J__SSL),
- PSSLContext("_SSLContext", J__SSL),
- PSSLSocket("_SSLSocket", J__SSL),
- PMemoryBIO("MemoryBIO", J__SSL),
+ PIOBase("_IOBase", PythonObject, newBuilder().publishInModule("_io").basetype().addDict().slots(IOBaseBuiltins.SLOTS)),
+ PRawIOBase("_RawIOBase", PIOBase, newBuilder().publishInModule("_io").basetype().slots(IOBaseBuiltins.SLOTS)),
+ PTextIOBase("_TextIOBase", PIOBase, newBuilder().publishInModule("_io").basetype().slots(IOBaseBuiltins.SLOTS)),
+ PBufferedIOBase("_BufferedIOBase", PIOBase, newBuilder().publishInModule("_io").basetype().slots(IOBaseBuiltins.SLOTS)),
+ PBufferedReader(
+ "BufferedReader",
+ PBufferedIOBase,
+ newBuilder().publishInModule("_io").basetype().addDict().slots(BufferedReaderMixinBuiltins.SLOTS, BufferedIOMixinBuiltins.SLOTS, BufferedReaderBuiltins.SLOTS)),
+ PBufferedWriter("BufferedWriter", PBufferedIOBase, newBuilder().publishInModule("_io").basetype().addDict().slots(BufferedIOMixinBuiltins.SLOTS, BufferedWriterBuiltins.SLOTS)),
+ PBufferedRWPair("BufferedRWPair", PBufferedIOBase, newBuilder().publishInModule("_io").basetype().addDict().slots(BufferedRWPairBuiltins.SLOTS)),
+ PBufferedRandom(
+ "BufferedRandom",
+ PBufferedIOBase,
+ newBuilder().publishInModule("_io").basetype().addDict().slots(BufferedReaderMixinBuiltins.SLOTS, BufferedIOMixinBuiltins.SLOTS, BufferedRandomBuiltins.SLOTS)),
+ PWindowsConsoleIO("_WindowsConsoleIO", PRawIOBase, newBuilder().moduleName("_io").basetype()),
+ PFileIO("FileIO", PRawIOBase, newBuilder().publishInModule("_io").basetype().addDict().slots(FileIOBuiltins.SLOTS)),
+ PTextIOWrapper("TextIOWrapper", PTextIOBase, newBuilder().publishInModule("_io").basetype().addDict().slots(TextIOWrapperBuiltins.SLOTS)),
+ PIncrementalNewlineDecoder("IncrementalNewlineDecoder", PythonObject, newBuilder().publishInModule("_io").basetype().slots(IncrementalNewlineDecoderBuiltins.SLOTS)),
+ PStringIO("StringIO", PTextIOBase, newBuilder().publishInModule("_io").basetype().addDict().slots(StringIOBuiltins.SLOTS)),
+ PBytesIO("BytesIO", PBufferedIOBase, newBuilder().publishInModule("_io").basetype().addDict().slots(BytesIOBuiltins.SLOTS)),
+ PBytesIOBuf("_BytesIOBuffer", PythonObject, newBuilder().moduleName("_io").basetype()),
+
+ PStatResult(
+ "stat_result",
+ PTuple,
+ newBuilder().publishInModule("os").slots(StructSequenceBuiltins.SLOTS, StatResultBuiltins.SLOTS).doc("""
+ stat_result: Result from stat, fstat, or lstat.
+
+ This object may be accessed either as a tuple of
+ (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)
+ or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.
+
+ Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,
+ or st_flags, they are available as attributes only.
+
+ See os.stat for more information.""")),
+ PStatvfsResult("statvfs_result", PTuple, newBuilder().publishInModule("os").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ statvfs_result: Result from statvfs or fstatvfs.
+
+ This object may be accessed either as a tuple of
+ (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),
+ or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.
+
+ See os.statvfs for more information.""")),
+ PTerminalSize("terminal_size", PTuple, newBuilder().publishInModule("os").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ A tuple of (columns, lines) for holding terminal window size""")),
+ PUnameResult("uname_result", PTuple, newBuilder().publishInModule(J_POSIX).slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ uname_result: Result from os.uname().
+
+ This object may be accessed either as a tuple of
+ (sysname, nodename, release, version, machine),
+ or via the attributes sysname, nodename, release, version, and machine.
+
+ See os.uname for more information.""")),
+ PStructTime("struct_time", PTuple, newBuilder().publishInModule("time").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ The time value as returned by gmtime(), localtime(), and strptime(), and
+ accepted by asctime(), mktime() and strftime(). May be considered as a
+ sequence of 9 integers.
+
+ Note that several fields' values are not the same as those defined by
+ the C language standard for struct tm. For example, the value of the
+ field tm_year is the actual year, not year - 1900. See individual
+ fields' descriptions for details.""")),
+ PProfilerEntry("profiler_entry", PTuple, newBuilder().publishInModule("_lsprof").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS)),
+ PProfilerSubentry("profiler_subentry", PTuple, newBuilder().publishInModule("_lsprof").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS)),
+ PStructPasswd("struct_passwd", PTuple, newBuilder().publishInModule("pwd").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ pwd.struct_passwd: Results from getpw*() routines.
+
+ This object may be accessed either as a tuple of
+ (pw_name,pw_passwd,pw_uid,pw_gid,pw_gecos,pw_dir,pw_shell)
+ or via the object attributes as named in the above tuple.""")),
+ PStructRusage("struct_rusage", PTuple, newBuilder().publishInModule("resource").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ struct_rusage: Result from getrusage.
+
+ This object may be accessed either as a tuple of
+ (utime,stime,maxrss,ixrss,idrss,isrss,minflt,majflt,
+ nswap,inblock,oublock,msgsnd,msgrcv,nsignals,nvcsw,nivcsw)
+ or via the attributes ru_utime, ru_stime, ru_maxrss, and so on.""")),
+ PVersionInfo("version_info", PTuple, newBuilder().publishInModule("sys").disallowInstantiation().slots(StructSequenceBuiltins.SLOTS).doc("""
+ sys.version_info
+
+ Version information as a named tuple.""")),
+ PWindowsVersion("windowsversion", PTuple, newBuilder().publishInModule("sys").disallowInstantiation().slots(StructSequenceBuiltins.SLOTS).doc("""
+ sys.getwindowsversion
+
+ Return info about the running version of Windows as a named tuple.""")),
+ PFlags("flags", PTuple, newBuilder().publishInModule("sys").disallowInstantiation().slots(StructSequenceBuiltins.SLOTS).doc("""
+ sys.flags
+
+ Flags provided through command line arguments or environment vars.""")),
+ PFloatInfo("float_info", PTuple, newBuilder().publishInModule("sys").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ sys.float_info
+
+ A named tuple holding information about the float type. It contains low level
+ information about the precision and internal representation. Please study
+ your system's :file:`float.h` for more information.""")),
+ PIntInfo("int_info", PTuple, newBuilder().publishInModule("sys").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ sys.int_info
+
+ A named tuple that holds information about Python's
+ internal representation of integers. The attributes are read only.""")),
+ PHashInfo("hash_info", PTuple, newBuilder().publishInModule("sys").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ hash_info
+
+ A named tuple providing parameters used for computing
+ hashes. The attributes are read only.""")),
+ PThreadInfo("thread_info", PTuple, newBuilder().publishInModule("sys").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ sys.thread_info
+
+ A named tuple holding information about the thread implementation.""")),
+ PUnraisableHookArgs(
+ "UnraisableHookArgs",
+ PTuple,
+ newBuilder().publishInModule("sys").slots(StructSequenceBuiltins.SLOTS, InstantiableStructSequenceBuiltins.SLOTS).doc("""
+ UnraisableHookArgs
+
+ Type used to pass arguments to sys.unraisablehook.""")),
+
+ PSSLSession("SSLSession", PythonObject, newBuilder().publishInModule(J__SSL).disallowInstantiation()),
+ PSSLContext("_SSLContext", PythonObject, newBuilder().publishInModule(J__SSL).basetype().slots(SSLContextBuiltins.SLOTS)),
+ PSSLSocket("_SSLSocket", PythonObject, newBuilder().publishInModule(J__SSL).basetype()),
+ PMemoryBIO("MemoryBIO", PythonObject, newBuilder().publishInModule(J__SSL).basetype().slots(MemoryBIOBuiltins.SLOTS)),
// itertools
- PTee("_tee", "itertools", Flags.PUBLIC_DERIVED_WODICT),
- PTeeDataObject("_tee_dataobject", "itertools", Flags.PUBLIC_DERIVED_WODICT),
- PAccumulate("accumulate", "itertools"),
- PCombinations("combinations", "itertools"),
- PCombinationsWithReplacement("combinations_with_replacement", "itertools"),
- PCompress("compress", "itertools"),
- PCycle("cycle", "itertools"),
- PDropwhile("dropwhile", "itertools"),
- PFilterfalse("filterfalse", "itertools"),
- PGroupBy("groupby", "itertools"),
- PGrouper("grouper", "itertools", Flags.PUBLIC_DERIVED_WODICT),
- PPairwise("pairwise", "itertools"),
- PPermutations("permutations", "itertools"),
- PProduct("product", "itertools"),
- PRepeat("repeat", "itertools"),
- PChain("chain", "itertools"),
- PCount("count", "itertools"),
- PIslice("islice", "itertools"),
- PStarmap("starmap", "itertools"),
- PTakewhile("takewhile", "itertools"),
- PZipLongest("zip_longest", "itertools"),
+ PTee("_tee", PythonObject, newBuilder().publishInModule("itertools").slots(TeeBuiltins.SLOTS)),
+ PTeeDataObject("_tee_dataobject", PythonObject, newBuilder().publishInModule("itertools").slots(TeeDataObjectBuiltins.SLOTS)),
+ PAccumulate("accumulate", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(AccumulateBuiltins.SLOTS).doc("""
+ accumulate(iterable) --> accumulate object
+
+ Return series of accumulated sums.""")),
+ PCombinations("combinations", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(CombinationsBuiltins.SLOTS).doc("""
+ combinations(iterable, r) --> combinations object
+
+ Return successive r-length combinations of elements in the iterable.
+
+ combinations(range(4), 3) --> (0,1,2), (0,1,3), (0,2,3), (1,2,3)""")),
+ PCombinationsWithReplacement(
+ "combinations_with_replacement",
+ PythonObject,
+ newBuilder().publishInModule("itertools").basetype().slots(CombinationsBuiltins.SLOTS, CombinationsWithReplacementBuiltins.SLOTS).doc("""
+ combinations_with_replacement(iterable, r) --> combinations_with_replacement object
+
+ Return successive r-length combinations of elements in the iterable
+ allowing individual elements to have successive repeats.
+ combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC""")),
+ PCompress("compress", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(CompressBuiltins.SLOTS).doc("""
+ Make an iterator that filters elements from *data* returning
+ only those that have a corresponding element in *selectors* that evaluates to
+ ``True``. Stops when either the *data* or *selectors* iterables has been
+ exhausted.
+ Equivalent to::
+
+ \tdef compress(data, selectors):
+ \t\t# compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
+ \t\treturn (d for d, s in zip(data, selectors) if s)""")),
+ PCycle("cycle", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(CycleBuiltins.SLOTS).doc("""
+ Make an iterator returning elements from the iterable and
+ saving a copy of each. When the iterable is exhausted, return
+ elements from the saved copy. Repeats indefinitely.
+
+ Equivalent to :
+
+ def cycle(iterable):
+ \tsaved = []
+ \tfor element in iterable:
+ \t\tyield element
+ \t\tsaved.append(element)
+ \twhile saved:
+ \t\tfor element in saved:
+ \t\t\tyield element""")),
+ PDropwhile("dropwhile", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(DropwhileBuiltins.SLOTS).doc("""
+ dropwhile(predicate, iterable) --> dropwhile object
+
+ Drop items from the iterable while predicate(item) is true.
+ Afterwards, return every element until the iterable is exhausted.""")),
+ PFilterfalse("filterfalse", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(FilterfalseBuiltins.SLOTS).doc("""
+ filterfalse(function or None, sequence) --> filterfalse object
+
+ Return those items of sequence for which function(item) is false.
+ If function is None, return the items that are false.""")),
+ PGroupBy("groupby", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(GroupByBuiltins.SLOTS).doc("""
+ Make an iterator that returns consecutive keys and groups from the
+ iterable. The key is a function computing a key value for each
+ element. If not specified or is None, key defaults to an identity
+ function and returns the element unchanged. Generally, the
+ iterable needs to already be sorted on the same key function.
+
+ The returned group is itself an iterator that shares the
+ underlying iterable with groupby(). Because the source is shared,
+ when the groupby object is advanced, the previous group is no
+ longer visible. So, if that data is needed later, it should be
+ stored as a list:
+
+ \tgroups = []
+ \tuniquekeys = []
+ \tfor k, g in groupby(data, keyfunc):
+ \t\tgroups.append(list(g)) # Store group iterator as a list
+ \t\tuniquekeys.append(k)""")),
+ PGrouper("grouper", PythonObject, newBuilder().publishInModule("itertools").slots(GrouperBuiltins.SLOTS)),
+ PPairwise("pairwise", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(PairwiseBuiltins.SLOTS).doc("""
+ Return an iterator of overlapping pairs taken from the input iterator.
+
+ s -> (s0,s1), (s1,s2), (s2, s3), ...""")),
+ PPermutations("permutations", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(PermutationsBuiltins.SLOTS).doc("""
+ permutations(iterable[, r]) --> permutations object
+
+ Return successive r-length permutations of elements in the iterable.
+
+ permutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)""")),
+ PProduct("product", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(ProductBuiltins.SLOTS).doc("""
+ Cartesian product of input iterables.
+
+ Equivalent to nested for-loops in a generator expression. For example,
+ ``product(A, B)`` returns the same as ``((x,y) for x in A for y in B)``.
+
+ The nested loops cycle like an odometer with the rightmost element advancing
+ on every iteration. This pattern creates a lexicographic ordering so that if
+ the input's iterables are sorted, the product tuples are emitted in sorted
+ order.
+
+ To compute the product of an iterable with itself, specify the number of
+ repetitions with the optional *repeat* keyword argument. For example,
+ ``product(A, repeat=4)`` means the same as ``product(A, A, A, A)``.
+
+ This function is equivalent to the following code, except that the
+ actual implementation does not build up intermediate results in memory::
+
+ def product(*args, **kwds):
+ \t# product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
+ \t# product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
+ \tpools = map(tuple, args) * kwds.get('repeat', 1)
+ \tresult = [[]]
+ \tfor pool in pools:
+ \t\tresult = [x+[y] for x in result for y in pool]
+ \tfor prod in result:
+ \t\tyield tuple(prod)""")),
+ PRepeat("repeat", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(RepeatBuiltins.SLOTS).doc("""
+ repeat(object [,times]) -> create an iterator which returns the object
+ for the specified number of times. If not specified, returns the object
+ endlessly.""")),
+ PChain("chain", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(ChainBuiltins.SLOTS).doc("""
+ Return a chain object whose .__next__() method returns elements from the
+ first iterable until it is exhausted, then elements from the next
+ iterable, until all of the iterables are exhausted.""")),
+ PCount("count", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(CountBuiltins.SLOTS)),
+ PIslice("islice", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(IsliceBuiltins.SLOTS)),
+ PStarmap("starmap", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(StarmapBuiltins.SLOTS).doc("""
+ starmap(function, sequence) --> starmap object
+
+ Return an iterator whose values are returned from the function evaluated
+ with an argument tuple taken from the given sequence.""")),
+ PTakewhile("takewhile", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(TakewhileBuiltins.SLOTS).doc("""
+ Make an iterator that returns elements from the iterable as
+ long as the predicate is true.
+
+ Equivalent to :
+
+ def takewhile(predicate, iterable):
+ \tfor x in iterable:
+ \t\tif predicate(x):
+ \t\t\tyield x
+ \t\telse:
+ \t\t\tbreak""")),
+ PZipLongest("zip_longest", PythonObject, newBuilder().publishInModule("itertools").basetype().slots(ZipLongestBuiltins.SLOTS).doc("""
+ zip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> zip_longest object
+
+ Return a zip_longest object whose .next() method returns a tuple where
+ the i-th element comes from the i-th iterable argument. The .next()
+ method continues until the longest iterable in the argument sequence
+ is exhausted and then it raises StopIteration. When the shorter iterables
+ are exhausted, the fillvalue is substituted in their place. The fillvalue
+ defaults to None or can be specified by a keyword argument.""")),
// json
- JSONScanner("Scanner", "_json", Flags.PUBLIC_BASE_WODICT),
- JSONEncoder("Encoder", "_json", Flags.PUBLIC_BASE_WODICT),
+ JSONScanner(
+ "Scanner",
+ PythonObject,
+ newBuilder().publishInModule("_json").basetype().slots(JSONScannerBuiltins.SLOTS).doc("""
+ JSON scanner object""")),
+ JSONEncoder(
+ "Encoder",
+ PythonObject,
+ newBuilder().publishInModule("_json").basetype().slots(JSONEncoderBuiltins.SLOTS).doc("""
+ _iterencode(obj, _current_indent_level) -> iterable""")),
// csv
- CSVDialect("Dialect", "_csv", Flags.PUBLIC_BASE_WODICT),
- CSVReader("Reader", "_csv", Flags.PUBLIC_BASE_WODICT),
- CSVWriter("Writer", "_csv", Flags.PUBLIC_BASE_WODICT),
+ CSVDialect("Dialect", PythonObject, newBuilder().publishInModule("_csv").basetype().slots(CSVDialectBuiltins.SLOTS)),
+ CSVReader("Reader", PythonObject, newBuilder().publishInModule("_csv").basetype().disallowInstantiation().slots(CSVReaderBuiltins.SLOTS)),
+ CSVWriter("Writer", PythonObject, newBuilder().publishInModule("_csv").basetype().disallowInstantiation()),
// codecs
- PEncodingMap("EncodingMap", Flags.PRIVATE_DERIVED_WODICT),
+ PEncodingMap("EncodingMap", PythonObject, newBuilder().disallowInstantiation()),
// hashlib
- MD5Type("md5", "_md5", Flags.PUBLIC_BASE_WODICT),
- SHA1Type("sha1", "_sha1", Flags.PUBLIC_BASE_WODICT),
- SHA224Type("sha224", "_sha256", Flags.PUBLIC_BASE_WODICT),
- SHA256Type("sha256", "_sha256", Flags.PUBLIC_BASE_WODICT),
- SHA384Type("sha384", "_sha512", Flags.PUBLIC_BASE_WODICT),
- SHA512Type("sha512", "_sha512", Flags.PUBLIC_BASE_WODICT),
- Sha3SHA224Type("sha3_224", "_sha3", Flags.PUBLIC_BASE_WODICT),
- Sha3SHA256Type("sha3_256", "_sha3", Flags.PUBLIC_BASE_WODICT),
- Sha3SHA384Type("sha3_384", "_sha3", Flags.PUBLIC_BASE_WODICT),
- Sha3SHA512Type("sha3_512", "_sha3", Flags.PUBLIC_BASE_WODICT),
- Sha3Shake128Type("shake_128", "_sha3", Flags.PUBLIC_BASE_WODICT),
- Sha3Shake256Type("shake_256", "_sha3", Flags.PUBLIC_BASE_WODICT),
- Blake2bType("blake2b", "_blake2", Flags.PUBLIC_BASE_WODICT),
- Blake2sType("blake2s", "_blake2", Flags.PUBLIC_BASE_WODICT),
- HashlibHash("HASH", "_hashlib", Flags.PUBLIC_BASE_WODICT),
- HashlibHashXof("HASHXOF", "_hashlib", Flags.PUBLIC_DERIVED_WODICT),
- HashlibHmac("HMAC", "_hashlib", Flags.PUBLIC_BASE_WODICT),
- UnsupportedDigestmodError("UnsupportedDigestmodError", "_hashlib", Flags.EXCEPTION),
+ MD5Type("md5", PythonObject, newBuilder().publishInModule("_md5").basetype().disallowInstantiation()),
+ SHA1Type("sha1", PythonObject, newBuilder().publishInModule("_sha1").basetype().disallowInstantiation()),
+ SHA224Type("sha224", PythonObject, newBuilder().publishInModule("_sha256").basetype().disallowInstantiation()),
+ SHA256Type("sha256", PythonObject, newBuilder().publishInModule("_sha256").basetype().disallowInstantiation()),
+ SHA384Type("sha384", PythonObject, newBuilder().publishInModule("_sha512").basetype().disallowInstantiation()),
+ SHA512Type("sha512", PythonObject, newBuilder().publishInModule("_sha512").basetype().disallowInstantiation()),
+ Sha3SHA224Type("sha3_224", PythonObject, newBuilder().publishInModule("_sha3").basetype().slots(Sha3Builtins.SLOTS)),
+ Sha3SHA256Type("sha3_256", PythonObject, newBuilder().publishInModule("_sha3").basetype().slots(Sha3Builtins.SLOTS)),
+ Sha3SHA384Type("sha3_384", PythonObject, newBuilder().publishInModule("_sha3").basetype().slots(Sha3Builtins.SLOTS)),
+ Sha3SHA512Type("sha3_512", PythonObject, newBuilder().publishInModule("_sha3").basetype().slots(Sha3Builtins.SLOTS)),
+ Sha3Shake128Type("shake_128", PythonObject, newBuilder().publishInModule("_sha3").basetype().slots(Sha3Builtins.SLOTS)),
+ Sha3Shake256Type("shake_256", PythonObject, newBuilder().publishInModule("_sha3").basetype().slots(Sha3Builtins.SLOTS)),
+ Blake2bType("blake2b", PythonObject, newBuilder().publishInModule("_blake2").basetype().slots(Blake2bObjectBuiltins.SLOTS)),
+ /* Note we reuse the blake2b slots */
+ Blake2sType("blake2s", PythonObject, newBuilder().publishInModule("_blake2").basetype().slots(Blake2bObjectBuiltins.SLOTS)),
+ HashlibHash("HASH", PythonObject, newBuilder().publishInModule("_hashlib").basetype().disallowInstantiation().slots(HashObjectBuiltins.SLOTS)),
+ HashlibHashXof("HASHXOF", HashlibHash, newBuilder().publishInModule("_hashlib").disallowInstantiation()),
+ HashlibHmac("HMAC", PythonObject, newBuilder().publishInModule("_hashlib").basetype().disallowInstantiation().slots(HashObjectBuiltins.SLOTS)),
+ UnsupportedDigestmodError("UnsupportedDigestmodError", ValueError, newBuilder().publishInModule("_hashlib").basetype().addDict()),
// _ast (rest of the classes are not builtin, they are generated in AstModuleBuiltins)
- AST("AST", "_ast", "ast", Flags.PUBLIC_BASE_WDICT),
+ AST("AST", PythonObject, newBuilder().moduleName("ast").publishInModule("_ast").basetype().addDict().slots(AstBuiltins.SLOTS)),
// _ctype
- CArgObject("CArgObject", Flags.PUBLIC_BASE_WODICT),
- CThunkObject("CThunkObject", J__CTYPES, Flags.PUBLIC_BASE_WODICT),
- StgDict("StgDict", Flags.PRIVATE_DERIVED_WODICT, DICT_M_FLAGS, StgDictBuiltins.SLOTS),
- PyCStructType("PyCStructType", J__CTYPES, Flags.PUBLIC_BASE_WODICT, PYCSTRUCTTYPE_M_FLAGS, TpSlots.merge(CDataTypeSequenceBuiltins.SLOTS, PyCStructTypeBuiltins.SLOTS)),
+ CArgObject("CArgObject", PythonObject, newBuilder().basetype().slots(CArgObjectBuiltins.SLOTS)),
+ CThunkObject("CThunkObject", PythonObject, newBuilder().publishInModule(J__CTYPES).basetype()),
+ StgDict("StgDict", PDict, newBuilder().slots(StgDictBuiltins.SLOTS)),
+ PyCStructType(
+ "PyCStructType",
+ PythonClass,
+ newBuilder().publishInModule(J__CTYPES).basetype().slots(CDataTypeSequenceBuiltins.SLOTS, StructUnionTypeBuiltins.SLOTS, PyCStructTypeBuiltins.SLOTS)),
UnionType(
"UnionType",
- J__CTYPES,
- Flags.PUBLIC_BASE_WODICT,
- UNIONTYPE_M_FLAGS,
- TpSlots.merge(CDataTypeSequenceBuiltins.SLOTS, com.oracle.graal.python.builtins.modules.ctypes.UnionTypeBuiltins.SLOTS)),
- PyCPointerType("PyCPointerType", J__CTYPES, Flags.PUBLIC_BASE_WODICT, PYCPOINTERTYPE_M_FLAGS, CDataTypeSequenceBuiltins.SLOTS),
- PyCArrayType("PyCArrayType", J__CTYPES, Flags.PUBLIC_BASE_WODICT, PYCARRAYTYPE_M_FLAGS, CDataTypeSequenceBuiltins.SLOTS),
- PyCSimpleType("PyCSimpleType", J__CTYPES, Flags.PUBLIC_BASE_WODICT, PYCSIMPLETYPE_M_FLAGS, CDataTypeSequenceBuiltins.SLOTS),
- PyCFuncPtrType("PyCFuncPtrType", J__CTYPES, Flags.PUBLIC_BASE_WODICT, PYCFUNCPTRTYPE_M_FLAGS, CDataTypeSequenceBuiltins.SLOTS),
- Structure("Structure", J__CTYPES, Flags.PUBLIC_BASE_WODICT), /*- type = PyCStructType */
- Union("Union", J__CTYPES, Flags.PUBLIC_BASE_WODICT), /*- type = UnionType */
- PyCPointer("_Pointer", J__CTYPES, Flags.PUBLIC_BASE_WODICT, PYCPOINTER_M_FLAGS, PyCPointerBuiltins.SLOTS), /*- type = PyCPointerType */
- PyCArray("Array", J__CTYPES, Flags.PUBLIC_BASE_WODICT, PYCARRAY_M_FLAGS, PyCArrayBuiltins.SLOTS), /*- type = PyCArrayType */
- PyCData("_CData", J__CTYPES, Flags.PUBLIC_BASE_WODICT), /*- type = PyCStructType */
- SimpleCData("_SimpleCData", J__CTYPES, Flags.PUBLIC_BASE_WODICT, SIMPLECDATA_M_FLAGS, SimpleCDataBuiltins.SLOTS), /*- type = PyCStructType */
- PyCFuncPtr("PyCFuncPtr", J__CTYPES, Flags.PUBLIC_BASE_WODICT, PYCFUNCPTR_M_FLAGS, PyCFuncPtrBuiltins.SLOTS), /*- type = PyCFuncPtrType */
- CField("CField", J__CTYPES, Flags.PUBLIC_BASE_WODICT, CFieldBuiltins.SLOTS),
- DictRemover("DictRemover", J__CTYPES, Flags.PUBLIC_BASE_WODICT),
- StructParam("StructParam_Type", J__CTYPES, Flags.PUBLIC_BASE_WODICT),
- ArgError("ArgumentError", J__CTYPES, Flags.EXCEPTION),
+ PythonClass,
+ newBuilder().publishInModule(J__CTYPES).basetype().slots(
+ CDataTypeSequenceBuiltins.SLOTS, StructUnionTypeBuiltins.SLOTS,
+ com.oracle.graal.python.builtins.modules.ctypes.UnionTypeBuiltins.SLOTS)),
+ PyCPointerType(
+ "PyCPointerType",
+ PythonClass,
+ newBuilder().publishInModule(J__CTYPES).basetype().slots(CDataTypeSequenceBuiltins.SLOTS, PyCPointerTypeBuiltins.SLOTS)),
+ PyCArrayType(
+ "PyCArrayType",
+ PythonClass,
+ newBuilder().publishInModule(J__CTYPES).basetype().slots(CDataTypeSequenceBuiltins.SLOTS, PyCArrayTypeBuiltins.SLOTS)),
+ PyCSimpleType(
+ "PyCSimpleType",
+ PythonClass,
+ newBuilder().publishInModule(J__CTYPES).basetype().slots(CDataTypeSequenceBuiltins.SLOTS, PyCPointerTypeBuiltins.SLOTS, PyCSimpleTypeBuiltins.SLOTS)),
+ PyCFuncPtrType(
+ "PyCFuncPtrType",
+ PythonClass,
+ newBuilder().publishInModule(J__CTYPES).basetype().slots(CDataTypeSequenceBuiltins.SLOTS, PyCFuncPtrTypeBuiltins.SLOTS)),
+ PyCData("_CData", PythonObject, newBuilder().publishInModule(J__CTYPES).basetype().slots(CDataBuiltins.SLOTS)), /*- type = PyCStructType */
+ Structure("Structure", PyCData, newBuilder().publishInModule(J__CTYPES).basetype().slots(StructureBuiltins.SLOTS)), /*- type = PyCStructType */
+ Union("Union", PyCData, newBuilder().publishInModule(J__CTYPES).basetype().slots(StructureBuiltins.SLOTS)), /*- type = UnionType */
+ PyCPointer("_Pointer", PyCData, newBuilder().publishInModule(J__CTYPES).basetype().slots(PyCPointerBuiltins.SLOTS)), /*- type = PyCPointerType */
+ PyCArray("Array", PyCData, newBuilder().publishInModule(J__CTYPES).basetype().slots(PyCArrayBuiltins.SLOTS)), /*- type = PyCArrayType */
+ SimpleCData("_SimpleCData", PyCData, newBuilder().publishInModule(J__CTYPES).basetype().slots(SimpleCDataBuiltins.SLOTS)), /*- type = PyCStructType */
+ PyCFuncPtr("PyCFuncPtr", PyCData, newBuilder().publishInModule(J__CTYPES).basetype().slots(PyCFuncPtrBuiltins.SLOTS)), /*- type = PyCFuncPtrType */
+ CField("CField", PythonObject, newBuilder().publishInModule(J__CTYPES).basetype().slots(CFieldBuiltins.SLOTS)),
+ DictRemover("DictRemover", PythonObject, newBuilder().publishInModule(J__CTYPES).basetype()),
+ StructParam("StructParam_Type", PythonObject, newBuilder().publishInModule(J__CTYPES).basetype()),
+ ArgError("ArgumentError", PBaseException, newBuilder().publishInModule(J__CTYPES).basetype().addDict()),
// _multibytecodec
- MultibyteCodec("MultibyteCodec", "_multibytecodec", Flags.PUBLIC_BASE_WDICT),
- MultibyteIncrementalEncoder("MultibyteIncrementalEncoder", "_multibytecodec", Flags.PUBLIC_BASE_WDICT),
- MultibyteIncrementalDecoder("MultibyteIncrementalDecoder", "_multibytecodec", Flags.PUBLIC_BASE_WDICT),
- MultibyteStreamReader("MultibyteStreamReader", "_multibytecodec", Flags.PUBLIC_BASE_WDICT),
- MultibyteStreamWriter("MultibyteStreamWriter", "_multibytecodec", Flags.PUBLIC_BASE_WDICT),
-
- // Errors and exceptions:
-
- // everything after BaseException is considered to be an exception
- PBaseException("BaseException", J_BUILTINS, Flags.EXCEPTION),
- PBaseExceptionGroup("BaseExceptionGroup", J_BUILTINS, Flags.EXCEPTION),
- SystemExit("SystemExit", J_BUILTINS, Flags.EXCEPTION),
- KeyboardInterrupt("KeyboardInterrupt", J_BUILTINS, Flags.EXCEPTION),
- GeneratorExit("GeneratorExit", J_BUILTINS, Flags.EXCEPTION),
- Exception("Exception", J_BUILTINS, Flags.EXCEPTION),
- StopIteration("StopIteration", J_BUILTINS, Flags.EXCEPTION),
- StopAsyncIteration("StopAsyncIteration", J_BUILTINS, Flags.EXCEPTION),
- ArithmeticError("ArithmeticError", J_BUILTINS, Flags.EXCEPTION),
- FloatingPointError("FloatingPointError", J_BUILTINS, Flags.EXCEPTION),
- OverflowError("OverflowError", J_BUILTINS, Flags.EXCEPTION),
- ZeroDivisionError("ZeroDivisionError", J_BUILTINS, Flags.EXCEPTION),
- AssertionError("AssertionError", J_BUILTINS, Flags.EXCEPTION),
- AttributeError("AttributeError", J_BUILTINS, Flags.EXCEPTION),
- BufferError("BufferError", J_BUILTINS, Flags.EXCEPTION),
- EOFError("EOFError", J_BUILTINS, Flags.EXCEPTION),
- ImportError("ImportError", J_BUILTINS, Flags.EXCEPTION),
- ModuleNotFoundError("ModuleNotFoundError", J_BUILTINS, Flags.EXCEPTION),
- LookupError("LookupError", J_BUILTINS, Flags.EXCEPTION),
- IndexError("IndexError", J_BUILTINS, Flags.EXCEPTION),
- KeyError("KeyError", J_BUILTINS, Flags.EXCEPTION),
- MemoryError("MemoryError", J_BUILTINS, Flags.EXCEPTION),
- NameError("NameError", J_BUILTINS, Flags.EXCEPTION),
- UnboundLocalError("UnboundLocalError", J_BUILTINS, Flags.EXCEPTION),
- OSError("OSError", J_BUILTINS, Flags.EXCEPTION),
- BlockingIOError("BlockingIOError", J_BUILTINS, Flags.EXCEPTION),
- ChildProcessError("ChildProcessError", J_BUILTINS, Flags.EXCEPTION),
- ConnectionError("ConnectionError", J_BUILTINS, Flags.EXCEPTION),
- BrokenPipeError("BrokenPipeError", J_BUILTINS, Flags.EXCEPTION),
- ConnectionAbortedError("ConnectionAbortedError", J_BUILTINS, Flags.EXCEPTION),
- ConnectionRefusedError("ConnectionRefusedError", J_BUILTINS, Flags.EXCEPTION),
- ConnectionResetError("ConnectionResetError", J_BUILTINS, Flags.EXCEPTION),
- FileExistsError("FileExistsError", J_BUILTINS, Flags.EXCEPTION),
- FileNotFoundError("FileNotFoundError", J_BUILTINS, Flags.EXCEPTION),
- InterruptedError("InterruptedError", J_BUILTINS, Flags.EXCEPTION),
- IsADirectoryError("IsADirectoryError", J_BUILTINS, Flags.EXCEPTION),
- NotADirectoryError("NotADirectoryError", J_BUILTINS, Flags.EXCEPTION),
- PermissionError("PermissionError", J_BUILTINS, Flags.EXCEPTION),
- ProcessLookupError("ProcessLookupError", J_BUILTINS, Flags.EXCEPTION),
- TimeoutError("TimeoutError", J_BUILTINS, Flags.EXCEPTION),
- ZLibError("error", "zlib", Flags.EXCEPTION),
- CSVError("Error", "_csv", Flags.EXCEPTION),
- LZMAError("LZMAError", "_lzma", Flags.EXCEPTION),
- StructError("StructError", J__STRUCT, Flags.EXCEPTION),
- PickleError("PickleError", "_pickle", Flags.EXCEPTION),
- PicklingError("PicklingError", "_pickle", Flags.EXCEPTION),
- UnpicklingError("UnpicklingError", "_pickle", Flags.EXCEPTION),
- SocketGAIError("gaierror", J__SOCKET, Flags.EXCEPTION),
- SocketHError("herror", J__SOCKET, Flags.EXCEPTION),
- BinasciiError("Error", "binascii", Flags.EXCEPTION),
- BinasciiIncomplete("Incomplete", "binascii", Flags.EXCEPTION),
- SSLError("SSLError", J__SSL, Flags.EXCEPTION),
- SSLZeroReturnError("SSLZeroReturnError", J__SSL, Flags.EXCEPTION),
- SSLWantReadError("SSLWantReadError", J__SSL, Flags.EXCEPTION),
- SSLWantWriteError("SSLWantWriteError", J__SSL, Flags.EXCEPTION),
- SSLSyscallError("SSLSyscallError", J__SSL, Flags.EXCEPTION),
- SSLEOFError("SSLEOFError", J__SSL, Flags.EXCEPTION),
- SSLCertVerificationError("SSLCertVerificationError", J__SSL, Flags.EXCEPTION),
+ MultibyteCodec("MultibyteCodec", PythonObject, newBuilder().publishInModule("_multibytecodec").basetype().addDict().disallowInstantiation()),
+ MultibyteIncrementalEncoder("MultibyteIncrementalEncoder", PythonObject, newBuilder().publishInModule("_multibytecodec").basetype().addDict().slots(MultibyteIncrementalEncoderBuiltins.SLOTS)),
+ MultibyteIncrementalDecoder("MultibyteIncrementalDecoder", PythonObject, newBuilder().publishInModule("_multibytecodec").basetype().addDict().slots(MultibyteIncrementalDecoderBuiltins.SLOTS)),
+ MultibyteStreamReader("MultibyteStreamReader", PythonObject, newBuilder().publishInModule("_multibytecodec").basetype().addDict().slots(MultibyteStreamReaderBuiltins.SLOTS)),
+ MultibyteStreamWriter("MultibyteStreamWriter", PythonObject, newBuilder().publishInModule("_multibytecodec").basetype().addDict().slots(MultibyteStreamWriterBuiltins.SLOTS)),
- // todo: all OS errors
-
- ReferenceError("ReferenceError", J_BUILTINS, Flags.EXCEPTION),
- RuntimeError("RuntimeError", J_BUILTINS, Flags.EXCEPTION),
- NotImplementedError("NotImplementedError", J_BUILTINS, Flags.EXCEPTION),
- SyntaxError("SyntaxError", J_BUILTINS, Flags.EXCEPTION),
- IndentationError("IndentationError", J_BUILTINS, Flags.EXCEPTION),
- TabError("TabError", J_BUILTINS, Flags.EXCEPTION),
- SystemError("SystemError", J_BUILTINS, Flags.EXCEPTION),
- TypeError("TypeError", J_BUILTINS, Flags.EXCEPTION),
- ValueError("ValueError", J_BUILTINS, Flags.EXCEPTION),
- UnicodeError("UnicodeError", J_BUILTINS, Flags.EXCEPTION),
- UnicodeDecodeError("UnicodeDecodeError", J_BUILTINS, Flags.EXCEPTION),
- UnicodeEncodeError("UnicodeEncodeError", J_BUILTINS, Flags.EXCEPTION),
- UnicodeTranslateError("UnicodeTranslateError", J_BUILTINS, Flags.EXCEPTION),
- RecursionError("RecursionError", J_BUILTINS, Flags.EXCEPTION),
+ // contextvars
+ ContextVarsToken("Token", PythonObject, newBuilder().publishInModule(J__CONTEXTVARS).slots(TokenBuiltins.SLOTS)),
+ ContextVarsContext("Context", PythonObject, newBuilder().publishInModule(J__CONTEXTVARS).slots(ContextBuiltins.SLOTS)),
+ ContextVar("ContextVar", PythonObject, newBuilder().publishInModule(J__CONTEXTVARS).slots(ContextVarBuiltins.SLOTS)),
+ // CPython uses separate keys, values, items python types for the iterators.
+ ContextIterator("context_iterator", PythonObject, newBuilder().publishInModule(J__CONTEXTVARS).slots(ContextIteratorBuiltins.SLOTS)),
- IOUnsupportedOperation("UnsupportedOperation", "io", Flags.EXCEPTION),
+ Capsule("PyCapsule", PythonObject, newBuilder().basetype()),
- Empty("Empty", "_queue", Flags.EXCEPTION),
+ PTokenizerIter("TokenizerIter", PythonObject, newBuilder().publishInModule("_tokenize").basetype().slots(TokenizerIterBuiltins.SLOTS));
- UnsupportedMessage("UnsupportedMessage", J_POLYGLOT, Flags.EXCEPTION),
+ private static TypeBuilder newBuilder() {
+ return new TypeBuilder();
+ }
- // warnings
- Warning("Warning", J_BUILTINS, Flags.EXCEPTION),
- BytesWarning("BytesWarning", J_BUILTINS, Flags.EXCEPTION),
- DeprecationWarning("DeprecationWarning", J_BUILTINS, Flags.EXCEPTION),
- FutureWarning("FutureWarning", J_BUILTINS, Flags.EXCEPTION),
- ImportWarning("ImportWarning", J_BUILTINS, Flags.EXCEPTION),
- PendingDeprecationWarning("PendingDeprecationWarning", J_BUILTINS, Flags.EXCEPTION),
- ResourceWarning("ResourceWarning", J_BUILTINS, Flags.EXCEPTION),
- RuntimeWarning("RuntimeWarning", J_BUILTINS, Flags.EXCEPTION),
- SyntaxWarning("SyntaxWarning", J_BUILTINS, Flags.EXCEPTION),
- UnicodeWarning("UnicodeWarning", J_BUILTINS, Flags.EXCEPTION),
- UserWarning("UserWarning", J_BUILTINS, Flags.EXCEPTION),
- EncodingWarning("EncodingWarning", J_BUILTINS, Flags.EXCEPTION),
+ private static final class TypeBuilder {
+ private String publishInModule;
+ private String moduleName;
+ private boolean basetype;
+ private boolean addDict;
+ private boolean disallowInstantiation;
+ private TpSlots slots;
+ private String doc;
+
+ public TypeBuilder publishInModule(String publishInModule) {
+ this.publishInModule = publishInModule;
+ if (moduleName == null) {
+ this.moduleName = publishInModule;
+ }
+ return this;
+ }
- // contextvars
- ContextVarsToken("Token", J__CONTEXTVARS, Flags.PUBLIC_DERIVED_WODICT),
- ContextVarsContext("Context", J__CONTEXTVARS, Flags.PUBLIC_DERIVED_WODICT, CONTEXT_M_FLAGS, ContextBuiltins.SLOTS),
- ContextVar("ContextVar", J__CONTEXTVARS, Flags.PUBLIC_DERIVED_WODICT),
- // CPython uses separate keys, values, items python types for the iterators.
- ContextIterator("context_iterator", J__CONTEXTVARS, Flags.PUBLIC_DERIVED_WODICT),
+ public TypeBuilder moduleName(String moduleName) {
+ this.moduleName = moduleName;
+ return this;
+ }
- Capsule("PyCapsule"),
+ public TypeBuilder basetype() {
+ this.basetype = true;
+ return this;
+ }
- PTokenizerIter("TokenizerIter", "_tokenize"),
+ public TypeBuilder addDict() {
+ this.addDict = true;
+ return this;
+ }
- // A marker for @Builtin that is not a class. Must always come last.
- nil("nil");
+ public TypeBuilder disallowInstantiation() {
+ this.disallowInstantiation = true;
+ return this;
+ }
- private static class Flags {
+ public TypeBuilder slots(TpSlots slots) {
+ this.slots = slots;
+ return this;
+ }
- static final Flags EXCEPTION = new Flags(true, true, true);
- static final Flags PRIVATE_DERIVED_WDICT = new Flags(false, false, true);
- static final Flags PRIVATE_BASE_WDICT = new Flags(false, true, true);
- static final Flags PRIVATE_BASE_WODICT = new Flags(false, true, false);
- static final Flags PUBLIC_BASE_WDICT = new Flags(true, true, true);
- static final Flags PUBLIC_BASE_WODICT = new Flags(true, true, false);
- static final Flags PUBLIC_DERIVED_WODICT = new Flags(true, false, false);
- static final Flags PRIVATE_DERIVED_WODICT = new Flags(false, false, false);
+ public TypeBuilder slots(TpSlots slots1, TpSlots slots2) {
+ this.slots = slots1.copy().overrideIgnoreGroups(slots2).build();
+ return this;
+ }
- final boolean isPublic;
- final boolean isBaseType;
- final boolean isBuiltinWithDict;
+ public TypeBuilder slots(TpSlots slots1, TpSlots slots2, TpSlots slots3) {
+ this.slots = slots1.copy().overrideIgnoreGroups(slots2).overrideIgnoreGroups(slots3).build();
+ return this;
+ }
- Flags(boolean isPublic, boolean isBaseType, boolean isBuiltinWithDict) {
- this.isPublic = isPublic;
- this.isBaseType = isBaseType;
- this.isBuiltinWithDict = isBuiltinWithDict;
+ public TypeBuilder doc(String doc) {
+ this.doc = doc;
+ return this;
}
}
private final TruffleString name;
+ private final PythonBuiltinClassType base;
private final TruffleString publishInModule;
private final TruffleString moduleName;
// This is the name qualified by module used for printing. But the actual __qualname__ is just
@@ -595,122 +1238,55 @@ private static class Flags {
private final TruffleString printName;
private final boolean basetype;
private final boolean isBuiltinWithDict;
+ private final boolean disallowInstantiation;
+ private final TruffleString doc;
// initialized in static constructor
@CompilationFinal private PythonBuiltinClassType type;
- @CompilationFinal private PythonBuiltinClassType base;
@CompilationFinal private int weaklistoffset;
- /**
- * @see #redefinesSlot(SpecialMethodSlot)
- */
- private SpecialMethodSlot[] redefinedSlots;
-
- /**
- * Lookup cache for special slots defined in {@link SpecialMethodSlot}. Use
- * {@link SpecialMethodSlot} to access the values. Unlike the cache in
- * {@link com.oracle.graal.python.builtins.objects.type.PythonManagedClass}, this caches only
- * builtin context independent values, most notably instances of {@link BuiltinMethodDescriptor}
- * .
- */
- private Object[] specialMethodSlots;
-
/**
* The slots defined directly on the builtin class.
*/
private final TpSlots declaredSlots;
/**
- * The actual slots including slots inherited from base classes. The value is computed in the
- * static ctor.
+ * The actual slots including slots inherited from base classes
*/
- @CompilationFinal private TpSlots slots;
- private final long methodsFlags;
-
- PythonBuiltinClassType(String name, String module, Flags flags) {
- this(name, module, module, flags);
- }
-
- PythonBuiltinClassType(String name, String module, PythonBuiltinClassType base, Flags flags) {
- this(name, module, module, flags);
- this.base = base;
- }
-
- PythonBuiltinClassType(String name, String module, Flags flags, TpSlots slots) {
- this(name, module, module, flags, DEFAULT_M_FLAGS, slots);
- }
-
- PythonBuiltinClassType(String name, String module, Flags flags, long methodsFlags) {
- this(name, module, module, flags, methodsFlags, TpSlots.createEmpty());
- }
-
- PythonBuiltinClassType(String name, String module, Flags flags, long methodsFlags, TpSlots slots) {
- this(name, module, module, flags, methodsFlags, slots);
- }
-
- PythonBuiltinClassType(String name, String module, PythonBuiltinClassType base, Flags flags, long methodsFlags, TpSlots slots) {
- this(name, module, module, flags, methodsFlags, slots);
- this.base = base;
- }
-
- PythonBuiltinClassType(String name, String publishInModule, String moduleName, Flags flags) {
- this(name, publishInModule, moduleName, flags, DEFAULT_M_FLAGS, TpSlots.createEmpty());
- }
+ private final TpSlots slots;
- PythonBuiltinClassType(String name, String publishInModule, String moduleName, Flags flags, TpSlots slots) {
- this(name, publishInModule, moduleName, flags, DEFAULT_M_FLAGS, slots);
- }
-
- PythonBuiltinClassType(String name, String publishInModule, String moduleName, Flags flags, long methodsFlags, TpSlots declaredSlots) {
+ PythonBuiltinClassType(String name, PythonBuiltinClassType base, TypeBuilder builder) {
this.name = toTruffleStringUncached(name);
- this.publishInModule = toTruffleStringUncached(publishInModule);
- this.moduleName = flags.isPublic && moduleName != null ? toTruffleStringUncached(moduleName) : null;
- if (moduleName != null && moduleName != J_BUILTINS) {
- printName = toTruffleStringUncached(moduleName + "." + name);
+ this.base = base;
+ this.publishInModule = toTruffleStringUncached(builder.publishInModule);
+ this.moduleName = builder.moduleName != null ? toTruffleStringUncached(builder.moduleName) : null;
+ if (builder.moduleName != null && !J_BUILTINS.equals(builder.moduleName)) {
+ printName = toTruffleStringUncached(builder.moduleName + "." + name);
} else {
printName = this.name;
}
- this.basetype = flags.isBaseType;
- this.isBuiltinWithDict = flags.isBuiltinWithDict;
- this.methodsFlags = methodsFlags;
+ this.basetype = builder.basetype;
+ this.isBuiltinWithDict = builder.addDict;
this.weaklistoffset = -1;
- this.declaredSlots = declaredSlots;
- }
-
- PythonBuiltinClassType(String name, String module) {
- this(name, module, Flags.PUBLIC_BASE_WODICT);
- }
-
- PythonBuiltinClassType(String name, String module, TpSlots slots) {
- this(name, module, Flags.PUBLIC_BASE_WODICT, slots);
- }
-
- PythonBuiltinClassType(String name, String module, long methodsFlags) {
- this(name, module, Flags.PUBLIC_BASE_WODICT, methodsFlags);
- }
-
- PythonBuiltinClassType(String name, String module, long methodsFlags, TpSlots slots) {
- this(name, module, Flags.PUBLIC_BASE_WODICT, methodsFlags, slots);
- }
-
- PythonBuiltinClassType(String name, Flags flags) {
- this(name, null, flags);
- }
-
- PythonBuiltinClassType(String name, Flags flags, TpSlots slots) {
- this(name, null, flags, slots);
- }
-
- PythonBuiltinClassType(String name, Flags flags, long methodsFlags) {
- this(name, null, flags, methodsFlags);
- }
-
- PythonBuiltinClassType(String name, Flags flags, long methodsFlags, TpSlots slots) {
- this(name, null, flags, methodsFlags, slots);
- }
-
- PythonBuiltinClassType(String name) {
- this(name, null, Flags.PRIVATE_BASE_WODICT);
+ this.declaredSlots = builder.slots != null ? builder.slots : TpSlots.createEmpty();
+ boolean disallowInstantiation = builder.disallowInstantiation;
+ // logic from type_ready_set_new
+ // base.base == null is a roundabout way to check for base == object
+ if (declaredSlots.tp_new() == null && base.base == null) {
+ disallowInstantiation = true;
+ }
+ if (base == null) {
+ this.slots = declaredSlots;
+ } else {
+ var slotBuilder = base.slots.copy();
+ slotBuilder.overrideIgnoreGroups(declaredSlots);
+ if (disallowInstantiation) {
+ slotBuilder.set(TpSlots.TpSlotMeta.TP_NEW, null);
+ }
+ this.slots = slotBuilder.build();
+ }
+ this.disallowInstantiation = disallowInstantiation;
+ this.doc = toTruffleStringUncached(builder.doc);
}
public boolean isAcceptableBase() {
@@ -737,6 +1313,10 @@ public boolean isBuiltinWithDict() {
return isBuiltinWithDict;
}
+ public boolean disallowInstantiation() {
+ return disallowInstantiation;
+ }
+
public TruffleString getPublishInModule() {
return publishInModule;
}
@@ -745,11 +1325,8 @@ public TruffleString getModuleName() {
return moduleName;
}
- /**
- * Access the values using methods in {@link SpecialMethodSlot}.
- */
- public Object[] getSpecialMethodSlots() {
- return specialMethodSlots;
+ public TruffleString getDoc() {
+ return doc;
}
public TpSlots getSlots() {
@@ -760,38 +1337,10 @@ public TpSlots getDeclaredSlots() {
return declaredSlots;
}
- public void setSpecialMethodSlots(Object[] slots) {
- assert specialMethodSlots == null; // should be assigned only once per VM
- specialMethodSlots = slots;
- }
-
- public long getMethodsFlags() {
- return methodsFlags;
- }
-
public int getWeaklistoffset() {
return weaklistoffset;
}
- /**
- * Returns {@code true} if this method slot is redefined in Python code during initialization.
- * Values of such slots cannot be cached in {@link #specialMethodSlots}, because they are not
- * context independent.
- */
- public boolean redefinesSlot(SpecialMethodSlot slot) {
- if (redefinedSlots != null) {
- for (SpecialMethodSlot redefSlot : redefinedSlots) {
- if (redefSlot == slot) {
- return true;
- }
- }
- }
- if (base != null) {
- return base.redefinesSlot(slot);
- }
- return false;
- }
-
@Override
public String toString() {
CompilerAsserts.neverPartOfCompilation();
@@ -799,216 +1348,19 @@ public String toString() {
}
public final Shape getInstanceShape(PythonLanguage lang) {
- if (name == null) {
- throw CompilerDirectives.shouldNotReachHere("incorrect use of Python builtin type marker");
- }
return lang.getBuiltinTypeInstanceShape(this);
}
- @CompilationFinal(dimensions = 1) public static final PythonBuiltinClassType[] VALUES = Arrays.copyOf(values(), values().length - 1);
+ @CompilationFinal(dimensions = 1) public static final PythonBuiltinClassType[] VALUES = Arrays.copyOf(values(), values().length);
static {
- // fill the overridden slots
- SpecialMethodSlot[] repr = new SpecialMethodSlot[]{SpecialMethodSlot.Repr};
- SpecialMethodSlot[] reprAndNew = new SpecialMethodSlot[]{SpecialMethodSlot.Repr, SpecialMethodSlot.New};
-
- PythonModule.redefinedSlots = Super.redefinedSlots = repr;
- SyntaxError.redefinedSlots = new SpecialMethodSlot[]{SpecialMethodSlot.Str};
- UnicodeEncodeError.redefinedSlots = new SpecialMethodSlot[]{SpecialMethodSlot.Str};
- UnicodeDecodeError.redefinedSlots = new SpecialMethodSlot[]{SpecialMethodSlot.Str};
- UnicodeTranslateError.redefinedSlots = new SpecialMethodSlot[]{SpecialMethodSlot.Str};
- OSError.redefinedSlots = new SpecialMethodSlot[]{SpecialMethodSlot.Str};
- PStructUnpackIterator.redefinedSlots = new SpecialMethodSlot[]{SpecialMethodSlot.Next, SpecialMethodSlot.Iter, SpecialMethodSlot.LengthHint};
-
- // These slots actually contain context independent values, but they are initialized in
- // StructSequence to artificial PBuiltinFunctions with artificial builtin node factories,
- // which are different for each context. We'd have to turn those factories into singletons
- // to guarantee their identity across contexts. For the sake of simplicity, we just ignore
- // those slots for now.
- PStruct.type = PythonClass;
- PStructRusage.redefinedSlots = reprAndNew;
- PStructPasswd.redefinedSlots = reprAndNew;
- PUnameResult.redefinedSlots = reprAndNew;
- PUnraisableHookArgs.redefinedSlots = reprAndNew;
- PIntInfo.redefinedSlots = reprAndNew;
- PHashInfo.redefinedSlots = reprAndNew;
- PStructTime.redefinedSlots = reprAndNew;
- PProfilerEntry.redefinedSlots = reprAndNew;
- PProfilerSubentry.redefinedSlots = reprAndNew;
- PThreadInfo.redefinedSlots = reprAndNew;
- PStatResult.redefinedSlots = repr;
- PStatvfsResult.redefinedSlots = repr;
- PFloatInfo.redefinedSlots = reprAndNew;
- PVersionInfo.redefinedSlots = repr;
- PWindowsVersion.redefinedSlots = repr;
- PFlags.redefinedSlots = repr;
- PTerminalSize.redefinedSlots = reprAndNew;
-
PythonObject.type = PythonClass;
- PythonObject.base = null;
-
- PBuiltinMethod.base = PBuiltinFunctionOrMethod;
-
- Boolean.base = PInt;
-
- PBaseExceptionGroup.base = PBaseException;
- SystemExit.base = PBaseException;
- KeyboardInterrupt.base = PBaseException;
- GeneratorExit.base = PBaseException;
- Exception.base = PBaseException;
- StopIteration.base = Exception;
- StopAsyncIteration.base = Exception;
- ArithmeticError.base = Exception;
- FloatingPointError.base = ArithmeticError;
- OverflowError.base = ArithmeticError;
- ZeroDivisionError.base = ArithmeticError;
- AssertionError.base = Exception;
- AttributeError.base = Exception;
- BufferError.base = Exception;
- EOFError.base = Exception;
- ImportError.base = Exception;
- ModuleNotFoundError.base = ImportError;
- LookupError.base = Exception;
- IndexError.base = LookupError;
- KeyError.base = LookupError;
- MemoryError.base = Exception;
- NameError.base = Exception;
- UnboundLocalError.base = NameError;
- OSError.base = Exception;
- BlockingIOError.base = OSError;
- ChildProcessError.base = OSError;
- ConnectionError.base = OSError;
- BrokenPipeError.base = ConnectionError;
- ConnectionAbortedError.base = ConnectionError;
- ConnectionRefusedError.base = ConnectionError;
- ConnectionResetError.base = ConnectionError;
- FileExistsError.base = OSError;
- FileNotFoundError.base = OSError;
- InterruptedError.base = OSError;
- IsADirectoryError.base = OSError;
- NotADirectoryError.base = OSError;
- PermissionError.base = OSError;
- ProcessLookupError.base = OSError;
- TimeoutError.base = OSError;
- ZLibError.base = Exception;
- CSVError.base = Exception;
- LZMAError.base = Exception;
- SocketGAIError.base = OSError;
- SocketHError.base = OSError;
-
- SSLError.base = OSError;
- SSLZeroReturnError.base = SSLError;
- SSLWantReadError.base = SSLError;
- SSLWantWriteError.base = SSLError;
- SSLSyscallError.base = SSLError;
- SSLCertVerificationError.base = SSLError;
- SSLEOFError.base = SSLError;
-
- ReferenceError.base = Exception;
- RuntimeError.base = Exception;
- NotImplementedError.base = RuntimeError;
- SyntaxError.base = Exception;
- IndentationError.base = SyntaxError;
- TabError.base = IndentationError;
- SystemError.base = Exception;
- TypeError.base = Exception;
- ValueError.base = Exception;
- UnicodeError.base = ValueError;
- UnicodeDecodeError.base = UnicodeError;
- UnicodeEncodeError.base = UnicodeError;
- UnicodeTranslateError.base = UnicodeError;
- RecursionError.base = RuntimeError;
- StructError.base = Exception;
- BinasciiError.base = ValueError;
- BinasciiIncomplete.base = Exception;
- PickleError.base = Exception;
- PicklingError.base = PickleError;
- UnpicklingError.base = PickleError;
-
- // warnings
- Warning.base = Exception;
- BytesWarning.base = Warning;
- DeprecationWarning.base = Warning;
- FutureWarning.base = Warning;
- ImportWarning.base = Warning;
- PendingDeprecationWarning.base = Warning;
- ResourceWarning.base = Warning;
- RuntimeWarning.base = Warning;
- SyntaxWarning.base = Warning;
- UnicodeWarning.base = Warning;
- UserWarning.base = Warning;
- EncodingWarning.base = Warning;
-
- PStatResult.base = PTuple;
- PStatvfsResult.base = PTuple;
- PTerminalSize.base = PTuple;
- PUnameResult.base = PTuple;
- PStructTime.base = PTuple;
- PProfilerEntry.base = PTuple;
- PProfilerSubentry.base = PTuple;
- PStructPasswd.base = PTuple;
- PStructRusage.base = PTuple;
- PVersionInfo.base = PTuple;
- PWindowsVersion.base = PTuple;
- PFlags.base = PTuple;
- PFloatInfo.base = PTuple;
- PIntInfo.base = PTuple;
- PHashInfo.base = PTuple;
- PThreadInfo.base = PTuple;
- PUnraisableHookArgs.base = PTuple;
- PDefaultDict.base = PDict;
- POrderedDict.base = PDict;
- POrderedDictKeys.base = PDictKeysView;
- POrderedDictValues.base = PDictValuesView;
- POrderedDictItems.base = PDictItemsView;
-
- PArrayIterator.type = PythonClass;
- PSocket.type = PythonClass;
-
- // _io.UnsupportedOperation inherits from ValueError and OSError
- // done currently within IOModuleBuiltins class
- IOUnsupportedOperation.base = OSError;
-
- PRawIOBase.base = PIOBase;
- PTextIOBase.base = PIOBase;
- PBufferedIOBase.base = PIOBase;
- PBufferedReader.base = PBufferedIOBase;
- PBufferedWriter.base = PBufferedIOBase;
- PBufferedRWPair.base = PBufferedIOBase;
- PBufferedRandom.base = PBufferedIOBase;
- PBytesIO.base = PBufferedIOBase;
- PFileIO.base = PRawIOBase;
- PTextIOWrapper.base = PTextIOBase;
- PStringIO.base = PTextIOBase;
-
- // hashlib
- UnsupportedDigestmodError.base = ValueError;
- HashlibHashXof.base = HashlibHash;
-
- // _ctypes
- StgDict.base = PDict;
- PyCStructType.base = PythonClass;
- UnionType.base = PythonClass;
- PyCPointerType.base = PythonClass;
- PyCArrayType.base = PythonClass;
- PyCSimpleType.base = PythonClass;
- PyCFuncPtrType.base = PythonClass;
Structure.type = PyCStructType;
- Structure.base = PyCData;
Union.type = UnionType;
- Union.base = PyCData;
PyCPointer.type = PyCPointerType;
- PyCPointer.base = PyCData;
PyCArray.type = PyCArrayType;
- PyCArray.base = PyCData;
SimpleCData.type = PyCSimpleType;
- SimpleCData.base = PyCData;
PyCFuncPtr.type = PyCFuncPtrType;
- PyCFuncPtr.base = PyCData;
- ArgError.base = PBaseException;
-
- Empty.base = Exception;
- UnsupportedMessage.base = Exception;
boolean assertionsEnabled = false;
assert (assertionsEnabled = true) == true;
@@ -1017,11 +1369,6 @@ public final Shape getInstanceShape(PythonLanguage lang) {
// check uniqueness
assert set.add("" + type.moduleName + "." + type.name) : type.name();
- /* Initialize type.base (defaults to PythonObject unless that's us) */
- if (type.base == null && type != PythonObject) {
- type.base = PythonObject;
- }
-
/*
* Now the only way base can still be null is if type is PythonObject.
*/
@@ -1038,23 +1385,6 @@ public final Shape getInstanceShape(PythonLanguage lang) {
type.type = PythonClass;
}
}
-
- for (PythonBuiltinClassType t : values()) {
- initSlots(t);
- }
- }
-
- private static void initSlots(PythonBuiltinClassType type) {
- if (type.base == null) {
- type.slots = type.declaredSlots;
- return;
- }
- if (type.base.getSlots() == null) {
- initSlots(type.base);
- }
- var slots = type.base.slots.copy();
- slots.overrideIgnoreGroups(type.declaredSlots);
- type.slots = slots.build();
}
/**
@@ -1068,10 +1398,6 @@ private static void initSlots(PythonBuiltinClassType type) {
* {@link PythonBuiltins} classes annotated with {@link CoreFunctions#extendClasses()} that
* contains the {@link PythonBuiltinClassType}.
*
- * If a {@link PythonBuiltinClassType#declaredSlots} should be initialized to a merge of slots
- * from multiple {@link CoreFunctions}, use the helper methods, such as
- * {@link TpSlots#merge(TpSlots, TpSlots)}.
- *
* Note: this is all done so that the generated slots code is referenced only from the class
* that contains the {@link Slot} annotation and that we can initialize the
* {@link PythonBuiltinClassType#slots} in static ctor and bake the values into native-image
@@ -1121,11 +1447,11 @@ static boolean verifySlotsConventions(PythonBuiltins[] allBuiltins) {
assert getSlotsFieldValue(builtins.get(0)) == type.declaredSlots;
} else {
// Multiple @CoreFunctions => PBCT.declaredSlots must be equal to their merge
- Builder builder = TpSlots.newBuilder();
+ TpSlots.Builder builder = TpSlots.newBuilder();
for (PythonBuiltins builtin : builtins) {
TpSlots slots = getSlotsFieldValue(builtin);
if (slots != null) {
- builder.merge(slots);
+ builder.overrideIgnoreGroups(slots);
}
}
assert type.declaredSlots.areEqualTo(builder.build()) : String.format("%s.declaredSlots are not equal to the merge of SLOTS " +
@@ -1137,6 +1463,9 @@ static boolean verifySlotsConventions(PythonBuiltins[] allBuiltins) {
}
private static boolean hasSlotNodes(PythonBuiltins builtin) {
+ if (builtin.getClass().getAnnotation(HashNotImplemented.class) != null) {
+ return true;
+ }
for (Class> innerClass : builtin.getClass().getDeclaredClasses()) {
if (innerClass.getDeclaredAnnotationsByType(Slot.class).length > 0) {
return true;
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltins.java
index 89f6cc235b..5db6d64e43 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltins.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltins.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2017, 2024, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2025, Oracle and/or its affiliates.
* Copyright (c) 2013, Regents of the University of California
*
* All rights reserved.
@@ -26,86 +26,6 @@
package com.oracle.graal.python.builtins;
import static com.oracle.graal.python.nodes.SpecialAttributeNames.T___DOC__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___ABS__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___ADD__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___AITER__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___AND__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___ANEXT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___AWAIT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___BOOL__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___CALL__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___CONTAINS__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___DELATTR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___DELETE__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___DELITEM__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___DEL__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___DIVMOD__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___EQ__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___FLOAT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___FLOORDIV__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___GETATTRIBUTE__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___GETATTR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___GETITEM__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___GET__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___GE__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___GT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___HASH__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IADD__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IAND__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IFLOORDIV__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___ILSHIFT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IMATMUL__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IMOD__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IMUL__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___INDEX__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___INIT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___INT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___INVERT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IOR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IPOW__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IRSHIFT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___ISUB__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___ITER__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___ITRUEDIV__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___IXOR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___LEN__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___LE__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___LSHIFT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___LT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___MATMUL__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___MOD__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___MUL__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___NEG__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___NEW__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___NEXT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___NE__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___OR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___POS__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___POW__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RADD__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RAND__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RDIVMOD__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___REPR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RFLOORDIV__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RLSHIFT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RMATMUL__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RMOD__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RMUL__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___ROR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RPOW__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RRSHIFT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RSHIFT__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RSUB__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RTRUEDIV__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___RXOR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___SETATTR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___SETITEM__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___SET__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___STR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___SUB__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___TRUEDIV__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.J___XOR__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.T___NEW__;
import static com.oracle.graal.python.nodes.truffle.TruffleStringMigrationHelpers.assertNoJavaString;
import static com.oracle.graal.python.nodes.truffle.TruffleStringMigrationHelpers.ensureNoJavaString;
import static com.oracle.graal.python.util.PythonUtils.toTruffleStringUncached;
@@ -114,20 +34,20 @@
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.Set;
+import com.oracle.graal.python.PythonLanguage;
+import com.oracle.graal.python.builtins.modules.ImpModuleBuiltins.ExecBuiltin;
import com.oracle.graal.python.builtins.objects.PNone;
import com.oracle.graal.python.builtins.objects.function.PBuiltinFunction;
-import com.oracle.graal.python.builtins.objects.method.PBuiltinMethod;
import com.oracle.graal.python.builtins.objects.module.PythonModule;
import com.oracle.graal.python.builtins.objects.object.PythonObject;
import com.oracle.graal.python.builtins.objects.type.PythonBuiltinClass;
-import com.oracle.graal.python.nodes.PGuards;
import com.oracle.graal.python.nodes.function.BuiltinFunctionRootNode;
import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
-import com.oracle.graal.python.runtime.object.PythonObjectSlowPathFactory;
+import com.oracle.graal.python.runtime.object.PFactory;
import com.oracle.graal.python.util.BiConsumer;
import com.oracle.truffle.api.RootCallTarget;
+import com.oracle.truffle.api.TruffleLanguage.Env;
import com.oracle.truffle.api.dsl.NodeFactory;
import com.oracle.truffle.api.strings.TruffleString;
@@ -160,79 +80,47 @@ public void initialize(Python3Core core) {
initializeEachFactoryWith((factory, builtin) -> {
CoreFunctions annotation = getClass().getAnnotation(CoreFunctions.class);
final boolean declaresExplicitSelf;
- PythonBuiltinClassType constructsClass = builtin.constructsClass();
- if ((annotation.defineModule().length() > 0 || annotation.extendsModule().length() > 0) && constructsClass == PythonBuiltinClassType.nil) {
+ if ((annotation.defineModule().length() > 0 || annotation.extendsModule().length() > 0)) {
assert !builtin.isGetter();
assert !builtin.isSetter();
assert annotation.extendClasses().length == 0;
// for module functions, explicit self is false by default
declaresExplicitSelf = builtin.declaresExplicitSelf();
- } else if (builtin.constructsClass() != PythonBuiltinClassType.nil) {
- declaresExplicitSelf = false;
} else {
declaresExplicitSelf = true;
}
TruffleString tsName = toTruffleStringUncached(builtin.name());
- RootCallTarget callTarget = core.getLanguage().initBuiltinCallTarget(l -> new BuiltinFunctionRootNode(l, builtin, factory, declaresExplicitSelf), factory.getNodeClass(),
+ PythonLanguage language = core.getLanguage();
+ RootCallTarget callTarget = language.initBuiltinCallTarget(l -> new BuiltinFunctionRootNode(l, builtin, factory, declaresExplicitSelf), factory.getNodeClass(),
builtin.name());
Object builtinDoc = builtin.doc().isEmpty() ? PNone.NONE : toTruffleStringUncached(builtin.doc());
int flags = PBuiltinFunction.getFlags(builtin, callTarget);
- if (constructsClass != PythonBuiltinClassType.nil) {
- assert !builtin.isGetter() && !builtin.isSetter() && !builtin.isClassmethod() && !builtin.isStaticmethod();
- // we explicitly do not make these "staticmethods" here, since CPython also doesn't
- // for builtin types
- PBuiltinFunction newFunc = core.factory().createBuiltinFunction(T___NEW__, constructsClass, numDefaults(builtin), flags, callTarget);
- PBuiltinMethod newMethod = core.factory().createBuiltinMethod(constructsClass, newFunc);
- PythonBuiltinClass builtinClass = core.lookupType(constructsClass);
- builtinClass.setAttributeUnsafe(T___NEW__, newMethod);
- final Object currentBuiltinDoc = builtinClass.getAttribute(T___DOC__);
- if (PGuards.isPNone(currentBuiltinDoc)) {
- builtinClass.setAttribute(T___DOC__, builtinDoc);
- }
- } else {
- PBuiltinFunction function;
- if (isSlotMethod(builtin)) {
- // HACK: TODO: we should not see any slots here anymore once all are converted
- // to slots, then we can make the slot field in PBuiltinFunction final, for now,
- // we patch it in TpSlots#wrapBuiltinSlots
- function = core.factory().createWrapperDescriptor(tsName, null, numDefaults(builtin), flags, callTarget, null, null);
- } else {
- function = core.factory().createBuiltinFunction(tsName, null, numDefaults(builtin), flags, callTarget);
- }
- function.setAttribute(T___DOC__, builtinDoc);
- BoundBuiltinCallable> callable = function;
- if (builtin.isGetter() || builtin.isSetter()) {
- assert !builtin.isClassmethod() && !builtin.isStaticmethod();
- PBuiltinFunction get = builtin.isGetter() ? function : null;
- PBuiltinFunction set = builtin.isSetter() ? function : null;
- callable = core.factory().createGetSetDescriptor(get, set, tsName, null, builtin.allowsDelete());
- } else if (builtin.isClassmethod()) {
- assert !builtin.isStaticmethod();
- callable = core.factory().createBuiltinClassmethodFromCallableObj(function);
- } else if (builtin.isStaticmethod()) {
- callable = core.factory().createStaticmethodFromCallableObj(function);
- }
- builtinFunctions.put(toTruffleStringUncached(builtin.name()), callable);
+ PBuiltinFunction function = PFactory.createBuiltinFunction(language, tsName, null, numDefaults(builtin), flags, callTarget);
+ function.setAttribute(T___DOC__, builtinDoc);
+ BoundBuiltinCallable> callable = function;
+ if (builtin.isGetter() || builtin.isSetter()) {
+ assert !builtin.isClassmethod() && !builtin.isStaticmethod();
+ PBuiltinFunction get = builtin.isGetter() ? function : null;
+ PBuiltinFunction set = builtin.isSetter() ? function : null;
+ callable = PFactory.createGetSetDescriptor(language, get, set, tsName, null, builtin.allowsDelete());
+ } else if (builtin.isClassmethod()) {
+ assert !builtin.isStaticmethod();
+ callable = PFactory.createBuiltinClassmethodFromCallableObj(language, function);
+ } else if (builtin.isStaticmethod()) {
+ callable = PFactory.createStaticmethodFromCallableObj(language, function);
}
+ builtinFunctions.put(toTruffleStringUncached(builtin.name()), callable);
});
}
- // All methods that are really slots in CPython
- private static final Set SLOTS = Set.of(J___ABS__, J___ADD__, J___AITER__, J___AND__, J___ANEXT__, J___AWAIT__, J___BOOL__, J___CALL__, J___CONTAINS__, J___DELATTR__, J___DELETE__,
- J___DELITEM__, J___DEL__, J___DIVMOD__, J___EQ__, J___FLOAT__, J___FLOORDIV__, J___GETATTRIBUTE__, J___GETATTR__, J___GETITEM__, J___GET__, J___GE__, J___GT__, J___HASH__,
- J___IADD__, J___IAND__, J___IFLOORDIV__, J___ILSHIFT__, J___IMATMUL__, J___IMOD__, J___IMUL__, J___INDEX__, J___INIT__, J___INT__, J___INVERT__, J___IOR__, J___IPOW__,
- J___IRSHIFT__, J___ISUB__, J___ITER__, J___ITRUEDIV__, J___IXOR__, J___LEN__, J___LE__, J___LSHIFT__, J___LT__, J___MATMUL__, J___MOD__, J___MUL__, J___NEG__, J___NEW__,
- J___NEXT__, J___NE__, J___OR__, J___POS__, J___POW__, J___RADD__, J___RAND__, J___RDIVMOD__, J___REPR__, J___RFLOORDIV__, J___RLSHIFT__, J___RMATMUL__, J___RMOD__, J___RMUL__,
- J___ROR__, J___RPOW__, J___RRSHIFT__, J___RSHIFT__, J___RSUB__, J___RTRUEDIV__, J___RXOR__, J___SETATTR__, J___SETITEM__, J___SET__, J___STR__, J___SUB__, J___TRUEDIV__,
- J___XOR__);
-
- private static boolean isSlotMethod(Builtin builtin) {
- return builtin.name().startsWith("__") && SLOTS.contains(builtin.name());
- }
-
/**
* Run any actions that can only be run in the post-initialization step, that is, if we're
* actually going to start running rather than just pre-initializing.
+ *
+ * See {@link Python3Core#postInitialize(Env)} as postInitialize() is only run under some
+ * conditions. See also {@link ExecBuiltin}, tough that does not get called if the built-in
+ * module is actually shadowed by a frozen one, or if the built-in module is actually added to
+ * sys.modules during context initialization before the importlib exists, etc.
*/
public void postInitialize(@SuppressWarnings("unused") Python3Core core) {
// nothing to do by default
@@ -275,10 +163,18 @@ public static int numDefaults(Builtin builtin) {
return maxNumPosArgs - builtin.minNumOfPositionalArgs();
}
+ /**
+ * May only be used in {@link #initialize} or before. Use {@link PythonObject#setAttribute}
+ * instead in {@link #postInitialize}.
+ */
protected final void addBuiltinConstant(String name, Object value) {
addBuiltinConstant(toTruffleStringUncached(name), value);
}
+ /**
+ * May only be used in {@link #initialize} or before. Use {@link PythonObject#setAttribute}
+ * instead in {@link #postInitialize}.
+ */
protected final void addBuiltinConstant(TruffleString name, Object value) {
builtinConstants.put(name, ensureNoJavaString(value));
}
@@ -294,18 +190,18 @@ void addConstantsToModuleObject(PythonObject obj) {
}
}
- void addFunctionsToModuleObject(PythonObject obj, PythonObjectSlowPathFactory factory) {
- addFunctionsToModuleObject(builtinFunctions, obj, factory);
+ void addFunctionsToModuleObject(PythonObject obj, PythonLanguage language) {
+ addFunctionsToModuleObject(builtinFunctions, obj, language);
}
- static void addFunctionsToModuleObject(Map> builtinFunctions, PythonObject obj, PythonObjectSlowPathFactory factory) {
+ static void addFunctionsToModuleObject(Map> builtinFunctions, PythonObject obj, PythonLanguage language) {
+ assert obj instanceof PythonModule || obj instanceof PythonBuiltinClass : "unexpected object while adding builtins";
for (Entry> entry : builtinFunctions.entrySet()) {
Object value;
- assert obj instanceof PythonModule || obj instanceof PythonBuiltinClass : "unexpected object while adding builtins";
if (obj instanceof PythonModule) {
- value = factory.createBuiltinMethod(obj, (PBuiltinFunction) entry.getValue());
+ value = PFactory.createBuiltinMethod(language, obj, (PBuiltinFunction) entry.getValue());
} else {
- value = entry.getValue().boundToObject(((PythonBuiltinClass) obj).getType(), factory);
+ value = entry.getValue().boundToObject(((PythonBuiltinClass) obj).getType(), language);
}
obj.setAttribute(entry.getKey(), value);
}
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonOS.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonOS.java
index 67114eb762..338e50f1ab 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonOS.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonOS.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* The Universal Permissive License (UPL), Version 1.0
@@ -45,25 +45,31 @@
import com.oracle.truffle.api.strings.TruffleString;
public enum PythonOS {
- PLATFORM_JAVA("java"),
- PLATFORM_CYGWIN("cygwin"),
- PLATFORM_LINUX("linux"),
- PLATFORM_DARWIN("darwin"),
- PLATFORM_WIN32("win32"),
- PLATFORM_SUNOS("sunos"),
- PLATFORM_FREEBSD("freebsd"),
- PLATFORM_ANY(null);
+ PLATFORM_JAVA("java", "Java"),
+ PLATFORM_CYGWIN("cygwin", "CYGWIN"),
+ PLATFORM_LINUX("linux", "Linux"),
+ PLATFORM_DARWIN("darwin", "Darwin"),
+ PLATFORM_WIN32("win32", "Windows"),
+ PLATFORM_SUNOS("sunos", "SunOS"),
+ PLATFORM_FREEBSD("freebsd", "FreeBSD"),
+ PLATFORM_ANY(null, null);
private final TruffleString name;
+ private final TruffleString uname;
- PythonOS(String name) {
+ PythonOS(String name, String uname) {
this.name = toTruffleStringUncached(name);
+ this.uname = toTruffleStringUncached(uname);
}
public TruffleString getName() {
return name;
}
+ public TruffleString getUname() {
+ return uname;
+ }
+
private static final PythonOS current;
static {
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/AbcModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/AbcModuleBuiltins.java
index 18b4c9bb56..ac6be1a5ce 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/AbcModuleBuiltins.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/AbcModuleBuiltins.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* The Universal Permissive License (UPL), Version 1.0
@@ -58,10 +58,10 @@
import com.oracle.graal.python.builtins.objects.type.TypeNodes;
import com.oracle.graal.python.builtins.objects.type.TypeNodes.GetSubclassesAsArrayNode;
import com.oracle.graal.python.lib.PyObjectLookupAttr;
+import com.oracle.graal.python.lib.PyObjectSetAttr;
import com.oracle.graal.python.nodes.ErrorMessages;
import com.oracle.graal.python.nodes.HiddenAttr;
import com.oracle.graal.python.nodes.PRaiseNode;
-import com.oracle.graal.python.nodes.attributes.DeleteAttributeNode;
import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
import com.oracle.graal.python.nodes.function.builtins.PythonBinaryBuiltinNode;
import com.oracle.graal.python.nodes.function.builtins.PythonUnaryBuiltinNode;
@@ -70,7 +70,6 @@
import com.oracle.graal.python.runtime.PythonContext;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.dsl.Bind;
-import com.oracle.truffle.api.dsl.Cached;
import com.oracle.truffle.api.dsl.GenerateNodeFactory;
import com.oracle.truffle.api.dsl.NodeFactory;
import com.oracle.truffle.api.dsl.Specialization;
@@ -94,8 +93,7 @@ abstract static class AbcInitCollectionFlagsNode extends PythonUnaryBuiltinNode
@TruffleBoundary
@Specialization
static Object init(Object object,
- @Bind("this") Node inliningTarget,
- @Cached DeleteAttributeNode deleteAttributeNode) {
+ @Bind("this") Node inliningTarget) {
if (TypeNodes.IsTypeNode.executeUncached(object)) {
Object flags = PyObjectLookupAttr.executeUncached(object, ABC_TPFLAGS);
long val;
@@ -105,7 +103,7 @@ static Object init(Object object,
return PNone.NONE;
}
if ((val & COLLECTION_FLAGS) == COLLECTION_FLAGS) {
- throw PRaiseNode.raiseUncached(inliningTarget, TypeError, ErrorMessages.ABC_FLAGS_CANNOT_BE_SEQUENCE_AND_MAPPING);
+ throw PRaiseNode.raiseStatic(inliningTarget, TypeError, ErrorMessages.ABC_FLAGS_CANNOT_BE_SEQUENCE_AND_MAPPING);
}
long tpFlags = TypeNodes.GetTypeFlagsNode.getUncached().execute(object);
tpFlags |= (val & COLLECTION_FLAGS);
@@ -117,7 +115,7 @@ static Object init(Object object,
type = (PythonAbstractObject) object;
}
HiddenAttr.WriteNode.executeUncached(type, HiddenAttr.FLAGS, tpFlags);
- deleteAttributeNode.execute(null, inliningTarget, object, ABC_TPFLAGS);
+ PyObjectSetAttr.deleteUncached(object, ABC_TPFLAGS);
}
return PNone.NONE;
}
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ArrayModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ArrayModuleBuiltins.java
index ce713d1aa2..687b9202d3 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ArrayModuleBuiltins.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ArrayModuleBuiltins.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2017, 2023, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2025, Oracle and/or its affiliates.
* Copyright (c) 2013, Regents of the University of California
*
* All rights reserved.
@@ -27,75 +27,44 @@
import static com.oracle.graal.python.nodes.BuiltinNames.J_ARRAY;
import static com.oracle.graal.python.nodes.BuiltinNames.T_ARRAY;
-import static com.oracle.graal.python.nodes.ErrorMessages.S_TAKES_AT_LEAST_D_ARGUMENTS_D_GIVEN;
-import static com.oracle.graal.python.nodes.ErrorMessages.S_TAKES_AT_MOST_D_ARGUMENTS_D_GIVEN;
-import static com.oracle.graal.python.nodes.ErrorMessages.S_TAKES_NO_KEYWORD_ARGS;
import static com.oracle.graal.python.nodes.SpecialMethodNames.T_DECODE;
-import static com.oracle.graal.python.runtime.exception.PythonErrorType.MemoryError;
import static com.oracle.graal.python.runtime.exception.PythonErrorType.TypeError;
import static com.oracle.graal.python.runtime.exception.PythonErrorType.ValueError;
-import static com.oracle.graal.python.util.PythonUtils.TS_ENCODING;
import static com.oracle.graal.python.util.PythonUtils.tsLiteral;
import java.nio.ByteOrder;
import java.util.List;
+import com.oracle.graal.python.PythonLanguage;
import com.oracle.graal.python.annotations.ArgumentClinic;
import com.oracle.graal.python.builtins.Builtin;
import com.oracle.graal.python.builtins.CoreFunctions;
import com.oracle.graal.python.builtins.Python3Core;
import com.oracle.graal.python.builtins.PythonBuiltinClassType;
import com.oracle.graal.python.builtins.PythonBuiltins;
-import com.oracle.graal.python.builtins.objects.PNone;
import com.oracle.graal.python.builtins.objects.array.ArrayBuiltins;
-import com.oracle.graal.python.builtins.objects.array.ArrayNodes;
import com.oracle.graal.python.builtins.objects.array.PArray;
import com.oracle.graal.python.builtins.objects.array.PArray.MachineFormat;
import com.oracle.graal.python.builtins.objects.bytes.PBytes;
-import com.oracle.graal.python.builtins.objects.bytes.PBytesLike;
-import com.oracle.graal.python.builtins.objects.common.SequenceNodes;
-import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodes;
-import com.oracle.graal.python.builtins.objects.function.PKeyword;
import com.oracle.graal.python.builtins.objects.module.PythonModule;
-import com.oracle.graal.python.builtins.objects.range.PIntRange;
-import com.oracle.graal.python.builtins.objects.str.StringNodes.CastToTruffleStringCheckedNode;
-import com.oracle.graal.python.lib.GetNextNode;
+import com.oracle.graal.python.builtins.objects.type.TypeNodes;
import com.oracle.graal.python.lib.PyObjectCallMethodObjArgs;
-import com.oracle.graal.python.lib.PyObjectGetIter;
import com.oracle.graal.python.nodes.ErrorMessages;
-import com.oracle.graal.python.nodes.PGuards;
import com.oracle.graal.python.nodes.PRaiseNode;
import com.oracle.graal.python.nodes.classes.IsSubtypeNode;
import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
import com.oracle.graal.python.nodes.function.builtins.PythonClinicBuiltinNode;
-import com.oracle.graal.python.nodes.function.builtins.PythonVarargsBuiltinNode;
import com.oracle.graal.python.nodes.function.builtins.clinic.ArgumentClinicProvider;
-import com.oracle.graal.python.nodes.object.BuiltinClassProfiles.IsBuiltinClassExactProfile;
-import com.oracle.graal.python.nodes.object.BuiltinClassProfiles.IsBuiltinObjectProfile;
-import com.oracle.graal.python.nodes.util.SplitArgsNode;
-import com.oracle.graal.python.runtime.exception.PException;
-import com.oracle.graal.python.runtime.object.PythonObjectFactory;
-import com.oracle.graal.python.runtime.sequence.PSequence;
-import com.oracle.graal.python.runtime.sequence.storage.SequenceStorage;
+import com.oracle.graal.python.runtime.object.PFactory;
import com.oracle.graal.python.util.BufferFormat;
-import com.oracle.graal.python.util.OverflowException;
-import com.oracle.graal.python.util.PythonUtils;
-import com.oracle.truffle.api.CompilerDirectives;
-import com.oracle.truffle.api.HostCompilerDirectives.InliningCutoff;
import com.oracle.truffle.api.dsl.Bind;
import com.oracle.truffle.api.dsl.Cached;
import com.oracle.truffle.api.dsl.Cached.Exclusive;
-import com.oracle.truffle.api.dsl.Cached.Shared;
-import com.oracle.truffle.api.dsl.Fallback;
-import com.oracle.truffle.api.dsl.GenerateCached;
-import com.oracle.truffle.api.dsl.GenerateInline;
import com.oracle.truffle.api.dsl.GenerateNodeFactory;
-import com.oracle.truffle.api.dsl.ImportStatic;
import com.oracle.truffle.api.dsl.NodeFactory;
import com.oracle.truffle.api.dsl.Specialization;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.nodes.Node;
-import com.oracle.truffle.api.profiles.InlinedConditionProfile;
import com.oracle.truffle.api.profiles.ValueProfile;
import com.oracle.truffle.api.strings.TruffleString;
@@ -115,225 +84,6 @@ public void postInitialize(Python3Core core) {
arrayModule.setAttribute(tsLiteral("typecodes"), tsLiteral("bBuhHiIlLqQfd"));
}
- // array.array(typecode[, initializer])
- @Builtin(name = J_ARRAY, minNumOfPositionalArgs = 1, constructsClass = PythonBuiltinClassType.PArray, takesVarArgs = true, takesVarKeywordArgs = true, declaresExplicitSelf = true)
- @GenerateNodeFactory
- abstract static class ArrayNode extends PythonVarargsBuiltinNode {
- @Child private SplitArgsNode splitArgsNode;
-
- @Specialization(guards = "args.length == 1 || args.length == 2")
- static Object array2(VirtualFrame frame, Object cls, Object[] args, PKeyword[] kwargs,
- @Bind("this") Node inliningTarget,
- @Cached InlinedConditionProfile hasInitializerProfile,
- @Cached IsBuiltinClassExactProfile isNotSubtypeProfile,
- @Cached CastToTruffleStringCheckedNode cast,
- @Cached ArrayNodeInternal arrayNodeInternal,
- @Cached PRaiseNode.Lazy raise) {
- if (isNotSubtypeProfile.profileClass(inliningTarget, cls, PythonBuiltinClassType.PArray)) {
- if (kwargs.length != 0) {
- throw raise.get(inliningTarget).raise(TypeError, S_TAKES_NO_KEYWORD_ARGS, "array.array()");
- }
- }
- Object initializer = hasInitializerProfile.profile(inliningTarget, args.length == 2) ? args[1] : PNone.NO_VALUE;
- return arrayNodeInternal.execute(frame, inliningTarget, cls, cast.cast(inliningTarget, args[0], ErrorMessages.ARG_1_MUST_BE_UNICODE_NOT_P, args[0]), initializer);
- }
-
- @Fallback
- @SuppressWarnings("unused")
- Object error(Object cls, Object[] args, PKeyword[] kwargs) {
- if (args.length < 2) {
- throw raise(TypeError, S_TAKES_AT_LEAST_D_ARGUMENTS_D_GIVEN, T_ARRAY, 2, args.length);
- } else {
- throw raise(TypeError, S_TAKES_AT_MOST_D_ARGUMENTS_D_GIVEN, T_ARRAY, 3, args.length);
- }
- }
-
- @Override
- public final Object varArgExecute(VirtualFrame frame, @SuppressWarnings("unused") Object self, Object[] arguments, PKeyword[] keywords) throws VarargsBuiltinDirectInvocationNotSupported {
- if (splitArgsNode == null) {
- CompilerDirectives.transferToInterpreterAndInvalidate();
- splitArgsNode = insert(SplitArgsNode.create());
- }
- return execute(frame, arguments[0], splitArgsNode.executeCached(arguments), keywords);
- }
-
- // multiple non-inlined specializations share nodes
- @SuppressWarnings("truffle-interpreted-performance")
- @ImportStatic(PGuards.class)
- @GenerateInline
- @GenerateCached(false)
- abstract static class ArrayNodeInternal extends Node {
-
- public abstract PArray execute(VirtualFrame frame, Node inliningTarget, Object cls, TruffleString typeCode, Object initializer);
-
- @Specialization(guards = "isNoValue(initializer)")
- static PArray array(Node inliningTarget, Object cls, TruffleString typeCode, @SuppressWarnings("unused") PNone initializer,
- @Shared @Cached GetFormatCheckedNode getFormatCheckedNode,
- @Shared @Cached(inline = false) PythonObjectFactory factory) {
- BufferFormat format = getFormatCheckedNode.execute(inliningTarget, typeCode);
- return factory.createArray(cls, typeCode, format);
- }
-
- @Specialization
- @InliningCutoff
- static PArray arrayWithRangeInitializer(Node inliningTarget, Object cls, TruffleString typeCode, PIntRange range,
- @Shared @Cached GetFormatCheckedNode getFormatCheckedNode,
- @Shared @Cached(inline = false) PythonObjectFactory factory,
- @Exclusive @Cached ArrayNodes.PutValueNode putValueNode) {
- BufferFormat format = getFormatCheckedNode.execute(inliningTarget, typeCode);
- PArray array;
- try {
- array = factory.createArray(cls, typeCode, format, range.getIntLength());
- } catch (OverflowException e) {
- CompilerDirectives.transferToInterpreterAndInvalidate();
- throw PRaiseNode.raiseUncached(inliningTarget, MemoryError);
- }
-
- int start = range.getIntStart();
- int step = range.getIntStep();
- int len = range.getIntLength();
-
- for (int index = 0, value = start; index < len; index++, value += step) {
- putValueNode.execute(null, inliningTarget, array, index, value);
- }
-
- return array;
- }
-
- @Specialization
- static PArray arrayWithBytesInitializer(VirtualFrame frame, Node inliningTarget, Object cls, TruffleString typeCode, PBytesLike bytes,
- @Shared @Cached GetFormatCheckedNode getFormatCheckedNode,
- @Shared @Cached(inline = false) PythonObjectFactory factory,
- @Cached(inline = false) ArrayBuiltins.FromBytesNode fromBytesNode) {
- BufferFormat format = getFormatCheckedNode.execute(inliningTarget, typeCode);
- PArray array = factory.createArray(cls, typeCode, format);
- fromBytesNode.executeWithoutClinic(frame, array, bytes);
- return array;
- }
-
- @Specialization(guards = "isString(initializer)")
- @InliningCutoff
- static PArray arrayWithStringInitializer(VirtualFrame frame, Node inliningTarget, Object cls, TruffleString typeCode, Object initializer,
- @Shared @Cached GetFormatCheckedNode getFormatCheckedNode,
- @Shared @Cached(inline = false) PythonObjectFactory factory,
- @Cached(inline = false) ArrayBuiltins.FromUnicodeNode fromUnicodeNode,
- @Cached PRaiseNode.Lazy raise) {
- BufferFormat format = getFormatCheckedNode.execute(inliningTarget, typeCode);
- if (format != BufferFormat.UNICODE) {
- throw raise.get(inliningTarget).raise(TypeError, ErrorMessages.CANNOT_USE_STR_TO_INITIALIZE_ARRAY, typeCode);
- }
- PArray array = factory.createArray(cls, typeCode, format);
- fromUnicodeNode.execute(frame, array, initializer);
- return array;
- }
-
- @Specialization
- @InliningCutoff
- static PArray arrayArrayInitializer(VirtualFrame frame, Node inliningTarget, Object cls, TruffleString typeCode, PArray initializer,
- @Shared @Cached GetFormatCheckedNode getFormatCheckedNode,
- @Shared @Cached(inline = false) PythonObjectFactory factory,
- @Exclusive @Cached ArrayNodes.PutValueNode putValueNode,
- @Cached ArrayNodes.GetValueNode getValueNode) {
- BufferFormat format = getFormatCheckedNode.execute(inliningTarget, typeCode);
- try {
- int length = initializer.getLength();
- PArray array = factory.createArray(cls, typeCode, format, length);
- for (int i = 0; i < length; i++) {
- putValueNode.execute(frame, inliningTarget, array, i, getValueNode.execute(inliningTarget, initializer, i));
- }
- return array;
- } catch (OverflowException e) {
- CompilerDirectives.transferToInterpreterAndInvalidate();
- throw PRaiseNode.raiseUncached(inliningTarget, MemoryError);
- }
- }
-
- @Specialization(guards = "!isBytes(initializer)")
- @InliningCutoff
- static PArray arraySequenceInitializer(VirtualFrame frame, Node inliningTarget, Object cls, TruffleString typeCode, PSequence initializer,
- @Shared @Cached GetFormatCheckedNode getFormatCheckedNode,
- @Shared @Cached(inline = false) PythonObjectFactory factory,
- @Exclusive @Cached ArrayNodes.PutValueNode putValueNode,
- @Cached SequenceNodes.GetSequenceStorageNode getSequenceStorageNode,
- @Cached SequenceStorageNodes.GetItemScalarNode getItemNode) {
- BufferFormat format = getFormatCheckedNode.execute(inliningTarget, typeCode);
- SequenceStorage storage = getSequenceStorageNode.execute(inliningTarget, initializer);
- int length = storage.length();
- try {
- PArray array = factory.createArray(cls, typeCode, format, length);
- for (int i = 0; i < length; i++) {
- putValueNode.execute(frame, inliningTarget, array, i, getItemNode.execute(inliningTarget, storage, i));
- }
- return array;
- } catch (OverflowException e) {
- CompilerDirectives.transferToInterpreterAndInvalidate();
- throw PRaiseNode.raiseUncached(inliningTarget, MemoryError);
- }
- }
-
- @Specialization(guards = {"!isBytes(initializer)", "!isString(initializer)", "!isPSequence(initializer)"})
- @InliningCutoff
- static PArray arrayIteratorInitializer(VirtualFrame frame, Node inliningTarget, Object cls, TruffleString typeCode, Object initializer,
- @Cached PyObjectGetIter getIter,
- @Shared @Cached GetFormatCheckedNode getFormatCheckedNode,
- @Shared @Cached(inline = false) PythonObjectFactory factory,
- @Exclusive @Cached ArrayNodes.PutValueNode putValueNode,
- @Cached(inline = false) GetNextNode nextNode,
- @Cached IsBuiltinObjectProfile errorProfile,
- @Cached ArrayNodes.SetLengthNode setLengthNode,
- @Cached ArrayNodes.EnsureCapacityNode ensureCapacityNode) {
- Object iter = getIter.execute(frame, inliningTarget, initializer);
-
- BufferFormat format = getFormatCheckedNode.execute(inliningTarget, typeCode);
- PArray array = factory.createArray(cls, typeCode, format);
-
- int length = 0;
- while (true) {
- Object nextValue;
- try {
- nextValue = nextNode.execute(frame, iter);
- } catch (PException e) {
- e.expectStopIteration(inliningTarget, errorProfile);
- break;
- }
- try {
- length = PythonUtils.addExact(length, 1);
- ensureCapacityNode.execute(inliningTarget, array, length);
- } catch (OverflowException e) {
- CompilerDirectives.transferToInterpreterAndInvalidate();
- throw PRaiseNode.raiseUncached(inliningTarget, MemoryError);
- }
- putValueNode.execute(frame, inliningTarget, array, length - 1, nextValue);
- }
-
- setLengthNode.execute(inliningTarget, array, length);
- return array;
- }
-
- @GenerateInline
- @GenerateCached(false)
- abstract static class GetFormatCheckedNode extends Node {
- abstract BufferFormat execute(Node inliningTarget, TruffleString typeCode);
-
- @Specialization
- static BufferFormat get(Node inliningTarget, TruffleString typeCode,
- @Cached(inline = false) TruffleString.CodePointLengthNode lengthNode,
- @Cached(inline = false) TruffleString.CodePointAtIndexNode atIndexNode,
- @Cached PRaiseNode.Lazy raise,
- @Cached(value = "createIdentityProfile()", inline = false) ValueProfile valueProfile) {
- if (lengthNode.execute(typeCode, TS_ENCODING) != 1) {
- throw raise.get(inliningTarget).raise(TypeError, ErrorMessages.ARRAY_ARG_1_MUST_BE_UNICODE);
- }
- BufferFormat format = BufferFormat.forArray(typeCode, lengthNode, atIndexNode);
- if (format == null) {
- throw raise.get(inliningTarget).raise(ValueError, ErrorMessages.BAD_TYPECODE);
- }
- return valueProfile.profile(format);
- }
- }
- }
- }
-
@Builtin(name = "_array_reconstructor", minNumOfPositionalArgs = 4, numOfPositionalOnlyArgs = 4, parameterNames = {"arrayType", "typeCode", "mformatCode", "items"})
@ArgumentClinic(name = "typeCode", conversion = ArgumentClinic.ClinicConversion.TString)
@ArgumentClinic(name = "mformatCode", conversion = ArgumentClinic.ClinicConversion.Index)
@@ -349,18 +99,20 @@ static Object reconstructCached(VirtualFrame frame, Object arrayType, TruffleStr
@Exclusive @Cached PyObjectCallMethodObjArgs callDecode,
@Exclusive @Cached ArrayBuiltins.FromBytesNode fromBytesNode,
@Exclusive @Cached ArrayBuiltins.FromUnicodeNode fromUnicodeNode,
+ @Exclusive @Cached TypeNodes.IsTypeNode isTypeNode,
@Exclusive @Cached IsSubtypeNode isSubtypeNode,
@Exclusive @Cached ArrayBuiltins.ByteSwapNode byteSwapNode,
@Exclusive @Cached TruffleString.CodePointLengthNode lengthNode,
@Exclusive @Cached TruffleString.CodePointAtIndexNode atIndexNode,
- @Exclusive @Cached PythonObjectFactory factory,
- @Exclusive @Cached PRaiseNode.Lazy raiseNode) {
+ @Exclusive @Cached TypeNodes.GetInstanceShape getInstanceShape,
+ @Exclusive @Cached PRaiseNode raiseNode) {
BufferFormat format = BufferFormat.forArray(typeCode, lengthNode, atIndexNode);
if (format == null) {
- throw raiseNode.get(inliningTarget).raise(ValueError, ErrorMessages.BAD_TYPECODE);
+ throw raiseNode.raise(inliningTarget, ValueError, ErrorMessages.BAD_TYPECODE);
}
- return doReconstruct(frame, inliningTarget, arrayType, typeCode, cachedCode, bytes, callDecode, fromBytesNode, fromUnicodeNode, isSubtypeNode, byteSwapNode, formatProfile.profile(format),
- factory, raiseNode);
+ return doReconstruct(frame, inliningTarget, arrayType, typeCode, cachedCode, bytes, callDecode, fromBytesNode, fromUnicodeNode, isTypeNode, isSubtypeNode, byteSwapNode,
+ formatProfile.profile(format),
+ getInstanceShape, raiseNode);
}
@Specialization(replaces = "reconstructCached")
@@ -369,35 +121,41 @@ static Object reconstruct(VirtualFrame frame, Object arrayType, TruffleString ty
@Exclusive @Cached PyObjectCallMethodObjArgs callDecode,
@Exclusive @Cached ArrayBuiltins.FromBytesNode fromBytesNode,
@Exclusive @Cached ArrayBuiltins.FromUnicodeNode fromUnicodeNode,
+ @Exclusive @Cached TypeNodes.IsTypeNode isTypeNode,
@Exclusive @Cached IsSubtypeNode isSubtypeNode,
@Exclusive @Cached ArrayBuiltins.ByteSwapNode byteSwapNode,
@Exclusive @Cached TruffleString.CodePointLengthNode lengthNode,
@Exclusive @Cached TruffleString.CodePointAtIndexNode atIndexNode,
- @Exclusive @Cached PythonObjectFactory factory,
- @Exclusive @Cached PRaiseNode.Lazy raiseNode) {
+ @Exclusive @Cached TypeNodes.GetInstanceShape getInstanceShape,
+ @Exclusive @Cached PRaiseNode raiseNode) {
BufferFormat format = BufferFormat.forArray(typeCode, lengthNode, atIndexNode);
if (format == null) {
- throw raiseNode.get(inliningTarget).raise(ValueError, ErrorMessages.BAD_TYPECODE);
+ throw raiseNode.raise(inliningTarget, ValueError, ErrorMessages.BAD_TYPECODE);
}
- return doReconstruct(frame, inliningTarget, arrayType, typeCode, mformatCode, bytes, callDecode, fromBytesNode, fromUnicodeNode, isSubtypeNode, byteSwapNode, format, factory, raiseNode);
+ return doReconstruct(frame, inliningTarget, arrayType, typeCode, mformatCode, bytes, callDecode, fromBytesNode, fromUnicodeNode, isTypeNode, isSubtypeNode, byteSwapNode, format,
+ getInstanceShape,
+ raiseNode);
}
private static Object doReconstruct(VirtualFrame frame, Node inliningTarget, Object arrayType, TruffleString typeCode, int mformatCode, PBytes bytes, PyObjectCallMethodObjArgs callDecode,
- ArrayBuiltins.FromBytesNode fromBytesNode, ArrayBuiltins.FromUnicodeNode fromUnicodeNode, IsSubtypeNode isSubtypeNode,
+ ArrayBuiltins.FromBytesNode fromBytesNode, ArrayBuiltins.FromUnicodeNode fromUnicodeNode, TypeNodes.IsTypeNode isTypeNode, IsSubtypeNode isSubtypeNode,
ArrayBuiltins.ByteSwapNode byteSwapNode, BufferFormat format,
- PythonObjectFactory factory, PRaiseNode.Lazy raiseNode) {
- if (!isSubtypeNode.execute(frame, arrayType, PythonBuiltinClassType.PArray)) {
- throw raiseNode.get(inliningTarget).raise(TypeError, ErrorMessages.N_NOT_SUBTYPE_OF_ARRAY, arrayType);
+ TypeNodes.GetInstanceShape getInstanceShape, PRaiseNode raiseNode) {
+ if (!isTypeNode.execute(inliningTarget, arrayType)) {
+ throw raiseNode.raise(inliningTarget, TypeError, ErrorMessages.FIRST_ARGUMENT_MUST_BE_A_TYPE_OBJECT_NOT_P, arrayType);
+ }
+ if (!isSubtypeNode.execute(arrayType, PythonBuiltinClassType.PArray)) {
+ throw raiseNode.raise(inliningTarget, TypeError, ErrorMessages.N_NOT_SUBTYPE_OF_ARRAY, arrayType);
}
MachineFormat machineFormat = MachineFormat.fromCode(mformatCode);
if (machineFormat != null) {
PArray array;
if (machineFormat == MachineFormat.forFormat(format)) {
- array = factory.createArray(arrayType, typeCode, machineFormat.format);
+ array = PFactory.createArray(PythonLanguage.get(inliningTarget), arrayType, getInstanceShape.execute(arrayType), typeCode, machineFormat.format);
fromBytesNode.executeWithoutClinic(frame, array, bytes);
} else {
TruffleString newTypeCode = machineFormat.format == format ? typeCode : machineFormat.format.baseTypeCode;
- array = factory.createArray(arrayType, newTypeCode, machineFormat.format);
+ array = PFactory.createArray(PythonLanguage.get(inliningTarget), arrayType, getInstanceShape.execute(arrayType), newTypeCode, machineFormat.format);
if (machineFormat.unicodeEncoding != null) {
Object decoded = callDecode.execute(frame, inliningTarget, bytes, T_DECODE, machineFormat.unicodeEncoding);
fromUnicodeNode.execute(frame, array, decoded);
@@ -410,15 +168,15 @@ private static Object doReconstruct(VirtualFrame frame, Node inliningTarget, Obj
}
return array;
} else {
- throw raiseNode.get(inliningTarget).raise(ValueError, ErrorMessages.THIRD_ARG_MUST_BE_A_VALID_MACHINE_CODE_FMT);
+ throw raiseNode.raise(inliningTarget, ValueError, ErrorMessages.THIRD_ARG_MUST_BE_A_VALID_MACHINE_CODE_FMT);
}
}
@Specialization(guards = "!isPBytes(value)")
@SuppressWarnings("unused")
static Object error(Object arrayType, TruffleString typeCode, int mformatCode, Object value,
- @Cached PRaiseNode raiseNode) {
- throw raiseNode.raise(TypeError, ErrorMessages.FOURTH_ARG_SHOULD_BE_BYTES, value);
+ @Bind("this") Node inliningTarget) {
+ throw PRaiseNode.raiseStatic(inliningTarget, TypeError, ErrorMessages.FOURTH_ARG_SHOULD_BE_BYTES, value);
}
protected static boolean isPBytes(Object obj) {
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/AsyncioModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/AsyncioModuleBuiltins.java
index 86f6cdf903..c6a9900c1c 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/AsyncioModuleBuiltins.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/AsyncioModuleBuiltins.java
@@ -70,7 +70,7 @@
import com.oracle.graal.python.nodes.function.builtins.PythonUnaryBuiltinNode;
import com.oracle.graal.python.nodes.statement.AbstractImportNode;
import com.oracle.graal.python.runtime.PythonContext;
-import com.oracle.graal.python.runtime.object.PythonObjectSlowPathFactory;
+import com.oracle.graal.python.runtime.object.PFactory;
import com.oracle.graal.python.util.PythonUtils;
import com.oracle.truffle.api.dsl.Bind;
import com.oracle.truffle.api.dsl.Cached;
@@ -99,7 +99,7 @@ static Object getCurrentLoop(
@Cached PRaiseNode raise) {
Object eventLoop = context.getThreadState(context.getLanguage(inliningTarget)).getRunningEventLoop();
if (eventLoop == null) {
- throw raise.raise(PythonBuiltinClassType.RuntimeError, ErrorMessages.NO_RUNNING_EVENT_LOOP);
+ throw raise.raise(inliningTarget, PythonBuiltinClassType.RuntimeError, ErrorMessages.NO_RUNNING_EVENT_LOOP);
} else {
return eventLoop;
}
@@ -189,7 +189,7 @@ public Object enterTask(VirtualFrame frame, PythonModule self, Object loop, Obje
if (item == null) {
set.execute(frame, inliningTarget, dict, loop, task);
} else {
- throw raise.raise(PythonBuiltinClassType.RuntimeError, ErrorMessages.CANT_ENTER_TASK_ALREADY_RUNNING, task, item);
+ throw raise.raise(inliningTarget, PythonBuiltinClassType.RuntimeError, ErrorMessages.CANT_ENTER_TASK_ALREADY_RUNNING, task, item);
}
return PNone.NONE;
}
@@ -210,7 +210,7 @@ public Object leaveTask(VirtualFrame frame, PythonModule self, Object loop, Obje
item = PNone.NONE;
}
if (item != task) {
- throw raise.raise(PythonBuiltinClassType.RuntimeError, ErrorMessages.TASK_NOT_ENTERED, task, item);
+ throw raise.raise(inliningTarget, PythonBuiltinClassType.RuntimeError, ErrorMessages.TASK_NOT_ENTERED, task, item);
}
del.execute(frame, inliningTarget, dict, loop);
return PNone.NONE;
@@ -253,9 +253,8 @@ public Object unregisterTask(VirtualFrame frame, PythonModule self, Object task,
@Override
public void postInitialize(Python3Core core) {
- PythonObjectSlowPathFactory factory = core.factory();
PythonModule self = core.lookupBuiltinModule(T__ASYNCIO);
- self.setAttribute(CURRENT_TASKS_ATTR, factory.createDict());
+ self.setAttribute(CURRENT_TASKS_ATTR, PFactory.createDict(core.getLanguage()));
Object weakref = AbstractImportNode.importModule(WEAKREF);
Object weakSetCls = PyObjectGetAttr.executeUncached(weakref, WEAKSET);
Object weakSet = CallNode.executeUncached(weakSetCls);
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BinasciiModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BinasciiModuleBuiltins.java
index e4f0b202a0..aae17200d2 100644
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BinasciiModuleBuiltins.java
+++ b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BinasciiModuleBuiltins.java
@@ -54,6 +54,7 @@
import java.util.Base64;
import java.util.List;
+import com.oracle.graal.python.PythonLanguage;
import com.oracle.graal.python.annotations.ArgumentClinic;
import com.oracle.graal.python.annotations.ClinicConverterFactory;
import com.oracle.graal.python.builtins.Builtin;
@@ -76,7 +77,7 @@
import com.oracle.graal.python.nodes.util.CastToTruffleStringNode;
import com.oracle.graal.python.runtime.IndirectCallData;
import com.oracle.graal.python.runtime.PythonContext;
-import com.oracle.graal.python.runtime.object.PythonObjectFactory;
+import com.oracle.graal.python.runtime.object.PFactory;
import com.oracle.graal.python.runtime.sequence.storage.ByteSequenceStorage;
import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
@@ -153,9 +154,9 @@ static Object asciiString(TruffleString value,
@Specialization(guards = "!isAscii(value, getCodeRangeNode)")
static Object nonAsciiString(@SuppressWarnings("unused") TruffleString value,
- @Shared("getCodeRange") @Cached @SuppressWarnings("unused") TruffleString.GetCodeRangeNode getCodeRangeNode,
- @Shared @Cached PRaiseNode raiseNode) {
- throw raiseNode.raise(ValueError, ErrorMessages.STRING_ARG_SHOULD_CONTAIN_ONLY_ASCII);
+ @Bind("this") Node inliningTarget,
+ @Shared("getCodeRange") @Cached @SuppressWarnings("unused") TruffleString.GetCodeRangeNode getCodeRangeNode) {
+ throw PRaiseNode.raiseStatic(inliningTarget, ValueError, ErrorMessages.STRING_ARG_SHOULD_CONTAIN_ONLY_ASCII);
}
@Specialization
@@ -163,20 +164,19 @@ static Object string(PString value,
@Bind("this") Node inliningTarget,
@Cached CastToTruffleStringNode cast,
@Shared("getCodeRange") @Cached @SuppressWarnings("unused") TruffleString.GetCodeRangeNode getCodeRangeNode,
- @Cached InlinedConditionProfile asciiProfile,
- @Cached PRaiseNode.Lazy raiseNode) {
+ @Cached InlinedConditionProfile asciiProfile) {
TruffleString ts = cast.execute(inliningTarget, value);
if (asciiProfile.profile(inliningTarget, isAscii(ts, getCodeRangeNode))) {
return asciiString(ts, getCodeRangeNode);
} else {
- return nonAsciiString(ts, getCodeRangeNode, raiseNode.get(inliningTarget));
+ return nonAsciiString(ts, inliningTarget, getCodeRangeNode);
}
}
@Fallback
static Object error(@SuppressWarnings("unused") Object value,
- @Shared @Cached PRaiseNode raiseNode) {
- throw raiseNode.raise(TypeError, ErrorMessages.ARG_SHOULD_BE_BYTES_BUFFER_OR_ASCII_NOT_P, value);
+ @Bind("this") Node inliningTarget) {
+ throw PRaiseNode.raiseStatic(inliningTarget, TypeError, ErrorMessages.ARG_SHOULD_BE_BYTES_BUFFER_OR_ASCII_NOT_P, value);
}
@ClinicConverterFactory
@@ -195,10 +195,10 @@ abstract static class A2bBase64Node extends PythonBinaryClinicBuiltinNode {
PBytes doConvert(VirtualFrame frame, Object buffer, boolean strictMode,
@Cached("createFor(this)") IndirectCallData indirectCallData,
@CachedLibrary("buffer") PythonBufferAccessLibrary bufferLib,
- @Cached PythonObjectFactory factory) {
+ @Bind PythonLanguage language) {
try {
ByteSequenceStorage storage = b64decode(bufferLib.getInternalOrCopiedByteArray(buffer), bufferLib.getBufferLength(buffer), strictMode);
- return factory.createBytes(storage);
+ return PFactory.createBytes(language, storage);
} finally {
bufferLib.release(buffer, frame, indirectCallData);
}
@@ -226,19 +226,19 @@ private ByteSequenceStorage b64decode(byte[] data, int dataLen, boolean strictMo
} else if (c == '=') {
padding++;
} else if (strictMode) {
- throw PRaiseNode.raiseUncached(this, BinasciiError, ErrorMessages.ONLY_BASE64_DATA_IS_ALLOWED);
+ throw PRaiseNode.raiseStatic(this, BinasciiError, ErrorMessages.ONLY_BASE64_DATA_IS_ALLOWED);
}
}
int expectedPadding = 0;
if (base64chars % 4 == 1) {
- throw PRaiseNode.raiseUncached(this, BinasciiError, ErrorMessages.INVALID_BASE64_ENCODED_STRING);
+ throw PRaiseNode.raiseStatic(this, BinasciiError, ErrorMessages.INVALID_BASE64_ENCODED_STRING);
} else if (base64chars % 4 == 2) {
expectedPadding = 2;
} else if (base64chars % 4 == 3) {
expectedPadding = 1;
}
if (padding < expectedPadding) {
- throw PRaiseNode.raiseUncached(this, BinasciiError, ErrorMessages.INCORRECT_PADDING);
+ throw PRaiseNode.raiseStatic(this, BinasciiError, ErrorMessages.INCORRECT_PADDING);
}
// Find the end of the expected padding, if any
int decodeLen = lastBase64Char + 1;
@@ -262,7 +262,7 @@ private ByteSequenceStorage b64decode(byte[] data, int dataLen, boolean strictMo
ByteBuffer result = decoder.decode(ByteBuffer.wrap(data, 0, decodeLen));
return new ByteSequenceStorage(result.array(), result.limit());
} catch (IllegalArgumentException e) {
- throw PRaiseNode.raiseUncached(this, BinasciiError, e);
+ throw PRaiseNode.raiseStatic(this, BinasciiError, e);
}
}
@@ -280,10 +280,10 @@ abstract static class A2bHexNode extends PythonUnaryClinicBuiltinNode {
PBytes a2b(VirtualFrame frame, Object buffer,
@Cached("createFor(this)") IndirectCallData indirectCallData,
@CachedLibrary("buffer") PythonBufferAccessLibrary bufferLib,
- @Cached PythonObjectFactory factory) {
+ @Bind PythonLanguage language) {
try {
byte[] bytes = a2b(bufferLib.getInternalOrCopiedByteArray(buffer), bufferLib.getBufferLength(buffer));
- return factory.createBytes(bytes);
+ return PFactory.createBytes(language, bytes);
} finally {
bufferLib.release(buffer, frame, indirectCallData);
}
@@ -292,7 +292,7 @@ PBytes a2b(VirtualFrame frame, Object buffer,
@TruffleBoundary
private byte[] a2b(byte[] bytes, int length) {
if (length % 2 != 0) {
- throw PRaiseNode.raiseUncached(this, BinasciiError, ErrorMessages.ODD_LENGTH_STRING);
+ throw PRaiseNode.raiseStatic(this, BinasciiError, ErrorMessages.ODD_LENGTH_STRING);
}
byte[] output = new byte[length / 2];
for (int i = 0; i < length / 2; i++) {
@@ -309,7 +309,7 @@ private int digitValue(char b) {
} else if (b >= 'A' && b <= 'F') {
return b - 'A' + 10;
} else {
- throw PRaiseNode.raiseUncached(this, BinasciiError, ErrorMessages.NON_HEX_DIGIT_FOUND);
+ throw PRaiseNode.raiseStatic(this, BinasciiError, ErrorMessages.NON_HEX_DIGIT_FOUND);
}
}
@@ -325,28 +325,28 @@ protected ArgumentClinicProvider getArgumentClinic() {
@GenerateNodeFactory
abstract static class B2aBase64Node extends PythonClinicBuiltinNode {
@TruffleBoundary
- private PBytes b2a(byte[] data, int lenght, int newline, PythonObjectFactory factory) {
+ private PBytes b2a(byte[] data, int lenght, int newline, PythonLanguage language) {
ByteBuffer encoded;
try {
encoded = Base64.getEncoder().encode(ByteBuffer.wrap(data, 0, lenght));
} catch (IllegalArgumentException e) {
- throw PRaiseNode.raiseUncached(this, BinasciiError, e);
+ throw PRaiseNode.raiseStatic(this, BinasciiError, e);
}
if (newline != 0) {
byte[] encodedWithNL = Arrays.copyOf(encoded.array(), encoded.limit() + 1);
encodedWithNL[encodedWithNL.length - 1] = '\n';
- return factory.createBytes(encodedWithNL);
+ return PFactory.createBytes(language, encodedWithNL);
}
- return factory.createBytes(encoded.array(), encoded.limit());
+ return PFactory.createBytes(language, encoded.array(), encoded.limit());
}
@Specialization(limit = "3")
PBytes b2aBuffer(VirtualFrame frame, Object buffer, int newline,
@Cached("createFor(this)") IndirectCallData indirectCallData,
@CachedLibrary("buffer") PythonBufferAccessLibrary bufferLib,
- @Cached PythonObjectFactory factory) {
+ @Bind PythonLanguage language) {
try {
- return b2a(bufferLib.getInternalOrCopiedByteArray(buffer), bufferLib.getBufferLength(buffer), newline, factory);
+ return b2a(bufferLib.getInternalOrCopiedByteArray(buffer), bufferLib.getBufferLength(buffer), newline, language);
} finally {
bufferLib.release(buffer, frame, indirectCallData);
}
@@ -371,28 +371,28 @@ static PBytes b2a(VirtualFrame frame, Object buffer, Object sep, int bytesPerSep
@Bind("this") Node inliningTarget,
@Cached("createFor(this)") IndirectCallData indirectCallData,
@CachedLibrary("buffer") PythonBufferAccessLibrary bufferLib,
- @Cached PythonObjectFactory factory,
- @Cached PRaiseNode.Lazy raiseNode) {
+ @Bind PythonLanguage language,
+ @Cached PRaiseNode raiseNode) {
if (sep != PNone.NO_VALUE || bytesPerSep != 1) {
// TODO implement sep and bytes_per_sep
- throw raiseNode.get(inliningTarget).raise(NotImplementedError);
+ throw raiseNode.raise(inliningTarget, NotImplementedError);
}
try {
- return b2a(bufferLib.getInternalOrCopiedByteArray(buffer), bufferLib.getBufferLength(buffer), factory);
+ return b2a(bufferLib.getInternalOrCopiedByteArray(buffer), bufferLib.getBufferLength(buffer), language);
} finally {
bufferLib.release(buffer, frame, indirectCallData);
}
}
@TruffleBoundary
- private static PBytes b2a(byte[] bytes, int length, PythonObjectFactory factory) {
+ private static PBytes b2a(byte[] bytes, int length, PythonLanguage language) {
byte[] output = new byte[length * 2];
for (int i = 0; i < length; i++) {
int v = bytes[i] & 0xff;
output[i * 2] = HEX_DIGITS[v >> 4];
output[i * 2 + 1] = HEX_DIGITS[v & 0xf];
}
- return factory.createBytes(output);
+ return PFactory.createBytes(language, output);
}
@Override
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinConstructors.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinConstructors.java
deleted file mode 100644
index 90d03d8aae..0000000000
--- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinConstructors.java
+++ /dev/null
@@ -1,2992 +0,0 @@
-/*
- * Copyright (c) 2017, 2025, Oracle and/or its affiliates.
- * Copyright (c) 2013, Regents of the University of California
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification, are
- * permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice, this list of
- * conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice, this list of
- * conditions and the following disclaimer in the documentation and/or other materials provided
- * with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
- * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
- * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-package com.oracle.graal.python.builtins.modules;
-
-import static com.oracle.graal.python.builtins.objects.cext.capi.NativeCAPISymbol.FUN_BYTES_SUBTYPE_NEW;
-import static com.oracle.graal.python.builtins.objects.cext.capi.NativeCAPISymbol.FUN_PY_OBJECT_NEW;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_BOOL;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_BYTEARRAY;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_BYTES;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_CLASSMETHOD;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_COMPLEX;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_DICT;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_DICT_ITEMITERATOR;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_DICT_ITEMS;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_DICT_KEYITERATOR;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_DICT_KEYS;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_DICT_VALUEITERATOR;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_DICT_VALUES;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_ENUMERATE;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_FLOAT;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_FROZENSET;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_GETSET_DESCRIPTOR;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_INSTANCEMETHOD;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_INT;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_LIST;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_MAP;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_MEMBER_DESCRIPTOR;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_MEMORYVIEW;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_MODULE;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_OBJECT;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_PROPERTY;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_RANGE;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_REVERSED;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_SET;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_STATICMETHOD;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_STR;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_SUPER;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_TUPLE;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_TYPE;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_WRAPPER_DESCRIPTOR;
-import static com.oracle.graal.python.nodes.BuiltinNames.J_ZIP;
-import static com.oracle.graal.python.nodes.BuiltinNames.T_EXCEPTION_GROUP;
-import static com.oracle.graal.python.nodes.BuiltinNames.T_GETSET_DESCRIPTOR;
-import static com.oracle.graal.python.nodes.BuiltinNames.T_LAMBDA_NAME;
-import static com.oracle.graal.python.nodes.BuiltinNames.T_MEMBER_DESCRIPTOR;
-import static com.oracle.graal.python.nodes.BuiltinNames.T_NOT_IMPLEMENTED;
-import static com.oracle.graal.python.nodes.BuiltinNames.T_WRAPPER_DESCRIPTOR;
-import static com.oracle.graal.python.nodes.BuiltinNames.T_ZIP;
-import static com.oracle.graal.python.nodes.ErrorMessages.ARG_MUST_NOT_BE_ZERO;
-import static com.oracle.graal.python.nodes.PGuards.isInteger;
-import static com.oracle.graal.python.nodes.PGuards.isNoValue;
-import static com.oracle.graal.python.nodes.SpecialAttributeNames.T___ABSTRACTMETHODS__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.T_JOIN;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.T_SORT;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.T___BYTES__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.T___COMPLEX__;
-import static com.oracle.graal.python.nodes.SpecialMethodNames.T___MRO_ENTRIES__;
-import static com.oracle.graal.python.nodes.StringLiterals.T_COMMA_SPACE;
-import static com.oracle.graal.python.nodes.StringLiterals.T_EMPTY_STRING;
-import static com.oracle.graal.python.nodes.StringLiterals.T_STRICT;
-import static com.oracle.graal.python.nodes.StringLiterals.T_UTF8;
-import static com.oracle.graal.python.nodes.truffle.TruffleStringMigrationHelpers.assertNoJavaString;
-import static com.oracle.graal.python.runtime.exception.PythonErrorType.NotImplementedError;
-import static com.oracle.graal.python.runtime.exception.PythonErrorType.OverflowError;
-import static com.oracle.graal.python.runtime.exception.PythonErrorType.RuntimeError;
-import static com.oracle.graal.python.runtime.exception.PythonErrorType.TypeError;
-import static com.oracle.graal.python.runtime.exception.PythonErrorType.ValueError;
-import static com.oracle.graal.python.util.PythonUtils.TS_ENCODING;
-import static com.oracle.graal.python.util.PythonUtils.addExact;
-import static com.oracle.graal.python.util.PythonUtils.multiplyExact;
-import static com.oracle.graal.python.util.PythonUtils.negateExact;
-import static com.oracle.graal.python.util.PythonUtils.objectArrayToTruffleStringArray;
-import static com.oracle.graal.python.util.PythonUtils.subtractExact;
-
-import java.math.BigInteger;
-import java.util.List;
-
-import com.oracle.graal.python.annotations.ArgumentClinic;
-import com.oracle.graal.python.builtins.Builtin;
-import com.oracle.graal.python.builtins.CoreFunctions;
-import com.oracle.graal.python.builtins.Python3Core;
-import com.oracle.graal.python.builtins.PythonBuiltinClassType;
-import com.oracle.graal.python.builtins.PythonBuiltins;
-import com.oracle.graal.python.builtins.modules.BuiltinConstructorsFactory.FloatNodeFactory.NonPrimitiveFloatNodeGen;
-import com.oracle.graal.python.builtins.modules.BuiltinConstructorsFactory.ObjectNodeFactory.ReportAbstractClassNodeGen;
-import com.oracle.graal.python.builtins.modules.WarningsModuleBuiltins.WarnNode;
-import com.oracle.graal.python.builtins.objects.PNone;
-import com.oracle.graal.python.builtins.objects.PNotImplemented;
-import com.oracle.graal.python.builtins.objects.buffer.PythonBufferAccessLibrary;
-import com.oracle.graal.python.builtins.objects.buffer.PythonBufferAcquireLibrary;
-import com.oracle.graal.python.builtins.objects.bytes.BytesNodes;
-import com.oracle.graal.python.builtins.objects.bytes.PByteArray;
-import com.oracle.graal.python.builtins.objects.bytes.PBytes;
-import com.oracle.graal.python.builtins.objects.cell.PCell;
-import com.oracle.graal.python.builtins.objects.cext.PythonAbstractNativeObject;
-import com.oracle.graal.python.builtins.objects.cext.capi.CExtNodes;
-import com.oracle.graal.python.builtins.objects.cext.capi.CExtNodes.PCallCapiFunction;
-import com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes;
-import com.oracle.graal.python.builtins.objects.cext.capi.NativeCAPISymbol;
-import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions.NativeToPythonTransferNode;
-import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions.PythonToNativeNode;
-import com.oracle.graal.python.builtins.objects.cext.common.CArrayWrappers.CByteArrayWrapper;
-import com.oracle.graal.python.builtins.objects.code.CodeNodes;
-import com.oracle.graal.python.builtins.objects.code.PCode;
-import com.oracle.graal.python.builtins.objects.common.HashingCollectionNodes;
-import com.oracle.graal.python.builtins.objects.common.HashingStorage;
-import com.oracle.graal.python.builtins.objects.common.SequenceNodes.GetObjectArrayNode;
-import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodes;
-import com.oracle.graal.python.builtins.objects.complex.PComplex;
-import com.oracle.graal.python.builtins.objects.dict.PDict;
-import com.oracle.graal.python.builtins.objects.ellipsis.PEllipsis;
-import com.oracle.graal.python.builtins.objects.enumerate.PEnumerate;
-import com.oracle.graal.python.builtins.objects.floats.FloatUtils;
-import com.oracle.graal.python.builtins.objects.floats.PFloat;
-import com.oracle.graal.python.builtins.objects.frame.PFrame;
-import com.oracle.graal.python.builtins.objects.function.PBuiltinFunction;
-import com.oracle.graal.python.builtins.objects.function.PFunction;
-import com.oracle.graal.python.builtins.objects.function.PKeyword;
-import com.oracle.graal.python.builtins.objects.ints.PInt;
-import com.oracle.graal.python.builtins.objects.iterator.PBigRangeIterator;
-import com.oracle.graal.python.builtins.objects.iterator.PZip;
-import com.oracle.graal.python.builtins.objects.list.PList;
-import com.oracle.graal.python.builtins.objects.map.PMap;
-import com.oracle.graal.python.builtins.objects.memoryview.PMemoryView;
-import com.oracle.graal.python.builtins.objects.method.PBuiltinMethod;
-import com.oracle.graal.python.builtins.objects.namespace.PSimpleNamespace;
-import com.oracle.graal.python.builtins.objects.object.ObjectBuiltinsFactory;
-import com.oracle.graal.python.builtins.objects.object.PythonObject;
-import com.oracle.graal.python.builtins.objects.property.PProperty;
-import com.oracle.graal.python.builtins.objects.range.PBigRange;
-import com.oracle.graal.python.builtins.objects.range.PIntRange;
-import com.oracle.graal.python.builtins.objects.range.RangeNodes;
-import com.oracle.graal.python.builtins.objects.range.RangeNodes.LenOfIntRangeNodeExact;
-import com.oracle.graal.python.builtins.objects.set.PFrozenSet;
-import com.oracle.graal.python.builtins.objects.set.PSet;
-import com.oracle.graal.python.builtins.objects.str.PString;
-import com.oracle.graal.python.builtins.objects.traceback.PTraceback;
-import com.oracle.graal.python.builtins.objects.tuple.PTuple;
-import com.oracle.graal.python.builtins.objects.type.PythonBuiltinClass;
-import com.oracle.graal.python.builtins.objects.type.PythonManagedClass;
-import com.oracle.graal.python.builtins.objects.type.SpecialMethodSlot;
-import com.oracle.graal.python.builtins.objects.type.TypeBuiltins;
-import com.oracle.graal.python.builtins.objects.type.TypeFlags;
-import com.oracle.graal.python.builtins.objects.type.TypeNodes;
-import com.oracle.graal.python.builtins.objects.type.TypeNodes.CreateTypeNode;
-import com.oracle.graal.python.builtins.objects.type.TypeNodes.IsAcceptableBaseNode;
-import com.oracle.graal.python.builtins.objects.type.TypeNodes.IsTypeNode;
-import com.oracle.graal.python.builtins.objects.type.TypeNodes.NeedsNativeAllocationNode;
-import com.oracle.graal.python.builtins.objects.types.PGenericAlias;
-import com.oracle.graal.python.lib.CanBeDoubleNode;
-import com.oracle.graal.python.lib.PyBytesCheckNode;
-import com.oracle.graal.python.lib.PyCallableCheckNode;
-import com.oracle.graal.python.lib.PyComplexCheckExactNode;
-import com.oracle.graal.python.lib.PyFloatAsDoubleNode;
-import com.oracle.graal.python.lib.PyFloatFromString;
-import com.oracle.graal.python.lib.PyLongFromUnicodeObject;
-import com.oracle.graal.python.lib.PyMappingCheckNode;
-import com.oracle.graal.python.lib.PyMemoryViewFromObject;
-import com.oracle.graal.python.lib.PyNumberAsSizeNode;
-import com.oracle.graal.python.lib.PyNumberFloatNode;
-import com.oracle.graal.python.lib.PyNumberIndexNode;
-import com.oracle.graal.python.lib.PyNumberLongNode;
-import com.oracle.graal.python.lib.PyObjectCallMethodObjArgs;
-import com.oracle.graal.python.lib.PyObjectGetAttr;
-import com.oracle.graal.python.lib.PyObjectGetIter;
-import com.oracle.graal.python.lib.PyObjectIsTrueNode;
-import com.oracle.graal.python.lib.PyObjectLookupAttr;
-import com.oracle.graal.python.lib.PyObjectSizeNode;
-import com.oracle.graal.python.lib.PyObjectStrAsObjectNode;
-import com.oracle.graal.python.lib.PySequenceCheckNode;
-import com.oracle.graal.python.lib.PySequenceSizeNode;
-import com.oracle.graal.python.lib.PySliceNew;
-import com.oracle.graal.python.lib.PyUnicodeCheckExactNode;
-import com.oracle.graal.python.lib.PyUnicodeCheckNode;
-import com.oracle.graal.python.nodes.BuiltinNames;
-import com.oracle.graal.python.nodes.ErrorMessages;
-import com.oracle.graal.python.nodes.PGuards;
-import com.oracle.graal.python.nodes.PNodeWithContext;
-import com.oracle.graal.python.nodes.PRaiseNode;
-import com.oracle.graal.python.nodes.attributes.LookupCallableSlotInMRONode;
-import com.oracle.graal.python.nodes.attributes.ReadAttributeFromObjectNode;
-import com.oracle.graal.python.nodes.builtins.ListNodes;
-import com.oracle.graal.python.nodes.builtins.TupleNodes;
-import com.oracle.graal.python.nodes.call.CallNode;
-import com.oracle.graal.python.nodes.call.special.CallUnaryMethodNode;
-import com.oracle.graal.python.nodes.call.special.LookupAndCallTernaryNode;
-import com.oracle.graal.python.nodes.call.special.LookupAndCallUnaryNode;
-import com.oracle.graal.python.nodes.call.special.LookupSpecialMethodSlotNode;
-import com.oracle.graal.python.nodes.classes.IsSubtypeNode;
-import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
-import com.oracle.graal.python.nodes.function.PythonBuiltinNode;
-import com.oracle.graal.python.nodes.function.builtins.PythonBinaryBuiltinNode;
-import com.oracle.graal.python.nodes.function.builtins.PythonClinicBuiltinNode;
-import com.oracle.graal.python.nodes.function.builtins.PythonQuaternaryBuiltinNode;
-import com.oracle.graal.python.nodes.function.builtins.PythonQuaternaryClinicBuiltinNode;
-import com.oracle.graal.python.nodes.function.builtins.PythonTernaryBuiltinNode;
-import com.oracle.graal.python.nodes.function.builtins.PythonVarargsBuiltinNode;
-import com.oracle.graal.python.nodes.function.builtins.clinic.ArgumentClinicProvider;
-import com.oracle.graal.python.nodes.object.BuiltinClassProfiles;
-import com.oracle.graal.python.nodes.object.BuiltinClassProfiles.IsAnyBuiltinClassProfile;
-import com.oracle.graal.python.nodes.object.BuiltinClassProfiles.IsBuiltinClassExactProfile;
-import com.oracle.graal.python.nodes.object.BuiltinClassProfiles.IsBuiltinObjectProfile;
-import com.oracle.graal.python.nodes.object.GetClassNode;
-import com.oracle.graal.python.nodes.util.CannotCastException;
-import com.oracle.graal.python.nodes.util.CastToJavaIntExactNode;
-import com.oracle.graal.python.nodes.util.CastToJavaStringNode;
-import com.oracle.graal.python.nodes.util.CastToTruffleStringNode;
-import com.oracle.graal.python.nodes.util.SplitArgsNode;
-import com.oracle.graal.python.runtime.IndirectCallData;
-import com.oracle.graal.python.runtime.PythonContext;
-import com.oracle.graal.python.runtime.exception.PException;
-import com.oracle.graal.python.runtime.object.PythonObjectFactory;
-import com.oracle.graal.python.runtime.object.PythonObjectSlowPathFactory;
-import com.oracle.graal.python.util.OverflowException;
-import com.oracle.graal.python.util.PythonUtils;
-import com.oracle.truffle.api.Assumption;
-import com.oracle.truffle.api.CompilerDirectives;
-import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
-import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
-import com.oracle.truffle.api.HostCompilerDirectives.InliningCutoff;
-import com.oracle.truffle.api.Truffle;
-import com.oracle.truffle.api.dsl.Bind;
-import com.oracle.truffle.api.dsl.Cached;
-import com.oracle.truffle.api.dsl.Cached.Exclusive;
-import com.oracle.truffle.api.dsl.Cached.Shared;
-import com.oracle.truffle.api.dsl.Fallback;
-import com.oracle.truffle.api.dsl.GenerateCached;
-import com.oracle.truffle.api.dsl.GenerateInline;
-import com.oracle.truffle.api.dsl.GenerateNodeFactory;
-import com.oracle.truffle.api.dsl.GenerateUncached;
-import com.oracle.truffle.api.dsl.ImportStatic;
-import com.oracle.truffle.api.dsl.NeverDefault;
-import com.oracle.truffle.api.dsl.ReportPolymorphism;
-import com.oracle.truffle.api.dsl.Specialization;
-import com.oracle.truffle.api.frame.VirtualFrame;
-import com.oracle.truffle.api.library.CachedLibrary;
-import com.oracle.truffle.api.nodes.LoopNode;
-import com.oracle.truffle.api.nodes.Node;
-import com.oracle.truffle.api.profiles.InlinedBranchProfile;
-import com.oracle.truffle.api.profiles.InlinedConditionProfile;
-import com.oracle.truffle.api.profiles.InlinedLoopConditionProfile;
-import com.oracle.truffle.api.strings.TruffleString;
-
-@CoreFunctions(defineModule = BuiltinNames.J_BUILTINS, isEager = true)
-public final class BuiltinConstructors extends PythonBuiltins {
-
- @Override
- protected List> getNodeFactories() {
- return BuiltinConstructorsFactory.getFactories();
- }
-
- @Override
- public void initialize(Python3Core core) {
- super.initialize(core);
- addBuiltinConstant(T_NOT_IMPLEMENTED, PNotImplemented.NOT_IMPLEMENTED);
- }
-
- // bytes([source[, encoding[, errors]]])
- @Builtin(name = J_BYTES, minNumOfPositionalArgs = 1, parameterNames = {"$self", "source", "encoding", "errors"}, constructsClass = PythonBuiltinClassType.PBytes, doc = """
- bytes(iterable_of_ints) -> bytes
- bytes(string, encoding[, errors]) -> bytes
- bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
- bytes(int) -> bytes object of size given by the parameter initialized with null bytes
- bytes() -> empty bytes object
-
- Construct an immutable array of bytes from:
- - an iterable yielding integers in range(256)
- - a text string encoded using the specified encoding
- - any object implementing the buffer API.
- - an integer""")
- @ArgumentClinic(name = "encoding", conversionClass = BytesNodes.ExpectStringNode.class, args = "\"bytes()\"")
- @ArgumentClinic(name = "errors", conversionClass = BytesNodes.ExpectStringNode.class, args = "\"bytes()\"")
- @GenerateNodeFactory
- @ImportStatic(SpecialMethodSlot.class)
- public abstract static class BytesNode extends PythonQuaternaryClinicBuiltinNode {
-
- @Override
- protected ArgumentClinicProvider getArgumentClinic() {
- return BuiltinConstructorsClinicProviders.BytesNodeClinicProviderGen.INSTANCE;
- }
-
- @SuppressWarnings("unused")
- @Specialization(guards = "isNoValue(source)")
- static Object doEmpty(Object cls, PNone source, PNone encoding, PNone errors,
- @Bind("this") Node inliningTarget,
- @Exclusive @Cached CreateBytes createBytes) {
- return createBytes.execute(inliningTarget, cls, PythonUtils.EMPTY_BYTE_ARRAY);
- }
-
- @Specialization(guards = "!isNoValue(source)")
- static Object doCallBytes(VirtualFrame frame, Object cls, Object source, PNone encoding, PNone errors,
- @Bind("this") Node inliningTarget,
- @Cached GetClassNode getClassNode,
- @Cached InlinedConditionProfile hasBytes,
- @Cached("create(Bytes)") LookupSpecialMethodSlotNode lookupBytes,
- @Cached CallUnaryMethodNode callBytes,
- @Cached BytesNodes.ToBytesNode toBytesNode,
- @Cached PyBytesCheckNode check,
- @Exclusive @Cached BytesNodes.BytesInitNode bytesInitNode,
- @Exclusive @Cached CreateBytes createBytes,
- @Cached PRaiseNode.Lazy raiseNode) {
- Object bytesMethod = lookupBytes.execute(frame, getClassNode.execute(inliningTarget, source), source);
- if (hasBytes.profile(inliningTarget, bytesMethod != PNone.NO_VALUE)) {
- Object bytes = callBytes.executeObject(frame, bytesMethod, source);
- if (check.execute(inliningTarget, bytes)) {
- if (cls == PythonBuiltinClassType.PBytes) {
- return bytes;
- } else {
- return createBytes.execute(inliningTarget, cls, toBytesNode.execute(frame, bytes));
- }
- } else {
- throw raiseNode.get(inliningTarget).raise(TypeError, ErrorMessages.RETURNED_NONBYTES, T___BYTES__, bytes);
- }
- }
- return createBytes.execute(inliningTarget, cls, bytesInitNode.execute(frame, inliningTarget, source, encoding, errors));
- }
-
- @Specialization(guards = {"isNoValue(source) || (!isNoValue(encoding) || !isNoValue(errors))"})
- static Object dontCallBytes(VirtualFrame frame, Object cls, Object source, Object encoding, Object errors,
- @Bind("this") Node inliningTarget,
- @Exclusive @Cached BytesNodes.BytesInitNode bytesInitNode,
- @Exclusive @Cached CreateBytes createBytes) {
- return createBytes.execute(inliningTarget, cls, bytesInitNode.execute(frame, inliningTarget, source, encoding, errors));
- }
-
- @GenerateInline
- @GenerateCached(false)
- abstract static class CreateBytes extends PNodeWithContext {
- abstract Object execute(Node inliningTarget, Object cls, byte[] bytes);
-
- @Specialization(guards = "!needsNativeAllocationNode.execute(inliningTarget, cls)")
- static PBytes doManaged(@SuppressWarnings("unused") Node inliningTarget, Object cls, byte[] bytes,
- @SuppressWarnings("unused") @Shared @Cached TypeNodes.NeedsNativeAllocationNode needsNativeAllocationNode,
- @Cached(inline = false) PythonObjectFactory factory) {
- return factory.createBytes(cls, bytes);
- }
-
- @Specialization(guards = "needsNativeAllocationNode.execute(inliningTarget, cls)")
- static Object doNative(@SuppressWarnings("unused") Node inliningTarget, Object cls, byte[] bytes,
- @SuppressWarnings("unused") @Shared @Cached TypeNodes.NeedsNativeAllocationNode needsNativeAllocationNode,
- @Cached(inline = false) PythonToNativeNode toNative,
- @Cached(inline = false) NativeToPythonTransferNode toPython,
- @Cached(inline = false) PCallCapiFunction call) {
- CByteArrayWrapper wrapper = new CByteArrayWrapper(bytes);
- try {
- return toPython.execute(call.call(FUN_BYTES_SUBTYPE_NEW, toNative.execute(cls), wrapper, bytes.length));
- } finally {
- wrapper.free();
- }
- }
- }
- }
-
- @Builtin(name = J_BYTEARRAY, minNumOfPositionalArgs = 1, takesVarArgs = true, takesVarKeywordArgs = true, constructsClass = PythonBuiltinClassType.PByteArray, doc = """
- bytearray(iterable_of_ints) -> bytearray
- bytearray(string, encoding[, errors]) -> bytearray
- bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
- bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
- bytearray() -> empty bytes array
-
- Construct a mutable bytearray object from:
- - an iterable yielding integers in range(256)
- - a text string encoded using the specified encoding
- - a bytes or a buffer object
- - any object implementing the buffer API.
- - an integer""")
- @GenerateNodeFactory
- public abstract static class ByteArrayNode extends PythonBuiltinNode {
- @Specialization
- public PByteArray setEmpty(Object cls, @SuppressWarnings("unused") Object arg,
- @Cached PythonObjectFactory factory) {
- // data filled in subsequent __init__ call - see BytesCommonBuiltins.InitNode
- return factory.createByteArray(cls, PythonUtils.EMPTY_BYTE_ARRAY);
- }
-
- // TODO: native allocation?
- }
-
- // complex([real[, imag]])
- @Builtin(name = J_COMPLEX, minNumOfPositionalArgs = 1, constructsClass = PythonBuiltinClassType.PComplex, parameterNames = {"$cls", "real", "imag"}, doc = """
- Create a complex number from a real part and an optional imaginary part.
-
- This is equivalent to (real + imag*1j) where imag defaults to 0.""")
- @GenerateNodeFactory
- public abstract static class ComplexNode extends PythonTernaryBuiltinNode {
- @Child private LookupAndCallUnaryNode callReprNode;
- @Child private LookupAndCallUnaryNode callComplexNode;
- @Child private WarnNode warnNode;
-
- @GenerateInline
- @GenerateCached(false)
- @GenerateUncached
- abstract static class CreateComplexNode extends Node {
- public abstract Object execute(Node inliningTarget, Object cls, double real, double imaginary);
-
- public static Object executeUncached(Object cls, double real, double imaginary) {
- return BuiltinConstructorsFactory.ComplexNodeFactory.CreateComplexNodeGen.getUncached().execute(null, cls, real, imaginary);
- }
-
- @Specialization(guards = "!needsNativeAllocationNode.execute(inliningTarget, cls)", limit = "1")
- static PComplex doManaged(@SuppressWarnings("unused") Node inliningTarget, Object cls, double real, double imaginary,
- @SuppressWarnings("unused") @Cached NeedsNativeAllocationNode needsNativeAllocationNode,
- @Cached(inline = false) PythonObjectFactory factory) {
- return factory.createComplex(cls, real, imaginary);
- }
-
- @Fallback
- static Object doNative(Node inliningTarget, Object cls, double real, double imaginary,
- @Cached(inline = false) PCallCapiFunction callCapiFunction,
- @Cached(inline = false) PythonToNativeNode toNativeNode,
- @Cached(inline = false) NativeToPythonTransferNode toPythonNode,
- @Cached(inline = false) ExternalFunctionNodes.DefaultCheckFunctionResultNode checkFunctionResultNode) {
- NativeCAPISymbol symbol = NativeCAPISymbol.FUN_COMPLEX_SUBTYPE_FROM_DOUBLES;
- Object nativeResult = callCapiFunction.call(symbol, toNativeNode.execute(cls), real, imaginary);
- return toPythonNode.execute(checkFunctionResultNode.execute(PythonContext.get(inliningTarget), symbol.getTsName(), nativeResult));
- }
- }
-
- @Specialization(guards = {"isNoValue(real)", "isNoValue(imag)"})
- @SuppressWarnings("unused")
- static Object complexFromNone(Object cls, PNone real, PNone imag,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, 0, 0);
- }
-
- @Specialization
- static Object complexFromIntInt(Object cls, int real, int imaginary,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, real, imaginary);
- }
-
- @Specialization
- static Object complexFromLongLong(Object cls, long real, long imaginary,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, real, imaginary);
- }
-
- @Specialization
- static Object complexFromLongLong(Object cls, PInt real, PInt imaginary,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, real.doubleValueWithOverflow(inliningTarget),
- imaginary.doubleValueWithOverflow(inliningTarget));
- }
-
- @Specialization
- static Object complexFromDoubleDouble(Object cls, double real, double imaginary,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, real, imaginary);
- }
-
- @Specialization(guards = "isNoValue(imag)")
- static Object complexFromDouble(Object cls, double real, @SuppressWarnings("unused") PNone imag,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, real, 0);
- }
-
- @Specialization(guards = "isNoValue(imag)")
- Object complexFromDouble(VirtualFrame frame, Object cls, PFloat real, @SuppressWarnings("unused") PNone imag,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode,
- @Shared @Cached CanBeDoubleNode canBeDoubleNode,
- @Shared("floatAsDouble") @Cached PyFloatAsDoubleNode asDoubleNode,
- @Shared("isComplex") @Cached PyComplexCheckExactNode isComplexType,
- @Shared("isComplexResult") @Cached PyComplexCheckExactNode isResultComplexType,
- @Shared("isPrimitive") @Cached IsBuiltinClassExactProfile isPrimitiveProfile,
- @Shared("isBuiltinObj") @Cached PyComplexCheckExactNode isBuiltinObjectProfile,
- @Shared @Cached PythonObjectFactory factory,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- return complexFromObject(frame, cls, real, imag, inliningTarget, createComplexNode, canBeDoubleNode, asDoubleNode, isComplexType, isResultComplexType, isPrimitiveProfile,
- isBuiltinObjectProfile, factory,
- raiseNode);
- }
-
- @Specialization(guards = "isNoValue(imag)")
- static Object complexFromInt(Object cls, int real, @SuppressWarnings("unused") PNone imag,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, real, 0);
- }
-
- @Specialization(guards = "isNoValue(imag)")
- static Object complexFromLong(Object cls, long real, @SuppressWarnings("unused") PNone imag,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, real, 0);
- }
-
- @Specialization(guards = "isNoValue(imag)")
- Object complexFromLong(VirtualFrame frame, Object cls, PInt real, @SuppressWarnings("unused") PNone imag,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode,
- @Shared @Cached CanBeDoubleNode canBeDoubleNode,
- @Shared("floatAsDouble") @Cached PyFloatAsDoubleNode asDoubleNode,
- @Shared("isComplex") @Cached PyComplexCheckExactNode isComplexType,
- @Shared("isComplexResult") @Cached PyComplexCheckExactNode isResultComplexType,
- @Shared("isPrimitive") @Cached IsBuiltinClassExactProfile isPrimitiveProfile,
- @Shared("isBuiltinObj") @Cached PyComplexCheckExactNode complexCheck,
- @Shared @Cached PythonObjectFactory factory,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- return complexFromObject(frame, cls, real, imag, inliningTarget, createComplexNode, canBeDoubleNode, asDoubleNode, isComplexType, isResultComplexType, isPrimitiveProfile, complexCheck,
- factory, raiseNode);
- }
-
- @Specialization(guards = {"isNoValue(imag)", "!isNoValue(number)", "!isString(number)"})
- Object complexFromObject(VirtualFrame frame, Object cls, Object number, @SuppressWarnings("unused") PNone imag,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode,
- @Shared @Cached CanBeDoubleNode canBeDoubleNode,
- @Shared("floatAsDouble") @Cached PyFloatAsDoubleNode asDoubleNode,
- @Shared("isComplex") @Cached PyComplexCheckExactNode isComplexType,
- @Shared("isComplexResult") @Cached PyComplexCheckExactNode isResultComplexType,
- @Shared("isPrimitive") @Cached IsBuiltinClassExactProfile isPrimitiveProfile,
- @Shared("isBuiltinObj") @Cached PyComplexCheckExactNode complexCheck,
- @Shared @Cached PythonObjectFactory factory,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- PComplex value = getComplexNumberFromObject(frame, number, inliningTarget, isComplexType, isResultComplexType, raiseNode);
- if (value == null) {
- if (canBeDoubleNode.execute(inliningTarget, number)) {
- return createComplexNode.execute(inliningTarget, cls, asDoubleNode.execute(frame, inliningTarget, number), 0.0);
- } else {
- throw raiseFirstArgError(number, raiseNode.get(inliningTarget));
- }
- }
- if (isPrimitiveProfile.profileClass(inliningTarget, cls, PythonBuiltinClassType.PComplex)) {
- if (complexCheck.execute(inliningTarget, value)) {
- return value;
- }
- return factory.createComplex(value.getReal(), value.getImag());
- }
- return createComplexNode.execute(inliningTarget, cls, value.getReal(), value.getImag());
- }
-
- @Specialization
- static Object complexFromLongComplex(Object cls, long one, PComplex two,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, one - two.getImag(), two.getReal());
- }
-
- @Specialization
- static Object complexFromPIntComplex(Object cls, PInt one, PComplex two,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, one.doubleValueWithOverflow(inliningTarget) - two.getImag(), two.getReal());
- }
-
- @Specialization
- static Object complexFromDoubleComplex(Object cls, double one, PComplex two,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode) {
- return createComplexNode.execute(inliningTarget, cls, one - two.getImag(), two.getReal());
- }
-
- @Specialization(guards = "!isString(one)")
- Object complexFromComplexLong(VirtualFrame frame, Object cls, Object one, long two,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode,
- @Shared @Cached CanBeDoubleNode canBeDoubleNode,
- @Shared("floatAsDouble") @Cached PyFloatAsDoubleNode asDoubleNode,
- @Shared("isComplex") @Cached PyComplexCheckExactNode isComplexType,
- @Shared("isComplexResult") @Cached PyComplexCheckExactNode isResultComplexType,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- PComplex value = getComplexNumberFromObject(frame, one, inliningTarget, isComplexType, isResultComplexType, raiseNode);
- if (value == null) {
- if (canBeDoubleNode.execute(inliningTarget, one)) {
- return createComplexNode.execute(inliningTarget, cls, asDoubleNode.execute(frame, inliningTarget, one), two);
- } else {
- throw raiseFirstArgError(one, raiseNode.get(inliningTarget));
- }
- }
- return createComplexNode.execute(inliningTarget, cls, value.getReal(), value.getImag() + two);
- }
-
- @Specialization(guards = "!isString(one)")
- Object complexFromComplexDouble(VirtualFrame frame, Object cls, Object one, double two,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode,
- @Shared @Cached CanBeDoubleNode canBeDoubleNode,
- @Shared("floatAsDouble") @Cached PyFloatAsDoubleNode asDoubleNode,
- @Shared("isComplex") @Cached PyComplexCheckExactNode isComplexType,
- @Shared("isComplexResult") @Cached PyComplexCheckExactNode isResultComplexType,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- PComplex value = getComplexNumberFromObject(frame, one, inliningTarget, isComplexType, isResultComplexType, raiseNode);
- if (value == null) {
- if (canBeDoubleNode.execute(inliningTarget, one)) {
- return createComplexNode.execute(inliningTarget, cls, asDoubleNode.execute(frame, inliningTarget, one), two);
- } else {
- throw raiseFirstArgError(one, raiseNode.get(inliningTarget));
- }
- }
- return createComplexNode.execute(inliningTarget, cls, value.getReal(), value.getImag() + two);
- }
-
- @Specialization(guards = "!isString(one)")
- Object complexFromComplexPInt(VirtualFrame frame, Object cls, Object one, PInt two,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode,
- @Shared @Cached CanBeDoubleNode canBeDoubleNode,
- @Shared("floatAsDouble") @Cached PyFloatAsDoubleNode asDoubleNode,
- @Shared("isComplex") @Cached PyComplexCheckExactNode isComplexType,
- @Shared("isComplexResult") @Cached PyComplexCheckExactNode isResultComplexType,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- PComplex value = getComplexNumberFromObject(frame, one, inliningTarget, isComplexType, isResultComplexType, raiseNode);
- if (value == null) {
- if (canBeDoubleNode.execute(inliningTarget, one)) {
- return createComplexNode.execute(inliningTarget, cls, asDoubleNode.execute(frame, inliningTarget, one), two.doubleValueWithOverflow(this));
- } else {
- throw raiseFirstArgError(one, raiseNode.get(inliningTarget));
- }
- }
- return createComplexNode.execute(inliningTarget, cls, value.getReal(), value.getImag() + two.doubleValueWithOverflow(this));
- }
-
- @Specialization(guards = "!isString(one)")
- Object complexFromComplexComplex(VirtualFrame frame, Object cls, Object one, PComplex two,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode,
- @Shared @Cached CanBeDoubleNode canBeDoubleNode,
- @Shared("floatAsDouble") @Cached PyFloatAsDoubleNode asDoubleNode,
- @Shared("isComplex") @Cached PyComplexCheckExactNode isComplexType,
- @Shared("isComplexResult") @Cached PyComplexCheckExactNode isResultComplexType,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- PComplex value = getComplexNumberFromObject(frame, one, inliningTarget, isComplexType, isResultComplexType, raiseNode);
- if (value == null) {
- if (canBeDoubleNode.execute(inliningTarget, one)) {
- return createComplexNode.execute(inliningTarget, cls, asDoubleNode.execute(frame, inliningTarget, one) - two.getImag(), two.getReal());
- } else {
- throw raiseFirstArgError(one, raiseNode.get(inliningTarget));
- }
- }
- return createComplexNode.execute(inliningTarget, cls, value.getReal() - two.getImag(), value.getImag() + two.getReal());
- }
-
- @Specialization(guards = {"!isString(one)", "!isNoValue(two)", "!isPComplex(two)"})
- @SuppressWarnings("truffle-static-method")
- Object complexFromComplexObject(VirtualFrame frame, Object cls, Object one, Object two,
- @Bind("this") Node inliningTarget,
- @Shared @Cached CreateComplexNode createComplexNode,
- @Shared @Cached CanBeDoubleNode canBeDoubleNode,
- @Shared("floatAsDouble") @Cached PyFloatAsDoubleNode asDoubleNode,
- @Shared("isComplex") @Cached PyComplexCheckExactNode isComplexType,
- @Shared("isComplexResult") @Cached PyComplexCheckExactNode isResultComplexType,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- PComplex oneValue = getComplexNumberFromObject(frame, one, inliningTarget, isComplexType, isResultComplexType, raiseNode);
- if (canBeDoubleNode.execute(inliningTarget, two)) {
- double twoValue = asDoubleNode.execute(frame, inliningTarget, two);
- if (oneValue == null) {
- if (canBeDoubleNode.execute(inliningTarget, one)) {
- return createComplexNode.execute(inliningTarget, cls, asDoubleNode.execute(frame, inliningTarget, one), twoValue);
- } else {
- throw raiseFirstArgError(one, raiseNode.get(inliningTarget));
- }
- }
- return createComplexNode.execute(inliningTarget, cls, oneValue.getReal(), oneValue.getImag() + twoValue);
- } else {
- throw raiseSecondArgError(two, raiseNode.get(inliningTarget));
- }
- }
-
- @Specialization
- Object complexFromString(VirtualFrame frame, Object cls, TruffleString real, Object imaginary,
- @Bind("this") Node inliningTarget,
- @Cached TruffleString.ToJavaStringNode toJavaStringNode,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- if (imaginary != PNone.NO_VALUE) {
- throw raiseNode.get(inliningTarget).raise(TypeError, ErrorMessages.COMPLEX_CANT_TAKE_ARG);
- }
- return convertStringToComplex(frame, inliningTarget, toJavaStringNode.execute(real), cls, real, raiseNode);
- }
-
- @Specialization
- Object complexFromString(VirtualFrame frame, Object cls, PString real, Object imaginary,
- @Bind("this") Node inliningTarget,
- @Cached CastToJavaStringNode castToStringNode,
- @Shared @Cached PRaiseNode.Lazy raiseNode) {
- if (imaginary != PNone.NO_VALUE) {
- throw raiseNode.get(inliningTarget).raise(TypeError, ErrorMessages.COMPLEX_CANT_TAKE_ARG);
- }
- return convertStringToComplex(frame, inliningTarget, castToStringNode.execute(real), cls, real, raiseNode);
- }
-
- private Object callComplex(VirtualFrame frame, Object object) {
- if (callComplexNode == null) {
- CompilerDirectives.transferToInterpreterAndInvalidate();
- callComplexNode = insert(LookupAndCallUnaryNode.create(T___COMPLEX__));
- }
- return callComplexNode.executeObject(frame, object);
- }
-
- private WarnNode getWarnNode() {
- if (warnNode == null) {
- CompilerDirectives.transferToInterpreterAndInvalidate();
- warnNode = insert(WarnNode.create());
- }
- return warnNode;
- }
-
- private static PException raiseFirstArgError(Object x, PRaiseNode raiseNode) {
- throw raiseNode.raise(PythonBuiltinClassType.TypeError, ErrorMessages.ARG_MUST_BE_STRING_OR_NUMBER, "complex() first", x);
- }
-
- private static PException raiseSecondArgError(Object x, PRaiseNode raiseNode) {
- throw raiseNode.raise(PythonBuiltinClassType.TypeError, ErrorMessages.ARG_MUST_BE_NUMBER, "complex() second", x);
- }
-
- private PComplex getComplexNumberFromObject(VirtualFrame frame, Object object, Node inliningTarget,
- PyComplexCheckExactNode isComplexType, PyComplexCheckExactNode isResultComplexType, PRaiseNode.Lazy raiseNode) {
- if (isComplexType.execute(inliningTarget, object)) {
- return (PComplex) object;
- } else {
- Object result = callComplex(frame, object);
- if (result instanceof PComplex) {
- if (!isResultComplexType.execute(inliningTarget, result)) {
- getWarnNode().warnFormat(frame, null, PythonBuiltinClassType.DeprecationWarning, 1,
- ErrorMessages.WARN_P_RETURNED_NON_P,
- object, "__complex__", "complex", result, "complex");
- }
- return (PComplex) result;
- } else if (result != PNone.NO_VALUE) {
- throw raiseNode.get(inliningTarget).raise(TypeError, ErrorMessages.COMPLEX_RETURNED_NON_COMPLEX, result);
- }
- if (object instanceof PComplex) {
- // the class extending PComplex but doesn't have __complex__ method
- return (PComplex) object;
- }
- return null;
- }
- }
-
- @Fallback
- @SuppressWarnings("unused")
- static Object complexGeneric(Object cls, Object realObj, Object imaginaryObj,
- @Cached PRaiseNode raiseNode) {
- throw raiseNode.raise(TypeError, ErrorMessages.IS_NOT_TYPE_OBJ, "complex.__new__(X): X", cls);
- }
-
- // Adapted from CPython's complex_subtype_from_string
- private Object convertStringToComplex(VirtualFrame frame, Node inliningTarget, String src, Object cls, Object origObj, PRaiseNode.Lazy raiseNode) {
- String str = FloatUtils.removeUnicodeAndUnderscores(src);
- if (str == null) {
- if (callReprNode == null) {
- CompilerDirectives.transferToInterpreterAndInvalidate();
- callReprNode = insert(LookupAndCallUnaryNode.create(SpecialMethodSlot.Repr));
- }
- Object strStr = callReprNode.executeObject(frame, origObj);
- if (PGuards.isString(strStr)) {
- throw raiseNode.get(inliningTarget).raise(ValueError, ErrorMessages.COULD_NOT_CONVERT_STRING_TO_COMPLEX, strStr);
- } else {
- // During the formatting of "ValueError: invalid literal ..." exception,
- // CPython attempts to raise "TypeError: __repr__ returned non-string",
- // which gets later overwitten with the original "ValueError",
- // but without any message (since the message formatting failed)
- throw raiseNode.get(inliningTarget).raise(ValueError);
- }
- }
- Object c = convertStringToComplexOrNull(str, cls);
- if (c == null) {
- throw raiseNode.get(inliningTarget).raise(ValueError, ErrorMessages.COMPLEX_ARG_IS_MALFORMED_STR);
- }
- return c;
- }
-
- // Adapted from CPython's complex_from_string_inner
- @TruffleBoundary
- private Object convertStringToComplexOrNull(String str, Object cls) {
- int len = str.length();
-
- // position on first nonblank
- int i = FloatUtils.skipAsciiWhitespace(str, 0, len);
-
- boolean gotBracket;
- if (i < len && str.charAt(i) == '(') {
- // Skip over possible bracket from repr().
- gotBracket = true;
- i = FloatUtils.skipAsciiWhitespace(str, i + 1, len);
- } else {
- gotBracket = false;
- }
-
- double x, y;
- boolean expectJ;
-
- // first look for forms starting with
- FloatUtils.StringToDoubleResult res1 = FloatUtils.stringToDouble(str, i, len);
- if (res1 != null) {
- // all 4 forms starting with land here
- i = res1.position;
- char ch = i < len ? str.charAt(i) : '\0';
- if (ch == '+' || ch == '-') {
- // j | j
- x = res1.value;
- FloatUtils.StringToDoubleResult res2 = FloatUtils.stringToDouble(str, i, len);
- if (res2 != null) {
- // j
- y = res2.value;
- i = res2.position;
- } else {
- // j
- y = ch == '+' ? 1.0 : -1.0;
- i++;
- }
- expectJ = true;
- } else if (ch == 'j' || ch == 'J') {
- // j
- i++;
- y = res1.value;
- x = 0;
- expectJ = false;
- } else {
- //
- x = res1.value;
- y = 0;
- expectJ = false;
- }
- } else {
- // not starting with ; must be j or j
- char ch = i < len ? str.charAt(i) : '\0';
- if (ch == '+' || ch == '-') {
- //