From 460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- dcopidlng/Ast.pm | 91 ++ dcopidlng/Iter.pm | 532 +++++++ dcopidlng/configure.in.in | 5 + dcopidlng/dcopidlng | 10 + dcopidlng/kalyptus | 1654 ++++++++++++++++++++ dcopidlng/kalyptusCxxToDcopIDL.pm | 1047 +++++++++++++ dcopidlng/kalyptusDataDict.pm | 3042 +++++++++++++++++++++++++++++++++++++ dcopidlng/kdocAstUtil.pm | 762 ++++++++++ dcopidlng/kdocLib.pm | 245 +++ dcopidlng/kdocParseDoc.pm | 419 +++++ dcopidlng/kdocUtil.pm | 189 +++ 11 files changed, 7996 insertions(+) create mode 100644 dcopidlng/Ast.pm create mode 100644 dcopidlng/Iter.pm create mode 100644 dcopidlng/configure.in.in create mode 100755 dcopidlng/dcopidlng create mode 100644 dcopidlng/kalyptus create mode 100644 dcopidlng/kalyptusCxxToDcopIDL.pm create mode 100644 dcopidlng/kalyptusDataDict.pm create mode 100644 dcopidlng/kdocAstUtil.pm create mode 100644 dcopidlng/kdocLib.pm create mode 100644 dcopidlng/kdocParseDoc.pm create mode 100644 dcopidlng/kdocUtil.pm (limited to 'dcopidlng') diff --git a/dcopidlng/Ast.pm b/dcopidlng/Ast.pm new file mode 100644 index 000000000..0fb4bd0d4 --- /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 000000000..7279a6faf --- /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 000000000..9ddc180e5 --- /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 000000000..d9ba453dd --- /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 000000000..b2781d11c --- /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 , 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", < "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 , 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 = ; + 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 () { + 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 ; +} + +=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 || ; + 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 = ) ) { + $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( ) { + 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 = ; + 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 = ; + } + } + 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 { ..." 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 +=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<\n"; +} + + diff --git a/dcopidlng/kalyptusCxxToDcopIDL.pm b/dcopidlng/kalyptusCxxToDcopIDL.pm new file mode 100644 index 000000000..a6fd58ad9 --- /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 "\n"; + + print STDOUT "".@{$rootnode->{Sources}}[0]->{astNodeName}."\n"; + + print STDOUT map { "$_\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 "\n"; + print STDOUT " $className\n"; + print STDOUT join("\n", map { " $_"; } grep { $_ ne "Global"; } + map { + my $name = $_->{astNodeName}; + $name =~ s//>/; + my $tmpl = $_->{TmplType}; + $tmpl =~ s//>/; + $tmpl ? "$name<$tmpl>" : $name; + } @{$node->{InList}}) . "\n"; + print STDOUT $methodCode; + + print STDOUT "\n"; + } + }); + + print STDOUT "\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, "$cast$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=\"&\"" if $x_isRef; + + $argType =~ s/^\s*(.*?)\s*$/$1/; + $argType =~ s//>/g; + $argType =~ s/\s//g; + + $args .= " $argType$arg->{ArgName}\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//>/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 .= " $returnType\n"; + $methodCode .= " $name\n"; + $methodCode .= "$args"; + $methodCode .= " \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 =~ / 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 000000000..0de248031 --- /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' => 'qt_QIntValueList*', +'QValueList&' => 'qt_QIntValueList*', +'QValueList' => 'qt_QIconDragItemValueList*', +'QValueList&' => 'qt_QIconDragItemValueList*', +'QValueList' => 'qt_QPixmapValueList*', +'QValueList&' => 'qt_QStringValueList*', +'QValueList&' => 'qt_QVariantValueList*', +'QValueList*' => 'qt_QUrlInfoValueList*', +'QValueList&' => 'kde_KDataToolInfoValueList*', +'QPtrList&' => 'kde_KActionPtrList*', +'QPtrList&' => 'kde_KSSLCertificatePtrList*', +'QPtrList*' => 'kde_KXMLGUIClientPtrList*', +'QPtrList*' => 'qt_QDockWindowPtrList*', +'QPtrList' => 'qt_QPixmapPtrList*', +'QPtrList' => '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*' => 'kde_ParsedMethodList*', +'QValueList' => '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 000000000..9c8c0dd15 --- /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 000000000..6eac4dff5 --- /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 + ------ + + + + + + + + + + + +=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="".$root->{LibDoc}->{astNodeName}.""; + } + + print LIB< + + + +$lib +$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 "{astNodeName}, + "\" REF=\"$prefix.html\">\n"; + } + else { + print LIB "\n"; + my $stats = $root->{Stats}; + foreach my $stat ( keys %$stats ) { + print LIB "", + $stats->{$stat},"\n"; + } + print LIB "\n"; + } + + if( exists $n->{Ancestors} ) { + my $in; + foreach $in ( @{$n->{Ancestors}} ) { + $in =~ s/\s+//g; + print LIB "\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 "\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( ) { + next if /^\s*$/; + if ( !/^\s*/ ) { + # TODO: what do we do with the version number? + $version = $1; + } + elsif ( // ) { + $root = $rootsub->( $1 ); + $n = $root; + } + elsif ( // ) { + # 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## ) { + # ancestor + kdocAstUtil::newInherit( $n, $1 ); + } + elsif ( m## ) { + # 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 000000000..e5f19d50c --- /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*
/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 000000000..629147ac3
--- /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 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;
+
-- 
cgit v1.2.1