mirror of
https://github.com/Ryujinx/GtkSharp.git
synced 2024-09-09 00:13:20 +02:00
71e9414883
* generator/Parameters.cs : Properly handle out params for Object and Opaque types. * gtk/ListStore.custom: remove out on GetValue overload * gtk/TreeStore.custom: remove out on GetValue overload * gtk/gtk-api.xml : regenerated * sources/Gtk.metadata : remove some incorrect out tags svn path=/trunk/gtk-sharp/; revision=18891
450 lines
11 KiB
C#
450 lines
11 KiB
C#
// GtkSharp.Generation.Parameters.cs - The Parameters Generation Class.
|
|
//
|
|
// Author: Mike Kestner <mkestner@speakeasy.net>
|
|
//
|
|
// (c) 2001-2002 Mike Kestner
|
|
|
|
namespace GtkSharp.Generation {
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Xml;
|
|
|
|
public class Parameter {
|
|
|
|
private XmlElement elem;
|
|
|
|
public Parameter (XmlElement e)
|
|
{
|
|
elem = e;
|
|
}
|
|
|
|
public string CType {
|
|
get {
|
|
string type = elem.GetAttribute("type");
|
|
if (type == "void*")
|
|
type = "gpointer";
|
|
return type;
|
|
}
|
|
}
|
|
|
|
public string CSType {
|
|
get {
|
|
string cstype = SymbolTable.Table.GetCSType( elem.GetAttribute("type"));
|
|
if (cstype == "void")
|
|
cstype = "System.IntPtr";
|
|
if (IsArray) {
|
|
cstype += "[]";
|
|
cstype = cstype.Replace ("ref ", "");
|
|
}
|
|
return cstype;
|
|
}
|
|
}
|
|
|
|
public IGeneratable Generatable {
|
|
get {
|
|
return SymbolTable.Table[CType];
|
|
}
|
|
}
|
|
|
|
public bool IsArray {
|
|
get {
|
|
return elem.HasAttribute("array");
|
|
}
|
|
}
|
|
|
|
public bool IsEllipsis {
|
|
get {
|
|
return elem.HasAttribute("ellipsis");
|
|
}
|
|
}
|
|
|
|
public bool IsLength {
|
|
get {
|
|
|
|
if (Name.EndsWith("len") || Name.EndsWith("length"))
|
|
switch (CSType) {
|
|
case "int":
|
|
case "uint":
|
|
case "long":
|
|
case "ulong":
|
|
case "short":
|
|
case "ushort":
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsString {
|
|
get {
|
|
return (CSType == "string");
|
|
}
|
|
}
|
|
|
|
public bool IsUserData {
|
|
get {
|
|
return CType == "gpointer" && (Name.EndsWith ("data") || Name.EndsWith ("data_or_owner"));
|
|
}
|
|
}
|
|
|
|
public string MarshalType {
|
|
get {
|
|
string type = SymbolTable.Table.GetMarshalType( elem.GetAttribute("type"));
|
|
if (type == "void")
|
|
type = "System.IntPtr";
|
|
if (IsArray) {
|
|
type += "[]";
|
|
type = type.Replace ("ref ", "");
|
|
}
|
|
return type;
|
|
}
|
|
}
|
|
|
|
public string Name {
|
|
get {
|
|
return SymbolTable.Table.MangleName (elem.GetAttribute("name"));
|
|
}
|
|
}
|
|
|
|
public bool NullOk {
|
|
get {
|
|
return elem.HasAttribute ("null_ok");
|
|
}
|
|
}
|
|
|
|
public string PassAs {
|
|
get {
|
|
return elem.GetAttribute ("pass_as");
|
|
}
|
|
}
|
|
|
|
public string StudlyName {
|
|
get {
|
|
string name = elem.GetAttribute("name");
|
|
string[] segs = name.Split('_');
|
|
string studly = "";
|
|
foreach (string s in segs) {
|
|
if (s.Trim () == "")
|
|
continue;
|
|
studly += (s.Substring(0,1).ToUpper() + s.Substring(1));
|
|
}
|
|
return studly;
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public class Parameters {
|
|
|
|
private ArrayList param_list;
|
|
private XmlElement elem;
|
|
private string impl_ns;
|
|
private string import_sig = "";
|
|
private string call_string = "";
|
|
private string signature = "";
|
|
private string signature_types = "";
|
|
private bool hide_data;
|
|
private bool is_static;
|
|
|
|
public Parameters (XmlElement elem, string impl_ns) {
|
|
|
|
this.elem = elem;
|
|
this.impl_ns = impl_ns;
|
|
param_list = new ArrayList ();
|
|
foreach (XmlNode node in elem.ChildNodes) {
|
|
XmlElement parm = node as XmlElement;
|
|
if (parm != null && parm.Name == "parameter")
|
|
param_list.Add (new Parameter (parm));
|
|
}
|
|
}
|
|
|
|
public string CallString {
|
|
get {
|
|
return call_string;
|
|
}
|
|
}
|
|
|
|
public int Count {
|
|
get {
|
|
return param_list.Count;
|
|
}
|
|
}
|
|
|
|
public Parameter this [int idx] {
|
|
get {
|
|
return param_list [idx] as Parameter;
|
|
}
|
|
}
|
|
|
|
public string ImportSig {
|
|
get {
|
|
return import_sig;
|
|
}
|
|
}
|
|
|
|
public string Signature {
|
|
get {
|
|
return signature;
|
|
}
|
|
}
|
|
|
|
public string SignatureTypes {
|
|
get {
|
|
return signature_types;
|
|
}
|
|
}
|
|
|
|
public bool HideData {
|
|
get { return hide_data; }
|
|
set { hide_data = value; }
|
|
}
|
|
|
|
public bool Static {
|
|
set { is_static = value; }
|
|
}
|
|
|
|
public bool Validate ()
|
|
{
|
|
foreach (Parameter p in param_list) {
|
|
|
|
if (p.IsEllipsis) {
|
|
Console.Write("Ellipsis parameter ");
|
|
return false;
|
|
}
|
|
|
|
if ((p.CSType == "") || (p.Name == "") ||
|
|
(p.MarshalType == "") || (SymbolTable.Table.CallByName(p.CType, p.Name) == "")) {
|
|
Console.Write("Name: " + p.Name + " Type: " + p.CType + " ");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void CreateSignature (bool is_set)
|
|
{
|
|
import_sig = call_string = signature = signature_types = "";
|
|
bool need_sep = false;
|
|
bool has_callback = hide_data;
|
|
|
|
SymbolTable table = SymbolTable.Table;
|
|
|
|
for (int i = 0; i < Count; i++) {
|
|
|
|
string type = this [i].CType;
|
|
string cs_type = this [i].CSType;
|
|
string m_type = this [i].MarshalType;
|
|
string name = this [i].Name;
|
|
|
|
if (i > 0 && this [i - 1].IsString && this [i].IsLength) {
|
|
call_string += ", " + this [i - 1].Name + ".Length";
|
|
import_sig += ", " + m_type + " " + name;
|
|
continue;
|
|
}
|
|
|
|
string call_parm_name = name;
|
|
if (is_set && i == 0)
|
|
call_parm_name = "value";
|
|
|
|
string call_parm;
|
|
if (table.IsCallback (type)) {
|
|
has_callback = true;
|
|
call_parm = table.CallByName (type, call_parm_name + "_wrapper");
|
|
} else
|
|
call_parm = table.CallByName(type, call_parm_name);
|
|
|
|
if (this [i].NullOk && !cs_type.EndsWith ("IntPtr") && !table.IsStruct (type))
|
|
call_parm = String.Format ("({0} != null) ? {1} : {2}", call_parm_name, call_parm, table.IsCallback (type) ? "null" : "IntPtr.Zero");
|
|
|
|
if (this [i].IsArray)
|
|
call_parm = call_parm.Replace ("ref ", "");
|
|
|
|
if (IsVarArgs && i == (Count - 1) && VAType == "length_param") {
|
|
cs_type = "params " + cs_type + "[]";
|
|
m_type += "[]";
|
|
}
|
|
|
|
if (need_sep) {
|
|
call_string += ", ";
|
|
import_sig += ", ";
|
|
if (type != "GError**" && !(IsVarArgs && i == (Count - 1) && VAType == "length_param"))
|
|
{
|
|
signature += ", ";
|
|
signature_types += ":";
|
|
}
|
|
} else {
|
|
need_sep = true;
|
|
}
|
|
|
|
if (this [i].PassAs != "") {
|
|
signature += this [i].PassAs + " ";
|
|
// We only need to do this for value types
|
|
if (type != "GError**" && m_type != "IntPtr" && m_type != "System.IntPtr")
|
|
{
|
|
import_sig += this [i].PassAs + " ";
|
|
call_string += this [i].PassAs + " ";
|
|
}
|
|
|
|
if (table.IsEnum (type))
|
|
call_parm = name + "_as_int";
|
|
else if (table.IsObject (type) || table.IsOpaque (type) || cs_type == "GLib.Value") {
|
|
call_parm = this [i].PassAs + " " + call_parm.Replace (".Handle", "_handle");
|
|
import_sig += this [i].PassAs + " ";
|
|
}
|
|
|
|
} else if (type == "GError**") {
|
|
call_string += "out ";
|
|
import_sig += "out ";
|
|
}
|
|
|
|
if (IsVarArgs && i == (Count - 2) && VAType == "length_param") {
|
|
call_string += this [Count - 1].Name + ".Length";
|
|
} else {
|
|
if (!(type == "GError**" || (has_callback && (type == "gpointer" || type == "void*") && (i == Count - 1) && (name.EndsWith ("data") || name.EndsWith ("data_or_owner"))))) {
|
|
signature += (cs_type + " " + name);
|
|
signature_types += cs_type;
|
|
} else if (type == "GError**") {
|
|
call_parm = call_parm.Replace (name, "error");
|
|
} else if ((type == "gpointer" || type == "void*") && (i == Count - 1) && (name.EndsWith ("data") || name.EndsWith ("data_or_owner"))) {
|
|
call_parm = "IntPtr.Zero";
|
|
}
|
|
|
|
call_string += call_parm;
|
|
}
|
|
if (table.IsCallback (type))
|
|
m_type = impl_ns + "Sharp" + m_type.Substring(m_type.IndexOf("."));
|
|
import_sig += (m_type + " " + name);
|
|
}
|
|
|
|
// FIXME: lame
|
|
call_string = call_string.Replace ("out ref", "out");
|
|
import_sig = import_sig.Replace ("out ref", "out");
|
|
call_string = call_string.Replace ("ref ref", "ref");
|
|
import_sig = import_sig.Replace ("ref ref", "ref");
|
|
|
|
// FIXME: this is also lame, I need to fix the need_sep algo
|
|
if (signature.EndsWith (", "))
|
|
signature = signature.Remove (signature.Length - 2, 2);
|
|
}
|
|
|
|
public void Initialize (GenerationInfo gen_info, bool is_get, bool is_set, string indent)
|
|
{
|
|
StreamWriter sw = gen_info.Writer;
|
|
foreach (Parameter p in param_list) {
|
|
|
|
IGeneratable gen = p.Generatable;
|
|
string name = p.Name;
|
|
if (is_set)
|
|
name = "value";
|
|
|
|
if (is_get) {
|
|
sw.WriteLine (indent + "\t\t\t" + p.CSType + " " + name + ";");
|
|
if (gen is ObjectGen || gen is OpaqueGen || p.CSType == "GLib.Value")
|
|
sw.WriteLine(indent + "\t\t\t" + name + " = new " + p.CSType + "();");
|
|
}
|
|
|
|
if ((is_get || p.PassAs == "out") && (gen is ObjectGen || gen is OpaqueGen || p.CSType == "GLib.Value"))
|
|
sw.WriteLine(indent + "\t\t\tIntPtr " + name + "_handle;");
|
|
|
|
if (p.PassAs == "out" && gen is EnumGen)
|
|
sw.WriteLine(indent + "\t\t\tint " + name + "_as_int;");
|
|
|
|
if (gen is CallbackGen) {
|
|
CallbackGen cbgen = gen as CallbackGen;
|
|
string wrapper = cbgen.GenWrapper(impl_ns, gen_info);
|
|
sw.WriteLine (indent + "\t\t\t{0} {1}_wrapper = null;", wrapper, name);
|
|
sw.Write (indent + "\t\t\t");
|
|
if (p.NullOk)
|
|
sw.Write ("if ({0} != null) ", name);
|
|
sw.WriteLine ("{1}_wrapper = new {0} ({1}, {2});", wrapper, name, is_static ? "null" : "this");
|
|
}
|
|
}
|
|
|
|
if (ThrowsException)
|
|
sw.WriteLine (indent + "\t\t\tIntPtr error = IntPtr.Zero;");
|
|
}
|
|
|
|
public void Finish (StreamWriter sw, string indent)
|
|
{
|
|
bool ref_owned_needed = true;
|
|
foreach (Parameter p in param_list) {
|
|
|
|
if (p.PassAs == "out" && p.Generatable is EnumGen) {
|
|
sw.WriteLine(indent + "\t\t\t" + p.Name + " = (" + p.CSType + ") " + p.Name + "_as_int;");
|
|
}
|
|
|
|
IGeneratable gen = p.Generatable;
|
|
if (ref_owned_needed && gen is ObjectGen && p.PassAs == "out") {
|
|
ref_owned_needed = false;
|
|
sw.WriteLine(indent + "\t\t\tbool ref_owned = false;");
|
|
}
|
|
|
|
if (p.PassAs == "out" && (gen is ObjectGen || gen is OpaqueGen || p.CSType == "GLib.Value"))
|
|
sw.WriteLine(indent + "\t\t\t" + p.Name + " = " + gen.FromNativeReturn (p.Name + "_handle") + ";");
|
|
}
|
|
}
|
|
|
|
|
|
public void HandleException (StreamWriter sw, string indent)
|
|
{
|
|
if (!ThrowsException)
|
|
return;
|
|
sw.WriteLine (indent + "\t\t\tif (error != IntPtr.Zero) throw new GLib.GException (error);");
|
|
}
|
|
|
|
public bool IsAccessor {
|
|
get {
|
|
return Count == 1 && this [0].PassAs == "out";
|
|
}
|
|
}
|
|
|
|
public bool ThrowsException {
|
|
get {
|
|
if (Count < 1)
|
|
return false;
|
|
|
|
return this [Count - 1].CType == "GError**";
|
|
}
|
|
}
|
|
|
|
public bool IsVarArgs {
|
|
get {
|
|
return elem.HasAttribute ("va_type");
|
|
}
|
|
}
|
|
|
|
public string VAType {
|
|
get {
|
|
return elem.GetAttribute ("va_type");
|
|
}
|
|
}
|
|
|
|
public string AccessorReturnType {
|
|
get {
|
|
if (Count > 0)
|
|
return this [0].CSType;
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public string AccessorName {
|
|
get {
|
|
if (Count > 0)
|
|
return this [0].Name;
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|