mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
614 lines
14 KiB
C#
614 lines
14 KiB
C#
//
|
|
// repl.cs: Support for using the compiler in interactive mode (read-eval-print loop)
|
|
//
|
|
// Authors:
|
|
// Miguel de Icaza ([email protected])
|
|
//
|
|
// Dual licensed under the terms of the MIT X11 or GNU GPL
|
|
//
|
|
// Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
|
|
// Copyright 2004, 2005, 2006, 2007, 2008 Novell, Inc
|
|
//
|
|
//
|
|
// TODO:
|
|
// Do not print results in Evaluate, do that elsewhere in preparation for Eval refactoring.
|
|
// Driver.PartialReset should not reset the coretypes, nor the optional types, to avoid
|
|
// computing that on every call.
|
|
//
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Globalization;
|
|
using System.Collections;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using System.Threading;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
|
|
using Mono.CSharp;
|
|
using Mono.Attach;
|
|
|
|
namespace Mono {
|
|
|
|
public class Driver {
|
|
|
|
static int Main (string [] args)
|
|
{
|
|
if (args.Length > 0 && args [0] == "--attach") {
|
|
new ClientCSharpShell (Int32.Parse (args [1])).Run ();
|
|
return 0;
|
|
} else if (args.Length > 0 && args [0].StartsWith ("--agent:")) {
|
|
new CSharpAgent (args [0]);
|
|
return 0;
|
|
} else {
|
|
try {
|
|
Evaluator.Init (args);
|
|
} catch {
|
|
return 1;
|
|
}
|
|
|
|
return new CSharpShell ().Run ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public class CSharpShell {
|
|
static bool isatty = true;
|
|
|
|
Mono.Terminal.LineEditor editor;
|
|
bool dumb;
|
|
|
|
protected virtual void ConsoleInterrupt (object sender, ConsoleCancelEventArgs a)
|
|
{
|
|
// Do not about our program
|
|
a.Cancel = true;
|
|
|
|
Mono.CSharp.Evaluator.Interrupt ();
|
|
}
|
|
|
|
void SetupConsole ()
|
|
{
|
|
string term = Environment.GetEnvironmentVariable ("TERM");
|
|
dumb = term == "dumb" || term == null || isatty == false;
|
|
|
|
editor = new Mono.Terminal.LineEditor ("csharp", 300);
|
|
#if false
|
|
//
|
|
// This is a sample of how completions sould be implemented.
|
|
//
|
|
editor.AutoCompleteEvent += delegate (string s, int pos){
|
|
|
|
// Single match: "Substring": Sub-string
|
|
if (s.EndsWith ("Sub")){
|
|
return new string [] { "string" };
|
|
}
|
|
|
|
// Multiple matches: "ToString" and "ToLower"
|
|
if (s.EndsWith ("T")){
|
|
return new string [] { "ToString", "ToLower" };
|
|
}
|
|
return null;
|
|
};
|
|
#endif
|
|
|
|
Console.CancelKeyPress += ConsoleInterrupt;
|
|
}
|
|
|
|
string GetLine (bool primary)
|
|
{
|
|
string prompt = primary ? InteractiveBase.Prompt : InteractiveBase.ContinuationPrompt;
|
|
|
|
if (dumb){
|
|
if (isatty)
|
|
Console.Write (prompt);
|
|
|
|
return Console.ReadLine ();
|
|
} else {
|
|
return editor.Edit (prompt, "");
|
|
}
|
|
}
|
|
|
|
delegate string ReadLiner (bool primary);
|
|
|
|
void InitializeUsing ()
|
|
{
|
|
Evaluate ("using System; using System.Linq; using System.Collections.Generic; using System.Collections;");
|
|
}
|
|
|
|
void InitTerminal ()
|
|
{
|
|
isatty = UnixUtils.isatty (0) && UnixUtils.isatty (1);
|
|
|
|
// Work around, since Console is not accounting for
|
|
// cursor position when writing to Stderr. It also
|
|
// has the undesirable side effect of making
|
|
// errors plain, with no coloring.
|
|
Report.Stderr = Console.Out;
|
|
SetupConsole ();
|
|
|
|
if (isatty)
|
|
Console.WriteLine ("Mono C# Shell, type \"help;\" for help\n\nEnter statements below.");
|
|
|
|
}
|
|
|
|
protected virtual void LoadStartupFiles ()
|
|
{
|
|
string dir = Path.Combine (
|
|
Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData),
|
|
"csharp");
|
|
if (!Directory.Exists (dir))
|
|
return;
|
|
|
|
ArrayList sources = new ArrayList ();
|
|
ArrayList libraries = new ArrayList ();
|
|
|
|
foreach (string file in System.IO.Directory.GetFiles (dir)){
|
|
string l = file.ToLower ();
|
|
|
|
if (l.EndsWith (".cs"))
|
|
sources.Add (file);
|
|
else if (l.EndsWith (".dll"))
|
|
libraries.Add (file);
|
|
}
|
|
|
|
foreach (string file in libraries){
|
|
Evaluator.LoadAssembly (file);
|
|
}
|
|
|
|
foreach (string file in sources){
|
|
try {
|
|
using (System.IO.StreamReader r = System.IO.File.OpenText (file)){
|
|
ReadEvalPrintLoopWith (p => r.ReadLine ());
|
|
}
|
|
} catch {
|
|
}
|
|
}
|
|
}
|
|
|
|
void ReadEvalPrintLoopWith (ReadLiner readline)
|
|
{
|
|
string expr = null;
|
|
while (!InteractiveBase.QuitRequested){
|
|
string input = readline (expr == null);
|
|
if (input == null)
|
|
return;
|
|
|
|
if (input == "")
|
|
continue;
|
|
|
|
expr = expr == null ? input : expr + "\n" + input;
|
|
|
|
expr = Evaluate (expr);
|
|
}
|
|
}
|
|
|
|
public int ReadEvalPrintLoop ()
|
|
{
|
|
InitTerminal ();
|
|
|
|
InitializeUsing ();
|
|
|
|
LoadStartupFiles ();
|
|
ReadEvalPrintLoopWith (GetLine);
|
|
|
|
return 0;
|
|
}
|
|
|
|
protected virtual string Evaluate (string input)
|
|
{
|
|
bool result_set;
|
|
object result;
|
|
|
|
try {
|
|
input = Evaluator.Evaluate (input, out result, out result_set);
|
|
|
|
if (result_set){
|
|
PrettyPrint (Console.Out, result);
|
|
Console.WriteLine ();
|
|
}
|
|
} catch (Exception e){
|
|
Console.WriteLine (e);
|
|
return null;
|
|
}
|
|
|
|
return input;
|
|
}
|
|
|
|
static void p (TextWriter output, string s)
|
|
{
|
|
output.Write (s);
|
|
}
|
|
|
|
static string EscapeString (string s)
|
|
{
|
|
return s.Replace ("\"", "\\\"");
|
|
}
|
|
|
|
static void EscapeChar (TextWriter output, char c)
|
|
{
|
|
if (c == '\''){
|
|
output.Write ("'\\''");
|
|
return;
|
|
}
|
|
if (c > 32){
|
|
output.Write ("'{0}'", c);
|
|
return;
|
|
}
|
|
switch (c){
|
|
case '\a':
|
|
output.Write ("'\\a'");
|
|
break;
|
|
|
|
case '\b':
|
|
output.Write ("'\\b'");
|
|
break;
|
|
|
|
case '\n':
|
|
output.Write ("'\\n'");
|
|
break;
|
|
|
|
case '\v':
|
|
output.Write ("'\\v'");
|
|
break;
|
|
|
|
case '\r':
|
|
output.Write ("'\\r'");
|
|
break;
|
|
|
|
case '\f':
|
|
output.Write ("'\\f'");
|
|
break;
|
|
|
|
case '\t':
|
|
output.Write ("'\\t");
|
|
break;
|
|
|
|
default:
|
|
output.Write ("'\\x{0:x}", (int) c);
|
|
break;
|
|
}
|
|
}
|
|
|
|
internal static void PrettyPrint (TextWriter output, object result)
|
|
{
|
|
if (result == null){
|
|
p (output, "null");
|
|
return;
|
|
}
|
|
|
|
if (result is Array){
|
|
Array a = (Array) result;
|
|
|
|
p (output, "{ ");
|
|
int top = a.GetUpperBound (0);
|
|
for (int i = a.GetLowerBound (0); i <= top; i++){
|
|
PrettyPrint (output, a.GetValue (i));
|
|
if (i != top)
|
|
p (output, ", ");
|
|
}
|
|
p (output, " }");
|
|
} else if (result is bool){
|
|
if ((bool) result)
|
|
p (output, "true");
|
|
else
|
|
p (output, "false");
|
|
} else if (result is string){
|
|
p (output, String.Format ("\"{0}\"", EscapeString ((string)result)));
|
|
} else if (result is IDictionary){
|
|
IDictionary dict = (IDictionary) result;
|
|
int top = dict.Count, count = 0;
|
|
|
|
p (output, "{");
|
|
foreach (DictionaryEntry entry in dict){
|
|
count++;
|
|
p (output, "{ ");
|
|
PrettyPrint (output, entry.Key);
|
|
p (output, ", ");
|
|
PrettyPrint (output, entry.Value);
|
|
if (count != top)
|
|
p (output, " }, ");
|
|
else
|
|
p (output, " }");
|
|
}
|
|
p (output, "}");
|
|
} else if (result is IEnumerable) {
|
|
int i = 0;
|
|
p (output, "{ ");
|
|
foreach (object item in (IEnumerable) result) {
|
|
if (i++ != 0)
|
|
p (output, ", ");
|
|
|
|
PrettyPrint (output, item);
|
|
}
|
|
p (output, " }");
|
|
} else if (result is char) {
|
|
EscapeChar (output, (char) result);
|
|
} else {
|
|
p (output, result.ToString ());
|
|
}
|
|
}
|
|
|
|
public CSharpShell ()
|
|
{
|
|
}
|
|
|
|
public virtual int Run ()
|
|
{
|
|
return ReadEvalPrintLoop ();
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// A shell connected to a CSharpAgent running in a remote process.
|
|
// - maybe add 'class_name' and 'method_name' arguments to LoadAgent.
|
|
// - Support Gtk and Winforms main loops if detected, this should
|
|
// probably be done as a separate agent in a separate place.
|
|
//
|
|
class ClientCSharpShell : CSharpShell {
|
|
NetworkStream ns, interrupt_stream;
|
|
|
|
public ClientCSharpShell (int pid)
|
|
{
|
|
// Create a server socket we listen on whose address is passed to the agent
|
|
TcpListener listener = new TcpListener (new IPEndPoint (IPAddress.Loopback, 0));
|
|
listener.Start ();
|
|
TcpListener interrupt_listener = new TcpListener (new IPEndPoint (IPAddress.Loopback, 0));
|
|
interrupt_listener.Start ();
|
|
|
|
string agent_assembly = typeof (ClientCSharpShell).Assembly.Location;
|
|
string agent_arg = String.Format ("--agent:{0}:{1}" ,
|
|
((IPEndPoint)listener.Server.LocalEndPoint).Port,
|
|
((IPEndPoint)interrupt_listener.Server.LocalEndPoint).Port);
|
|
|
|
VirtualMachine vm = new VirtualMachine (pid);
|
|
vm.Attach (agent_assembly, agent_arg);
|
|
|
|
/* Wait for the client to connect */
|
|
TcpClient client = listener.AcceptTcpClient ();
|
|
ns = client.GetStream ();
|
|
TcpClient interrupt_client = interrupt_listener.AcceptTcpClient ();
|
|
interrupt_stream = interrupt_client.GetStream ();
|
|
|
|
Console.WriteLine ("Connected.");
|
|
}
|
|
|
|
//
|
|
// A remote version of Evaluate
|
|
//
|
|
protected override string Evaluate (string input)
|
|
{
|
|
ns.WriteString (input);
|
|
while (true) {
|
|
AgentStatus s = (AgentStatus) ns.ReadByte ();
|
|
|
|
switch (s){
|
|
case AgentStatus.PARTIAL_INPUT:
|
|
return input;
|
|
|
|
case AgentStatus.ERROR:
|
|
string err = ns.GetString ();
|
|
Console.Error.WriteLine (err);
|
|
break;
|
|
|
|
case AgentStatus.RESULT_NOT_SET:
|
|
return null;
|
|
|
|
case AgentStatus.RESULT_SET:
|
|
string res = ns.GetString ();
|
|
Console.WriteLine (res);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override int Run ()
|
|
{
|
|
// The difference is that we do not call Evaluator.Init, that is done on the target
|
|
return ReadEvalPrintLoop ();
|
|
}
|
|
|
|
protected override void ConsoleInterrupt (object sender, ConsoleCancelEventArgs a)
|
|
{
|
|
// Do not about our program
|
|
a.Cancel = true;
|
|
|
|
interrupt_stream.WriteByte (0);
|
|
int c = interrupt_stream.ReadByte ();
|
|
if (c != -1)
|
|
Console.WriteLine ("Execution interrupted");
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Stream helper extension methods
|
|
//
|
|
public static class StreamHelper {
|
|
static DataConverter converter = DataConverter.LittleEndian;
|
|
|
|
public static int GetInt (this Stream stream)
|
|
{
|
|
byte [] b = new byte [4];
|
|
if (stream.Read (b, 0, 4) != 4)
|
|
throw new IOException ("End reached");
|
|
return converter.GetInt32 (b, 0);
|
|
}
|
|
|
|
public static string GetString (this Stream stream)
|
|
{
|
|
int len = stream.GetInt ();
|
|
byte [] b = new byte [len];
|
|
if (stream.Read (b, 0, len) != len)
|
|
throw new IOException ("End reached");
|
|
return Encoding.UTF8.GetString (b);
|
|
}
|
|
|
|
public static void WriteInt (this Stream stream, int n)
|
|
{
|
|
byte [] bytes = converter.GetBytes (n);
|
|
stream.Write (bytes, 0, bytes.Length);
|
|
}
|
|
|
|
public static void WriteString (this Stream stream, string s)
|
|
{
|
|
stream.WriteInt (s.Length);
|
|
byte [] bytes = Encoding.UTF8.GetBytes (s);
|
|
stream.Write (bytes, 0, bytes.Length);
|
|
}
|
|
}
|
|
|
|
public enum AgentStatus : byte {
|
|
// Received partial input, complete
|
|
PARTIAL_INPUT = 1,
|
|
|
|
// The result was set, expect the string with the result
|
|
RESULT_SET = 2,
|
|
|
|
// No result was set, complete
|
|
RESULT_NOT_SET = 3,
|
|
|
|
// Errors and warnings string follows
|
|
ERROR = 4,
|
|
}
|
|
|
|
//
|
|
// This is the agent loaded into the target process when using --attach.
|
|
//
|
|
class CSharpAgent
|
|
{
|
|
NetworkStream interrupt_stream;
|
|
|
|
public CSharpAgent (String arg)
|
|
{
|
|
new Thread (new ParameterizedThreadStart (Run)).Start (arg);
|
|
}
|
|
|
|
public void InterruptListener ()
|
|
{
|
|
while (true){
|
|
int b = interrupt_stream.ReadByte();
|
|
if (b == -1)
|
|
return;
|
|
Evaluator.Interrupt ();
|
|
interrupt_stream.WriteByte (0);
|
|
}
|
|
}
|
|
|
|
public void Run (object o)
|
|
{
|
|
string arg = (string)o;
|
|
string ports = arg.Substring (8);
|
|
int sp = ports.IndexOf (':');
|
|
int port = Int32.Parse (ports.Substring (0, sp));
|
|
int interrupt_port = Int32.Parse (ports.Substring (sp+1));
|
|
|
|
Console.WriteLine ("csharp-agent: started, connecting to localhost:" + port);
|
|
|
|
TcpClient client = new TcpClient ("127.0.0.1", port);
|
|
TcpClient interrupt_client = new TcpClient ("127.0.0.1", interrupt_port);
|
|
Console.WriteLine ("csharp-agent: connected.");
|
|
|
|
NetworkStream s = client.GetStream ();
|
|
interrupt_stream = interrupt_client.GetStream ();
|
|
new Thread (InterruptListener).Start ();
|
|
|
|
try {
|
|
Evaluator.Init (new string [0]);
|
|
} catch {
|
|
// TODO: send a result back.
|
|
Console.WriteLine ("csharp-agent: initialization failed");
|
|
return;
|
|
}
|
|
|
|
try {
|
|
// Add all assemblies loaded later
|
|
AppDomain.CurrentDomain.AssemblyLoad += AssemblyLoaded;
|
|
|
|
// Add all currently loaded assemblies
|
|
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies ())
|
|
Evaluator.ReferenceAssembly (a);
|
|
|
|
RunRepl (s);
|
|
} finally {
|
|
AppDomain.CurrentDomain.AssemblyLoad -= AssemblyLoaded;
|
|
client.Close ();
|
|
interrupt_client.Close ();
|
|
Console.WriteLine ("csharp-agent: disconnected.");
|
|
}
|
|
}
|
|
|
|
static void AssemblyLoaded (object sender, AssemblyLoadEventArgs e)
|
|
{
|
|
Evaluator.ReferenceAssembly (e.LoadedAssembly);
|
|
}
|
|
|
|
public void RunRepl (NetworkStream s)
|
|
{
|
|
string input = null;
|
|
|
|
while (!InteractiveBase.QuitRequested) {
|
|
try {
|
|
string error_string;
|
|
StringWriter error_output = new StringWriter ();
|
|
Report.Stderr = error_output;
|
|
|
|
string line = s.GetString ();
|
|
|
|
bool result_set;
|
|
object result;
|
|
|
|
if (input == null)
|
|
input = line;
|
|
else
|
|
input = input + "\n" + line;
|
|
|
|
try {
|
|
input = Evaluator.Evaluate (input, out result, out result_set);
|
|
} catch (Exception e) {
|
|
s.WriteByte ((byte) AgentStatus.ERROR);
|
|
s.WriteString (e.ToString ());
|
|
s.WriteByte ((byte) AgentStatus.RESULT_NOT_SET);
|
|
continue;
|
|
}
|
|
|
|
if (input != null){
|
|
s.WriteByte ((byte) AgentStatus.PARTIAL_INPUT);
|
|
continue;
|
|
}
|
|
|
|
// Send warnings and errors back
|
|
error_string = error_output.ToString ();
|
|
if (error_string.Length != 0){
|
|
s.WriteByte ((byte) AgentStatus.ERROR);
|
|
s.WriteString (error_output.ToString ());
|
|
}
|
|
|
|
if (result_set){
|
|
s.WriteByte ((byte) AgentStatus.RESULT_SET);
|
|
StringWriter sr = new StringWriter ();
|
|
CSharpShell.PrettyPrint (sr, result);
|
|
s.WriteString (sr.ToString ());
|
|
} else {
|
|
s.WriteByte ((byte) AgentStatus.RESULT_NOT_SET);
|
|
}
|
|
} catch (IOException) {
|
|
break;
|
|
} catch (Exception e){
|
|
Console.WriteLine (e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace Mono.Management
|
|
{
|
|
interface IVirtualMachine {
|
|
void LoadAgent (string filename, string args);
|
|
}
|
|
}
|
|
|
|
|