[GR-13793] [GH-52] Various fixes for textfsm package

PullRequest: graalpython/399

Author: timfel

graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/GraalPythonMain.java

@@ -158,6 +158,12 @@ protected List<String> preprocessArguments(List<String> givenArgs, Map<String, S
                 case "-LLI":
                     runLLI = true;
                     break;
+                case "-debug-java":
+                    if (!isAOT()) {
+                        subprocessArgs.add("Xrunjdwp:transport=dt_socket,server=y,address=8000,suspend=y");
+                        inputArgs.remove("-debug-java");
+                    }
+                    break;
                 case "-debug-perf":
                     subprocessArgs.add("Dgraal.TraceTruffleCompilation=true");
                     subprocessArgs.add("Dgraal.TraceTrufflePerformanceWarnings=true");
@@ -739,7 +745,7 @@ static List<String> getCmdline(List<String> args, List<String> subProcessDefs) {
             cmd.add("-cp");
             cmd.add(ManagementFactory.getRuntimeMXBean().getClassPath());
             for (String subProcArg : subProcessDefs) {
-                assert subProcArg.startsWith("D");
+                assert subProcArg.startsWith("D") || subProcArg.startsWith("X");
                 cmd.add("-" + subProcArg);
             }
             cmd.add(GraalPythonMain.class.getName());

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Python3Core.java

@@ -57,6 +57,7 @@
 import com.oracle.graal.python.builtins.modules.CtypesModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.ErrnoModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.FaulthandlerModuleBuiltins;
+import com.oracle.graal.python.builtins.modules.FcntlModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.FunctoolsModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.GcModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.IOModuleBuiltins;
@@ -329,7 +330,8 @@ private static final PythonBuiltins[] initializeBuiltins(Env env) {
                         new ZipImporterBuiltins(),
                         new ZipImportModuleBuiltins(),
                         new ZLibModuleBuiltins(),
-                        new MMapModuleBuiltins()));
+                        new MMapModuleBuiltins(),
+                        new FcntlModuleBuiltins()));
         if (!TruffleOptions.AOT) {
             ServiceLoader<PythonBuiltins> providers = ServiceLoader.load(PythonBuiltins.class);
             for (PythonBuiltins builtin : providers) {

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

@@ -29,6 +29,8 @@
 import static com.oracle.graal.python.builtins.objects.PNotImplemented.NOT_IMPLEMENTED;
 import static com.oracle.graal.python.nodes.BuiltinNames.ABS;
 import static com.oracle.graal.python.nodes.BuiltinNames.BIN;
+import static com.oracle.graal.python.nodes.BuiltinNames.BREAKPOINT;
+import static com.oracle.graal.python.nodes.BuiltinNames.BREAKPOINTHOOK;
 import static com.oracle.graal.python.nodes.BuiltinNames.CALLABLE;
 import static com.oracle.graal.python.nodes.BuiltinNames.CHR;
 import static com.oracle.graal.python.nodes.BuiltinNames.COMPILE;
@@ -39,6 +41,7 @@
 import static com.oracle.graal.python.nodes.BuiltinNames.EXEC;
 import static com.oracle.graal.python.nodes.BuiltinNames.GETATTR;
 import static com.oracle.graal.python.nodes.BuiltinNames.HASH;
+import static com.oracle.graal.python.nodes.BuiltinNames.HEX;
 import static com.oracle.graal.python.nodes.BuiltinNames.ID;
 import static com.oracle.graal.python.nodes.BuiltinNames.ISINSTANCE;
 import static com.oracle.graal.python.nodes.BuiltinNames.ISSUBCLASS;
@@ -55,8 +58,6 @@
 import static com.oracle.graal.python.nodes.BuiltinNames.ROUND;
 import static com.oracle.graal.python.nodes.BuiltinNames.SETATTR;
 import static com.oracle.graal.python.nodes.BuiltinNames.SUM;
-import static com.oracle.graal.python.nodes.BuiltinNames.BREAKPOINT;
-import static com.oracle.graal.python.nodes.BuiltinNames.BREAKPOINTHOOK;
 import static com.oracle.graal.python.nodes.BuiltinNames.__BUILTIN__;
 import static com.oracle.graal.python.nodes.BuiltinNames.__DEBUG__;
 import static com.oracle.graal.python.nodes.BuiltinNames.__DUMP_TRUFFLE_AST__;
@@ -170,8 +171,8 @@
 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.debug.Debugger;
 import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.debug.Debugger;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
@@ -351,6 +352,60 @@ protected static OctNode create() {
         }
     }
 
+    // hex(object)
+    @Builtin(name = HEX, fixedNumOfPositionalArgs = 1)
+    @TypeSystemReference(PythonArithmeticTypes.class)
+    @GenerateNodeFactory
+    public abstract static class HexNode extends PythonUnaryBuiltinNode {
+
+        public abstract String executeObject(Object x);
+
+        @TruffleBoundary
+        private static String buildString(boolean isNegative, String number) {
+            StringBuilder sb = new StringBuilder();
+            if (isNegative) {
+                sb.append('-');
+            }
+            sb.append("0x");
+            sb.append(number);
+            return sb.toString();
+        }
+
+        @Specialization
+        public String doL(long x) {
+            return buildString(x < 0, longToHexString(x));
+        }
+
+        @TruffleBoundary
+        private static String longToHexString(long x) {
+            return Long.toHexString(Math.abs(x));
+        }
+
+        @Specialization
+        public String doD(double x) {
+            throw raise(TypeError, "'%p' object cannot be interpreted as an integer", x);
+        }
+
+        @Specialization
+        @TruffleBoundary
+        public String doPI(PInt x) {
+            BigInteger value = x.getValue();
+            return buildString(value.compareTo(BigInteger.ZERO) == -1, value.abs().toString(8));
+        }
+
+        @Specialization
+        public String doO(Object x,
+                        @Cached("create()") CastToIntegerFromIndexNode toIntNode,
+                        @Cached("create()") HexNode recursiveNode) {
+            Object value = toIntNode.execute(x);
+            return recursiveNode.executeObject(value);
+        }
+
+        protected static HexNode create() {
+            return BuiltinFunctionsFactory.HexNodeFactory.create();
+        }
+    }
+
     // callable(object)
     @Builtin(name = CALLABLE, fixedNumOfPositionalArgs = 1)
     @GenerateNodeFactory

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2019, 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
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.graal.python.builtins.modules;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.oracle.graal.python.builtins.CoreFunctions;
+import com.oracle.graal.python.builtins.PythonBuiltins;
+import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
+import com.oracle.truffle.api.dsl.NodeFactory;
+
+@CoreFunctions(defineModule = "fcntl")
+public class FcntlModuleBuiltins extends PythonBuiltins {
+    @Override
+    protected List<? extends NodeFactory<? extends PythonBuiltinBaseNode>> getNodeFactories() {
+        return new ArrayList<>();
+    }
+}

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

@@ -1863,4 +1863,13 @@ String getStrError(int errno) {
             return result;
         }
     }
+
+    @Builtin(name = "ctermid", fixedNumOfPositionalArgs = 0)
+    @GenerateNodeFactory
+    abstract static class CtermId extends PythonBuiltinNode {
+        @Specialization
+        String ctermid() {
+            return "/dev/tty";
+        }
+    }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/str/StringBuiltins.java

@@ -1291,10 +1291,10 @@ private PList rsplitfields(String s, int maxsplit) {
     }
 
     // str.splitlines([keepends])
-    @Builtin(name = "splitlines", minNumOfPositionalArgs = 1, maxNumOfPositionalArgs = 2)
+    @Builtin(name = "splitlines", fixedNumOfPositionalArgs = 1, keywordArguments = {"keepends"})
     @GenerateNodeFactory
     @TypeSystemReference(PythonArithmeticTypes.class)
-    public abstract static class SplitLinesNode extends PythonBuiltinNode {
+    public abstract static class SplitLinesNode extends PythonBinaryBuiltinNode {
         @Child private ListAppendNode appendNode = ListAppendNode.create();
         @Child private CastToBooleanNode keepEndsNode = CastToBooleanNode.createIfTrueNode();
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TypeBuiltins.java

@@ -219,7 +219,14 @@ protected Object doItUnboxed(VirtualFrame frame, @SuppressWarnings("unused") PNo
         @Specialization(replaces = "doItUnboxed")
         protected Object doItUnboxedIndirect(VirtualFrame frame, @SuppressWarnings("unused") PNone noSelf, Object[] arguments, PKeyword[] keywords) {
             Object self = arguments[0];
-            return op(frame, (PythonAbstractClass) self, arguments, keywords, false);
+            if (PGuards.isClass(self)) {
+                return op(frame, (PythonAbstractClass) self, arguments, keywords, false);
+            } else if (self instanceof PythonBuiltinClassType) {
+                PythonBuiltinClass actual = getBuiltinPythonClass((PythonBuiltinClassType) self);
+                return op(frame, actual, arguments, keywords, false);
+            } else {
+                throw raise(TypeError, "descriptor '__call__' requires a 'type' object but received a '%p'", self);
+            }
         }
 
         @Specialization(limit = "getCallSiteInlineCacheMaxDepth()", guards = {"self == cachedSelf"})
@@ -869,4 +876,15 @@ Object setNative(@SuppressWarnings("unused") PythonAbstractNativeObject cls, @Su
             throw raise(PythonErrorType.RuntimeError, "can't set attributes of native type");
         }
     }
+
+    @Builtin(name = "__flags__", fixedNumOfPositionalArgs = 1, isGetter = true)
+    @GenerateNodeFactory
+    static abstract class FlagsNode extends PythonUnaryBuiltinNode {
+        @Child TypeNodes.GetTypeFlagsNode getFlagsNode = TypeNodes.GetTypeFlagsNode.create();
+
+        @Specialization
+        Object flags(PythonAbstractClass self) {
+            return getFlagsNode.execute(self);
+        }
+    }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TypeNodes.java

@@ -102,6 +102,7 @@
 public abstract class TypeNodes {
 
     public abstract static class GetTypeFlagsNode extends PNodeWithContext {
+        private static final int HEAPTYPE = 1 << 9;
 
         public abstract long execute(PythonAbstractClass clazz);
 
@@ -113,7 +114,7 @@ long doInitialized(PythonManagedClass clazz) {
         @Specialization
         long doGeneric(PythonManagedClass clazz) {
             if (!isInitialized(clazz)) {
-                return getValue(clazz.getFlagsContainer());
+                return getValue(clazz, clazz.getFlagsContainer());
             }
             return clazz.getFlagsContainer().flags;
         }
@@ -125,12 +126,16 @@ long doNative(PythonNativeClass clazz,
         }
 
         @TruffleBoundary
-        private static long getValue(FlagsContainer fc) {
+        private static long getValue(PythonManagedClass clazz, FlagsContainer fc) {
             // This method is only called from C code, i.e., the flags of the initial super class
             // must be available.
             if (fc.initialDominantBase != null) {
                 fc.flags = doSlowPath(fc.initialDominantBase);
                 fc.initialDominantBase = null;
+                if (clazz instanceof PythonClass) {
+                    // user classes are heap types
+                    fc.flags |= HEAPTYPE;
+                }
             }
             return fc.flags;
         }
@@ -142,7 +147,7 @@ public static long doSlowPath(PythonAbstractClass clazz) {
                 if (isInitialized(mclazz)) {
                     return mclazz.getFlagsContainer().flags;
                 } else {
-                    return getValue(mclazz.getFlagsContainer());
+                    return getValue(mclazz, mclazz.getFlagsContainer());
                 }
             } else if (PGuards.isNativeClass(clazz)) {
                 return doNativeGeneric((PythonNativeClass) clazz, createReadNode());