summaryrefslogtreecommitdiffstats
path: root/dcopidlng
diff options
context:
space:
mode:
Diffstat (limited to 'dcopidlng')
-rw-r--r--dcopidlng/Ast.pm91
-rw-r--r--dcopidlng/Iter.pm532
-rw-r--r--dcopidlng/configure.in.in5
-rwxr-xr-xdcopidlng/dcopidlng10
-rw-r--r--dcopidlng/kalyptus1654
-rw-r--r--dcopidlng/kalyptusCxxToDcopIDL.pm1047
-rw-r--r--dcopidlng/kalyptusDataDict.pm3042
-rw-r--r--dcopidlng/kdocAstUtil.pm762
-rw-r--r--dcopidlng/kdocLib.pm245
-rw-r--r--dcopidlng/kdocParseDoc.pm419
-rw-r--r--dcopidlng/kdocUtil.pm189
11 files changed, 7996 insertions, 0 deletions
diff --git a/dcopidlng/Ast.pm b/dcopidlng/Ast.pm
new file mode 100644
index 00000000..0fb4bd0d
--- /dev/null
+++ b/dcopidlng/Ast.pm
@@ -0,0 +1,91 @@
+package Ast;
+use strict;
+
+use vars qw/ $this $pack @endCodes /;
+
+#-----------------------------------------------------------------------------
+# This package is used to create a simple Abstract Syntax tree. Each node
+# in the AST is an associative array and supports two kinds of properties -
+# scalars and lists of scalars.
+# See SchemParser.pm for an example of usage.
+# ... Sriram
+#-----------------------------------------------------------------------------
+
+# Constructor
+# e.g AST::New ("personnel")
+# Stores the argument in a property called astNodeName whose sole purpose
+# is to support Print()
+
+sub New {
+ my ($this) = {"astNodeName" => $_[0]};
+ bless ($this);
+ return $this;
+}
+
+# Add a property to this object
+# $astNode->AddProp("className", "Employee");
+
+sub AddProp {
+ my ($this) = $_[0];
+ $this->{$_[1]} = $_[2];
+}
+
+# Equivalent to AddProp, except the property name is associated
+# with a list of values
+# $classAstNode->AddProp("attrList", $attrAstNode);
+
+sub AddPropList {
+ my ($this) = $_[0];
+ if (! exists $this->{$_[1]}) {
+ $this->{$_[1]} = [];
+ }
+ push (@{$this->{$_[1]}}, $_[2]);
+}
+
+# Returns a list of all the property names of this object
+sub GetProps {
+ my ($this) = $_[0];
+ return keys %{$this};
+}
+
+sub Visit {
+ # Converts each of this AstNode's properties into global variables.
+ # The global variables are introduced into package "main"
+ # At the same time, a piece of code is formed to undo this work above -
+ # $endCode essentially contains the values of these global variables
+ # before they are mangled. endCode gets pushed into a stack (endCodes),
+ # which is unwound by UnVisit().
+
+ local ($this, $pack) = @_;
+
+
+ my $code = "";
+ my $endCode = "";
+
+
+ foreach my $k (keys %{$this}) {
+
+ my $glob = $pack."::".$k;
+
+ if ( defined $$glob ) {
+
+ if ( ${$glob} ne "" ) {
+ $$glob =~ s/\'/\\\'/g;
+ }
+
+ $endCode .= '$'.$pack.'::'.$k. " = '".$$glob."';";
+ } else {
+ $endCode .= '$'.$pack . "::". $k . ' = "";';
+ }
+ $code .= '$'.$pack . "::" . $k . "= \$this->{\"$k\"};";
+ }
+ push (@endCodes, $endCode);
+ eval($code) if $code;
+}
+
+sub UnVisit {
+ my $code = pop(@endCodes);
+ eval($code) if ($code);
+}
+
+1;
diff --git a/dcopidlng/Iter.pm b/dcopidlng/Iter.pm
new file mode 100644
index 00000000..7279a6fa
--- /dev/null
+++ b/dcopidlng/Iter.pm
@@ -0,0 +1,532 @@
+package Iter;
+
+=head1 Iterator Module
+
+A set of iterator functions for traversing the various trees and indexes.
+Each iterator expects closures that operate on the elements in the iterated
+data structure.
+
+
+=head2 Generic
+
+ Params: $node, &$loopsub, &$skipsub, &$applysub, &$recursesub
+
+Iterate over $node\'s children. For each iteration:
+
+If loopsub( $node, $kid ) returns false, the loop is terminated.
+If skipsub( $node, $kid ) returns true, the element is skipped.
+
+Applysub( $node, $kid ) is called
+If recursesub( $node, $kid ) returns true, the function recurses into
+the current node.
+
+=cut
+
+sub Generic
+{
+ my ( $root, $loopcond, $skipcond, $applysub, $recursecond ) = @_;
+
+ return sub {
+ foreach my $node ( @{$root->{Kids}} ) {
+
+ if ( defined $loopcond ) {
+ return 0 unless $loopcond->( $root, $node );
+ }
+
+ if ( defined $skipcond ) {
+ next if $skipcond->( $root, $node );
+ }
+
+ my $ret = $applysub->( $root, $node );
+ return $ret if defined $ret && $ret;
+
+ if ( defined $recursecond
+ && $recursecond->( $root, $node ) ) {
+ $ret = Generic( $node, $loopcond, $skipcond,
+ $applysub, $recursecond)->();
+ if ( $ret ) {
+ return $ret;
+ }
+ }
+ }
+
+ return 0;
+ };
+}
+
+sub Class
+{
+ my ( $root, $applysub, $recurse ) = @_;
+
+ return Generic( $root, undef,
+ sub {
+ return !( $node->{NodeType} eq "class"
+ || $node->{NodeType} eq "struct" );
+ },
+ $applysub, $recurse );
+}
+
+=head2 Tree
+
+ Params: $root, $recurse?, $commonsub, $compoundsub, $membersub,
+ $skipsub
+
+Traverse the ast tree starting at $root, skipping if skipsub returns true.
+
+Applying $commonsub( $node, $kid),
+then $compoundsub( $node, $kid ) or $membersub( $node, $kid ) depending on
+the Compound flag of the node.
+
+=cut
+
+sub Tree
+{
+ my ( $rootnode, $recurse, $commonsub, $compoundsub, $membersub,
+ $skipsub ) = @_;
+
+ my $recsub = $recurse ? sub { return 1 if $_[1]->{Compound}; }
+ : undef;
+
+ Generic( $rootnode, undef, $skipsub,
+ sub { # apply
+ my ( $root, $node ) = @_;
+ my $ret;
+
+ if ( defined $commonsub ) {
+ $ret = $commonsub->( $root, $node );
+ return $ret if defined $ret;
+ }
+
+ if ( $node->{Compound} && defined $compoundsub ) {
+ $ret = $compoundsub->( $root, $node );
+ return $ret if defined $ret;
+ }
+
+ if( !$node->{Compound} && defined $membersub ) {
+ $ret = $membersub->( $root, $node );
+ return $ret if defined $ret;
+ }
+ return;
+ },
+ $recsub # skip
+ )->();
+}
+
+=head2 LocalCompounds
+
+Apply $compoundsub( $node ) to all locally defined compound nodes
+(ie nodes that are not external to the library being processed).
+
+=cut
+
+sub LocalCompounds
+{
+ my ( $rootnode, $compoundsub ) = @_;
+
+ return unless defined $rootnode && defined $rootnode->{Kids};
+
+ foreach my $kid ( sort { $a->{astNodeName} cmp $b->{astNodeName} }
+ @{$rootnode->{Kids}} ) {
+ next if !defined $kid->{Compound};
+
+ $compoundsub->( $kid ) unless defined $kid->{ExtSource};
+ LocalCompounds( $kid, $compoundsub );
+ }
+}
+
+=head2 Hierarchy
+
+ Params: $node, $levelDownSub, $printSub, $levelUpSub
+
+This allows easy hierarchy traversal and printing.
+
+Traverses the inheritance hierarchy starting at $node, calling printsub
+for each node. When recursing downward into the tree, $levelDownSub($node) is
+called, the recursion takes place, and $levelUpSub is called when the
+recursion call is completed.
+
+=cut
+
+sub Hierarchy
+{
+ my ( $node, $ldownsub, $printsub, $lupsub, $nokidssub ) = @_;
+
+ return if defined $node->{ExtSource}
+ && (!defined $node->{InBy}
+ || !kdocAstUtil::hasLocalInheritor( $node ));
+
+ $printsub->( $node );
+
+ if ( defined $node->{InBy} ) {
+ $ldownsub->( $node );
+
+ foreach my $kid (
+ sort {$a->{astNodeName} cmp $b->{astNodeName}}
+ @{ $node->{InBy} } ) {
+ Hierarchy( $kid, $ldownsub, $printsub, $lupsub );
+ }
+
+ $lupsub->( $node );
+ }
+ elsif ( defined $nokidssub ) {
+ $nokidssub->( $node );
+ }
+
+ return;
+}
+
+=head2
+
+ Call $printsub for each *direct* ancestor of $node.
+ Only multiple inheritance can lead to $printsub being called more than once.
+
+=cut
+sub Ancestors
+{
+ my ( $node, $rootnode, $noancessub, $startsub, $printsub,
+ $endsub ) = @_;
+ my @anlist = ();
+
+ return if $node eq $rootnode;
+
+ if ( !exists $node->{InList} ) {
+ $noancessub->( $node ) unless !defined $noancessub;
+ return;
+ }
+
+ foreach my $innode ( @{ $node->{InList} } ) {
+ my $nref = $innode->{Node}; # real ancestor
+ next if defined $nref && $nref == $rootnode;
+
+ push @anlist, $innode;
+ }
+
+ if ( $#anlist < 0 ) {
+ $noancessub->( $node ) unless !defined $noancessub;
+ return;
+ }
+
+ $startsub->( $node ) unless !defined $startsub;
+
+ foreach my $innode ( sort { $a->{astNodeName} cmp $b->{astNodeName} }
+ @anlist ) {
+
+ # print
+ $printsub->( $innode->{Node}, $innode->{astNodeName},
+ $innode->{Type}, $innode->{TmplType} )
+ unless !defined $printsub;
+ }
+
+ $endsub->( $node ) unless !defined $endsub;
+
+ return;
+
+}
+
+sub Descendants
+{
+ my ( $node, $nodescsub, $startsub, $printsub, $endsub ) = @_;
+
+ if ( !exists $node->{InBy} ) {
+ $nodescsub->( $node ) unless !defined $nodescsub;
+ return;
+ }
+
+
+ my @desclist = ();
+ DescendantList( \@desclist, $node );
+
+ if ( $#desclist < 0 ) {
+ $nodescsub->( $node ) unless !defined $nodescsub;
+ return;
+ }
+
+ $startsub->( $node ) unless !defined $startsub;
+
+ foreach my $innode ( sort { $a->{astNodeName} cmp $b->{astNodeName} }
+ @desclist ) {
+
+ $printsub->( $innode)
+ unless !defined $printsub;
+ }
+
+ $endsub->( $node ) unless !defined $endsub;
+
+ return;
+
+}
+
+sub DescendantList
+{
+ my ( $list, $node ) = @_;
+
+ return unless exists $node->{InBy};
+
+ foreach my $kid ( @{ $node->{InBy} } ) {
+ push @$list, $kid;
+ DescendantList( $list, $kid );
+ }
+}
+
+=head2 DocTree
+
+=cut
+
+sub DocTree
+{
+ my ( $rootnode, $allowforward, $recurse,
+ $commonsub, $compoundsub, $membersub ) = @_;
+
+ Generic( $rootnode, undef,
+ sub { # skip
+ my( $node, $kid ) = @_;
+
+ unless (!(defined $kid->{ExtSource})
+ && ($allowforward || $kid->{NodeType} ne "Forward")
+ && ($main::doPrivate || !($kid->{Access} =~ /private/))
+ && exists $kid->{DocNode} ) {
+
+ return 1;
+ }
+
+ return;
+ },
+ sub { # apply
+ my ( $root, $node ) = @_;
+
+ my $ret;
+
+ if ( defined $commonsub ) {
+ $ret = $commonsub->( $root, $node );
+ return $ret if defined $ret;
+ }
+
+ if ( $node->{Compound} && defined $compoundsub ) {
+ $ret = $compoundsub->( $root, $node );
+ return $ret if defined $ret;
+ }
+ elsif( defined $membersub ) {
+ $ret = $membersub->( $root, $node );
+ return $ret if defined $ret;
+ }
+
+ return;
+ },
+ sub { return 1 if $recurse; return; } # recurse
+ )->();
+
+}
+
+sub MembersByType
+{
+ my ( $node, $startgrpsub, $methodsub, $endgrpsub, $nokidssub ) = @_;
+
+# public
+ # types
+ # data
+ # methods
+ # signals
+ # slots
+ # static
+# protected
+# private (if enabled)
+
+ if ( !defined $node->{Kids} ) {
+ $nokidssub->( $node ) if defined $nokidssub;
+ return;
+ }
+
+ foreach my $acc ( qw/public protected private/ ) {
+ next if $acc eq "private" && !$main::doPrivate;
+ $access = $acc;
+
+ my @types = ();
+ my @data = ();
+ my @signals = ();
+ my @k_dcops = ();
+ my @k_dcop_signals = ();
+ my @k_dcop_hiddens = ();
+ my @slots =();
+ my @methods = ();
+ my @static = ();
+ my @modules = ();
+ my @interfaces = ();
+
+ # Build lists
+ foreach my $kid ( @{$node->{Kids}} ) {
+ next unless ( $kid->{Access} =~ /$access/
+ && !$kid->{ExtSource})
+ || ( $access eq "public"
+ && ( $kid->{Access} eq "signals"
+ || $kid->{Access} =~ "k_dcop" # note the =~
+ || $kid->{Access} eq "K_DCOP"));
+
+ my $type = $kid->{NodeType};
+
+ if ( $type eq "method" ) {
+ if ( $kid->{Flags} =~ "s" ) {
+ push @static, $kid;
+ }
+ elsif ( $kid->{Flags} =~ "l" ) {
+ push @slots, $kid;
+ }
+ elsif ( $kid->{Flags} =~ "n" ) {
+ push @signals, $kid;
+ }
+ elsif ( $kid->{Flags} =~ "d" ) {
+ push @k_dcops, $kid;
+ }
+ elsif ( $kid->{Flags} =~ "z" ) {
+ push @k_dcop_signals, $kid;
+ }
+ elsif ( $kid->{Flags} =~ "y" ) {
+ push @k_dcop_hiddens, $kid;
+ }
+ else {
+ push @methods, $kid; }
+ }
+ elsif ( $kid->{Compound} ) {
+ if ( $type eq "module" ) {
+ push @modules, $kid;
+ }
+ elsif ( $type eq "interface" ) {
+ push @interfaces, $kid;
+ }
+ else {
+ push @types, $kid;
+ }
+ }
+ elsif ( $type eq "typedef" || $type eq "enum" ) {
+ push @types, $kid;
+ }
+ else {
+ push @data, $kid;
+ }
+ }
+
+ # apply
+ $uc_access = ucfirst( $access );
+
+ doGroup( "$uc_access Types", $node, \@types, $startgrpsub,
+ $methodsub, $endgrpsub);
+ doGroup( "Modules", $node, \@modules, $startgrpsub,
+ $methodsub, $endgrpsub);
+ doGroup( "Interfaces", $node, \@interfaces, $startgrpsub,
+ $methodsub, $endgrpsub);
+ doGroup( "$uc_access Methods", $node, \@methods, $startgrpsub,
+ $methodsub, $endgrpsub);
+ doGroup( "$uc_access Slots", $node, \@slots, $startgrpsub,
+ $methodsub, $endgrpsub);
+ doGroup( "Signals", $node, \@signals, $startgrpsub,
+ $methodsub, $endgrpsub);
+ doGroup( "k_dcop", $node, \@k_dcops, $startgrpsub,
+ $methodsub, $endgrpsub);
+ doGroup( "k_dcop_signals", $node, \@k_dcop_signals, $startgrpsub,
+ $methodsub, $endgrpsub);
+ doGroup( "k_dcop_hiddens", $node, \@k_dcop_hiddens, $startgrpsub,
+ $methodsub, $endgrpsub);
+ doGroup( "$uc_access Static Methods", $node, \@static,
+ $startgrpsub, $methodsub, $endgrpsub);
+ doGroup( "$uc_access Members", $node, \@data, $startgrpsub,
+ $methodsub, $endgrpsub);
+ }
+}
+
+sub doGroup
+{
+ my ( $name, $node, $list, $startgrpsub, $methodsub, $endgrpsub ) = @_;
+
+ my ( $hasMembers ) = 0;
+ foreach my $kid ( @$list ) {
+ if ( !exists $kid->{DocNode}->{Reimplemented} ) {
+ $hasMembers = 1;
+ break;
+ }
+ }
+ return if !$hasMembers;
+
+ if ( defined $methodsub ) {
+ foreach my $kid ( @$list ) {
+ if ( !exists $kid->{DocNode}->{Reimplemented} ) {
+ $methodsub->( $node, $kid );
+ }
+ }
+ }
+
+ $endgrpsub->( $name ) if defined $endgrpsub;
+}
+
+sub ByGroupLogical
+{
+ my ( $root, $startgrpsub, $itemsub, $endgrpsub ) = @_;
+
+ return 0 unless defined $root->{Groups};
+
+ foreach my $groupname ( sort keys %{$root->{Groups}} ) {
+ next if $groupname eq "astNodeName"||$groupname eq "NodeType";
+
+ my $group = $root->{Groups}->{ $group };
+ next unless $group->{Kids};
+
+ $startgrpsub->( $group->{astNodeName}, $group->{Desc} );
+
+ foreach my $kid (sort {$a->{astNodeName} cmp $b->{astNodeName}}
+ @group->{Kids} ) {
+ $itemsub->( $root, $kid );
+ }
+ $endgrpsub->( $group->{Desc} );
+ }
+
+ return 1;
+}
+
+sub SeeAlso
+{
+ my ( $node, $nonesub, $startsub, $printsub, $endsub ) = @_;
+
+ if( !defined $node ) {
+ $nonesub->();
+ return;
+ }
+
+ my $doc = $node;
+
+ if ( $node->{NodeType} ne "DocNode" ) {
+ $doc = $node->{DocNode};
+ if ( !defined $doc ) {
+ $nonesub->() if defined $nonesub;
+ return;
+ }
+ }
+
+ if ( !defined $doc->{See} ) {
+ $nonesub->() if defined $nonesub;
+ return;
+ }
+
+ my $see = $doc->{See};
+ my $ref = $doc->{SeeRef};
+
+ if ( $#$see < 1 ) {
+ $nonesub->() if defined $nonesub;
+ return;
+ }
+
+ $startsub->( $node ) if defined $startsub;
+
+ for my $i ( 0..$#$see ) {
+ my $seelabel = $see->[ $i ];
+ my $seenode = undef;
+ if ( defined $ref ) {
+ $seenode = $ref->[ $i ];
+ }
+
+ $printsub->( $seelabel, $seenode ) if defined $printsub;
+ }
+
+ $endsub->( $node ) if defined $endsub;
+
+ return;
+}
+
+1;
diff --git a/dcopidlng/configure.in.in b/dcopidlng/configure.in.in
new file mode 100644
index 00000000..9ddc180e
--- /dev/null
+++ b/dcopidlng/configure.in.in
@@ -0,0 +1,5 @@
+dnl we need to use our own copy, since kmailicalIface needs post 3.3 fixes in it
+dnl TODO: remove once we rely on kdelibs 3.4
+DCOPIDLNG='$(top_srcdir)/dcopidlng/dcopidlng'
+AC_SUBST(DCOPIDLNG)
+
diff --git a/dcopidlng/dcopidlng b/dcopidlng/dcopidlng
new file mode 100755
index 00000000..d9ba453d
--- /dev/null
+++ b/dcopidlng/dcopidlng
@@ -0,0 +1,10 @@
+#!/bin/sh
+trap "rm -f dcopidlng.stderr.$$" 0 1 2 15
+LIBDIR=`dirname $0`
+perl -I"$LIBDIR" "$LIBDIR/kalyptus" --allow_k_dcop_accessors -f dcopidl $1 2>dcopidlng.stderr.$$
+RET=$?
+if [ $RET -ne 0 ]
+then
+ cat dcopidlng.stderr.$$ >&2
+fi
+exit $RET
diff --git a/dcopidlng/kalyptus b/dcopidlng/kalyptus
new file mode 100644
index 00000000..b2781d11
--- /dev/null
+++ b/dcopidlng/kalyptus
@@ -0,0 +1,1654 @@
+#!/usr/bin/perl -I/Users/duke/src/kde/kdebindings/kalyptus
+
+# KDOC -- C++ and CORBA IDL interface documentation tool.
+# Sirtaj Singh Kang <taj@kde.org>, Jan 1999.
+# $Id$
+
+# All files in this project are distributed under the GNU General
+# Public License. This is Free Software.
+
+require 5.000;
+
+use Carp;
+use Getopt::Long;
+use File::Basename;
+use strict;
+
+use Ast;
+
+use kdocUtil;
+use kdocAstUtil;
+use kdocParseDoc;
+
+use vars qw/ %rootNodes $declNodeType @includes_list %options @formats_wanted $allow_k_dcop_accessors
+ @includeclasses $includeclasses $skipInternal %defines $defines $match_qt_defines
+ $libdir $libname $outputdir @libs $parse_global_space $striphpath $doPrivate $readstdin
+ $Version $quiet $debug $debuggen $parseonly $currentfile $cSourceNode $exe
+ %formats %flagnames @allowed_k_dcop_accesors $allowed_k_dcop_accesors_re $rootNode
+ @classStack $cNode $globalSpaceClassName
+ $lastLine $docNode @includes $cpp $defcppcmd $cppcmd $docincluded
+ $inExtern %stats %definitions @inputqueue @codeqobject /;
+
+## globals
+
+%rootNodes = (); # root nodes for each file type
+$declNodeType = undef; # last declaration type
+
+@includes_list = (); # list of files included from the parsed .h
+
+# All options
+
+%options = (); # hash of options (set getopt below)
+@formats_wanted = ();
+$libdir = $ENV{KDOCLIBS};
+$libname = "";
+$outputdir = ".";
+@libs = (); # list of includes
+$striphpath = 0;
+
+@includeclasses = (); # names of classes to include
+$includeclasses = "";
+
+$doPrivate = 0;
+$Version = "0.9";
+
+$quiet = 0;
+$debug = 0;
+$debuggen = 0;
+$parseonly = 0;
+$globalSpaceClassName = "QGlobalSpace";
+
+$currentfile = "";
+
+$cpp = 0;
+$defcppcmd = "g++ -Wp,-C -E";
+$cppcmd = "";
+
+$exe = basename $0;
+
+@inputqueue = ();
+@codeqobject = split "\n", <<CODE;
+public:
+ virtual QMetaObject *metaObject() const;
+ virtual const char *className() const;
+ virtual void* qt_cast( const char* );
+ virtual bool qt_invoke( int, QUObject* );
+ virtual bool qt_emit( int, QUObject* );
+ virtual bool qt_property( int, int, QVariant* );
+ static QMetaObject* staticMetaObject();
+ QObject* qObject();
+ static QString tr( const char *, const char * = 0 );
+ static QString trUtf8( const char *, const char * = 0 );
+private:
+CODE
+
+# Supported formats
+%formats = ( "java" => "kalyptusCxxToJava", "c" => "kalyptusCxxToC",
+ "objc" => "kalyptusCxxToObjc", "dcopidl" => "kalyptusCxxToDcopIDL",
+ "smoke" => "kalyptusCxxToSmoke", "csharp" => "kalyptusCxxToCSharp",
+ "ECMA" => "kalyptusCxxToECMA", "swig" => "kalyptusCxxToSwig" );
+
+# these are for expansion of method flags
+%flagnames = ( v => 'virtual', 's' => 'static', p => 'pure',
+ c => 'const', l => 'slot', i => 'inline', n => 'signal',
+ d => 'k_dcop', z => 'k_dcop_signals', y => 'k_dcop_hidden' );
+
+@allowed_k_dcop_accesors = qw(k_dcop k_dcop_hidden k_dcop_signals);
+$allowed_k_dcop_accesors_re = join("|", @allowed_k_dcop_accesors);
+
+%definitions = {
+ _STYLE_CDE => '',
+ _STYLE_MOTIF => '',
+ _STYLE_MOTIF_PLUS => '',
+ PLUS => '',
+ _STYLE_PLATINUM => '',
+ _STYLE_SGI => '',
+ _STYLE_WINDOWS => '',
+ QT_STATIC_CONST => 'static const',
+ Q_EXPORT => '',
+ Q_REFCOUNT => '',
+ QM_EXPORT_CANVAS => '',
+ QM_EXPORT_DNS => '',
+ QM_EXPORT_ICONVIEW => '',
+ QM_EXPORT_NETWORK => '',
+ QM_EXPORT_SQL => '',
+ QM_EXPORT_WORKSPACE => '',
+ QT_NO_REMOTE => 'QT_NO_REMOTE',
+ QT_ACCESSIBILITY_SUPPORT => 'QT_ACCESSIBILITY_SUPPORT',
+ Q_WS_X11 => 'Q_WS_X11',
+ Q_DISABLE_COPY => 'Q_DISABLE_COPY',
+ Q_WS_QWS => 'undef',
+ Q_WS_MAC => 'undef',
+ Q_OBJECT => <<'CODE',
+public:
+ virtual QMetaObject *metaObject() const;
+ virtual const char *className() const;
+ virtual bool qt_invoke( int, QUObject* );
+ virtual bool qt_emit( int, QUObject* );
+ static QString tr( const char *, const char * = 0 );
+ static QString trUtf8( const char *, const char * = 0 );
+private:
+CODE
+};
+
+=head1 KDOC -- Source documentation tool
+
+ Sirtaj Singh Kang <taj@kde.org>, Dec 1998.
+
+=cut
+
+# read options
+
+Getopt::Long::config qw( no_ignore_case permute bundling auto_abbrev );
+
+GetOptions( \%options,
+ "format|f=s", \@formats_wanted,
+ "url|u=s",
+ "skip-internal", \$skipInternal,
+ "skip-deprecated|e",
+ "document-all|a",
+ "compress|z",
+ "no-cache", # do not create $HOME/.kalyptus cache
+ # HTML options
+ "html-cols=i",
+ "html-logo=s",
+
+ "strip-h-path", \$striphpath,
+ "outputdir|d=s", \$outputdir,
+ "stdin|i", \$readstdin,
+ "name|n=s", \$libname,
+ "help|h", \&show_usage,
+ "version|v|V", \&show_version,
+ "private|p", \$doPrivate,
+ "libdir|L=s", \$libdir,
+ "xref|l=s", \@libs,
+ "classes|c=s", \@includeclasses,
+ "globspace", \$parse_global_space,
+ "allow_k_dcop_accessors", \$allow_k_dcop_accessors,
+
+ "cpp|P", \$cpp,
+ "docincluded", \$docincluded,
+ "cppcmd|C=s", \$cppcmd,
+ "includedir|I=s", \@includes,
+ "define=s", \%defines, # define a single preprocessing symbol
+ "defines=s", \$defines, # file containing preprocessing symbols, one per line
+
+ "quiet|q", \$quiet,
+ "debug|D", \$debug, # debug the parsing
+ "debuggen", \$debuggen, # debug the file generation
+ "parse-only", \$parseonly )
+ || exit 1;
+
+$| = 1 if $debug or $debuggen;
+
+# preprocessor settings
+
+if ( $cppcmd eq "" ) {
+ $cppcmd = $defcppcmd;
+}
+else {
+ $cpp = 1;
+}
+
+if ($#includeclasses>=0)
+{
+ $includeclasses = join (" ", @includeclasses);
+ print "Using Classes: $includeclasses\n" unless $quiet;
+}
+
+if ( $#includes >= 0 && !$cpp ) {
+ die "$exe: --includedir requires --cpp\n";
+}
+
+# Check output formats. HTML is the default
+if( $#formats_wanted < 0 ) {
+ push @formats_wanted, "java";
+}
+
+foreach my $format ( @formats_wanted ) {
+ die "$exe: unsupported format '$format'.\n"
+ if !defined $formats{$format};
+}
+
+if( $defines )
+{
+ open( DEFS, $defines ) or die "Couldn't open $defines: $!\n";
+ my @defs = <DEFS>;
+ chomp @defs;
+ close DEFS;
+ foreach (@defs)
+ {
+ $defines{ $_ } = 1 unless exists $defines{ $_ };
+ }
+}
+
+# Check the %defines hash for QT_* symbols and compile the corresponding RE
+# Otherwise, compile the default ones. Used for filtering in readCxxLine.
+if ( my @qt_defines = map { ($_=~m/^QT_(.*)/)[0] } keys %defines)
+{
+ my $regexp = "m/^#\\s*ifn?def\\s+QT_(?:" . join('|', map { "\$qt_defines[$_]" } 0..$#qt_defines).")/o";
+ $match_qt_defines = eval "sub { my \$s=shift;
+ \$s=~/^#\\s*if(n)?def/ || return 0;
+ if(!\$1) { return \$s=~$regexp ? 0:1 }
+ else { return \$s=~$regexp ? 1:0 }
+ }";
+ die if $@;
+}
+else
+{
+ $match_qt_defines = eval q£
+ sub
+ {
+ my $s = shift;
+ $s =~ m/^\#\s*ifndef\s+QT_NO_(?:REMOTE| # not in the default compile options
+ NIS| # ...
+ XINERAMA|
+ IMAGEIO_(?:MNG|JPEG)|
+ STYLE_(?:MAC|INTERLACE|COMPACT)
+ )/x;
+ }
+ £;
+ die if $@;
+}
+# Check if there any files to process.
+# We do it here to prevent the libraries being loaded up first.
+
+checkFileArgs();
+
+# work out libdir. This is created by kdocLib:writeDoc when
+# required.
+$libdir = $ENV{HOME}."/.kalyptus" unless $libdir ne "";
+
+
+######
+###### main program
+######
+ readLibraries();
+ parseFiles();
+
+ if ( $parseonly ) {
+ print "\n\tParse Tree\n\t------------\n\n";
+ kdocAstUtil::dumpAst( $rootNode );
+ }
+ else {
+ writeDocumentation();
+ writeLibrary() unless $libname eq "";
+ }
+
+ kdocAstUtil::printDebugStats() if $debug;
+
+ exit 0;
+######
+
+sub checkFileArgs
+{
+ return unless $#ARGV < 0;
+
+ die "$exe: no input files.\n" unless $readstdin;
+
+ # read filenames from standard input
+ while (<STDIN>) {
+ chop;
+ $_ =~ s,\\,/,g; # back to fwd slash (for Windows)
+ foreach my $file ( split( /\s+/, $_ ) ) {
+ push @ARGV, $file;
+ }
+ }
+}
+
+sub readLibraries
+{
+ return if $#libs < 0;
+
+ require kdocLib;
+ foreach my $lib ( @libs ) {
+ print "$exe: reading lib: $lib\n" unless $quiet;
+
+ my $relpath = exists $options{url} ?
+ $options{url} : $outputdir;
+ kdocLib::readLibrary( \&getRoot, $lib, $libdir, $relpath );
+ }
+}
+
+sub parseFiles
+{
+ foreach $currentfile ( @ARGV ) {
+ my $lang = "CXX";
+
+ if ( $currentfile =~ /\.idl\s*$/ ) {
+ # IDL file
+ $lang = "IDL";
+ }
+
+ # assume cxx file
+ if( $cpp ) {
+ # pass through preprocessor
+ my $cmd = $cppcmd;
+ foreach my $dir ( @includes ) {
+ $cmd .= " -I $dir ";
+ }
+
+ $cmd .= " -DQOBJECTDEFS_H $currentfile";
+
+ open( INPUT, "$cmd |" )
+ || croak "Can't preprocess $currentfile";
+ }
+ else {
+ open( INPUT, "$currentfile" )
+ || croak "Can't read from $currentfile";
+ }
+
+ print STDERR "$exe: processing $currentfile\n" unless $quiet;
+
+ # reset vars
+ $rootNode = getRoot( $lang );
+
+
+ # add to file lookup table
+ my $showname = $striphpath ? basename( $currentfile )
+ : $currentfile;
+ $cSourceNode = Ast::New( $showname );
+ $cSourceNode->AddProp( "NodeType", "source" );
+ $cSourceNode->AddProp( "Path", $currentfile );
+ $rootNode->AddPropList( "Sources", $cSourceNode );
+
+ # reset state
+ @classStack = ();
+ $cNode = $rootNode;
+ $inExtern = 0;
+
+ # parse
+ my $k = undef;
+ while ( defined ($k = readDecl()) ) {
+ print "\nDecl: <$k>[$declNodeType]\n" if $debug;
+ if( identifyDecl( $k ) && $k =~ /{/ ) {
+ readCxxCodeBlock();
+ }
+ }
+ close INPUT;
+ }
+}
+
+
+sub writeDocumentation
+{
+ foreach my $node ( values %rootNodes ) {
+ # postprocess
+ kdocAstUtil::linkNamespaces( $node );
+ kdocAstUtil::makeInherit( $node, $node );
+ kdocAstUtil::linkReferences( $node, $node );
+ kdocAstUtil::calcStats( \%stats, $node, $node );
+
+ # write
+ no strict "refs";
+ foreach my $format ( @formats_wanted ) {
+ my $pack = $formats{ $format };
+ require $pack.".pm";
+
+ print STDERR "Generating bindings for $format ",
+ "language...\n" unless $quiet;
+
+ my $f = "$pack\::writeDoc";
+ &$f( $libname, $node, $outputdir, \%options );
+ }
+ }
+}
+
+sub writeLibrary
+{
+ if( $libname ne "" and !exists $options{'no-cache'} ) {
+ require kdocLib;
+ foreach my $lang ( keys %rootNodes ) {
+ my $node = $rootNodes{ $lang };
+ kdocLib::writeDoc( $libname, $node, $lang, $libdir,
+ $outputdir, $options{url},
+ exists $options{compress} ? 1 : 0 );
+ }
+ }
+}
+
+###### Parser routines
+
+=head2 readSourceLine
+
+ Returns a raw line read from the current input file.
+ This is used by routines outside main, since I don t know
+ how to share fds.
+
+=cut
+
+sub readSourceLine
+{
+ return <INPUT>;
+}
+
+=head2 readCxxLine
+
+ Reads a C++ source line, skipping comments, blank lines,
+ preprocessor tokens and the Q_OBJECT macro
+
+=cut
+
+sub readCxxLine
+{
+ my( $p );
+ my( $l );
+
+ while( 1 ) {
+ $p = shift @inputqueue || <INPUT>;
+ return undef if !defined ($p);
+
+ $p =~ s#//.*$##g; # C++ comment
+ $p =~ s#/\*(?!\*).*?\*/##g; # C comment
+
+ # join all multiline comments
+ if( $p =~ m#/\*(?!\*)#s ) {
+ # unterminated comment
+LOOP:
+ while( defined ($l = <INPUT>) ) {
+ $l =~ s#//.*$##g; # C++ comment
+ $p .= $l;
+ $p =~ s#/\*(?!\*).*?\*/##sg; # C comment
+ last LOOP unless $p =~ m#(/\*(?!\*))|(\*/)#sg;
+ }
+ }
+
+ if ( $p =~ /^\s*Q_OBJECT/ ) {
+ push @inputqueue, @codeqobject;
+ next;
+ }
+ # Hack, waiting for real handling of preprocessor defines
+ $p =~ s/QT_STATIC_CONST/static const/;
+ $p =~ s/KSVG_GET/KJS::Value get();/;
+ $p =~ s/KSVG_BASECLASS_GET/KJS::Value get();/;
+ $p =~ s/KSVG_BRIDGE/KJS::ObjectImp *bridge();/;
+ $p =~ s/KSVG_FORWARDGET/KJS::Value getforward();/;
+ $p =~ s/KSVG_PUT/bool put();/;
+ $p =~ s/KSVG_FORWARDPUT/bool putforward();/;
+ $p =~ s/KSVG_BASECLASS/virtual KJS::Value cache();/;
+ if ( $p =~ m/KSVG_DEFINE_PROTOTYPE\((\w+)\)/ ) {
+ push @inputqueue, split('\n',"namespace KSVG {\nclass $1 {\n};\n};");
+ }
+
+ next if ( $p =~ /^\s*$/s ); # blank lines
+# || $p =~ /^\s*Q_OBJECT/ # QObject macro
+# );
+#
+
+ next if ( $p =~ /^\s*Q_ENUMS/ # ignore Q_ENUMS
+ || $p =~ /^\s*Q_PROPERTY/ # and Q_PROPERTY
+ || $p =~ /^\s*Q_OVERRIDE/ # and Q_OVERRIDE
+ || $p =~ /^\s*Q_SETS/
+ || $p =~ /^\s*Q_DUMMY_COMPARISON_OPERATOR/
+ || $p =~ /^\s*K_SYCOCATYPE/ # and K_SYCOCA stuff
+ || $p =~ /^\s*K_SYCOCAFACTORY/ #
+ || $p =~ /^\s*KSVG_/ # and KSVG stuff ;)
+ );
+
+ push @includes_list, $1 if $p =~ /^#include\s+<?(.*?)>?\s*$/;
+
+ # remove all preprocessor macros
+ if( $p =~ /^\s*#\s*(\w+)/ ) {
+ # Handling of preprocessed sources: skip anything included from
+ # other files, unless --docincluded was passed.
+ if (!$docincluded && $p =~ /^\s*#\s*[0-9]+\s*\".*$/
+ && not($p =~ /\"$currentfile\"/)) {
+ # include file markers
+ while( <INPUT> ) {
+ last if(/\"$currentfile\"/);
+ print "Overread $_" if $debug;
+ };
+ print "Cont: $_" if $debug;
+ }
+ else {
+ # Skip platform-specific stuff, or #if 0 stuff
+ # or #else of something we parsed (e.g. for QKeySequence)
+ if ( $p =~ m/^#\s*ifdef\s*Q_WS_/ or
+ $p =~ m/^#\s*if\s+defined\(Q_WS_/ or
+ $p =~ m/^#\s*if\s+defined\(Q_OS_/ or
+ $p =~ m/^#\s*if\s+defined\(Q_CC_/ or
+ $p =~ m/^#\s*if\s+defined\(QT_THREAD_SUPPORT/ or
+ $p =~ m/^#\s*else/ or
+ $p =~ m/^#\s*if\s+defined\(Q_FULL_TEMPLATE_INSTANTIATION/ or
+ $p =~ m/^#\s*ifdef\s+CONTAINER_CUSTOM_WIDGETS/ or
+ &$match_qt_defines( $p ) or
+ $p =~ m/^#\s*if\s+0\s+/ ) {
+ my $if_depth = 1;
+ while ( defined $p && $if_depth > 0 ) {
+ $p = <INPUT>;
+ last if !defined $p;
+ $if_depth++ if $p =~ m/^#\s*if/;
+ $if_depth-- if $p =~ m/^#\s*endif/;
+ # Exit at #else in the #ifdef QT_NO_ACCEL/#else/#endif case
+ last if $if_depth == 1 && $p =~ m/^#\s*else\s/;
+ #ignore elif for now
+ print "Skipping ifdef'ed line: $p" if $debug;
+ }
+ }
+
+ # multiline macros
+ while ( defined $p && $p =~ m#\\\s*$# ) {
+ $p = <INPUT>;
+ }
+ }
+ next;
+ }
+
+ $lastLine = $p;
+ return $p;
+ }
+}
+
+=head2 readCxxCodeBlock
+
+ Reads a C++ code block (recursive curlies), returning the last line
+ or undef on error.
+
+ Parameters: none
+
+=cut
+
+sub readCxxCodeBlock
+{
+# Code: begins in a {, ends in }\s*;?
+# In between: cxx source, including {}
+ my ( $count ) = 0;
+ my $l = undef;
+
+ if ( defined $lastLine ) {
+ print "lastLine: '$lastLine'" if $debug;
+
+ my $open = kdocUtil::countReg( $lastLine, "{" );
+ my $close = kdocUtil::countReg( $lastLine, "}" );
+ $count = $open - $close;
+
+ return $lastLine if ( $open || $close) && $count == 0;
+ }
+
+ # find opening brace
+ if ( $count == 0 ) {
+ while( $count == 0 ) {
+ $l = readCxxLine();
+ return undef if !defined $l;
+ $l =~ s/\\.//g;
+ $l =~ s/'.?'//g;
+ $l =~ s/".*?"//g;
+
+ $count += kdocUtil::countReg( $l, "{" );
+ print "c ", $count, " at '$l'" if $debug;
+ }
+ $count -= kdocUtil::countReg( $l, "}" );
+ }
+
+ # find associated closing brace
+ while ( $count > 0 ) {
+ $l = readCxxLine();
+ croak "Confused by unmatched braces" if !defined $l;
+ $l =~ s/\\.//g;
+ $l =~ s/'.?'//g;
+ $l =~ s/".*?"//g;
+
+ my $add = kdocUtil::countReg( $l, "{" );
+ my $sub = kdocUtil::countReg( $l, "}" );
+ $count += $add - $sub;
+
+ print "o ", $add, " c ", $sub, " at '$l'" if $debug;
+ }
+
+ undef $lastLine;
+ return $l;
+}
+
+=head2 readDecl
+
+ Returns a declaration and sets the $declNodeType variable.
+
+ A decl starts with a type or keyword and ends with [{};]
+ The entire decl is returned in a single line, sans newlines.
+
+ declNodeType values: undef for error, "a" for access specifier,
+ "c" for doc comment, "d" for other decls.
+
+ readCxxLine is used to read the declaration.
+
+=cut
+
+sub readDecl
+{
+ undef $declNodeType;
+ my $l = readCxxLine();
+ my ( $decl ) = "";
+
+ my $allowed_accesors = "private|public|protected|signals";
+ $allowed_accesors .= "|$allowed_k_dcop_accesors_re" if $allow_k_dcop_accessors;
+
+ if( !defined $l ) {
+ return undef;
+ }
+ elsif ( $l =~ /^\s*($allowed_accesors)
+ (\s+\w+)?\s*:/x) { # access specifier
+ $declNodeType = "a";
+ return $l;
+ }
+ elsif ( $l =~ /K_DCOP/ ) {
+ $declNodeType = "k";
+ return $l;
+ }
+ elsif ( $l =~ m#^\s*/\*\*# ) { # doc comment
+ $declNodeType = "c";
+ return $l;
+ }
+
+ do {
+ $decl .= $l;
+
+ if ( $l =~ /[{};]/ ) {
+ $decl =~ s/\n/ /gs;
+ $declNodeType = "d";
+ return $decl;
+ }
+ return undef if !defined ($l = readCxxLine());
+
+ } while ( 1 );
+}
+
+#### AST Generator Routines
+
+=head2 getRoot
+
+ Return a root node for the given type of input file.
+
+=cut
+
+sub getRoot
+{
+ my $type = shift;
+ carp "getRoot called without type" unless defined $type;
+
+ if ( !exists $rootNodes{ $type } ) {
+ my $node = Ast::New( "Global" ); # parent of all nodes
+ $node->AddProp( "NodeType", "root" );
+ $node->AddProp( "RootType", $type );
+ $node->AddProp( "Compound", 1 );
+ $node->AddProp( "KidAccess", "public" );
+
+ $rootNodes{ $type } = $node;
+ }
+ print "getRoot: call for $type\n" if $debug;
+
+ return $rootNodes{ $type };
+}
+
+=head2 identifyDecl
+
+ Parameters: decl
+
+ Identifies a declaration returned by readDecl. If a code block
+ needs to be skipped, this subroutine returns a 1, or 0 otherwise.
+
+=cut
+
+sub identifyDecl
+{
+ my( $decl ) = @_;
+
+ my $newNode = undef;
+ my $skipBlock = 0;
+
+ # Doc comment
+ if ( $declNodeType eq "c" ) {
+ $docNode = kdocParseDoc::newDocComment( $decl );
+
+ # if it's the main doc, it is attached to the root node
+ if ( defined $docNode->{LibDoc} ) {
+ kdocParseDoc::attachDoc( $rootNode, $docNode,
+ $rootNode );
+ undef $docNode;
+ }
+
+ }
+ elsif ( $declNodeType eq "a" ) {
+ newAccess( $decl );
+ }
+ elsif ( $declNodeType eq "k" ) {
+ $cNode->AddProp( "DcopExported", 1 );
+ }
+
+ # Typedef struct/class
+ elsif ( $decl =~ /^\s*typedef
+ \s+(struct|union|class|enum)
+ \s*([_\w\:]*)
+ \s*([;{])
+ /xs ) {
+ my ($type, $name, $endtag, $rest ) = ($1, $2, $3, $' );
+ $name = "--" if $name eq "";
+
+ warn "typedef '$type' n:'$name'\n" if $debug;
+
+ if ( $rest =~ /}\s*([\w_]+(?:::[\w_])*)\s*;/ ) {
+ # TODO: Doesn't parse members yet!
+ $endtag = ";";
+ $name = $1;
+ }
+
+ $newNode = newTypedefComp( $type, $name, $endtag );
+ }
+
+ # Typedef
+ elsif ( $decl =~ /^\s*typedef\s+
+ (?:typename\s+)? # `typename' keyword
+ (.*?\s*[\*&]?) # type
+ \s+([-\w_\:]+) # name
+ \s*((?:\[[-\w_\:<>\s]*\])*) # array
+ \s*[{;]\s*$/xs ) {
+
+ print "Typedef: <$1 $3> <$2>\n" if $debug;
+ $newNode = newTypedef( $1." ".$3, $2 );
+ }
+
+ # Enum
+ elsif ( $decl =~ /^\s*enum\s+([-\w_:]*)?\s*\{(.*)/s ) {
+
+ print "Enum: <$1>\n" if $debug;
+ my $enumname = defined $2 ? $1 : "";
+
+ $newNode = newEnum( $enumname );
+ }
+
+ # Class/Struct
+ elsif ( $decl =~ /^\s*((?:template\s*<.*>)?) # 1 template
+ \s*(class|struct|union|namespace) # 2 struct type
+ (?:\s*Q[A-Z_]*EXPORT[A-Z_]*)?
+ (?:\s*Q_PACKED)?
+ (?:\s*Q_REFCOUNT)?
+ \s+([\w_]+ # 3 name
+ (?:<[\w_ :,]+?>)? # maybe explicit template
+ # (eat chars between <> non-hungry)
+ (?:::[\w_]+)* # maybe nested
+ )
+ (.*?) # 4 inheritance
+ ([;{])/xs ) { # 5 rest
+
+ print "Class: [$1]\n\t[$2]\n\t[$3]\n\t[$4]\n\t[$5]\n" if $debug;
+ my ( $tmpl, $ntype, $name, $rest, $endtag ) =
+ ( $1, $2, $3, $4, $5 );
+
+ if ($includeclasses)
+ {
+ if (! ($includeclasses =~ /$name/) )
+ {
+ return 1;
+
+ }
+ }
+
+ my @inherits = ();
+
+ $tmpl =~ s/<(.*)>/$1/ if $tmpl ne "";
+
+ if( $rest =~ /^\s*:\s*/ ) {
+ # inheritance
+ $rest = $';
+ @inherits = parseInheritance( $rest );
+ }
+
+ $newNode = newClass( $tmpl, $ntype,
+ $name, $endtag, @inherits );
+ }
+ # IDL compound node
+ elsif( $decl =~ /^\s*(module|interface|exception) # struct type
+ \s+([-\w_]+) # name
+ (.*?) # inheritance?
+ ([;{])/xs ) {
+
+ my ( $type, $name, $rest, $fwd, $complete )
+ = ( $1, $2, $3, $4 eq ";" ? 1 : 0,
+ 0 );
+ my @in = ();
+ print "IDL: [$type] [$name] [$rest] [$fwd]\n" if $debug;
+
+ if( $rest =~ /^\s*:\s*/ ) {
+ $rest = $';
+ $rest =~ s/\s+//g;
+ @in = split ",", $rest;
+ }
+ if( $decl =~ /}\s*;/ ) {
+ $complete = 1;
+ }
+
+ $newNode = newIDLstruct( $type, $name, $fwd, $complete, @in );
+ }
+ # Method
+ elsif ( $decl =~ /^\s*([^=]+?(?:operator\s*(?:\(\)|.?=)\s*)?) # ret+nm
+ \( (.*?) \) # parameters
+ \s*((?:const)?)\s*
+ \s*((?:=\s*0(?:L?))?)\s* # Pureness. is "0L" allowed?
+ \s*[;{]+/xs ) { # rest
+
+ my $tpn = $1; # type + name
+ my $params = $2;
+ # Remove constructor initializer, that's not in the params
+ if ( $params =~ /\s*\)\s*:\s*/ ) {
+ # Hack: first .* made non-greedy for QSizePolicy using a?(b):c in ctor init
+ $params =~ s/(.*?)\s*\)\s*:\s*.*$/$1/;
+ }
+
+ my $const = $3 eq "" ? 0 : 1;
+ my $pure = $4 eq "" ? 0 : 1;
+ $tpn =~ s/\s+/ /g;
+ $params =~ s/\s+/ /g;
+
+ print "Method: R+N:[$tpn]\n\tP:[$params]\n\t[$const]\n" if $debug;
+
+ if ( $tpn =~ /((?:\w+\s*::\s*)?operator.*?)\s*$/ # operator
+ || $tpn =~ /((?:\w*\s*::\s*~?)?[-\w:]+)\s*$/ ) { # normal
+ my $name = $1;
+ $tpn = $`;
+ $newNode = newMethod( $tpn, $name,
+ $params, $const, $pure );
+ }
+
+ $skipBlock = 1; # FIXME check end token before doing this!
+ }
+ # Using: import namespace
+ elsif ( $decl =~ /^\s*using\s+namespace\s+(\w+)/ ) {
+ newNamespace( $1 );
+
+ }
+
+ # extern block
+ elsif ( $decl =~ /^\s*extern\s*"(.*)"\s*{/ ) {
+ $inExtern = 1 unless $decl =~ /}/;
+ }
+
+ # Single variable
+ elsif ( $decl =~ /^
+ \s*( (?:[\w_:]+(?:\s+[\w_:]+)*? )# type
+ \s*(?:<.+>)? # template
+ \s*(?:[\&\*])? # ptr or ref
+ (?:\s*(?:const|volatile))* )
+ \s*([\w_:]+) # name
+ \s*( (?:\[[^\[\]]*\] (?:\s*\[[^\[\]]*\])*)? ) # array
+ \s*((?:=.*)?) # value
+ \s*([;{])\s*$/xs ) {
+ my $type = $1;
+ my $name = $2;
+ my $arr = $3;
+ my $val = $4;
+ my $end = $5;
+
+ if ( $type !~ /^friend\s+class\s*/ ) {
+ print "Var: [$name] type: [$type$arr] val: [$val]\n"
+ if $debug;
+
+ $newNode = newVar( $type.$arr, $name, $val );
+ }
+
+ $skipBlock = 1 if $end eq '{';
+ }
+
+ # Multi variables
+ elsif ( $decl =~ m/^
+ \s*( (?:[\w_:]+(?:\s+[\w_:]+)*? ) # type
+ \s*(?:<.+>)?) # template
+
+ \s*( (?:\s*(?: [\&\*][\&\*\s]*)? # ptr or ref
+ [\w_:]+) # name
+ \s*(?:\[[^\[\]]*\] (?:\s*\[[^\[\]]*\])*)? # array
+ \s*(?:, # extra vars
+ \s*(?: [\&\*][\&\*\s]*)? # ptr or ref
+ \s*(?:[\w_:]+) # name
+ \s*(?:\[[^\[\]]*\] (?:\s*\[[^\[\]]*\])*)? # array
+ )*
+ \s*(?:=.*)?) # value
+ \s*[;]/xs ) {
+
+ my $type = $1;
+ my $names = $2;
+ my $end = $3;
+ my $doc = $docNode;
+
+ print "Multivar: type: [$type] names: [$names] \n" if $debug;
+
+ foreach my $vardecl ( split( /\s*,\s*/, $names ) ) {
+ next unless $vardecl =~ m/
+ \s*((?: [\&\*][\&\*\s]*)?) # ptr or ref
+ \s*([\w_:]+) # name
+ \s*( (?:\[[^\[\]]*\] (?:\s*\[[^\[\]]*\])*)? ) # array
+ \s*((?:=.*)?) # value
+ /xs;
+ my ($ptr, $name, $arr, $val) = ($1, $2, $3, $4);
+
+ print "Split: type: [$type$ptr$arr] ",
+ " name: [$name] val: [$val] \n" if $debug;
+
+ my $node = newVar( $type.$ptr.$arr, $name, $val );
+
+ $docNode = $doc; # reuse docNode for each
+ postInitNode( $node ) unless !defined $node;
+ }
+
+ $skipBlock = 1 if $end eq '{';
+ }
+ # end of an "extern" block
+ elsif ( $decl =~ /^\s*}\s*$/ ) {
+ $inExtern = 0;
+ }
+ # end of an in-block declaration
+ elsif ( $decl =~ /^\s*}\s*(.*?)\s*;\s*$/ ) {
+
+ if ( $cNode->{astNodeName} eq "--" ) {
+ # structure typedefs should have no name preassigned.
+ # If they do, then the name in
+ # "typedef struct <name> { ..." is kept instead.
+ # TODO: Buglet. You should fix YOUR code dammit. ;)
+
+
+ $cNode->{astNodeName} = $1;
+ my $siblings = $cNode->{Parent}->{KidHash};
+ undef $siblings->{"--"};
+ $siblings->{ $1 } = $cNode;
+ }
+
+ if ( $#classStack < 0 ) {
+ confess "close decl found, but no class in stack!" ;
+ $cNode = $rootNode;
+ }
+ else {
+ $cNode = pop @classStack;
+ print "end decl: popped $cNode->{astNodeName}\n"
+ if $debug;
+ }
+ }
+ # unidentified block start
+ elsif ( $decl =~ /{/ ) {
+ print "Unidentified block start: $decl\n" if $debug;
+ $skipBlock = 1;
+ }
+ # explicit template instantiation, or friend template
+ elsif ( $decl =~ /(template|friend)\s+class\s+(?:Q[A-Z_]*EXPORT[A-Z_]*\s*)?\w+\s*<.*>\s*;/x ) {
+ # Nothing to be done with those.
+ }
+ else {
+
+ ## decl is unidentified.
+ warn "Unidentified decl: $decl\n";
+ }
+
+ # once we get here, the last doc node is already used.
+ # postInitNode should NOT be called for forward decls
+ postInitNode( $newNode ) unless !defined $newNode;
+
+ return $skipBlock;
+}
+
+sub postInitNode
+{
+ my $newNode = shift;
+
+ carp "Cannot postinit undef node." if !defined $newNode;
+
+ # The reasoning here:
+ # Forward decls never get a source node.
+ # Once a source node is defined, don't assign another one.
+
+ if ( $newNode->{NodeType} ne "Forward" && !defined $newNode->{Source}) {
+ $newNode->AddProp( "Source", $cSourceNode );
+ } elsif ( $newNode->{NodeType} eq "Forward" ) {
+ if ($debug) {
+ print "postInit: skipping fwd: $newNode->{astNodeName}\n";
+ }
+ undef $docNode;
+ return;
+ }
+
+ if( defined $docNode ) {
+ kdocParseDoc::attachDoc( $newNode, $docNode, $rootNode );
+ undef $docNode;
+ }
+}
+
+
+##### Node generators
+
+=head2 newEnum
+
+ Reads the parameters of an enumeration.
+
+ Returns the parameters, or undef on error.
+
+=cut
+
+sub newEnum
+{
+ my ( $enum ) = @_;
+ my $k = undef;
+ my $params = "";
+
+ $k = $lastLine if defined $lastLine;
+
+ if( defined $lastLine && $lastLine =~ /{/ ) {
+ $params = $';
+ if ( $lastLine =~ /}(.*?);/ ) {
+ return initEnum( $enum, $1, $params );
+ }
+ }
+
+ while ( defined ( $k = readCxxLine() ) ) {
+ $params .= $k;
+
+ if ( $k =~ /}(.*?);/ ) {
+ return initEnum( $enum, $1, $params );
+ }
+ }
+
+ return undef;
+}
+
+=head2 initEnum
+
+ Parameters: name, (ref) params
+
+ Returns an initialized enum node.
+
+=cut
+
+sub initEnum
+{
+ my( $name, $end, $params ) = @_;
+
+ ($name = $end) if $name eq "" && $end ne "";
+
+ $params =~ s#\s+# #sg; # no newlines
+ $params = $1 if $params =~ /^\s*{?(.*)}/;
+ print "$name params: [$params]\n" if $debug;
+
+
+ my ( $node ) = Ast::New( $name );
+ $node->AddProp( "NodeType", "enum" );
+ $node->AddProp( "Params", $params );
+ makeParamList( $node, $params, 1 ); # Adds the ParamList property containing the list of param nodes
+ kdocAstUtil::attachChild( $cNode, $node );
+
+ return $node;
+}
+
+=head2 newIDLstruct
+
+ Parameters: type, name, forward, complete, inherits...
+
+ Handles an IDL structure definition (ie module, interface,
+ exception).
+
+=cut
+
+sub newIDLstruct
+{
+ my ( $type, $name, $fwd, $complete ) = @_;
+
+ my $node = exists $cNode->{KidHash} ?
+ $cNode->{KidHash}->{ $name } : undef;
+
+ if( !defined $node ) {
+ $node = Ast::New( $name );
+ $node->AddProp( "NodeType", $fwd ? "Forward" : $type );
+ $node->AddProp( "KidAccess", "public" );
+ $node->AddProp( "Compound", 1 ) unless $fwd;
+ kdocAstUtil::attachChild( $cNode, $node );
+ }
+ elsif ( $fwd ) {
+ # If we have a node already, we ignore forwards.
+ return undef;
+ }
+ elsif ( $node->{NodeType} eq "Forward" ) {
+ # we are defining a previously forward node.
+ $node->AddProp( "NodeType", $type );
+ $node->AddProp( "Compound", 1 );
+ $node->AddProp( "Source", $cSourceNode );
+ }
+
+ # register ancestors.
+ foreach my $ances ( splice ( @_, 4 ) ) {
+ my $n = kdocAstUtil::newInherit( $node, $ances );
+ }
+
+ if( !( $fwd || $complete) ) {
+ print "newIDL: pushing $cNode->{astNodeName},",
+ " new is $node->{astNodeName}\n"
+ if $debug;
+ push @classStack, $cNode;
+ $cNode = $node;
+ }
+
+ return $node;
+}
+
+=head2 newClass
+
+ Parameters: tmplArgs, cNodeType, name, endTag, @inheritlist
+
+ Handles a class declaration (also fwd decls).
+
+=cut
+
+sub newClass
+{
+ my( $tmplArgs, $cNodeType, $name, $endTag ) = @_;
+
+ my $access = "private";
+ $access = "public" if $cNodeType ne "class";
+
+ # try to find an exisiting node, or create a new one
+ my $oldnode = kdocAstUtil::findRef( $cNode, $name );
+ my $node = defined $oldnode ? $oldnode : Ast::New( $name );
+
+ if ( $endTag ne "{" ) {
+ # forward
+ if ( !defined $oldnode ) {
+ # new forward node
+ $node->AddProp( "NodeType", "Forward" );
+ $node->AddProp( "KidAccess", $access );
+ kdocAstUtil::attachChild( $cNode, $node );
+ }
+ return $node;
+ }
+
+ # this is a class declaration
+
+ print "ClassName: $name\n" if $debug;
+
+ $node->AddProp( "NodeType", $cNodeType );
+ $node->AddProp( "Compound", 1 );
+ $node->AddProp( "Source", $cSourceNode );
+
+ $node->AddProp( "KidAccess", $access );
+ $node->AddProp( "Tmpl", $tmplArgs ) unless $tmplArgs eq "";
+
+ if ( !defined $oldnode ) {
+ kdocAstUtil::attachChild( $cNode, $node );
+ }
+
+ # inheritance
+
+ foreach my $ances ( splice (@_, 4) ) {
+ my $type = "";
+ my $name = $ances;
+ my $intmpl = undef;
+
+WORD:
+ foreach my $word ( split ( /([\w:]+(:?\s*<.*>)?)/, $ances ) ) {
+ next WORD unless $word =~ /^[\w:]/;
+ if ( $word =~ /(private|public|protected|virtual)/ ) {
+ $type .= "$1 ";
+ }
+ else {
+
+ if ( $word =~ /<(.*)>/ ) {
+ # FIXME: Handle multiple tmpl args
+ $name = $`;
+ $intmpl = $1;
+ }
+ else {
+ $name = $word;
+ }
+
+ last WORD;
+ }
+ }
+
+ # set inheritance access specifier if none specified
+ if ( $type eq "" ) {
+ $type = $cNodeType eq "class" ? "private ":"public ";
+ }
+ chop $type;
+
+ # attach inheritance information
+ my $n = kdocAstUtil::newInherit( $node, $name );
+ $n->AddProp( "Type", $type );
+
+ $n->AddProp( "TmplType", $intmpl ) if defined $intmpl;
+
+ print "In: $name type: $type, tmpl: $intmpl\n" if $debug;
+ }
+
+ # new current node
+ print "newClass: Pushing $cNode->{astNodeName}\n" if $debug;
+ push ( @classStack, $cNode );
+ $cNode = $node;
+
+ return $node;
+}
+
+
+=head3 parseInheritance
+
+ Param: inheritance decl string
+ Returns: list of superclasses (template decls included)
+
+ This will fail if < and > appear in strings in the decl.
+
+=cut
+
+sub parseInheritance
+{
+ my $instring = shift;
+ my @inherits = ();
+
+ my $accum = "";
+ foreach $instring ( split (/\s*,\s*/, $instring) ) {
+ $accum .= $instring.", ";
+ next unless (kdocUtil::countReg( $accum, "<" )
+ - kdocUtil::countReg( $accum, ">" ) ) == 0;
+
+ # matching no. of < and >, so assume the parent is
+ # complete
+ $accum =~ s/,\s*$//;
+ print "Inherits: '$accum'\n" if $debug;
+ push @inherits, $accum;
+ $accum = "";
+ }
+
+ return @inherits;
+}
+
+
+=head2 newNamespace
+
+ Param: namespace name.
+ Returns nothing.
+
+ Imports a namespace into the current node, for ref searches etc.
+ Triggered by "using namespace ..."
+
+=cut
+
+sub newNamespace
+{
+ $cNode->AddPropList( "ImpNames", shift );
+}
+
+
+
+=head2 newTypedef
+
+ Parameters: realtype, name
+
+ Handles a type definition.
+
+=cut
+
+sub newTypedef
+{
+ my ( $realtype, $name ) = @_;
+
+ my ( $node ) = Ast::New( $name );
+
+ $node->AddProp( "NodeType", "typedef" );
+ $node->AddProp( "Type", $realtype );
+
+ kdocAstUtil::attachChild( $cNode, $node );
+
+ return $node;
+}
+
+=head2 newTypedefComp
+
+ Params: realtype, name endtoken
+
+ Creates a new compound type definition.
+
+=cut
+
+sub newTypedefComp
+{
+ my ( $realtype, $name, $endtag ) = @_;
+
+ my ( $node ) = Ast::New( $name );
+
+ $node->AddProp( "NodeType", "typedef" );
+ $node->AddProp( "Type", $realtype );
+
+ kdocAstUtil::attachChild( $cNode, $node );
+
+ if ( $endtag eq '{' ) {
+ print "newTypedefComp: Pushing $cNode->{astNodeName}\n"
+ if $debug;
+ push ( @classStack, $cNode );
+ $cNode = $node;
+ }
+
+ return $node;
+}
+
+
+=head2 newMethod
+
+ Parameters: retType, name, params, const, pure?
+
+ Handles a new method declaration or definition.
+
+=cut
+BEGIN {
+
+my $theSourceNode = $cSourceNode;
+
+sub newMethod
+{
+ my ( $retType, $name, $params, $const, $pure ) = @_;
+ my $parent = $cNode;
+ my $class;
+
+ print "Cracked: [$retType] [$name]\n\t[$params]\n\t[$const]\n"
+ if $debug;
+
+ if ( $retType =~ /([\w\s_<>,]+)\s*::\s*$/ ) {
+ # check if stuff before :: got into rettype by mistake.
+ $retType = $`;
+ ($name = $1."::".$name);
+ $name =~ s/\s+/ /g;
+ print "New name = \"$name\" and type = '$retType'\n" if $debug;
+ }
+
+ # A 'friend method' declaration isn't a real method declaration
+ return undef if ( $retType =~ /^friend\s+/ || $retType =~ /^friend\s+class\s+/ );
+
+ my $isGlobalSpace = 0;
+ my $nameWasChanged = 0;
+ my $origName;
+
+ if( $name =~ /^\s*(.*?)\s*::\s*(.*?)\s*$/ ) {
+ # Fully qualified method name.
+ $name = $2;
+ $class = $1;
+
+ if( $class =~ /^\s*$/ ) {
+ $parent = $rootNode;
+ }
+ elsif ( $class eq $cNode->{astNodeName} ) {
+ $parent = $cNode;
+ }
+ else {
+ # ALWAYS IGNORE...
+ return undef;
+
+ my $node = kdocAstUtil::findRef( $cNode, $class );
+
+ if ( !defined $node ) {
+ # if we couldn't find the name, try again with
+ # all template parameters stripped off:
+ my $strippedClass = $class;
+ $strippedClass =~ s/<[^<>]*>//g;
+
+ $node = kdocAstUtil::findRef( $cNode, $strippedClass );
+
+ # if still not found: give up
+ if ( !defined $node ) {
+ warn "$exe: Unidentified class: $class ".
+ "in $currentfile\:$.\n";
+ return undef;
+ }
+ }
+
+ $parent = $node;
+ }
+ }
+ # TODO fix for $retType =~ /template<.*?>/
+ elsif( $parse_global_space && $parent->{NodeType} eq "root" && $name !~ /\s*qt_/ && $retType !~ /template\s*<.*?>/ ) {
+ $origName = $name;
+ # $name =~ s/^q([A-Z])([a-z]+)/$nameWasChanged++, lc($1).$2/e; # too much troubles (eg. qGLVersion, qRed vs. Qt::red )
+ $name =~ s/^\s*operator(.*)$/$nameWasChanged++, "$1"/e;
+ $class = $globalSpaceClassName; # FIXME - sanitize the naming system?
+ $isGlobalSpace = 1;
+
+ my $opsNode = kdocAstUtil::findRef( $cNode, $class );
+ if (!$opsNode) {
+ # manually create a "GlobalSpace" class
+ $opsNode = Ast::New( $class );
+ $opsNode->AddProp( "NodeType", "class" );
+ $opsNode->AddProp( "Compound", 1 );
+ $opsNode->AddProp( "Source", $cSourceNode ); # dummy
+ $opsNode->AddProp( "KidAccess", "public" );
+ kdocAstUtil::attachChild( $cNode, $opsNode );
+ }
+ unless( $theSourceNode == $cSourceNode ) {
+ $theSourceNode = $cSourceNode;
+ $opsNode->AddPropList( "Sources", $theSourceNode ); # sources are scattered across Qt
+ }
+ $parent = $opsNode;
+ }
+
+ # flags
+
+ my $flags = "";
+
+ if( $retType =~ /static/ || $isGlobalSpace ) {
+ $flags .= "s";
+ $retType =~ s/static//g;
+ }
+
+ if( $const && !$isGlobalSpace ) {
+ $flags .= "c";
+ }
+
+ if( $pure ) {
+ $flags .= "p";
+ }
+
+ if( $retType =~ /virtual/ ) {
+ $flags .= "v";
+ $retType =~ s/virtual//g;
+ }
+
+ print "\n" if $flags ne "" && $debug;
+
+ if ( !defined $parent->{KidAccess} ) {
+ warn "'", $parent->{astNodeName}, "' has no KidAccess ",
+ exists $parent->{Forward} ? "(forward)\n" :"\n";
+ }
+
+ # NB, these are =~, so make sure they are listed in correct order
+ if ( $parent->{KidAccess} =~ /slot/ ) {
+ $flags .= "l";
+ }
+ elsif ( $parent->{KidAccess} =~ /k_dcop_signals/ ) {
+ $flags .= "z";
+ }
+ elsif ( $parent->{KidAccess} =~ /k_dcop_hidden/ ) {
+ $flags .= "y";
+ }
+ elsif ( $parent->{KidAccess} =~ /k_dcop/ ) {
+ $flags .= "d";
+ }
+ elsif ( $parent->{KidAccess} =~ /signal/ ) {
+ $flags .= "n";
+ }
+
+ $retType =~ s/QM?_EXPORT[_A-Z]*\s*//;
+ $retType =~ s/inline\s+//;
+ $retType =~ s/extern\s+//;
+ $retType =~ s/^\s*//g;
+ $retType =~ s/\s*$//g;
+
+ # node
+
+ my $node = Ast::New( $name );
+ $node->AddProp( "NodeType", "method" );
+ $node->AddProp( "Flags", $flags );
+ $node->AddProp( "ReturnType", $retType );
+ $node->AddProp( "Params", $params ); # The raw string with the whole param list
+ makeParamList( $node, $params, 0 ); # Adds the ParamList property containing the list of param nodes
+
+ $parent->AddProp( "Pure", 1 ) if $pure;
+
+ if ($nameWasChanged) {
+ $node->AddProp( "OriginalName", $origName );
+ }
+
+ kdocAstUtil::attachChild( $parent, $node );
+ return $node;
+}
+
+}
+
+=head2 makeParamList
+
+ Parameters:
+ * method (or enum) node
+ * string containing the whole param list
+ * 1 for enums
+
+ Adds a property "ParamList" to the method node.
+ This property contains a list of nodes, one for each parameter.
+
+ Each parameter node has the following properties:
+ * ArgType the type of the argument, e.g. const QString&
+ * ArgName the name of the argument - optionnal
+ * DefaultValue the default value of the argument - optionnal
+
+ For enum values, ArgType is unset, ArgName is the name, DefaultValue its value.
+
+ Author: David Faure <david@mandrakesoft.com>
+=cut
+
+sub makeParamList($$$)
+{
+ my ( $methodNode, $params, $isEnum ) = @_;
+ $params =~ s/\s+/ /g; # normalize multiple spaces/tabs into a single one
+ $params =~ s/\s*([,\*\&])\s*/$1 /g; # normalize spaces before and after *, & and ','
+ $params =~ s/^\s*void\s*$//; # foo(void) ==> foo()
+ $params =~ s/^\s*$//;
+ # Make sure the property always exists, makes iteration over it easier
+ $methodNode->AddProp( "ParamList", [] );
+
+ my @args = kdocUtil::splitUnnested( ',', $params);
+
+ my $argId = 0;
+ foreach my $arg ( @args ) {
+ my $argType;
+ my $argName;
+ my $defaultparam;
+ $arg =~ s/\s*([^\s].*[^\s])\s*/$1/; # stripWhiteSpace
+ $arg =~ s/(\w+)\[\]/\* $1/; # Turn [] array into *
+
+ # The RE below reads as: = ( string constant or char
+ # or some word/number, with optional bitwise shifts, OR'ed or +'ed flags, and/or function call ).
+ if ( $arg =~ s/\s*=\s*(("[^\"]*")|(\'.\')|(([-\w:~]*)\s*([<>\|\+-]*\s*\w*\s*)*(\([^(]*\))?))// ) {
+ $defaultparam = $1;
+ }
+
+ # Separate arg type from arg name, if the latter is specified
+ if ( $arg =~ /(.*)\s+([\w_]+)\s*$/ || $arg =~ /(.*)\(\s*\*\s([\w_]+)\)\s*\((.*)\)\s*$/ ) {
+ if ( defined $3 ) { # function pointer
+ $argType = $1."(*)($3)";
+ $argName = $2;
+ } else {
+ $argType = $1;
+ $argName = $2;
+ }
+ } else { # unnamed arg - or enum value
+ $argType = $arg if (!$isEnum);
+ $argName = $arg if ($isEnum);
+ }
+ $argId++;
+
+ my $node = Ast::New( $argId ); # let's make the arg index the node "name"
+ $node->AddProp( "NodeType", "param" );
+ $node->AddProp( "ArgType", $argType );
+ $node->AddProp( "ArgName", $argName ) if (defined $argName);
+ $node->AddProp( "DefaultValue", $defaultparam ) if (defined $defaultparam);
+ $methodNode->AddPropList( "ParamList", $node );
+ print STDERR "ArgType: $argType ArgName: $argName\n" if ($debug);
+ }
+}
+
+=head2 newAccess
+
+ Parameters: access
+
+ Sets the default "Access" specifier for the current class node. If
+ the access is a "slot" type, "_slots" is appended to the access
+ string.
+
+=cut
+
+sub newAccess
+{
+ my ( $access ) = @_;
+
+ return undef unless ($access =~ /^\s*(\w+)\s*(slots|$allowed_k_dcop_accesors_re)?/);
+
+ print "Access: [$1] [$2]\n" if $debug;
+
+ $access = $1;
+
+ if ( defined $2 && $2 ne "" ) {
+ $access .= "_" . $2;
+ }
+
+ $cNode->AddProp( "KidAccess", $access );
+
+ return $cNode;
+}
+
+
+=head2 newVar
+
+ Parameters: type, name, value
+
+ New variable. Value is ignored if undef
+
+=cut
+
+sub newVar
+{
+ my ( $type, $name, $val ) = @_;
+
+ my $node = Ast::New( $name );
+ $node->AddProp( "NodeType", "var" );
+
+ my $static = 0;
+ if ( $type =~ /static/ ) {
+ # $type =~ s/static//;
+ $static = 1;
+ }
+
+ $node->AddProp( "Type", $type );
+ $node->AddProp( "Flags", 's' ) if $static;
+ $node->AddProp( "Value", $val ) if defined $val;
+ kdocAstUtil::attachChild( $cNode, $node );
+
+ return $node;
+}
+
+
+
+=head2 show_usage
+
+ Display usage information and quit.
+
+=cut
+
+sub show_usage
+{
+print<<EOF;
+usage:
+ $exe [options] [-f format] [-d outdir] [-n name] files... [-llib..]
+
+See the man page kdoc[1] for more info.
+EOF
+ exit 1;
+}
+
+
+=head2 show_version
+
+ Display short version information and quit.
+
+=cut
+
+sub show_version
+{
+ die "$exe: $Version (c) Sirtaj S. Kang <taj\@kde.org>\n";
+}
+
+
diff --git a/dcopidlng/kalyptusCxxToDcopIDL.pm b/dcopidlng/kalyptusCxxToDcopIDL.pm
new file mode 100644
index 00000000..a6fd58ad
--- /dev/null
+++ b/dcopidlng/kalyptusCxxToDcopIDL.pm
@@ -0,0 +1,1047 @@
+#***************************************************************************
+# kalyptusCxxToDcopIDL.pm - Generates idl from dcop headers
+# -------------------
+# begin : Fri Jan 25 12:00:00 2000
+# copyright : (C) 2003 Alexander Kellett
+# email : lypanov@kde.org
+# author : Alexander Kellett
+#***************************************************************************/
+
+#/***************************************************************************
+# * *
+# * This program is free software; you can redistribute it and/or modify *
+# * it under the terms of the GNU General Public License as published by *
+# * the Free Software Foundation; either version 2 of the License, or *
+# * (at your option) any later version. *
+# * *
+#***************************************************************************/
+
+package kalyptusCxxToDcopIDL;
+
+use File::Path;
+use File::Basename;
+use Carp;
+use Ast;
+use kdocAstUtil;
+use kdocUtil;
+use Iter;
+use kalyptusDataDict;
+use Data::Dumper;
+
+use strict;
+no strict "subs";
+
+use vars qw/
+ $libname $rootnode $outputdir $opt $debug
+ $methodNumber
+ %builtins %typeunion %allMethods %allTypes %enumValueToType %typedeflist %mungedTypeMap
+ %skippedClasses /;
+
+BEGIN
+{
+
+# Types supported by the StackItem union
+# Key: C++ type Value: Union field of that type
+%typeunion = (
+ 'void*' => 's_voidp',
+ 'bool' => 's_bool',
+ 'char' => 's_char',
+ 'uchar' => 's_uchar',
+ 'short' => 's_short',
+ 'ushort' => 's_ushort',
+ 'int' => 's_int',
+ 'uint' => 's_uint',
+ 'long' => 's_long',
+ 'ulong' => 's_ulong',
+ 'float' => 's_float',
+ 'double' => 's_double',
+ 'enum' => 's_enum',
+ 'class' => 's_class'
+);
+
+# Mapping for iterproto, when making up the munged method names
+%mungedTypeMap = (
+ 'QString' => '$',
+ 'QString*' => '$',
+ 'QString&' => '$',
+ 'QCString' => '$',
+ 'QCString*' => '$',
+ 'QCString&' => '$',
+ 'QByteArray' => '$',
+ 'QByteArray&' => '$',
+ 'QByteArray*' => '$',
+ 'char*' => '$',
+ 'QCOORD*' => '?',
+ 'QRgb*' => '?',
+);
+
+# Yes some of this is in kalyptusDataDict's ctypemap
+# but that one would need to be separated (builtins vs normal classes)
+%typedeflist =
+(
+ 'signed char' => 'char',
+ 'unsigned char' => 'uchar',
+ 'signed short' => 'short',
+ 'unsigned short' => 'ushort',
+ 'signed' => 'int',
+ 'signed int' => 'int',
+ 'unsigned' => 'uint',
+ 'unsigned int' => 'uint',
+ 'signed long' => 'long',
+ 'unsigned long' => 'ulong',
+
+# Anything that is not known is mapped to void*, so no need for those here anymore
+# 'QWSEvent*' => 'void*',
+# 'QDiskFont*' => 'void*',
+# 'XEvent*' => 'void*',
+# 'QStyleHintReturn*' => 'void*',
+# 'FILE*' => 'void*',
+# 'QUnknownInterface*' => 'void*',
+# 'GDHandle' => 'void*',
+# '_NPStream*' => 'void*',
+# 'QTextFormat*' => 'void*',
+# 'QTextDocument*' => 'void*',
+# 'QTextCursor*' => 'void*',
+# 'QTextParag**' => 'void*',
+# 'QTextParag*' => 'void*',
+# 'QRemoteInterface*' => 'void*',
+# 'QSqlRecordPrivate*' => 'void*',
+# 'QTSMFI' => 'void*', # QTextStream's QTSManip
+# 'const GUID&' => 'void*',
+# 'QWidgetMapper*' => 'void*',
+# 'MSG*' => 'void*',
+# 'const QSqlFieldInfoList&' => 'void*', # QSqlRecordInfo - TODO (templates)
+
+ 'QPtrCollection::Item' => 'void*', # to avoid a warning
+
+ 'mode_t' => 'long',
+ 'QProcess::PID' => 'long',
+ 'size_type' => 'int', # QSqlRecordInfo
+ 'Qt::ComparisonFlags' => 'uint',
+ 'Qt::ToolBarDock' => 'int', # compat thing, Qt shouldn't use it
+ 'QIODevice::Offset' => 'ulong',
+ 'WState' => 'int',
+ 'WId' => 'ulong',
+ 'QRgb' => 'uint',
+ 'QCOORD' => 'int',
+ 'QTSMFI' => 'int',
+ 'Qt::WState' => 'int',
+ 'Qt::WFlags' => 'int',
+ 'Qt::HANDLE' => 'uint',
+ 'QEventLoop::ProcessEventsFlags' => 'uint',
+ 'QStyle::SCFlags' => 'int',
+ 'QStyle::SFlags' => 'int',
+ 'Q_INT16' => 'short',
+ 'Q_INT32' => 'int',
+ 'Q_INT8' => 'char',
+ 'Q_LONG' => 'long',
+ 'Q_UINT16' => 'ushort',
+ 'Q_UINT32' => 'uint',
+ 'Q_UINT8' => 'uchar',
+ 'Q_ULONG' => 'long',
+);
+
+}
+
+sub writeDoc
+{
+ ( $libname, $rootnode, $outputdir, $opt ) = @_;
+
+ print STDERR "Starting writeDoc for $libname...\n";
+
+ $debug = $main::debuggen;
+
+ # Define QPtrCollection::Item, for resolveType
+ unless ( kdocAstUtil::findRef( $rootnode, "QPtrCollection::Item" ) ) {
+ my $cNode = kdocAstUtil::findRef( $rootnode, "QPtrCollection" );
+ warn "QPtrCollection not found" if (!$cNode);
+ my $node = Ast::New( 'Item' );
+ $node->AddProp( "NodeType", "Forward" );
+ $node->AddProp( "Source", $cNode->{Source} ) if ($cNode);
+ kdocAstUtil::attachChild( $cNode, $node ) if ($cNode);
+ $node->AddProp( "Access", "public" );
+ }
+
+ print STDERR "Preparsing...\n";
+
+ # Preparse everything, to prepare some additional data in the classes and methods
+ Iter::LocalCompounds( $rootnode, sub { preParseClass( shift ); } );
+
+ # Write out smokedata.cpp
+ writeSmokeDataFile($rootnode);
+
+ print STDERR "Writing dcopidl...\n";
+
+ print STDOUT "<!DOCTYPE DCOP-IDL><DCOP-IDL>\n";
+
+ print STDOUT "<SOURCE>".@{$rootnode->{Sources}}[0]->{astNodeName}."</SOURCE>\n";
+
+ print STDOUT map { "<INCLUDE>$_</INCLUDE>\n" } reverse @main::includes_list;
+
+ Iter::LocalCompounds( $rootnode, sub {
+ my ($node) = @_;
+
+ my ($methodCode, $switchCode, $incl) = generateAllMethods( $node );
+ my $className = join "::", kdocAstUtil::heritage($node);
+
+ if ($node->{DcopExported}) {
+ print STDOUT "<CLASS>\n";
+ print STDOUT " <NAME>$className</NAME>\n";
+ print STDOUT join("\n", map { " <SUPER>$_</SUPER>"; } grep { $_ ne "Global"; }
+ map {
+ my $name = $_->{astNodeName};
+ $name =~ s/</&lt;/;
+ $name =~ s/>/&gt;/;
+ my $tmpl = $_->{TmplType};
+ $tmpl =~ s/</&lt;/;
+ $tmpl =~ s/>/&gt;/;
+ $tmpl ? "$name&lt;<TYPE>$tmpl</TYPE>&gt;" : $name;
+ } @{$node->{InList}}) . "\n";
+ print STDOUT $methodCode;
+
+ print STDOUT "</CLASS>\n";
+ }
+ });
+
+ print STDOUT "</DCOP-IDL>\n";
+
+ print STDERR "Done.\n";
+}
+
+=head2 preParseClass
+ Called for each class
+=cut
+sub preParseClass
+{
+ my( $classNode ) = @_;
+ my $className = join( "::", kdocAstUtil::heritage($classNode) );
+
+ if( $#{$classNode->{Kids}} < 0 ||
+ $classNode->{Access} eq "private" ||
+ $classNode->{Access} eq "protected" || # e.g. QPixmap::QPixmapData
+ exists $classNode->{Tmpl} ||
+ # Don't generate standard bindings for QString, this class is handled as a native type
+ $className eq 'QString' ||
+ $className eq 'QConstString' ||
+ $className eq 'QCString' ||
+ # Don't map classes which are really arrays
+ $className eq 'QStringList' ||
+ $className eq 'QCanvasItemList' ||
+ $className eq 'QWidgetList' ||
+ $className eq 'QObjectList' ||
+ $className eq 'QStrList' ||
+ # Those are template related
+ $className eq 'QTSManip' || # cause compiler errors with several gcc versions
+ $className eq 'QGDict' ||
+ $className eq 'QGList' ||
+ $className eq 'QGVector' ||
+ $className eq 'QStrIList' ||
+ $className eq 'QStrIVec' ||
+ $className eq 'QByteArray' ||
+ $className eq 'QBitArray' ||
+ $classNode->{NodeType} eq 'union' # Skip unions for now, e.g. QPDevCmdParam
+ ) {
+ print STDERR "Skipping $className\n" if ($debug);
+ print STDERR "Skipping union $className\n" if ( $classNode->{NodeType} eq 'union');
+ $skippedClasses{$className} = 1;
+ delete $classNode->{Compound}; # Cheat, to get it excluded from Iter::LocalCompounds
+ return;
+ }
+
+ my $signalCount = 0;
+ my $eventHandlerCount = 0;
+ my $defaultConstructor = 'none'; # none, public, protected or private. 'none' will become 'public'.
+ my $constructorCount = 0; # total count of _all_ ctors
+ # If there are ctors, we need at least one public/protected one to instanciate the class
+ my $hasPublicProtectedConstructor = 0;
+ # We need a public dtor to destroy the object --- ### aren't protected dtors ok too ??
+ my $hasPublicDestructor = 1; # by default all classes have a public dtor!
+ my $hasDestructor = 0;
+ my $hasPrivatePureVirtual = 0;
+ my $hasCopyConstructor = 0;
+ my $hasPrivateCopyConstructor = 0;
+ # Note: no need for hasPureVirtuals. $classNode{Pure} has that.
+
+ my $doPrivate = $main::doPrivate;
+ $main::doPrivate = 1;
+ # Look at each class member (looking for methods and enums in particular)
+ Iter::MembersByType ( $classNode, undef,
+ sub {
+
+ my( $classNode, $m ) = @_;
+ my $name = $m->{astNodeName};
+
+ if( $m->{NodeType} eq "method" ) {
+ if ( $m->{ReturnType} eq 'typedef' # QFile's EncoderFn/DecoderFn callback, very badly parsed
+ ) {
+ $m->{NodeType} = 'deleted';
+ next;
+ }
+
+ print STDERR "preParseClass: looking at $className\::$name $m->{Params}\n" if ($debug);
+
+ if ( $name eq $classNode->{astNodeName} ) {
+ if ( $m->{ReturnType} =~ /~/ ) {
+ # A destructor
+ $hasPublicDestructor = 0 if $m->{Access} ne 'public';
+ $hasDestructor = 1;
+ } else {
+ # A constructor
+ $constructorCount++;
+ $defaultConstructor = $m->{Access} if ( $m->{Params} eq '' );
+ $hasPublicProtectedConstructor = 1 if ( $m->{Access} ne 'private' );
+
+ # Copy constructor?
+ if ( $#{$m->{ParamList}} == 0 ) {
+ my $theArgType = @{$m->{ParamList}}[0]->{ArgType};
+ if ($theArgType =~ /$className\s*\&/) {
+ $hasCopyConstructor = 1;
+ $hasPrivateCopyConstructor = 1 if ( $m->{Access} eq 'private' );
+ }
+ }
+ # Hack the return type for constructors, since constructors return an object pointer
+ $m->{ReturnType} = $className."*";
+ }
+ }
+
+ if ( $name =~ /~$classNode->{astNodeName}/ && $m->{Access} ne "private" ) { # not used
+ $hasPublicDestructor = 0 if $m->{Access} ne 'public';
+ $hasDestructor = 1;
+ }
+
+ if ( $m->{Flags} =~ "p" && $m->{Access} =~ /private/ ) {
+ $hasPrivatePureVirtual = 1; # ouch, can't inherit from that one
+ }
+
+ # All we want from private methods is to check for virtuals, nothing else
+ next if ( $m->{Access} =~ /private/ );
+
+ my $argId = 0;
+ my $firstDefaultParam;
+ foreach my $arg ( @{$m->{ParamList}} ) {
+ # Look for first param with a default value
+ if ( defined $arg->{DefaultValue} && !defined $firstDefaultParam ) {
+ $firstDefaultParam = $argId;
+ }
+
+ if ( $arg->{ArgType} eq '...' # refuse a method with variable arguments
+ or $arg->{ArgType} eq 'image_io_handler' # QImage's callback
+ or $arg->{ArgType} eq 'DecoderFn' # QFile's callback
+ or $arg->{ArgType} eq 'EncoderFn' # QFile's callback
+ or $arg->{ArgType} =~ /bool \(\*\)\(QObject/ # QMetaObject's ctor
+ or $arg->{ArgType} eq 'QtStaticMetaObjectFunction' # QMetaObjectCleanUp's ctor with func pointer
+ or $arg->{ArgType} eq 'const QTextItem&' # ref to a private class in 3.2.0b1
+ or $arg->{ArgType} eq 'FILE*' # won't be able to handle that I think
+ ) {
+ $m->{NodeType} = 'deleted';
+ }
+ else
+ {
+ # Resolve type in full, e.g. for QSessionManager::RestartHint
+ # (x_QSessionManager doesn't inherit QSessionManager)
+ $arg->{ArgType} = kalyptusDataDict::resolveType($arg->{ArgType}, $classNode, $rootnode);
+ registerType( $arg->{ArgType} );
+ $argId++;
+ }
+ }
+ $m->AddProp( "FirstDefaultParam", $firstDefaultParam );
+ $m->{ReturnType} = kalyptusDataDict::resolveType($m->{ReturnType}, $classNode, $rootnode) if ($m->{ReturnType});
+ registerType( $m->{ReturnType} );
+ }
+ elsif( $m->{NodeType} eq "enum" ) {
+ my $fullEnumName = $className."::".$m->{astNodeName};
+ $classNode->{enumerations}{$m->{astNodeName}} = $fullEnumName
+ if $m->{astNodeName} and $m->{Access} ne 'private';
+
+ # Define a type for this enum
+ registerType( $fullEnumName );
+
+ # Remember that it's an enum
+ findTypeEntry( $fullEnumName )->{isEnum} = 1;
+
+ #print STDERR "$fullEnumName is an enum\n";
+ }
+ elsif( $m->{NodeType} eq 'var' ) {
+ my $varType = $m->{Type};
+ # We are interested in public static vars, like QColor::blue
+ if ( $varType =~ s/static\s+// && $m->{Access} ne 'private' )
+ {
+ $varType =~ s/const\s+(.*)\s*&/$1/;
+ $varType =~ s/\s*$//;
+ print STDERR "var: $m->{astNodeName} '$varType'\n" if ($debug);
+
+ # Register the type
+ registerType( $varType );
+
+ } else {
+ # To avoid duplicating the above test, we just get rid of any other var
+ $m->{NodeType} = 'deleted';
+ }
+ }
+ },
+ undef
+ );
+ $main::doPrivate = $doPrivate;
+
+ print STDERR "$className: ctor count: $constructorCount, hasPublicProtectedConstructor: $hasPublicProtectedConstructor, hasCopyConstructor: $hasCopyConstructor:, defaultConstructor: $defaultConstructor, hasPublicDestructor: $hasPublicDestructor, hasPrivatePureVirtual:$hasPrivatePureVirtual\n" if ($debug);
+
+ # We will derive from the class only if it has public or protected constructors.
+ # (_Even_ if it has pure virtuals. But in that case the x_ class can't be instantiated either.)
+ $classNode->AddProp( "BindingDerives", $hasPublicProtectedConstructor );
+}
+
+
+=head2 writeClassDoc
+
+ Called by writeDoc for each series of classes to be written out
+
+=cut
+
+ sub writeClassDoc
+ {
+ }
+
+# Generate the prototypes for a method (one per arg with a default value)
+# Helper for makeprotos
+sub iterproto($$$$$) {
+ my $classidx = shift; # to check if a class exists
+ my $method = shift;
+ my $proto = shift;
+ my $idx = shift;
+ my $protolist = shift;
+
+ my $argcnt = scalar @{ $method->{ParamList} } - 1;
+ if($idx > $argcnt) {
+ push @$protolist, $proto;
+ return;
+ }
+ if(defined $method->{FirstDefaultParam} and $method->{FirstDefaultParam} <= $idx) {
+ push @$protolist, $proto;
+ }
+
+ my $arg = $method->{ParamList}[$idx]->{ArgType};
+
+ my $typeEntry = findTypeEntry( $arg );
+ my $realType = $typeEntry->{realType};
+
+ # A scalar ?
+ $arg =~ s/\bconst\b//g;
+ $arg =~ s/\s+//g;
+ if($typeEntry->{isEnum} || $allTypes{$realType}{isEnum} || exists $typeunion{$realType} || exists $mungedTypeMap{$arg})
+ {
+ my $id = '$'; # a 'scalar
+ $id = '?' if $arg =~ /[*&]{2}/;
+ $id = $mungedTypeMap{$arg} if exists $mungedTypeMap{$arg};
+ iterproto($classidx, $method, $proto . $id, $idx + 1, $protolist);
+ return;
+ }
+
+ # A class ?
+ if(exists $classidx->{$realType}) {
+ iterproto($classidx, $method, $proto . '#', $idx + 1, $protolist);
+ return;
+ }
+
+ # A non-scalar (reference to array or hash, undef)
+ iterproto($classidx, $method, $proto . '?', $idx + 1, $protolist);
+ return;
+}
+
+# Generate the prototypes for a method (one per arg with a default value)
+sub makeprotos($$$) {
+ my $classidx = shift;
+ my $method = shift;
+ my $protolist = shift;
+ iterproto($classidx, $method, $method->{astNodeName}, 0, $protolist);
+}
+
+# Return the string containing the signature for this method (without return type).
+# If the 2nd arg is not the size of $m->{ParamList}, this method returns a
+# partial signature (this is used to handle default values).
+sub methodSignature($$) {
+ my $method = shift;
+ my $last = shift;
+ my $sig = $method->{astNodeName};
+ my @argTypeList;
+ my $argId = 0;
+ foreach my $arg ( @{$method->{ParamList}} ) {
+ last if $argId > $last;
+ push @argTypeList, $arg->{ArgType};
+ $argId++;
+ }
+ $sig .= "(". join(", ",@argTypeList) .")";
+ $sig .= " const" if $method->{Flags} =~ "c";
+ return $sig;
+}
+
+sub coerce_type($$$$) {
+ #my $m = shift;
+ my $union = shift;
+ my $var = shift;
+ my $type = shift;
+ my $new = shift; # 1 if this is a return value, 0 for a normal param
+
+ my $typeEntry = findTypeEntry( $type );
+ my $realType = $typeEntry->{realType};
+
+ my $unionfield = $typeEntry->{typeId};
+ die "$type" unless defined( $unionfield );
+ $unionfield =~ s/t_/s_/;
+
+ $type =~ s/\s+const$//; # for 'char* const'
+ $type =~ s/\s+const\s*\*$/\*/; # for 'char* const*'
+
+ my $code = "$union.$unionfield = ";
+ if($type =~ /&$/) {
+ $code .= "(void*)&$var;\n";
+ } elsif($type =~ /\*$/) {
+ $code .= "(void*)$var;\n";
+ } else {
+ if ( $unionfield eq 's_class'
+ or ( $unionfield eq 's_voidp' and $type ne 'void*' )
+ or $type eq 'QString' ) { # hack
+ $type =~ s/^const\s+//;
+ if($new) {
+ $code .= "(void*)new $type($var);\n";
+ } else {
+ $code .= "(void*)&$var;\n";
+ }
+ } else {
+ $code .= "$var;\n";
+ }
+ }
+
+ return $code;
+}
+
+# Generate the list of args casted to their real type, e.g.
+# (QObject*)x[1].s_class,(QEvent*)x[2].s_class,x[3].s_int
+sub makeCastedArgList
+{
+ my @castedList;
+ my $i = 1; # The args start at x[1]. x[0] is the return value
+ my $arg;
+ foreach $arg (@_) {
+ my $type = $arg;
+ my $cast;
+
+ my $typeEntry = findTypeEntry( $type );
+ my $unionfield = $typeEntry->{typeId};
+ die "$type" unless defined( $unionfield );
+ $unionfield =~ s/t_/s_/;
+
+ $type =~ s/\s+const$//; # for 'char* const'
+ $type =~ s/\s+const\s*\*$/\*/; # for 'char* const*'
+
+ my $v .= "$unionfield";
+ if($type =~ s/&$//) {
+ $cast = "{($type *)}";
+ } elsif($type =~ /\*$/) {
+ $cast = "$type";
+ } elsif($type =~ /\(\*\)\s*\(/) { # function pointer ... (*)(...)
+ $cast = "$type";
+ } else {
+ if ( $unionfield eq 's_class'
+ or ( $unionfield eq 's_voidp' and $type ne 'void*' )
+ or $type eq 'QString' ) { # hack
+ $cast = "{*($type *)}";
+ } else {
+ $cast = "$type";
+ }
+ }
+ push @castedList, "<TYPE>$cast</TYPE>$v";
+ $i++;
+ }
+ return @castedList;
+}
+
+# Adds the header for node $1 to be included in $2 if not already there
+# Prints out debug stuff if $3
+sub addIncludeForClass($$$)
+{
+ my ( $node, $addInclude, $debugMe ) = @_;
+ my $sourcename = $node->{Source}->{astNodeName};
+ $sourcename =~ s!.*/(.*)!$1!m;
+ die "Empty source name for $node->{astNodeName}" if ( $sourcename eq '' );
+ unless ( defined $addInclude->{$sourcename} ) {
+ print " Including $sourcename\n" if ($debugMe);
+ $addInclude->{$sourcename} = 1;
+ }
+ else { print " $sourcename already included.\n" if ($debugMe); }
+}
+
+sub checkIncludesForObject($$)
+{
+ my $type = shift;
+ my $addInclude = shift;
+
+ my $debugCI = 0; #$debug
+ #print "checkIncludesForObject $type\n";
+ $type =~ s/const\s+//;
+ my $it = $type;
+ if (!($it and exists $typeunion{$it}) and $type !~ /\*/
+ #and $type !~ /&/ # in fact we also want refs, due to the generated code
+ ) {
+ $type =~ s/&//;
+ print " Detecting an object by value/ref: $type\n" if ($debugCI);
+ my $node = kdocAstUtil::findRef( $rootnode, $type );
+ if ($node) {
+ addIncludeForClass( $node, $addInclude, $debugCI );
+ }
+ else { print " No header found for $type\n" if ($debugCI); }
+ }
+}
+
+sub generateMethod($$$)
+{
+ my( $classNode, $m, $addInclude ) = @_; # input
+ my $methodCode = ''; # output
+
+ my $name = $m->{astNodeName}; # method name
+ my @heritage = kdocAstUtil::heritage($classNode);
+ my $className = join( "::", @heritage );
+ my $xClassName = "x_" . join( "__", @heritage );
+
+ # Check some method flags: constructor, destructor etc.
+ my $flags = $m->{Flags};
+
+ if ( !defined $flags ) {
+ warn "Method ".$name. " has no flags\n";
+ }
+
+ my $returnType = $m->{ReturnType};
+ $returnType = undef if ($returnType eq 'void');
+
+ # Don't use $className here, it's never the fully qualified (A::B) name for a ctor.
+ my $isConstructor = ($name eq $classNode->{astNodeName} );
+ my $isDestructor = ($returnType eq '~');
+
+ if ($debug) {
+ print STDERR " Method $name";
+ print STDERR ", is DTOR" if $isDestructor;
+ print STDERR ", returns $returnType" if $returnType;
+ #print STDERR " ($m->{Access})";
+ print STDERR "\n";
+ }
+
+ # Don't generate anything for destructors
+ return if $isDestructor;
+
+ return if ( $m->{SkipFromSwitch} ); # pure virtuals, etc.
+
+# # Skip internal methods, which return unknown types
+# # Hmm, the C# bindings have a list of those too.
+# return if ( $returnType =~ m/QGfx\s*\*/ );
+# return if ( $returnType eq 'CGContextRef' );
+# return if ( $returnType eq 'QWSDisplay *' );
+# # This stuff needs callback, or **
+# return if ( $name eq 'defineIOHandler' or $name eq 'qt_init_internal' );
+# # Skip casting operators, but not == < etc.
+# return if ( $name =~ /operator \w+/ );
+# # QFile's EncoderFn/DecoderFn
+# return if ( $name =~ /set[ED][ne]codingFunction/ );
+# # How to implement this? (QXmlDefaultHandler/QXmlEntityResolver::resolveEntity, needs A*&)
+# return if ( $name eq 'resolveEntity' and $className =~ /^QXml/ );
+# return if ( $className eq 'QBitArray' && $m->{Access} eq 'protected' );
+
+ #print STDERR "Tests passed, generating.\n";
+
+ # Detect objects returned by value
+ checkIncludesForObject( $returnType, $addInclude ) if ($returnType);
+
+ my $argId = 0;
+
+ my @argTypeList=();
+
+ my $args = "";
+
+ foreach my $arg ( @{$m->{ParamList}} ) {
+
+ print STDERR " Param ".$arg->{astNodeName}." type: ".$arg->{ArgType}." name:".$arg->{ArgName}." default: ".$arg->{DefaultValue}."\n" if ($debug);
+
+ my $argType = $arg->{ArgType};
+
+ my $x_isConst = ($argType =~ s/const//);
+ my $x_isRef = ($argType =~ s/&//);
+
+ my $typeAttrs = "";
+ $typeAttrs .= " qleft=\"const\"" if $x_isConst;
+ $typeAttrs .= " qright=\"&amp;\"" if $x_isRef;
+
+ $argType =~ s/^\s*(.*?)\s*$/$1/;
+ $argType =~ s/</&lt;/g;
+ $argType =~ s/>/&gt;/g;
+ $argType =~ s/\s//g;
+
+ $args .= " <ARG><TYPE$typeAttrs>$argType</TYPE><NAME>$arg->{ArgName}</NAME></ARG>\n";
+
+ push @argTypeList, $argType;
+
+ # Detect objects passed by value
+ checkIncludesForObject( $argType, $addInclude );
+ }
+
+# my @castedArgList = makeCastedArgList( @argTypeList );
+
+ my $isStatic = ($flags =~ "s");
+ my $extra = "";
+ $extra .= "static " if $isStatic || $isConstructor;
+
+ my $qual = "";
+ $qual .= " qual=\"const\"" if $flags =~ "c";
+
+ my $this = $classNode->{BindingDerives} > 0 ? "this" : "xthis";
+
+ # We iterate as many times as we have default params
+ my $firstDefaultParam = $m->{FirstDefaultParam};
+ $firstDefaultParam = scalar(@argTypeList) unless defined $firstDefaultParam;
+
+ my $xretCode = '';
+ if($returnType) {
+ $xretCode .= coerce_type('x[0]', 'xret', $returnType, 1); }
+
+ $returnType = "void" unless $returnType;
+ $returnType =~ s/</&lt;/g;
+ $returnType =~ s/>/&gt;/g;
+
+ my $methodCode = "";
+
+ my $tagType = ($flags !~ /z/) ? "FUNC" : "SIGNAL";
+ my $tagAttr = "";
+ $tagAttr .= " hidden=\"yes\"" if $flags =~ /y/;
+
+ if (!$isConstructor) {
+ $methodCode .= " <$tagType$tagAttr$qual>\n";
+ $methodCode .= " <TYPE>$returnType</TYPE>\n";
+ $methodCode .= " <NAME>$name</NAME>\n";
+ $methodCode .= "$args";
+ $methodCode .= " </$tagType>\n";
+ }
+
+ $methodNumber++;
+
+ return ( $methodCode, "" );
+}
+
+## Called by writeClassDoc
+sub generateAllMethods
+{
+ my ($classNode) = @_;
+ my $methodCode = '';
+
+ my $sourcename = $classNode->{Source}->{astNodeName};
+ $sourcename =~ s!.*/(.*)!$1!m;
+ die "Empty source name for $classNode->{astNodeName}" if ( $sourcename eq '' );
+
+ my %addInclude = ( $sourcename => 1 );
+
+ # Then all methods
+ Iter::MembersByType ( $classNode, undef,
+ sub { my ($classNode, $methodNode ) = @_;
+
+ if ( $methodNode->{NodeType} eq 'method' ) {
+ next unless $methodNode->{Flags} =~ /(d|z|y)/;
+ my ($meth, $swit) = generateMethod( $classNode, $methodNode, \%addInclude );
+ $methodCode .= $meth;
+ }
+ }, undef );
+
+ return ( $methodCode, "", \%addInclude );
+}
+
+# Known typedef? If so, apply it.
+sub applyTypeDef($)
+{
+ my $type = shift;
+ # Parse 'const' in front of it, and '*' or '&' after it
+ my $prefix = $type =~ s/^const\s+// ? 'const ' : '';
+ my $suffix = $type =~ s/\s*([\&\*]+)$// ? $1 : '';
+
+ if (exists $typedeflist{$type}) {
+ return $prefix.$typedeflist{$type}.$suffix;
+ }
+ return $prefix.$type.$suffix;
+}
+
+# Register type ($1) into %allTypes if not already there
+sub registerType($$) {
+ my $type = shift;
+ #print "registerType: $type\n" if ($debug);
+
+ $type =~ s/\s+const$//; # for 'char* const'
+ $type =~ s/\s+const\s*\*$/\*/; # for 'char* const*'
+
+ return if ( $type eq 'void' or $type eq '' or $type eq '~' );
+ die if ( $type eq '...' ); # ouch
+
+ # Let's register the real type, not its known equivalent
+ #$type = applyTypeDef($type);
+
+ # Enum _value_ -> get corresponding type
+ if (exists $enumValueToType{$type}) {
+ $type = $enumValueToType{$type};
+ }
+
+ # Already in allTypes
+ if(exists $allTypes{$type}) {
+ return;
+ }
+
+ die if $type eq 'QTextEdit::UndoRedoInfo::Type';
+ die if $type eq '';
+
+ my $realType = $type;
+
+ # Look for references (&) and pointers (* or **) - this will not handle *& correctly.
+ # We do this parsing here because both the type list and iterproto need it
+ if($realType =~ s/&$//) {
+ $allTypes{$type}{typeFlags} = 'Smoke::tf_ref';
+ }
+ elsif($realType ne 'void*' && $realType =~ s/\*$//) {
+ $allTypes{$type}{typeFlags} = 'Smoke::tf_ptr';
+ }
+ else {
+ $allTypes{$type}{typeFlags} = 'Smoke::tf_stack';
+ }
+
+ if ( $realType =~ s/^const\s+// ) { # Remove 'const'
+ $allTypes{$type}{typeFlags} .= ' | Smoke::tf_const';
+ }
+
+ # Apply typedefs, and store the resulting type.
+ # For instance, if $type was Q_UINT16&, realType will be ushort
+ $allTypes{$type}{realType} = applyTypeDef( $realType );
+
+ # In the first phase we only create entries into allTypes.
+ # The values (indexes) are calculated afterwards, once the list is full.
+ $allTypes{$type}{index} = -1;
+ #print STDERR "Register $type. Realtype: $realType\n" if($debug);
+}
+
+# Get type from %allTypes
+# This returns a hash with {index}, {isEnum}, {typeFlags}, {realType}
+# (and {typeId} after the types array is written by writeSmokeDataFile)
+sub findTypeEntry($) {
+ my $type = shift;
+ my $typeIndex = -1;
+ $type =~ s/\s+const$//; # for 'char* const'
+ $type =~ s/\s+const\s*\*$/\*/; # for 'char* const*'
+
+ return undef if ( $type =~ '~' or $type eq 'void' or $type eq '' );
+
+ # Enum _value_ -> get corresponding type
+ if (exists $enumValueToType{$type}) {
+ $type = $enumValueToType{$type};
+ }
+
+ die "type not known: $type" unless defined $allTypes{$type};
+ return $allTypes{ $type };
+}
+
+# List of all super-classes for a given class
+sub superclass_list($)
+{
+ my $classNode = shift;
+ my @super;
+ Iter::Ancestors( $classNode, $rootnode, undef, undef, sub {
+ push @super, @_[0];
+ push @super, superclass_list( @_[0] );
+ }, undef );
+ return @super;
+}
+
+=head2
+ Write out the smokedata.cpp file containing all the arrays.
+=cut
+
+sub writeSmokeDataFile($) {
+ my $rootnode = shift;
+
+ # Make list of classes
+ my %allIncludes; # list of all header files for all classes
+ my @classlist;
+ push @classlist, ""; # Prepend empty item for "no class"
+ my %enumclasslist;
+ Iter::LocalCompounds( $rootnode, sub {
+ my $classNode = $_[0];
+ my $className = join( "::", kdocAstUtil::heritage($classNode) );
+ push @classlist, $className;
+ $enumclasslist{$className}++ if keys %{$classNode->{enumerations}};
+ $classNode->{ClassIndex} = $#classlist;
+ addIncludeForClass( $classNode, \%allIncludes, undef );
+ } );
+
+ kdocAstUtil::dumpAst($rootnode) if ($debug);
+
+ my %classidx = do { my $i = 0; map { $_ => $i++ } @classlist };
+
+ # Prepare descendants information for each class
+ my %descendants; # classname -> list of descendant nodes
+ Iter::LocalCompounds( $rootnode, sub {
+ my $classNode = shift;
+ # Get _all_ superclasses (up any number of levels)
+ # and store that $classNode is a descendant of $s
+ my @super = superclass_list($classNode);
+ for my $s (@super) {
+ my $superClassName = join( "::", kdocAstUtil::heritage($s) );
+ Ast::AddPropList( \%descendants, $superClassName, $classNode );
+ }
+ } );
+
+ # Iterate over all classes, to write the xtypecast function
+ Iter::LocalCompounds( $rootnode, sub {
+ my $classNode = shift;
+ my $className = join( "::", kdocAstUtil::heritage($classNode) );
+ # @super will contain superclasses, the class itself, and all descendants
+ my @super = superclass_list($classNode);
+ push @super, $classNode;
+ if ( defined $descendants{$className} ) {
+ push @super, @{$descendants{$className}};
+ }
+ my $cur = $classidx{$className};
+ $cur = -1;
+ for my $s (@super) {
+ my $superClassName = join( "::", kdocAstUtil::heritage($s) );
+ next if !defined $classidx{$superClassName}; # inherits from unknown class, see below
+ next if $classidx{$superClassName} == $cur; # shouldn't happen in Qt
+ $cur = $classidx{$superClassName};
+ }
+ } );
+
+ # Write inheritance array
+ # Imagine you have "Class : public super1, super2"
+ # The inheritlist array will get 3 new items: super1, super2, 0
+ my %inheritfinder; # key = (super1, super2) -> data = (index in @inheritlist). This one allows reuse.
+ my %classinherit; # we store that index in %classinherit{className}
+ # We don't actually need to store inheritlist in memory, we write it
+ # directly to the file. We only need to remember its current size.
+ my $inheritlistsize = 1;
+
+ Iter::LocalCompounds( $rootnode, sub {
+ my $classNode = shift;
+ my $className = join( "__", kdocAstUtil::heritage($classNode) );
+ print STDERR "inheritanceList: looking at $className\n" if ($debug);
+
+ # Make list of direct ancestors
+ my @super;
+ Iter::Ancestors( $classNode, $rootnode, undef, undef, sub {
+ my $superClassName = join( "::", kdocAstUtil::heritage($_[0]) );
+ push @super, $superClassName;
+ }, undef );
+ # Turn that into a list of class indexes
+ my $key = '';
+ foreach my $superClass( @super ) {
+ if (defined $classidx{$superClass}) {
+ $key .= ', ' if ( length $key > 0 );
+ $key .= $classidx{$superClass};
+ }
+ }
+ if ( $key ne '' ) {
+ if ( !defined $inheritfinder{$key} ) {
+ my $index = $inheritlistsize; # Index of first entry (for this group) in inheritlist
+ foreach my $superClass( @super ) {
+ if (defined $classidx{$superClass}) {
+ $inheritlistsize++;
+ }
+ }
+ $inheritlistsize++;
+ my $comment = join( ", ", @super );
+ $inheritfinder{$key} = $index;
+ }
+ $classinherit{$className} = $inheritfinder{$key};
+ } else { # No superclass
+ $classinherit{$className} = 0;
+ }
+ } );
+
+ for my $className (keys %enumclasslist) {
+ my $c = $className;
+ $c =~ s/::/__/g;
+ }
+ my $firstClass = 1;
+ for my $className (@classlist) {
+ if ($firstClass) {
+ $firstClass = 0;
+ next;
+ }
+ my $c = $className; # make a copy
+ $c =~ s/::/__/g;
+ }
+
+ # Write class list afterwards because it needs offsets to the inheritance array.
+ my $firstClass = 1;
+ Iter::LocalCompounds( $rootnode, sub {
+ my $classNode = shift;
+ my $className = join( "__", kdocAstUtil::heritage($classNode) );
+
+ if ($firstClass) {
+ $firstClass = 0;
+ }
+ my $c = $className;
+ $c =~ s/::/__/g;
+ my $xcallFunc = "xcall_$c";
+ my $xenumFunc = "0";
+ $xenumFunc = "xenum_$c" if exists $enumclasslist{$className};
+ # %classinherit needs Foo__Bar, not Foo::Bar?
+ die "problem with $className" unless defined $classinherit{$c};
+
+ my $xClassFlags = 0;
+ $xClassFlags =~ s/0\|//; # beautify
+ } );
+
+
+ my $typeCount = 0;
+ $allTypes{''}{index} = 0; # We need an "item 0"
+ for my $type (sort keys %allTypes) {
+ $allTypes{$type}{index} = $typeCount; # Register proper index in allTypes
+ if ( $typeCount == 0 ) {
+ $typeCount++;
+ next;
+ }
+ my $isEnum = $allTypes{$type}{isEnum};
+ my $typeId;
+ my $typeFlags = $allTypes{$type}{typeFlags};
+ my $realType = $allTypes{$type}{realType};
+ die "$type" if !defined $typeFlags;
+ die "$realType" if $realType =~ /\(/;
+ # First write the name
+ # Then write the classId (and find out the typeid at the same time)
+ if(exists $classidx{$realType}) { # this one first, we want t_class for QBlah*
+ $typeId = 't_class';
+ }
+ elsif($type =~ /&$/ || $type =~ /\*$/) {
+ $typeId = 't_voidp';
+ }
+ elsif($isEnum || $allTypes{$realType}{isEnum}) {
+ $typeId = 't_enum';
+ if($realType =~ /(.*)::/) {
+ my $c = $1;
+ }
+ }
+ else {
+ $typeId = $typeunion{$realType};
+ if (defined $typeId) {
+ $typeId =~ s/s_/t_/; # from s_short to t_short for instance
+ }
+ else {
+ # Not a known class - ouch, this happens quite a lot
+ # (private classes, typedefs, template-based types, etc)
+ if ( $skippedClasses{$realType} ) {
+# print STDERR "$realType has been skipped, using t_voidp for it\n";
+ } else {
+ unless( $realType =~ /</ ) { # Don't warn for template stuff...
+ print STDERR "$realType isn't a known type (type=$type)\n";
+ }
+ }
+ $typeId = 't_voidp'; # Unknown -> map to a void *
+ }
+ }
+ # Then write the flags
+ die "$type" if !defined $typeId;
+ $typeCount++;
+ # Remember it for coerce_type
+ $allTypes{$type}{typeId} = $typeId;
+ }
+}
+
+1;
diff --git a/dcopidlng/kalyptusDataDict.pm b/dcopidlng/kalyptusDataDict.pm
new file mode 100644
index 00000000..0de24803
--- /dev/null
+++ b/dcopidlng/kalyptusDataDict.pm
@@ -0,0 +1,3042 @@
+#***************************************************************************
+# kalyptusDataDict.pm - A Qt/KDE types data dictionary
+# -------------------
+# begin : Fri Oct 20 12:00:00 2000
+# copyright : (C) 2000-2001 Lost Highway Ltd. All Rights Reserved.
+# email : Richard_Dale@tipitina.demon.co.uk
+# author : Richard Dale.
+#***************************************************************************/
+
+#/***************************************************************************
+# * *
+# * This program is free software; you can redistribute it and/or modify *
+# * it under the terms of the GNU General Public License as published by *
+# * the Free Software Foundation; either version 2 of the License, or *
+# * (at your option) any later version. *
+# * *
+#***************************************************************************/
+
+package kalyptusDataDict;
+
+use strict;
+no strict "subs";
+
+use vars qw/ %interfacemap %ctypemap %builtins /;
+
+BEGIN
+{
+
+%interfacemap = (
+'QPaintDevice' => 'QPaintDeviceInterface',
+'QMenuData' => 'QMenuDataInterface',
+'QRangeControl' => 'QRangeControlInterface',
+'QMimeSource' => 'QMimeSourceInterface',
+'QLayoutItem' => 'QLayoutItemInterface',
+'QUrl' => 'QUrlInterface',
+'QIODevice' => 'QIODeviceInterface',
+'QXmlContentHandler' => 'QXmlContentHandlerInterface',
+'QXmlErrorHandler' => 'QXmlErrorHandlerInterface',
+'QXmlDTDHandler' => 'QXmlDTDHandlerInterface',
+'QXmlEntityResolver' => 'QXmlEntityResolverInterface',
+'QXmlLexicalHandler' => 'QXmlLexicalHandlerInterface',
+'QXmlDeclHandler' => 'QXmlDeclHandlerInterface',
+'KInstance' => 'KInstanceInterface',
+'QwAbsSpriteFieldView' => 'QwAbsSpriteFieldViewInterface',
+'PartBase' => 'PartBaseInterface',
+'KCompletionBase' => 'KCompletionBaseInterface',
+'KDirNotify' => 'KDirNotifyInterface',
+'KXMLGUIClient' => 'KXMLGUIClientInterface',
+'KFileView' => 'KFileViewInterface',
+'KXMLGUIBuilder' => 'KXMLGUIBuilderInterface',
+'DCOPObject' => 'DCOPObjectInterface',
+'KDevCore' => 'KDevCoreInterface',
+'QSqlQuery' => 'QSqlQueryInterface',
+
+);
+
+# A hard coded type translation table (the idea from the Roberto Alsina's Qtc
+# python conversion scripts). The particular format used here makes it possible to use
+# the same table with three different kdoc based Qt/KDE language binding generators;
+# C, Objective-C and Java.
+%ctypemap = (
+
+'ASConsumer*' => 'kde_ASConsumer*',
+'ASProducer*' => 'kde_ASProducer*',
+'ASYNC' => 'void' ,
+'Address&' => 'kde_Address*' ,
+'Address*' => 'kde_Address*',
+'AddressBook*' => 'kde_AddressBook*',
+'AddressBook::Entry&' => 'kde_Entry*' ,
+'Addressee&' => 'kde_Addressee*',
+'Addressee*' => 'kde_Addressee*',
+'AddresseeData*' => 'kde_AddresseeData*',
+'AddresseeDialog*' => 'kde_AddresseeDialog*',
+'AddresseeItem*' => 'kde_AddresseeItem*',
+'AlsaOut*' => 'kde_AlsaOut*',
+'AnyConstRef&' => 'kde_AnyConstRef*',
+'AnyConstRef*' => 'kde_AnyConstRef*',
+'AnyRef&' => 'kde_AnyRef*',
+'AnyRef*' => 'kde_AnyRef*',
+'AnyRefBase&' => 'kde_AnyRefBase*',
+'AnyRefBase*' => 'kde_AnyRefBase*',
+'ArgList' => 'int' ,
+'ArrowType' => 'int' ,
+'Arts*' => 'kde_Arts*',
+'Arts::AudioManagerClient' => 'int',
+'Arts::Buffer&' => 'kde_Arts_Buffer*',
+'Arts::Buffer*' => 'kde_Arts_Buffer*',
+'Arts::ByteSoundProducer' => 'kde_Arts_ByteSoundProducer*',
+'Arts::Connection*' => 'kde_Arts_Connection*',
+'Arts::DynamicCast&' => 'kde_Arts_DynamicCast*',
+'Arts::FlowSystemReceiver' => 'kde_Arts_FlowSystemReceiver*',
+'Arts::FlowSystemSender' => 'kde_Arts_FlowSystemSender*',
+'Arts::Format&' => 'kde_Arts_Format*',
+'Arts::Format' => 'kde_Arts_Format',
+'Arts::GenericAsyncStream*' => 'kde_Arts_GenericAsyncStream*',
+'Arts::GenericDataChannel*' => 'kde_Arts_GenericDataChannel*',
+'Arts::InterfaceDef' => 'kde_Arts_InterfaceDef*',
+'Arts::MethodDef&' => 'kde_Arts_MethodDef*',
+'Arts::ModuleDef&' => 'kde_Arts_ModuleDef*',
+'Arts::Notification&' => 'kde_Arts_Notification*',
+'Arts::Object' => 'kde_Arts_Object*',
+'Arts::Object::Pool&' => 'kde_Arts_Object_Pool*',
+'Arts::ObjectReference' => 'kde_Arts_ObjectReference*',
+'Arts::PlayObject' => 'kde_Arts_PlayObject*',
+'Arts::Reference&' => 'kde_Arts_Reference*',
+'Arts::StereoEffect' => 'kde_Arts_StereoEffect*',
+'Arts::StereoEffectStack' => 'kde_Arts_StereoEffectStack*',
+'Arts::SubClass&' => 'kde_Arts_SubClass*',
+'Arts::TypeDef' => 'kde_Arts_TypeDef*',
+'Arts::poTime&' => 'kde_Arts_poTime*',
+'Arts::poTime' => 'kde_Arts_poTime',
+'AsyncStream*' => 'kde_AsyncStream*',
+'Attr&' => 'kde_Attr*',
+'Attr' => 'kde_Attr*',
+'Attr*' => 'kde_Attr*',
+'AttrImpl*' => 'kde_AttrImpl*',
+'AttributeDef&' => 'kde_AttributeDef*',
+'AttributeDef*' => 'kde_AttributeDef*',
+'AudioManager&' => 'kde_AudioManager*',
+'AudioManager' => 'kde_AudioManager*',
+'AudioManager*' => 'kde_AudioManager*',
+'AudioManagerClient&' => 'kde_AudioManagerClient*',
+'AudioManagerClient' => 'kde_AudioManagerClient*',
+'AudioManagerClient*' => 'kde_AudioManagerClient*',
+'AudioManagerClient_base*' => 'kde_AudioManagerClient_base*',
+'AudioManagerClient_skel*' => 'kde_AudioManagerClient_skel*',
+'AudioManagerClient_stub*' => 'kde_AudioManagerClient_stub*',
+'AudioManagerInfo&' => 'kde_AudioManagerInfo*',
+'AudioManagerInfo*' => 'kde_AudioManagerInfo*',
+'AudioManager_base*' => 'kde_AudioManager_base*',
+'AudioManager_skel*' => 'kde_AudioManager_skel*',
+'AudioManager_stub*' => 'kde_AudioManager_stub*',
+'AudioPort*' => 'kde_AudioPort*',
+'AudioSubSystem*' => 'kde_AudioSubSystem*',
+'AudioSubSystemStart*' => 'kde_AudioSubSystemStart*',
+'AuthAccept&' => 'kde_AuthAccept*',
+'AuthAccept*' => 'kde_AuthAccept*',
+'AuthInfo&' => 'kde_AuthInfo*',
+'AuthInfo*' => 'kde_AuthInfo*',
+'BGMode' => 'int',
+'BMToken*' => 'kde_BMToken*',
+'BackgroundMode' => 'int',
+'BlockSelectionInterface*' => 'kde_BlockSelectionInterface*',
+'BookmarkTokenizer*' => 'kde_BookmarkTokenizer*',
+'Bool' => 'int' ,
+'Boolean&' => 'kde_Boolean*',
+'Boolean*' => 'kde_Boolean*',
+'BrowserExtension*' => 'kde_BrowserExtension*',
+'BrowserHostExtension*' => 'kde_BrowserHostExtension*',
+'BrowserInterface*' => 'kde_BrowserInterface*',
+'BrushStyle' => 'int',
+'Buffer&' => 'kde_Buffer*',
+'Buffer*' => 'kde_Buffer*',
+'ButtonCode' => 'int' ,
+'ButtonState' => 'int' ,
+'ByteAsyncStream*' => 'kde_ByteAsyncStream*',
+'ByteDataPacket*' => 'kde_ByteDataPacket*',
+'ByteSoundProducer&' => 'kde_ByteSoundProducer*',
+'ByteSoundProducer' => 'kde_ByteSoundProducer*',
+'ByteSoundProducer*' => 'kde_ByteSoundProducer*',
+'ByteSoundProducer_base*' => 'kde_ByteSoundProducer_base*',
+'ByteSoundProducer_skel*' => 'kde_ByteSoundProducer_skel*',
+'ByteSoundProducer_stub*' => 'kde_ByteSoundProducer_stub*',
+'ByteStreamToAudio&' => 'kde_ByteStreamToAudio*',
+'ByteStreamToAudio' => 'kde_ByteStreamToAudio*',
+'ByteStreamToAudio*' => 'kde_ByteStreamToAudio*',
+'ByteStreamToAudio_base*' => 'kde_ByteStreamToAudio_base*',
+'ByteStreamToAudio_skel*' => 'kde_ByteStreamToAudio_skel*',
+'ByteStreamToAudio_stub*' => 'kde_ByteStreamToAudio_stub*',
+'CDATASection&' => 'kde_CDATASection*',
+'CDATASection' => 'kde_CDATASection*',
+'CDATASection*' => 'kde_CDATASection*',
+'CFlags' => 'int',
+'COORD' => 'short' ,
+'CSSCharsetRule&' => 'kde_CSSCharsetRule*',
+'CSSCharsetRule*' => 'kde_CSSCharsetRule*',
+'CSSCharsetRuleImpl*' => 'kde_CSSCharsetRuleImpl*',
+'CSSException&' => 'kde_CSSException*',
+'CSSException*' => 'kde_CSSException*',
+'CSSFontFaceRule&' => 'kde_CSSFontFaceRule*',
+'CSSFontFaceRule*' => 'kde_CSSFontFaceRule*',
+'CSSFontFaceRuleImpl*' => 'kde_CSSFontFaceRuleImpl*',
+'CSSImportRule&' => 'kde_CSSImportRule*',
+'CSSImportRule*' => 'kde_CSSImportRule*',
+'CSSImportRuleImpl*' => 'kde_CSSImportRuleImpl*',
+'CSSMediaRule&' => 'kde_CSSMediaRule*',
+'CSSMediaRule*' => 'kde_CSSMediaRule*',
+'CSSMediaRuleImpl*' => 'kde_CSSMediaRuleImpl*',
+'CSSPageRule&' => 'kde_CSSPageRule*',
+'CSSPageRule*' => 'kde_CSSPageRule*',
+'CSSPageRuleImpl*' => 'kde_CSSPageRuleImpl*',
+'CSSPrimitiveValue&' => 'kde_CSSPrimitiveValue*',
+'CSSPrimitiveValue' => 'kde_CSSPrimitiveValue*',
+'CSSPrimitiveValue*' => 'kde_CSSPrimitiveValue*',
+'CSSPrimitiveValueImpl*' => 'kde_CSSPrimitiveValueImpl*',
+'CSSRule&' => 'kde_CSSRule*',
+'CSSRule' => 'kde_CSSRule*',
+'CSSRule*' => 'kde_CSSRule*',
+'CSSRuleImpl*' => 'kde_CSSRuleImpl*',
+'CSSRuleList&' => 'kde_CSSRuleList*',
+'CSSRuleList' => 'kde_CSSRuleList*',
+'CSSRuleList*' => 'kde_CSSRuleList*',
+'CSSRuleListImpl*' => 'kde_CSSRuleListImpl*',
+'CSSStyleDeclaration&' => 'kde_CSSStyleDeclaration*',
+'CSSStyleDeclaration' => 'kde_CSSStyleDeclaration*',
+'CSSStyleDeclaration*' => 'kde_CSSStyleDeclaration*',
+'CSSStyleDeclarationImpl*' => 'kde_CSSStyleDeclarationImpl*',
+'CSSStyleRule&' => 'kde_CSSStyleRule*',
+'CSSStyleRule*' => 'kde_CSSStyleRule*',
+'CSSStyleRuleImpl*' => 'kde_CSSStyleRuleImpl*',
+'CSSStyleSheet&' => 'kde_CSSStyleSheet*',
+'CSSStyleSheet' => 'kde_CSSStyleSheet*',
+'CSSStyleSheet*' => 'kde_CSSStyleSheet*',
+'CSSStyleSheetImpl*' => 'kde_CSSStyleSheetImpl*',
+'CSSUnknownRule&' => 'kde_CSSUnknownRule*',
+'CSSUnknownRule*' => 'kde_CSSUnknownRule*',
+'CSSUnknownRuleImpl*' => 'kde_CSSUnknownRuleImpl*',
+'CSSValue&' => 'kde_CSSValue*',
+'CSSValue' => 'kde_CSSValue*',
+'CSSValue*' => 'kde_CSSValue*',
+'CSSValueImpl*' => 'kde_CSSValueImpl*',
+'CSSValueList&' => 'kde_CSSValueList*',
+'CSSValueList*' => 'kde_CSSValueList*',
+'CSSValueListImpl*' => 'kde_CSSValueListImpl*',
+'CString&' => 'kde_CString*',
+'CString' => 'kde_CString*',
+'CString*' => 'kde_CString*',
+'Cache*' => 'kde_Cache*',
+'CacheInfo*' => 'kde_CacheInfo*',
+'CachedObject*' => 'kde_CachedObject*',
+'CachedWav*' => 'kde_CachedWav*',
+'Cardinal' => 'int' ,
+'CharSet' => 'int',
+'CharacterData&' => 'kde_CharacterData*',
+'CharacterData*' => 'kde_CharacterData*',
+'CharacterDataImpl*' => 'kde_CharacterDataImpl*',
+'ChmodJob*' => 'kde_ChmodJob*',
+'ClassInfo*' => 'kde_ClassInfo*',
+'ClassStore*' => 'kde_ClassStore*',
+'ClassTreeNode*' => 'kde_ClassTreeNode*',
+'ClientHello&' => 'kde_ClientHello*',
+'ClientHello*' => 'kde_ClientHello*',
+'ClipboardInterface*' => 'kde_ClipboardInterface*',
+'CodeCompletionInterface*' => 'kde_CodeCompletionInterface*',
+'ColorMode' => 'int',
+'Comment&' => 'kde_Comment*',
+'Comment' => 'kde_Comment*',
+'Comment*' => 'kde_Comment*',
+'CommentImpl*' => 'kde_CommentImpl*',
+'ComparisonFlags' => 'int',
+'Compl' => 'kde_Compl',
+'Completion&' => 'kde_Completion*',
+'Completion*' => 'kde_Completion*',
+'CompletionEntry&' => 'kde_CompletionEntry*',
+'CompletionEntry*' => 'kde_CompletionEntry*',
+'ComplexControl' => 'int',
+'ComponentFactory*' => 'kde_ComponentFactory*',
+'ConfigInterface*' => 'kde_ConfigInterface*',
+'Connection*' => 'kde_Connection*',
+'ConstIterator' => 'int' ,
+'Constructor' => 'kde_Constructor*',
+'Constructor*' => 'kde_Constructor*',
+'ConstructorImp*' => 'kde_ConstructorImp*',
+'ContentsType' => 'int',
+'Context&' => 'kde_Context*',
+'Context*' => 'kde_Context*',
+'ControlElement' => 'int',
+'CopyInfo*' => 'kde_CopyInfo*',
+'CopyJob*' => 'kde_CopyJob*',
+'Core*' => 'kde_Core*',
+'Counter&' => 'kde_Counter*',
+'Counter' => 'kde_Counter*',
+'Counter*' => 'kde_Counter*',
+'Cursor*' => 'kde_Cursor*',
+'CursorInterface*' => 'kde_CursorInterface*',
+'DCOPClient*' => 'kde_DCOPClient*',
+'DCOPClientTransaction*' => 'kde_DCOPClientTransaction*' ,
+'DCOPObject*' => 'kde_DCOPObject*',
+'DCOPObjectProxy*' => 'kde_DCOPObjectProxy*',
+'DCOPRef&' => 'kde_DCOPRef*' ,
+'DCOPRef*' => 'kde_DCOPRef*',
+'DCOPStub*' => 'kde_DCOPStub*',
+'DOM*' => 'kde_DOM*',
+'DOM::CSSProperty*' => 'kde_CSSProperty*' ,
+'DOM::DOMString&' => 'kde_DOMString*' ,
+'DOM::DOMString' => 'kde_DOMString*' ,
+'DOM::Document&' => 'kde_DOMDocument*' ,
+'DOM::Document' => 'kde_DOMDocument*' ,
+'DOM::Document*' => 'kde_DOMDocument*' ,
+'DOM::ElementImpl*' => 'kde_DOM_ElementImpl*' ,
+'DOM::HTMLDocument' => 'kde_HTMLDocument*' ,
+'DOM::MediaList&' => 'kde_MediaList*',
+'DOM::MediaList' => 'kde_MediaList',
+'DOM::MediaList*' => 'kde_MediaList*',
+'DOM::Node&' => 'kde_DOMNode*' ,
+'DOM::Node' => 'kde_DOMNode*' ,
+'DOM::NodeList&' => 'kde_DOMNodeList*',
+'DOM::NodeList' => 'kde_DOMNodeList*',
+'DOM::NodeList*' => 'kde_DOMNodeList*',
+'DOM::Range' => 'kde_Range*' ,
+'DOM::StyleSheetList&' => 'kde_StyleSheetList*',
+'DOM::StyleSheetList' => 'kde_StyleSheetList',
+'DOM::StyleSheetList*' => 'kde_StyleSheetList*',
+'DOMException&' => 'kde_DOMException*',
+'DOMException*' => 'kde_DOMException*',
+'DOMImplementation&' => 'kde_DOMImplementation*',
+'DOMImplementation' => 'kde_DOMImplementation*',
+'DOMImplementation*' => 'kde_DOMImplementation*',
+'DOMImplementationImpl*' => 'kde_DOMImplementationImpl*',
+'DOMString&' => 'kde_DOMString*',
+'DOMString' => 'kde_DOMString*',
+'DOMString*' => 'kde_DOMString*',
+'DOMStringImpl*' => 'kde_DOMStringImpl*',
+'DW_EXPORT*' => 'void*',
+'DataPacket*' => 'kde_DataPacket*',
+'DateFormat' => 'int',
+'Debug*' => 'kde_Debug*',
+'DecoderFn' => 'int' ,
+'DefaultProgress*' => 'kde_DefaultProgress*',
+'DeleteJob*' => 'kde_DeleteJob*',
+'DeviceManager*' => 'kde_DeviceManager*',
+'Direction' => 'int',
+'DispatchFunction' => 'kde_DispatchFunction*',
+'Dispatcher*' => 'kde_Dispatcher*',
+'Display' => 'Display',
+'Display*' => 'Display*',
+'DistributionList*' => 'kde_DistributionList*',
+'DistributionListEditor*' => 'kde_DistributionListEditor*',
+'DistributionListManager*' => 'kde_DistributionListManager*',
+'Dock&' => 'int',
+'Dock' => 'int',
+'DockMainWindow*' => 'kde_DockMainWindow*',
+'DockPosData&' => 'kde_DockPosData*' ,
+'DockPosData*' => 'kde_DockPosData*',
+'DockWindowData*' => 'long',
+'Document&' => 'kde_Document*',
+'Document' => 'kde_Document*',
+'Document*' => 'kde_Document*',
+'DocumentFragment&' => 'kde_DocumentFragment*',
+'DocumentFragment' => 'kde_DocumentFragment*',
+'DocumentFragment*' => 'kde_DocumentFragment*',
+'DocumentFragmentImpl*' => 'kde_DocumentFragmentImpl*',
+'DocumentImpl*' => 'kde_DocumentImpl*',
+'DocumentStyle&' => 'kde_DocumentStyle*',
+'DocumentStyle*' => 'kde_DocumentStyle*',
+'DocumentType&' => 'kde_DocumentType*',
+'DocumentType' => 'kde_DocumentType*',
+'DocumentType*' => 'kde_DocumentType*',
+'DocumentationContext*' => 'kde_DocumentationContext*',
+'DomShared*' => 'kde_DomShared*',
+'DrageMode' => 'int',
+'DrawContentsEvent*' => 'kde_DrawContentsEvent*',
+'DwAddress&' => 'kde_DwAddress*',
+'DwAddress*' => 'kde_DwAddress*',
+'DwAddressList&' => 'kde_DwAddressList*',
+'DwAddressList*' => 'kde_DwAddressList*',
+'DwBody&' => 'kde_DwBody*',
+'DwBody*' => 'kde_DwBody*',
+'DwBodyPart&' => 'kde_DwBodyPart*',
+'DwBodyPart*' => 'kde_DwBodyPart*',
+'DwBool' => 'int',
+'DwDateTime&' => 'kde_DwDateTime*',
+'DwDateTime*' => 'kde_DwDateTime*',
+'DwDispositionType&' => 'kde_DwDispositionType*',
+'DwDispositionType*' => 'kde_DwDispositionType*',
+'DwEntity&' => 'kde_DwEntity*',
+'DwField&' => 'kde_DwField*',
+'DwField*' => 'kde_DwField*',
+'DwFieldBody&' => 'kde_DwFieldBody*',
+'DwFieldBody*' => 'kde_DwFieldBody*',
+'DwGroup&' => 'kde_DwGroup*',
+'DwGroup*' => 'kde_DwGroup*',
+'DwHeaders&' => 'kde_DwHeaders*',
+'DwHeaders*' => 'kde_DwHeaders*',
+'DwInt32' => 'int',
+'DwMailbox&' => 'kde_DwMailbox*',
+'DwMailbox*' => 'kde_DwMailbox*',
+'DwMailboxList&' => 'kde_DwMailboxList*',
+'DwMailboxList*' => 'kde_DwMailboxList*',
+'DwMechanism&' => 'kde_DwMechanism*',
+'DwMechanism*' => 'kde_DwMechanism*',
+'DwMediaType&' => 'kde_DwMediaType*',
+'DwMediaType*' => 'kde_DwMediaType*',
+'DwMessage&' => 'kde_DwMessage*',
+'DwMessage*' => 'kde_DwMessage*',
+'DwMessageComponent&' => 'kde_DwMessageComponent*',
+'DwMessageComponent*' => 'kde_DwMessageComponent*',
+'DwMime*' => 'kde_DwMime*',
+'DwMsgId&' => 'kde_DwMsgId*',
+'DwMsgId*' => 'kde_DwMsgId*',
+'DwObserver*' => 'kde_DwObserver*',
+'DwParameter&' => 'kde_DwParameter*',
+'DwParameter*' => 'kde_DwParameter*',
+'DwProtocolClient*' => 'kde_DwProtocolClient*',
+'DwString&' => 'kde_DwString*',
+'DwString' => 'kde_DwString',
+'DwString*' => 'kde_DwString*',
+'DwText&' => 'kde_DwText*',
+'DwText*' => 'kde_DwText*',
+'DwTokenizer&' => 'kde_DwTokenizer*',
+'DwUint16' => 'unsigned short',
+'DwUint32' => 'unsigned int',
+'DwUint8' => 'unsigned char',
+'DynamicCast*' => 'kde_DynamicCast*',
+'DynamicRequest&' => 'kde_DynamicRequest*',
+'DynamicRequest*' => 'kde_DynamicRequest*',
+'EXPORT_DOCKCLASS*' => 'kde_EXPORT_DOCKCLASS*',
+'EchoMode' => 'int',
+'EditInterface*' => 'kde_EditInterface*',
+'Editor*' => 'kde_Editor*',
+'EditorContext*' => 'kde_EditorContext*',
+'Element&' => 'kde_Element*',
+'Element' => 'kde_Element*',
+'Element*' => 'kde_Element*',
+'ElementImpl*' => 'kde_ElementImpl*',
+'EmailSelectDialog*' => 'kde_EmailSelectDialog*',
+'EncoderFn' => 'int' ,
+'Endian' => 'int',
+'Entity&' => 'kde_Entity*',
+'Entity*' => 'kde_Entity*',
+'EntityReference&' => 'kde_EntityReference*',
+'EntityReference' => 'kde_EntityReference*',
+'EntityReference*' => 'kde_EntityReference*',
+'Entry&' => 'kde_Entry*' ,
+'Entry*' => 'kde_Entry*',
+'Entry::Address&' => 'kde_EntryAddress' ,
+'EnumComponent&' => 'kde_EnumComponent*',
+'EnumComponent*' => 'kde_EnumComponent*',
+'EnumDef&' => 'kde_EnumDef*',
+'EnumDef*' => 'kde_EnumDef*',
+'EnumEntry*' => 'kde_EnumEntry*',
+'Error*' => 'kde_Error*',
+'Event*' => 'kde_Event*',
+'ExecState*' => 'kde_ExecState*',
+'ExtensionLoader*' => 'kde_ExtensionLoader*',
+'FALSE' => '0',
+'FILE*' => 'FILE*',
+'FMOut*' => 'kde_FMOut*',
+'Factory*' => 'kde_Factory*',
+'False' => '0',
+'FileCopyJob*' => 'kde_FileCopyJob*',
+'FileProtocol*' => 'kde_FileProtocol*',
+'FileView&' => 'int' ,
+'FloatAsyncStream*' => 'kde_FloatAsyncStream*',
+'FloatDataPacket*' => 'kde_FloatDataPacket*',
+'FlowSystem&' => 'kde_FlowSystem*',
+'FlowSystem' => 'kde_FlowSystem*',
+'FlowSystem*' => 'kde_FlowSystem*',
+'FlowSystemReceiver&' => 'kde_FlowSystemReceiver*',
+'FlowSystemReceiver' => 'kde_FlowSystemReceiver*',
+'FlowSystemReceiver*' => 'kde_FlowSystemReceiver*',
+'FlowSystemReceiver_base*' => 'kde_FlowSystemReceiver_base*',
+'FlowSystemReceiver_skel*' => 'kde_FlowSystemReceiver_skel*',
+'FlowSystemReceiver_stub*' => 'kde_FlowSystemReceiver_stub*',
+'FlowSystemSender&' => 'kde_FlowSystemSender*',
+'FlowSystemSender' => 'kde_FlowSystemSender*',
+'FlowSystemSender*' => 'kde_FlowSystemSender*',
+'FlowSystemSender_base*' => 'kde_FlowSystemSender_base*',
+'FlowSystemSender_skel*' => 'kde_FlowSystemSender_skel*',
+'FlowSystemSender_stub*' => 'kde_FlowSystemSender_stub*',
+'FlowSystem_base*' => 'kde_FlowSystem_base*',
+'FlowSystem_impl*' => 'kde_FlowSystem_impl*',
+'FlowSystem_skel*' => 'kde_FlowSystem_skel*',
+'FlowSystem_stub*' => 'kde_FlowSystem_stub*',
+'FocusPolicy' => 'int',
+'Format&' => 'kde_Format*',
+'Format*' => 'kde_Format*',
+'Function*' => 'kde_Function*',
+'FunctionImp*' => 'kde_FunctionImp*',
+'GCI&' => 'GCI*' ,
+'GCI' => 'GCI*' ,
+'GCI*' => 'GCI*' ,
+'GUIActivateEvent*' => 'kde_GUIActivateEvent*',
+'GUIStyle' => 'int',
+'GUSOut*' => 'kde_GUSOut*',
+'GenericAsyncStream*' => 'kde_GenericAsyncStream*',
+'GenericDataChannel*' => 'kde_GenericDataChannel*',
+'GenericDataPacket*' => 'kde_GenericDataPacket*',
+'GenericFactory*' => 'kde_GenericFactory*',
+'GenericFactoryBase*' => 'kde_GenericFactoryBase*',
+'Global*' => 'kde_Global*',
+'GlobalComm&' => 'kde_GlobalComm*',
+'GlobalComm' => 'kde_GlobalComm*',
+'GlobalComm*' => 'kde_GlobalComm*',
+'GlobalComm_base*' => 'kde_GlobalComm_base*',
+'GlobalComm_skel*' => 'kde_GlobalComm_skel*',
+'GlobalComm_stub*' => 'kde_GlobalComm_stub*',
+'HANDLE' => 'unsigned int',
+'HBITMAP' => 'void *' ,
+'HCURSOR' => 'void *' ,
+'HDC' => 'void *' ,
+'HFONT' => 'void *' ,
+'HPALETTE' => 'void *' ,
+'HRGN' => 'void *' ,
+'HTMLAnchorElement&' => 'kde_HTMLAnchorElement*',
+'HTMLAnchorElement*' => 'kde_HTMLAnchorElement*',
+'HTMLAnchorElementImpl*' => 'kde_HTMLAnchorElementImpl*',
+'HTMLAppletElement&' => 'kde_HTMLAppletElement*',
+'HTMLAppletElement*' => 'kde_HTMLAppletElement*',
+'HTMLAppletElementImpl*' => 'kde_HTMLAppletElementImpl*',
+'HTMLAreaElement&' => 'kde_HTMLAreaElement*',
+'HTMLAreaElement*' => 'kde_HTMLAreaElement*',
+'HTMLAreaElementImpl*' => 'kde_HTMLAreaElementImpl*',
+'HTMLBRElement&' => 'kde_HTMLBRElement*',
+'HTMLBRElement*' => 'kde_HTMLBRElement*',
+'HTMLBRElementImpl*' => 'kde_HTMLBRElementImpl*',
+'HTMLBaseElement&' => 'kde_HTMLBaseElement*',
+'HTMLBaseElement*' => 'kde_HTMLBaseElement*',
+'HTMLBaseElementImpl*' => 'kde_HTMLBaseElementImpl*',
+'HTMLBaseFontElement&' => 'kde_HTMLBaseFontElement*',
+'HTMLBaseFontElement*' => 'kde_HTMLBaseFontElement*',
+'HTMLBaseFontElementImpl*' => 'kde_HTMLBaseFontElementImpl*',
+'HTMLBlockquoteElement&' => 'kde_HTMLBlockquoteElement*',
+'HTMLBlockquoteElement*' => 'kde_HTMLBlockquoteElement*',
+'HTMLBlockquoteElementImpl*' => 'kde_HTMLBlockquoteElementImpl*',
+'HTMLBodyElement&' => 'kde_HTMLBodyElement*',
+'HTMLBodyElement*' => 'kde_HTMLBodyElement*',
+'HTMLBodyElementImpl*' => 'kde_HTMLBodyElementImpl*',
+'HTMLButtonElement&' => 'kde_HTMLButtonElement*',
+'HTMLButtonElement*' => 'kde_HTMLButtonElement*',
+'HTMLButtonElementImpl*' => 'kde_HTMLButtonElementImpl*',
+'HTMLCollection&' => 'kde_HTMLCollection*',
+'HTMLCollection' => 'kde_HTMLCollection*',
+'HTMLCollection*' => 'kde_HTMLCollection*',
+'HTMLCollectionImpl*' => 'kde_HTMLCollectionImpl*',
+'HTMLDListElement&' => 'kde_HTMLDListElement*',
+'HTMLDListElement*' => 'kde_HTMLDListElement*',
+'HTMLDListElementImpl*' => 'kde_HTMLDListElementImpl*',
+'HTMLDirectoryElement&' => 'kde_HTMLDirectoryElement*',
+'HTMLDirectoryElement*' => 'kde_HTMLDirectoryElement*',
+'HTMLDirectoryElementImpl*' => 'kde_HTMLDirectoryElementImpl*',
+'HTMLDivElement&' => 'kde_HTMLDivElement*',
+'HTMLDivElement*' => 'kde_HTMLDivElement*',
+'HTMLDivElementImpl*' => 'kde_HTMLDivElementImpl*',
+'HTMLDocument&' => 'kde_HTMLDocument*',
+'HTMLDocument*' => 'kde_HTMLDocument*',
+'HTMLDocumentImpl*' => 'kde_HTMLDocumentImpl*',
+'HTMLElement&' => 'kde_HTMLElement*',
+'HTMLElement' => 'kde_HTMLElement*',
+'HTMLElement*' => 'kde_HTMLElement*',
+'HTMLElementImpl*' => 'kde_HTMLElementImpl*',
+'HTMLFieldSetElement&' => 'kde_HTMLFieldSetElement*',
+'HTMLFieldSetElement*' => 'kde_HTMLFieldSetElement*',
+'HTMLFieldSetElementImpl*' => 'kde_HTMLFieldSetElementImpl*',
+'HTMLFontElement&' => 'kde_HTMLFontElement*',
+'HTMLFontElement*' => 'kde_HTMLFontElement*',
+'HTMLFontElementImpl*' => 'kde_HTMLFontElementImpl*',
+'HTMLFormElement&' => 'kde_HTMLFormElement*',
+'HTMLFormElement' => 'kde_HTMLFormElement*',
+'HTMLFormElement*' => 'kde_HTMLFormElement*',
+'HTMLFormElementImpl*' => 'kde_HTMLFormElementImpl*',
+'HTMLFrameElement&' => 'kde_HTMLFrameElement*',
+'HTMLFrameElement*' => 'kde_HTMLFrameElement*',
+'HTMLFrameElementImpl*' => 'kde_HTMLFrameElementImpl*',
+'HTMLFrameSetElement&' => 'kde_HTMLFrameSetElement*',
+'HTMLFrameSetElement*' => 'kde_HTMLFrameSetElement*',
+'HTMLFrameSetElementImpl*' => 'kde_HTMLFrameSetElementImpl*',
+'HTMLHRElement&' => 'kde_HTMLHRElement*',
+'HTMLHRElement*' => 'kde_HTMLHRElement*',
+'HTMLHRElementImpl*' => 'kde_HTMLHRElementImpl*',
+'HTMLHeadElement&' => 'kde_HTMLHeadElement*',
+'HTMLHeadElement*' => 'kde_HTMLHeadElement*',
+'HTMLHeadElementImpl*' => 'kde_HTMLHeadElementImpl*',
+'HTMLHeadingElement&' => 'kde_HTMLHeadingElement*',
+'HTMLHeadingElement*' => 'kde_HTMLHeadingElement*',
+'HTMLHeadingElementImpl*' => 'kde_HTMLHeadingElementImpl*',
+'HTMLHtmlElement&' => 'kde_HTMLHtmlElement*',
+'HTMLHtmlElement*' => 'kde_HTMLHtmlElement*',
+'HTMLHtmlElementImpl*' => 'kde_HTMLHtmlElementImpl*',
+'HTMLIFrameElement&' => 'kde_HTMLIFrameElement*',
+'HTMLIFrameElement*' => 'kde_HTMLIFrameElement*',
+'HTMLIFrameElementImpl*' => 'kde_HTMLIFrameElementImpl*',
+'HTMLImageElement&' => 'kde_HTMLImageElement*',
+'HTMLImageElement*' => 'kde_HTMLImageElement*',
+'HTMLImageElementImpl*' => 'kde_HTMLImageElementImpl*',
+'HTMLInputElement&' => 'kde_HTMLInputElement*',
+'HTMLInputElement*' => 'kde_HTMLInputElement*',
+'HTMLInputElementImpl*' => 'kde_HTMLInputElementImpl*',
+'HTMLIsIndexElement&' => 'kde_HTMLIsIndexElement*',
+'HTMLIsIndexElement*' => 'kde_HTMLIsIndexElement*',
+'HTMLIsIndexElementImpl*' => 'kde_HTMLIsIndexElementImpl*',
+'HTMLLIElement&' => 'kde_HTMLLIElement*',
+'HTMLLIElement*' => 'kde_HTMLLIElement*',
+'HTMLLIElementImpl*' => 'kde_HTMLLIElementImpl*',
+'HTMLLabelElement&' => 'kde_HTMLLabelElement*',
+'HTMLLabelElement*' => 'kde_HTMLLabelElement*',
+'HTMLLabelElementImpl*' => 'kde_HTMLLabelElementImpl*',
+'HTMLLegendElement&' => 'kde_HTMLLegendElement*',
+'HTMLLegendElement*' => 'kde_HTMLLegendElement*',
+'HTMLLegendElementImpl*' => 'kde_HTMLLegendElementImpl*',
+'HTMLLinkElement&' => 'kde_HTMLLinkElement*',
+'HTMLLinkElement*' => 'kde_HTMLLinkElement*',
+'HTMLLinkElementImpl*' => 'kde_HTMLLinkElementImpl*',
+'HTMLMapElement&' => 'kde_HTMLMapElement*',
+'HTMLMapElement*' => 'kde_HTMLMapElement*',
+'HTMLMapElementImpl*' => 'kde_HTMLMapElementImpl*',
+'HTMLMenuElement&' => 'kde_HTMLMenuElement*',
+'HTMLMenuElement*' => 'kde_HTMLMenuElement*',
+'HTMLMenuElementImpl*' => 'kde_HTMLMenuElementImpl*',
+'HTMLMetaElement&' => 'kde_HTMLMetaElement*',
+'HTMLMetaElement*' => 'kde_HTMLMetaElement*',
+'HTMLMetaElementImpl*' => 'kde_HTMLMetaElementImpl*',
+'HTMLModElement&' => 'kde_HTMLModElement*',
+'HTMLModElement*' => 'kde_HTMLModElement*',
+'HTMLModElementImpl*' => 'kde_HTMLModElementImpl*',
+'HTMLOListElement&' => 'kde_HTMLOListElement*',
+'HTMLOListElement*' => 'kde_HTMLOListElement*',
+'HTMLOListElementImpl*' => 'kde_HTMLOListElementImpl*',
+'HTMLObjectElement&' => 'kde_HTMLObjectElement*',
+'HTMLObjectElement*' => 'kde_HTMLObjectElement*',
+'HTMLObjectElementImpl*' => 'kde_HTMLObjectElementImpl*',
+'HTMLOptGroupElement&' => 'kde_HTMLOptGroupElement*',
+'HTMLOptGroupElement*' => 'kde_HTMLOptGroupElement*',
+'HTMLOptGroupElementImpl*' => 'kde_HTMLOptGroupElementImpl*',
+'HTMLOptionElement&' => 'kde_HTMLOptionElement*',
+'HTMLOptionElement*' => 'kde_HTMLOptionElement*',
+'HTMLOptionElementImpl*' => 'kde_HTMLOptionElementImpl*',
+'HTMLParagraphElement&' => 'kde_HTMLParagraphElement*',
+'HTMLParagraphElement*' => 'kde_HTMLParagraphElement*',
+'HTMLParagraphElementImpl*' => 'kde_HTMLParagraphElementImpl*',
+'HTMLParamElement&' => 'kde_HTMLParamElement*',
+'HTMLParamElement*' => 'kde_HTMLParamElement*',
+'HTMLParamElementImpl*' => 'kde_HTMLParamElementImpl*',
+'HTMLPreElement&' => 'kde_HTMLPreElement*',
+'HTMLPreElement*' => 'kde_HTMLPreElement*',
+'HTMLPreElementImpl*' => 'kde_HTMLPreElementImpl*',
+'HTMLQuoteElement&' => 'kde_HTMLQuoteElement*',
+'HTMLQuoteElement*' => 'kde_HTMLQuoteElement*',
+'HTMLQuoteElementImpl*' => 'kde_HTMLQuoteElementImpl*',
+'HTMLScriptElement&' => 'kde_HTMLScriptElement*',
+'HTMLScriptElement*' => 'kde_HTMLScriptElement*',
+'HTMLScriptElementImpl*' => 'kde_HTMLScriptElementImpl*',
+'HTMLSelectElement&' => 'kde_HTMLSelectElement*',
+'HTMLSelectElement*' => 'kde_HTMLSelectElement*',
+'HTMLSelectElementImpl*' => 'kde_HTMLSelectElementImpl*',
+'HTMLStyleElement&' => 'kde_HTMLStyleElement*',
+'HTMLStyleElement*' => 'kde_HTMLStyleElement*',
+'HTMLStyleElementImpl*' => 'kde_HTMLStyleElementImpl*',
+'HTMLTableCaptionElement&' => 'kde_HTMLTableCaptionElement*',
+'HTMLTableCaptionElement' => 'kde_HTMLTableCaptionElement*',
+'HTMLTableCaptionElement*' => 'kde_HTMLTableCaptionElement*',
+'HTMLTableCaptionElementImpl*' => 'kde_HTMLTableCaptionElementImpl*',
+'HTMLTableCellElement&' => 'kde_HTMLTableCellElement*',
+'HTMLTableCellElement*' => 'kde_HTMLTableCellElement*',
+'HTMLTableCellElementImpl*' => 'kde_HTMLTableCellElementImpl*',
+'HTMLTableColElement&' => 'kde_HTMLTableColElement*',
+'HTMLTableColElement*' => 'kde_HTMLTableColElement*',
+'HTMLTableColElementImpl*' => 'kde_HTMLTableColElementImpl*',
+'HTMLTableElement&' => 'kde_HTMLTableElement*',
+'HTMLTableElement*' => 'kde_HTMLTableElement*',
+'HTMLTableElementImpl*' => 'kde_HTMLTableElementImpl*',
+'HTMLTableRowElement&' => 'kde_HTMLTableRowElement*',
+'HTMLTableRowElement*' => 'kde_HTMLTableRowElement*',
+'HTMLTableRowElementImpl*' => 'kde_HTMLTableRowElementImpl*',
+'HTMLTableSectionElement&' => 'kde_HTMLTableSectionElement*',
+'HTMLTableSectionElement' => 'kde_HTMLTableSectionElement*',
+'HTMLTableSectionElement*' => 'kde_HTMLTableSectionElement*',
+'HTMLTableSectionElementImpl*' => 'kde_HTMLTableSectionElementImpl*',
+'HTMLTextAreaElement&' => 'kde_HTMLTextAreaElement*',
+'HTMLTextAreaElement*' => 'kde_HTMLTextAreaElement*',
+'HTMLTextAreaElementImpl*' => 'kde_HTMLTextAreaElementImpl*',
+'HTMLTitleElement&' => 'kde_HTMLTitleElement*',
+'HTMLTitleElement*' => 'kde_HTMLTitleElement*',
+'HTMLTitleElementImpl*' => 'kde_HTMLTitleElementImpl*',
+'HTMLUListElement&' => 'kde_HTMLUListElement*',
+'HTMLUListElement*' => 'kde_HTMLUListElement*',
+'HTMLUListElementImpl*' => 'kde_HTMLUListElementImpl*',
+'HandlerType' => 'qt_HandlerType*' ,
+'HashEntry*' => 'kde_HashEntry*',
+'HashTable*' => 'kde_HashTable*',
+'Header&' => 'kde_Header*',
+'Header*' => 'kde_Header*',
+'HighlightingInterface*' => 'kde_HighlightingInterface*',
+'HistoryProvider*' => 'kde_HistoryProvider*',
+'HostImp*' => 'kde_HostImp*',
+'IDLFileReg*' => 'kde_IDLFileReg*',
+'IOManager*' => 'kde_IOManager*',
+'IONotify*' => 'kde_IONotify*',
+'IOType*' => 'kde_IOType*',
+'IOWatchFD*' => 'kde_IOWatchFD*',
+'Icon' => 'int',
+'IconListBox*' => 'kde_IconListBox*',
+'Imp*' => 'void*',
+'Info*' => 'kde_Info*',
+'InterfaceDef&' => 'kde_InterfaceDef*',
+'InterfaceDef' => 'kde_InterfaceDef*',
+'InterfaceDef*' => 'kde_InterfaceDef*',
+'InterfaceEntry*' => 'kde_InterfaceEntry*',
+'InterfaceRepo&' => 'kde_InterfaceRepo*',
+'InterfaceRepo' => 'kde_InterfaceRepo*',
+'InterfaceRepo*' => 'kde_InterfaceRepo*',
+'InterfaceRepo_base*' => 'kde_InterfaceRepo_base*',
+'InterfaceRepo_impl*' => 'kde_InterfaceRepo_impl*',
+'InterfaceRepo_skel*' => 'kde_InterfaceRepo_skel*',
+'InterfaceRepo_stub*' => 'kde_InterfaceRepo_stub*',
+'InternalFunctionImp*' => 'kde_InternalFunctionImp*',
+'Interpreter*' => 'kde_Interpreter*',
+'Invocation&' => 'kde_Invocation*',
+'Invocation*' => 'kde_Invocation*',
+'Iterator' => 'Iterator*' ,
+'Job*' => 'void*',
+'K&' => 'K*' ,
+'KAboutApplication*' => 'kde_KAboutApplication*',
+'KAboutContainer*' => 'kde_KAboutContainer*' ,
+'KAboutContributor*' => 'kde_KAboutContributor*',
+'KAboutData*' => 'kde_KAboutData*' ,
+'KAboutDialog*' => 'kde_KAboutDialog*',
+'KAboutKDE*' => 'kde_KAboutKDE*',
+'KAboutPerson*' => 'kde_KAboutPerson*',
+'KAboutTranslator*' => 'kde_KAboutTranslator*',
+'KAboutWidget*' => 'kde_KAboutWidget*',
+'KAccel*' => 'kde_KAccel*' ,
+'KAccelAction&' => 'kde_KAccelAction*',
+'KAccelAction*' => 'kde_KAccelAction*',
+'KAccelActions&' => 'kde_KAccelActions*',
+'KAccelActions*' => 'kde_KAccelActions*',
+'KAccelBase*' => 'kde_KAccelBase*',
+'KAccelGen*' => 'kde_KAccelGen*',
+'KAccelMenu*' => 'kde_KAccelMenu*',
+'KAccelSequence&' => 'kde_KAccelSequence*',
+'KAccelSequence' => 'kde_KAccelSequence*',
+'KAccelSequence*' => 'kde_KAccelSequence*',
+'KAccelShortcut&' => 'kde_KAccelShortcut*',
+'KAccelShortcut' => 'kde_KAccelShortcut*',
+'KAccelShortcut*' => 'kde_KAccelShortcut*',
+'KAccelShortcuts&' => 'kde_KAccelShortcuts*',
+'KAccelShortcuts*' => 'kde_KAccelShortcuts*',
+'KAction*' => 'kde_KAction*' ,
+'KActionCollection&' => 'kde_KActionCollection*' ,
+'KActionCollection' => 'kde_KActionCollection*' ,
+'KActionCollection*' => 'kde_KActionCollection*' ,
+'KActionMenu*' => 'kde_KActionMenu*',
+'KActionSeparator*' => 'kde_KActionSeparator*',
+'KAddressInfo*' => 'kde_KAddressInfo*',
+'KAlphaPainter*' => 'kde_KAlphaPainter*',
+'KAnimWidget*' => 'kde_KAnimWidget*' ,
+'KAppTreeListItem*' => 'kde_KAppTreeListItem*' ,
+'KApplication*' => 'kde_KApplication*' ,
+'KApplicationPropsPlugin*' => 'kde_KApplicationPropsPlugin*',
+'KApplicationTree*' => 'kde_KApplicationTree*',
+'KArchive*' => 'kde_KArchive*',
+'KArchiveDirectory*' => 'kde_KArchiveDirectory*',
+'KArchiveEntry*' => 'kde_KArchiveEntry*',
+'KArchiveFile*' => 'kde_KArchiveFile*',
+'KArrowButton*' => 'kde_KArrowButton*',
+'KArtsDispatcher*' => 'kde_KArtsDispatcher*',
+'KArtsFloatWatch*' => 'kde_KArtsFloatWatch*',
+'KAsyncIO*' => 'kde_KAsyncIO*',
+'KAudioPlayer*' => 'kde_KAudioPlayer*',
+'KAuthIcon*' => 'kde_KAuthIcon*',
+'KAutoMount*' => 'kde_KAutoMount*',
+'KAutoUnmount*' => 'kde_KAutoUnmount*',
+'KBindingPropsPlugin*' => 'kde_KBindingPropsPlugin*',
+'KBlankEffect*' => 'kde_KBlankEffect*',
+'KBufferedIO*' => 'kde_KBufferedIO*',
+'KBugReport*' => 'kde_KBugReport*',
+'KButtonBox*' => 'kde_KButtonBox*',
+'KCModule*' => 'kde_KCModule*' ,
+'KCatalogue&' => 'kde_KCatalogue*',
+'KCatalogue*' => 'kde_KCatalogue*',
+'KCharSelect*' => 'kde_KCharSelect*',
+'KCharSelectTable*' => 'kde_KCharSelectTable*',
+'KCharsets*' => 'kde_KCharsets*' ,
+'KCmdLineArgs*' => 'kde_KCmdLineArgs*' ,
+'KCmdLineOptions*' => 'kde_KCmdLineOptions*' ,
+'KCodecs*' => 'kde_KCodecs*',
+'KColor&' => 'kde_KColor*' ,
+'KColor*' => 'kde_KColor*',
+'KColorButton*' => 'kde_KColorButton*',
+'KColorCells*' => 'kde_KColorCells*',
+'KColorCombo*' => 'kde_KColorCombo*',
+'KColorDialog*' => 'kde_KColorDialog*',
+'KColorDrag*' => 'kde_KColorDrag*' ,
+'KColorPatch*' => 'kde_KColorPatch*',
+'KCombiView*' => 'kde_KCombiView*',
+'KComboBox*' => 'kde_KComboBox*' ,
+'KCommand*' => 'kde_KCommand*',
+'KCommandHistory*' => 'kde_KCommandHistory*',
+'KCompletion*' => 'kde_KCompletion*' ,
+'KCompletionBase*' => 'kde_KCompletionBase*',
+'KCompletionBase::KeyBindingType' => 'kde_KCompletionBase_KeyBindingType*' ,
+'KCompletionBox*' => 'kde_KCompletionBox*',
+'KConfig*' => 'kde_KConfig*' ,
+'KConfigBackEnd*' => 'kde_KConfigBackEnd*',
+'KConfigBase&' => 'kde_KConfigBase*',
+'KConfigBase*' => 'kde_KConfigBase*' ,
+'KConfigBase::ConfigState' => 'kde_KConfigBase_ConfigState' ,
+'KConfigGroup*' => 'kde_KConfigGroup*',
+'KConfigGroupSaver*' => 'kde_KConfigGroupSaver*',
+'KConfigINIBackEnd*' => 'kde_KConfigINIBackEnd*',
+'KContainerLayout*' => 'kde_KContainerLayout*',
+'KContainerLayoutItem*' => 'kde_KContainerLayoutItem*' ,
+'KContextMenuManager*' => 'kde_KContextMenuManager*',
+'KCookie*' => 'kde_KCookie*',
+'KCrash*' => 'kde_KCrash*',
+'KCursor*' => 'kde_KCursor*',
+'KDBGFUNC' => 'void *' ,
+'KDCOPActionProxy*' => 'kde_KDCOPActionProxy*',
+'KDCOPPropertyProxy*' => 'kde_KDCOPPropertyProxy*',
+'KDEAniMenu*' => 'kde_KDEAniMenu*',
+'KDEDModule*' => 'kde_KDEDModule*',
+'KDEDesktopMimeType*' => 'kde_KDEDesktopMimeType*',
+'KDEDesktopMimeType::Service&' => 'kde_KDEDesktopMimeType_Service*' ,
+'KDESasl*' => 'kde_KDESasl*',
+'KDEStyle*' => 'kde_KDEStyle*',
+'KDEsuClient*' => 'kde_KDEsuClient*',
+'KDataTool*' => 'kde_KDataTool*',
+'KDataToolAction*' => 'kde_KDataToolAction*',
+'KDataToolInfo&' => 'kde_KDataToolInfo*',
+'KDataToolInfo*' => 'kde_KDataToolInfo*',
+'KDateInternalMonthPicker*' => 'kde_KDateInternalMonthPicker*',
+'KDateInternalYearSelector*' => 'kde_KDateInternalYearSelector*',
+'KDatePicker*' => 'kde_KDatePicker*',
+'KDateTable*' => 'kde_KDateTable*',
+'KDateValidator*' => 'kde_KDateValidator*',
+'KDateWidget*' => 'kde_KDateWidget*',
+'KDesktopFile*' => 'kde_KDesktopFile*' ,
+'KDevApi*' => 'kde_KDevApi*',
+'KDevAppFrontend*' => 'kde_KDevAppFrontend*',
+'KDevCompilerOptions*' => 'kde_KDevCompilerOptions*',
+'KDevCore*' => 'kde_KDevCore*',
+'KDevFactory*' => 'kde_KDevFactory*',
+'KDevLanguageSupport*' => 'kde_KDevLanguageSupport*',
+'KDevMakeFrontend*' => 'kde_KDevMakeFrontend*',
+'KDevPart*' => 'kde_KDevPart*',
+'KDevProject*' => 'kde_KDevProject*',
+'KDevVersionControl*' => 'kde_KDevVersionControl*',
+'KDevicePropsPlugin*' => 'kde_KDevicePropsPlugin*',
+'KDialog*' => 'kde_KDialog*',
+'KDialogBase*' => 'kde_KDialogBase*' ,
+'KDialogBaseTile*' => 'kde_KDialogBaseTile*',
+'KDialogQueue*' => 'kde_KDialogQueue*',
+'KDirLister*' => 'kde_KDirLister*',
+'KDirNotify*' => 'kde_KDirNotify*',
+'KDirNotify_stub*' => 'kde_KDirNotify_stub*',
+'KDirOperator*' => 'kde_KDirOperator*',
+'KDirSelectDialog*' => 'kde_KDirSelectDialog*',
+'KDirSize*' => 'kde_KDirSize*' ,
+'KDirWatch*' => 'kde_KDirWatch*' ,
+'KDirectionButton*' => 'kde_KDirectionButton*',
+'KDockArea*' => 'kde_KDockArea*',
+'KDockMainWindow*' => 'kde_KDockMainWindow*',
+'KDockManager*' => 'kde_KDockManager*' ,
+'KDockTabBar*' => 'kde_KDockTabBar*',
+'KDockTabBar::TabPos' => 'int',
+'KDockTabBarPainter*' => 'kde_KDockTabBarPainter*',
+'KDockTabCtl*' => 'kde_KDockTabCtl*',
+'KDockTabCtl_PrivateStruct*' => 'kde_KDockTabCtl_PrivateStruct*' ,
+'KDockTabGroup*' => 'kde_KDockTabGroup*' ,
+'KDockWidget*' => 'kde_KDockWidget*' ,
+'KDockWidgetAbstractHeader*' => 'kde_KDockWidgetAbstractHeader*' ,
+'KDockWidgetAbstractHeaderDrag*' => 'kde_KDockWidgetAbstractHeaderDrag*',
+'KDockWidgetHeader*' => 'kde_KDockWidgetHeader*',
+'KDockWidgetHeaderDrag*' => 'kde_KDockWidgetHeaderDrag*',
+'KDockWindow*' => 'kde_KDockWindow*',
+'KDoubleNumInput*' => 'kde_KDoubleNumInput*',
+'KDualColorButton*' => 'kde_KDualColorButton*',
+'KEMailSettings*' => 'kde_KEMailSettings*',
+'KEdFind*' => 'kde_KEdFind*',
+'KEdGotoLine*' => 'kde_KEdGotoLine*',
+'KEdReplace*' => 'kde_KEdReplace*',
+'KEdit*' => 'kde_KEdit*',
+'KEditListBox*' => 'kde_KEditListBox*',
+'KEditToolbar*' => 'kde_KEditToolbar*',
+'KEditToolbarWidget*' => 'kde_KEditToolbarWidget*',
+'KEntry&' => 'kde_KEntry*' ,
+'KEntry' => 'kde_KEntry*' ,
+'KEntry*' => 'kde_KEntry*',
+'KEntryKey&' => 'kde_KEntryKey*' ,
+'KEntryKey*' => 'kde_KEntryKey*',
+'KEntryMap' => 'kde_KEntryMap*' ,
+'KEntryMap*' => 'kde_KEntryMap*' ,
+'KExecMimeType*' => 'kde_KExecMimeType*',
+'KExecPropsPlugin*' => 'kde_KExecPropsPlugin*',
+'KExtendedSocket*' => 'kde_KExtendedSocket*',
+'KFile*' => 'kde_KFile*',
+'KFile::FileView' => 'int' ,
+'KFile::Mode' => 'int' ,
+'KFile::SelectionMode' => 'int' ,
+'KFileBookmark*' => 'kde_KFileBookmark*' ,
+'KFileBookmarkManager*' => 'kde_KFileBookmarkManager*',
+'KFileComboBox*' => 'kde_KFileComboBox*',
+'KFileDetailView*' => 'kde_KFileDetailView*',
+'KFileDialog*' => 'kde_KFileDialog*' ,
+'KFileFilter*' => 'kde_KFileFilter*',
+'KFileFilterCombo*' => 'kde_KFileFilterCombo*',
+'KFileIconView*' => 'kde_KFileIconView*',
+'KFileIconViewItem*' => 'kde_KFileIconViewItem*',
+'KFileItem&' => 'kde_KFileItem*',
+'KFileItem*' => 'kde_KFileItem*' ,
+'KFileItemList&' => 'kde_KFileItemList*' ,
+'KFileItemList' => 'kde_KFileItemList*' ,
+'KFileItemList*' => 'kde_KFileItemList*' ,
+'KFileListViewItem*' => 'kde_KFileListViewItem*',
+'KFileMetaInfo*' => 'kde_KFileMetaInfo*',
+'KFileMetaInfoItem*' => 'kde_KFileMetaInfoItem*',
+'KFileMetaInfoProvider*' => 'kde_KFileMetaInfoProvider*',
+'KFileOpenWithHandler*' => 'kde_KFileOpenWithHandler*',
+'KFilePermissionsPropsPlugin*' => 'kde_KFilePermissionsPropsPlugin*',
+'KFilePlugin*' => 'kde_KFilePlugin*',
+'KFilePreview*' => 'kde_KFilePreview*',
+'KFilePropsPlugin*' => 'kde_KFilePropsPlugin*',
+'KFileReader*' => 'kde_KFileReader*' ,
+'KFileTreeBranch*' => 'kde_KFileTreeBranch*',
+'KFileTreeView*' => 'kde_KFileTreeView*',
+'KFileTreeViewItem*' => 'kde_KFileTreeViewItem*',
+'KFileTreeViewToolTip*' => 'kde_KFileTreeViewToolTip*',
+'KFileView*' => 'kde_KFileView*' ,
+'KFileView::FileView' => 'int',
+'KFileViewItem&' => 'kde_KFileViewItem*',
+'KFileViewItem*' => 'kde_KFileViewItem*' ,
+'KFileViewItem**' => 'kde_KFileViewItem**' ,
+'KFileViewItemList&' => 'kde_KFileViewItemList*' ,
+'KFileViewItemList*' => 'kde_KFileViewItemList*' ,
+'KFileViewSignaler*' => 'kde_KFileViewSignaler*',
+'KFilterBase*' => 'kde_KFilterBase*',
+'KFilterDev*' => 'kde_KFilterDev*',
+'KFloatValidator*' => 'kde_KFloatValidator*',
+'KFloatWatchProxy&' => 'kde_KFloatWatchProxy*',
+'KFloatWatchProxy' => 'kde_KFloatWatchProxy*',
+'KFloatWatchProxy*' => 'kde_KFloatWatchProxy*',
+'KFolderType*' => 'kde_KFolderType*',
+'KFontAction*' => 'kde_KFontAction*',
+'KFontChooser*' => 'kde_KFontChooser*',
+'KFontCombo*' => 'kde_KFontCombo*',
+'KFontDialog*' => 'kde_KFontDialog*',
+'KFontSizeAction*' => 'kde_KFontSizeAction*',
+'KGenericFactory*' => 'kde_KGenericFactory*',
+'KGenericFactoryBase*' => 'kde_KGenericFactoryBase*',
+'KGlobal*' => 'kde_KGlobal*',
+'KGlobalAccel*' => 'kde_KGlobalAccel*' ,
+'KGlobalSettings*' => 'kde_KGlobalSettings*',
+'KGlobalSettings::Completion' => 'int' ,
+'KGradientSelector*' => 'kde_KGradientSelector*',
+'KGuiItem&' => 'kde_KGuiItem*',
+'KGuiItem' => 'kde_KGuiItem*',
+'KGuiItem*' => 'kde_KGuiItem*',
+'KHSSelector*' => 'kde_KHSSelector*',
+'KHTMLPart*' => 'kde_KHTMLPart*' ,
+'KHTMLSettings&' => 'kde_KHTMLSettings*',
+'KHTMLSettings*' => 'kde_KHTMLSettings*' ,
+'KHTMLView*' => 'kde_KHTMLView*' ,
+'KHelpMenu*' => 'kde_KHelpMenu*',
+'KHistoryCombo*' => 'kde_KHistoryCombo*',
+'KIO*' => 'kde_KIO*',
+'KIO::AuthInfo&' => 'kde_AuthInfo*',
+'KIO::CopyJob*' => 'kde_CopyJob*' ,
+'KIO::DeleteJob*' => 'kde_DeleteJob*' ,
+'KIO::Job*' => 'kde_Job*' ,
+'KIO::ListJob*' => 'kde_ListJob*' ,
+'KIO::MetaData&' => 'kde_MetaData*',
+'KIO::RenameDlg_Mode' => 'int',
+'KIO::RenameDlg_Result' => 'int',
+'KIO::SimpleJob*' => 'kde_SimpleJob*',
+'KIO::SkipDlg_Result' => 'int',
+'KIO::Slave*' => 'kde_Slave*',
+'KIO::UDSEntry&' => 'kde_UDSEntry*' ,
+'KIO::UDSEntryList&' => 'kde_UDSEntryList*' ,
+'KIOInputStream&' => 'kde_KIOInputStream*',
+'KIOInputStream*' => 'kde_KIOInputStream*',
+'KIOTestSlow&' => 'kde_KIOTestSlow*',
+'KIOTestSlow' => 'kde_KIOTestSlow*',
+'KIOTestSlow*' => 'kde_KIOTestSlow*',
+'KIPC*' => 'kde_KIPC*',
+'KIcon' => 'kde_KIcon*' ,
+'KIcon*' => 'kde_KIcon*',
+'KIconButton*' => 'kde_KIconButton*',
+'KIconCanvas*' => 'kde_KIconCanvas*',
+'KIconDialog*' => 'kde_KIconDialog*',
+'KIconEffect*' => 'kde_KIconEffect*' ,
+'KIconLoader*' => 'kde_KIconLoader*' ,
+'KIconSelectAction*' => 'kde_KIconSelectAction*',
+'KIconTheme*' => 'kde_KIconTheme*' ,
+'KIconView*' => 'kde_KIconView*',
+'KIconViewItem*' => 'kde_KIconViewItem*',
+'KImageEffect*' => 'kde_KImageEffect*',
+'KImageFilePreview*' => 'kde_KImageFilePreview*',
+'KImageIO*' => 'kde_KImageIO*',
+'KInetSocketAddress&' => 'kde_KInetSocketAddress*',
+'KInetSocketAddress*' => 'kde_KInetSocketAddress*',
+'KInstance&' => 'kde_KInstance*' ,
+'KInstance' => 'kde_KInstance*' ,
+'KInstance*' => 'kde_KInstance*' ,
+'KIntNumInput*' => 'kde_KIntNumInput*',
+'KIntSpinBox*' => 'kde_KIntSpinBox*',
+'KIntValidator*' => 'kde_KIntValidator*',
+'KJS*' => 'kde_KJS*',
+'KJS::KJSO&' => 'kde_KJS_KJSO*',
+'KJS::UString&' => 'kde_KJS_UString*',
+'KJSO&' => 'kde_KJSO*',
+'KJSO' => 'kde_KJSO*',
+'KJSO*' => 'kde_KJSO*',
+'KJScript*' => 'kde_KJScript*',
+'KJanusWidget*' => 'kde_KJanusWidget*',
+'KJavaApplet*' => 'kde_KJavaApplet*' ,
+'KJavaAppletContext*' => 'kde_KJavaAppletContext*' ,
+'KJavaAppletServer*' => 'kde_KJavaAppletServer*' ,
+'KJavaAppletWidget*' => 'kde_KJavaAppletWidget*',
+'KJavaProcess*' => 'kde_KJavaProcess*',
+'KJavaScriptAdvice&' => 'kde_KJavaScriptAdvice*' ,
+'KKeyChooser*' => 'kde_KKeyChooser*',
+'KKeyChooserItem*' => 'kde_KKeyChooserItem*',
+'KKeyDialog*' => 'kde_KKeyDialog*',
+'KKeyEntry&' => 'kde_KKeyEntry*' ,
+'KKeyEntry*' => 'kde_KKeyEntry*',
+'KKeyEntryMap&' => 'kde_KKeyEntryMap*' ,
+'KKeyEntryMap' => 'kde_KKeyEntryMap*' ,
+'KKeyEntryMap*' => 'kde_KKeyEntryMap*' ,
+'KKeySequence&' => 'kde_KKeySequence*',
+'KKeySequence' => 'kde_KKeySequence*',
+'KKeySequence*' => 'kde_KKeySequence*',
+'KKeySequence::I18N' => 'int',
+'KKeySequences&' => 'kde_KKeySequences*',
+'KKeySequences' => 'kde_KKeySequences*',
+'KKeySequences*' => 'kde_KKeySequences*',
+'KLed*' => 'kde_KLed*',
+'KLibFactory*' => 'kde_KLibFactory*' ,
+'KLibLoader*' => 'kde_KLibLoader*' ,
+'KLibrary*' => 'kde_KLibrary*' ,
+'KLineEdit*' => 'kde_KLineEdit*' ,
+'KLineEditDlg*' => 'kde_KLineEditDlg*',
+'KListAction*' => 'kde_KListAction*',
+'KListBox*' => 'kde_KListBox*',
+'KListView*' => 'kde_KListView*' ,
+'KListViewItem*' => 'kde_KListViewItem*',
+'KLocale&' => 'kde_KLocale*' ,
+'KLocale*' => 'kde_KLocale*' ,
+'KMJobViewer*' => 'kde_KMJobViewer*',
+'KMMainView*' => 'kde_KMMainView*',
+'KMManager*' => 'kde_KMManager*',
+'KMObject*' => 'kde_KMObject*',
+'KMPrinter&' => 'kde_KMPrinter*',
+'KMPrinter*' => 'kde_KMPrinter*',
+'KMPrinterList*' => 'kde_KMPrinterList*',
+'KMPrinterPage*' => 'kde_KMPrinterPage*',
+'KMacroCommand*' => 'kde_KMacroCommand*',
+'KMainWindow*' => 'kde_KMainWindow*',
+'KMainWindowInterface*' => 'kde_KMainWindowInterface*',
+'KMenuBar*' => 'kde_KMenuBar*' ,
+'KMessageBox*' => 'kde_KMessageBox*',
+'KMidSimpleAPI*' => 'kde_KMidSimpleAPI*',
+'KMimeMagic*' => 'kde_KMimeMagic*' ,
+'KMimeMagicResult*' => 'kde_KMimeMagicResult*' ,
+'KMimeSourceFactory*' => 'kde_KMimeSourceFactory*' ,
+'KMimeType*' => 'kde_KMimeType*',
+'KMimeType::List&' => 'kde_KMimeType_List*' ,
+'KMimeType::Ptr&' => 'kde_KMimeType_Ptr*' ,
+'KMimeType::Ptr' => 'kde_KMimeType_Ptr' ,
+'KMouseSettings*' => 'kde_KMouseSettings*',
+'KMultipleDrag*' => 'kde_KMultipleDrag*',
+'KNDBGFUNC' => 'void *' ,
+'KNotifyClient*' => 'kde_KNotifyClient*',
+'KNumInput*' => 'kde_KNumInput*' ,
+'KOCRDialog*' => 'kde_KOCRDialog*',
+'KOCRDialogFactory*' => 'kde_KOCRDialogFactory*',
+'KOpenSSLProxy*' => 'kde_KOpenSSLProxy*',
+'KOpenWithDlg*' => 'kde_KOpenWithDlg*',
+'KOpenWithHandler*' => 'kde_KOpenWithHandler*' ,
+'KPAC*' => 'kde_KPAC*',
+'KPReloadObject*' => 'kde_KPReloadObject*',
+'KPalette&' => 'kde_KPalette*' ,
+'KPalette*' => 'kde_KPalette*',
+'KPaletteTable*' => 'kde_KPaletteTable*',
+'KPanelAppMenu*' => 'kde_KPanelAppMenu*',
+'KPanelApplet*' => 'kde_KPanelApplet*',
+'KPanelExtension*' => 'kde_KPanelExtension*',
+'KPanelMenu*' => 'kde_KPanelMenu*' ,
+'KParts*' => 'kde_KParts*',
+'KParts::BrowserExtension*' => 'kde_BrowserExtension*' ,
+'KParts::GUIActivateEvent*' => 'kde_GUIActivateEvent*' ,
+'KParts::Part*' => 'kde_Part*',
+'KParts::PartManager*' => 'kde_PartManager*' ,
+'KParts::ReadOnlyPart*' => 'kde_ReadOnlyPart*' ,
+'KParts::URLArgs&' => 'kde_URLArgs*' ,
+'KParts::URLArgs' => 'kde_URLArgs*',
+'KPasswordDialog*' => 'kde_KPasswordDialog*',
+'KPasswordEdit*' => 'kde_KPasswordEdit*',
+'KPixmap&' => 'kde_KPixmap*' ,
+'KPixmap' => 'kde_KPixmap*' ,
+'KPixmap*' => 'kde_KPixmap*',
+'KPixmapEffect*' => 'kde_KPixmapEffect*',
+'KPixmapIO*' => 'kde_KPixmapIO*',
+'KPixmapProvider*' => 'kde_KPixmapProvider*' ,
+'KPixmapSplitter*' => 'kde_KPixmapSplitter*',
+'KPlayObject*' => 'kde_KPlayObject*',
+'KPlayObjectFactory*' => 'kde_KPlayObjectFactory*',
+'KPopupFrame*' => 'kde_KPopupFrame*',
+'KPopupMenu*' => 'kde_KPopupMenu*' ,
+'KPopupTitle*' => 'kde_KPopupTitle*',
+'KPreviewWidgetBase*' => 'kde_KPreviewWidgetBase*',
+'KPrintAction*' => 'kde_KPrintAction*',
+'KPrintDialogPage*' => 'kde_KPrintDialogPage*',
+'KPrinter*' => 'kde_KPrinter*',
+'KPrinterWrapper*' => 'kde_KPrinterWrapper*',
+'KProcIO*' => 'kde_KProcIO*' ,
+'KProcess&' => 'kde_KProcess*' ,
+'KProcess*' => 'kde_KProcess*' ,
+'KProcessController*' => 'kde_KProcessController*',
+'KProcessRunner*' => 'kde_KProcessRunner*',
+'KProgress*' => 'kde_KProgress*',
+'KPropertiesDialog*' => 'kde_KPropertiesDialog*' ,
+'KPropsDlgPlugin*' => 'kde_KPropsDlgPlugin*' ,
+'KProtocolInfo*' => 'kde_KProtocolInfo*',
+'KProtocolManager*' => 'kde_KProtocolManager*',
+'KPushButton*' => 'kde_KPushButton*',
+'KRFCDate*' => 'kde_KRFCDate*',
+'KRadioAction*' => 'kde_KRadioAction*',
+'KRandomSequence*' => 'kde_KRandomSequence*',
+'KRecentDocument*' => 'kde_KRecentDocument*',
+'KRecentFilesAction*' => 'kde_KRecentFilesAction*' ,
+'KRegExp*' => 'kde_KRegExp*',
+'KRegExpEditor*' => 'kde_KRegExpEditor*',
+'KRegExpEditorInterface*' => 'kde_KRegExpEditorInterface*',
+'KRestrictedLine*' => 'kde_KRestrictedLine*',
+'KRootPermsIcon*' => 'kde_KRootPermsIcon*',
+'KRootPixmap*' => 'kde_KRootPixmap*',
+'KRootProp*' => 'kde_KRootProp*',
+'KRuler*' => 'kde_KRuler*',
+'KRun*' => 'kde_KRun*',
+'KSSL&' => 'kde_KSSL*',
+'KSSL*' => 'kde_KSSL*',
+'KSSLAuthAction' => 'int',
+'KSSLAuthAction*' => 'int*',
+'KSSLCertBox*' => 'kde_KSSLCertBox*',
+'KSSLCertChain&' => 'kde_KSSLCertChain*',
+'KSSLCertChain*' => 'kde_KSSLCertChain*',
+'KSSLCertDlg*' => 'kde_KSSLCertDlg*',
+'KSSLCertDlgRet' => 'kde_KSSLCertDlgRet*',
+'KSSLCertDlgRet*' => 'kde_KSSLCertDlgRet*',
+'KSSLCertificate&' => 'kde_KSSLCertificate*',
+'KSSLCertificate*' => 'kde_KSSLCertificate*',
+'KSSLCertificateCache*' => 'kde_KSSLCertificateCache*',
+'KSSLCertificateFactory*' => 'kde_KSSLCertificateFactory*',
+'KSSLCertificateHome*' => 'kde_KSSLCertificateHome*',
+'KSSLConnectionInfo&' => 'kde_KSSLConnectionInfo*',
+'KSSLConnectionInfo*' => 'kde_KSSLConnectionInfo*',
+'KSSLInfoDlg*' => 'kde_KSSLInfoDlg*',
+'KSSLKeyGen*' => 'kde_KSSLKeyGen*',
+'KSSLKeyType' => 'kde_KSSLKeyType',
+'KSSLPKCS12*' => 'kde_KSSLPKCS12*',
+'KSSLPKCS7*' => 'kde_KSSLPKCS7*',
+'KSSLPeerInfo&' => 'kde_KSSLPeerInfo*',
+'KSSLPeerInfo*' => 'kde_KSSLPeerInfo*',
+'KSSLSettings*' => 'kde_KSSLSettings*',
+'KSSLSigners*' => 'kde_KSSLSigners*',
+'KSSLX509Map*' => 'kde_KSSLX509Map*',
+'KSSLX509V3&' => 'kde_KSSLX509V3*',
+'KSSLX509V3*' => 'kde_KSSLX509V3*',
+'KSaveFile*' => 'kde_KSaveFile*',
+'KScanDialog*' => 'kde_KScanDialog*',
+'KScanDialogFactory*' => 'kde_KScanDialogFactory*',
+'KScreenSaver*' => 'kde_KScreenSaver*',
+'KScriptClientInterface*' => 'kde_KScriptClientInterface*',
+'KScriptClientInterface::Result' => 'int',
+'KScriptInterface*' => 'kde_KScriptInterface*',
+'KScriptManager*' => 'kde_KScriptManager*',
+'KSelectAction*' => 'kde_KSelectAction*',
+'KSelector*' => 'kde_KSelector*',
+'KSeparator*' => 'kde_KSeparator*',
+'KServerSocket*' => 'kde_KServerSocket*',
+'KService&' => 'kde_KService*' ,
+'KService*' => 'kde_KService*',
+'KService::List' => 'kde_KService_List*' ,
+'KService::Ptr' => 'kde_KService_Ptr*' ,
+'KServiceGroup*' => 'kde_KServiceGroup*',
+'KServiceOffer&' => 'kde_KServiceOffer*' ,
+'KServiceOffer*' => 'kde_KServiceOffer*',
+'KServiceType*' => 'kde_KServiceType*',
+'KServiceTypeProfile*' => 'kde_KServiceTypeProfile*' ,
+'KSessionManaged*' => 'kde_KSessionManaged*',
+'KShared&' => 'kde_KShared*' ,
+'KShared*' => 'kde_KShared*',
+'KSharedPixmap*' => 'kde_KSharedPixmap*',
+'KSharedPtr&' => 'kde_KSharedPtr*' ,
+'KSharedPtr*' => 'kde_KSharedPtr*',
+'KShellCompletion*' => 'kde_KShellCompletion*',
+'KShellProcess*' => 'kde_KShellProcess*',
+'KShortcuts&' => 'kde_KShortcuts*',
+'KShortcuts' => 'kde_KShortcuts*',
+'KShortcuts*' => 'kde_KShortcuts*',
+'KShred*' => 'kde_KShred*',
+'KSimpleConfig&' => 'kde_KSimpleConfig*' ,
+'KSimpleConfig*' => 'kde_KSimpleConfig*',
+'KSimpleFileFilter*' => 'kde_KSimpleFileFilter*',
+'KSocket*' => 'kde_KSocket*',
+'KSocketAddress&' => 'kde_KSocketAddress*',
+'KSocketAddress*' => 'kde_KSocketAddress*',
+'KSocks*' => 'kde_KSocks*',
+'KSpell*' => 'kde_KSpell*',
+'KSpellConfig&' => 'kde_KSpellConfig*' ,
+'KSpellConfig' => 'kde_KSpellConfig*' ,
+'KSpellConfig*' => 'kde_KSpellConfig*' ,
+'KSpellDlg*' => 'kde_KSpellDlg*',
+'KSqueezedTextLabel*' => 'kde_KSqueezedTextLabel*',
+'KStandardDirs*' => 'kde_KStandardDirs*' ,
+'KStartupInfo*' => 'kde_KStartupInfo*',
+'KStartupInfoData&' => 'kde_KStartupInfoData*',
+'KStartupInfoData*' => 'kde_KStartupInfoData*',
+'KStartupInfoId&' => 'kde_KStartupInfoId*',
+'KStartupInfoId' => 'kde_KStartupInfoId*',
+'KStartupInfoId*' => 'kde_KStartupInfoId*',
+'KStaticDeleter*' => 'kde_KStaticDeleter*',
+'KStaticDeleterBase*' => 'kde_KStaticDeleterBase*' ,
+'KStatusBar*' => 'kde_KStatusBar*' ,
+'KStatusBar::BarStatusstat::Toggle' => 'int' ,
+'KStatusBarLabel*' => 'kde_KStatusBarLabel*',
+'KStdAccel*' => 'kde_KStdAccel*',
+'KStdAccel::StdAccel' => 'int' ,
+'KStdAction*' => 'kde_KStdAction*',
+'KStdGuiItem*' => 'kde_KStdGuiItem*',
+'KStringHandler*' => 'kde_KStringHandler*',
+'KStyle*' => 'kde_KStyle*' ,
+'KSycoca*' => 'kde_KSycoca*' ,
+'KSycocaEntry*' => 'kde_KSycocaEntry*' ,
+'KSycocaFactory*' => 'kde_KSycocaFactory*' ,
+'KSycocaFactoryId' => 'kde_KSycocaFactoryId' ,
+'KSycocaType&' => 'kde_KSycocaType*' ,
+'KSycocaType' => 'kde_KSycocaType*' ,
+'KSystemTray*' => 'kde_KSystemTray*',
+'KTMainWindow*' => 'kde_KTMainWindow*',
+'KTabButton*' => 'kde_KTabButton*',
+'KTabCtl*' => 'kde_KTabCtl*',
+'KTar*' => 'kde_KTar*',
+'KTarBase*' => 'kde_KTarBase*' ,
+'KTarData*' => 'kde_KTarData*',
+'KTarDirectory*' => 'kde_KTarDirectory*' ,
+'KTarEntry*' => 'kde_KTarEntry*' ,
+'KTarFile*' => 'kde_KTarFile*',
+'KTarGz*' => 'kde_KTarGz*',
+'KTempFile*' => 'kde_KTempFile*',
+'KTextBrowser*' => 'kde_KTextBrowser*',
+'KTextEditor*' => 'kde_KTextEditor*',
+'KTextEditor__View&' => 'kde_KTextEditor__View*',
+'KTextEditor__View' => 'kde_KTextEditor__View*',
+'KTextEditor__View*' => 'kde_KTextEditor__View*',
+'KThemeBase*' => 'kde_KThemeBase*', ,
+'KThemeCache*' => 'kde_KThemeCache*',
+'KThemePixmap&' => 'kde_KThemePixmap*' ,
+'KThemePixmap*' => 'kde_KThemePixmap*' ,
+'KThemeStyle*' => 'kde_KThemeStyle*',
+'KTipDatabase*' => 'kde_KTipDatabase*',
+'KTipDialog*' => 'kde_KTipDialog*',
+'KToggleAction*' => 'kde_KToggleAction*' ,
+'KToolBar*' => 'kde_KToolBar*' ,
+'KToolBar::BarStatus' => 'int',
+'KToolBar::BarStatusstat::Toggle' => 'int' ,
+'KToolBarButton*' => 'kde_KToolBarButton*' ,
+'KToolBarButtonList*' => 'kde_KToolBarButtonList*',
+'KToolBarPopupAction*' => 'kde_KToolBarPopupAction*',
+'KToolBarPos' => 'int' ,
+'KToolBarRadioGroup*' => 'kde_KToolBarRadioGroup*',
+'KToolBarSeparator*' => 'kde_KToolBarSeparator*',
+'KToolButtonType' => 'int' ,
+'KTrader*' => 'kde_KTrader*' ,
+'KTypeList*' => 'kde_KTypeList*',
+'KURIFilter*' => 'kde_KURIFilter*' ,
+'KURIFilterData&' => 'kde_KURIFilterData*' ,
+'KURIFilterData*' => 'kde_KURIFilterData*',
+'KURIFilterPlugin*' => 'kde_KURIFilterPlugin*',
+'KURIFilterPluginList*' => 'kde_KURIFilterPluginList*',
+'KURL& url ()' => 'kde_KURL*',
+'KURL& urlName ()' => 'kde_KURL*',
+'KURL&' => 'kde_KURL*' ,
+'KURL' => 'kde_KURL*' ,
+'KURL*' => 'kde_KURL*',
+'KURL::List&' => 'kde_KURLList*' ,
+'KURL::List' => 'kde_KURLList*' ,
+'KURLComboBox*' => 'kde_KURLComboBox*',
+'KURLComboItem*' => 'kde_KURLComboItem*' ,
+'KURLCompletion*' => 'kde_KURLCompletion*',
+'KURLDrag*' => 'kde_KURLDrag*',
+'KURLLabel*' => 'kde_KURLLabel*',
+'KURLPixmapProvider*' => 'kde_KURLPixmapProvider*',
+'KURLPropsPlugin*' => 'kde_KURLPropsPlugin*',
+'KURLRequester*' => 'kde_KURLRequester*',
+'KURLRequesterDlg*' => 'kde_KURLRequesterDlg*',
+'KUniqueApplication*' => 'kde_KUniqueApplication*',
+'KUnixSocketAddress*' => 'kde_KUnixSocketAddress*',
+'KValueSelector*' => 'kde_KValueSelector*',
+'KWin*' => 'kde_KWin*',
+'KWinModule*' => 'kde_KWinModule*',
+'KWindowListMenu*' => 'kde_KWindowListMenu*',
+'KWizard*' => 'kde_KWizard*',
+'KWordWrap*' => 'kde_KWordWrap*',
+'KWritePermsIcon*' => 'kde_KWritePermsIcon*',
+'KXMLGUIBuilder*' => 'kde_KXMLGUIBuilder*' ,
+'KXMLGUIClient*' => 'kde_KXMLGUIClient*' ,
+'KXMLGUIFactory*' => 'kde_KXMLGUIFactory*' ,
+'KXMessages*' => 'kde_KXMessages*',
+'KXYSelector*' => 'kde_KXYSelector*',
+'KZoneAllocator*' => 'kde_KZoneAllocator*',
+'KabAPI*' => 'kde_KabAPI*',
+'KabKey&' => 'kde_KabKey*' ,
+'KabKey' => 'kde_KabKey*' ,
+'KabKey*' => 'kde_KabKey*',
+'Key&' => 'Key*' ,
+'KeyBindingMap' => 'kde_KeyBindingMap*' ,
+'KeyValueMap&' => 'kde_KeyValueMap*' ,
+'KeyValueMap*&' => 'kde_KeyValueMap*' ,
+'KeyValueMap*' => 'kde_KeyValueMap*' ,
+'Keymap*' => 'kde_Keymap*',
+'LinkStyle&' => 'kde_LinkStyle*',
+'LinkStyle*' => 'kde_LinkStyle*',
+'List&' => 'kde_List*',
+'List' => 'kde_List',
+'List*' => 'kde_List*',
+'ListIterator&' => 'kde_ListIterator*',
+'ListIterator' => 'kde_ListIterator',
+'ListIterator*' => 'kde_ListIterator*',
+'ListJob*' => 'kde_ListJob*',
+'ListNode*' => 'kde_ListNode*',
+'ListProgress*' => 'kde_ListProgress*',
+'Lookup*' => 'kde_Lookup*',
+'MCOPConfig*' => 'kde_MCOPConfig*',
+'MCOPUtils*' => 'kde_MCOPUtils*',
+'MSG*' => 'MSG*' ,
+'MailServer&' => 'MailServer*' ,
+'MailServer*' => 'kde_MailServer*',
+'MainWindow*' => 'kde_MainWindow*',
+'Mark*' => 'kde_Mark*',
+'MarkInterface*' => 'kde_MarkInterface*',
+'MediaAsyncStream*' => 'kde_MediaAsyncStream*',
+'MediaDataPacket*' => 'kde_MediaDataPacket*',
+'MediaFrame*' => 'kde_MediaFrame*',
+'MediaList&' => 'kde_MediaList*',
+'MediaList' => 'kde_MediaList',
+'MediaList*' => 'kde_MediaList*',
+'MediaListImpl*' => 'kde_MediaListImpl*',
+'MediaModule&' => 'kde_MediaModule*',
+'MediaModule' => 'kde_MediaModule*',
+'MediaModule*' => 'kde_MediaModule*',
+'MediaModule_base*' => 'kde_MediaModule_base*',
+'MediaModule_skel*' => 'kde_MediaModule_skel*',
+'MediaModule_stub*' => 'kde_MediaModule_stub*',
+'MenuDockData*' => 'kde_MenuDockData*',
+'MetaData&' => 'kde_MetaData*',
+'MetaData' => 'kde_MetaData*',
+'MetaData*' => 'kde_MetaData*',
+'MethodDef&' => 'kde_MethodDef*',
+'MethodDef*' => 'kde_MethodDef*',
+'MidiEvent*' => 'kde_MidiEvent*',
+'MidiFileInfo*' => 'kde_MidiFileInfo*',
+'MidiMapper*' => 'kde_MidiMapper*',
+'MidiOut*' => 'kde_MidiOut*',
+'MidiPlayer*' => 'kde_MidiPlayer*',
+'MidiStatus*' => 'kde_MidiStatus*',
+'MidiTrack*' => 'kde_MidiTrack*',
+'MimetypeJob*' => 'kde_MimetypeJob*',
+'Mode' => 'int',
+'ModuleDef&' => 'kde_ModuleDef*',
+'ModuleDef*' => 'kde_ModuleDef*',
+'MouseDoubleClickEvent*' => 'kde_MouseDoubleClickEvent*',
+'MouseEvent*' => 'kde_MouseEvent*',
+'MouseMoveEvent*' => 'kde_MouseMoveEvent*',
+'MousePressEvent*' => 'kde_MousePressEvent*',
+'MouseReleaseEvent*' => 'kde_MouseReleaseEvent*',
+'MultiGetJob*' => 'kde_MultiGetJob*',
+'MultiPort*' => 'kde_MultiPort*',
+'NET*' => 'kde_NET*',
+'NET::WindowType' => 'int' ,
+'NETIcon' => 'kdeNETIcon*' ,
+'NETIcon*' => 'kde_NETIcon*',
+'NETPoint&' => 'kde_NETPoint*' ,
+'NETPoint' => 'kde_NETPoint*' ,
+'NETPoint*' => 'kde_NETPoint*',
+'NETRect&' => 'kde_NETRect*' ,
+'NETRect' => 'kde_NETRect*' ,
+'NETRect*' => 'kde_NETRect*',
+'NETRootInfo&' => 'kde_NETRootInfo*' ,
+'NETRootInfo*' => 'kde_NETRootInfo*',
+'NETRootInfoPrivate*' => 'kde_NETRootInfoPrivate*',
+'NETSize&' => 'kde_NETSize*' ,
+'NETSize' => 'kde_NETSize*' ,
+'NETSize*' => 'kde_NETSize*',
+'NETStrut' => 'kde_NETStrut*' ,
+'NETStrut*' => 'kde_NETStrut*',
+'NETWinInfo&' => 'kde_NETWinInfo*' ,
+'NETWinInfo*' => 'kde_NETWinInfo*',
+'NETWinInfoPrivate*' => 'kde_NETWinInfoPrivate*',
+'NamedNodeMap&' => 'kde_NamedNodeMap*',
+'NamedNodeMap' => 'kde_NamedNodeMap*',
+'NamedNodeMap*' => 'kde_NamedNodeMap*',
+'NamedNodeMapImpl*' => 'kde_NamedNodeMapImpl*',
+'NetAccess*' => 'kde_NetAccess*',
+'NetRC*' => 'kde_NetRC*',
+'Node&' => 'kde_DOMNode*',
+'Node' => 'kde_DOMNode*',
+'Node*' => 'kde_DOMNode*',
+'NodeFilter&' => 'kde_NodeFilter*',
+'NodeFilter' => 'kde_NodeFilter*',
+'NodeFilter*' => 'kde_NodeFilter*',
+'NodeFilterImpl*' => 'kde_NodeFilterImpl*',
+'NodeImpl*' => 'kde_NodeImpl*',
+'NodeIterator&' => 'kde_NodeIterator*',
+'NodeIterator' => 'kde_NodeIterator*',
+'NodeIterator*' => 'kde_NodeIterator*',
+'NodeIteratorImpl*' => 'kde_NodeIteratorImpl*',
+'NodeList&' => 'kde_DOMNodeList*',
+'NodeList' => 'kde_DOMNodeList*',
+'NodeList*' => 'kde_DOMNodeList*',
+'NodeListImpl*' => 'kde_NodeListImpl*',
+'NodePtr' => 'int' ,
+'NodeType' => 'int' ,
+'Notation&' => 'kde_Notation*',
+'Notation*' => 'kde_Notation*',
+'NoteArray*' => 'kde_NoteArray*',
+'Notification&' => 'kde_Notification*',
+'Notification' => 'kde_Notification*',
+'Notification*' => 'kde_Notification*',
+'NotificationClient*' => 'kde_NotificationClient*',
+'NotificationManager*' => 'kde_NotificationManager*',
+'Null*' => 'null',
+'Number&' => 'kde_Number*',
+'Number*' => 'kde_Number*',
+'Object&' => 'kde_Object*',
+'Object' => 'kde_Object*',
+'Object*' => 'kde_Object*',
+'ObjectImp*' => 'kde_ObjectImp*',
+'ObjectManager*' => 'kde_ObjectManager*',
+'ObjectReference&' => 'kde_ObjectReference*',
+'ObjectReference*' => 'kde_ObjectReference*',
+'Object_base*' => 'kde_Object_base*',
+'Object_skel*' => 'kde_Object_skel*',
+'Object_stub*' => 'kde_Object_stub*',
+'Observer*' => 'kde_Observer*',
+'OfferList' => 'kde_OfferList*' ,
+'Offset' => 'int',
+'OnewayDispatchFunction' => 'kde_OnewayDispatchFunction*',
+'OnewayInvocation&' => 'kde_OnewayInvocation*',
+'OnewayInvocation*' => 'kde_OnewayInvocation*',
+'OpenURLEvent*' => 'kde_OpenURLEvent*',
+'Orientation' => 'int',
+'PFlags' => 'int',
+'PIAccess' => 'int',
+'PID' => 'long',
+'PIType' => 'int',
+'PTY*' => 'kde_PTY*',
+'PageSize' => 'int',
+'ParamDef&' => 'kde_ParamDef*',
+'ParamDef*' => 'kde_ParamDef*',
+'ParsedArgument*' => 'kde_ParsedArgument*',
+'ParsedAttribute*' => 'kde_ParsedAttribute*',
+'ParsedClass&' => 'kde_ParsedClass&',
+'ParsedClass*' => 'kde_ParsedClass*',
+'ParsedClassContainer*' => 'kde_ParsedClassContainer*',
+'ParsedContainer*' => 'kde_ParsedContainer*',
+'ParsedItem*' => 'kde_ParsedItem*',
+'ParsedMethod*' => 'kde_ParsedMethod*',
+'ParsedParent*' => 'kde_ParsedParent*',
+'ParsedScopeContainer*' => 'kde_ParsedScopeContainer*',
+'ParsedSignalSlot*' => 'kde_ParsedSignalSlot*',
+'ParsedStruct*' => 'kde_ParsedStruct*',
+'Part*' => 'kde_Part*',
+'PartActivateEvent*' => 'kde_PartActivateEvent*',
+'PartBase*' => 'kde_PartBase*',
+'PartManager*' => 'kde_PartManager*',
+'PartSelectEvent*' => 'kde_PartSelectEvent*',
+'PassDlg*' => 'kde_PassDlg*',
+'PasswordDialog*' => 'kde_PasswordDialog*',
+'PenCapStyle' => 'int' ,
+'PenJoinStyle' => 'int' ,
+'PenStyle' => 'int',
+'PersistantClassStore*' => 'kde_PersistantClassStore*',
+'PhoneNumber&' => 'kde_PhoneNumber*',
+'PhoneNumber*' => 'kde_PhoneNumber*',
+'PipeBuffer*' => 'kde_PipeBuffer*',
+'PipeSegment*' => 'kde_PipeSegment*',
+'Pix&' => 'kde_Pix*' ,
+'Pix' => 'kde_Pix*' ,
+'PixelMetric' => 'int',
+'PlayObject&' => 'kde_PlayObject*',
+'PlayObject' => 'kde_PlayObject*',
+'PlayObject*' => 'kde_PlayObject*',
+'PlayObjectFactory&' => 'kde_PlayObjectFactory*',
+'PlayObjectFactory' => 'kde_PlayObjectFactory',
+'PlayObjectFactory*' => 'kde_PlayObjectFactory*',
+'PlayObjectFactory_base*' => 'kde_PlayObjectFactory_base*',
+'PlayObjectFactory_skel*' => 'kde_PlayObjectFactory_skel*',
+'PlayObjectFactory_stub*' => 'kde_PlayObjectFactory_stub*',
+'PlayObject_base*' => 'kde_PlayObject_base*',
+'PlayObject_private&' => 'kde_PlayObject_private*',
+'PlayObject_private' => 'kde_PlayObject_private',
+'PlayObject_private*' => 'kde_PlayObject_private*',
+'PlayObject_private_base*' => 'kde_PlayObject_private_base*',
+'PlayObject_private_skel*' => 'kde_PlayObject_private_skel*',
+'PlayObject_private_stub*' => 'kde_PlayObject_private_stub*',
+'PlayObject_skel*' => 'kde_PlayObject_skel*',
+'PlayObject_stub*' => 'kde_PlayObject_stub*',
+'PlayerController*' => 'kde_PlayerController*',
+'Plugin*' => 'kde_Plugin*',
+'PluginInfo*' => 'kde_PluginInfo*',
+'Policy' => 'int',
+'Pool&' => 'kde_Pool*',
+'Pool*' => 'kde_Pool*',
+'PopupMenuInterface*' => 'kde_PopupMenuInterface*',
+'Port*' => 'kde_Port*',
+'PreviewJob*' => 'kde_PreviewJob*',
+'PrimitiveElement' => 'int',
+'PrintInterface*' => 'kde_PrintInterface*',
+'PrinterMode' => 'int',
+'ProcessingInstruction&' => 'kde_ProcessingInstruction*',
+'ProcessingInstruction' => 'kde_ProcessingInstruction*',
+'ProcessingInstruction*' => 'kde_ProcessingInstruction*',
+'ProgressBase*' => 'kde_ProgressBase*',
+'ProgressItem*' => 'kde_ProgressItem*',
+'PropagationMode' => 'int',
+'ProtocolInfo*' => 'kde_ProtocolInfo*',
+'Ptr' => 'void *',
+'PtyProcess*' => 'kde_PtyProcess*',
+'QAccel*' => 'qt_QAccel*',
+'QAccessible*' => 'qt_QAccessible*',
+'QAccessibleFactoryInterface*' => 'qt_QAccessibleFactoryInterface*',
+'QAccessibleInterface*' => 'qt_QAccessibleInterface*',
+'QAccessibleInterface**' => 'qt_QAccessibleInterface**',
+'QAccessibleObject*' => 'qt_QAccessibleObject*',
+'QAction*' => 'qt_QAction*' ,
+'QActionGroup*' => 'qt_QActionGroup*',
+'QApplication*' => 'qt_QApplication*' ,
+'QArabicCodec*' => 'qt_QArabicCodec*',
+'QArray*' => 'qt_QArray*',
+'QAsciiBucket*' => 'qt_QAsciiBucket*',
+'QAsciiCache*' => 'qt_QAsciiCache*',
+'QAsciiCacheIterator*' => 'qt_QAsciiCacheIterator*',
+'QAsciiDict*' => 'qt_QAsciiDict*',
+'QAsciiDictIterator*' => 'qt_QAsciiDictIterator*',
+'QAsyncIO*' => 'qt_QAsyncIO*',
+'QAuBucket*' => 'qt_QAuBucket*' ,
+'QAuServer*' => 'qt_QAuServer*',
+'QBaseBucket*' => 'qt_QBaseBucket*' ,
+'QBig5Codec*' => 'qt_QBig5Codec*',
+'QBitArray&' => 'qt_QBitArray*' ,
+'QBitArray' => 'qt_QBitArray*' ,
+'QBitArray*' => 'qt_QBitArray*' ,
+'QBitVal&' => 'qt_QBitVal*' ,
+'QBitVal' => 'qt_QBitVal*' ,
+'QBitVal*' => 'qt_QBitVal*',
+'QBitmap&' => 'qt_QBitmap *',
+'QBitmap' => 'qt_QBitmap *',
+'QBitmap*' => 'qt_QBitmap *',
+'QBoxLayout*' => 'qt_QBoxLayout*',
+'QBrush&' => 'qt_QBrush *',
+'QBrush' => 'qt_QBrush*' ,
+'QBrush*' => 'qt_QBrush*' ,
+'QBrushData*' => 'qt_QBrushData*',
+'QBuffer*' => 'qt_QBuffer*',
+'QButton*' => 'qt_QButton *',
+'QButtonGroup*' => 'qt_QButtonGroup*' ,
+'QByteArray& arr ()' => 'qt_QByteArray*',
+'QByteArray&' => 'qt_QByteArray*' ,
+'QByteArray' => 'qt_QByteArray*',
+'QByteArray*' => 'qt_QByteArray*',
+'QCDEStyle*' => 'qt_QCDEStyle*',
+'QCOORD&' => 'short',
+'QCOORD' => 'short',
+'QCOORD*' => 'short *',
+'QCString&' => 'qt_QCString*' ,
+'QCString' => 'qt_QCString*' ,
+'QCString*' => 'qt_QCString*' ,
+'QCStringLess*' => 'qt_QCStringLess*' ,
+'QCStringList' => 'kde_QCStringList*' ,
+'QCache*' => 'qt_QCache*',
+'QCacheIterator*' => 'qt_QCacheIterator*',
+'QCanvas*' => 'qt_QCanvas*' ,
+'QCanvasEllipse*' => 'qt_QCanvasEllipse*',
+'QCanvasItem*' => 'qt_QCanvasItem*' ,
+'QCanvasItemList' => 'qt_QCanvasItemList*' ,
+'QCanvasItemList*' => 'qt_QCanvasItemList*',
+'QCanvasLine*' => 'qt_QCanvasLine*',
+'QCanvasPixmap*' => 'qt_QCanvasPixmap*' ,
+'QCanvasPixmapArray*' => 'qt_QCanvasPixmapArray*' ,
+'QCanvasPolygon*' => 'qt_QCanvasPolygon*',
+'QCanvasPolygonalItem*' => 'qt_QCanvasPolygonalItem*',
+'QCanvasRectangle*' => 'qt_QCanvasRectangle*',
+'QCanvasSpline*' => 'qt_QCanvasSpline*',
+'QCanvasSprite*' => 'qt_QCanvasSprite*',
+'QCanvasText*' => 'qt_QCanvasText*',
+'QCanvasView*' => 'qt_QCanvasView*' ,
+'QChain*' => 'qt_QChain*' ,
+'QChar&' => 'qt_QChar*' ,
+'QChar' => 'qt_QChar*' ,
+'QChar*' => 'qt_QChar*' ,
+'QChar::Category' => 'int' ,
+'QChar::Decomposition' => 'int' ,
+'QChar::Direction' => 'int' ,
+'QChar::Joining' => 'int' ,
+'QCharRef&' => 'qt_QCharRef*' ,
+'QCharRef' => 'qt_QCharRef*' ,
+'QCharRef*' => 'qt_QCharRef*',
+'QCheckBox*' => 'qt_QCheckBox*',
+'QCheckListItem*' => 'qt_QCheckListItem *',
+'QCheckTableItem*' => 'qt_QCheckTableItem*',
+'QChildEvent*' => 'qt_QChildEvent*' ,
+'QClassInfo*' => 'qt_QClassInfo*' ,
+'QCleanupHandler*' => 'qt_QCleanupHandler*',
+'QClipboard*' => 'qt_QClipboard *',
+'QCloseEvent*' => 'qt_QCloseEvent*' ,
+'QCollection&' => 'qt_QCollection*' ,
+'QCollection*' => 'qt_QCollection*',
+'QCollection::Item&' => 'void *' ,
+'QCollection::Item' => 'void *' ,
+'QColor &' => 'qt_QColor *',
+'QColor&' => 'qt_QColor *',
+'QColor&fillColor::white' => 'int' ,
+'QColor&linkColor::blue' => 'int' ,
+'QColor' => 'qt_QColor *',
+'QColor*' => 'qt_QColor*' ,
+'QColorDialog*' => 'qt_QColorDialog*',
+'QColorDrag*' => 'qt_QColorDrag*',
+'QColorGroup&' => 'qt_QColorGroup *',
+'QColorGroup' => 'qt_QColorGroup*' ,
+'QColorGroup*' => 'qt_QColorGroup*' ,
+'QColorGroup::ColorRole' => 'int' ,
+'QComboBox*' => 'qt_QComboBox*' ,
+'QComboBox::Policy' => 'int' ,
+'QComboBox::Policypolicy::AtBottom' => 'int' ,
+'QComboTableItem*' => 'qt_QComboTableItem*',
+'QCommonStyle*' => 'qt_QCommonStyle*',
+'QCompactStyle*' => 'qt_QCompactStyle*',
+'QComponentFactory*' => 'qt_QComponentFactory*',
+'QComponentFactoryInterface*' => 'qt_QComponentFactoryInterface*',
+'QComponentInterface*' => 'qt_QComponentInterface*',
+'QComponentRegistration*' => 'qt_QComponentRegistration*',
+'QComponentServerInterface*' => 'qt_QComponentServerInterface*',
+'QConfigDB*' => 'qt_QConfigDB*' ,
+'QConfigDB*' => 'qt_QConfigDB*' ,
+'QConnection*' => 'qt_QConnection*',
+'QConnectionList&' => 'qt_QConnectionList*' ,
+'QConnectionList*' => 'qt_QConnectionList*' ,
+'QConnectionListIt&' => 'qt_QConnectionListIt*' ,
+'QConnectionListIt*' => 'qt_QConnectionListIt*',
+'QConstString' => 'qt_QConstString*',
+'QConstString*' => 'qt_QConstString*',
+'QContextMenuEvent*' => 'qt_QContextMenuEvent*',
+'QCursor&' => 'qt_QCursor *',
+'QCursor' => 'qt_QCursor*' ,
+'QCursor*' => 'qt_QCursor *',
+'QCustomEvent*' => 'qt_QCustomEvent*' ,
+'QCustomMenuItem*' => 'qt_QCustomMenuItem*' ,
+'QDOM_NodeListPrivate*' => 'void*' ,
+'QDOM_NodePrivate*' => 'void*' ,
+'QDataBrowser*' => 'qt_QDataBrowser*',
+'QDataPump*' => 'qt_QDataPump*',
+'QDataSink*' => 'qt_QDataSink*' ,
+'QDataSource*' => 'qt_QDataSource*' ,
+'QDataStream&' => 'qt_QDataStream *',
+'QDataStream*' => 'qt_QDataStream*' ,
+'QDataTable*' => 'qt_QDataTable*',
+'QDataView*' => 'qt_QDataView*',
+'QDate &' => 'qt_QDate *',
+'QDate date()' => 'qt_QDate*',
+'QDate&' => 'qt_QDate *',
+'QDate' => 'qt_QDate *',
+'QDate*' => 'qt_QDate*',
+'QDateEdit*' => 'qt_QDateEdit*',
+'QDateTime&' => 'qt_QDateTime *',
+'QDateTime' => 'qt_QDateTime *',
+'QDateTime*' => 'qt_QDateTime*' ,
+'QDateTimeEdit*' => 'qt_QDateTimeEdit*',
+'QDateTimeEditBase*' => 'qt_QDateTimeEditBase*',
+'QDesktopWidget*' => 'qt_QDesktopWidget*',
+'QDial*' => 'qt_QDial*',
+'QDialog*' => 'qt_QDialog*',
+'QDict*' => 'qt_QDict*',
+'QDictIterator*' => 'qt_QDictIterator*',
+'QDir&' => 'qt_QDir *',
+'QDir' => 'qt_QDir *',
+'QDir*' => 'qt_QDir *',
+'QDir::SortSpec&' => 'int' ,
+'QDir::SortSpec' => 'int' ,
+'QDirSortItem*' => 'qt_QDirSortItem*',
+'QDiskFont*' => 'qt_QDiskFont*',
+'QDispatchInterface*' => 'qt_QDispatchInterface*',
+'QDns*' => 'qt_QDns*',
+'QDnsSocket*' => 'qt_QDnsSocket*',
+'QDockArea*' => 'qt_QDockArea*',
+'QDockAreaLayout*' => 'qt_QDockAreaLayout*',
+'QDockWindow*' => 'qt_QDockWindow*',
+'QDomAttr&' => 'qt_QDomAttr*' ,
+'QDomAttr' => 'qt_QDomAttr*' ,
+'QDomAttr*' => 'qt_QDomAttr*',
+'QDomCDATASection&' => 'qt_QDomCDATASection*' ,
+'QDomCDATASection' => 'qt_QDomCDATASection*' ,
+'QDomCDATASection*' => 'qt_QDomCDATASection*',
+'QDomCharacterData&' => 'qt_QDomCharacterData*' ,
+'QDomCharacterData' => 'qt_QDomCharacterData*' ,
+'QDomCharacterData*' => 'qt_QDomCharacterData*',
+'QDomComment&' => 'qt_QDomComment*' ,
+'QDomComment' => 'qt_QDomComment*' ,
+'QDomComment*' => 'qt_QDomComment*',
+'QDomDocument&' => 'qt_QDomDocument*' ,
+'QDomDocument' => 'qt_QDomDocument*' ,
+'QDomDocument*' => 'qt_QDomDocument*',
+'QDomDocumentFragment&' => 'qt_QDomDocumentFragment*' ,
+'QDomDocumentFragment' => 'qt_QDomDocumentFragment*' ,
+'QDomDocumentFragment*' => 'qt_QDomDocumentFragment*',
+'QDomDocumentType&' => 'qt_QDomDocumentType*' ,
+'QDomDocumentType' => 'qt_QDomDocumentType*' ,
+'QDomDocumentType*' => 'qt_QDomDocumentType*',
+'QDomElement&' => 'qt_QDomElement*' ,
+'QDomElement' => 'qt_QDomElement*' ,
+'QDomElement*' => 'qt_QDomElement*',
+'QDomEntity&' => 'qt_QDomEntity*' ,
+'QDomEntity' => 'qt_QDomEntity*' ,
+'QDomEntity*' => 'qt_QDomEntity*',
+'QDomEntityReference&' => 'qt_QDomEntityReference*' ,
+'QDomEntityReference' => 'qt_QDomEntityReference*' ,
+'QDomEntityReference*' => 'qt_QDomEntityReference*',
+'QDomImplementation&' => 'qt_QDomImplementation*' ,
+'QDomImplementation' => 'qt_QDomImplementation*' ,
+'QDomImplementation*' => 'qt_QDomImplementation*',
+'QDomNamedNodeMap&' => 'qt_QDomNamedNodeMap*' ,
+'QDomNamedNodeMap' => 'qt_QDomNamedNodeMap*' ,
+'QDomNamedNodeMap*' => 'qt_QDomNamedNodeMap*',
+'QDomNode&' => 'qt_QDomNode*' ,
+'QDomNode' => 'qt_QDomNode*' ,
+'QDomNode*' => 'qt_QDomNode*',
+'QDomNode::NodeType' => 'int',
+'QDomNodeList&' => 'qt_QDomNodeList*' ,
+'QDomNodeList' => 'qt_QDomNodeList*' ,
+'QDomNodeList*' => 'qt_QDomNodeList*',
+'QDomNodePrivate*' => 'qt_QDomNodePrivate*',
+'QDomNotation&' => 'qt_QDomNotation*' ,
+'QDomNotation' => 'qt_QDomNotation*' ,
+'QDomNotation*' => 'qt_QDomNotation*',
+'QDomProcessingInstruction&' => 'qt_QDomProcessingInstruction*' ,
+'QDomProcessingInstruction' => 'qt_QDomProcessingInstruction*' ,
+'QDomProcessingInstruction*' => 'qt_QDomProcessingInstruction*',
+'QDomText&' => 'qt_QDomText*' ,
+'QDomText' => 'qt_QDomText*' ,
+'QDomText*' => 'qt_QDomText*',
+'QDoubleValidator*' => 'qt_QDoubleValidator*',
+'QDragEnterEvent*' => 'qt_QDragEnterEvent*' ,
+'QDragLeaveEvent*' => 'qt_QDragLeaveEvent*' ,
+'QDragManager*' => 'qt_QDragManager*',
+'QDragMoveEvent*' => 'qt_QDragMoveEvent*' ,
+'QDragObject*' => 'qt_QDragObject*' ,
+'QDragResponseEvent*' => 'qt_QDragResponseEvent*',
+'QDropEvent*' => 'qt_QDropEvent*' ,
+'QDropSite*' => 'qt_QDropSite*',
+'QEditorFactory*' => 'qt_QEditorFactory*',
+'QErrorMessage*' => 'qt_QErrorMessage*',
+'QEucJpCodec*' => 'qt_QEucJpCodec*',
+'QEucKrCodec*' => 'qt_QEucKrCodec*',
+'QEvent*' => 'qt_QEvent *',
+'QEventLoop::ProcessEventsFlags' => 'uint',
+'QFeatureListInterface*' => 'qt_QFeatureListInterface*',
+'QFile&' => 'qt_QFile *',
+'QFile*' => 'qt_QFile*' ,
+'QFileDialog*' => 'qt_QFileDialog*',
+'QFileIconProvider*' => 'qt_QFileIconProvider*' ,
+'QFileInfo&' => 'qt_QFileInfo *',
+'QFileInfo*' => 'qt_QFileInfo*',
+'QFileInfoList*' => 'qt_QFileInfoList*' ,
+'QFilePreview*' => 'qt_QFilePreview*' ,
+'QFocusData*' => 'qt_QFocusData*' ,
+'QFocusEvent*' => 'qt_QFocusEvent*' ,
+'QFont&' => 'qt_QFont *',
+'QFont' => 'qt_QFont *',
+'QFont*' => 'qt_QFont *',
+'QFont::CharSet' => 'int',
+'QFont::CharSetcharset::Unicode' => 'int' ,
+'QFont::StyleHint' => 'int',
+'QFontData&' => 'qt_QFontData*' ,
+'QFontDatabase*' => 'qt_QFontDatabase*',
+'QFontDialog*' => 'qt_QFontDialog*',
+'QFontInfo&' => 'qt_QFontInfo *',
+'QFontInfo' => 'qt_QFontInfo *',
+'QFontInfo*' => 'qt_QFontInfo*',
+'QFontMetrics&' => 'qt_QFontMetrics *',
+'QFontMetrics' => 'qt_QFontMetrics *',
+'QFontMetrics*' => 'qt_QFontMetrics*',
+'QFrame*' => 'qt_QFrame*' ,
+'QFtp*' => 'qt_QFtp*',
+'QGArray&' => 'qt_QGArray*' ,
+'QGArray*' => 'qt_QGArray*',
+'QGCache&' => 'qt_QGCache*' ,
+'QGCache*' => 'qt_QGCache*',
+'QGCacheIterator&' => 'qt_QGCacheIterator*' ,
+'QGCacheIterator*' => 'qt_QGCacheIterator*',
+'QGDict&' => 'qt_QGDict*' ,
+'QGDict*' => 'qt_QGDict*',
+'QGDictIterator&' => 'qt_QGDictIterator*' ,
+'QGDictIterator*' => 'qt_QGDictIterator*',
+'QGL*' => 'qt_QGL*',
+'QGLColormap&' => 'qt_QGLColormap*',
+'QGLColormap*' => 'qt_QGLColormap*',
+'QGLContext*' => 'qt_QGLContext*' ,
+'QGLFormat&' => 'qt_QGLFormat*' ,
+'QGLFormat' => 'qt_QGLFormat*' ,
+'QGLFormat*' => 'qt_QGLFormat*',
+'QGLWidget*' => 'qt_QGLWidget*' ,
+'QGLayoutIterator*' => 'qt_QGLayoutIterator*' ,
+'QGList&' => 'qt_QGList*' ,
+'QGList*' => 'qt_QGList*' ,
+'QGListIterator&' => 'qt_QGListIterator*' ,
+'QGListIterator*' => 'qt_QGListIterator*',
+'QGPlugin*' => 'qt_QGPlugin*',
+'QGPluginManager*' => 'qt_QGPluginManager*',
+'QGVector&' => 'qt_QGVector*' ,
+'QGVector*' => 'qt_QGVector*' ,
+'QGbkCodec*' => 'qt_QGbkCodec*',
+'QGfx*' => 'qt_QGfx*' ,
+'QGrid*' => 'qt_QGrid*' ,
+'QGrid::Direction' => 'int' ,
+'QGridLayout*' => 'qt_QGridLayout*',
+'QGridView*' => 'qt_QGridView*',
+'QGroupBox*' => 'qt_QGroupBox*',
+'QGuardedPtr*' => 'qt_QGuardedPtr*',
+'QGuardedPtrPrivate*' => 'qt_QGuardedPtrPrivate*',
+'QHBox*' => 'qt_QHBox*' ,
+'QHBoxLayout*' => 'qt_QHBoxLayout*' ,
+'QHButtonGroup*' => 'qt_QHButtonGroup*',
+'QHGroupBox*' => 'qt_QHGroupBox*',
+'QHeader*' => 'qt_QHeader *',
+'QHebrewCodec*' => 'qt_QHebrewCodec*',
+'QHideEvent*' => 'qt_QHideEvent*' ,
+'QHostAddress&' => 'qt_QHostAddress*' ,
+'QHostAddress' => 'qt_QHostAddress*' ,
+'QHostAddress*' => 'qt_QHostAddress*' ,
+'QHttp*' => 'qt_QHttp*',
+'QIMEvent*' => 'qt_QIMEvent*',
+'QIODevice*' => 'qt_QIODevice *',
+'QIODevice::Offset' => 'int',
+'QIODeviceSource*' => 'qt_QIODeviceSource*',
+'QIOManager*' => 'qt_QIOManager*',
+'QIOWatch*' => 'qt_QIOWatch*',
+'QIconDrag*' => 'qt_QIconDrag*',
+'QIconDragItem&' => 'qt_QIconDragItem*' ,
+'QIconDragItem*' => 'qt_QIconDragItem*',
+'QIconSet&' => 'qt_QIconSet*' ,
+'QIconSet' => 'qt_QIconSet*' ,
+'QIconSet*' => 'qt_QIconSet*' ,
+'QIconView*' => 'qt_QIconView*' ,
+'QIconViewItem*' => 'qt_QIconViewItem*' ,
+'QImage&' => 'qt_QImage *',
+'QImage' => 'qt_QImage *',
+'QImage*' => 'qt_QImage*' ,
+'QImageConsumer*' => 'qt_QImageConsumer*' ,
+'QImageData*' => 'qt_QImageData*',
+'QImageDecoder*' => 'qt_QImageDecoder*',
+'QImageDrag*' => 'qt_QImageDrag*',
+'QImageFormat*' => 'qt_QImageFormat*' ,
+'QImageFormatInterface*' => 'qt_QImageFormatInterface*',
+'QImageFormatPlugin*' => 'qt_QImageFormatPlugin*',
+'QImageFormatType*' => 'qt_QImageFormatType*' ,
+'QImageIO*' => 'qt_QImageIO*',
+'QImageTextKeyLang&' => 'qt_QImageTextKeyLang*' ,
+'QImageTextKeyLang*' => 'qt_QImageTextKeyLang*',
+'QInputDialog*' => 'qt_QInputDialog*',
+'QIntBucket*' => 'qt_QIntBucket*',
+'QIntCache*' => 'qt_QIntCache*',
+'QIntCacheIterator*' => 'qt_QIntCacheIterator*',
+'QIntDict*' => 'qt_QIntDict*',
+'QIntDictIterator*' => 'qt_QIntDictIterator*',
+'QIntValidator*' => 'qt_QIntValidator*',
+'QInterfaceListInterface*' => 'qt_QInterfaceListInterface*',
+'QInterfacePtr*' => 'qt_QInterfacePtr*',
+'QInterlaceStyle*' => 'qt_QInterlaceStyle*',
+'QInternal*' => 'qt_QInternal*',
+'QJisCodec*' => 'qt_QJisCodec*',
+'QJpUnicodeConv*' => 'qt_QJpUnicodeConv*' ,
+'QKeyEvent*' => 'qt_QKeyEvent*' ,
+'QKeySequence&' => 'qt_QKeySequence*',
+'QKeySequence' => 'qt_QKeySequence*',
+'QKeySequence*' => 'qt_QKeySequence*',
+'QKoi8Codec*' => 'qt_QKoi8Codec*',
+'QLCDNumber*' => 'qt_QLCDNumber*',
+'QLNode*' => 'qt_QLNode*' ,
+'QLabel*' => 'qt_QLabel *',
+'QLayout*' => 'qt_QLayout *',
+'QLayoutItem*' => 'qt_QLayoutItem*' ,
+'QLayoutIterator&' => 'qt_QLayoutIterator*' ,
+'QLayoutIterator' => 'qt_QLayoutIterator*' ,
+'QLayoutIterator*' => 'qt_QLayoutIterator*',
+'QLibrary*' => 'qt_QLibrary*',
+'QLibrary::Policy' => 'int',
+'QLibraryInterface*' => 'qt_QLibraryInterface*',
+'QLineEdit*' => 'qt_QLineEdit*' ,
+'QLineEdit::EchoMode' => 'int' ,
+'QList*' => 'qt_QList*',
+'QListBox*' => 'qt_QListBox *',
+'QListBoxItem*' => 'qt_QListBoxItem *',
+'QListBoxPixmap*' => 'qt_QListBoxPixmap*',
+'QListBoxText*' => 'qt_QListBoxText*',
+'QListIterator*' => 'qt_QListIterator*',
+'QListView*' => 'qt_QListView *',
+'QListViewItem*&' => 'qt_QListViewItem*',
+'QListViewItem*' => 'qt_QListViewItem *',
+'QListViewItemIterator&' => 'qt_QListViewItemIterator*' ,
+'QListViewItemIterator' => 'qt_QListViewItemIterator*' ,
+'QListViewItemIterator*' => 'qt_QListViewItemIterator*',
+'QLocalFs*' => 'qt_QLocalFs*',
+'QMCPI*' => 'qt_QMCPI*',
+'QMSG*' => 'QMSG*' ,
+'QMainWindow*' => 'qt_QMainWindow*' ,
+'QMainWindow::ToolBarDock' => 'int',
+'QMainWindow::ToolBarDock::Top' => 'int' ,
+'QMap&' => 'qt_QMap*' ,
+'QMap*' => 'qt_QMap*',
+'QMapConstIterator*' => 'qt_QMapConstIterator*',
+'QMapIterator*' => 'qt_QMapIterator*',
+'QMapNode*' => 'qt_QMapNode*',
+'QMapNodeBase*&' => 'qt_QMapNodeBase*' ,
+'QMapNodeBase*' => 'qt_QMapNodeBase*' ,
+'QMapPrivate*' => 'qt_QMapPrivate*',
+'QMapPrivateBase*' => 'qt_QMapPrivateBase*' ,
+'QMemArray*' => 'qt_QMemArray*',
+'QMember' => 'qt_QMember*' ,
+'QMember*' => 'qt_QMember*' ,
+'QMenuBar*' => 'qt_QMenuBar *',
+'QMenuData*' => 'qt_QMenuData*',
+'QMenuData**' => 'qt_QMenuData**' ,
+'QMenuItem*' => 'qt_QMenuItem *',
+'QMessageBox*' => 'qt_QMessageBox*',
+'QMetaData*' => 'qt_QMetaData*' ,
+'QMetaData::Access*' => 'int*' ,
+'QMetaEnum*' => 'qt_QMetaEnum*' ,
+'QMetaEnum::Item*' => 'int*' ,
+'QMetaObject*&' => 'qt_QMetaObject*',
+'QMetaObject*' => 'qt_QMetaObject *',
+'QMetaObjectCleanUp*' => 'qt_QMetaObjectCleanUp*',
+'QMetaObjectInit*' => 'qt_QMetaObjectInit*',
+'QMetaProperty*' => 'qt_QMetaProperty*' ,
+'QMimeSource*' => 'qt_QMimeSource*' ,
+'QMimeSourceFactory*' => 'qt_QMimeSourceFactory*' ,
+'QMotifPlusStyle*' => 'qt_QMotifPlusStyle*',
+'QMotifStyle*' => 'qt_QMotifStyle*',
+'QMouseEvent*' => 'qt_QMouseEvent*' ,
+'QMoveEvent*' => 'qt_QMoveEvent*' ,
+'QMovie&' => 'qt_QMovie *',
+'QMovie*' => 'qt_QMovie *',
+'QMultiLineEdit*' => 'qt_QMultiLineEdit*',
+'QMultiLineEditRow*' => 'qt_QMultiLineEditRow*',
+'QMutex*' => 'qt_QMutex*',
+'QNPInstance*' => 'qt_QNPInstance*',
+'QNPStream*' => 'qt_QNPStream*',
+'QNPWidget*' => 'qt_QNPWidget*',
+'QNPlugin*' => 'qt_QNPlugin*',
+'QNetworkOperation*' => 'qt_QNetworkOperation*' ,
+'QNetworkProtocol*' => 'qt_QNetworkProtocol*' ,
+'QNetworkProtocol::Operation' => 'int' ,
+'QNetworkProtocol::State' => 'int' ,
+'QNetworkProtocolFactory*' => 'qt_QNetworkProtocolFactory*',
+'QNetworkProtocolFactoryBase*' => 'qt_QNetworkProtocolFactoryBase*' ,
+'QObject*' => 'qt_QObject *',
+'QObjectCleanupHandler*' => 'qt_QObjectCleanupHandler*',
+'QObjectDictionary&' => 'qt_QObjectDictionary*' ,
+'QObjectDictionary*' => 'qt_QObjectDictionary*',
+'QObjectInterface*' => 'qt_QObjectInterface*',
+'QObjectList&' => 'qt_QObjectList*' ,
+'QObjectList*' => 'qt_QObjectList*',
+'QObjectListIt&' => 'qt_QObjectListIt*' ,
+'QObjectListIt*' => 'qt_QObjectListIt*',
+'QPNGImagePacker*' => 'qt_QPNGImagePacker*',
+'QPNGImageWriter*' => 'qt_QPNGImageWriter*',
+'QPaintDevice*' => 'qt_QPaintDevice *',
+'QPaintDeviceMetrics*' => 'qt_QPaintDeviceMetrics*',
+'QPaintDeviceX11Data*' => 'qt_QPaintDeviceX11Data*' ,
+'QPaintEvent*' => 'qt_QPaintEvent*' ,
+'QPainter&' => 'qt_QPainter*' ,
+'QPainter*' => 'qt_QPainter *',
+'QPair*' => 'qt_QPair*',
+'QPalData*' => 'qt_QPalData*',
+'QPalette&' => 'qt_QPalette *',
+'QPalette' => 'qt_QPalette *',
+'QPalette*' => 'qt_QPalette *',
+'QPen&' => 'qt_QPen *',
+'QPen' => 'qt_QPen*' ,
+'QPen*' => 'qt_QPen*',
+'QPenData*' => 'qt_QPenData*',
+'QPicture&' => 'qt_QPicture *',
+'QPicture' => 'qt_QPicture*',
+'QPicture*' => 'qt_QPicture*',
+'QPicturePrivate*' => 'qt_QPicturePrivate*',
+'QPixmap& pixmap()' => 'kde_QPixmap*',
+'QPixmap&' => 'qt_QPixmap *',
+'QPixmap' => 'qt_QPixmap *',
+'QPixmap*' => 'qt_QPixmap *',
+'QPixmap::Optimization' => 'int' ,
+'QPixmap::Optimization' => 'int',
+'QPixmap::Optimization::DefaultOptim' => 'int' ,
+'QPixmapCache*' => 'qt_QPixmapCache*',
+'QPixmapData*' => 'qt_QPixmapData*',
+'QPlatinumStyle*' => 'qt_QPlatinumStyle*',
+'QPluginManager*' => 'qt_QPluginManager*',
+'QPoint&' => 'qt_QPoint*',
+'QPoint&pos()' => 'int' ,
+'QPoint&pos::pos()' => 'int' ,
+'QPoint' => 'qt_QPoint*',
+'QPoint*' => 'qt_QPoint*' ,
+'QPointArray&' => 'qt_QPointArray*',
+'QPointArray' => 'qt_QPointArray*',
+'QPointArray*' => 'qt_QPointArray*',
+'QPointVal&' => 'qt_QPointVal*' ,
+'QPointVal' => 'qt_QPointVal*' ,
+'QPolygonScanner*' => 'qt_QPolygonScanner*',
+'QPopupMenu*' => 'qt_QPopupMenu*',
+'QPrintDialog*' => 'qt_QPrintDialog*',
+'QPrinter*' => 'qt_QPrinter*' ,
+'QPrinter::PrinterMode' => 'int',
+'QProcess*' => 'qt_QProcess*',
+'QProgressBar*' => 'qt_QProgressBar*',
+'QProgressDialog*' => 'qt_QProgressDialog*',
+'QPtrBucket*' => 'qt_QPtrBucket*',
+'QPtrCollection&' => 'qt_QPtrCollection*',
+'QPtrCollection*' => 'qt_QPtrCollection*',
+'QPtrDict*' => 'qt_QPtrDict*',
+'QPtrDictIterator*' => 'qt_QPtrDictIterator*',
+'QPtrList*' => 'qt_QPtrList*',
+'QPtrListIterator*' => 'qt_QPtrListIterator*',
+'QPtrQueue*' => 'qt_QPtrQueue*',
+'QPtrStack*' => 'qt_QPtrStack*',
+'QPtrVector*' => 'qt_QPtrVector*',
+'QPushButton*' => 'qt_QPushButton*',
+'QQueue*' => 'qt_QQueue*',
+'QRESULT' => 'long',
+'QRadioButton*' => 'qt_QRadioButton*',
+'QRangeControl*' => 'qt_QRangeControl*',
+'QRect&' => 'qt_QRect*',
+'QRect' => 'qt_QRect*',
+'QRect*' => 'qt_QRect*',
+'QRegExp&' => 'qt_QRegExp*',
+'QRegExp*' => 'qt_QRegExp*',
+'QRegExpValidator*' => 'qt_QRegExpValidator*',
+'QRegion&' => 'qt_QRegion *',
+'QRegion' => 'qt_QRegion *',
+'QRegion*' => 'qt_QRegion*',
+'QRegionData*' => 'qt_QRegionData*',
+'QRemoteFactory*' => 'qt_QRemoteFactory*',
+'QRemotePlugin*' => 'qt_QRemotePlugin*',
+'QResizeEvent*' => 'qt_QResizeEvent*' ,
+'QRgb' => 'unsigned int',
+'QRgb*' => 'int *',
+'QRichText&' => 'qt_QRichText*' ,
+'QSGIStyle*' => 'qt_QSGIStyle*',
+'QScrollBar&' => 'qt_QScrollBar*' ,
+'QScrollBar*' => 'qt_QScrollBar*' ,
+'QScrollView*' => 'qt_QScrollView*',
+'QSemaphore*' => 'qt_QSemaphore*',
+'QSemiModal*' => 'qt_QSemiModal*',
+'QSenderObject*' => 'qt_QSenderObject*',
+'QServerSocket*' => 'qt_QServerSocket*',
+'QSessionManager&' => 'qt_QSessionManager*' ,
+'QSessionManager*' => 'qt_QSessionManager*',
+'QSettings*' => 'qt_QSettings*',
+'QShared*' => 'qt_QShared*',
+'QShowEvent*' => 'qt_QShowEvent*' ,
+'QSignal*' => 'qt_QSignal *',
+'QSignalDict&' => 'qt_QSignalDict*' ,
+'QSignalDict*' => 'qt_QSignalDict*',
+'QSignalDictIt&' => 'qt_QSignalDictIt*' ,
+'QSignalDictIt*' => 'qt_QSignalDictIt*',
+'QSignalMapper*' => 'qt_QSignalMapper*',
+'QSignalVec&' => 'qt_QSignalVec*',
+'QSignalVec*' => 'qt_QSignalVec*',
+'QSimpleRichText*' => 'qt_QSimpleRichText*',
+'QSize&' => 'qt_QSize *',
+'QSize' => 'qt_QSize *',
+'QSize*' => 'qt_QSize*' ,
+'QSizeGrip*' => 'qt_QSizeGrip*',
+'QSizePolicy&' => 'qt_QSizePolicy*' ,
+'QSizePolicy' => 'qt_QSizePolicy*' ,
+'QSizePolicy*' => 'qt_QSizePolicy*',
+'QSizePolicy::ExpandData' => 'int' ,
+'QSizePolicy::SizeTypehData::Minimum' => 'int' ,
+'QSizePolicy::SizeTypevData::Minimum' => 'int' ,
+'QSjisCodec*' => 'qt_QSjisCodec*',
+'QSlider*' => 'qt_QSlider*',
+'QSmartPtr&' => 'qt_QSmartPtr*' ,
+'QSmartPtr*' => 'qt_QSmartPtr*',
+'QSmartPtrPrivate*' => 'qt_QSmartPtrPrivate*',
+'QSocket*' => 'qt_QSocket*',
+'QSocketDevice*' => 'qt_QSocketDevice*' ,
+'QSocketNotifier*' => 'qt_QSocketNotifier*',
+'QSocketNotifier::Type' => 'int',
+'QSortedList*' => 'qt_QSortedList*',
+'QSound*' => 'qt_QSound*',
+'QSpacerItem*' => 'qt_QSpacerItem*' ,
+'QSpinBox*' => 'qt_QSpinBox*',
+'QSpinWidget*' => 'qt_QSpinWidget*',
+'QSplitter*' => 'qt_QSplitter*',
+'QSql*' => 'qt_QSql*',
+'QSql::Confirm' => 'int',
+'QSql::Op' => 'int',
+'QSqlCursor&' => 'qt_QSqlCursor*',
+'QSqlCursor' => 'qt_QSqlCursor*',
+'QSqlCursor*' => 'qt_QSqlCursor*',
+'QSqlDatabase*' => 'qt_QSqlDatabase*',
+'QSqlDriver*' => 'qt_QSqlDriver*',
+'QSqlDriverCreator*' => 'qt_QSqlDriverCreator*',
+'QSqlDriverCreatorBase*' => 'qt_QSqlDriverCreatorBase*',
+'QSqlDriverFactoryInterface*' => 'qt_QSqlDriverFactoryInterface*',
+'QSqlDriverPlugin*' => 'qt_QSqlDriverPlugin*',
+'QSqlEditorFactory*' => 'qt_QSqlEditorFactory*',
+'QSqlError&' => 'qt_QSqlError*',
+'QSqlError' => 'qt_QSqlError*',
+'QSqlError*' => 'qt_QSqlError*',
+'QSqlField&' => 'qt_QSqlField*',
+'QSqlField' => 'qt_QSqlField*',
+'QSqlField*' => 'qt_QSqlField*',
+'QSqlFieldInfo&' => 'qt_QSqlFieldInfo*',
+'QSqlFieldInfo*' => 'qt_QSqlFieldInfo*',
+'QSqlForm' => 'qt_QSqlForm*',
+'QSqlForm*' => 'qt_QSqlForm*',
+'QSqlIndex&' => 'qt_QSqlIndex*',
+'QSqlIndex' => 'qt_QSqlIndex*',
+'QSqlIndex*' => 'qt_QSqlIndex*',
+'QSqlPropertyMap*' => 'qt_QSqlPropertyMap*',
+'QSqlQuery&' => 'qt_QSqlQuery*',
+'QSqlQuery' => 'qt_QSqlQuery*',
+'QSqlQuery*' => 'qt_QSqlQuery*',
+'QSqlRecord&' => 'qt_QSqlRecord*',
+'QSqlRecord' => 'qt_QSqlRecord*',
+'QSqlRecord*' => 'qt_QSqlRecord*',
+'QSqlRecordInfo&' => 'qt_QSqlRecordInfo*',
+'QSqlRecordInfo' => 'qt_QSqlRecordInfo*',
+'QSqlRecordInfo*' => 'qt_QSqlRecordInfo*',
+'QSqlRecordPrivate*' => 'qt_QSqlRecordPrivate*',
+'QSqlRecordShared*' => 'qt_QSqlRecordShared*',
+'QSqlResult' => 'qt_QSqlResult*',
+'QSqlResult*' => 'qt_QSqlResult*',
+'QSqlResultShared*' => 'qt_QSqlResultShared*',
+'QStack*' => 'qt_QStack*',
+'QStatusBar*' => 'qt_QStatusBar*' ,
+'QStoredDrag*' => 'qt_QStoredDrag*',
+'QStrIList' => 'kde_QStrIList',
+'QStrIList*' => 'qt_QStrIList*',
+'QStrIVec*' => 'qt_QStrIVec*',
+'QStrList&' => 'qt_QStrList *',
+'QStrList' => 'qt_QStrList *',
+'QStrList*' => 'qt_QStrList *',
+'QStrListIterator*' => 'qt_QStrListIterator*',
+'QStrVec*' => 'qt_QStrVec*',
+'QString&' => 'qt_QString *',
+'QString&::null' => 'qt_QString*' ,
+'QString&button0Text::null' => 'qt_QString*' ,
+'QString&button1Text::null' => 'qt_QString*' ,
+'QString&button2Text::null' => 'qt_QString*' ,
+'QString&buttonText::null' => 'qt_QString*' ,
+'QString&caption::null' => 'qt_QString*' ,
+'QString&charSet::null' => 'qt_QString*' ,
+'QString&context::null' => 'qt_QString*' ,
+'QString&defValue::null' => 'qt_QString*' ,
+'QString&dir::null' => 'qt_QString*' ,
+'QString&directory::null' => 'qt_QString*' ,
+'QString&filter::null' => 'qt_QString*' ,
+'QString&initially::null' => 'qt_QString*' ,
+'QString&location::null' => 'qt_QString*' ,
+'QString&n::null' => 'qt_QString*' ,
+'QString&nameFilter::null' => 'qt_QString*' ,
+'QString&noButtonText::null' => 'qt_QString*' ,
+'QString&search_delimiters::null' => 'qt_QString*' ,
+'QString&style::null' => 'qt_QString*' ,
+'QString&suffix::null' => 'qt_QString*' ,
+'QString&text::null' => 'qt_QString*' ,
+'QString&text_::null' => 'qt_QString*' ,
+'QString&translation::null' => 'qt_QString*' ,
+'QString&yesButtonText::null' => 'qt_QString*' ,
+'QString' => 'qt_QString *',
+'QString*' => 'qt_QString*' ,
+'QString::null' => 'qt_QString_null()' ,
+'QStringBucket*' => 'qt_QStringBucket*',
+'QStringData*' => 'qt_QStringData*',
+'QStringList&' => 'qt_QStringList*' ,
+'QStringList' => 'qt_QStringList*' ,
+'QStringList*' => 'qt_QStringList*' ,
+'QStringcharSetName::null' => 'qt_QStringcharSetName*' ,
+'QStyle&' => 'qt_QStyle*' ,
+'QStyle*' => 'qt_QStyle*' ,
+'QStyle::ScrollControl' => 'int' ,
+'QStyle::StylePixmap' => 'int',
+'QStyle::SubControl' => 'int',
+'QStyle::SubRect' => 'int',
+'QStyleFactory*' => 'qt_QStyleFactory*',
+'QStyleFactoryInterface*' => 'qt_QStyleFactoryInterface*',
+'QStyleHintReturn*' => 'qt_QStyleHintReturn*',
+'QStyleOption&' => 'int',
+'QStyleOption' => 'int',
+'QStyleOption*' => 'int*',
+'QStylePlugin*' => 'qt_QStylePlugin*',
+'QStyleSheet*' => 'qt_QStyleSheet*' ,
+'QStyleSheetItem&' => 'qt_QStyleSheetItem*' ,
+'QStyleSheetItem*' => 'qt_QStyleSheetItem*' ,
+'QStyleSheetItem::DisplayMode*' => 'int',
+'QStyleSheetItem::ListStyle*' => 'int',
+'QStyleSheetItem::WhiteSpaceMode' => 'int',
+'QTSCIICodec*' => 'qt_QTSCIICodec*',
+'QTSMFI' => 'int' ,
+'QTab*' => 'qt_QTab*',
+'QTabBar*' => 'qt_QTabBar*' ,
+'QTabBar::Shape' => 'int' ,
+'QTabDialog*' => 'qt_QTabDialog*',
+'QTabWidget*' => 'qt_QTabWidget*',
+'QTable*' => 'qt_QTable*' ,
+'QTableHeader*' => 'qt_QTableHeader*',
+'QTableItem*' => 'qt_QTableItem*' ,
+'QTableSelection&' => 'qt_QTableSelection*' ,
+'QTableSelection' => 'qt_QTableSelection*' ,
+'QTableSelection*' => 'qt_QTableSelection*',
+'QTableView*' => 'qt_QTableView*',
+'QTabletEvent*' => 'qt_QTabletEvent*',
+'QTextBrowser*' => 'qt_QTextBrowser*',
+'QTextCodec*' => 'qt_QTextCodec*' ,
+'QTextCodecFactory*' => 'qt_QTextCodecFactory*',
+'QTextCodecFactoryInterface*' => 'qt_QTextCodecFactoryInterface*',
+'QTextCodecPlugin*' => 'qt_QTextCodecPlugin*',
+'QTextCursor*' => 'qt_QTextCursor*',
+'QTextDecoder*' => 'qt_QTextDecoder*' ,
+'QTextDocument*' => 'qt_QTextDocument*',
+'QTextDrag*' => 'qt_QTextDrag*',
+'QTextEdit*' => 'qt_QTextEdit*',
+'QTextEncoder*' => 'qt_QTextEncoder*' ,
+'QTextFormat*' => 'qt_QTextFormat*',
+'QTextIStream*' => 'qt_QTextIStream*',
+'QTextOStream&' => 'qt_QTextOStream*' ,
+'QTextOStream*' => 'qt_QTextOStream*',
+'QTextOStreamIterator*' => 'qt_QTextOStreamIterator*',
+'QTextParag**' => 'qt_QTextParag**',
+'QTextStream&' => 'qt_QTextStream*' ,
+'QTextStream*' => 'qt_QTextStream*' ,
+'QTextView*' => 'qt_QTextView*',
+'QThread*' => 'qt_QThread*',
+'QThreadData*' => 'qt_QThreadData*',
+'QThreadEvent*' => 'qt_QThreadEvent*',
+'QTime&' => 'qt_QTime *',
+'QTime' => 'qt_QTime *',
+'QTime*' => 'qt_QTime*',
+'QTimeEdit*' => 'qt_QTimeEdit*',
+'QTimeWatch*' => 'qt_QTimeWatch*',
+'QTimer*' => 'qt_QTimer*',
+'QTimerEvent*' => 'qt_QTimerEvent*' ,
+'QToolBar*' => 'qt_QToolBar*' ,
+'QToolButton*' => 'qt_QToolButton*' ,
+'QToolTip*' => 'qt_QToolTip*',
+'QToolTipGroup*' => 'qt_QToolTipGroup *',
+'QTranslator*' => 'qt_QTranslator*' ,
+'QTranslatorMessage&' => 'qt_QTranslatorMessage*' ,
+'QTranslatorMessage' => 'qt_QTranslatorMessage*' ,
+'QTranslatorMessage*' => 'qt_QTranslatorMessage*',
+'QTsciiCodec*' => 'qt_QTsciiCodec*',
+'QUObject*' => 'qt_QUObject*',
+'QUnknownInterface*' => 'qt_QUnknownInterface*',
+'QUnknownInterface**' => 'qt_QUnknownInterface**',
+'QUriDrag*' => 'qt_QUriDrag*',
+'QUrl&' => 'qt_QUrl*' ,
+'QUrl' => 'qt_QUrl*' ,
+'QUrl*' => 'qt_QUrl*',
+'QUrlInfo&' => 'qt_QUrlInfo*' ,
+'QUrlInfo' => 'qt_QUrlInfo*' ,
+'QUrlInfo*' => 'qt_QUrlInfo*',
+'QUrlOperator&' => 'qt_QUrlOperator*' ,
+'QUrlOperator*' => 'qt_QUrlOperator*' ,
+'QUtf16Codec*' => 'qt_QUtf16Codec*',
+'QUtf8Codec*' => 'qt_QUtf8Codec*',
+'QUuid&' => 'qt_QUuid*',
+'QUuid*' => 'qt_QUuid*',
+'QVBox*' => 'qt_QVBox*' ,
+'QVBoxLayout*' => 'qt_QVBoxLayout*',
+'QVButtonGroup*' => 'qt_QVButtonGroup*',
+'QVFbHeader*' => 'qt_QVFbHeader*',
+'QVFbKeyData*' => 'qt_QVFbKeyData*',
+'QVGroupBox*' => 'qt_QVGroupBox*',
+'QValidator*' => 'qt_QValidator *',
+'QValidator::State' => 'int',
+'QValueList*' => 'qt_QValueList*',
+'QValueListConstIterator*' => 'qt_QValueListConstIterator*',
+'QValueListIterator*' => 'qt_QValueListIterator*',
+'QValueListNode*' => 'qt_QValueListNode*',
+'QValueListPrivate*' => 'qt_QValueListPrivate*',
+'QValueStack*' => 'qt_QValueStack*',
+'QValueVector*' => 'qt_QValueVector*',
+'QValueVectorPrivate*' => 'qt_QValueVectorPrivate*',
+'QVariant&' => 'qt_QVariant *',
+'QVariant' => 'qt_QVariant *',
+'QVariant*' => 'qt_QVariant*',
+'QVariant::Type' => 'int' ,
+'QVariantPrivate*' => 'qt_QVariantPrivate*' ,
+'QVector*' => 'qt_QVector*',
+'QWMatrix&' => 'qt_QWMatrix *',
+'QWMatrix' => 'qt_QWMatrix *',
+'QWMatrix*' => 'qt_QWMatrix*',
+'QWSDecoration&' => 'qt_QWSDecoration*' ,
+'QWSDecoration*' => 'qt_QWSDecoration*' ,
+'QWSDisplay*' => 'qt_QWSDisplay*' ,
+'QWSEvent*' => 'qt_QWSEvent*' ,
+'QWaitCondition*' => 'qt_QWaitCondition*',
+'QWhatsThis*' => 'qt_QWhatsThis*',
+'QWheelEvent*' => 'qt_QWheelEvent*' ,
+'QWidget *' => 'qt_QWidget *',
+'QWidget' => 'qt_QWidget *',
+'QWidget*' => 'qt_QWidget *',
+'QWidgetFactory*' => 'qt_QWidgetFactory*',
+'QWidgetIntDict&' => 'qt_QWidgetIntDict*' ,
+'QWidgetIntDict*' => 'qt_QWidgetIntDict*',
+'QWidgetIntDictIt&' => 'qt_QWidgetIntDictIt*' ,
+'QWidgetIntDictIt*' => 'qt_QWidgetIntDictIt*',
+'QWidgetItem*' => 'qt_QWidgetItem*',
+'QWidgetList&' => 'qt_QWidgetList *' ,
+'QWidgetList&' => 'qt_QWidgetList*' ,
+'QWidgetList' => 'qt_QWidgetList *' ,
+'QWidgetList' => 'qt_QWidgetList*' ,
+'QWidgetList*' => 'qt_QWidgetList *',
+'QWidgetList*' => 'qt_QWidgetList*',
+'QWidgetListIt&' => 'qt_QWidgetListIt*' ,
+'QWidgetListIt*' => 'qt_QWidgetListIt*',
+'QWidgetMapper*' => 'qt_QWidgetMapper*',
+'QWidgetPlugin*' => 'qt_QWidgetPlugin*',
+'QWidgetStack*' => 'qt_QWidgetStack*',
+'QWindowsMime*' => 'qt_QWindowsMime*' ,
+'QWindowsStyle*' => 'qt_QWindowsStyle*',
+'QWizard*' => 'qt_QWizard*',
+'QWorkspace*' => 'qt_QWorkspace*',
+'QXEmbed*' => 'qt_QXEmbed*' ,
+'QXmlAttributes&' => 'qt_QXmlAttributes*' ,
+'QXmlAttributes*' => 'qt_QXmlAttributes*',
+'QXmlContentHandler*' => 'qt_QXmlContentHandler*' ,
+'QXmlDTDHandler*' => 'qt_QXmlDTDHandler*' ,
+'QXmlDeclHandler*' => 'qt_QXmlDeclHandler*' ,
+'QXmlDefaultHandler*' => 'qt_QXmlDefaultHandler*',
+'QXmlEntityResolver*' => 'qt_QXmlEntityResolver*' ,
+'QXmlErrorHandler*' => 'qt_QXmlErrorHandler*' ,
+'QXmlInputSource&' => 'qt_QXmlInputSource*' ,
+'QXmlInputSource*&' => 'qt_QXmlInputSource*',
+'QXmlInputSource*' => 'qt_QXmlInputSource*' ,
+'QXmlLexicalHandler*' => 'qt_QXmlLexicalHandler*' ,
+'QXmlLocator*' => 'qt_QXmlLocator*' ,
+'QXmlNamespaceSupport*' => 'qt_QXmlNamespaceSupport*',
+'QXmlParseException&' => 'qt_QXmlParseException*' ,
+'QXmlParseException*' => 'qt_QXmlParseException*',
+'QXmlReader*' => 'qt_QXmlReader*',
+'QXmlSimpleReader*' => 'qt_QXmlSimpleReader*' ,
+'QXtApplication*' => 'qt_QXtApplication*',
+'QXtWidget*' => 'qt_QXtWidget*',
+'Q_INT16&' => 'short',
+'Q_INT16' => 'short',
+'Q_INT32&' => 'int',
+'Q_INT32' => 'int',
+'Q_INT8&' => 'char',
+'Q_INT8' => 'char',
+'Q_LONG&' => 'long',
+'Q_LONG' => 'long',
+'Q_PACKED*' => 'void*',
+'Q_UINT16&' => 'unsigned short',
+'Q_UINT16' => 'unsigned short',
+'Q_UINT32&' => 'unsigned int',
+'Q_UINT32' => 'unsigned int',
+'Q_UINT8&' => 'unsigned char',
+'Q_UINT8' => 'unsigned char',
+'Q_UINT8*' => 'unsigned char*' ,
+'Q_ULONG&' => 'long',
+'Q_ULONG' => 'long',
+'Qt*' => 'qt_Qt*' ,
+'Qt::ArrowType' => 'int' ,
+'Qt::BackgroundMode' => 'int',
+'Qt::DateFormat' => 'int',
+'Qt::GUIStyle' => 'int' ,
+'Qt::GUIStylecolorStyle::WindowsStyle' => 'int' ,
+'Qt::GUIStylestyle::WindowsStyle' => 'int' ,
+'Qt::Orientation' => 'int' ,
+'Qt::RasterOp' => 'int' ,
+'Qt::UIEffect' => 'int' ,
+'Qt::WFlags' => 'int' ,
+'QtMultiLineEdit*' => 'qt_QtMultiLineEdit*',
+'QtMultiLineEditRow*' => 'qt_QtMultiLineEditRow*',
+'QtTableView*' => 'qt_QtTableView*',
+'QwAbsSpriteFieldView*' => 'qt_QwAbsSpriteFieldView*' ,
+'QwClusterizer*' => 'qt_QwClusterizer*' ,
+'QwEllipse*' => 'qt_QwEllipse*',
+'QwImageSpriteField*' => 'qt_QwImageSpriteField*',
+'QwMobilePositionedSprite*' => 'qt_QwMobilePositionedSprite*',
+'QwMobileSprite*' => 'qt_QwMobileSprite*',
+'QwPolygon*' => 'qt_QwPolygon*',
+'QwPolygonalGraphic*' => 'qt_QwPolygonalGraphic*',
+'QwPositionedSprite*' => 'qt_QwPositionedSprite*',
+'QwPublicList*' => 'qt_QwPublicList*' ,
+'QwRealMobileSprite*' => 'qt_QwRealMobileSprite*',
+'QwRealSprite*' => 'qt_QwRealSprite*',
+'QwRectangle*' => 'qt_QwRectangle*',
+'QwScrollingSpriteFieldView*' => 'qt_QwScrollingSpriteFieldView*',
+'QwSprite*' => 'qt_QwSprite*',
+'QwSpriteField*' => 'qt_QwSpriteField*' ,
+'QwSpriteField*' => 'qt_QwSpriteField*' ,
+'QwSpriteFieldGraphic&' => 'qt_QwSpriteFieldGraphic*' ,
+'QwSpriteFieldGraphic*' => 'qt_QwSpriteFieldGraphic*' ,
+'QwSpriteFieldView*' => 'qt_QwSpriteFieldView*',
+'QwSpritePixmap*' => 'qt_QwSpritePixmap*' ,
+'QwSpritePixmapSequence*' => 'qt_QwSpritePixmapSequence*' ,
+'QwTextSprite*' => 'qt_QwTextSprite*',
+'QwTiledSpriteField*' => 'qt_QwTiledSpriteField*',
+'QwVirtualSprite*' => 'qt_QwVirtualSprite*',
+'RArray*' => 'kde_RArray*',
+'RGBColor&' => 'kde_RGBColor*',
+'RGBColor' => 'kde_RGBColor*',
+'RGBColor*' => 'kde_RGBColor*',
+'Range&' => 'kde_Range*',
+'Range' => 'kde_Range*',
+'Range*' => 'kde_Range*',
+'RangeException&' => 'kde_RangeException*',
+'RangeException*' => 'kde_RangeException*',
+'RangeImpl*' => 'kde_RangeImpl*',
+'RasterOp' => 'int',
+'RawDataPacket*' => 'kde_RawDataPacket*',
+'ReadOnlyPart*' => 'kde_ReadOnlyPart*',
+'ReadWritePart*' => 'kde_ReadWritePart*',
+'Rect&' => 'kde_Rect*',
+'Rect' => 'kde_Rect*',
+'Rect*' => 'kde_Rect*',
+'Reference&' => 'kde_Reference*',
+'Reference*' => 'kde_Reference*',
+'ReferenceClean*' => 'kde_ReferenceClean*',
+'ReferenceHelper*' => 'kde_ReferenceHelper*',
+'Region' => 'int',
+'RegionType' => 'int',
+'RemoteScheduleNode*' => 'kde_RemoteScheduleNode*',
+'RenameDlg*' => 'kde_RenameDlg*',
+'RenderStyle*' => 'kde_RenderStyle*' ,
+'Rep*' => 'kde_Rep*',
+'RunMode' => 'int' ,
+'SButton*' => 'kde_SButton*',
+'SCFlags' => 'int',
+'SFlags' => 'int',
+'ScheduleNode*' => 'kde_ScheduleNode*',
+'Scheduler*' => 'kde_Scheduler*',
+'ScrollBarMode' => 'int',
+'ScrollControl' => 'int' ,
+'SearchInterface*' => 'kde_SearchInterface*',
+'Section&' => 'kde_Section*' ,
+'Section*&' => 'kde_Section*' ,
+'Section*' => 'kde_Section*' ,
+'SegmentStyle' => 'int',
+'SelectionInterface*' => 'kde_SelectionInterface*',
+'Separator' => 'int',
+'Server&' => 'Server*' ,
+'Server*' => 'kde_Server*',
+'ServerHello&' => 'kde_ServerHello*',
+'ServerHello*' => 'kde_ServerHello*',
+'Service*' => 'kde_Service*',
+'SessionData*' => 'kde_SessionData*',
+'SimpleFormat*' => 'kde_SimpleFormat*',
+'SimpleJob*' => 'kde_SimpleJob*',
+'SimpleSoundServer&' => 'kde_SimpleSoundServer*',
+'SimpleSoundServer' => 'kde_SimpleSoundServer*',
+'SimpleSoundServer*' => 'kde_SimpleSoundServer*',
+'SimpleSoundServer_base*' => 'kde_SimpleSoundServer_base*',
+'SimpleSoundServer_skel*' => 'kde_SimpleSoundServer_skel*',
+'SimpleSoundServer_stub*' => 'kde_SimpleSoundServer_stub*',
+'SkipDlg*' => 'kde_SkipDlg*',
+'Slave*' => 'kde_Slave*',
+'SlaveBase*' => 'kde_SlaveBase*',
+'SlaveBasePrivate*' => 'kde_SlaveBasePrivate*',
+'SlaveConfig*' => 'kde_SlaveConfig*',
+'SlaveInterface*' => 'kde_SlaveInterface*',
+'SocketConnection*' => 'kde_SocketConnection*',
+'Spec' => 'int',
+'SpecialEvent*' => 'kde_SpecialEvent*',
+'SshProcess*' => 'kde_SshProcess*',
+'SshProcessPrivate*' => 'kde_SshProcessPrivate*',
+'StartupClass*' => 'kde_StartupClass*',
+'StartupManager*' => 'kde_StartupManager*',
+'StatJob*' => 'kde_StatJob*',
+'State' => 'int',
+'QSocket::State' => 'int',
+'StatusbarProgress*' => 'kde_StatusbarProgress*',
+'StdAddressBook*' => 'kde_StdAddressBook*',
+'StdFlowSystem*' => 'kde_StdFlowSystem*',
+'StdIOManager*' => 'kde_StdIOManager*',
+'StdScheduleNode*' => 'kde_StdScheduleNode*',
+'StdSynthModule*' => 'kde_StdSynthModule*',
+'StereoEffect&' => 'kde_StereoEffect*',
+'StereoEffect' => 'kde_StereoEffect*',
+'StereoEffect*' => 'kde_StereoEffect*',
+'StereoEffectStack&' => 'kde_StereoEffectStack*',
+'StereoEffectStack' => 'kde_StereoEffectStack*',
+'StereoEffectStack*' => 'kde_StereoEffectStack*',
+'StereoEffectStack_base*' => 'kde_StereoEffectStack_base*',
+'StereoEffectStack_skel*' => 'kde_StereoEffectStack_skel*',
+'StereoEffectStack_stub*' => 'kde_StereoEffectStack_stub*',
+'StereoEffect_base*' => 'kde_StereoEffect_base*',
+'StereoEffect_skel*' => 'kde_StereoEffect_skel*',
+'StereoEffect_stub*' => 'kde_StereoEffect_stub*',
+'StereoFFTScope&' => 'kde_StereoFFTScope*',
+'StereoFFTScope' => 'kde_StereoFFTScope*',
+'StereoFFTScope*' => 'kde_StereoFFTScope*',
+'StereoFFTScope_base*' => 'kde_StereoFFTScope_base*',
+'StereoFFTScope_skel*' => 'kde_StereoFFTScope_skel*',
+'StereoFFTScope_stub*' => 'kde_StereoFFTScope_stub*',
+'StereoVolumeControl&' => 'kde_StereoVolumeControl*',
+'StereoVolumeControl' => 'kde_StereoVolumeControl*',
+'StereoVolumeControl*' => 'kde_StereoVolumeControl*',
+'StereoVolumeControl_base*' => 'kde_StereoVolumeControl_base*',
+'StereoVolumeControl_skel*' => 'kde_StereoVolumeControl_skel*',
+'StereoVolumeControl_stub*' => 'kde_StereoVolumeControl_stub*',
+'StreamMode&' => 'int',
+'String*' => 'kde_String*',
+'StringSectionMap::iterator&' => 'kde_StringSectionMap*' ,
+'StringSectionMap::iterator' => 'kde_StringSectionMap*r' ,
+'StubProcess*' => 'kde_StubProcess*',
+'StyleHint' => 'int',
+'StyleListImpl*' => 'kde_StyleListImpl*',
+'StylePixmap' => 'int',
+'StyleSheet&' => 'kde_StyleSheet*',
+'StyleSheet' => 'kde_StyleSheet*',
+'StyleSheet*' => 'kde_StyleSheet*',
+'StyleSheetImpl*' => 'kde_StyleSheetImpl*',
+'StyleSheetList&' => 'kde_StyleSheetList*',
+'StyleSheetList' => 'kde_StyleSheetList',
+'StyleSheetList*' => 'kde_StyleSheetList*',
+'StyleSheetListImpl*' => 'kde_StyleSheetListImpl*',
+'StyleStrategy' => 'int',
+'SuProcess*' => 'kde_SuProcess*',
+'SubClass&' => 'kde_SubClass*',
+'SubClass*' => 'kde_SubClass*',
+'SubControl' => 'int',
+'SubRect' => 'int',
+'SynthBuffer*' => 'kde_SynthBuffer*',
+'SynthModule&' => 'kde_SynthModule*',
+'SynthModule' => 'kde_SynthModule*',
+'SynthModule*' => 'kde_SynthModule*',
+'SynthModule_base*' => 'kde_SynthModule_base*',
+'SynthModule_skel*' => 'kde_SynthModule_skel*',
+'SynthModule_stub*' => 'kde_SynthModule_stub*',
+'SynthOut*' => 'kde_SynthOut*',
+'Synth_ADD&' => 'kde_Synth_ADD*',
+'Synth_ADD' => 'kde_Synth_ADD*',
+'Synth_ADD*' => 'kde_Synth_ADD*',
+'Synth_ADD_base*' => 'kde_Synth_ADD_base*',
+'Synth_ADD_skel*' => 'kde_Synth_ADD_skel*',
+'Synth_ADD_stub*' => 'kde_Synth_ADD_stub*',
+'Synth_AMAN_PLAY&' => 'kde_Synth_AMAN_PLAY*',
+'Synth_AMAN_PLAY' => 'kde_Synth_AMAN_PLAY*',
+'Synth_AMAN_PLAY*' => 'kde_Synth_AMAN_PLAY*',
+'Synth_AMAN_PLAY_base*' => 'kde_Synth_AMAN_PLAY_base*',
+'Synth_AMAN_PLAY_skel*' => 'kde_Synth_AMAN_PLAY_skel*',
+'Synth_AMAN_PLAY_stub*' => 'kde_Synth_AMAN_PLAY_stub*',
+'Synth_AMAN_RECORD&' => 'kde_Synth_AMAN_RECORD*',
+'Synth_AMAN_RECORD' => 'kde_Synth_AMAN_RECORD*',
+'Synth_AMAN_RECORD*' => 'kde_Synth_AMAN_RECORD*',
+'Synth_AMAN_RECORD_base*' => 'kde_Synth_AMAN_RECORD_base*',
+'Synth_AMAN_RECORD_skel*' => 'kde_Synth_AMAN_RECORD_skel*',
+'Synth_AMAN_RECORD_stub*' => 'kde_Synth_AMAN_RECORD_stub*',
+'Synth_BUS_DOWNLINK&' => 'kde_Synth_BUS_DOWNLINK*',
+'Synth_BUS_DOWNLINK' => 'kde_Synth_BUS_DOWNLINK*',
+'Synth_BUS_DOWNLINK*' => 'kde_Synth_BUS_DOWNLINK*',
+'Synth_BUS_DOWNLINK_base*' => 'kde_Synth_BUS_DOWNLINK_base*',
+'Synth_BUS_DOWNLINK_skel*' => 'kde_Synth_BUS_DOWNLINK_skel*',
+'Synth_BUS_DOWNLINK_stub*' => 'kde_Synth_BUS_DOWNLINK_stub*',
+'Synth_BUS_UPLINK&' => 'kde_Synth_BUS_UPLINK*',
+'Synth_BUS_UPLINK' => 'kde_Synth_BUS_UPLINK*',
+'Synth_BUS_UPLINK*' => 'kde_Synth_BUS_UPLINK*',
+'Synth_BUS_UPLINK_base*' => 'kde_Synth_BUS_UPLINK_base*',
+'Synth_BUS_UPLINK_skel*' => 'kde_Synth_BUS_UPLINK_skel*',
+'Synth_BUS_UPLINK_stub*' => 'kde_Synth_BUS_UPLINK_stub*',
+'Synth_FREQUENCY&' => 'kde_Synth_FREQUENCY*',
+'Synth_FREQUENCY' => 'kde_Synth_FREQUENCY*',
+'Synth_FREQUENCY*' => 'kde_Synth_FREQUENCY*',
+'Synth_FREQUENCY_base*' => 'kde_Synth_FREQUENCY_base*',
+'Synth_FREQUENCY_skel*' => 'kde_Synth_FREQUENCY_skel*',
+'Synth_FREQUENCY_stub*' => 'kde_Synth_FREQUENCY_stub*',
+'Synth_MUL&' => 'kde_Synth_MUL*',
+'Synth_MUL' => 'kde_Synth_MUL*',
+'Synth_MUL*' => 'kde_Synth_MUL*',
+'Synth_MULTI_ADD&' => 'kde_Synth_MULTI_ADD*',
+'Synth_MULTI_ADD' => 'kde_Synth_MULTI_ADD*',
+'Synth_MULTI_ADD*' => 'kde_Synth_MULTI_ADD*',
+'Synth_MULTI_ADD_base*' => 'kde_Synth_MULTI_ADD_base*',
+'Synth_MULTI_ADD_skel*' => 'kde_Synth_MULTI_ADD_skel*',
+'Synth_MULTI_ADD_stub*' => 'kde_Synth_MULTI_ADD_stub*',
+'Synth_MUL_base*' => 'kde_Synth_MUL_base*',
+'Synth_MUL_skel*' => 'kde_Synth_MUL_skel*',
+'Synth_MUL_stub*' => 'kde_Synth_MUL_stub*',
+'Synth_PLAY&' => 'kde_Synth_PLAY*',
+'Synth_PLAY' => 'kde_Synth_PLAY*',
+'Synth_PLAY*' => 'kde_Synth_PLAY*',
+'Synth_PLAY_WAV&' => 'kde_Synth_PLAY_WAV*',
+'Synth_PLAY_WAV' => 'kde_Synth_PLAY_WAV*',
+'Synth_PLAY_WAV*' => 'kde_Synth_PLAY_WAV*',
+'Synth_PLAY_WAV_base*' => 'kde_Synth_PLAY_WAV_base*',
+'Synth_PLAY_WAV_skel*' => 'kde_Synth_PLAY_WAV_skel*',
+'Synth_PLAY_WAV_stub*' => 'kde_Synth_PLAY_WAV_stub*',
+'Synth_PLAY_base*' => 'kde_Synth_PLAY_base*',
+'Synth_PLAY_skel*' => 'kde_Synth_PLAY_skel*',
+'Synth_PLAY_stub*' => 'kde_Synth_PLAY_stub*',
+'Synth_RECORD&' => 'kde_Synth_RECORD*',
+'Synth_RECORD' => 'kde_Synth_RECORD*',
+'Synth_RECORD*' => 'kde_Synth_RECORD*',
+'Synth_RECORD_base*' => 'kde_Synth_RECORD_base*',
+'Synth_RECORD_skel*' => 'kde_Synth_RECORD_skel*',
+'Synth_RECORD_stub*' => 'kde_Synth_RECORD_stub*',
+'Synth_WAVE_SIN&' => 'kde_Synth_WAVE_SIN*',
+'Synth_WAVE_SIN' => 'kde_Synth_WAVE_SIN*',
+'Synth_WAVE_SIN*' => 'kde_Synth_WAVE_SIN*',
+'Synth_WAVE_SIN_base*' => 'kde_Synth_WAVE_SIN_base*',
+'Synth_WAVE_SIN_skel*' => 'kde_Synth_WAVE_SIN_skel*',
+'Synth_WAVE_SIN_stub*' => 'kde_Synth_WAVE_SIN_stub*',
+'T&' => 'T*' ,
+'T' => 'T*' ,
+'T*' => 'T*' ,
+'TCPConnection*' => 'kde_TCPConnection*',
+'TCPServer*' => 'kde_TCPServer*',
+'TCPSlaveBase*' => 'kde_TCPSlaveBase*',
+'TRUE' => '1',
+'Task*' => 'kde_Task*',
+'Text&' => 'kde_Text*',
+'Text' => 'kde_Text*',
+'Text*' => 'kde_Text*',
+'TextFormat' => 'int' ,
+'TextImpl*' => 'kde_TextImpl*',
+'ThumbCreator*' => 'kde_ThumbCreator*',
+'TickSetting' => 'int',
+'Ticket*' => 'kde_Ticket*',
+'TimeNotify*' => 'kde_TimeNotify*',
+'TimeWatcher*' => 'kde_TimeWatcher*',
+'TimeZone&' => 'kde_TimeZone*',
+'TimeZone*' => 'kde_TimeZone*',
+'TmpGlobalComm&' => 'kde_TmpGlobalComm*',
+'TmpGlobalComm' => 'kde_TmpGlobalComm*',
+'TmpGlobalComm*' => 'kde_TmpGlobalComm*',
+'TmpGlobalComm_base*' => 'kde_TmpGlobalComm_base*',
+'TmpGlobalComm_skel*' => 'kde_TmpGlobalComm_skel*',
+'TmpGlobalComm_stub*' => 'kde_TmpGlobalComm_stub*',
+'ToolBarDock&' => 'int' ,
+'ToolBarDock' => 'int',
+'TraderOffer&' => 'kde_TraderOffer*',
+'TraderOffer' => 'kde_TraderOffer*',
+'TraderOffer*' => 'kde_TraderOffer*',
+'TraderOffer_base*' => 'kde_TraderOffer_base*',
+'TraderOffer_skel*' => 'kde_TraderOffer_skel*',
+'TraderOffer_stub*' => 'kde_TraderOffer_stub*',
+'TraderQuery&' => 'kde_TraderQuery*',
+'TraderQuery' => 'kde_TraderQuery*',
+'TraderQuery*' => 'kde_TraderQuery*',
+'TraderQuery_base*' => 'kde_TraderQuery_base*',
+'TraderQuery_skel*' => 'kde_TraderQuery_skel*',
+'TraderQuery_stub*' => 'kde_TraderQuery_stub*',
+'TransferJob*' => 'kde_TransferJob*',
+'TreeWalker&' => 'kde_TreeWalker*',
+'TreeWalker' => 'kde_TreeWalker*',
+'TreeWalker*' => 'kde_TreeWalker*',
+'TreeWalkerImpl*' => 'kde_TreeWalkerImpl*',
+'True' => '1',
+'Type&' => 'kde_Type*',
+'Type' => 'int',
+'Type*' => 'kde_Type*',
+'TypeComponent&' => 'kde_TypeComponent*',
+'TypeComponent*' => 'kde_TypeComponent*',
+'TypeDef&' => 'kde_TypeDef*',
+'TypeDef' => 'kde_TypeDef*',
+'TypeDef*' => 'kde_TypeDef*',
+'TypeEntry*' => 'kde_TypeEntry*',
+'TypeInfo*' => 'kde_TypeInfo*',
+'UChar&' => 'kde_UChar*',
+'UChar' => 'kde_UChar*',
+'UChar*' => 'kde_UChar*',
+'UCharReference&' => 'kde_UCharReference*',
+'UCharReference' => 'kde_UCharReference*',
+'UCharReference*' => 'kde_UCharReference*',
+'UDSAtom*' => 'kde_UDSAtom*',
+'UDSEntry&' => 'kde_UDSEntry*',
+'UDSEntryList&' => 'kde_UDSEntryList*',
+'UIServer*' => 'kde_UIServer*',
+'UIServer_stub*' => 'kde_UIServer_stub*',
+'ULONG_MAX' => 'ULONG_MAX',
+'URLArgs&' => 'kde_URLArgs*',
+'URLArgs' => 'kde_URLArgs*',
+'URLArgs*' => 'kde_URLArgs*',
+'UString&' => 'kde_UString*',
+'UString' => 'kde_UString*',
+'UString*' => 'kde_UString*',
+'Undefined*' => 'kde_Undefined*',
+'UndoInterface*' => 'kde_UndoInterface*',
+'UndoRedoInfo*' => 'int*',
+'UnixConnection*' => 'kde_UnixConnection*',
+'UnixServer*' => 'kde_UnixServer*',
+'VCardFormat*' => 'kde_VCardFormat*',
+'VPort*' => 'kde_VPort*',
+'Value&' => 'kde_Value*',
+'Value' => 'kde_Value*',
+'Value*' => 'kde_Value*',
+'VerticalAlignment*' => 'int*',
+'View*' => 'kde_View*' ,
+'ViewCursorInterface*' => 'kde_ViewCursorInterface*',
+'VoiceManager*' => 'kde_VoiceManager*',
+'WFlags' => 'int',
+'WId' => 'unsigned int',
+'WState' => 'int',
+'WavPlayObject&' => 'kde_WavPlayObject*',
+'WavPlayObject' => 'kde_WavPlayObject*',
+'WavPlayObject*' => 'kde_WavPlayObject*',
+'WavPlayObject_base*' => 'kde_WavPlayObject_base*',
+'WavPlayObject_skel*' => 'kde_WavPlayObject_skel*',
+'WavPlayObject_stub*' => 'kde_WavPlayObject_stub*',
+'WeakReference*' => 'kde_WeakReference*',
+'WeakReferenceBase*' => 'kde_WeakReferenceBase*',
+'Widget' => 'int' ,
+'WidgetClass' => 'int' ,
+'WidthMode' => 'int',
+'Window' => 'kde_Window*',
+'Window*' => 'kde_Window*',
+'WindowArgs&' => 'kde_WindowArgs*',
+'WindowArgs*' => 'kde_WindowArgs*',
+'WindowsVersion' => 'int' ,
+'XrmOptionDescRec*' => 'XrmOptionDescRec*' ,
+'array_data*' => 'void*' ,
+'bitarr_data*' => 'void*',
+'bool&' => 'int' ,
+'bool' => 'int',
+'bool*' => 'int*',
+'char *' => 'char *',
+'char&' => 'char' ,
+'char' => 'char',
+'char* bugsEmailAddress @bugs.kde.org"' => 'String',
+'char*&' => 'char*',
+'char*' => 'char*',
+'char**' => 'char**',
+'char*xpm[]' => 'char**' ,
+'classConnection*' => 'kde_classConnection*',
+'classDeviceManager*' => 'kde_classDeviceManager*',
+'classExtensionLoader*' => 'kde_classExtensionLoader*',
+'classMidiStatus*' => 'kde_classMidiStatus*',
+'classObjectReference' => 'kde_classObjectReference*',
+'classQPainter*' => 'kde_classQPainter*',
+'classStartupClass*' => 'kde_classStartupClass*',
+'double d .0' => 'double',
+'double nDefault .0' => 'double',
+'double pri .0' => 'double',
+'double&' => 'double' ,
+'double' => 'double',
+'double*' => 'double*' ,
+'false' => '0',
+'float desat .3' => 'float',
+'float&' => 'float' ,
+'float' => 'float',
+'float*' => 'float*',
+'image_io_handler' => 'int' ,
+'int a |' => 'int',
+'int buttonMask|Apply|Cancel' => 'int',
+'int buttonMask|No|Cancel' => 'int',
+'int desktop' => 'int',
+'int&' => 'int',
+'int' => 'int',
+'int*' => 'int*',
+'kdbgstream&' => 'kde_Kdbgstream*' ,
+'kdbgstream*' => 'kde_kdbgstream*',
+'khtml*' => 'kde_khtml*',
+'khtml::ChildFrame*' => 'kde_khtml_ChildFrame*' ,
+'khtml::DrawContentsEvent*' => 'kde_khtml_DrawContentsEvent*' ,
+'khtml::MouseDoubleClickEvent*' => 'kde_khtml_MouseDoubleClickEvent*' ,
+'khtml::MouseMoveEvent*' => 'kde_khtml_MouseMoveEvent*' ,
+'khtml::MousePressEvent*' => 'kde_khtml_MousePressEvent*' ,
+'khtml::MouseReleaseEvent*' => 'kde_khtml_MouseReleaseEvent*' ,
+'khtml::RenderObject*' => 'kde_khtml_RenderObject*' ,
+'khtml::RenderStyle*' => 'kde_khtml_RenderStyle*' ,
+'khtml__DrawContentsEvent*' => 'kde_khtml__DrawContentsEvent*',
+'khtml__MouseDoubleClickEvent*' => 'kde_khtml__MouseDoubleClickEvent*',
+'khtml__MouseEvent*' => 'kde_khtml__MouseEvent*',
+'khtml__MouseMoveEvent*' => 'kde_khtml__MouseMoveEvent*',
+'khtml__MousePressEvent*' => 'kde_khtml__MousePressEvent*',
+'khtml__MouseReleaseEvent*' => 'kde_khtml__MouseReleaseEvent*',
+'kndbgstream&' => 'void**' ,
+'kndbgstream*' => 'kde_kndbgstream*',
+'ksockaddr_in*' => 'void*' ,
+'long _blockSize *' => 'long *',
+'long int' => 'long',
+'long unsigned int' => 'long',
+'long&' => 'long' ,
+'long' => 'long',
+'long_blockSize*' => 'long_blockSize*' ,
+'longint' => 'long',
+'longunsigned int' => 'unsigned long',
+'lt_dlhandle' => 'void *' ,
+'lt_user_dlloader*' => 'kde_lt_user_dlloader*',
+'mcopbyte&' => 'void *',
+'mcopbyte' => 'unsigned char',
+'mode_t _mode (mode_t) -1' => 'int',
+'mode_t' => 'long' ,
+'noteCmd' => 'kde_noteCmd*',
+'noteCmd*' => 'kde_noteCmd*',
+'ostream&' => 'int',
+'ostream*' => 'int',
+'pid_t' => 'long' ,
+'poTime&' => 'kde_poTime*',
+'poTime*' => 'kde_poTime*',
+'short unsigned' => 'short',
+'short' => 'short',
+'short*' => 'short*',
+'shortunsigned' => 'unsigned short',
+'signed int&' => 'signed int' ,
+'signed long&' => 'signed long' ,
+'signed short&' => 'signed short' ,
+'signed' => 'signed' ,
+'size_t' => 'int' ,
+'size_t*' => 'int*',
+'size_type' => 'int' ,
+'snd_seq_event_t*' => 'int*',
+'ssize_t' => 'int',
+'std*' => 'kde_std*',
+'std::string&' => 'char *' ,
+'std::string' => 'char *' ,
+'time_t' => 'long' ,
+'timeval&' => 'int',
+'true' => '1',
+'type&' => 'int' ,
+'type*' => 'int*' ,
+'type**' => 'int**' ,
+'uchar&' => 'unsigned char' ,
+'uchar' => 'unsigned char' ,
+'uchar*' => 'unsigned char*',
+'uchar**' => 'unsigned char**',
+'uint&' => 'unsigned int',
+'uint' => 'unsigned int',
+'uint*' => 'unsigned int*' ,
+'uintf~0' => 'unsigned int' ,
+'ulong' => 'unsigned long',
+'unsigned char&' => 'unsigned char',
+'unsigned char' => 'unsigned char' ,
+'unsigned char*' => 'unsigned char*' ,
+'unsigned int&' => 'unsigned int' ,
+'unsigned int' => 'unsigned int' ,
+'unsigned int*' => 'int*' ,
+'unsigned long int' => 'long',
+'unsigned long&' => 'unsigned long' ,
+'unsigned long' => 'unsigned long' ,
+'unsigned short int' => 'unsigned short' ,
+'unsigned short&' => 'unsigned short' ,
+'unsigned short' => 'unsigned short' ,
+'unsigned short*' => 'short*' ,
+'unsigned shortint' => 'unsigned short' ,
+'unsigned' => 'unsigned int' ,
+'ushort' => 'unsigned short',
+'ushort*' => 'short*' ,
+'voice*' => 'int',
+'void' => 'void',
+'void(*)()' => 'void(*)()' ,
+'void*' => 'void*',
+'~' => '~',
+'QValueList<int>' => 'qt_QIntValueList*',
+'QValueList<int>&' => 'qt_QIntValueList*',
+'QValueList<QIconDragItem>' => 'qt_QIconDragItemValueList*',
+'QValueList<QIconDragItem>&' => 'qt_QIconDragItemValueList*',
+'QValueList<QPixmap>' => 'qt_QPixmapValueList*',
+'QValueList<QString>&' => 'qt_QStringValueList*',
+'QValueList<QVariant>&' => 'qt_QVariantValueList*',
+'QValueList<QUrlInfo>*' => 'qt_QUrlInfoValueList*',
+'QValueList<KDataToolInfo>&' => 'kde_KDataToolInfoValueList*',
+'QPtrList<KAction>&' => 'kde_KActionPtrList*',
+'QPtrList<KSSLCertificate>&' => 'kde_KSSLCertificatePtrList*',
+'QPtrList<KXMLGUIClient>*' => 'kde_KXMLGUIClientPtrList*',
+'QPtrList<QDockWindow>*' => 'qt_QDockWindowPtrList*',
+'QPtrList<QPixmap>' => 'qt_QPixmapPtrList*',
+'QPtrList<QPoint>' => 'qt_QPointPtrList*',
+'KService::Ptr&' => 'kde_KServicePtr*',
+'ClassContext*' => 'kde_ClassContext*',
+'ClassStoreIface*' => 'kde_ClassStoreIface*',
+'ClipboardDocumentIface*' => 'kde_ClipboardDocumentIface*',
+'CodeCompletionDocumentIface*' => 'kde_CodeCompletionDocumentIface*',
+'CursorDocumentIface*' => 'kde_CursorDocumentIface*',
+'DebugDocumentIface*' => 'kde_DebugDocumentIface*',
+'DocumentInterface*' => 'kde_DocumentInterface*',
+'EditDocumentIface*' => 'kde_EditDocumentIface*',
+'EditorInterface*' => 'kde_EditorInterface*',
+'FileContext*' => 'kde_FileContext*',
+'KDevAppFrontendIface*' => 'kde_KDevAppFrontendIface*',
+'KDevCoreIface*' => 'kde_KDevCoreIface*',
+'KDevMakeFrontendIface*' => 'kde_KDevMakeFrontendIface*',
+'KEditor*' => 'kde_KEditor*',
+'KEditor::Document*' => 'kde_Document*',
+'ParsedClassContainer&' => 'kde_ParsedClassContainer*',
+'ParsedContainer&' => 'kde_ParsedContainer*',
+'ParsedScopeContainer&' => 'kde_ParsedScopeContainer*',
+'QValueList<ParsedMethod>*' => 'kde_ParsedMethodList*',
+'QValueList<CompletionEntry>' => 'kde_CompletionEntryValueList*',
+'StatusDocumentIface*' => 'kde_StatusDocumentIface*',
+'UndoDocumentIface*' => 'kde_UndoDocumentIface*',
+'KShortcut&' => 'kde_KShortcut*',
+'KShortcut' => 'kde_KShortcut*',
+'KShortcut*' => 'kde_KShortcut*',
+'KKey&' => 'kde_KKey*',
+'KKey*' => 'kde_KKey*',
+'KKeyNative&' => 'kde_KKeyNative*',
+'KKeyNative*' => 'kde_KKeyNative*',
+'KKeyVariations&' => 'kde_KKeyVariations*',
+'KKeyVariations*' => 'kde_KKeyVariations*',
+'KKeyX11&' => 'kde_KKeyX11*',
+'KKeyX11' => 'kde_KKeyX11*',
+'KKeyX11*' => 'kde_KKeyX11*',
+'KAccelActions' => 'kde_KAccelActions*',
+'KRandomSequence&' => 'kde_KRandomSequence*',
+'KIcon::Context' => 'int',
+'KIcon::Group' => 'int',
+);
+
+
+ # Initialize %builtins, used by resolveType
+ my @noreflist = qw( const int char long double template
+ unsigned signed float void bool true false uint
+ uint32 uint64 extern static inline virtual operator );
+ foreach my $r ( @noreflist ) {
+ $builtins{ $r } = $r;
+ }
+
+}
+
+sub interfacemap
+{
+ my ( $interfaceType ) = @_;
+ return $interfacemap{$interfaceType};
+}
+
+sub ctypemap
+{
+ my ( $cType ) = @_;
+ return $ctypemap{$cType};
+}
+
+sub setctypemap
+{
+ my ( $cType, $cValue ) = @_;
+
+ $ctypemap{$cType} = $cValue;
+ return;
+}
+
+sub addNamespace
+{
+ my ( $className ) = @_;
+
+ if ( $className =~ /Bridge$/ ) {
+ return $className;
+ }
+
+ if ( $className =~ /^(AbstractView|Attr|CDATASection|CSSCharsetRule|CSSException|CSSFontFaceRule|CSSImportRule|CSSMediaRule|CSSPageRule|CSSPrimitiveValue|CSSRule|CSSRuleList|CSSStyleDeclaration|CSSStyleRule|CSSStyleSheet|CSSUnknownRule|CSSValue|CSSValueList|CharacterData|Comment|Counter|CustomNodeFilter|DOMException|DOMImplementation|DOMString|Document|DocumentFragment|DocumentStyle|DocumentType|DomShared|Element|Entity|EntityReference|EventException|EventListener|LinkStyle|MediaList|MutationEvent|NamedNodeMap|Node|NodeFilter|NodeIterator|NodeList|Notation|ProcessingInstruction|RGBColor|Range|RangeException|Rect|StyleSheet|StyleSheetList|Text|TreeWalker|UIEvent|HTML.*)/ )
+ {
+ return "DOM::".$className;
+ }
+
+ if ( $className =~ /^(BrowserExtension|BrowserHostExtensionBrowserInterface|ComponentFactory|DockMainWindow|Event|Factory|GUIActivateEvent|HistoryProvider|MainWindow|OpenURLEvent|Part|PartActivateEvent|PartBase|PartManager|PartSelectEvent|Plugin|PluginInfo|ReadOnlyPart|ReadWritePart|URLArgs|WindowArgs)/ )
+ {
+ return "KParts::".$className;
+ }
+
+ if ( $className =~ /^(AuthInfo|AutoLogin|CacheInfo|ChmodJob|Connection|CopyInfo|CopyJob|DefaultProgress|DeleteJob|FileCopyJob|Job|ListJob|MetaData|MimetypeJob|MultiGetJob|NetAccess|NetRC|PasswordDialog|PreviewJob|ProgressBase|RenameDlg|Scheduler|SessionData|SimpleJob|SkipDlg|Slave|SlaveBase|SlaveConfig|SlaveInterface|StatJob|StatusbarProgress|TCPSlaveBase|Task|TransferJob|UDSAtom)/ )
+ {
+ return "KIO::".$className;
+ }
+
+ if ( $className =~ /^(DrawContentsEvent|MouseDoubleClickEvent|MouseEvent|MouseMoveEvent|MousePressEvent|MouseReleaseEvent)/ )
+ {
+ return "khtml::".$className;
+ }
+
+ if ( $className =~ /^(OfferList)/ )
+ {
+ return "KTrader::".$className;
+ }
+
+ if ( $className =~ /^(BlockSelectionInterface|ClipboardInterface|CodeCompletionInterface|CompletionEntry|ConfigInterface|Cursor|CursorInterface|Document|EditInterface|Editor|HighlightingInterface|Mark|MarkInterface|PopupMenuInterface|PrintInterface|SearchInterface|SelectionInterface|UndoInterface|View|ViewCursorInterface)/ )
+ {
+ return "KTextEditor::".$className;
+ }
+
+
+ return $className;
+}
+
+
+# Helper for resolveType. This one is recursive and returns undef if not found.
+sub resolveTypeInternal($$$)
+{
+ my ( $argType, $contextClass, $rootnode ) = @_;
+
+ #print "resolveTypeInternal type:'$argType' context:'$contextClass->{astNodeName}' ($contextClass)\n";
+
+ my $contextClassName = join( "::", kdocAstUtil::heritage($contextClass) );
+
+ # 'A' resolves to 'A' in context 'A' ;) (i.e. classname itself)
+ return $contextClassName if ( $argType eq $contextClass->{astNodeName} );
+
+ # Try as an identifier of contextClass
+ #print "Trying as ".$contextClassName."::".$argType."\n";
+
+ my $node = kdocAstUtil::findRef( $rootnode, $contextClassName."::".$argType );
+
+ #print "Found as $node->{NodeType}\n" if $node;
+
+ return $contextClassName."::".$argType if ( $node
+ && $node->{NodeType} ne 'method'
+ && $node->{NodeType} ne 'deleted'
+ && $node->{NodeType} ne 'var' );
+
+ my $found;
+
+ # Then look at ancestors, and try for each one
+ Iter::Ancestors( $contextClass, $rootnode, undef, undef,
+ sub {
+ my ( $ances, $name, $type, $template ) = @_;
+ unless ($found) {
+ $found = resolveTypeInternal( $argType, $ances, $rootnode );
+ }
+ },
+ undef
+ );
+
+ return $found;
+}
+
+=head2
+
+ Look up a type, following the class hierarchy.
+ e.g. "Mode", if ContextClassName is A, will be looked as A::Mode,
+ then as B::Mode (if B is a parent class of A), then as Qt::Mode,
+ then as just Mode.
+
+=cut
+
+sub resolveType($$$)
+{
+ my ( $argType, $contextClass, $rootnode ) = @_;
+ $argType =~ s/\s*(\*)\s*$/$1/g; # remove space before *
+ #print "resolveType: '$argType'\n";
+
+ # Look for builtin words (int etc.)
+ return $builtins{ $argType } if exists $builtins{ $argType };
+
+ # Parse 'const' in front of it, and '*' or '&' after it
+ my $prefix = $argType =~ s/^const\s+// ? 'const ' : '';
+ my $suffix = $argType =~ s/\s*([\&\*]+)$// ? $1 : '';
+ #print "resolveType: prefix:$prefix, '$argType', suffix:$suffix\n";
+
+ # Launch the (possibly recursive) resolveTypeInternal
+ my $result = resolveTypeInternal( $argType, $contextClass, $rootnode );
+ return $prefix.$result.$suffix if $result;
+
+ # Not found, so look as a toplevel class
+ #print "Checking that ".$argType." exists.\n";
+ return $prefix.$argType.$suffix if ( kdocAstUtil::findRef( $rootnode, $argType ) );
+
+ #print "resolveType: $argType not found (context $contextClass->{astNodeName})\n\n";
+
+ return $prefix.$argType.$suffix;
+}
+
+1;
diff --git a/dcopidlng/kdocAstUtil.pm b/dcopidlng/kdocAstUtil.pm
new file mode 100644
index 00000000..9c8c0dd1
--- /dev/null
+++ b/dcopidlng/kdocAstUtil.pm
@@ -0,0 +1,762 @@
+=head1 kdocAstUtil
+
+ Utilities for syntax trees.
+
+=cut
+
+
+package kdocAstUtil;
+
+use Ast;
+use Carp;
+use File::Basename;
+use kdocUtil;
+use Iter;
+use strict;
+
+use vars qw/ $depth $refcalls $refiters @noreflist %noref /;
+
+sub BEGIN {
+# statistics for findRef
+
+ $depth = 0;
+ $refcalls = 0;
+ $refiters = 0;
+
+# findRef will ignore these words
+
+ @noreflist = qw( const int char long double template
+ unsigned signed float void bool true false uint
+ uint32 uint64 extern static inline virtual operator );
+
+ foreach my $r ( @noreflist ) {
+ $noref{ $r } = 1;
+ }
+}
+
+
+=head2 findNodes
+
+ Parameters: outlist ref, full list ref, key, value
+
+ Find all nodes in full list that have property "key=value".
+ All resulting nodes are stored in outlist.
+
+=cut
+
+sub findNodes
+{
+ my( $rOutList, $rInList, $key, $value ) = @_;
+
+ my $node;
+
+ foreach $node ( @{$rInList} ) {
+ next if !exists $node->{ $key };
+ if ( $node->{ $key } eq $value ) {
+ push @$rOutList, $node;
+ }
+ }
+}
+
+=head2 allTypes
+
+ Parameters: node list ref
+ returns: list
+
+ Returns a sorted list of all distinct "NodeType"s in the nodes
+ in the list.
+
+=cut
+
+sub allTypes
+{
+ my ( $lref ) = @_;
+
+ my %types = ();
+ foreach my $node ( @{$lref} ) {
+ $types{ $node->{NodeType} } = 1;
+ }
+
+ return sort keys %types;
+}
+
+
+
+
+=head2 findRef
+
+ Parameters: root, ident, report-on-fail
+ Returns: node, or undef
+
+ Given a root node and a fully qualified identifier (:: separated),
+ this function will try to find a child of the root node that matches
+ the identifier.
+
+=cut
+
+sub findRef
+{
+ my( $root, $name, $r ) = @_;
+
+ confess "findRef: no name" if !defined $name || $name eq "";
+
+ $name =~ s/\s+//g;
+ return undef if exists $noref{ $name };
+
+ $name =~ s/^#//g;
+
+ my ($iter, @tree) = split /(?:\:\:|#)/, $name;
+ my $kid;
+
+ $refcalls++;
+
+ # Upward search for the first token
+ return undef if !defined $iter;
+
+ while ( !defined findIn( $root, $iter ) ) {
+ return undef if !defined $root->{Parent};
+ $root = $root->{Parent};
+ }
+ $root = $root->{KidHash}->{$iter};
+ carp if !defined $root;
+
+ # first token found, resolve the rest of the tree downwards
+ foreach $iter ( @tree ) {
+ confess "iter in $name is undefined\n" if !defined $iter;
+ next if $iter =~ /^\s*$/;
+
+ unless ( defined findIn( $root, $iter ) ) {
+ confess "findRef: failed on '$name' at '$iter'\n"
+ if defined $r;
+ return undef;
+ }
+
+ $root = $root->{KidHash}->{ $iter };
+ carp if !defined $root;
+ }
+
+ return $root;
+}
+
+=head2 findIn
+
+ node, name: search for a child
+
+=cut
+
+sub findIn
+{
+ return undef unless defined $_[0]->{KidHash};
+
+ my $ret = $_[0]->{KidHash}->{ $_[1] };
+
+ return $ret;
+}
+
+=head2 linkReferences
+
+ Parameters: root, node
+
+ Recursively links references in the documentation for each node
+ to real nodes if they can be found. This should be called once
+ the entire parse tree is filled.
+
+=cut
+
+sub linkReferences
+{
+ my( $root, $node ) = @_;
+
+ if ( exists $node->{DocNode} ) {
+ linkDocRefs( $root, $node, $node->{DocNode} );
+
+ if( exists $node->{Compound} ) {
+ linkSee( $root, $node, $node->{DocNode} );
+ }
+ }
+
+ my $kids = $node->{Kids};
+ return unless defined $kids;
+
+ foreach my $kid ( @$kids ) {
+ # only continue in a leaf node if it has documentation.
+ next if !exists $kid->{Kids} && !exists $kid->{DocNode};
+ if( !exists $kid->{Compound} ) {
+ linkSee( $root, $node, $kid->{DocNode} );
+ }
+ linkReferences( $root, $kid );
+ }
+}
+
+sub linkNamespaces
+{
+ my ( $node ) = @_;
+
+ if ( defined $node->{ImpNames} ) {
+ foreach my $space ( @{$node->{ImpNames}} ) {
+ my $spnode = findRef( $node, $space );
+
+ if( defined $spnode ) {
+ $node->AddPropList( "ExtNames", $spnode );
+ }
+ else {
+ warn "namespace not found: $space\n";
+ }
+ }
+ }
+
+ return unless defined $node->{Compound} || !defined $node->{Kids};
+
+
+ foreach my $kid ( @{$node->{Kids}} ) {
+ next unless localComp( $kid );
+
+ linkNamespaces( $kid );
+ }
+}
+
+sub calcStats
+{
+ my ( $stats, $root, $node ) = @_;
+# stats:
+# num types
+# num nested
+# num global funcs
+# num methods
+
+
+ my $type = $node->{NodeType};
+
+ if ( $node eq $root ) {
+ # global methods
+ if ( defined $node->{Kids} ) {
+ foreach my $kid ( @{$node->{Kids}} ) {
+ $stats->{Global}++ if $kid->{NodeType} eq "method";
+ }
+ }
+
+ $node->AddProp( "Stats", $stats );
+ }
+ elsif ( kdocAstUtil::localComp( $node )
+ || $type eq "enum" || $type eq "typedef" ) {
+ $stats->{Types}++;
+ $stats->{Nested}++ if $node->{Parent} ne $root;
+ }
+ elsif( $type eq "method" ) {
+ $stats->{Methods}++;
+ }
+
+ return unless defined $node->{Compound} || !defined $node->{Kids};
+
+ foreach my $kid ( @{$node->{Kids}} ) {
+ next if defined $kid->{ExtSource};
+ calcStats( $stats, $root, $kid );
+ }
+}
+
+=head2 linkDocRefs
+
+ Parameters: root, node, docnode
+
+ Link references in the docs if they can be found. This should
+ be called once the entire parse tree is filled.
+
+=cut
+
+sub linkDocRefs
+{
+ my ( $root, $node, $docNode ) = @_;
+ return unless exists $docNode->{Text};
+
+ my ($text, $ref, $item, $tosearch);
+
+ foreach $item ( @{$docNode->{Text}} ) {
+ next if $item->{NodeType} ne 'Ref';
+
+ $text = $item->{astNodeName};
+
+ if ( $text =~ /^(?:#|::)/ ) {
+ $text = $';
+ $tosearch = $node;
+ }
+ else {
+ $tosearch = $root;
+ }
+
+ $ref = findRef( $tosearch, $text );
+ $item->AddProp( 'Ref', $ref ) if defined $ref;
+
+ confess "Ref failed for ", $item->{astNodeName},
+ "\n" unless defined $ref;
+ }
+}
+
+sub linkSee
+{
+ my ( $root, $node, $docNode ) = @_;
+ return unless exists $docNode->{See};
+
+ my ( $text, $tosearch, $ref );
+
+ foreach $text ( @{$docNode->{See}} ) {
+ if ( $text =~ /^\s*(?:#|::)/ ) {
+ $text = $';
+ $tosearch = $node;
+ }
+ else {
+ $tosearch = $root;
+ }
+
+ $ref = findRef( $tosearch, $text );
+ $docNode->AddPropList( 'SeeRef', $ref )
+ if defined $ref;
+ }
+}
+
+
+
+#
+# Inheritance utilities
+#
+
+=head2 makeInherit
+
+ Parameter: $rootnode, $parentnode
+
+ Make an inheritance graph from the parse tree that begins
+ at rootnode. parentnode is the node that is the parent of
+ all base class nodes.
+
+=cut
+
+sub makeInherit
+{
+ my( $rnode, $parent ) = @_;
+
+ foreach my $node ( @{ $rnode->{Kids} } ) {
+ next if !defined $node->{Compound};
+
+ # set parent to root if no inheritance
+
+ if ( !exists $node->{InList} ) {
+ newInherit( $node, "Global", $parent );
+ $parent->AddPropList( 'InBy', $node );
+
+ makeInherit( $node, $parent );
+ next;
+ }
+
+ # link each ancestor
+ my $acount = 0;
+ANITER:
+ foreach my $in ( @{ $node->{InList} } ) {
+ unless ( defined $in ) {
+ Carp::cluck "warning: $node->{astNodeName} "
+ ." has undef in InList.";
+ next ANITER;
+ }
+
+ my $ref = kdocAstUtil::findRef( $rnode,
+ $in->{astNodeName} );
+
+ if( !defined $ref ) {
+ # ancestor undefined
+ warn "warning: ", $node->{astNodeName},
+ " inherits unknown class '",
+ $in->{astNodeName},"'\n";
+
+ $parent->AddPropList( 'InBy', $node );
+ }
+ else {
+ # found ancestor
+ $in->AddProp( "Node", $ref );
+ $ref->AddPropList( 'InBy', $node );
+ $acount++;
+ }
+ }
+
+ if ( $acount == 0 ) {
+ # inherits no known class: just parent it to global
+ newInherit( $node, "Global", $parent );
+ $parent->AddPropList( 'InBy', $node );
+ }
+ makeInherit( $node, $parent );
+ }
+}
+
+=head2 newInherit
+
+ p: $node, $name, $lnode?
+
+ Add a new ancestor to $node with raw name = $name and
+ node = lnode.
+=cut
+
+sub newInherit
+{
+ my ( $node, $name, $link ) = @_;
+
+ my $n = Ast::New( $name );
+ $n->AddProp( "Node", $link ) unless !defined $link;
+
+ $node->AddPropList( "InList", $n );
+ return $n;
+}
+
+=head2 inheritName
+
+ pr: $inheritance node.
+
+ Returns the name of the inherited node. This checks for existence
+ of a linked node and will use the "raw" name if it is not found.
+
+=cut
+
+sub inheritName
+{
+ my ( $innode ) = @_;
+
+ return defined $innode->{Node} ?
+ $innode->{Node}->{astNodeName}
+ : $innode->{astNodeName};
+}
+
+=head2 inheritedBy
+
+ Parameters: out listref, node
+
+ Recursively searches for nodes that inherit from this one, returning
+ a list of inheriting nodes in the list ref.
+
+=cut
+
+sub inheritedBy
+{
+ my ( $list, $node ) = @_;
+
+ return unless exists $node->{InBy};
+
+ foreach my $kid ( @{ $node->{InBy} } ) {
+ push @$list, $kid;
+ inheritedBy( $list, $kid );
+ }
+}
+
+=head2 hasLocalInheritor
+
+ Parameter: node
+ Returns: 0 on fail
+
+ Checks if the node has an inheritor that is defined within the
+ current library. This is useful for drawing the class hierarchy,
+ since you don't want to display classes that have no relationship
+ with classes within this library.
+
+ NOTE: perhaps we should cache the value to reduce recursion on
+ subsequent calls.
+
+=cut
+
+sub hasLocalInheritor
+{
+ my $node = shift;
+
+ return 0 if !exists $node->{InBy};
+
+ my $in;
+ foreach $in ( @{$node->{InBy}} ) {
+ return 1 if !exists $in->{ExtSource}
+ || hasLocalInheritor( $in );
+ }
+
+ return 0;
+}
+
+
+
+=head2 allMembers
+
+ Parameters: hashref outlist, node, $type
+
+ Fills the outlist hashref with all the methods of outlist,
+ recursively traversing the inheritance tree.
+
+ If type is not specified, it is assumed to be "method"
+
+=cut
+
+sub allMembers
+{
+ my ( $outlist, $n, $type ) = @_;
+ my $in;
+ $type = "method" if !defined $type;
+
+ if ( exists $n->{InList} ) {
+
+ foreach $in ( @{$n->{InList}} ) {
+ next if !defined $in->{Node};
+ my $i = $in->{Node};
+
+ allMembers( $outlist, $i )
+ unless $i == $main::rootNode;
+ }
+ }
+
+ return unless exists $n->{Kids};
+
+ foreach $in ( @{$n->{Kids}} ) {
+ next if $in->{NodeType} ne $type;
+
+ $outlist->{ $in->{astNodeName} } = $in;
+ }
+}
+
+=head2 findOverride
+
+ Parameters: root, node, name
+
+ Looks for nodes of the same name as the parameter, in its parent
+ and the parent's ancestors. It returns a node if it finds one.
+
+=cut
+
+sub findOverride
+{
+ my ( $root, $node, $name ) = @_;
+ return undef if !exists $node->{InList};
+
+ foreach my $in ( @{$node->{InList}} ) {
+ my $n = $in->{Node};
+ next unless defined $n && $n != $root && exists $n->{KidHash};
+
+ my $ref = $n->{KidHash}->{ $name };
+
+ return $n if defined $ref && $ref->{NodeType} eq "method";
+
+ if ( exists $n->{InList} ) {
+ $ref = findOverride( $root, $n, $name );
+ return $ref if defined $ref;
+ }
+ }
+
+ return undef;
+}
+
+=head2 attachChild
+
+ Parameters: parent, child
+
+ Attaches child to the parent, setting Access, Kids
+ and KidHash of respective nodes.
+
+=cut
+
+sub attachChild
+{
+ my ( $parent, $child ) = @_;
+ confess "Attempt to attach ".$child->{astNodeName}." to an ".
+ "undefined parent\n" if !defined $parent;
+
+ $child->AddProp( "Access", $parent->{KidAccess} );
+ $child->AddProp( "Parent", $parent );
+
+ $parent->AddPropList( "Kids", $child );
+
+ if( !exists $parent->{KidHash} ) {
+ my $kh = Ast::New( "LookupTable" );
+ $parent->AddProp( "KidHash", $kh );
+ }
+
+ $parent->{KidHash}->AddProp( $child->{astNodeName},
+ $child );
+}
+
+=head2 makeClassList
+
+ Parameters: node, outlist ref
+
+ fills outlist with a sorted list of all direct, non-external
+ compound children of node.
+
+=cut
+
+sub makeClassList
+{
+ my ( $rootnode, $list ) = @_;
+
+ @$list = ();
+
+ Iter::LocalCompounds( $rootnode,
+ sub {
+ my $node = shift;
+
+ my $her = join ( "::", heritage( $node ) );
+ $node->AddProp( "FullName", $her );
+
+ if ( !exists $node->{DocNode}->{Internal} ||
+ !$main::skipInternal ) {
+ push @$list, $node;
+ }
+ } );
+
+ @$list = sort { $a->{FullName} cmp $b->{FullName} } @$list;
+}
+
+#
+# Debugging utilities
+#
+
+=head2 dumpAst
+
+ Parameters: node, deep
+ Returns: none
+
+ Does a recursive dump of the node and its children.
+ If deep is set, it is used as the recursion property, otherwise
+ "Kids" is used.
+
+=cut
+
+sub dumpAst
+{
+ my ( $node, $deep ) = @_;
+
+ $deep = "Kids" if !defined $deep;
+
+ print "\t" x $depth, $node->{astNodeName},
+ " (", $node->{NodeType}, ")\n";
+
+ my $kid;
+
+ foreach $kid ( $node->GetProps() ) {
+ print "\t" x $depth, " -\t", $kid, " -> ", $node->{$kid},"\n"
+ unless $kid =~ /^(astNodeName|NodeType|$deep)$/;
+ }
+ if ( exists $node->{InList} ) {
+ print "\t" x $depth, " -\tAncestors -> ";
+ foreach my $innode ( @{$node->{InList}} ) {
+ print $innode->{astNodeName} . ",";
+ }
+ print "\n";
+ }
+
+ print "\t" x $depth, " -\n" if (defined $node->{ $deep } && scalar(@{$node->{ $deep }}) != 0);
+
+ $depth++;
+ foreach $kid ( @{$node->{ $deep }} ) {
+ dumpAst( $kid );
+ }
+
+ print "\t" x $depth, "Documentation nodes:\n" if defined
+ @{ $node->{Doc}->{ "Text" }};
+
+ foreach $kid ( @{ $node->{Doc}->{ "Text" }} ) {
+ dumpAst( $kid );
+ }
+
+ $depth--;
+}
+
+=head2 testRef
+
+ Parameters: rootnode
+
+ Interactive testing of referencing system. Calling this
+ will use the readline library to allow interactive entering of
+ identifiers. If a matching node is found, its node name will be
+ printed.
+
+=cut
+
+sub testRef {
+ require Term::ReadLine;
+
+ my $rootNode = $_[ 0 ];
+
+ my $term = new Term::ReadLine 'Testing findRef';
+
+ my $OUT = $term->OUT || *STDOUT{IO};
+ my $prompt = "Identifier: ";
+
+ while( defined ($_ = $term->readline($prompt)) ) {
+
+ my $node = kdocAstUtil::findRef( $rootNode, $_ );
+
+ if( defined $node ) {
+ print $OUT "Reference: '", $node->{astNodeName},
+ "', Type: '", $node->{NodeType},"'\n";
+ }
+ else {
+ print $OUT "No reference found.\n";
+ }
+
+ $term->addhistory( $_ ) if /\S/;
+ }
+}
+
+sub printDebugStats
+{
+ print "findRef: ", $refcalls, " calls, ",
+ $refiters, " iterations.\n";
+}
+
+sub External
+{
+ return defined $_[0]->{ExtSource};
+}
+
+sub Compound
+{
+ return defined $_[0]->{Compound};
+}
+
+sub localComp
+{
+ my ( $node ) = $_[0];
+ return defined $node->{Compound}
+ && !defined $node->{ExtSource}
+ && $node->{NodeType} ne "Forward";
+}
+
+sub hasDoc
+{
+ return defined $_[0]->{DocNode};
+}
+
+### Warning: this returns the list of parents, e.g. the 3 words in KParts::ReadOnlyPart::SomeEnum
+### It has nothing do to with inheritance.
+sub heritage
+{
+ my $node = shift;
+ my @heritage;
+
+ while( 1 ) {
+ push @heritage, $node->{astNodeName};
+
+ last unless defined $node->{Parent};
+ $node = $node->{Parent};
+ last unless defined $node->{Parent};
+ }
+
+ return reverse @heritage;
+}
+
+sub refHeritage
+{
+ my $node = shift;
+ my @heritage;
+
+ while( 1 ) {
+ push @heritage, $node;
+
+ last unless defined $node->{Parent};
+ $node = $node->{Parent};
+ last unless defined $node->{Parent};
+ }
+
+ return reverse @heritage;
+
+}
+
+
+1;
diff --git a/dcopidlng/kdocLib.pm b/dcopidlng/kdocLib.pm
new file mode 100644
index 00000000..6eac4dff
--- /dev/null
+++ b/dcopidlng/kdocLib.pm
@@ -0,0 +1,245 @@
+
+=head1 kdocLib
+
+Writes out a library file.
+
+NOTES ON THE NEW FORMAT
+
+ Stores: class name, members, hierarchy
+ node types are not stored
+
+
+ File Format Spec
+ ----------------
+
+ header
+ zero or more members, each of
+ method
+ member
+ class, each of
+ inheritance
+ zero or more members
+
+
+
+ Unrecognized lines ignored.
+
+ Sample
+ ------
+
+ <! KDOC Library HTML Reference File>
+ <VERSION="2.0">
+ <BASE URL="http://www.kde.org/API/kdecore/">
+
+ <C NAME="KApplication" REF="KApplication.html">
+ <IN NAME="QObject">
+ <ME NAME="getConfig" REF="KApplication.html#getConfig">
+ <M NAME="" REF="">
+ </C>
+
+=cut
+
+package kdocLib;
+use strict;
+
+use Carp;
+use File::Path;
+use File::Basename;
+
+use Ast;
+use kdocAstUtil;
+use kdocUtil;
+
+
+use vars qw/ $exe $lib $root $plang $outputdir $docpath $url $compress /;
+
+BEGIN {
+ $exe = basename $0;
+}
+
+sub writeDoc
+{
+ ( $lib, $root, $plang, $outputdir, $docpath, $url,
+ $compress ) = @_;
+ my $outfile = "$outputdir/$lib.kalyptus";
+ $url = $docpath unless defined $url;
+
+ mkpath( $outputdir ) unless -f $outputdir;
+
+ if( $compress ) {
+ open( LIB, "| gzip -9 > \"$outfile.gz\"" )
+ || die "$exe: couldn't write to $outfile.gz\n";
+
+ }
+ else {
+ open( LIB, ">$outfile" )
+ || die "$exe: couldn't write to $outfile\n";
+ }
+
+ my $libdesc = "";
+ if ( defined $root->{LibDoc} ) {
+ $libdesc="<LIBDESC>".$root->{LibDoc}->{astNodeName}."</LIBDESC>";
+ }
+
+ print LIB<<LTEXT;
+<! KDOC Library HTML Reference File>
+<VERSION="$main::Version">
+<BASE URL="$url">
+<PLANG="$plang">
+<LIBNAME>$lib</LIBNAME>
+$libdesc
+
+LTEXT
+
+ writeNode( $root, "" );
+ close LIB;
+}
+
+sub writeNode
+{
+ my ( $n, $prefix ) = @_;
+ return if !exists $n->{Compound};
+ return if exists $n->{Forward} && !exists $n->{KidAccess};
+
+ if( $n != $root ) {
+ $prefix .= $n->{astNodeName};
+ print LIB "<C NAME=\"", $n->{astNodeName},
+ "\" REF=\"$prefix.html\">\n";
+ }
+ else {
+ print LIB "<STATS>\n";
+ my $stats = $root->{Stats};
+ foreach my $stat ( keys %$stats ) {
+ print LIB "<STAT NAME=\"$stat\">",
+ $stats->{$stat},"</STAT>\n";
+ }
+ print LIB "</STATS>\n";
+ }
+
+ if( exists $n->{Ancestors} ) {
+ my $in;
+ foreach $in ( @{$n->{Ancestors}} ) {
+ $in =~ s/\s+//g;
+ print LIB "<IN NAME=\"",$in,"\">\n";
+ }
+ }
+
+ return if !exists $n->{Kids};
+ my $kid;
+ my $type;
+
+ foreach $kid ( @{$n->{Kids}} ) {
+ next if exists $kid->{ExtSource}
+ || $kid->{Access} eq "private";
+
+ if ( exists $kid->{Compound} ) {
+ if( $n != $root ) {
+ writeNode( $kid, $prefix."::" );
+ }
+ else {
+ writeNode( $kid, "" );
+ }
+ next;
+ }
+
+ $type = $kid->{NodeType} eq "method" ?
+ "ME" : "M";
+
+ print LIB "<$type NAME=\"", $kid->{astNodeName},
+ "\" REF=\"$prefix.html#", $kid->{astNodeName}, "\">\n";
+ }
+
+ if( $n != $root ) {
+ print LIB "</C>\n";
+ }
+}
+
+sub readLibrary
+{
+ my( $rootsub, $name, $path, $relurl ) = @_;
+ $path = "." unless defined $path;
+ my $real = $path."/".$name.".kalyptus";
+ my $url = ".";
+ my @stack = ();
+ my $version = "2.0";
+ my $new;
+ my $root = undef;
+ my $n = undef;
+ my $havecomp = -r "$real.gz";
+ my $haveuncomp = -r "$real";
+
+ if ( $haveuncomp ) {
+ open( LIB, "$real" ) || die "Can't read lib $real\n";
+ }
+
+ if( $havecomp ) {
+ if ( $haveuncomp ) {
+ warn "$exe: two libs exist: $real and $real.gz. "
+ ."Using $real\n";
+ }
+ else {
+ open( LIB, "gunzip < \"$real.gz\"|" )
+ || die "Can't read pipe gunzip < \"$real.gz\": $?\n";
+ }
+ }
+
+ while( <LIB> ) {
+ next if /^\s*$/;
+ if ( !/^\s*</ ) {
+ close LIB;
+ #readOldLibrary( $root, $name, $path );
+ return;
+ }
+
+ if( /<VER\w+\s+([\d\.]+)>/ ) {
+ # TODO: what do we do with the version number?
+ $version = $1;
+ }
+ elsif ( /<BASE\s*URL\s*=\s*"(.*?)"/ ) {
+ $url = $1;
+ $url .= "/" unless $url =~ m:/$:;
+
+ my $test = kdocUtil::makeRelativePath( $relurl, $url );
+ $url = $test;
+ }
+ elsif( /<PLANG\s*=\s*"(.*?)">/ ) {
+ $root = $rootsub->( $1 );
+ $n = $root;
+ }
+ elsif ( /<C\s*NAME="(.*?)"\s*REF="(.*?)"\s*>/ ) {
+ # class
+ $new = Ast::New( $1 );
+ $new->AddProp( "NodeType", "class" );
+ $new->AddProp( "Compound", 1 );
+ $new->AddProp( "ExtSource", $name );
+
+ # already escaped at this point!
+ $new->AddProp( "Ref", $url.$2 );
+
+ $root = $n = $rootsub->( "CXX" ) unless defined $root;
+ kdocAstUtil::attachChild( $n, $new );
+ push @stack, $n;
+ $n = $new;
+ }
+ elsif ( m#<IN\s*NAME\s*=\s*"(.*?)"\s*># ) {
+ # ancestor
+ kdocAstUtil::newInherit( $n, $1 );
+ }
+ elsif ( m#</C># ) {
+ # end class
+ $n = pop @stack;
+ }
+ elsif ( m#<(M\w*)\s+NAME="(.*?)"\s+REF="(.*?)"\s*># ) {
+ # member
+ $new = Ast::New( $2 );
+ $new->AddProp( "NodeType", $1 eq "ME" ? "method" : "var" );
+ $new->AddProp( "ExtSource", $name );
+ $new->AddProp( "Flags", "" );
+ $new->AddProp( "Ref", $url.$3 );
+
+ kdocAstUtil::attachChild( $n, $new );
+ }
+ }
+}
+
+1;
diff --git a/dcopidlng/kdocParseDoc.pm b/dcopidlng/kdocParseDoc.pm
new file mode 100644
index 00000000..e5f19d50
--- /dev/null
+++ b/dcopidlng/kdocParseDoc.pm
@@ -0,0 +1,419 @@
+package kdocParseDoc;
+
+use Ast;
+use strict;
+
+use vars qw/ $buffer $docNode %extraprops $currentProp $propType /;
+
+=head1 kdocParseDoc
+
+ Routines for parsing of javadoc comments.
+
+=head2 newDocComment
+
+ Parameters: begin (starting line of declaration)
+
+ Reads a doc comment to the end and creates a new doc node.
+
+ Read a line
+ check if it changes the current context
+ yes
+ flush old context
+ check if it is a non-text tag
+ (ie internal/deprecated etc)
+ yes
+ reset context to text
+ set associated property
+ no
+ set the new context
+ assign text to new buffer
+ no add to text buffer
+ continue
+ at end
+ flush anything pending.
+
+=cut
+
+sub newDocComment
+{
+ my( $text ) = @_;
+ return undef unless $text =~ m#/\*\*+#;
+
+ setType( "DocText", 2 );
+ $text =~ m#/\*#; # need to do the match again, otherwise /***/ doesn't parse
+ ### TODO update this method from kdoc
+ $buffer = $'; # everything after the first \*
+ $docNode = undef;
+ %extraprops = (); # used for textprops when flushing.
+ my $finished = 0;
+ my $inbounded = 0;
+
+ if ( $buffer =~ m#\*/# ) {
+ $buffer = $`;
+ $finished = 1;
+ }
+
+PARSELOOP:
+ while ( defined $text && !$finished ) {
+ # read text and remove leading junk
+ $text = main::readSourceLine();
+ next if !defined $text;
+ $text =~ s#^\s*\*(?!\/)##;
+
+# if ( $text =~ /^\s*<\/pre>/i ) {
+# flushProp();
+# $inbounded = 0;
+# }
+ if( $inbounded ) {
+ if ( $text =~ m#\*/# ) {
+ $finished = 1;
+ $text = $`;
+ }
+ $buffer .= $text;
+ next PARSELOOP;
+ }
+# elsif ( $text =~ /^\s*<pre>/i ) {
+# textProp( "Pre" );
+# $inbounded = 1;
+# }
+ elsif ( $text =~ /^\s*$/ ) {
+ textProp( "ParaBreak", "\n" );
+ }
+ elsif ( $text =~ /^\s*\@internal\s*/ ) {
+ codeProp( "Internal", 1 );
+ }
+ elsif ( $text =~ /^\s*\@deprecated\s*/ ) {
+ codeProp( "Deprecated", 1 );
+ }
+ elsif ( $text =~ /^\s*\@reimplemented\s*/ ) {
+ codeProp( "Reimplemented", 1 );
+ }
+ elsif ( $text =~ /^\s*\@group\s*/ ) {
+ # logical group tag in which this node belongs
+ # multiples allowed
+
+ my $groups = $';
+ $groups =~ s/^\s*(.*?)\s*$/$1/;
+
+ if ( $groups ne "" ) {
+ foreach my $g ( split( /[^_\w]+/, $groups) ) {
+
+ codeProp( "InGroup", $g );
+ }
+ }
+ }
+ elsif ( $text =~ /^\s*\@defgroup\s+(\w+)\s*/ ) {
+ # parse group tag and description
+ my $grptag = $1;
+ my $grpdesc = $' eq "" ? $grptag : $';
+
+ # create group node
+ my $grpnode = Ast::New( $grptag );
+ $grpnode->AddProp( "Desc", $grpdesc );
+ $grpnode->AddProp( "NodeType", "GroupDef" );
+
+ # attach
+ codeProp( "Groups", $grpnode );
+ }
+ elsif ( $text =~ /^\s*\@see\s*/ ) {
+ docListProp( "See" );
+ }
+ elsif( $text =~ /^\s*\@short\s*/ ) {
+ docProp( "ClassShort" );
+ }
+ elsif( $text =~ /^\s*\@author\s*/ ) {
+ docProp( "Author" );
+
+ }
+ elsif( $text =~ /^\s*\@version\s*/ ) {
+ docProp( "Version" );
+ }
+ elsif( $text =~ /^\s*\@id\s*/ ) {
+
+ docProp( "Id" );
+ }
+ elsif( $text =~ /^\s*\@since\s*/ ) {
+ docProp( "Since" );
+ }
+ elsif( $text =~ /^\s*\@returns?\s*/ ) {
+ docProp( "Returns" );
+ }
+ elsif( $text =~ /^\s*\@(?:throws|exception|raises)\s*/ ) {
+ docListProp( "Throws" );
+ }
+ elsif( $text =~ /^\s*\@image\s+([^\s]+)\s*/ ) {
+ textProp( "Image" );
+ $extraprops{ "Path" } = $1;
+ }
+ elsif( $text =~ /^\s*\@param\s+(\w+)\s*/ ) {
+ textProp( "Param" );
+ $extraprops{ "Name" } = $1;
+ }
+ elsif( $text =~ /^\s*\@sect\s+/ ) {
+
+ textProp( "DocSection" );
+ }
+ elsif( $text =~ /^\s*\@li\s+/ ) {
+
+ textProp( "ListItem" );
+ }
+ elsif ( $text =~ /^\s*\@libdoc\s+/ ) {
+ # Defines the text for the entire library
+ docProp( "LibDoc" );
+ }
+ else {
+ if ( $text =~ m#\*/# ) {
+ $finished = 1;
+ $text = $`;
+ }
+ $buffer .= $text;
+ }
+ }
+
+ flushProp();
+
+
+ return undef if !defined $docNode;
+
+# postprocess docnode
+
+ # add a . to the end of the short if required.
+ my $short = $docNode->{ClassShort};
+
+ if ( defined $short ) {
+ if ( !($short =~ /\.\s*$/) ) {
+ $docNode->{ClassShort} =~ s/\s*$/./;
+ }
+ }
+ else {
+ # use first line of normal text as short name.
+ if ( defined $docNode->{Text} ) {
+ my $node;
+ foreach $node ( @{$docNode->{Text}} ) {
+ next if $node->{NodeType} ne "DocText";
+ $short = $node->{astNodeName};
+ $short = $`."." if $short =~ /\./;
+ $docNode->{ClassShort} = $short;
+ goto shortdone;
+ }
+ }
+ }
+shortdone:
+
+# Join and break all word list props so that they are one string per list
+# node, ie remove all commas and spaces.
+
+ recombineOnWords( $docNode, "See" );
+ recombineOnWords( $docNode, "Throws" );
+
+ return $docNode;
+}
+
+=head3 setType
+
+ Parameters: propname, proptype ( 0 = single, 1 = list, 2 = text )
+
+ Set the name and type of the pending property.
+
+=cut
+
+sub setType
+{
+ ( $currentProp, $propType ) = @_;
+}
+
+=head3 flushProp
+
+ Flush any pending item and reset the buffer. type is set to DocText.
+
+=cut
+
+sub flushProp
+{
+ return if $buffer eq "";
+ initDocNode() unless defined $docNode;
+
+ if( $propType == 1 ) {
+ # list prop
+ $docNode->AddPropList( $currentProp, $buffer );
+ }
+ elsif ( $propType == 2 ) {
+ # text prop
+ my $textnode = Ast::New( $buffer );
+ $textnode->AddProp( 'NodeType', $currentProp );
+ $docNode->AddPropList( 'Text', $textnode );
+
+ foreach my $prop ( keys %extraprops ) {
+ $textnode->AddProp( $prop,
+ $extraprops{ $prop } );
+ }
+
+ %extraprops = ();
+ }
+ else {
+ # one-off prop
+ $docNode->AddProp( $currentProp, $buffer );
+ }
+
+ # reset buffer
+ $buffer = "";
+ setType( "DocText", 2 );
+}
+
+=head3 codeProp
+
+ Flush the last node, add a new property and reset type to DocText.
+
+=cut
+
+sub codeProp
+{
+ my( $prop, $val ) = @_;
+
+ flushProp();
+
+ initDocNode() unless defined $docNode;
+ $docNode->AddPropList( $prop, $val );
+
+ setType( "DocText", 2 );
+
+}
+
+=head3 docListProp
+
+ The next item is a list property of docNode.
+
+=cut
+
+sub docListProp
+{
+ my( $prop ) = @_;
+
+ flushProp();
+
+ $buffer = $';
+ setType( $prop, 1 );
+}
+
+=head3 docProp
+
+ The next item is a simple property of docNode.
+
+=cut
+
+sub docProp
+{
+ my( $prop ) = @_;
+
+ flushProp();
+
+ $buffer = $';
+ setType( $prop, 0 );
+}
+
+=head3 textProp
+
+ Parameters: prop, val
+
+ Set next item to be a 'Text' list node. if val is assigned, the
+ new node is assigned that text and flushed immediately. If this
+ is the case, the next item is given the 'DocText' text property.
+
+=cut
+
+sub textProp
+{
+ my( $prop, $val ) = @_;
+
+ flushProp();
+
+ if ( defined $val ) {
+ $buffer = $val;
+ setType( $prop, 2 );
+ flushProp();
+ $prop = "DocText";
+ }
+
+ setType( $prop, 2 );
+ $buffer = $';
+}
+
+
+=head3 initDocNode
+
+ Creates docNode if it is not defined.
+
+=cut
+
+sub initDocNode
+{
+ $docNode = Ast::New( "Doc" );
+ $docNode->AddProp( "NodeType", "DocNode" );
+}
+
+sub recombineOnWords
+{
+ my ( $docNode, $prop ) = @_;
+
+ if ( exists $docNode->{$prop} ) {
+ my @oldsee = @{$docNode->{$prop}};
+ @{$docNode->{$prop}} = split (/[\s,]+/, join( " ", @oldsee ));
+ }
+}
+
+###############
+
+=head2 attachDoc
+
+Connects a docnode to a code node, setting any other properties
+if required, such as groups, internal/deprecated flags etc.
+
+=cut
+
+sub attachDoc
+{
+ my ( $node, $doc, $rootnode ) = @_;
+
+ $node->AddProp( "DocNode", $doc );
+ $node->AddProp( "Internal", 1 ) if defined $doc->{Internal};
+ $node->AddProp( "Deprecated", 1 ) if defined $doc->{Deprecated};
+
+ # attach group definitions if they exist
+ if ( defined $doc->{Groups} ) {
+ my $groupdef = $rootnode->{Groups};
+ if( !defined $groupdef ) {
+ $groupdef = Ast::New( "Groups" );
+ $rootnode->AddProp( "Groups", $groupdef );
+ }
+
+ foreach my $grp ( @{$doc->{Groups}} ) {
+ if ( defined $groupdef->{ $grp->{astNodeName} } ) {
+ $groupdef->{ $grp->{ astNodeName}
+ }->AddProp( "Desc", $grp->{Desc} );
+ }
+ else {
+ $groupdef->AddProp( $grp->{astNodeName}, $grp );
+ }
+ }
+ }
+
+ # attach node to group index(es)
+ # create groups if not found, they may be parsed later.
+
+ if ( defined $doc->{InGroup} ) {
+ my $groupdef = $rootnode->{Groups};
+
+ foreach my $grp ( @{$doc->{InGroup}} ) {
+ if ( !exists $groupdef->{$grp} ) {
+ my $newgrp = Ast::New( $grp );
+ $newgrp->AddProp( "Desc", $grp );
+ $newgrp->AddProp( "NodeType", "GroupDef" );
+ $groupdef->AddProp( $grp, $newgrp );
+ }
+
+ $groupdef->{$grp}->AddPropList( "Kids", $node );
+ }
+ }
+}
+
+1;
diff --git a/dcopidlng/kdocUtil.pm b/dcopidlng/kdocUtil.pm
new file mode 100644
index 00000000..629147ac
--- /dev/null
+++ b/dcopidlng/kdocUtil.pm
@@ -0,0 +1,189 @@
+
+package kdocUtil;
+
+use strict;
+
+
+=head1 kdocUtil
+
+ General utilities.
+
+=head2 countReg
+
+ Parameters: string, regexp
+
+ Returns the number of times of regexp occurs in string.
+
+=cut
+
+sub countReg
+{
+ my( $str, $regexp ) = @_;
+ my( $count ) = 0;
+
+ while( $str =~ /$regexp/s ) {
+ $count++;
+
+ $str =~ s/$regexp//s;
+ }
+
+ return $count;
+}
+
+=head2 findCommonPrefix
+
+ Parameters: string, string
+
+ Returns the prefix common to both strings. An empty string
+ is returned if the strings have no common prefix.
+
+=cut
+
+sub findCommonPrefix
+{
+ my @s1 = split( "/", $_[0] );
+ my @s2 = split( "/", $_[1] );
+ my $accum = "";
+ my $len = ($#s2 > $#s1 ) ? $#s1 : $#s2;
+
+ for my $i ( 0..$len ) {
+# print "Compare: $i '$s1[$i]', '$s2[$i]'\n";
+ last if $s1[ $i ] ne $s2[ $i ];
+ $accum .= $s1[ $i ]."/";
+ }
+
+ return $accum;
+}
+
+=head2 makeRelativePath
+
+ Parameters: localpath, destpath
+
+ Returns a relative path to the destination from the local path,
+ after removal of any common prefix.
+
+=cut
+
+sub makeRelativePath
+{
+ my ( $from, $to ) = @_;
+
+ # remove prefix
+ $from .= '/' unless $from =~ m#/$#;
+ $to .= '/' unless $to =~ m#/$#;
+
+ my $pfx = findCommonPrefix( $from, $to );
+
+ if ( $pfx ne "" ) {
+ $from =~ s/^$pfx//g;
+ $to =~ s/^$pfx//g;
+ }
+# print "Prefix is '$pfx'\n";
+
+ $from =~ s#/+#/#g;
+ $to =~ s#/+#/#g;
+ $pfx = countReg( $from, '\/' );
+
+ my $rel = "../" x $pfx;
+ $rel .= $to;
+
+ return $rel;
+}
+
+sub hostName
+{
+ my $host = "";
+ my @hostenvs = qw( HOST HOSTNAME COMPUTERNAME );
+
+ # Host name
+ foreach my $evar ( @hostenvs ) {
+ next unless defined $ENV{ $evar };
+
+ $host = $ENV{ $evar };
+ last;
+ }
+
+ if( $host eq "" ) {
+ $host = `uname -n`;
+ chop $host;
+ }
+
+ return $host;
+}
+
+sub userName
+{
+ my $who = "";
+ my @userenvs = qw( USERNAME USER LOGNAME );
+
+ # User name
+ foreach my $evar ( @userenvs ) {
+ next unless defined $ENV{ $evar };
+
+ $who = $ENV{ $evar };
+ last;
+ }
+
+ if( $who eq "" ) {
+ if ( $who = `whoami` ) {
+ chop $who;
+ }
+ elsif ( $who - `who am i` ) {
+ $who = ( split (/ /, $who ) )[0];
+ }
+ }
+
+ return $who;
+}
+
+=head2 splitUnnested
+ Helper to split a list using a delimiter, but looking for
+ nesting with (), {}, [] and <>.
+ Example: splitting int a, QPair<c,b> d, e=","
+ on ',' will give 3 items in the list.
+
+ Parameter: delimiter, string
+ Returns: array, after splitting the string
+
+ Thanks to Ashley Winters
+=cut
+sub splitUnnested($$) {
+ my $delim = shift;
+ my $string = shift;
+ my(%open) = (
+ '[' => ']',
+ '(' => ')',
+ '<' => '>',
+ '{' => '}',
+ );
+ my(%close) = reverse %open;
+ my @ret;
+ my $depth = 0;
+ my $start = 0;
+ my $indoublequotes = 0;
+ while($string =~ /($delim|<<|>>|[][}{)(><\"])/g) {
+ my $c = $1;
+ if(!$depth and !$indoublequotes and $c eq $delim) {
+ my $len = pos($string) - $start - 1;
+ push @ret, substr($string, $start, $len);
+ $start = pos($string);
+ } elsif($open{$c}) {
+ $depth++;
+ } elsif($close{$c}) {
+ $depth--;
+ } elsif($c eq '"') {
+ if ($indoublequotes) {
+ $indoublequotes = 0;
+ } else {
+ $indoublequotes = 1;
+ }
+ }
+ }
+
+ my $subs = substr($string, $start);
+ push @ret, $subs if ($subs);
+ return @ret;
+}
+
+1;
+