Introduce accessor concept to InterfaceVMs

This fixes inconsistent method generation in GIntrface interfaces, adapters and implementor
interfaces. For example, in Atk.IText the method GetRangeExtents existed with two different
signatures. In Atk.IText and Atk.TextAdapter we had:
 (1) Atk.TextRectangle GetRangeExtents(int start_offset, int end_offset, Atk.CoordType coord_type);
whereas the signature in Atk.ITextImplementor was:
 (2) void GetRangeExtents (int start_offset, int end_offset, Atk.CoordType coord_type,
                           out Atk.TextRectangle rect);

This fix ensures that all interface methods have the form as shown in (1). This has been
implemented by applying the same rules for "Accessor"-methods in InterfaceVM as are already in
place in class Method. Essentially these rules state that all methods with one out-parameter are
Accessor-methods.

Author: riccioclista

generator/InterfaceVM.cs

@@ -86,7 +86,9 @@ public void GenerateDeclaration (StreamWriter sw, InterfaceVM complement, string
 				}
 			} else if (IsSetter) 
 				sw.WriteLine ("\t\t" + declPrefix + parms[0].CSType + " " + Name.Substring (3) + " { set; }");
-			else
+			else if (IsAccessor) {
+				sw.WriteLine ("\t\t" + declPrefix + Signature.AccessorType + " " + Name + " (" + Signature.AsAccessor + ");");
+			} else
 				sw.WriteLine ("\t\t" + declPrefix + retval.CSType + " " + Name + " (" + Signature + ");");
 		}
 

generator/ManagedCallString.cs

@@ -24,6 +24,7 @@ namespace GtkSharp.Generation {
 	using System;
 	using System.Collections.Generic;
 	using System.IO;
+	using System.Linq;
 
 	public class ManagedCallString {
 
@@ -34,9 +35,18 @@ public class ManagedCallString {
 		string destroy_param = null;
 
 		public ManagedCallString (Parameters parms)
+			: this (parms, false)
+		{
+		}
+
+		private ManagedCallString (Parameters parms, bool stripAccessorParameter)
 		{
 			for (int i = 0; i < parms.Count; i ++) {
 				Parameter p = parms [i];
+				if (stripAccessorParameter && p.PassAs == "out") {
+					continue;
+				}
+
 				if (p.IsLength && i > 0 && parms [i-1].IsString) 
 					continue;
 				else if (p.Scope == "notified") {
@@ -90,6 +100,14 @@ public string Unconditional (string indent) {
 			return ret;
 		}
 
+		public static ManagedCallString CreateWithoutAccessorParameter (Parameters parms,
+			out Parameter accessorParam)
+		{
+			var call = new ManagedCallString (parms, true);
+			accessorParam = parms.FirstOrDefault (p => p.PassAs == "out");
+			return call;
+		}
+
 		public string Setup (string indent)
 		{
 			string ret = "";
@@ -158,21 +176,29 @@ public string Finish (string indent)
 					continue;
 				}
 
-				IGeneratable igen = p.Generatable;
-
-				if (igen is CallbackGen)
-					continue;
-				else if (igen is StructBase || igen is ByRefGen)
-					ret += indent + String.Format ("if ({0} != IntPtr.Zero) System.Runtime.InteropServices.Marshal.StructureToPtr (my{0}, {0}, false);\n", p.Name);
-				else if (igen is IManualMarshaler)
-					ret += String.Format ("{0}{1} = {2};", indent, p.Name, (igen as IManualMarshaler).AllocNative ("my" + p.Name));
-				else
-					ret += indent + p.Name + " = " + igen.CallByName ("my" + p.Name) + ";\n";
+				ret += GetParamAssignmentStatement ("my" + p.Name, p, indent);
 			}
 
 			return ret;
 		}
 
+		public static string GetParamAssignmentStatement (string srcParameterName, Parameter p, string indent)
+		{
+			var ret = string.Empty;
+			IGeneratable igen = p.Generatable;
+
+			if (igen is CallbackGen)
+				return string.Empty;
+			else if (igen is StructBase || igen is ByRefGen)
+				ret += indent + String.Format ("if ({0} != IntPtr.Zero) System.Runtime.InteropServices.Marshal.StructureToPtr ({1}, {0}, false);\n", p.Name, srcParameterName);
+			else if (igen is IManualMarshaler)
+				ret += String.Format ("{0}{1} = {2};", indent, p.Name, (igen as IManualMarshaler).AllocNative (srcParameterName));
+			else
+				ret += indent + p.Name + " = " + igen.CallByName (srcParameterName) + ";\n";
+
+			return ret;
+		}
+
 		public string DisposeParams (string indent)
 		{
 			string ret = "";

generator/VMSignature.cs

@@ -55,6 +55,57 @@ public VMSignature (Parameters parms)
 			}
 		}
 
+		public bool IsAccessor {
+			get {
+				int count = 0;
+				foreach (Parameter p in parms) {
+					if (p.PassAs == "out")
+						count++;
+
+					if (count > 1)
+						return false;
+				}
+				return count == 1;
+			}
+		}
+
+		public string AccessorType {
+			get {
+				foreach (Parameter p in parms)
+					if (p.PassAs == "out")
+						return p.CSType;
+
+				return null;
+			}
+		}
+
+		public string AccessorName {
+			get {
+				foreach (Parameter p in parms)
+					if (p.PassAs == "out")
+						return p.Name;
+
+				return null;
+			}
+		}
+
+		public string AsAccessor {
+			get {
+				string[] result = new string [parms.Count - 1];
+				int i = 0;
+
+				foreach (Parameter p in parms) {
+					if (p.PassAs == "out")
+						continue;
+
+					result [i] = p.PassAs != "" ? p.PassAs + " " : "";
+					result [i++] += p.CSType + " " + p.Name;
+				}
+
+				return String.Join (", ", result);
+			}
+		}
+
 		public string GetCallString (bool use_place_holders)
 		{
 			if (parms.Count == 0)

generator/VirtualMethod.cs

@@ -30,6 +30,7 @@ namespace GtkSharp.Generation {
 	public abstract class VirtualMethod : MethodBase  {
 		protected ReturnValue retval;
 		protected ManagedCallString call;
+		private Parameter accessorParam;
 
 		protected string modifiers = "";
 
@@ -56,6 +57,12 @@ protected abstract string CallString {
 			}
 		}
 
+		protected bool IsAccessor {
+			get {
+				return retval.IsVoid && Signature.IsAccessor;
+			}
+		}
+
 		/* Creates a callback method which invokes the corresponding virtual method
 		* @implementor is the class that implements the virtual method(e.g. the class that derives from an interface) or NULL if containing and declaring type are equal
 		*/
@@ -99,16 +106,22 @@ public void GenerateCallback (StreamWriter sw, ClassBase implementor)
 			}
 
 			string indent = "\t\t\t\t";
-			if (!retval.IsVoid)
+			if (IsAccessor) {
+				sw.WriteLine (indent + Signature.AccessorType + " __result;");
+			} else if (!retval.IsVoid)
 				sw.WriteLine (indent + retval.CSType + " __result;");
 			sw.Write (call.Setup (indent));
 			sw.Write (indent);
-			if (!retval.IsVoid)
+			if (!retval.IsVoid || IsAccessor)
 				sw.Write ("__result = ");
 			if (!this.IsStatic)
 				sw.Write ("__obj.");
 			sw.WriteLine (this.CallString + ";");
 			sw.Write (call.Finish (indent));
+			if (IsAccessor) {
+				sw.Write (ManagedCallString.GetParamAssignmentStatement ("__result", accessorParam, indent));
+			}
+
 			if (!retval.IsVoid)
 				sw.WriteLine ("\t\t\t\treturn " + retval.ToNative ("__result") + ";");
 
@@ -149,7 +162,12 @@ public override bool Validate (LogWriter log)
 				return false;
 			}
 
-			call = new ManagedCallString (parms);
+			if (IsAccessor) {
+				call = ManagedCallString.CreateWithoutAccessorParameter (parms, out accessorParam);
+			} else {
+				call = new ManagedCallString (parms);
+			}
+
 			return true;
 		}
 	}