StreamFromPythonFile(PythonFile pyFile)
        {
            FieldInfo streamField = (FieldInfo)(pyFile.GetType().GetMember(
                                                    "_stream", BindingFlags.NonPublic | BindingFlags.Instance)[0]);

            return((FileStream)streamField.GetValue(pyFile));
        }
Пример #2
0
        internal static void showwarning(CodeContext context, object message, PythonType category, string filename, int lineno, [DefaultParameterValue(null)] object file, [DefaultParameterValue(null)] string line)
        {
            string text = formatwarning(message, category, filename, lineno, line);

            try {
                if (file == null)
                {
                    PythonContext pContext = PythonContext.GetContext(context);
                    PythonFile    stderr   = pContext.GetSystemStateValue("stderr") as PythonFile;
                    if (stderr != null)
                    {
                        stderr.write(text);
                    }
                    else
                    {
                        // use CLR stderr if python's is unavailable
                        Console.Error.Write(text);
                    }
                }
                else
                {
                    if (file is PythonFile)
                    {
                        ((PythonFile)file).write(text);
                    }
                    else if (file is TextWriter)
                    {
                        ((TextWriter)file).Write(text);
                    } // unrecognized file type - warning is lost
                }
            } catch (IOException) {
                // invalid file - warning is lost
            }
        }
Пример #3
0
        public static object Open(ICallerContext context, string filename, int flag, int mode)
        {
            FileStream fs = File.Open(filename, FileModeFromFlags(flag), FileAccessFromFlags(flag));
            PythonFile pf = PythonFile.Make(context, null, fs);

            return(PythonFileManager.GetIdFromFile(pf));
        }
Пример #4
0
        IC_PyFile_AsFile(IntPtr pyFilePtr)
        {
            try
            {
                if (this.FILEs.ContainsKey(pyFilePtr))
                {
                    return(this.FILEs[pyFilePtr]);
                }

                PythonFile pyFile = (PythonFile)this.Retrieve(pyFilePtr);

                this.PrintToStdErr("Warning: creating unmanaged FILE* from managed stream. Please use ironclad.open with this extension.");
                int    fd   = this.ConvertPyFileToDescriptor(pyFile);
                IntPtr FILE = IntPtr.Zero;
                if (InappropriateReflection.StreamFromPythonFile(pyFile).CanWrite)
                {
                    FILE = Unmanaged._fdopen(fd, "w");
                }
                else
                {
                    FILE = Unmanaged._fdopen(fd, "r");
                }
                this.FILEs[pyFilePtr] = FILE;
                return(FILE);
            }
            catch (Exception e)
            {
                this.LastException = e;
                return(IntPtr.Zero);
            }
        }
Пример #5
0
        ConvertPyFileToDescriptor(PythonFile pyFile)
        {
            FileStream stream     = InappropriateReflection.StreamFromPythonFile(pyFile);
            SafeHandle safeHandle = stream.SafeFileHandle;
            IntPtr     handle     = safeHandle.DangerousGetHandle();

            return(Unmanaged._open_osfhandle(handle, 0));
        }
Пример #6
0
        /// <summary>
        /// Get a logger which logs to the console verbose logs
        /// </summary>
        /// <param name="file">A python file object to use for output</param>
        /// <returns>The new logger</returns>
        public static Logger GetVerboseLogger(PythonFile file)
        {
            Logger l = GetLogger(file);

            l.LogLevel = Logger.LogEntryType.All;

            return(l);
        }
Пример #7
0
        /// <summary>
        /// Get a logger which logs to the console
        /// </summary>
        /// <param name="file">A python file object to use for output</param>
        /// <returns>The new logger</returns>
        public static Logger GetLogger(PythonFile file)
        {
            Logger ret = new Logger();

            ret.LogEntryAdded += (sender, e) =>
                                 ret_LogEntryAdded(file, sender, e);

            return(ret);
        }
Пример #8
0
        public static void dump(object value, PythonFile /*!*/ file, int version)
        {
            if (file == null)
            {
                throw PythonOps.TypeError("expected file, found None");
            }

            file.write(dumps(value, version));
        }
Пример #9
0
        public static object load(PythonFile /*!*/ file)
        {
            if (file == null)
            {
                throw PythonOps.TypeError("expected file, found None");
            }

            return(BytesToObject(FileEnumerator(file)));
        }
Пример #10
0
        static Analyzer()
        {
            state = new SystemState();
            PythonFile empty = new PythonFile(System.IO.Stream.Null, System.Text.Encoding.Default, "rw");

            state.__stderr__ = empty;
            state.__stdin__  = empty;
            state.__stdout__ = empty;
        }
Пример #11
0
        private static IFile?Parse(FileInfo fileInfo)
        {
            IFile?parsedFile = null;

            switch (fileInfo.Extension)
            {
            case ".ps1":
            case ".bat":
            case ".sh":
            case ".cmd":
                parsedFile = new ShellFile(fileInfo);
                break;

            case ".html":
            case ".md":
                parsedFile = new DocumentationFile(fileInfo);
                break;

            case ".properties":
            case ".xml":
            case ".cfg":
            case ".conf":
            case ".gitignore":
            case ".yml":
            case ".yaml":
            case ".gradle":
            case FileExtensions.Json:
                parsedFile = new ConfigurationFile(fileInfo);
                break;

            case ".py":
                parsedFile = new PythonFile(fileInfo);
                break;

            case ".scala":
                parsedFile = new ScalaFile(fileInfo);
                break;

            case FileExtensions.Java:
                parsedFile = new JavaSourceFile(fileInfo);
                break;

            case ".png":
            default:
                break;
            }
            ;

            if (parsedFile == null && extensions.Add(fileInfo.FullName))
            {
                Console.WriteLine(fileInfo.FullName);
            }

            return(parsedFile);
        }
Пример #12
0
 private static Stream OpenFile(CodeContext /*!*/ context, PlatformAdaptationLayer pal, string name, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
 {
     try {
         return(pal.OpenInputFileStream(name, fileMode, fileAccess, fileShare));
     } catch (UnauthorizedAccessException e) {
         throw PythonFile.ToIoException(context, name, e);
     } catch (IOException e) {
         PythonFile.AddFilename(context, name, e);
         throw;
     }
 }
Пример #13
0
        public static void Dump(object value, object file, object version)
        {
            PythonFile pf = file as PythonFile;

            if (pf == null)
            {
                throw Ops.TypeError("expected file, found '{0}'", Ops.GetDynamicType(file).__name__);
            }

            pf.Write(DumpString(value, version));
        }
Пример #14
0
        public static object Load(object file)
        {
            PythonFile pf = file as PythonFile;

            if (pf == null)
            {
                throw Ops.TypeError("expected file, found '{0}'", Ops.GetDynamicType(file).__name__);
            }

            return(LoadString(pf.Read()));
        }
Пример #15
0
        static void ret_LogEntryAdded(PythonFile file, object sender, Logger.LogEntryAddedEventArgs e)
        {
            string text = e.LogEntry.Text;

            if (e.LogEntry.ExceptionObject != null)
            {
                text = e.LogEntry.ExceptionObject.ToString();
            }

            file.write(String.Format("[{0}] {1} {2}: {3}\n", e.LogEntry.EntryType, e.LogEntry.Timestamp, e.LogEntry.SourceName, text));
        }
Пример #16
0
        private static IEnumerator <byte> FileEnumerator(PythonFile /*!*/ file)
        {
            for (; ;)
            {
                string data = file.read(1);
                if (data.Length == 0)
                {
                    yield break;
                }

                yield return((byte)data[0]);
            }
        }
Пример #17
0
        StoreTyped(PythonFile obj)
        {
            IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyFileObject)));

            CPyMarshal.Zero(ptr, Marshal.SizeOf(typeof(PyFileObject)));
            CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 1);
            CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.PyFile_Type);
            CPyMarshal.WriteIntField(ptr, typeof(PyFileObject), "f_fp", -2);
            CPyMarshal.WritePtrField(ptr, typeof(PyFileObject), "f_name", this.Store(obj.name));
            CPyMarshal.WritePtrField(ptr, typeof(PyFileObject), "f_mode", this.Store(obj.mode));
            this.map.Associate(ptr, obj);
            return(ptr);
        }
Пример #18
0
        public static object get_osfhandle(CodeContext context, int fd)
        {
            PythonFile pfile = context.LanguageContext.FileManager.GetFileFromId(context.LanguageContext, fd);

            object handle;

            if (pfile.TryGetFileHandle(out handle))
            {
                return(handle);
            }

            return(-1);
        }
Пример #19
0
 IC_PyFile_WriteString(string s, IntPtr filePtr)
 {
     try
     {
         PythonFile file = (PythonFile)this.Retrieve(filePtr);
         file.write(s);
         return(0);
     }
     catch (Exception e)
     {
         this.LastException = e;
         return(-1);
     }
 }
Пример #20
0
        public static object get_osfhandle(CodeContext context, int fd)
        {
            PythonFile pfile = context.LanguageContext.FileManager.GetFileFromId(context.LanguageContext, fd);

            FileStream stream = pfile._stream as FileStream;

            if (stream != null)
            {
#pragma warning disable 618 // System.IO.FileStream.Handle is obsolete
                return(stream.Handle.ToPython());

#pragma warning restore 618
            }
            return(-1);
        }
Пример #21
0
        public static int setmode(CodeContext context, int fd, int flags)
        {
            PythonFile pfile = context.LanguageContext.FileManager.GetFileFromId(context.LanguageContext, fd);
            int        oldMode;

            if (flags == PythonNT.O_TEXT)
            {
                oldMode = pfile.SetMode(context, true) ? PythonNT.O_TEXT : PythonNT.O_BINARY;
            }
            else if (flags == PythonNT.O_BINARY)
            {
                oldMode = pfile.SetMode(context, false) ? PythonNT.O_TEXT : PythonNT.O_BINARY;
            }
            else
            {
                throw PythonOps.ValueError("unknown mode: {0}", flags);
            }
            return(oldMode);
        }
Пример #22
0
        public static object load_module(CodeContext /*!*/ context, string name, PythonFile file, string filename, PythonTuple /*!*/ description)
        {
            if (description == null)
            {
                throw PythonOps.TypeError("load_module() argument 4 must be 3-item sequence, not None");
            }
            else if (description.__len__() != 3)
            {
                throw PythonOps.TypeError("load_module() argument 4 must be sequence of length 3, not {0}", description.__len__());
            }

            PythonContext pythonContext = PythonContext.GetContext(context);

            // already loaded? do reload()
            PythonModule module = pythonContext.GetModuleByName(name);

            if (module != null)
            {
                Importer.ReloadModule(context, module, file);
                return(module);
            }

            int type = PythonContext.GetContext(context).ConvertToInt32(description[2]);

            switch (type)
            {
            case PythonSource:
                return(LoadPythonSource(pythonContext, name, file, filename));

            case CBuiltin:
                return(LoadBuiltinModule(context, name));

            case PackageDirectory:
                return(LoadPackageDirectory(pythonContext, name, filename));

            default:
                throw PythonOps.TypeError("don't know how to import {0}, (type code {1}", name, type);
            }
        }
Пример #23
0
        private static PythonTuple FindModulePath(CodeContext /*!*/ context, string name, List path)
        {
            Debug.Assert(path != null);

            if (name == null)
            {
                throw PythonOps.TypeError("find_module() argument 1 must be string, not None");
            }

            PlatformAdaptationLayer pal = context.LanguageContext.DomainManager.Platform;

            foreach (object d in path)
            {
                string dir = d as string;
                if (dir == null)
                {
                    continue;               // skip invalid entries
                }
                string pathName = Path.Combine(dir, name);
                if (pal.DirectoryExists(pathName))
                {
                    if (pal.FileExists(Path.Combine(pathName, "__init__.py")))
                    {
                        return(PythonTuple.MakeTuple(null, pathName, PythonTuple.MakeTuple("", "", PackageDirectory)));
                    }
                }

                string fileName = pathName + ".py";
                if (pal.FileExists(fileName))
                {
                    Stream     fs = pal.OpenInputFileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                    PythonFile pf = PythonFile.Create(context, fs, fileName, "U");
                    return(PythonTuple.MakeTuple(pf, fileName, PythonTuple.MakeTuple(".py", "U", PythonSource)));
                }
            }
            throw PythonOps.ImportError("No module named {0}", name);
        }
Пример #24
0
 IC_PyFile_WriteObject(IntPtr objPtr, IntPtr filePtr, int use_str)
 {
     try
     {
         object obj = this.Retrieve(objPtr);
         string s;
         if (use_str % 2 == 1)
         {
             s = (string)PythonCalls.Call(Builtin.str, new object[] { obj });
         }
         else
         {
             s = (string)Builtin.repr(this.scratchContext, obj);
         }
         PythonFile file = (PythonFile)this.Retrieve(filePtr);
         file.write(s);
         return(0);
     }
     catch (Exception e)
     {
         this.LastException = e;
         return(-1);
     }
 }
Пример #25
0
 public static object load_dynamic(string name, string pathname, PythonFile file)
 {
     return(null);
 }
Пример #26
0
        private static PythonModule /*!*/ LoadPythonSource(PythonContext /*!*/ context, string /*!*/ name, PythonFile /*!*/ file, string /*!*/ fileName)
        {
            SourceUnit sourceUnit = context.CreateSnippet(file.read(), String.IsNullOrEmpty(fileName) ? null : fileName, SourceCodeKind.File);

            return(context.CompileModule(fileName, name, sourceUnit, ModuleOptions.Initialize));
        }
Пример #27
0
            public FileIO(CodeContext /*!*/ context, int fd, [DefaultParameterValue("r")] string mode, [DefaultParameterValue(true)] bool closefd)
                : base(context)
            {
                if (fd < 0)
                {
                    throw PythonOps.ValueError("fd must be >= 0");
                }

                PythonContext pc = PythonContext.GetContext(context);

                PythonFile pf     = null;
                FileIO     file   = null;
                Stream     stream = null;
                object     temp;

                if (pc.FileManager.TryGetFileFromId(pc, fd, out pf))
                {
                    name = (object)pf.name ?? fd;
                }
                else if (pc.FileManager.TryGetObjectFromId(pc, fd, out temp))
                {
                    file = temp as FileIO;
                    if (file != null)
                    {
                        name = file.name ?? fd;
                    }
                    else
                    {
                        stream = temp as Stream;
                        if (stream != null)
                        {
                            name = fd;
                        }
                    }
                }

                _context = pc;
                switch (StandardizeMode(mode))
                {
                case "r": _mode = "rb"; break;

                case "w": _mode = "wb"; break;

                case "a": _mode = "w"; break;

                case "r+":
                case "+r": _mode = "rb+"; break;

                case "w+":
                case "+w": _mode = "rb+"; break;

                case "a+":
                case "+a": _mode = "r+"; break;

                default:
                    BadMode(mode);
                    break;
                }

                if (file != null)
                {
                    _readStream  = file._readStream;
                    _writeStream = file._writeStream;
                }
                else if (pf != null)
                {
                    _readStream  = pf._stream;
                    _writeStream = pf._stream;
                }
                else if (stream != null)
                {
                    _readStream  = stream;
                    _writeStream = stream;
                }
                _closefd = closefd;
            }
Пример #28
0
 public static void dump(object value, PythonFile /*!*/ file)
 {
     dump(value, file, version);
 }
Пример #29
0
        public static object GetFileFStats(int fd)
        {
            PythonFile pf = PythonFileManager.GetFileFromId(fd);

            return(GetFileStats(pf.name));
        }
Пример #30
0
        public static object load_source(CodeContext /*!*/ context, string /*!*/ name, string /*!*/ pathname, PythonFile /*!*/ file)
        {
            if (name == null)
            {
                throw PythonOps.TypeError("load_source() argument 1 must be string, not None");
            }
            if (pathname == null)
            {
                throw PythonOps.TypeError("load_source() argument 2 must be string, not None");
            }
            if (file == null)
            {
                throw PythonOps.TypeError("load_source() argument 3 must be file, not None");
            }

            return(LoadPythonSource(PythonContext.GetContext(context), name, file, pathname));
        }