public TypedVariableReferenceExpression(Mono.Cecil.Cil.VariableReference variable)
: base(variable)
{
var type = Type.GetType(variable.VariableType.FullName, true);
this.ElementType = TypedTransformer.GetElementType(type);
}
public ILSpyTreeNode CreateNode(Mono.Cecil.Resource resource)
{
EmbeddedResource er = resource as EmbeddedResource;
if (er != null)
return CreateNode(er.Name, er.GetResourceStream());
return null;
}
static string PostStream (Mono.Security.Protocol.Tls.SecurityProtocolType protocol, string url, byte[] buffer)
{
Uri uri = new Uri (url);
string post = "POST " + uri.AbsolutePath + " HTTP/1.0\r\n";
post += "Content-Type: application/x-www-form-urlencoded\r\n";
post += "Content-Length: " + (buffer.Length + 5).ToString () + "\r\n";
post += "Host: " + uri.Host + "\r\n\r\n";
post += "TEST=";
byte[] bytes = Encoding.Default.GetBytes (post);
IPHostEntry host = Dns.Resolve (uri.Host);
IPAddress ip = host.AddressList [0];
Socket socket = new Socket (ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Connect (new IPEndPoint (ip, uri.Port));
NetworkStream ns = new NetworkStream (socket, false);
SslClientStream ssl = new SslClientStream (ns, uri.Host, false, protocol);
ssl.ServerCertValidationDelegate += new CertificateValidationCallback (CertificateValidation);
ssl.Write (bytes, 0, bytes.Length);
ssl.Write (buffer, 0, buffer.Length);
ssl.Flush ();
StreamReader reader = new StreamReader (ssl, Encoding.UTF8);
string result = reader.ReadToEnd ();
int start = result.IndexOf ("\r\n\r\n") + 4;
start = result.IndexOf ("\r\n\r\n") + 4;
return result.Substring (start);
}
public void LoadModule(System.IO.Stream dllStream, System.IO.Stream pdbStream, Mono.Cecil.Cil.ISymbolReaderProvider debugInfoLoader)
{
var module = Mono.Cecil.ModuleDefinition.ReadModule(dllStream);
if (debugInfoLoader != null && pdbStream != null)
{
module.ReadSymbols(debugInfoLoader.GetSymbolReader(module, pdbStream));
}
if (module.HasAssemblyReferences)
{
foreach (var ar in module.AssemblyReferences)
{
if (moduleref.Contains(ar.Name) == false)
moduleref.Add(ar.Name);
if (moduleref.Contains(ar.FullName) == false)
moduleref.Add(ar.FullName);
}
}
//mapModule[module.Name] = module;
if (module.HasTypes)
{
foreach (var t in module.Types)
{
mapType[t.FullName] = new Type_Common_CLRSharp(this, t);
}
}
}
// fd, error
public static void open(string path, OpenFlags flags, Mono.Unix.Native.FilePermissions mode, Action<FileStream, Exception> callback)
{
ThreadPool.QueueUserWorkItem(a =>
{
try
{
FileMode fm;
FileAccess fa;
FileShare fs = FileShare.ReadWrite;
if (0 != (flags & OpenFlags.O_CREAT))
fm = FileMode.Create;
else
fm = FileMode.Open;
if (0 != (flags & OpenFlags.O_RDWR))
fa = FileAccess.ReadWrite;
else if (0 != (flags & OpenFlags.O_WRONLY))
fa = FileAccess.Write;
else
fa = FileAccess.Read;
var stream = new FileStream(path, fm, fa, fs);
Boundary.Instance.ExecuteOnTargetLoop (() => callback (stream, null));
}
catch(Exception e)
{
Boundary.Instance.ExecuteOnTargetLoop (() => callback (null, e));
}
});
}
protected async override Task Process(Mono.Net.HttpListenerContext context)
{
var writer = new StreamWriter(context.Response.OutputStream);
writer.Write(string.Empty);
writer.Flush();
context.Response.OutputStream.Close();
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyData"/> class.
/// </summary>
/// <param name="assembly">The assembly.</param>
private AssemblyData(Mono.Cecil.AssemblyDefinition assembly)
{
if (assembly == null)
throw new ArgumentNullException("assembly");
_assemblyDefinition = assembly;
Refresh();
}
/// <summary>
/// 组建被添加到mono的时候
/// </summary>
/// <param name="mono"></param>
public override void OnBeAdded(IMono mono)
{
base.OnBeAdded(mono);
MainCamera = Camera.main;
MainCameraTrans = MainCamera.transform;
HighlighterRenderer = Mono.GetComponentInChildren <HighlighterRenderer>();
}
public override void Update()
{
if (ControlEnabled && RobotProvider.RobotActive && !Input.GetKey(KeyCode.LeftAlt) && !Input.GetKey(KeyCode.RightAlt))
{
if (InputControl.GetMouseButton(0))
{
if (GameObject.Find("ChangeRobotPanel") || GameObject.Find("ChangeFieldPanel"))
{
ControlEnabled = false;
}
else
{
rotationVector.x -= InputControl.GetAxis("Mouse Y") * rotationSpeed;
rotationVector.y += Input.GetAxis("Mouse X") * rotationSpeed;
ControlEnabled = true;
}
}
//Use WASD to move camera position
positionVector += Input.GetAxis("CameraHorizontal") * Mono.transform.right * transformSpeed * Time.deltaTime;
positionVector += Input.GetAxis("CameraVertical") * Mono.transform.forward * transformSpeed * Time.deltaTime;
zoomValue = Mathf.Max(Mathf.Min(zoomValue - InputControl.GetAxis("Mouse ScrollWheel") * scrollWheelSensitivity, 60.0f), 10.0f);
lagRotVector = CalculateLagVector(lagRotVector, rotationVector, lagResponsiveness);
lagZoom = CalculateLagScalar(lagZoom, zoomValue, lagResponsiveness);
Mono.transform.position += positionVector;
positionVector = Vector3.zero;
Mono.transform.eulerAngles = lagRotVector;
Mono.GetComponent <Camera>().fieldOfView = lagZoom;
}
}
public ParameterDataProvider(Mono.TextEditor.TextEditor editor, string functionName)
{
//this.editor = editor;
List<CompletionData> cd = editor.GetCompletionMemberData(functionName);
if(cd!= null)
list.AddRange(cd);
}
public ModuleMetadataInfo(Module module, Mono.Cecil.ModuleDefinition cecilModule)
{
this.Module = module;
this.CecilModule = cecilModule;
typeRefLoader = new CecilLoader();
typeRefLoader.SetCurrentModule(cecilModule);
}
public XSPWorker(Socket client, EndPoint localEP, ApplicationServer server,
bool secureConnection,
Mono.Security.Protocol.Tls.SecurityProtocolType SecurityProtocol,
X509Certificate cert,
PrivateKeySelectionCallback keyCB,
bool allowClientCert,
bool requireClientCert)
{
if (secureConnection) {
ssl = new SslInformation ();
ssl.AllowClientCertificate = allowClientCert;
ssl.RequireClientCertificate = requireClientCert;
ssl.RawServerCertificate = cert.GetRawCertData ();
netStream = new LingeringNetworkStream (client, true);
SslServerStream s = new SslServerStream (netStream, cert, requireClientCert, false);
s.PrivateKeyCertSelectionDelegate += keyCB;
s.ClientCertValidationDelegate += new CertificateValidationCallback (ClientCertificateValidation);
stream = s;
} else {
netStream = new LingeringNetworkStream (client, false);
stream = netStream;
}
sock = client;
this.server = server;
this.remoteEP = (IPEndPoint) client.RemoteEndPoint;
this.localEP = (IPEndPoint) localEP;
}
/// <summary>
/// Loads library in a platform specific way.
/// </summary>
static IntPtr PlatformSpecificLoadLibrary(string libraryPath)
{
if (IsWindows)
{
return(Windows.LoadLibrary(libraryPath));
}
if (IsLinux)
{
if (IsMono)
{
return(Mono.dlopen(libraryPath, RTLD_GLOBAL + RTLD_LAZY));
}
if (IsNetCore)
{
return(CoreCLR.dlopen(libraryPath, RTLD_GLOBAL + RTLD_LAZY));
}
return(Linux.dlopen(libraryPath, RTLD_GLOBAL + RTLD_LAZY));
}
if (IsMacOSPlatform)
{
return(MacOSX.dlopen(libraryPath, RTLD_GLOBAL + RTLD_LAZY));
}
throw new InvalidOperationException("Unsupported platform.");
}
protected override Gtk.Window CreateTooltipWindow (Mono.TextEditor.TextEditor editor, int offset, Gdk.ModifierType modifierState, TooltipItem item)
{
LanguageItemWindow result = new LanguageItemWindow ((ExtensibleTextEditor) editor, modifierState, null, (string)item.Item, null);
if (result.IsEmpty)
return null;
return result;
}
public override void ProcessType(Mono.Cecil.TypeDefinition type)
{
switch (type.Namespace) {
case "System.Runtime.Serialization.Json":
switch (type.Name) {
case "JsonFormatWriterInterpreter":
TypeDefinition jwd = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.Json.JsonWriterDelegator");
PreserveMethods (jwd);
break;
}
break;
case "System.Runtime.Serialization":
// MS referencesource use reflection to call the required methods to serialize each PrimitiveDataContract subclasses
// this goes thru XmlFormatGeneratorStatics and it's a better candidate (than PrimitiveDataContract) as there are other callers
switch (type.Name) {
case "XmlFormatGeneratorStatics":
TypeDefinition xwd = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.XmlWriterDelegator");
PreserveMethods (xwd);
TypeDefinition xoswc = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.XmlObjectSerializerWriteContext");
PreserveMethods (xoswc);
TypeDefinition xosrc = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.XmlObjectSerializerReadContext");
PreserveMethods (xosrc);
TypeDefinition xrd = GetType ("System.Runtime.Serialization", "System.Runtime.Serialization.XmlReaderDelegator");
PreserveMethods (xrd);
break;
case "CollectionDataContract":
// ensure the nested type, DictionaryEnumerator and GenericDictionaryEnumerator`2, can be created thru reflection
foreach (var nt in type.NestedTypes)
PreserveConstructors (nt);
break;
}
break;
}
}
public static string GenerateHtml (TextDocument doc, Mono.TextEditor.Highlighting.ISyntaxMode mode, Mono.TextEditor.Highlighting.ColorScheme style, ITextEditorOptions options)
{
var htmlText = new StringBuilder ();
htmlText.AppendLine (@"<!DOCTYPE HTML PUBLIC ""-//W3C//DTD HTML 4.0 Transitional//EN"">");
htmlText.AppendLine ("<HTML>");
htmlText.AppendLine ("<HEAD>");
htmlText.AppendLine ("<META HTTP-EQUIV=\"CONTENT-TYPE\" CONTENT=\"text/html; charset=utf-8\">");
htmlText.AppendLine ("<META NAME=\"GENERATOR\" CONTENT=\"Mono Text Editor\">");
htmlText.AppendLine ("</HEAD>");
htmlText.AppendLine ("<BODY>");
var selection = new TextSegment (0, doc.TextLength);
int startLineNumber = doc.OffsetToLineNumber (selection.Offset);
int endLineNumber = doc.OffsetToLineNumber (selection.EndOffset);
htmlText.AppendLine ("<FONT face = '" + options.Font.Family + "'>");
bool first = true;
if (mode is SyntaxMode) {
SyntaxModeService.StartUpdate (doc, (SyntaxMode)mode, selection.Offset, selection.EndOffset);
SyntaxModeService.WaitUpdate (doc);
}
foreach (var line in doc.GetLinesBetween (startLineNumber, endLineNumber)) {
if (!first) {
htmlText.AppendLine ("<BR>");
} else {
first = false;
}
if (mode == null) {
AppendHtmlText (htmlText, doc, options, System.Math.Max (selection.Offset, line.Offset), System.Math.Min (line.EndOffset, selection.EndOffset));
continue;
}
int curSpaces = 0;
foreach (var chunk in mode.GetChunks (style, line, line.Offset, line.Length)) {
int start = System.Math.Max (selection.Offset, chunk.Offset);
int end = System.Math.Min (chunk.EndOffset, selection.EndOffset);
var chunkStyle = style.GetChunkStyle (chunk);
if (start < end) {
htmlText.Append ("<SPAN style='");
if (chunkStyle.FontWeight != Xwt.Drawing.FontWeight.Normal)
htmlText.Append ("font-weight:" + ((int)chunkStyle.FontWeight) + ";");
if (chunkStyle.FontStyle != Xwt.Drawing.FontStyle.Normal)
htmlText.Append ("font-style:" + chunkStyle.FontStyle.ToString ().ToLower () + ";");
htmlText.Append ("color:" + ((HslColor)chunkStyle.Foreground).ToPangoString () + ";");
htmlText.Append ("'>");
AppendHtmlText (htmlText, doc, options, start, end);
htmlText.Append ("</SPAN>");
}
}
}
htmlText.AppendLine ("</FONT>");
htmlText.AppendLine ("</BODY></HTML>");
if (Platform.IsWindows)
return GenerateCFHtml (htmlText.ToString ());
return htmlText.ToString ();
}
public TooltipItem GetItem (Mono.TextEditor.TextEditor editor, int offset)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null || doc.ParsedDocument == null)
return null;
var unit = doc.ParsedDocument.GetAst<SyntaxTree> ();
if (unit == null)
return null;
var file = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
if (file == null)
return null;
ResolveResult result;
AstNode node;
var loc = editor.OffsetToLocation (offset);
if (!doc.TryResolveAt (loc, out result, out node))
return null;
var resolver = new CSharpAstResolver (doc.Compilation, unit, file);
resolver.ApplyNavigator (new NodeListResolveVisitorNavigator (node), CancellationToken.None);
int startOffset = offset;
int endOffset = offset;
return new TooltipItem (new ToolTipData (unit, result, node, resolver), startOffset, endOffset - startOffset);
}
public void Collect(Mono.Cecil.TypeDefinition td, TypeCollection typeCollection, ConfigBase config)
{
if (td.ShouldIgnoreType())
{
return;
}
// don't duplicate types
if (typeCollection.Contains(td.FullName))
{
return;
}
StringBuilder sb = new StringBuilder();
var indentCount = 0;
ITypeWriter typeWriter = typeSelector.PickTypeWriter(td, indentCount, typeCollection, config);
td.Interfaces.Each(item =>
{
var foundType = typeCollection.LookupType(item);
if (foundType == null)
{
//TODO: This reporting a missing type is too early in the process.
// typeNotFoundErrorHandler.Handle(item);
return;
}
var itemWriter = typeSelector.PickTypeWriter(foundType, indentCount, typeCollection, config);
typeCollection.Add(foundType.Namespace, foundType.Name, itemWriter);
});
typeCollection.Add(td.Namespace, td.Name, typeWriter);
}
public void AddMember(IUnresolvedEntity entity, Mono.Cecil.MemberReference cecilObject)
{
rwLock.EnterWriteLock();
try {
uint token = cecilObject.MetadataToken.ToUInt32();
metadataTokens[entity] = token;
var cecilMethod = cecilObject as Mono.Cecil.MethodDefinition;
if (cecilMethod != null) {
IUnresolvedMethod method = (IUnresolvedMethod)entity;
tokenToMethod[token] = method;
if (cecilMethod.HasBody) {
var locals = cecilMethod.Body.Variables;
if (locals.Count > 0) {
localVariableTypes[method] = locals.Select(v => typeRefLoader.ReadTypeReference(v.VariableType)).ToArray();
}
if (cecilMethod.RVA != 0) {
// The method was loaded from image - we can free the memory for the body
// because Cecil will re-initialize it on demand
cecilMethod.Body = null;
}
}
}
} finally {
rwLock.ExitWriteLock();
}
}
public override void ActivateEvent (Mono.Debugger.Event ev)
{
if (Process.MainThread.IsStopped)
ev.Activate (Process.MainThread);
else
ThrowNotSupported ("Breakpoints can't be changed while the process is running.");
}
public override void VisitTypeDefinitionCollection(Mono.Cecil.TypeDefinitionCollection types)
{
if(types.Contains(className))
{
VisitTypeDefinition(types[className]);
}
}
bool IActionTextLineMarker.MousePressed (Mono.TextEditor.MonoTextEditor editor, MarginMouseEventArgs args)
{
var handler = MousePressed;
if (handler != null)
handler (this, new TextEventArgsWrapper (args));
return false;
}
private void InitBlock(Mono.Lucene.Net.Search.StringIndex fcsi, int inclusiveLowerPoint, int inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter enclosingInstance)
{
this.fcsi = fcsi;
this.inclusiveLowerPoint = inclusiveLowerPoint;
this.inclusiveUpperPoint = inclusiveUpperPoint;
this.enclosingInstance = enclosingInstance;
}
/// <summary>
/// Creates the specified employee.
/// </summary>
/// <param name="employee">The employee.</param>
/// <param name="candidate">The candidate.</param>
/// <param name="feedback">The feedback.</param>
/// <returns>IMono<Review>.</returns>
public static IMono<Review> Create(IMono<Employee> employee, IMono<Candidate> candidate, string feedback)
{
return candidate.FlatMap(
c => employee.FlatMap(
e => Mono.Just(
new Review { Candidate = c, Employee = e, Date = DateTime.Now, Feedback = feedback })));
}
public void Then_EmptyVoid_Fused()
{
Flux.Range(1, 10).Then(Mono.Empty <Void>())
.Test(fusionMode: FuseableHelper.ANY)
.AssertFusionMode(FuseableHelper.ASYNC)
.AssertResult();
}
public ITypeWriter PickTypeWriter(Mono.Cecil.TypeDefinition td, int indentCount, TypeCollection typeCollection, ConfigBase config)
{
if (td.IsEnum)
{
return new EnumWriter(td, indentCount, typeCollection, config);
}
if (td.IsInterface)
{
return new InterfaceWriter(td, indentCount, typeCollection, config);
}
if (td.IsClass)
{
if (td.BaseType.FullName == "System.MulticastDelegate" ||
td.BaseType.FullName == "System.Delegate")
{
return new DelegateWriter(td, indentCount, typeCollection, config);
}
return new ClassWriter(td, indentCount, typeCollection, config);
}
throw new NotImplementedException("Could not get a type to generate for:" + td.FullName);
}
protected UnixSocket (Mono.Unix.UnixEndPoint localEndPoint)
: base (System.Net.Sockets.AddressFamily.Unix,
System.Net.Sockets.SocketType.Stream,
System.Net.Sockets.ProtocolType.IP,
localEndPoint)
{
}
// Mono.TextEditor.Document document;
// MonoDevelop.Ide.Gui.Document doc;
// IParser parser;
// IResolver resolver;
// IExpressionFinder expressionFinder;
/* void Init (Mono.TextEditor.Document document)
{
// parser = ProjectDomService.GetParser (document.FileName, document.MimeType);
// expressionFinder = ProjectDomService.GetExpressionFinder (document.FileName);
}*/
ProjectDom GetParserContext (Mono.TextEditor.Document document)
{
var project = IdeApp.ProjectOperations.CurrentSelectedProject;
if (project != null)
return ProjectDomService.GetProjectDom (project);
return ProjectDom.Empty;
}
public override void InformMouseHover (Mono.TextEditor.MonoTextEditor editor, Margin margin, MarginMouseEventArgs args)
{
if (!(margin is ActionMargin))
return;
string toolTip;
if (unitTest.IsFixture) {
if (isFailed) {
toolTip = GettextCatalog.GetString ("NUnit Fixture failed (click to run)");
if (!string.IsNullOrEmpty (failMessage))
toolTip += Environment.NewLine + failMessage.TrimEnd ();
} else {
toolTip = GettextCatalog.GetString ("NUnit Fixture (click to run)");
}
} else {
if (isFailed) {
toolTip = GettextCatalog.GetString ("NUnit Test failed (click to run)");
if (!string.IsNullOrEmpty (failMessage))
toolTip += Environment.NewLine + failMessage.TrimEnd ();
foreach (var id in unitTest.TestCases) {
if (host.IsFailure (unitTest.UnitTestIdentifier, id)) {
var msg = host.GetMessage (unitTest.UnitTestIdentifier, id);
if (!string.IsNullOrEmpty (msg)) {
toolTip += Environment.NewLine + "Test" + id + ":";
toolTip += Environment.NewLine + msg.TrimEnd ();
}
}
}
} else {
toolTip = GettextCatalog.GetString ("NUnit Test (click to run)");
}
}
editor.TooltipText = toolTip;
}
/// <summary>
/// Generates a proxy that forwards all virtual method calls
/// to a single <see cref="IInterceptor"/> instance.
/// </summary>
/// <param name="originalBaseType">The base class of the type being constructed.</param>
/// <param name="baseInterfaces">The list of interfaces that the new type must implement.</param>
/// <param name="module">The module that will hold the brand new type.</param>
/// <param name="targetType">The <see cref="TypeDefinition"/> that represents the type to be created.</param>
public override void Construct(Type originalBaseType, IEnumerable<Type> baseInterfaces, ModuleDefinition module, Mono.Cecil.TypeDefinition targetType)
{
var interfaces = new HashSet<Type>(baseInterfaces);
if (!interfaces.Contains(typeof(ISerializable)))
interfaces.Add(typeof(ISerializable));
var serializableInterfaceType = module.ImportType<ISerializable>();
if (!targetType.Interfaces.Contains(serializableInterfaceType))
targetType.Interfaces.Add(serializableInterfaceType);
// Create the proxy type
base.Construct(originalBaseType, interfaces, module, targetType);
// Add the Serializable attribute
targetType.IsSerializable = true;
var serializableCtor = module.ImportConstructor<SerializableAttribute>();
var serializableAttribute = new CustomAttribute(serializableCtor);
targetType.CustomAttributes.Add(serializableAttribute);
ImplementGetObjectData(originalBaseType, baseInterfaces, module, targetType);
DefineSerializationConstructor(module, targetType);
var interceptorType = module.ImportType<IInterceptor>();
var interceptorGetterProperty = (from PropertyDefinition m in targetType.Properties
where m.Name == "Interceptor" && m.PropertyType == interceptorType
select m).First();
}
public override void CopyFrom (Mono.Debugging.Evaluation.EvaluationContext gctx)
{
base.CopyFrom (gctx);
MdbEvaluationContext ctx = (MdbEvaluationContext) gctx;
thread = ctx.thread;
frame = ctx.frame;
}
public CustomAttribute InjectCustomAttribute(Mono.Cecil.ICustomAttributeProvider target, CustomAttribute attribute)
{
if(module == null)
throw new ArgumentNullException("module");
if(target == null)
throw new ArgumentNullException("target");
if(attribute == null)
throw new ArgumentNullException("attribute");
TypeReference attributeType = ReferenceOrInjectType(attribute.AttributeType);
// no context required as attributes cannot be generic
MethodReference constructor = ReferenceOrInjectMethod(attribute.Constructor);
CustomAttribute newAttribute;
if((newAttribute = Helper.GetCustomAttribute(target.CustomAttributes, attribute)) != null)
return newAttribute;
newAttribute = new CustomAttribute(constructor);//, attr.GetBlob());
target.CustomAttributes.Add(newAttribute);
CopyCustomAttributeArguments(attribute.ConstructorArguments, newAttribute.ConstructorArguments);
CopyCustomAttributeNamedArguments(attribute.Fields, newAttribute.Fields);
CopyCustomAttributeNamedArguments(attribute.Properties, newAttribute.Properties);
return newAttribute;
}
public override void EnableEvent (Mono.Debugger.Event ev, bool enable)
{
if (enable)
ev.Activate (Process.MainThread);
else
ev.Deactivate (Process.MainThread);
}
AstType ConvertToType (Mono.CSharp.Expression typeName)
{
if (typeName is TypeExpression) {
var typeExpr = (Mono.CSharp.TypeExpression)typeName;
return new PrimitiveType (typeExpr.GetSignatureForError (), Convert (typeExpr.Location));
}
if (typeName is Mono.CSharp.QualifiedAliasMember) {
var qam = (Mono.CSharp.QualifiedAliasMember)typeName;
// TODO: Overwork the return type model - atm we don't have a good representation
// for qualified alias members.
return new SimpleType (qam.Name, Convert (qam.Location));
}
if (typeName is MemberAccess) {
MemberAccess ma = (MemberAccess)typeName;
var memberType = new MonoDevelop.CSharp.Ast.MemberType ();
memberType.AddChild (ConvertToType (ma.LeftExpression), MonoDevelop.CSharp.Ast.MemberType.TargetRole);
memberType.MemberName = ma.Name;
AddTypeArguments (ma, memberType);
return memberType;
}
if (typeName is SimpleName) {
var sn = (SimpleName)typeName;
var result = new SimpleType (sn.Name, Convert (sn.Location));
AddTypeArguments (sn, result);
return result;
}
if (typeName is ComposedCast) {
var cc = (ComposedCast)typeName;
var baseType = ConvertToType (cc.Left);
var result = new ComposedType () { BaseType = baseType };
if (cc.Spec.IsNullable) {
result.HasNullableSpecifier = true;
} else if (cc.Spec.IsPointer) {
result.PointerRank++;
} else {
var location = LocationsBag.GetLocations (cc.Spec);
var spec = new ArraySpecifier () { Dimensions = cc.Spec.Dimension - 1 };
spec.AddChild (new CSharpTokenNode (Convert (cc.Spec.Location), 1), FieldDeclaration.Roles.LBracket);
if (location != null)
spec.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FieldDeclaration.Roles.RBracket);
result.ArraySpecifiers = new ArraySpecifier[] {
spec
};
}
return result;
}
System.Console.WriteLine ("Error while converting :" + typeName + " - unknown type name");
System.Console.WriteLine (Environment.StackTrace);
return new SimpleType ("unknown");
}
public override void VisitTypeDefinition(Mono.Cecil.TypeDefinition type)
{
if (!ShouldBeRenamed(type))
return;
logVisitingMember(type);
RenameDefinition(type);
}
/// <summary>
/// To the authenticated.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Map to the authenticated.</returns>
private Func <User, IMono <AuthenticatedUser> > ToAuthenticated(Credential request)
{
return(user => user is null || !BCrypt.EnhancedVerify(request.Password, user.Password)
? Mono.Error <AuthenticatedUser>(
new ArgumentException("the user or the password are invalid"))
: Mono.Just(
new AuthenticatedUser(user.Name, user.LastName, user.Email, this.Token(user))));
}
/// <summary>
/// Loads symbol in a platform specific way.
/// </summary>
/// <param name="symbolName"></param>
/// <returns></returns>
private IntPtr LoadSymbol(string symbolName)
{
IntPtr pResult = IntPtr.Zero;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) /* PlatformApis.IsWindows */
{
int ErrCode = 0;
string errorMsg = "";
// See http://stackoverflow.com/questions/10473310 for background on this.
if (Environment.Is64BitProcess) /* PlatformApis.Is64Bit */
{
pResult = Windows.GetProcAddress(this.handle, symbolName);
if (pResult == IntPtr.Zero)
{
ErrCode = Marshal.GetLastWin32Error();
errorMsg = Windows.GetLastErrMsg((uint)ErrCode);
Console.WriteLine("Error while loading function: " + symbolName + "\n\t" + errorMsg);
}
return(pResult);
}
else
{
// Yes, we could potentially predict the size... but it's a lot simpler to just try
// all the candidates. Most functions have a suffix of @0, @4 or @8 so we won't be trying
// many options - and if it takes a little bit longer to fail if we've really got the wrong
// library, that's not a big problem. This is only called once per function in the native library.
symbolName = "_" + symbolName + "@";
for (int stackSize = 0; stackSize < 128; stackSize += 4)
{
pResult = Windows.GetProcAddress(this.handle, symbolName + stackSize);
if (pResult != IntPtr.Zero)
{
return(pResult);
}
}
// Fail.
return(IntPtr.Zero);
}
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
if (InteropRuntimeConfig.IsRunningOnMono) /* PlatformApis.IsMono */
{
return(Mono.dlsym(this.handle, symbolName));
}
if (RuntimeInformation.FrameworkDescription.StartsWith(".NET Core")) /* PlatformApis.IsNetCore */
{
return(CoreCLR.dlsym(this.handle, symbolName));
}
return(Linux.dlsym(this.handle, symbolName));
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) /* PlatformApis.IsMacOSX */
{
return(MacOSX.dlsym(this.handle, symbolName));
}
throw new InvalidOperationException("Unsupported platform.");
}
public override void Exit()
{
var AttackProcessGenarator = Mono.GetComponent <AttackGenerator>();
if (AttackProcessGenarator != null)
{
Object.Destroy(AttackProcessGenarator);
}
}
protected override void OnBattleLoadedScene()
{
base.OnBattleLoadedScene();
TerrainGridSystem = TerrainGridSystem.instance;
TerrainGridSystem.cameraMain = Mono.GetComponentInChildren <Camera>();
OnSetTerrainGridSystem();
TerrainGridSystem.GenerateMap();
CloseMap();
}
public override void Exit()
{
Debug.Log("Patrol-Exit");
var PatrolProcessGenarator = Mono.GetComponent <PatrolGenerator>();
if (PatrolProcessGenarator != null)
{
Object.Destroy(PatrolProcessGenarator);
}
}
/// <summary>
/// The Create instance.
/// </summary>
/// <param name="server">the server name.</param>
/// <returns>The config.</returns>
public static IMono <Config> Create(string server)
{
var validator = new ConfigValidator();
var config = new Config(server);
var validation = validator.Validate(config);
return(validation.IsValid
? Mono.Just(config)
: Mono.Error <Config>(new ArgumentException(string.Join(", ", validation.Errors))));
}
public override void OnBeAdded(IMono mono)
{
base.OnBeAdded(mono);
Animator = Mono.GetComponentInChildren <Animator>();
if (Animator == null)
{
CLog.Error("错误 该对象没有Animator" + Mono.name);
}
SourceAnimator = Animator.runtimeAnimatorController;
}
public override void Init()
{
targetPosition = target.transform.position;
Mono.transform.position = targetPosition + targetOffset;
Mono.transform.rotation = Quaternion.Euler(rotationVector);
Mono.GetComponent <Camera>().orthographic = true;
Mono.GetComponent <Camera>().orthographicSize = orthoSize;
}
public void Initialize()
{
var repositoryMock = new Mock <IUserRepository>();
repositoryMock.Setup(r => r.Save(It.IsAny <IMono <User> >())).Returns(Mono.Just(new User()));
var userRepository = repositoryMock.Object;
var command = new CreateUserHandler(userRepository);
this.context.Command = command;
}
public override void OnBeAdded(IMono mono)
{
base.OnBeAdded(mono);
VoiceAudioSource = Mono.EnsureComponet <AudioSource>();
VoiceAudioSource.playOnAwake = false;
VoiceAudioSource.rolloffMode = AudioRolloffMode.Linear;
VoiceAudioSource.spatialBlend = 1.0f;
VoiceAudioSource.minDistance = 1.0f;
VoiceAudioSource.maxDistance = DefaultMaxDistance;
}
public override void Exit()
{
Debug.Log("Chase-Exit");
var ChaseProcessGenarator = Mono.GetComponent <ChaseGenerator>();
if (ChaseProcessGenarator == null)
{
return;
}
Object.Destroy(ChaseProcessGenarator);
}
static void Init()
{
if (GameObject.Find("[MonoBehaviour]") != null)
{
return;
}
var go = new GameObject();
go.name = "[MonoBehaviour]";
mono = go.AddComponent <Mono>();
Object.DontDestroyOnLoad(go);
}
private void OnAwake()
{
Mono.InitCmpts();
Resource.InitCmpts();
Scene.InitCmpts();
Debugs.InitCmpts();
MsgMechain.InitCmpts();
Pool.InitCmpts();
DB.InitCmpts();
Audio.InitCmpts();
UI.InitCmpts();
}
private void OnDestroy()
{
Mono.ShutDown();
MsgMechain.ShutDown();
Resource.ShutDown();
Debugs.ShutDown();
DB.ShutDown();
UI.ShutDown();
Audio.ShutDown();
Scene.ShutDown();
Pool.ShutDown();
Debugs.ShutDown();
}
public void Mono_ScansArray_DoNotThrow(int inputLength)
{
var zeros = new double[inputLength];
var audio = new Mono(
zeros,
new AudioProcessingSettings()
{
HistoryLengthSamples = 512
});
Assert.DoesNotThrowAsync(
() => audio.ScanAsync(new Progress <string>(), new Progress <double>()));
}
/// <summary>
/// Loads symbol in a platform specific way.
/// </summary>
/// <param name="symbolName"></param>
/// <returns></returns>
private IntPtr LoadSymbol(string symbolName)
{
if (PlatformApis.IsWindows)
{
// See http://stackoverflow.com/questions/10473310 for background on this.
//if (PlatformApis.Is64Bit)
//{
// return Windows.GetProcAddress(this.handle, symbolName);
//}
//else
//{
// // Yes, we could potentially predict the size... but it's a lot simpler to just try
// // all the candidates. Most functions have a suffix of @0, @4 or @8 so we won't be trying
// // many options - and if it takes a little bit longer to fail if we've really got the wrong
// // library, that's not a big problem. This is only called once per function in the native library.
// symbolName = "_" + symbolName + "@";
// for (int stackSize = 0; stackSize < 128; stackSize += 4)
// {
// IntPtr candidate = Windows.GetProcAddress(this.handle, symbolName + stackSize);
// if (candidate != IntPtr.Zero)
// {
// return candidate;
// }
// }
// // Fail.
// return IntPtr.Zero;
//}
// VLFD.dll 比较特殊
// 虽然是32位的,但符号和64位相同
return(Windows.GetProcAddress(this.handle, symbolName));
}
if (PlatformApis.IsLinux)
{
if (PlatformApis.IsMono)
{
return(Mono.dlsym(this.handle, symbolName));
}
if (PlatformApis.IsNetCore)
{
return(CoreCLR.dlsym(this.handle, symbolName));
}
return(Linux.dlsym(this.handle, symbolName));
}
if (PlatformApis.IsMacOSX)
{
return(MacOSX.dlsym(this.handle, symbolName));
}
throw new InvalidOperationException("Unsupported platform.");
}
public void Close()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
if (this.handle != IntPtr.Zero)
{
Windows.FreeLibrary(this.handle);
this.handle = IntPtr.Zero;
}
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
if (InteropRuntimeConfig.IsRunningOnMono)
{
if (this.handle != IntPtr.Zero)
{
Mono.dlclose(this.handle);
this.handle = IntPtr.Zero;
}
}
else if (RuntimeInformation.FrameworkDescription.StartsWith(".NET Core"))
{
if (this.handle != IntPtr.Zero)
{
CoreCLR.dlclose(this.handle);
this.handle = IntPtr.Zero;
}
}
else
{
if (this.handle != IntPtr.Zero)
{
Linux.dlclose(this.handle);
this.handle = IntPtr.Zero;
}
}
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
if (this.handle != IntPtr.Zero)
{
MacOSX.dlclose(this.handle);
this.handle = IntPtr.Zero;
}
}
else
{
throw new InvalidOperationException("Unsupported platform.");
}
bLibOpen = false;
}
void RegetNode()
{
Model = SelfBaseUnit.Trans;
bones = new Dictionary <int, Transform>();
extendBones = new Dictionary <string, Transform>();
bones.Clear();
extendBones.Clear();
Transform[] trans = Mono.GetComponentsInChildren <Transform>();
for (int i = 0; i < trans.Length; ++i)
{
OnMapNodes(trans[i]);
if (trans[i].name == BaseConstMgr.STR_Model)
{
Model = trans[i];
}
}
BaseBone[] bonescom = Mono.GetComponentsInChildren <BaseBone>();
if (bonescom != null)
{
foreach (var item in bonescom)
{
int index = (int)item.Type;
if (index != -1)
{
if (bones.ContainsKey(index))
{
bones[index] = item.Trans;
}
else
{
bones.Add(index, item.Trans);
}
}
else
{
string name = item.ExtendName;
if (extendBones.ContainsKey(name))
{
CLog.Error("ExtenBone 名称重复:{0}", name);
}
else
{
extendBones.Add(name, item.Trans);
}
}
}
}
}
void StartLoader(params ILoader[] loaders)
{
if (loaders == null || loaders.Length == 0)
{
CLog.Error("错误,没有Loader");
return;
}
foreach (var item in loaders)
{
loderList.Add(item);
}
IsLoadEnd = false;
Mono.StartCoroutine(IEnumerator_Load());
}
/// <summary>
/// Creates the specified name.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="lastName">The last name.</param>
/// <param name="email">The email.</param>
/// <param name="password">The password.</param>
/// <param name="confirm">The confirm.</param>
/// <returns>the user.</returns>
public static IMono <User> Create(string name, string lastName, string email, string password, string confirm)
{
if (password != confirm)
{
return(Mono.Error <User>(new ArgumentException(nameof(confirm))));
}
var user = new User(name, lastName, email, BCrypt.Net.BCrypt.EnhancedHashPassword(password));
var validation = new UserValidation();
var valid = validation.Validate(user);
return(!valid.IsValid
? Mono.Error <User>(new ArgumentException(string.Join(", ", valid.Errors)))
: Mono.Just(user));
}
IEnumerator IEnumerator_Load()
{
Callback_OnStartLoad?.Invoke();
for (int i = 0; i < loderList.Count; ++i)
{
LoadInfo = loderList[i].GetLoadInfo();
yield return(Mono.StartCoroutine(loderList[i].Load()));
Percent = i / loderList.Count;
}
Callback_OnLoadEnd?.Invoke(LoadEndType.Success, LoadInfo);
IsLoadEnd = true;
Callback_OnAllLoadEnd?.Invoke();
Callback_OnAllLoadEnd2?.Invoke();
}
/// <summary>
/// Default constructor for creating a new instance of hte Layout form
/// </summary>
public LayoutForm()
{
InitializeComponent();
if (Mono.IsRunningOnMono())
{
// On Mac and possibly other Mono platforms, GdipCreateLineBrushFromRect
// in gdiplus native lib returns InvalidParameter in Mono file LinearGradientBrush.cs
// if a StripPanel's Width or Height is 0, so force them to non-0.
_toolStripContainer1.TopToolStripPanel.Size = new Size(_toolStripContainer1.TopToolStripPanel.Size.Width, 1);
_toolStripContainer1.BottomToolStripPanel.Size = new Size(_toolStripContainer1.BottomToolStripPanel.Size.Width, 1);
_toolStripContainer1.LeftToolStripPanel.Size = new Size(1, _toolStripContainer1.LeftToolStripPanel.Size.Height);
_toolStripContainer1.RightToolStripPanel.Size = new Size(1, _toolStripContainer1.RightToolStripPanel.Size.Height);
}
}
/// <summary>
/// Handles the Click event of the PrintLayout control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void PrintLayoutClick(object sender, EventArgs e)
{
// In Mono show the dialog only if printers installed else show error message.
if (Mono.IsRunningOnMono())
{
if (!new PrinterSettings().IsValid)
{
MessageBox.Show(Msg.NoPrintersInstalled, Msg.Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
using var layout = new LayoutForm();
layout.MapControl = App.Map as Map;
layout.ShowDialog();
}
/// <summary>
/// Loads symbol in a platform specific way.
/// </summary>
/// <param name="symbolName"></param>
/// <returns></returns>
public IntPtr LoadSymbol(string symbolName)
{
if (PlatformApis.IsLinux)
{
if (PlatformApis.IsMono)
{
return(Mono.dlsym(this.handle, symbolName));
}
return(Linux.dlsym(this.handle, symbolName));
}
if (PlatformApis.IsMacOSX)
{
return(MacOSX.dlsym(this.handle, symbolName));
}
throw new InvalidOperationException("Unsupported platform.");
}
public override void Update()
{
if (target != null && target.transform.childCount > 0)
{
targetPosition = target.transform.GetChild(0).transform.position;
}
else if (target != null)
{
targetPosition = target.transform.position;
}
Mono.transform.position = targetPosition + targetOffset;
Mono.transform.rotation = Quaternion.Euler(rotationVector);
Mono.GetComponent <Camera>().orthographic = true;
Mono.GetComponent <Camera>().orthographicSize = orthoSize;
}