From 90825e2392b2d70e43c7a25b8a3752299a933894 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/kdebindings@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kalyptus/kalyptusCxxToSwig.pm | 996 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 996 insertions(+) create mode 100644 kalyptus/kalyptusCxxToSwig.pm (limited to 'kalyptus/kalyptusCxxToSwig.pm') diff --git a/kalyptus/kalyptusCxxToSwig.pm b/kalyptus/kalyptusCxxToSwig.pm new file mode 100644 index 00000000..1430dd91 --- /dev/null +++ b/kalyptus/kalyptusCxxToSwig.pm @@ -0,0 +1,996 @@ +package kalyptusCxxToSwig; + +use File::Path; +use File::Basename; + +use Carp; +use Ast; +use kdocAstUtil; +use kdocUtil; +use Iter; +use kalyptusDataDict; + +use strict; +no strict "subs"; + +use vars qw/ @clist $host $who $now $gentext %functionId $docTop %typedeflist + $lib $rootnode $outputdir $opt $debug $typeprefix $eventHandlerCount + $constructorCount *CLASS *HEADER *QTCTYPES *KDETYPES /; + +BEGIN +{ +@clist = (); + +%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', + '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*', + 'QTextParag*' => 'void*', + 'QRemoteInterface*' => 'void*', + 'QSqlRecordPrivate*' => 'void*', + 'QTSMFI' => 'void*', # QTextStream's QTSManip + 'const GUID&' => 'void*', + 'QWidgetMapper*' => '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', + 'QRgb *' => 'uint*', + 'QRgb*' => 'uint*', + 'const QCOORD*' => 'const int*', + 'QCOORD*' => 'int*', + 'QCOORD' => 'int', + 'QCOORD &' => 'int&', + 'QTSMFI' => 'int', + 'Qt::WState' => 'int', + 'Qt::WFlags' => 'int', + 'Qt::HANDLE' => 'uint', + 'QEventLoop::ProcessEventsFlags' => 'uint', + 'QStyle::SCFlags' => 'int', + 'QStyle::SFlags' => 'int', + 'QStyleOption&' => 'int&', + 'const QStyleOption&' => 'const 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', +); + # Page footer + + $who = kdocUtil::userName(); + $host = kdocUtil::hostName(); + $now = localtime; + $gentext = "$who\@$host on $now, using kalyptus $main::Version."; + + $docTop =<{NodeType} ne "method" ) { + return 1; + } + + my $access = $kid->{Access}; +# if ( $access eq "private" || $access eq "private_slots" || $access eq "signals" ) { + if ( $access eq "private_slots" || $access eq "signals" ) { + return 1; + } + return undef; +} + +# returns 1 if the $kid is not a protected method of object $node +sub isNotProtectedMethod($$) +{ + my ($node, $kid) = @_; + + print "HERE $node->{NodeType} $node->{astNodeName}, $kid->{NodeType} $kid->{astNodeName} \n"; + if ( $kid->{NodeType} ne "method" ) { + return 1; + } + + my $access = $kid->{Access}; + if ( $access ne "protected" && $access ne "protected_slots" ) { + return 1; + } + return undef; + +} + +# Returns the list of all classes this one inherits +# If $recurse is defined function returns also all the parents +# of the classes $classNode inherits from +sub superClassList($;$) +{ + my $classNode = shift; + my $recurse = shift; + my @super; + my @nodes; + + Iter::Ancestors( $classNode, $rootnode, undef, undef, sub { + push @super, @_[0]; + if ( defined $recurse ) { + push @super, superClassList( @_[0] ); + } + }, undef ); + + return @super; +} + +# Returns the names of the classes the $classNode +# inherits from +sub parentClassNames($) +{ + my $classNode = shift; + my @names; + my @supers = superClassList($classNode); + foreach my $class (@supers) { + push @names, $class->{astNodeName}; + } + + return @names; +} + +#doesn't do anything, for me to test +sub hasPublicConstructors($) +{ + my ($node) = @_; + our $exists; + Iter::MembersByType ( $node, + sub { print SWIG_HEADER "1) @_\n"; }, + sub { my ($node, $kid ) = @_; + print SWIG_HEADER "\%$node->{NodeType} $node->{astNodeName}\% $kid->{NodeType} $kid->{astNodeName}\n"; + }, + sub { print SWIG_HEADER "3 @_ \n"; } + ); +} + + + +# Returns string representing $child method declaration or definition. +# $child is the method node for which the code should be generated, +# $parentName is the name of the parent for which the code should be generated, +# this is one is tricky, the reason for it is that $child node belongs +# to some class e.g. QWidget and we want to generate a code for $child +# but in a class called QWidget_bridge therefore we need to pass tha name +# $mangleProtected will mangle the name of the method to look like normalNameProtected +# $definition - if set the code generated will be a definition (without the opening +# and closing {} ) +sub generateMethodsCode($$$;$$) +{ + my ($child, $parentName, $mangleProtected, $definition, $inline ) = @_; + + my $ret = ""; + + if ( !(defined $definition) ) { + if ( $child->{Flags} =~ "s" ) { + $ret = "\tstatic "; + } elsif ( $child->{Flags} =~ "v" ) { + $ret = "\tvirtual "; + } else { + $ret = "\t"; + } + } + if ( defined $definition && !(defined $inline)) { + if ( $mangleProtected ) { + $ret .= "$child->{ReturnType} $parentName"."::"."$child->{astNodeName}Protected"; + } else { + $ret .= "$child->{ReturnType} $parentName"."::"."$child->{astNodeName}"; + } + } else { + if ( defined $inline ) { + $ret .= "\t"; + } + if ( $mangleProtected ) { + $ret .="$child->{ReturnType} $child->{astNodeName}Protected"; + } else { + $ret .= convertType($child->{ReturnType})." $child->{astNodeName}"; + } + } + $ret .= "("; + #$ret .= " $child->{Params} "; #can't be used because it includes names and default values + my @params = $child->{ParamList}; + foreach my $arg (@params) { + if ( $arg ) { + my @arr = @{$arg}; + my $num = @arr; + my $defParam = 'a'; + foreach my $param ( @{$arg} ) { + #print "Node: $param->{ArgType} is a $param->{NodeType}\n"; + # if ($param->{NodeType} eq "enum" ) { + #fix up enums + # $ret .= $parentName."::".$param->{astNodeName}; + #} + #else{ + $ret .= convertType($param->{ArgType})." "; + #} + # Apparently some languages do not appreciate the names and default values + ## FIXME: generate argument names for functions that do not have them + if ( ! $param->{ArgName} ) { + $param->{ArgName} = $defParam++; + $ret .= $param->{ArgName}; + } else { + $ret .= " $param->{ArgName}"; + } + # For some reason we are not getting all of these... + #if ( ! (defined $definition) ) { + # $ret .= "=$param->{DefaultValue}" if $param->{DefaultValue}; + #} + --$num; + $ret .= ", " if $num; + } + } + } + $ret .= ")"; + if ( $child->{Flags} =~ "c" ) { + $ret .= " const"; + } + if ( defined $definition ) { + $ret .= "\n"; + } else { + $ret .= ";\n"; + } +} + +sub normalMethodDeclarations($$;$&$) +{ + my ($node, $parentName, $definition, $writerSub, $inline) = @_; + my $accessType = ""; + my $defaultConstructor = 0; + my $hasPublicProtectedConstructor = 0; + my $hasDestructor = 1; + my $hasPublicDestructor = 1; + my $hasCopyConstructor = 0; + my $hasPrivateCopyConstructor = 1; + my $enums = ""; + + my @methods; + + my $ret = ""; + + Iter::MembersByType ( $node, undef, + sub { my ($classNode, $methodNode ) = @_; + if ( $methodNode->{NodeType} eq "method" || + $methodNode->{NodeType} eq "enum" || + $methodNode->{NodeType} eq "typedef" ) { + if ( $methodNode->{Access} ne "protected" && + $methodNode->{Access} ne "protected_slots" && + #$methodNode->{Access} eq "private" && + $methodNode->{Access} ne "private_slots" && + $methodNode->{Access} ne "signals" && + !$methodNode->{Pure} && + $methodNode->{astNodeName} !~ /qt_/ && + $methodNode->{astNodeName} !~ /operator/ && + $methodNode->{Params} !~ /std\:\:/ && + $methodNode->{Params} !~ /\.\.\./){ + push @methods, $methodNode; + } + } + }, undef ); + + foreach my $child ( @methods ) { + if ( $child->{Access} ne $accessType ) { + $accessType = $child->{Access}; + + if ( ! (defined $definition ) ) { + if ( $accessType eq "public_slots" ) { + $ret .= "public: //slots\n"; + } else { + $ret .= "$accessType:\n"; + } + } + } + ## check for private ctor, dtor or copy ctor... +# print " public $node->{astNodeName}, $child->{astNodeName}\n"; + if ( $node->{astNodeName} eq $child->{astNodeName} ) { +# print "Constructor..."; + if ( $child->{ReturnType} =~ /~/ ) { + # A destructor + $hasPublicDestructor = 0 if $child->{Access} ne 'public'; + $hasDestructor = 1; + } else { + if ( $child->{Params} eq '' && $child->{Access} ne 'private'){ + # A constructor + $defaultConstructor = 1; + } + } +# $hasPublicProtectedConstructor = 1 if ( $child->{Access} ne 'private' ); + + # Copy constructor? + if ( $#{$child->{ParamList}} == 0 ) { + my $theArgType = @{$child->{ParamList}}[0]->{ArgType}; + if ($theArgType =~ /$parentName\s*\&/) { + $hasCopyConstructor = 1; + $hasPrivateCopyConstructor = 1 if ( $child->{Access} eq 'private' ); + } + } + # Hack the return type for constructors, since constructors return an object pointer + #$child->{ReturnType} = $node->{astNodeName}."*"; + + } + + if( $child->{NodeType} eq "enum"){ + $ret .= "\tenum ".$child->{astNodeName}." {".$child->{Params}."};\n"; + $enums .= "\tenum ".$child->{astNodeName}." {".$child->{Params}."};\n"; + } + else{ + if ( $child->{NodeType} eq "typedef"){ + $ret .= "\t".$child->{NodeType}." ".$child->{Type}." ".$child->{astNodeName}.";\n"; + $enums .= "\t".$child->{NodeType}." ".$child->{Type}." ".$child->{astNodeName}.";\n"; + } + else{ + $ret .= generateMethodsCode( $child, $parentName, 0, $definition, $inline ); + } + } + + if ( defined $definition && defined $writerSub ) { + if ( defined $inline ) { $ret .= "\t"; } + $ret .= "{\n"; + $ret .= &$writerSub( $child ); + if ( defined $inline ) { $ret .= "\t"; } + $ret .= "}\n"; + } + + } + + if ( $defaultConstructor == 0) + { + #print "Private ctor for $node->{astNodeName}\n"; + $ret .= "private:\n\t"; + $ret .= $node->{astNodeName}."();\n"; + } + + if ( $hasCopyConstructor == 1 && $hasPrivateCopyConstructor == 1) + { + #print "Private copy ctor for $node->{astNodeName}\n"; + $ret .= "private:\n\t"; + $ret .= $node->{astNodeName}."(const ".$node->{astNodeName}."& );\n"; + } + + if ( $hasPublicDestructor == 0) + { + #print "Private dtor for $node->{astNodeName}\n"; + $ret .= "private:\n\t"; + $ret .= "~".$node->{astNodeName}."();\n"; + } + + if ( $enums ne "") + { + print "inlineing enums...\n"; + $ret .= "\n\n%{\n"; + $ret .= $enums; + $ret .= "%}\n"; + } + return $ret; +} + +sub definitionParentWriter +{ + my ($child) = @_; + my $ret = "\t\t$child->{Parent}->{astNodeName}::$child->{astNodeName}\( "; + $ret .= pureParamNames( $child ); + $ret .= ");\n"; + + return $ret; +} + +sub bridgeWriter +{ + my ($child) = @_; + my $ret = "\t\t$child->{astNodeName}Protected\( "; + $ret .= pureParamNames( $child ); + $ret .= ");\n"; + + return $ret; + +} + +# returns a list of parameter names for $method in the form: +# "a,b,c,d", suitable to call another method with the same +# parameters +sub pureParamNames($) +{ + my $method = shift; + my $ret = ""; + + my @params = $method->{ParamList}; + foreach my $arg (@params) { + if ( $arg ) { + my @arr = @{$arg}; + my $num = @arr; + foreach my $param ( @{$arg} ) { + $ret .= " $param->{ArgName}"; + --$num; + $ret .= ", " if $num; + } + } + } + return $ret; +} + +sub mangledProtectedDeclarations($$$;$$$) +{ + my ($node, $parentName, $mangle, $definition, $writerSub, $inline) = @_; + my $accessType = ""; + + my @methods; + + my $ret = ""; + + Iter::MembersByType ( $node, undef, + sub { my ($classNode, $methodNode ) = @_; + + if ( $methodNode->{NodeType} eq "method" ) { + if ( $methodNode->{Access} eq "protected" || + $methodNode->{Access} eq "protected_slots" ) { + push @methods, $methodNode; + } + } + }, undef ); + + foreach my $child ( @methods ) { + if ( $child->{Access} ne $accessType ) { + $accessType = $child->{Access}; + + if ( ! (defined $definition ) ) { + if ( $accessType eq "protected_slots" ) { + $ret .= "protected: //slots\n"; + } else { + $ret .= "$accessType:\n"; + } + } + } + $ret .= generateMethodsCode( $child, $parentName, $mangle, $definition, $inline ); + if ( defined $definition && defined $writerSub ) { + if ( defined $inline ) { $ret .= "\t"; } + $ret .= "{\n"; + #FIXME : from which of the parents does the method come from? + $ret .= &$writerSub( $child ); + if ( defined $inline ) { $ret .= "\t"; } + $ret .= "}\n"; + } + } + return $ret; +} + +sub neededImportsForObject($) +{ + my ($node) = @_; +# our @imports; + my @imports; + Iter::MembersByType ( $node, + sub { }, + sub { my ($node, $kid ) = @_; + if ( $kid->{NodeType} eq "method" && + $kid->{Access} eq "public" && + $kid->{astNodeName} !~ /qt_/ + ) { + #print "Method: $kid->{ReturnType} $kid->{astNodeName}\n"; + + my @params = $kid->{ParamList}; + foreach my $arg (@params) { + if ( $arg ) { + foreach my $param ( @{$arg} ) { + my $pname = convertType($param->{ArgType}); + if ( $pname !~ /\bQ_[A-Z0-9_]+/ && + $pname =~ /\bQ[A-Za-z0-9_]+/ && + $& ne $node->{astNodeName} + ) { + push @imports, checkObj($&); + #print "Adding $&\n"; + } + } + } + } + my $pname = convertType($kid->{ReturnType}); + if ( $pname !~ /\bQ_[A-Z0-9_]+/ && + $pname =~ /\bQ[A-Za-z0-9_]+/ && + $& ne $node->{astNodeName} + ) { + push @imports, checkObj($&); + #print "Adding $&\n"; + } + } + }, + sub { } + ); + my %seen = (); + my @uniq; + foreach my $item (@imports) { + push(@uniq, $item) unless $seen{$item}++; + } + return @uniq; +} + +sub convertType($) +{ + my ($item) = @_; + #print "-$item-\n"; + if (exists $typedeflist{$item}) { + print "$item change to $typedeflist{$item}\n"; + return $typedeflist{$item}; + } else { + return $item; + } +} + +sub checkObj($) +{ + + my ($item) = @_; + # Yes some of this is in kalyptusDataDict's ctypemap +# but that one would need to be separated (builtins vs normal classes) + + my $node = kdocAstUtil::findRef( $rootnode, $item ); + #print "Data item $item is a $node->{Access} node $node->{astNodeName}\n"; + return $node->{astNodeName}; + +} +sub generateNeededTemplatesForObject($) +{ + my ($node) = @_; + + Iter::MembersByType ( $node, + sub { }, + sub { my ($node, $kid ) = @_; + if ( $kid->{NodeType} eq "method" ) { + my @params = $kid->{ParamList}; + foreach my $arg (@params) { + if ( $arg ) { + foreach my $param ( @{$arg} ) { + my $pname = $param->{ArgType}; + if ( $pname =~ /\b(Q[A-Za-z0-9_]+)\<([A-Za-z0-9_]+)\>/ ) { + my $cname = $1; + my $tname = $2; + if ( $tname eq "type" || $tname eq "T"){ + $tname = "int"; + }else{ + print "Template $1::$2 in $pname\n"; + print SWIG_HEADER "\%template($tname",$cname,") $cname"."<",$tname,">;\n"; + } + } + } + } + } + my $returnName = $kid->{ReturnType}; + if ( $returnName =~ /\b(Q[A-Za-z0-9_]+)\<([A-Za-z0-9_]+)\>/ ) { + my $cname = $1; + my $tname = $2; + if ( $tname eq "type" || $tname eq "T"){ + $tname = "int"; + #}else{ + print "Template $1::$2 in $returnName\n"; + print SWIG_HEADER "\%template($tname",$cname,") $cname"."<",$tname,">;\n"; + } + + } + } + }, + sub { } + ); +} + +sub generateHeader($$) +{ + my ($node, $filename) = @_; + + open ( HEADER, ">$outputdir/$filename" ) || die "Can't open header $filename\n"; + print HEADER documentationHeader( $filename, "header file" ); + + my $macro = uc $filename; + $macro =~ s/\./_/g; + print HEADER "#ifndef ", $macro, "\n"; + print HEADER "#define ", $macro, "\n"; + + print HEADER "class $node->{astNodeName}Bridge;\n"; + my @parentNames = parentClassNames($node); + my $len = @parentNames; + if ( $len ) { + print HEADER "\n"; + print HEADER "$node->{NodeType} ",$typeprefix,$node->{astNodeName}," "; + my $idx = 0; + my $start = 0; + while ( $len-- ) { + if ( $len ) { + if ($parentNames[$idx] ) { + if ( !$start ) { + print HEADER ": "; + $start = 1; + } + print HEADER " public ",$typeprefix,"$parentNames[$idx],\n\t" if $parentNames[$idx]; + } + } else { + if ($parentNames[$idx] ) { + if ( !$start ) { + print HEADER ": "; + $start = 1; + } + print HEADER " public ",$typeprefix,"$parentNames[$idx]\n" if $parentNames[$idx]; + } + } + ++$idx; + } + } else { + print HEADER "$node->{NodeType} $node->{astNodeName} "; + } + print HEADER "{\n"; + print HEADER normalMethodDeclarations( $node, $typeprefix + $node->{NodeType} ); + my $prot = mangledProtectedDeclarations( $node, $typeprefix + $node->{NodeType}, 0 ); + $prot =~ s/protected\:/public\:/g; + print HEADER $prot; + print HEADER "private:\n"; + print HEADER "\t$node->{astNodeName}Bridge *mBridge;\n"; + print HEADER "};\n\n"; + print HEADER "#endif //", uc $filename, "\n"; + close HEADER; +} + +sub generateBridge($*) +{ + my($node, $fh) = @_; + + print $fh "$node->{NodeType} $node->{astNodeName}Bridge : public $node->{astNodeName}\n"; + print $fh "{\n"; + # print $fh "public:\n"; + # print $fh normalMethodDeclarations( $node, $node->{astNodeName}."Bridge" , 1, sub { definitionParentWriter(@_) }, 1 ); + print $fh "public:\n"; + print $fh mangledProtectedDeclarations( $node, $node->{astNodeName}."Bridge", 1, 1, sub { definitionParentWriter(@_) }, 1 ); + print $fh "protected:\n"; + print $fh mangledProtectedDeclarations( $node, $node->{astNodeName}."Bridge", 0, 1, sub { bridgeWriter(@_) }, 1 ); + print $fh "\n"; + print $fh "\n"; + print $fh "};\n"; + +} + +sub generateWrapper($*) +{ + my($node, $fh) = @_; + +} + +sub generateSource +{ + my ($node, $filename) = @_; + + open ( SOURCE, ">$outputdir/$filename" ) || die "Can't open $filename\n"; + + $filename =~ s/\.cpp$/\.h/; + print SOURCE "#include \"$filename\";\n\n\n"; + + generateBridge( $node, *SOURCE ); + generateWrapper( $node, *SOURCE ); + + close SOURCE; +} + +sub protectedMethods($) +{ + +} + +sub documentationHeader($$) +{ + my ($file, $descr) = @_; + my $ret = "/***************************************************************************\n"; + $ret .= " File: $file - $descr\n"; + $ret .= $docTop; + return $ret; +} + +sub writeDoc +{ + ( $lib, $rootnode, $outputdir, $opt ) = @_; + + $debug = $main::debuggen; + + mkpath( $outputdir ) unless -f $outputdir; + unlink $outputdir."/interfaces_all.i"; + + # Document all compound nodes + Iter::LocalCompounds( $rootnode, sub { writeClassDoc( shift ); } ); +} + + +sub addInterface($$$) +{ + my ($outputdir,$typeprefix,$node) = @_; + my $interfacesFile = "interfaces_all.i"; + open( IFILE, ">>$outputdir/$interfacesFile" ) || die "Can't open $outputdir/$interfacesFile"; + print IFILE "%include \"$typeprefix", kdocAstUtil::heritage($node),".i\"\n"; + close IFILE; +} + + +sub writeClassDoc +{ + my( $node ) = @_; + + if( exists $node->{ExtSource} ) { + print "Trying to write doc for ".$node->{AstNodeName}. + " from ".$node->{ExtSource}."\n"; + return; + } + + if( $node->{Access} eq "private" || + $node->{Access} eq "protected" ) { + return; + } + + my $typeName = $node->{astNodeName}."*"; + + if ( kalyptusDataDict::ctypemap($typeName) eq "" ) { + $typeprefix = ($typeName =~ /^Q/ ? "qt_" : "kde_"); + kalyptusDataDict::setctypemap($typeName, $typeprefix.$node->{astNodeName}."*"); + print "'$typeName' => '$typeprefix$typeName',\n"; + } elsif ( kalyptusDataDict::ctypemap($typeName) =~ /^qt_/ ) { + $typeprefix = "qt_"; + } elsif ( kalyptusDataDict::ctypemap($typeName) =~ /^kde_/ ) { + $typeprefix = "kde_"; + } else { + $typeprefix = "kde_"; + } + + my $basefile = "$typeprefix".join("__", kdocAstUtil::heritage($node)).".i"; + my $cppfile = $basefile; + $cppfile =~ s/\.i/_wrap\.cpp/; + + + my $file = "$outputdir/$typeprefix".join("__", kdocAstUtil::heritage($node)).".i"; + my $docnode = $node->{DocNode}; + my @list = (); + my $version = undef; + my $author = undef; + + addInterface( $outputdir, $typeprefix, $node ); + + # if( $#{$node->{Kids}} < 0 || $node->{Access} eq "private" || exists $node->{Tmpl} ) { + if( $#{$node->{Kids}} < 0 || $node->{Access} eq "private") { + return; + } + + open( SWIG_HEADER, ">$file" ) || die "Couldn't create $file\n"; + + # Header + + my $short = ""; + my $extra = ""; + + my $f = $typeprefix . $node->{astNodeName} . ".h"; + my $descr = documentationHeader( $f, "header" ); + print SWIG_HEADER $descr; + + generateHeader( $node, $f ); + $f =~ s/\.h$/\.cpp/; + generateSource( $node, $f ); + + if ( defined $docnode ) { + print SWIG_HEADER "/**\n"; + if ( defined $docnode->{Text} ) { + my $node; + foreach $node ( @{$docnode->{Text}} ) { + next if $node->{NodeType} ne "DocText"; + print SWIG_HEADER $node->{astNodeName}, "\n"; + } + } + + exists $docnode->{Author} && print SWIG_HEADER " \@author ", $docnode->{Author}, "\n"; + exists $docnode->{Version} && print SWIG_HEADER " \@version ", $docnode->{Version}, "\n"; + exists $docnode->{ClassShort} && print SWIG_HEADER " \@short ", $docnode->{ClassShort}, "\n"; + print SWIG_HEADER "*/\n"; + } + + my $sourcename = $node->{Source}->{astNodeName}; + + if ( $sourcename =~ m!.*(dom|kabc|kdeprint|kdesu|kio|kjs|kparts|ktexteditor|libkmid)/([^/]*$)! ) { + $sourcename = $1."/".$2; + } else { + $sourcename =~ s!.*/([^/]*$)!$1!; + } + + print SWIG_HEADER "\%module ",$typeprefix,$node->{astNodeName},"\n\n"; + + print SWIG_HEADER "\%{\n#include <",$sourcename , ">\n\%}\n\n"; + + #print SWIG_HEADER "\%import \"interfaces_all.i\"\n"; + + #print SWIG_HEADER "\%import \"", $basefile ,"\"\n"; + + # make this smarter i guess... +# my @types = neededImportsForObject($node); +# foreach my $f ( @types ) { +# print SWIG_HEADER "\%import \"qt_".$f.".i\"\n"; +# } +# print SWIG_HEADER "\%import \"qt_Qt.i\"\n"; + +# my @impor = parentClassNames($node); +# foreach my $f ( @impor ) { +# print SWIG_HEADER "\%import \"qt_".$f.".i\"\n"; +# } + + # Iter::LocalCompounds( $node, sub { my ($node) = @_; print STDERR "$node->{NodeType}||$node->{astNodeName} \n"; } ); + # Iter::Generic( $node, undef, + # &isNotProtectedMethod, + # sub { my ($node, $kid) = @_; debugPrint "This is :: ", $node->{astNodeName}, " | ", $kid->{astNodeName}, "\n"; }, + # undef ); + # Iter::MembersByType ( $node, undef, + # sub { my ($classNode, $methodNode ) = @_; + # + # if ( $methodNode->{NodeType} eq "method" ) { + # print SWIG_HEADER generateMethodsCode( $methodNode, 0 ); + # } + # }, undef ); + + my @parentNames = parentClassNames($node); + my $len = @parentNames; + if ( $len ) { + print SWIG_HEADER "\n"; + print SWIG_HEADER "$node->{NodeType} ",$node->{astNodeName}," "; + my $idx = 0; + my $start = 0; + while ( $len-- ) { + if ( $len ) { + if ($parentNames[$idx] ) { + if ( !$start ) { + print SWIG_HEADER ": "; + $start = 1; + } + print SWIG_HEADER " public $parentNames[$idx],\n\t" if $parentNames[$idx]; + } + } else { + if ($parentNames[$idx] ) { + if ( !$start ) { + print SWIG_HEADER ": "; + $start = 1; + } + print SWIG_HEADER " public $parentNames[$idx]\n" if $parentNames[$idx]; + } + } + ++$idx; + } + } else { + print SWIG_HEADER "$node->{NodeType} $node->{astNodeName} "; + } + print SWIG_HEADER "{\n"; +# my $name = $node->{astNodeName}."Bridge"; +# print SWIG_HEADER normalMethodDeclarations( $node, $name, 1 ); + print SWIG_HEADER normalMethodDeclarations( $node, $typeprefix + $node->{NodeType} ); + print SWIG_HEADER "};\n\n\n"; + + +# generateNeededTemplatesForObject( $node ); + print SWIG_HEADER "\n"; + + #print SWIG_HEADER "\%inline \%{\n\n"; + + #print SWIG_HEADER "class ",$node->{astNodeName},";\n"; + #print SWIG_HEADER "#include <",$sourcename , ">\n"; + #print SWIG_HEADER $node->{astNodeName}, " *",$node->{astNodeName},"Null()\n"; + #print SWIG_HEADER "{\n"; + #print SWIG_HEADER "\treturn ($node->{astNodeName}*)0L;\n"; + #print SWIG_HEADER "}\n\n"; + #print SWIG_HEADER "\%}\n"; + + $constructorCount = 0; + + # Iter::MembersByType ( $node, + # sub { print SWIG_HEADER "", $_[0], ""; }, + # sub { my ($node, $kid ) = @_; + # preParseMember( $node, $kid ); + # }, + # sub { print SWIG_HEADER ""; } + # ); + + # if ( ! exists $node->{Pure} && $constructorCount > 0 ) { + # print SWIG_HEADER "CLASS HEADER = class ", $node->{astNodeName}, "Bridge : public ", kalyptusDataDict::addNamespace($node->{astNodeName}), "\n{\npublic:\n"; + + # Iter::MembersByType ( $node, + # sub { print SWIG_HEADER "", $_[0], ""; }, + # sub { my ($node, $kid ) = @_; + # generateBridgeClass( $node, $kid ); + # }, + # sub { print SWIG_HEADER ""; } + # ); + + # generateBridgeEventHandlers($node); + # } + + %functionId = (); + $eventHandlerCount = 0; + + # Iter::MembersByType ( $node, + # sub { print SWIG_HEADER "", $_[0], ""; }, + # sub { my ($node, $kid ) = @_; + # listMember( $node, $kid ); + # }, + # sub { print SWIG_HEADER ""; } + # ); + + # ancestors + # my @ancestors = (); + # Iter::Ancestors( $node, $rootnode, undef, undef, + # sub { # print + # my ( $ances, $name, $type, $template ) = @_; + # + # push @ancestors, $name; + # + # }, + # undef + # ); + + # if ( $#ancestors > 0 ) { + # # 'type transfer' functions to cast for correct use of multiple inheritance + # foreach my $ancestor (@ancestors) { + # print SWIG_HEADER "\n/\*\* Casts a '$typeprefix", $node->{astNodeName}, " *' to a '", kalyptusDataDict::ctypemap($ancestor."\*"), "' \*/\n"; + # print SWIG_HEADER kalyptusDataDict::ctypemap($ancestor."\*"), " ", $typeprefix, $node->{astNodeName}, "_", $ancestor; + # print SWIG_HEADER "(", $typeprefix, $node->{astNodeName}, "* instPointer);\n"; + + # print CLASS kalyptusDataDict::ctypemap($ancestor."\*"), " ", $typeprefix, $node->{astNodeName}, "_", $ancestor; + # print CLASS "(", $typeprefix, $node->{astNodeName}, "* instPointer){\n"; + # print CLASS "\treturn (", kalyptusDataDict::ctypemap($ancestor."\*"), ") (", $ancestor, " *) (", $node->{astNodeName}, " *) instPointer;\n}\n"; + # } + # } + + close SWIG_HEADER; +} + +################################################################################### + +1; + -- cgit v1.2.3