[GR-34617] intrinsify sys.excepthook

PullRequest: graalpython/2010

Author: cosminbasca

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/SysModuleBuiltins.java

@@ -40,12 +40,16 @@
  */
 package com.oracle.graal.python.builtins.objects.traceback;
 
+import static com.oracle.graal.python.builtins.objects.traceback.PTraceback.UNKNOWN_LINE_NUMBER;
+
 import com.oracle.graal.python.builtins.objects.frame.PFrame;
 import com.oracle.graal.python.builtins.objects.function.PArguments;
 import com.oracle.graal.python.runtime.exception.PException;
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.TruffleStackTraceElement;
 import com.oracle.truffle.api.frame.Frame;
 import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.source.SourceSection;
 
 /**
  * A lazy representation of an exception traceback that can be evaluated to a python object by
@@ -111,6 +115,25 @@ public void setTraceback(PTraceback traceback) {
         this.materialized = true;
     }
 
+    @CompilerDirectives.TruffleBoundary
+    public static int getSourceLineNoOrDefault(PException exception, int defaultValue) {
+        final Node location = exception.getLocation();
+        if (location != null) {
+            final SourceSection sourceSection = location.getSourceSection();
+            if (sourceSection != null) {
+                return sourceSection.getStartLine();
+            }
+        }
+        return defaultValue;
+    }
+
+    public int getLineNo() {
+        if (exception != null) {
+            return getSourceLineNoOrDefault(exception, UNKNOWN_LINE_NUMBER);
+        }
+        return UNKNOWN_LINE_NUMBER;
+    }
+
     public boolean isMaterialized() {
         return materialized;
     }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/traceback/LazyTraceback.java

@@ -47,10 +47,11 @@
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 
 public final class PTraceback extends PythonBuiltinObject {
+    public static final int UNKNOWN_LINE_NUMBER = -2;
 
     private PFrame frame;
     private PFrame.Reference frameInfo;
-    private int lineno = -2;
+    private int lineno = UNKNOWN_LINE_NUMBER;
     private int lasti;
     private PTraceback next;
     private LazyTraceback lazyTraceback;
@@ -72,6 +73,7 @@ public PTraceback(PythonLanguage lang, LazyTraceback lazyTraceback) {
         this.lazyTraceback = lazyTraceback;
         this.frameInfo = lazyTraceback.getFrameInfo();
         this.frame = lazyTraceback.getFrame();
+        this.lineno = lazyTraceback.getLineNo();
     }
 
     public PFrame getFrame() {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/traceback/PTraceback.java

@@ -84,7 +84,7 @@ public Object dir(@SuppressWarnings("unused") PTraceback self) {
      *
      * @see GetTracebackNode
      */
-    abstract static class MaterializeTruffleStacktraceNode extends Node {
+    public abstract static class MaterializeTruffleStacktraceNode extends Node {
         public abstract void execute(PTraceback tb);
 
         @Specialization(guards = "tb.isMaterialized()")
@@ -186,6 +186,12 @@ private static PFrame materializeFrame(TruffleStackTraceElement element, Materia
     @Builtin(name = TB_FRAME, minNumOfPositionalArgs = 1, isGetter = true)
     @GenerateNodeFactory
     public abstract static class GetTracebackFrameNode extends PythonBuiltinNode {
+        public abstract PFrame execute(VirtualFrame frame, Object traceback);
+
+        public static GetTracebackFrameNode create() {
+            return TracebackBuiltinsFactory.GetTracebackFrameNodeFactory.create(null);
+        }
+
         @Specialization(guards = "hasPFrame(tb)")
         PFrame getExisting(PTraceback tb) {
             return tb.getFrame();

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/traceback/TracebackBuiltins.java

@@ -56,13 +56,21 @@ public abstract class BuiltinNames {
     public static final String __DEBUG__ = "__debug__";
 
     // sys
+    public static final String TRACEBACKLIMIT = "tracebacklimit";
     public static final String DISPLAYHOOK = "displayhook";
     public static final String BREAKPOINTHOOK = "breakpointhook";
     public static final String EXCEPTHOOK = "excepthook";
     public static final String UNRAISABLEHOOK = "unraisablehook";
     public static final String LAST_TYPE = "last_type";
     public static final String LAST_VALUE = "last_value";
     public static final String LAST_TRACEBACK = "last_traceback";
+    public static final String __EXCEPTHOOK__ = "__excepthook__";
+    public static final String __STDERR__ = "__stderr__";
+    public static final String STDERR = "stderr";
+    public static final String __STDIN__ = "__stdin__";
+    public static final String STDIN = "stdin";
+    public static final String __STDOUT__ = "__stdout__";
+    public static final String STDOUT = "stdout";
 
     // builtin functions
     public static final String ABS = "abs";

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/BuiltinNames.java

@@ -412,16 +412,44 @@ public static int indexOf(StringBuilder sb, String str, int start) {
         return sb.indexOf(str, start);
     }
 
+    @TruffleBoundary(allowInlining = true)
+    public static String substring(String s, int start, int end) {
+        return s.substring(start, end);
+    }
+
+    @TruffleBoundary(allowInlining = true)
+    public static String substring(String s, int start) {
+        return s.substring(start);
+    }
+
+    @TruffleBoundary(allowInlining = true)
+    public static int lastIndexOf(String s, char chr) {
+        return s.lastIndexOf(chr);
+    }
+
     @TruffleBoundary(allowInlining = true)
     public static StringBuilder append(StringBuilder sb, char c) {
         return sb.append(c);
     }
 
+    @TruffleBoundary(allowInlining = true)
+    public static StringBuilder append(StringBuilder sb, Object... args) {
+        for (Object arg : args) {
+            sb.append(arg);
+        }
+        return sb;
+    }
+
     @TruffleBoundary(allowInlining = true)
     public static StringBuilder append(StringBuilder sb, String s) {
         return sb.append(s);
     }
 
+    @TruffleBoundary(allowInlining = true)
+    public static StringBuilder append(StringBuilder sb, int i) {
+        return sb.append(i);
+    }
+
     @TruffleBoundary(allowInlining = true)
     public static StringBuilder append(StringBuilder sb, String s, int start, int end) {
         return sb.append(s, start, end);
@@ -437,6 +465,34 @@ public static StringBuilder appendCodePoint(StringBuilder sb, int codePoint) {
         return sb.appendCodePoint(codePoint);
     }
 
+    @TruffleBoundary(allowInlining = true)
+    public static String toString(CharSequence sequence) {
+        return sequence.toString();
+    }
+
+    @TruffleBoundary(allowInlining = true)
+    public static String trim(String s) {
+        return s.trim();
+    }
+
+    @TruffleBoundary(allowInlining = true)
+    public static String trim(CharSequence sequence) {
+        return sequence.toString().trim();
+    }
+
+    @TruffleBoundary(allowInlining = true)
+    public static String trimLeft(CharSequence sequence) {
+        int len = sequence.length();
+        int st = 0;
+
+        while ((st < len) && (sequence.charAt(st) <= ' ')) {
+            st++;
+        }
+
+        final String s = sequence.toString();
+        return (st > 0) ? substring(s, st, len) : s;
+    }
+
     @TruffleBoundary(allowInlining = true)
     public static int sbLength(StringBuilder sb) {
         return sb.length();

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/util/PythonUtils.java

@@ -60,72 +60,6 @@ def exit(arg=None):
     raise SystemExit(code)
 
 
-def make_excepthook():
-    def simple_print_traceback(e):
-        print("Traceback (most recent call last):", file=stderr);
-        tb = e.__traceback__
-        while tb is not None:
-            print('  File "%s", line %d, in %s' % (
-                tb.tb_frame.f_code.co_filename,
-                tb.tb_lineno,
-                tb.tb_frame.f_code.co_name
-            ), file=stderr)
-            tb = tb.tb_next
-        msg = str(e)
-        if msg:
-            print("%s: %s" % (type(e).__qualname__, msg), file=stderr)
-        else:
-            print(type(e).__qualname__, file=stderr)
-
-    def __print_traceback__(typ, value, tb):
-        if not isinstance(value, BaseException):
-            msg = "TypeError: print_exception(): Exception expected for value, {} found\n".format(type(value).__name__)
-            print(msg, file=stderr, end="")
-            return
-        try:
-            # CPython's C traceback printer diverges from traceback.print_exception in some details marked as (*)
-            import sys
-            import traceback
-            no_traceback = False
-            limit = getattr(sys, 'tracebacklimit', None)
-            if isinstance(limit, int):
-                if limit <= 0:
-                    # (*) the C traceback printer does nothing if the limit is <= 0,
-                    # but the exception message is still printed
-                    limit = 0
-                    no_traceback = True
-                else:
-                    # (*) CPython convert 'limit' to C long and if it overflows, it uses 'LONG_MAX'; we use Java int
-                    if limit > sys.maxsize:
-                        limit = sys.maxsize
-                    # (*) in the C printer limit is interpreted as -limit in format_exception
-                    limit = -limit
-            else:
-                # (*) non integer values of limit are interpreted as the default limit
-                limit = None
-            lines = traceback.format_exception(typ, value, tb, limit=limit)
-            # (*) if the exception cannot be printed, then the message differs between the C driver and format_exception
-            # We'd like to contribute to CPython to fix the divergence, but for now we do just a string substitution
-            # to pass the tests
-            lines[-1] = lines[-1].replace(f'<unprintable {typ.__name__} object>', f'<exception str() failed>')
-            if no_traceback:
-                lines = lines[-1:]
-            for line in lines:
-                print(line, file=stderr, end="")
-        except BaseException as exc:
-            print("Error in sys.excepthook:\n", file=stderr)
-            simple_print_traceback(exc)
-            print("\nOriginal exception was:\n", file=stderr)
-            simple_print_traceback(value)
-
-    return __print_traceback__
-
-
-__excepthook__ = make_excepthook()
-excepthook = __excepthook__
-del make_excepthook
-
-
 def make_unraisablehook():
     def __unraisablehook__(unraisable, /):
         try: