GtkSharp/generator/ClassBase.cs
Mike Kestner fc06f3829a 2007-08-13 Mike Kestner <mkestner@novell.com>
* generator/*.cs : switch to IntPtr marshaling for struct types
	in the managed to native direction.
	* gtk/*.custom : adjust to new gapi struct pinvoke sigs.

svn path=/trunk/gtk-sharp/; revision=83961
2007-08-13 14:29:06 +00:00

464 lines
11 KiB
C#

// GtkSharp.Generation.ClassBase.cs - Common code between object
// and interface wrappers
//
// Authors: Rachel Hestilow <hestilow@ximian.com>
// Mike Kestner <mkestner@speakeasy.net>
//
// Copyright (c) 2002 Rachel Hestilow
// Copyright (c) 2001-2003 Mike Kestner
// Copyright (c) 2004 Novell, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of version 2 of the GNU General Public
// License as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public
// License along with this program; if not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
namespace GtkSharp.Generation {
using System;
using System.Collections;
using System.IO;
using System.Xml;
public abstract class ClassBase : GenBase {
protected Hashtable props = new Hashtable();
protected Hashtable fields = new Hashtable();
protected Hashtable sigs = new Hashtable();
protected Hashtable methods = new Hashtable();
protected ArrayList interfaces = new ArrayList();
protected ArrayList managed_interfaces = new ArrayList();
protected ArrayList ctors = new ArrayList();
private bool ctors_initted = false;
private Hashtable clash_map;
private bool deprecated = false;
private bool isabstract = false;
public Hashtable Methods {
get {
return methods;
}
}
public Hashtable Signals {
get {
return sigs;
}
}
public ClassBase Parent {
get {
string parent = Elem.GetAttribute("parent");
if (parent == "")
return null;
else
return SymbolTable.Table.GetClassGen(parent);
}
}
protected ClassBase (XmlElement ns, XmlElement elem) : base (ns, elem) {
if (elem.HasAttribute ("deprecated"))
deprecated = elem.GetAttribute ("deprecated") == "1";
if (elem.HasAttribute ("abstract"))
isabstract = elem.GetAttribute ("abstract") == "1";
foreach (XmlNode node in elem.ChildNodes) {
if (!(node is XmlElement)) continue;
XmlElement member = (XmlElement) node;
if (member.HasAttribute ("hidden"))
continue;
string name;
switch (node.Name) {
case "method":
name = member.GetAttribute("name");
while (methods.ContainsKey(name))
name += "mangled";
methods.Add (name, new Method (member, this));
break;
case "property":
name = member.GetAttribute("name");
while (props.ContainsKey(name))
name += "mangled";
props.Add (name, new Property (member, this));
break;
case "field":
name = member.GetAttribute("name");
while (fields.ContainsKey (name))
name += "mangled";
fields.Add (name, new ObjectField (member, this));
break;
case "signal":
name = member.GetAttribute("name");
while (sigs.ContainsKey(name))
name += "mangled";
sigs.Add (name, new Signal (member, this));
break;
case "implements":
ParseImplements (member);
break;
case "constructor":
ctors.Add (new Ctor (member, this));
break;
default:
break;
}
}
}
public override bool Validate ()
{
if (Parent != null && !Parent.ValidateForSubclass ())
return false;
foreach (string iface in interfaces) {
InterfaceGen igen = SymbolTable.Table[iface] as InterfaceGen;
if (igen == null) {
Console.WriteLine (QualifiedName + " implements unknown GInterface " + iface);
return false;
}
if (!igen.ValidateForSubclass ()) {
Console.WriteLine (QualifiedName + " implements invalid GInterface " + iface);
return false;
}
}
ArrayList invalids = new ArrayList ();
foreach (Property prop in props.Values) {
if (!prop.Validate ()) {
Console.WriteLine ("in type " + QualifiedName);
invalids.Add (prop);
}
}
foreach (Property prop in invalids)
props.Remove (prop.Name);
invalids.Clear ();
foreach (Signal sig in sigs.Values) {
if (!sig.Validate ()) {
Console.WriteLine ("in type " + QualifiedName);
invalids.Add (sig);
}
}
foreach (Signal sig in invalids)
sigs.Remove (sig.Name);
invalids.Clear ();
foreach (ObjectField field in fields.Values) {
if (!field.Validate ()) {
Console.WriteLine ("in type " + QualifiedName);
invalids.Add (field);
}
}
foreach (ObjectField field in invalids)
fields.Remove (field.Name);
invalids.Clear ();
foreach (Method method in methods.Values) {
if (!method.Validate ()) {
Console.WriteLine ("in type " + QualifiedName);
invalids.Add (method);
}
}
foreach (Method method in invalids)
methods.Remove (method.Name);
invalids.Clear ();
foreach (Ctor ctor in ctors) {
if (!ctor.Validate ()) {
Console.WriteLine ("in type " + QualifiedName);
invalids.Add (ctor);
}
}
foreach (Ctor ctor in invalids)
ctors.Remove (ctor);
invalids.Clear ();
return true;
}
public virtual bool ValidateForSubclass ()
{
ArrayList invalids = new ArrayList ();
foreach (Signal sig in sigs.Values) {
if (!sig.Validate ()) {
Console.WriteLine ("in type " + QualifiedName);
invalids.Add (sig);
}
}
foreach (Signal sig in invalids)
sigs.Remove (sig.Name);
invalids.Clear ();
return true;
}
public bool IsDeprecated {
get {
return deprecated;
}
}
public bool IsAbstract {
get {
return isabstract;
}
}
public abstract string AssignToName { get; }
public abstract string CallByName ();
protected bool IsNodeNameHandled (string name)
{
switch (name) {
case "method":
case "property":
case "field":
case "signal":
case "implements":
case "constructor":
case "disabledefaultconstructor":
return true;
default:
return false;
}
}
public void GenProperties (GenerationInfo gen_info, ClassBase implementor)
{
if (props.Count == 0)
return;
foreach (Property prop in props.Values)
prop.Generate (gen_info, "\t\t", implementor);
}
public void GenSignals (GenerationInfo gen_info, ClassBase implementor)
{
if (sigs == null)
return;
foreach (Signal sig in sigs.Values)
sig.Generate (gen_info, implementor);
}
protected void GenFields (GenerationInfo gen_info)
{
foreach (ObjectField field in fields.Values)
field.Generate (gen_info, "\t\t");
}
private void ParseImplements (XmlElement member)
{
foreach (XmlNode node in member.ChildNodes) {
if (node.Name != "interface")
continue;
XmlElement element = (XmlElement) node;
if (element.HasAttribute ("cname"))
interfaces.Add (element.GetAttribute ("cname"));
else if (element.HasAttribute ("name"))
managed_interfaces.Add (element.GetAttribute ("name"));
}
}
protected bool IgnoreMethod (Method method, ClassBase implementor)
{
if (implementor != null && implementor.QualifiedName != this.QualifiedName && method.IsStatic)
return true;
string mname = method.Name;
return ((method.IsSetter || (method.IsGetter && mname.StartsWith("Get"))) &&
((props != null) && props.ContainsKey(mname.Substring(3)) ||
(fields != null) && fields.ContainsKey(mname.Substring(3))));
}
public void GenMethods (GenerationInfo gen_info, Hashtable collisions, ClassBase implementor)
{
if (methods == null)
return;
foreach (Method method in methods.Values) {
if (IgnoreMethod (method, implementor))
continue;
string oname = null, oprotection = null;
if (collisions != null && collisions.Contains (method.Name)) {
oname = method.Name;
oprotection = method.Protection;
method.Name = QualifiedName + "." + method.Name;
method.Protection = "";
}
method.Generate (gen_info, implementor);
if (oname != null) {
method.Name = oname;
method.Protection = oprotection;
}
}
}
public Method GetMethod (string name)
{
return (Method) methods[name];
}
public Property GetProperty (string name)
{
return (Property) props[name];
}
public Signal GetSignal (string name)
{
return (Signal) sigs[name];
}
public Method GetMethodRecursively (string name)
{
return GetMethodRecursively (name, false);
}
public virtual Method GetMethodRecursively (string name, bool check_self)
{
Method p = null;
if (check_self)
p = GetMethod (name);
if (p == null && Parent != null)
p = Parent.GetMethodRecursively (name, true);
if (check_self && p == null) {
foreach (string iface in interfaces) {
ClassBase igen = SymbolTable.Table.GetClassGen (iface);
p = igen.GetMethodRecursively (name, true);
if (p != null)
break;
}
}
return p;
}
public virtual Property GetPropertyRecursively (string name)
{
ClassBase klass = this;
Property p = null;
while (klass != null && p == null) {
p = (Property) klass.GetProperty (name);
klass = klass.Parent;
}
return p;
}
public Signal GetSignalRecursively (string name)
{
return GetSignalRecursively (name, false);
}
public virtual Signal GetSignalRecursively (string name, bool check_self)
{
Signal p = null;
if (check_self)
p = GetSignal (name);
if (p == null && Parent != null)
p = Parent.GetSignalRecursively (name, true);
if (check_self && p == null) {
foreach (string iface in interfaces) {
ClassBase igen = SymbolTable.Table.GetClassGen (iface);
p = igen.GetSignalRecursively (name, true);
if (p != null)
break;
}
}
return p;
}
public bool Implements (string iface)
{
if (interfaces.Contains (iface))
return true;
else if (Parent != null)
return Parent.Implements (iface);
else
return false;
}
public ArrayList Ctors { get { return ctors; } }
bool HasStaticCtor (string name)
{
if (Parent != null && Parent.HasStaticCtor (name))
return true;
foreach (Ctor ctor in Ctors)
if (ctor.StaticName == name)
return true;
return false;
}
private void InitializeCtors ()
{
if (ctors_initted)
return;
if (Parent != null)
Parent.InitializeCtors ();
ArrayList valid_ctors = new ArrayList();
clash_map = new Hashtable();
foreach (Ctor ctor in ctors) {
if (clash_map.Contains (ctor.Signature.Types)) {
Ctor clash = clash_map [ctor.Signature.Types] as Ctor;
Ctor alter = ctor.Preferred ? clash : ctor;
alter.IsStatic = true;
if (Parent != null && Parent.HasStaticCtor (alter.StaticName))
alter.Modifiers = "new ";
} else
clash_map [ctor.Signature.Types] = ctor;
valid_ctors.Add (ctor);
}
ctors = valid_ctors;
ctors_initted = true;
}
protected virtual void GenCtors (GenerationInfo gen_info)
{
InitializeCtors ();
foreach (Ctor ctor in ctors)
ctor.Generate (gen_info);
}
public virtual void Finish (StreamWriter sw, string indent)
{
}
public virtual void Prepare (StreamWriter sw, string indent)
{
}
}
}