From 59b13f9a1d684a632c2c73352f0ec08a63bc0913 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 21 Aug 2005 23:30:17 +0000 Subject: r9460: - Move pidl to lib/. This fixes standalone installation of pidl. - Update the README - Allow building the docs stand-alone (This used to be commit b56084ce251ab7a35dd1422f38de258e8e1e1477) --- source4/pidl/lib/Parse/Pidl/Compat.pm | 203 ++ source4/pidl/lib/Parse/Pidl/Dump.pm | 277 +++ .../pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 161 ++ source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 844 +++++++ source4/pidl/lib/Parse/Pidl/IDL.pm | 2609 ++++++++++++++++++++ source4/pidl/lib/Parse/Pidl/NDR.pm | 967 ++++++++ source4/pidl/lib/Parse/Pidl/ODL.pm | 92 + source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm | 139 ++ source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm | 212 ++ source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm | 324 +++ source4/pidl/lib/Parse/Pidl/Samba/EJS.pm | 835 +++++++ source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm | 76 + source4/pidl/lib/Parse/Pidl/Samba/Header.pm | 356 +++ source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm | 99 + source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm | 166 ++ source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 2341 ++++++++++++++++++ source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm | 322 +++ source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm | 76 + source4/pidl/lib/Parse/Pidl/Samba/TDR.pm | 266 ++ source4/pidl/lib/Parse/Pidl/Samba/Template.pm | 88 + source4/pidl/lib/Parse/Pidl/Test.pm | 169 ++ source4/pidl/lib/Parse/Pidl/Typelist.pm | 336 +++ source4/pidl/lib/Parse/Pidl/Util.pm | 149 ++ 23 files changed, 11107 insertions(+) create mode 100644 source4/pidl/lib/Parse/Pidl/Compat.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Dump.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm create mode 100644 source4/pidl/lib/Parse/Pidl/IDL.pm create mode 100644 source4/pidl/lib/Parse/Pidl/NDR.pm create mode 100644 source4/pidl/lib/Parse/Pidl/ODL.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/EJS.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/Header.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/TDR.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba/Template.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Test.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Typelist.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Util.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Compat.pm b/source4/pidl/lib/Parse/Pidl/Compat.pm new file mode 100644 index 0000000000..39cb67fd71 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Compat.pm @@ -0,0 +1,203 @@ +################################################### +# IDL Compatibility checker +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Compat; + +use Parse::Pidl::Util qw(has_property); +use strict; + +my %supported_properties = ( + # interface + "helpstring" => ["INTERFACE", "FUNCTION"], + "version" => ["INTERFACE"], + "uuid" => ["INTERFACE"], + "endpoint" => ["INTERFACE"], + "pointer_default" => ["INTERFACE"], + + # dcom + "object" => ["INTERFACE"], + "local" => ["INTERFACE", "FUNCTION"], + "iid_is" => ["ELEMENT"], + "call_as" => ["FUNCTION"], + "idempotent" => ["FUNCTION"], + + # function + "in" => ["ELEMENT"], + "out" => ["ELEMENT"], + + # pointer + "ref" => ["ELEMENT"], + "ptr" => ["ELEMENT"], + "unique" => ["ELEMENT"], + "ignore" => ["ELEMENT"], + + "value" => ["ELEMENT"], + + # generic + "public" => ["FUNCTION", "TYPEDEF"], + "nopush" => ["FUNCTION", "TYPEDEF"], + "nopull" => ["FUNCTION", "TYPEDEF"], + "noprint" => ["FUNCTION", "TYPEDEF"], + "noejs" => ["FUNCTION", "TYPEDEF"], + + # union + "switch_is" => ["ELEMENT"], + "switch_type" => ["ELEMENT", "TYPEDEF"], + "case" => ["ELEMENT"], + "default" => ["ELEMENT"], + + # subcontext + "subcontext" => ["ELEMENT"], + "subcontext_size" => ["ELEMENT"], + + # enum + "enum16bit" => ["TYPEDEF"], + "v1_enum" => ["TYPEDEF"], + + # bitmap + "bitmap8bit" => ["TYPEDEF"], + "bitmap16bit" => ["TYPEDEF"], + "bitmap32bit" => ["TYPEDEF"], + "bitmap64bit" => ["TYPEDEF"], + + # array + "range" => ["ELEMENT"], + "size_is" => ["ELEMENT"], + "string" => ["ELEMENT"], + "noheader" => ["ELEMENT"], + "charset" => ["ELEMENT"], + "length_is" => ["ELEMENT"], +); + + +my($res); + +sub warning($$) +{ + my $l = shift; + my $m = shift; + + print "$l->{FILE}:$l->{LINE}:Warning:$m\n"; +} + +sub error($$) +{ + my ($l,$m) = @_; + print "$l->{FILE}:$l->{LINE}:$m\n"; +} + +sub CheckTypedef($) +{ + my $td = shift; + + if (has_property($td, "nodiscriminant")) { + error($td, "nodiscriminant property not supported"); + } + + if ($td->{TYPE} eq "BITMAP") { + warning($td, "converting bitmap to scalar"); + #FIXME + } + + if (has_property($td, "gensize")) { + warning($td, "ignoring gensize() property. "); + } + + if (has_property($td, "enum8bit") and has_property($td, "enum16bit")) { + warning($td, "8 and 16 bit enums not supported, converting to scalar"); + #FIXME + } + + StripProperties($td); +} + +sub CheckElement($) +{ + my $e = shift; + + if (has_property($e, "noheader")) { + error($e, "noheader property not supported"); + return; + } + + if (has_property($e, "subcontext")) { + warning($e, "converting subcontext to byte array"); + #FIXME + } + + if (has_property($e, "compression")) { + error($e, "compression() property not supported"); + } + + if (has_property($e, "obfuscation")) { + error($e, "obfuscation() property not supported"); + } + + if (has_property($e, "sptr")) { + error($e, "sptr() pointer property not supported"); + } + + if (has_property($e, "relative")) { + error($e, "relative() pointer property not supported"); + } + + if (has_property($td, "flag")) { + warning($e, "ignoring flag() property"); + } + + if (has_property($td, "value")) { + warning($e, "ignoring value() property"); + } + + StripProperties($e); +} + +sub CheckFunction($) +{ + my $fn = shift; + + if (has_property($fn, "noopnum")) { + error($fn, "noopnum not converted. Opcodes will be out of sync."); + } + + StripProperties($fn); + + +} + +sub CheckInterface($) +{ + my $if = shift; + + if (has_property($if, "pointer_default_top") and + $if->{PROPERTIES}->{pointer_default_top} ne "ref") { + error($if, "pointer_default_top() is pidl-specific"); + } + + StripProperties($if); + + foreach my $x (@{$if->{DATA}}) { + if ($x->{TYPE} eq "DECLARE") { + warning($if, "the declare keyword is pidl-specific"); + next; + } + } +} + +sub Check($) +{ + my $pidl = shift; + my $nidl = []; + my $res = ""; + + foreach my $x (@{$pidl}) { + push (@$nidl, CheckInterface($x)) + if ($x->{TYPE} eq "INTERFACE"); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Dump.pm b/source4/pidl/lib/Parse/Pidl/Dump.pm new file mode 100644 index 0000000000..bca599262a --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Dump.pm @@ -0,0 +1,277 @@ +################################################### +# dump function for IDL structures +# Copyright tridge@samba.org 2000 +# released under the GNU GPL + +package Parse::Pidl::Dump; + +use Exporter; + +@ISA = qw(Exporter); +@EXPORT_OK = qw(DumpTypedef DumpStruct DumpEnum DumpBitmap DumpUnion DumpFunction); + +use strict; +use Parse::Pidl::Util qw(has_property); + +my($res); + +##################################################################### +# dump a properties list +sub DumpProperties($) +{ + my($props) = shift; + my($res); + + foreach my $d ($props) { + foreach my $k (keys %{$d}) { + if ($k eq "in") { + $res .= "[in] "; + next; + } + if ($k eq "out") { + $res .= "[out] "; + next; + } + if ($k eq "ref") { + $res .= "[ref] "; + next; + } + $res .= "[$k($d->{$k})] "; + } + } + return $res; +} + +##################################################################### +# dump a structure element +sub DumpElement($) +{ + my($element) = shift; + my($res); + + (defined $element->{PROPERTIES}) && + ($res .= DumpProperties($element->{PROPERTIES})); + $res .= DumpType($element->{TYPE}); + $res .= " "; + for my $i (1..$element->{POINTERS}) { + $res .= "*"; + } + $res .= "$element->{NAME}"; + foreach (@{$element->{ARRAY_LEN}}) { + $res .= "[$_]"; + } + + return $res; +} + +##################################################################### +# dump a struct +sub DumpStruct($) +{ + my($struct) = shift; + my($res); + + $res .= "struct {\n"; + if (defined $struct->{ELEMENTS}) { + foreach my $e (@{$struct->{ELEMENTS}}) { + $res .= "\t" . DumpElement($e); + $res .= ";\n"; + } + } + $res .= "}"; + + return $res; +} + + +##################################################################### +# dump a struct +sub DumpEnum($) +{ + my($enum) = shift; + my($res); + + $res .= "enum {\n"; + + foreach (@{$enum->{ELEMENTS}}) { + if (/^([A-Za-z0-9_]+)[ \t]*\((.*)\)$/) { + $res .= "\t$1 = $2,\n"; + } else { + $res .= "\t$_,\n"; + } + } + + $res.= "}"; + + return $res; +} + +##################################################################### +# dump a struct +sub DumpBitmap($) +{ + my($bitmap) = shift; + my($res); + + $res .= "bitmap {\n"; + + foreach (@{$bitmap->{ELEMENTS}}) { + if (/^([A-Za-z0-9_]+)[ \t]*\((.*)\)$/) { + $res .= "\t$1 = $2,\n"; + } else { + die ("Bitmap $bitmap->{NAME} has field $_ without proper value"); + } + } + + $res.= "}"; + + return $res; +} + + +##################################################################### +# dump a union element +sub DumpUnionElement($) +{ + my($element) = shift; + my($res); + + if (has_property($element, "default")) { + $res .= "[default] ;\n"; + } else { + $res .= "[case($element->{PROPERTIES}->{case})] "; + $res .= DumpElement($element), if defined($element); + $res .= ";\n"; + } + + return $res; +} + +##################################################################### +# dump a union +sub DumpUnion($) +{ + my($union) = shift; + my($res); + + (defined $union->{PROPERTIES}) && + ($res .= DumpProperties($union->{PROPERTIES})); + $res .= "union {\n"; + foreach my $e (@{$union->{ELEMENTS}}) { + $res .= DumpUnionElement($e); + } + $res .= "}"; + + return $res; +} + +##################################################################### +# dump a type +sub DumpType($) +{ + my($data) = shift; + my($res); + + if (ref($data) eq "HASH") { + ($data->{TYPE} eq "STRUCT") && ($res .= DumpStruct($data)); + ($data->{TYPE} eq "UNION") && ($res .= DumpUnion($data)); + ($data->{TYPE} eq "ENUM") && ($res .= DumpEnum($data)); + ($data->{TYPE} eq "BITMAP") && ($res .= DumpBitmap($data)); + } else { + $res .= "$data"; + } + + return $res; +} + +##################################################################### +# dump a typedef +sub DumpTypedef($) +{ + my($typedef) = shift; + my($res); + + $res .= "typedef "; + $res .= DumpType($typedef->{DATA}); + $res .= " $typedef->{NAME};\n\n"; + + return $res; +} + +##################################################################### +# dump a typedef +sub DumpFunction($) +{ + my($function) = shift; + my($first) = 1; + my($res); + + $res .= DumpType($function->{RETURN_TYPE}); + $res .= " $function->{NAME}(\n"; + for my $d (@{$function->{DATA}}) { + $first || ($res .= ",\n"); $first = 0; + $res .= DumpElement($d); + } + $res .= "\n);\n\n"; + + return $res; +} + +##################################################################### +# dump a module header +sub DumpInterfaceProperties($) +{ + my($header) = shift; + my($data) = $header->{DATA}; + my($first) = 1; + my($res); + + $res .= "[\n"; + foreach my $k (keys %{$data}) { + $first || ($res .= ",\n"); $first = 0; + $res .= "$k($data->{$k})"; + } + $res .= "\n]\n"; + + return $res; +} + +##################################################################### +# dump the interface definitions +sub DumpInterface($) +{ + my($interface) = shift; + my($data) = $interface->{DATA}; + my($res); + + $res .= DumpInterfaceProperties($interface->{PROPERTIES}); + + $res .= "interface $interface->{NAME}\n{\n"; + foreach my $d (@{$data}) { + ($d->{TYPE} eq "TYPEDEF") && + ($res .= DumpTypedef($d)); + ($d->{TYPE} eq "FUNCTION") && + ($res .= DumpFunction($d)); + } + $res .= "}\n"; + + return $res; +} + + +##################################################################### +# dump a parsed IDL structure back into an IDL file +sub Dump($) +{ + my($idl) = shift; + my($res); + + $res = "/* Dumped by pidl */\n\n"; + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && + ($res .= DumpInterface($x)); + } + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm new file mode 100644 index 0000000000..45654fe6aa --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -0,0 +1,161 @@ +################################################### +# parse an ethereal conformance file +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Ethereal::Conformance; + +require Exporter; + +@ISA = qw(Exporter); +@EXPORT_OK = qw(ReadConformance); + +use strict; + +use Parse::Pidl::Util qw(has_property); + +sub handle_type($$$$$$$$) +{ + my ($data,$name,$dissectorname,$ft_type,$base_type,$mask,$valsstring,$alignment) = @_; + + $data->{types}->{$name} = { + NAME => $name, + DISSECTOR_NAME => $dissectorname, + FT_TYPE => $ft_type, + BASE_TYPE => $base_type, + MASK => $mask, + VALSSTRING => $valsstring, + ALIGNMENT => $alignment + }; +} + + +sub handle_hf_rename($$$) +{ + my ($data,$old,$new) = @_; + $data->{hf_renames}{$old} = $new; +} + +sub handle_param_value($$$) +{ + my ($data,$dissector_name,$value) = @_; + + $data->{dissectorparams}->{$dissector_name} = $value; +} + +sub handle_hf_field($$$$$$$$$) +{ + my ($data,$hf,$title,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; + + $data->{header_fields}->{$hf} = { + HF => $hf, + TITLE => $title, + FILTER => $filter, + FT_TYPE => $ft_type, + BASE_TYPE => $base_type, + VALSSTRING => $valsstring, + MASK => $mask, + BLURB => $blurb + }; +} + +sub handle_strip_prefix($$) +{ + my ($data,$x) = @_; + + push (@{$data->{strip_prefixes}}, $x); +} + +sub handle_noemit($$) +{ + my ($data,$type) = @_; + + $data->{noemit}->{$type} = 1; +} + +sub handle_protocol($$$$$) +{ + my ($data, $name, $longname, $shortname, $filtername) = @_; + + $data->{protocols}->{$name} = { + LONGNAME => $longname, + SHORTNAME => $shortname, + FILTERNAME => $filtername + }; +} + +sub handle_fielddescription($$$) +{ + my ($data,$field,$desc) = @_; + + $data->{fielddescription}->{$field} = $desc; +} + +sub handle_import +{ + my $data = shift @_; + my $dissectorname = shift @_; + + $data->{imports}->{$dissectorname} = join(' ', @_); +} + +my %field_handlers = ( + TYPE => \&handle_type, + NOEMIT => \&handle_noemit, + PARAM_VALUE => \&handle_param_value, + HF_FIELD => \&handle_hf_field, + HF_RENAME => \&handle_hf_rename, + STRIP_PREFIX => \&handle_strip_prefix, + PROTOCOL => \&handle_protocol, + FIELD_DESCRIPTION => \&handle_fielddescription, + IMPORT => \&handle_import +); + +sub ReadConformance($$) +{ + my ($f,$data) = @_; + + $data->{override} = ""; + + my $incodeblock = 0; + + open(IN,"<$f") or return undef; + + my $ln = 0; + + foreach () { + $ln++; + next if (/^#.*$/); + next if (/^$/); + + s/[\r\n]//g; + + if ($_ eq "CODE START") { + $incodeblock = 1; + next; + } elsif ($incodeblock and $_ eq "CODE END") { + $incodeblock = 0; + next; + } elsif ($incodeblock) { + $data->{override}.="$_\n"; + next; + } + + my @fields = split(/ /); + + my $cmd = $fields[0]; + + shift @fields; + + if (not defined($field_handlers{$cmd})) { + print "$f:$ln: Warning: Unknown command `$cmd'\n"; + next; + } + + $field_handlers{$cmd}($data, @fields); + } + + close(IN); +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm new file mode 100644 index 0000000000..73dd34096e --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -0,0 +1,844 @@ +################################################## +# Samba4 NDR parser generator for IDL structures +# Copyright tridge@samba.org 2000-2003 +# Copyright tpot@samba.org 2001 +# Copyright jelmer@samba.org 2004-2005 +# Portions based on idl2eth.c by Ronnie Sahlberg +# released under the GNU GPL + +package Parse::Pidl::Ethereal::NDR; + +use strict; +use Parse::Pidl::Typelist; +use Parse::Pidl::Util qw(has_property ParseExpr property_matches); +use Parse::Pidl::NDR; +use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); +use Parse::Pidl::Ethereal::Conformance qw(ReadConformance); + +my %types; + +my $conformance = {imports=>{}}; + +my %ptrtype_mappings = ( + "unique" => "NDR_POINTER_UNIQUE", + "ref" => "NDR_POINTER_REF", + "ptr" => "NDR_POINTER_PTR" +); + +sub type2ft($) +{ + my($t) = shift; + + return "FT_UINT$1" if $t =~ /uint(8|16|32|64)/; + return "FT_INT$1" if $t =~ /int(8|16|32|64)/; + return "FT_UINT64", if $t eq "HYPER_T" or $t eq "NTTIME" + or $t eq "NTTIME_1sec" or $t eq "NTTIME_hyper" or $t eq "hyper"; + + return "FT_STRING" if ($t eq "string"); + + return "FT_NONE"; +} + +sub StripPrefixes($) +{ + my ($s) = @_; + + foreach (@{$conformance->{strip_prefixes}}) { + $s =~ s/^$_\_//g; + } + + return $s; +} + +# Convert a IDL structure field name (e.g access_mask) to a prettier +# string like 'Access Mask'. + +sub field2name($) +{ + my($field) = shift; + + $field =~ s/_/ /g; # Replace underscores with spaces + $field =~ s/(\w+)/\u\L$1/g; # Capitalise each word + + return $field; +} + +my %res = (); +my $tabs = ""; +sub pidl_code($) +{ + my $d = shift; + if ($d) { + $res{code} .= $tabs; + $res{code} .= $d; + } + $res{code} .="\n"; +} + +sub pidl_hdr($) { my $x = shift; $res{hdr} .= "$x\n"; } +sub pidl_def($) { my $x = shift; $res{def} .= "$x\n"; } + +sub indent() +{ + $tabs .= "\t"; +} + +sub deindent() +{ + $tabs = substr($tabs, 0, -1); +} + +sub PrintIdl($) +{ + my $idl = shift; + + foreach (split /\n/, $idl) { + pidl_code "/* IDL: $_ */"; + } +} + +##################################################################### +# parse the interface definitions +sub Interface($) +{ + my($interface) = @_; + Const($_,$interface->{NAME}) foreach (@{$interface->{CONSTS}}); + Typedef($_,$interface->{NAME}) foreach (@{$interface->{TYPEDEFS}}); + Function($_,$interface->{NAME}) foreach (@{$interface->{FUNCTIONS}}); +} + +sub Enum($$$) +{ + my ($e,$name,$ifname) = @_; + my $valsstring = "$ifname\_$name\_vals"; + my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name); + return if (defined($conformance->{noemit}->{$dissectorname})); + + foreach (@{$e->{ELEMENTS}}) { + if (/([^=]*)=(.*)/) { + pidl_hdr "#define $1 ($2)"; + } + } + + pidl_hdr "extern const value_string $valsstring\[];"; + pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; + + pidl_def "const value_string ".$valsstring."[] = {"; + foreach (@{$e->{ELEMENTS}}) { + next unless (/([^=]*)=(.*)/); + pidl_def "\t{ $1, \"$1\" },"; + } + + pidl_def "{ 0, NULL }"; + pidl_def "};"; + + pidl_code "int"; + pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "{"; + indent; + pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, NULL);"; + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + + my $enum_size = $e->{BASE_TYPE}; + $enum_size =~ s/uint//g; + register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8); +} + +sub Bitmap($$$) +{ + my ($e,$name,$ifname) = @_; + my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name); + + register_ett("ett_$ifname\_$name"); + + + pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; + + pidl_code "int"; + pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "{"; + indent; + pidl_code "proto_item *item=NULL;"; + pidl_code "proto_tree *tree=NULL;"; + pidl_code ""; + + pidl_code "g$e->{BASE_TYPE} flags;"; + if ($e->{ALIGN} > 1) { + pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; + } + + pidl_code ""; + + pidl_code "if(parent_tree) {"; + indent; + pidl_code "item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);"; + pidl_code "tree=proto_item_add_subtree(item,ett_$ifname\_$name);"; + deindent; + pidl_code "}\n"; + + pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);"; + + foreach (@{$e->{ELEMENTS}}) { + next unless (/([^ ]*) (.*)/); + my ($en,$ev) = ($1,$2); + my $hf_bitname = "hf_$ifname\_$name\_$en"; + my $filtername = "$ifname\.$name\.$en"; + + register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, ""); + + pidl_def "static const true_false_string $name\_$en\_tfs = {"; + pidl_def " \"$en is SET\","; + pidl_def " \"$en is NOT SET\","; + pidl_def "};"; + + pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);"; + pidl_code "if (flags&$ev){"; + pidl_code "\tproto_item_append_text(item,\"$en \");"; + pidl_code "}"; + pidl_code "flags&=(~$ev);"; + pidl_code ""; + } + + pidl_code "if(flags){"; + pidl_code "\tproto_item_append_text(item, \"UNKNOWN-FLAGS\");"; + pidl_code "}\n"; + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + + my $size = $e->{BASE_TYPE}; + $size =~ s/uint//g; + register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "NULL", $size/8); +} + +sub ElementLevel($$$$$) +{ + my ($e,$l,$hf,$myname,$pn) = @_; + + my $param = 0; + + if (defined($conformance->{dissectorparams}->{$myname})) { + $param = $conformance->{dissectorparams}->{$myname}; + } + + if ($l->{TYPE} eq "POINTER") { + my $type; + if ($l->{LEVEL} eq "TOP") { + $type = "toplevel"; + } elsif ($l->{LEVEL} eq "EMBEDDED") { + $type = "embedded"; + } + pidl_code "offset=dissect_ndr_$type\_pointer(tvb,offset,pinfo,tree,drep,$myname\_,$ptrtype_mappings{$l->{POINTER_TYPE}},\"".field2name(StripPrefixes($e->{NAME})) . " (".StripPrefixes($e->{TYPE}).")\",$hf);"; + } elsif ($l->{TYPE} eq "ARRAY") { + + if ($l->{IS_INLINE}) { + warn ("Inline arrays not supported"); + pidl_code "/* FIXME: Handle inline array */"; + } elsif ($l->{IS_FIXED}) { + pidl_code "int i;"; + pidl_code "for (i = 0; i < $l->{SIZE_IS}; i++)"; + pidl_code "\toffset=$myname\_(tvb,offset,pinfo,tree,drep);"; + } else { + my $af = ""; + ($af = "ucarray") if ($l->{IS_CONFORMANT}); + ($af = "uvarray") if ($l->{IS_VARYING}); + ($af = "ucvarray") if ($l->{IS_CONFORMANT} and $l->{IS_VARYING}); + + pidl_code "offset=dissect_ndr_$af(tvb,offset,pinfo,tree,drep,$myname\_);"; + } + } elsif ($l->{TYPE} eq "DATA") { + if ($l->{DATA_TYPE} eq "string") { + my $bs = 2; # Byte size defaults to that of UCS2 + + + ($bs = 1) if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_ASCII.*")); + + if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) { + pidl_code "offset=dissect_ndr_cvstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);"; + } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*")) { + pidl_code "offset=dissect_ndr_vstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);"; + } else { + warn("Unable to handle string with flags $e->{PROPERTIES}->{flag}"); + } + } else { + my $call; + + if (defined($types{$l->{DATA_TYPE}})) { + $call= $types{$l->{DATA_TYPE}}->{CALL}; + } elsif ($conformance->{imports}->{$l->{DATA_TYPE}}) { + $call = $conformance->{imports}->{$l->{DATA_TYPE}}; + } else { + warn("Unknown data type `$l->{DATA_TYPE}'"); + pidl_code "/* FIXME: Handle unknown data type $l->{DATA_TYPE} */"; + if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/) + { + pidl_code "offset=$1_dissect_$2(tvb,offset,pinfo,tree,drep,$hf,$param);"; + } + + return; + } + + $call =~ s/\@HF\@/$hf/g; + $call =~ s/\@PARAM\@/$param/g; + pidl_code "$call"; + } + } elsif ($_->{TYPE} eq "SUBCONTEXT") { + my $num_bits = ($l->{HEADER_SIZE}*8); + pidl_code "guint$num_bits size;"; + pidl_code "int start_offset=offset;"; + pidl_code "tvbuff_t *subtvb;"; + pidl_code "offset=dissect_ndr_uint$num_bits(tvb,offset,pinfo,tree,drep,$hf,&size);"; + pidl_code "proto_tree_add_text(tree,tvb,start_offset,offset-start_offset+size,\"Subcontext size\");"; + + pidl_code "subtvb = tvb_new_subset(tvb,offset,size,-1);"; + pidl_code "$myname\_(subtvb,0,pinfo,tree,drep);"; + } else { + die("Unknown type `$_->{TYPE}'"); + } +} + +sub Element($$$) +{ + my ($e,$pn,$ifname) = @_; + + my $dissectorname = "$ifname\_dissect\_".StripPrefixes($pn)."\_".StripPrefixes($e->{NAME}); + + my $call_code = "offset=$dissectorname(tvb,offset,pinfo,tree,drep);"; + + my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", type2ft($e->{TYPE}), "BASE_HEX", "NULL", 0, ""); + + if (defined($conformance->{noemit}->{$dissectorname})) { + return $call_code; + } + + my $add = ""; + + foreach (@{$e->{LEVELS}}) { + next if ($_->{TYPE} eq "SWITCH"); + pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);"; + pidl_code "static int"; + pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)"; + pidl_code "{"; + indent; + + ElementLevel($e,$_,$hf,$dissectorname.$add,$pn); + + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + $add.="_"; + } + + return $call_code; +} + +sub Function($$$) +{ + my ($fn,$ifname) = @_; + + my %dissectornames; + + foreach (@{$fn->{ELEMENTS}}) { + $dissectornames{$_->{NAME}} = Element($_, $fn->{NAME}, $ifname) + } + + my $fn_name = $_->{NAME}; + $fn_name =~ s/^${ifname}_//; + + PrintIdl DumpFunction($fn->{ORIGINAL}); + pidl_code "static int"; + pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; + pidl_code "{"; + indent; + foreach (@{$fn->{ELEMENTS}}) { + if (grep(/out/,@{$_->{DIRECTION}})) { + pidl_code "$dissectornames{$_->{NAME}}"; + pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);"; + pidl_code ""; + } + } + + if (not defined($fn->{RETURN_TYPE})) { + } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { + pidl_code "offset=dissect_ntstatus(tvb,offset,pinfo,tree,drep,hf\_$ifname\_status, NULL);"; + } elsif ($fn->{RETURN_TYPE} eq "WERROR") { + pidl_code "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,hf\_$ifname\_werror, NULL);"; + } + + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + + pidl_code "static int"; + pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; + pidl_code "{"; + indent; + foreach (@{$fn->{ELEMENTS}}) { + if (grep(/in/,@{$_->{DIRECTION}})) { + pidl_code "$dissectornames{$_->{NAME}}"; + pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);"; + } + + } + + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; +} + +sub Struct($$$) +{ + my ($e,$name,$ifname) = @_; + my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name); + + return if (defined($conformance->{noemit}->{$dissectorname})); + + register_ett("ett_$ifname\_$name"); + + my $res = ""; + ($res.="\t".Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}}); + + pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_);"; + + pidl_code "int"; + pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "{"; + indent; + pidl_code "proto_item *item = NULL;"; + pidl_code "proto_tree *tree = NULL;"; + pidl_code "int old_offset;"; + pidl_code ""; + + if ($e->{ALIGN} > 1) { + pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; + } + pidl_code ""; + + pidl_code "old_offset=offset;"; + pidl_code ""; + pidl_code "if(parent_tree){"; + indent; + pidl_code "item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);"; + pidl_code "tree=proto_item_add_subtree(item, ett_$ifname\_$name);"; + deindent; + pidl_code "}"; + + pidl_code "\n$res"; + + pidl_code "proto_item_set_len(item, offset-old_offset);"; + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + + register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); +} + +sub Union($$$) +{ + my ($e,$name,$ifname) = @_; + + my $dissectorname = "$ifname\_dissect_".StripPrefixes($name); + return if (defined($conformance->{noemit}->{$dissectorname})); + + register_ett("ett_$ifname\_$name"); + + my $res = ""; + foreach (@{$e->{ELEMENTS}}) { + $res.="\n\t\t$_->{CASE}:\n"; + if ($_->{TYPE} ne "EMPTY") { + $res.="\t\t\t".Element($_, $name, $ifname)."\n"; + } + $res.="\t\tbreak;\n"; + } + + pidl_code "static int"; + pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "{"; + indent; + pidl_code "proto_item *item=NULL;"; + pidl_code "proto_tree *tree=NULL;"; + pidl_code "int old_offset;"; + pidl_code "g$e->{SWITCH_TYPE} level;"; + pidl_code ""; + + if ($e->{ALIGN} > 1) { + pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; + } + + pidl_code ""; + + pidl_code "old_offset=offset;"; + pidl_code "if(parent_tree){"; + indent; + pidl_code "item=proto_tree_add_text(parent_tree,tvb,offset,-1,\"$name\");"; + pidl_code "tree=proto_item_add_subtree(item,ett_$ifname\_$name);"; + deindent; + pidl_code "}"; + + pidl_code ""; + + pidl_code "offset = dissect_ndr_$e->{SWITCH_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, &level);"; + + pidl_code "switch(level) {$res\t}"; + pidl_code "proto_item_set_len(item, offset-old_offset);"; + pidl_code "return offset;"; + deindent; + pidl_code "}"; + + register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); +} + +sub Const($$) +{ + my ($const,$ifname) = @_; + + if (!defined($const->{ARRAY_LEN}[0])) { + pidl_hdr "#define $const->{NAME}\t( $const->{VALUE} )\n"; + } else { + pidl_hdr "#define $const->{NAME}\t $const->{VALUE}\n"; + } +} + +sub Typedef($$) +{ + my ($e,$ifname) = @_; + + PrintIdl DumpTypedef($e->{ORIGINAL}); + + { + ENUM => \&Enum, + STRUCT => \&Struct, + UNION => \&Union, + BITMAP => \&Bitmap + }->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $ifname); +} + +sub RegisterInterface($) +{ + my ($x) = @_; + + pidl_code "void proto_register_dcerpc_$x->{NAME}(void)"; + pidl_code "{"; + indent; + + $res{code}.=DumpHfList()."\n"; + $res{code}.="\n".DumpEttList()."\n"; + + if (defined($x->{UUID})) { + # These can be changed to non-pidl_code names if the old dissectors + # in epan/dissctors are deleted. + + my $name = "\"" . uc($x->{NAME}) . " (pidl)\""; + my $short_name = $x->{NAME}; + my $filter_name = $x->{NAME}; + + if (has_property($x, "helpstring")) { + $name = $x->{PROPERTIES}->{helpstring}; + } + + if (defined($conformance->{protocols}->{$x->{NAME}})) { + $short_name = $conformance->{protocols}->{$x->{NAME}}->{SHORTNAME}; + $name = $conformance->{protocols}->{$x->{NAME}}->{LONGNAME}; + $filter_name = $conformance->{protocols}->{$x->{NAME}}->{FILTERNAME}; + } + + pidl_code "proto_dcerpc_$x->{NAME} = proto_register_protocol($name, \"$short_name\", \"$filter_name\");"; + + pidl_code "proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));"; + pidl_code "proto_register_subtree_array(ett, array_length(ett));"; + } else { + pidl_code "proto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");"; + pidl_code "proto_register_field_array(proto_dcerpc, hf, array_length(hf));"; + pidl_code "proto_register_subtree_array(ett, array_length(ett));"; + } + + deindent; + pidl_code "}\n"; +} + +sub RegisterInterfaceHandoff($) +{ + my $x = shift; + pidl_code "void proto_reg_handoff_dcerpc_$x->{NAME}(void)"; + pidl_code "{"; + indent; + pidl_code "dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},"; + pidl_code "\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},"; + pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);"; + deindent; + pidl_code "}"; +} + +sub ProcessInterface($) +{ + my ($x) = @_; + + push(@{$conformance->{strip_prefixes}}, $x->{NAME}); + + my $define = "__PACKET_DCERPC_" . uc($_->{NAME}) . "_H"; + pidl_hdr "#ifndef $define"; + pidl_hdr "#define $define"; + pidl_hdr ""; + + if (defined $x->{PROPERTIES}->{depends}) { + foreach (split / /, $x->{PROPERTIES}->{depends}) { + next if($_ eq "security"); + pidl_hdr "#include \"packet-dcerpc-$_\.h\"\n"; + } + } + + pidl_def "static gint proto_dcerpc_$x->{NAME} = -1;"; + register_ett("ett_dcerpc_$x->{NAME}"); + register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, ""); + register_hf_field("hf_$x->{NAME}_status", "Status", "$x->{NAME}.status", "FT_UINT32", "BASE_HEX", "VALS(NT_errors)", 0, ""); + register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "NULL", 0, ""); + + if (defined($x->{UUID})) { + my $if_uuid = $x->{UUID}; + + pidl_def "/* Version information */\n\n"; + + pidl_def "static e_uuid_t uuid_dcerpc_$x->{NAME} = {"; + pidl_def "\t0x" . substr($if_uuid, 1, 8) + . ", 0x" . substr($if_uuid, 10, 4) + . ", 0x" . substr($if_uuid, 15, 4) . ","; + pidl_def "\t{ 0x" . substr($if_uuid, 20, 2) + . ", 0x" . substr($if_uuid, 22, 2) + . ", 0x" . substr($if_uuid, 25, 2) + . ", 0x" . substr($if_uuid, 27, 2) + . ", 0x" . substr($if_uuid, 29, 2) + . ", 0x" . substr($if_uuid, 31, 2) + . ", 0x" . substr($if_uuid, 33, 2) + . ", 0x" . substr($if_uuid, 35, 2) . " }"; + pidl_def "};"; + + my $maj = $x->{VERSION}; + $maj =~ s/\.(.*)$//g; + pidl_def "static guint16 ver_dcerpc_$x->{NAME} = $maj;"; + pidl_def ""; + } + + Interface($x); + + pidl_code "\n".DumpFunctionTable($x); + + RegisterInterface($x); + RegisterInterfaceHandoff($x); + + pidl_hdr "#endif /* $define */"; +} + + +sub register_type($$$$$$$) +{ + my ($type,$call,$ft,$base,$mask,$vals,$length) = @_; + + $types{$type} = { + TYPE => $type, + CALL => $call, + FT_TYPE => $ft, + BASE => $base, + MASK => $mask, + VALSSTRING => $vals, + LENGTH => $length + }; +} + +# Loads the default types +sub Initialize($) +{ + my $cnf_file = shift; + + $conformance = {}; + + ReadConformance($cnf_file, $conformance) or print "Warning: Not using conformance file `$cnf_file'\n"; + + foreach my $bytes (qw(1 2 4 8)) { + my $bits = $bytes * 8; + register_type("uint$bits", "offset=dissect_ndr_uint$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes); + register_type("int$bits", "offset=dissect_ndr_uint$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes); + } + + register_type("udlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4); + register_type("bool8", "offset=dissect_ndr_uint8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + register_type("char", "offset=dissect_ndr_uint8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + register_type("long", "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4); + register_type("dlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8); + register_type("GUID", "offset=dissect_ndr_uuid_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4); + register_type("policy_handle", "offset=dissect_nt_policy_hnd(tvb,offset,pinfo,tree,drep,\@HF\@,NULL,NULL,\@PARAM\@&0x01,\@PARAM\@&0x02);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); + register_type("NTTIME", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + register_type("NTTIME_hyper", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + register_type("time_t", "offset=dissect_ndr_time_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4); + register_type("NTTIME_1sec", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + register_type("SID", " + dcerpc_info *di = (dcerpc_info *)pinfo->private_data; + + di->hf_index = \@HF\@; + + offset=dissect_ndr_nt_SID_with_options(tvb,offset,pinfo,tree,drep,param); + ","FT_STRING", "BASE_DEC", 0, "NULL", 4); + register_type("WERROR", + "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4); + +} + +##################################################################### +# Generate ethereal parser and header code +sub Parse($$) +{ + my($ndr,$h_filename,$cnf_file) = @_; + Initialize($cnf_file); + + $tabs = ""; + + %res = (code=>"",def=>"",hdr=>""); + + pidl_hdr "/* header auto-generated by pidl */"; + + $res{headers} = "\n"; + $res{headers} .= "#ifdef HAVE_CONFIG_H\n"; + $res{headers} .= "#include \"config.h\"\n"; + $res{headers} .= "#endif\n\n"; + $res{headers} .= "#include \n"; + $res{headers} .= "#include \n"; + $res{headers} .= "#include \n\n"; + + $res{headers} .= "#include \"packet-dcerpc.h\"\n"; + $res{headers} .= "#include \"packet-dcerpc-nt.h\"\n"; + $res{headers} .= "#include \"packet-windows-common.h\"\n"; + $res{headers} .= "#include \"$h_filename\"\n"; + pidl_code ""; + + # Ethereal protocol registration + + ProcessInterface($_) foreach (@$ndr); + + $res{ett} = DumpEttDeclaration(); + $res{hf} = DumpHfDeclaration(); + + my $parser = "/* parser auto-generated by pidl */"; + $parser.= $res{headers}; + $parser.=$res{ett}; + $parser.=$res{hf}; + $parser.=$res{def}; + $parser.=$conformance->{override}; + $parser.=$res{code}; + + my $header = "/* autogenerated by pidl */\n\n"; + $header.=$res{hdr}; + + return ($parser,$header); +} + +############################################################################### +# ETT +############################################################################### + +my @ett = (); + +sub register_ett($) +{ + my $name = shift; + + push (@ett, $name); +} + +sub DumpEttList() +{ + my $res = "\tstatic gint *ett[] = {\n"; + foreach (@ett) { + $res .= "\t\t&$_,\n"; + } + + return "$res\t};\n"; +} + +sub DumpEttDeclaration() +{ + my $res = "\n/* Ett declarations */\n"; + foreach (@ett) { + $res .= "static gint $_ = -1;\n"; + } + + return "$res\n"; +} + +############################################################################### +# HF +############################################################################### + +my %hf = (); + +sub register_hf_field($$$$$$$$) +{ + my ($index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; + + return $conformance->{hf_renames}->{$index} if defined ($conformance->{hf_renames}->{$index}); + + $hf{$index} = { + INDEX => $index, + NAME => $name, + FILTER => $filter_name, + FT_TYPE => $ft_type, + BASE_TYPE => $base_type, + VALS => $valsstring, + MASK => $mask, + BLURB => $blurb + }; + + return $index; +} + +sub DumpHfDeclaration() +{ + my $res = ""; + + $res = "\n/* Header field declarations */\n"; + + foreach (keys %hf) + { + $res .= "static gint $_ = -1;\n"; + } + + return "$res\n"; +} + +sub DumpHfList() +{ + my $res = "\tstatic hf_register_info hf[] = {\n"; + + foreach (values %hf) + { + $res .= "\t{ &$_->{INDEX}, + { \"$_->{NAME}\", \"$_->{FILTER}\", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALS}, $_->{MASK}, \"$_->{BLURB}\", HFILL }}, +"; + } + + return $res."\t};\n"; +} + + +############################################################################### +# Function table +############################################################################### + +sub DumpFunctionTable($) +{ + my $if = shift; + + my $res = "static dcerpc_sub_dissector $if->{NAME}\_dissectors[] = {\n"; + foreach (@{$if->{FUNCTIONS}}) { + my $fn_name = $_->{NAME}; + $fn_name =~ s/^$if->{NAME}_//; + $res.= "\t{ $_->{OPNUM}, \"$fn_name\",\n"; + $res.= "\t $if->{NAME}_dissect_${fn_name}_request, $if->{NAME}_dissect_${fn_name}_response},\n"; + } + + $res .= "\t{ 0, NULL, NULL, NULL }\n"; + + return "$res};\n"; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm new file mode 100644 index 0000000000..7f7e5bcdca --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -0,0 +1,2609 @@ +#################################################################### +# +# This file was generated using Parse::Yapp version 1.05. +# +# Don't edit this file, use source file instead. +# +# ANY CHANGE MADE HERE WILL BE LOST ! +# +#################################################################### +package Parse::Pidl::IDL; +use vars qw ( @ISA ); +use strict; + +@ISA= qw ( Parse::Yapp::Driver ); +#Included Parse/Yapp/Driver.pm file---------------------------------------- +{ +# +# Module Parse::Yapp::Driver +# +# This module is part of the Parse::Yapp package available on your +# nearest CPAN +# +# Any use of this module in a standalone parser make the included +# text under the same copyright as the Parse::Yapp module itself. +# +# This notice should remain unchanged. +# +# (c) Copyright 1998-2001 Francois Desarmenien, all rights reserved. +# (see the pod text in Parse::Yapp module for use and distribution rights) +# + +package Parse::Yapp::Driver; + +require 5.004; + +use strict; + +use vars qw ( $VERSION $COMPATIBLE $FILENAME ); + +$VERSION = '1.05'; +$COMPATIBLE = '0.07'; +$FILENAME=__FILE__; + +use Carp; + +#Known parameters, all starting with YY (leading YY will be discarded) +my(%params)=(YYLEX => 'CODE', 'YYERROR' => 'CODE', YYVERSION => '', + YYRULES => 'ARRAY', YYSTATES => 'ARRAY', YYDEBUG => ''); +#Mandatory parameters +my(@params)=('LEX','RULES','STATES'); + +sub new { + my($class)=shift; + my($errst,$nberr,$token,$value,$check,$dotpos); + my($self)={ ERROR => \&_Error, + ERRST => \$errst, + NBERR => \$nberr, + TOKEN => \$token, + VALUE => \$value, + DOTPOS => \$dotpos, + STACK => [], + DEBUG => 0, + CHECK => \$check }; + + _CheckParams( [], \%params, \@_, $self ); + + exists($$self{VERSION}) + and $$self{VERSION} < $COMPATIBLE + and croak "Yapp driver version $VERSION ". + "incompatible with version $$self{VERSION}:\n". + "Please recompile parser module."; + + ref($class) + and $class=ref($class); + + bless($self,$class); +} + +sub YYParse { + my($self)=shift; + my($retval); + + _CheckParams( \@params, \%params, \@_, $self ); + + if($$self{DEBUG}) { + _DBLoad(); + $retval = eval '$self->_DBParse()';#Do not create stab entry on compile + $@ and die $@; + } + else { + $retval = $self->_Parse(); + } + $retval +} + +sub YYData { + my($self)=shift; + + exists($$self{USER}) + or $$self{USER}={}; + + $$self{USER}; + +} + +sub YYErrok { + my($self)=shift; + + ${$$self{ERRST}}=0; + undef; +} + +sub YYNberr { + my($self)=shift; + + ${$$self{NBERR}}; +} + +sub YYRecovering { + my($self)=shift; + + ${$$self{ERRST}} != 0; +} + +sub YYAbort { + my($self)=shift; + + ${$$self{CHECK}}='ABORT'; + undef; +} + +sub YYAccept { + my($self)=shift; + + ${$$self{CHECK}}='ACCEPT'; + undef; +} + +sub YYError { + my($self)=shift; + + ${$$self{CHECK}}='ERROR'; + undef; +} + +sub YYSemval { + my($self)=shift; + my($index)= $_[0] - ${$$self{DOTPOS}} - 1; + + $index < 0 + and -$index <= @{$$self{STACK}} + and return $$self{STACK}[$index][1]; + + undef; #Invalid index +} + +sub YYCurtok { + my($self)=shift; + + @_ + and ${$$self{TOKEN}}=$_[0]; + ${$$self{TOKEN}}; +} + +sub YYCurval { + my($self)=shift; + + @_ + and ${$$self{VALUE}}=$_[0]; + ${$$self{VALUE}}; +} + +sub YYExpect { + my($self)=shift; + + keys %{$self->{STATES}[$self->{STACK}[-1][0]]{ACTIONS}} +} + +sub YYLexer { + my($self)=shift; + + $$self{LEX}; +} + + +################# +# Private stuff # +################# + + +sub _CheckParams { + my($mandatory,$checklist,$inarray,$outhash)=@_; + my($prm,$value); + my($prmlst)={}; + + while(($prm,$value)=splice(@$inarray,0,2)) { + $prm=uc($prm); + exists($$checklist{$prm}) + or croak("Unknow parameter '$prm'"); + ref($value) eq $$checklist{$prm} + or croak("Invalid value for parameter '$prm'"); + $prm=unpack('@2A*',$prm); + $$outhash{$prm}=$value; + } + for (@$mandatory) { + exists($$outhash{$_}) + or croak("Missing mandatory parameter '".lc($_)."'"); + } +} + +sub _Error { + print "Parse error.\n"; +} + +sub _DBLoad { + { + no strict 'refs'; + + exists(${__PACKAGE__.'::'}{_DBParse})#Already loaded ? + and return; + } + my($fname)=__FILE__; + my(@drv); + open(DRV,"<$fname") or die "Report this as a BUG: Cannot open $fname"; + while() { + /^\s*sub\s+_Parse\s*{\s*$/ .. /^\s*}\s*#\s*_Parse\s*$/ + and do { + s/^#DBG>//; + push(@drv,$_); + } + } + close(DRV); + + $drv[0]=~s/_P/_DBP/; + eval join('',@drv); +} + +#Note that for loading debugging version of the driver, +#this file will be parsed from 'sub _Parse' up to '}#_Parse' inclusive. +#So, DO NOT remove comment at end of sub !!! +sub _Parse { + my($self)=shift; + + my($rules,$states,$lex,$error) + = @$self{ 'RULES', 'STATES', 'LEX', 'ERROR' }; + my($errstatus,$nberror,$token,$value,$stack,$check,$dotpos) + = @$self{ 'ERRST', 'NBERR', 'TOKEN', 'VALUE', 'STACK', 'CHECK', 'DOTPOS' }; + +#DBG> my($debug)=$$self{DEBUG}; +#DBG> my($dbgerror)=0; + +#DBG> my($ShowCurToken) = sub { +#DBG> my($tok)='>'; +#DBG> for (split('',$$token)) { +#DBG> $tok.= (ord($_) < 32 or ord($_) > 126) +#DBG> ? sprintf('<%02X>',ord($_)) +#DBG> : $_; +#DBG> } +#DBG> $tok.='<'; +#DBG> }; + + $$errstatus=0; + $$nberror=0; + ($$token,$$value)=(undef,undef); + @$stack=( [ 0, undef ] ); + $$check=''; + + while(1) { + my($actions,$act,$stateno); + + $stateno=$$stack[-1][0]; + $actions=$$states[$stateno]; + +#DBG> print STDERR ('-' x 40),"\n"; +#DBG> $debug & 0x2 +#DBG> and print STDERR "In state $stateno:\n"; +#DBG> $debug & 0x08 +#DBG> and print STDERR "Stack:[". +#DBG> join(',',map { $$_[0] } @$stack). +#DBG> "]\n"; + + + if (exists($$actions{ACTIONS})) { + + defined($$token) + or do { + ($$token,$$value)=&$lex($self); +#DBG> $debug & 0x01 +#DBG> and print STDERR "Need token. Got ".&$ShowCurToken."\n"; + }; + + $act= exists($$actions{ACTIONS}{$$token}) + ? $$actions{ACTIONS}{$$token} + : exists($$actions{DEFAULT}) + ? $$actions{DEFAULT} + : undef; + } + else { + $act=$$actions{DEFAULT}; +#DBG> $debug & 0x01 +#DBG> and print STDERR "Don't need token.\n"; + } + + defined($act) + and do { + + $act > 0 + and do { #shift + +#DBG> $debug & 0x04 +#DBG> and print STDERR "Shift and go to state $act.\n"; + + $$errstatus + and do { + --$$errstatus; + +#DBG> $debug & 0x10 +#DBG> and $dbgerror +#DBG> and $$errstatus == 0 +#DBG> and do { +#DBG> print STDERR "**End of Error recovery.\n"; +#DBG> $dbgerror=0; +#DBG> }; + }; + + + push(@$stack,[ $act, $$value ]); + + $$token ne '' #Don't eat the eof + and $$token=$$value=undef; + next; + }; + + #reduce + my($lhs,$len,$code,@sempar,$semval); + ($lhs,$len,$code)=@{$$rules[-$act]}; + +#DBG> $debug & 0x04 +#DBG> and $act +#DBG> and print STDERR "Reduce using rule ".-$act." ($lhs,$len): "; + + $act + or $self->YYAccept(); + + $$dotpos=$len; + + unpack('A1',$lhs) eq '@' #In line rule + and do { + $lhs =~ /^\@[0-9]+\-([0-9]+)$/ + or die "In line rule name '$lhs' ill formed: ". + "report it as a BUG.\n"; + $$dotpos = $1; + }; + + @sempar = $$dotpos + ? map { $$_[1] } @$stack[ -$$dotpos .. -1 ] + : (); + + $semval = $code ? &$code( $self, @sempar ) + : @sempar ? $sempar[0] : undef; + + splice(@$stack,-$len,$len); + + $$check eq 'ACCEPT' + and do { + +#DBG> $debug & 0x04 +#DBG> and print STDERR "Accept.\n"; + + return($semval); + }; + + $$check eq 'ABORT' + and do { + +#DBG> $debug & 0x04 +#DBG> and print STDERR "Abort.\n"; + + return(undef); + + }; + +#DBG> $debug & 0x04 +#DBG> and print STDERR "Back to state $$stack[-1][0], then "; + + $$check eq 'ERROR' + or do { +#DBG> $debug & 0x04 +#DBG> and print STDERR +#DBG> "go to state $$states[$$stack[-1][0]]{GOTOS}{$lhs}.\n"; + +#DBG> $debug & 0x10 +#DBG> and $dbgerror +#DBG> and $$errstatus == 0 +#DBG> and do { +#DBG> print STDERR "**End of Error recovery.\n"; +#DBG> $dbgerror=0; +#DBG> }; + + push(@$stack, + [ $$states[$$stack[-1][0]]{GOTOS}{$lhs}, $semval ]); + $$check=''; + next; + }; + +#DBG> $debug & 0x04 +#DBG> and print STDERR "Forced Error recovery.\n"; + + $$check=''; + + }; + + #Error + $$errstatus + or do { + + $$errstatus = 1; + &$error($self); + $$errstatus # if 0, then YYErrok has been called + or next; # so continue parsing + +#DBG> $debug & 0x10 +#DBG> and do { +#DBG> print STDERR "**Entering Error recovery.\n"; +#DBG> ++$dbgerror; +#DBG> }; + + ++$$nberror; + + }; + + $$errstatus == 3 #The next token is not valid: discard it + and do { + $$token eq '' # End of input: no hope + and do { +#DBG> $debug & 0x10 +#DBG> and print STDERR "**At eof: aborting.\n"; + return(undef); + }; + +#DBG> $debug & 0x10 +#DBG> and print STDERR "**Dicard invalid token ".&$ShowCurToken.".\n"; + + $$token=$$value=undef; + }; + + $$errstatus=3; + + while( @$stack + and ( not exists($$states[$$stack[-1][0]]{ACTIONS}) + or not exists($$states[$$stack[-1][0]]{ACTIONS}{error}) + or $$states[$$stack[-1][0]]{ACTIONS}{error} <= 0)) { + +#DBG> $debug & 0x10 +#DBG> and print STDERR "**Pop state $$stack[-1][0].\n"; + + pop(@$stack); + } + + @$stack + or do { + +#DBG> $debug & 0x10 +#DBG> and print STDERR "**No state left on stack: aborting.\n"; + + return(undef); + }; + + #shift the error token + +#DBG> $debug & 0x10 +#DBG> and print STDERR "**Shift \$error token and go to state ". +#DBG> $$states[$$stack[-1][0]]{ACTIONS}{error}. +#DBG> ".\n"; + + push(@$stack, [ $$states[$$stack[-1][0]]{ACTIONS}{error}, undef ]); + + } + + #never reached + croak("Error in driver logic. Please, report it as a BUG"); + +}#_Parse +#DO NOT remove comment + +1; + +} +#End of include-------------------------------------------------- + + + + +sub new { + my($class)=shift; + ref($class) + and $class=ref($class); + + my($self)=$class->SUPER::new( yyversion => '1.05', + yystates => +[ + {#State 0 + DEFAULT => -1, + GOTOS => { + 'idl' => 1 + } + }, + {#State 1 + ACTIONS => { + '' => 2 + }, + DEFAULT => -63, + GOTOS => { + 'interface' => 3, + 'coclass' => 4, + 'property_list' => 5 + } + }, + {#State 2 + DEFAULT => 0 + }, + {#State 3 + DEFAULT => -2 + }, + {#State 4 + DEFAULT => -3 + }, + {#State 5 + ACTIONS => { + "coclass" => 6, + "interface" => 8, + "[" => 7 + } + }, + {#State 6 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 10 + } + }, + {#State 7 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 11, + 'properties' => 13, + 'property' => 12 + } + }, + {#State 8 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 14 + } + }, + {#State 9 + DEFAULT => -89 + }, + {#State 10 + ACTIONS => { + "{" => 15 + } + }, + {#State 11 + ACTIONS => { + "(" => 16 + }, + DEFAULT => -67 + }, + {#State 12 + DEFAULT => -65 + }, + {#State 13 + ACTIONS => { + "," => 17, + "]" => 18 + } + }, + {#State 14 + ACTIONS => { + ":" => 19 + }, + DEFAULT => -8, + GOTOS => { + 'base_interface' => 20 + } + }, + {#State 15 + DEFAULT => -5, + GOTOS => { + 'interface_names' => 21 + } + }, + {#State 16 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'listtext' => 26, + 'anytext' => 25, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 17 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 11, + 'property' => 29 + } + }, + {#State 18 + DEFAULT => -64 + }, + {#State 19 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 30 + } + }, + {#State 20 + ACTIONS => { + "{" => 31 + } + }, + {#State 21 + ACTIONS => { + "}" => 32, + "interface" => 33 + } + }, + {#State 22 + DEFAULT => -93 + }, + {#State 23 + DEFAULT => -74 + }, + {#State 24 + DEFAULT => -76 + }, + {#State 25 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "&" => 39, + "{" => 38, + "/" => 40, + "(" => 41, + "|" => 42, + "*" => 43, + "." => 44, + ">" => 45 + }, + DEFAULT => -69 + }, + {#State 26 + ACTIONS => { + "," => 46, + ")" => 47 + } + }, + {#State 27 + DEFAULT => -75 + }, + {#State 28 + DEFAULT => -92 + }, + {#State 29 + DEFAULT => -66 + }, + {#State 30 + DEFAULT => -9 + }, + {#State 31 + ACTIONS => { + "typedef" => 48, + "union" => 49, + "enum" => 62, + "bitmap" => 63, + "declare" => 55, + "const" => 57, + "struct" => 60 + }, + DEFAULT => -63, + GOTOS => { + 'typedecl' => 61, + 'function' => 50, + 'bitmap' => 64, + 'definitions' => 51, + 'definition' => 54, + 'property_list' => 53, + 'usertype' => 52, + 'declare' => 66, + 'const' => 65, + 'struct' => 56, + 'enum' => 58, + 'typedef' => 59, + 'union' => 67 + } + }, + {#State 32 + ACTIONS => { + ";" => 68 + }, + DEFAULT => -94, + GOTOS => { + 'optional_semicolon' => 69 + } + }, + {#State 33 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 70 + } + }, + {#State 34 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 71, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 35 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 72, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 36 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 73, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 37 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 74, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 38 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 75, + 'text' => 24, + 'constant' => 27, + 'commalisttext' => 76 + } + }, + {#State 39 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 77, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 40 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 78, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 41 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 75, + 'text' => 24, + 'constant' => 27, + 'commalisttext' => 79 + } + }, + {#State 42 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 80, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 43 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 81, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 44 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 82, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 45 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 83, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 46 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 84, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 47 + DEFAULT => -68 + }, + {#State 48 + DEFAULT => -63, + GOTOS => { + 'property_list' => 85 + } + }, + {#State 49 + ACTIONS => { + 'IDENTIFIER' => 86 + }, + DEFAULT => -91, + GOTOS => { + 'optional_identifier' => 87 + } + }, + {#State 50 + DEFAULT => -12 + }, + {#State 51 + ACTIONS => { + "}" => 88, + "typedef" => 48, + "union" => 49, + "enum" => 62, + "bitmap" => 63, + "declare" => 55, + "const" => 57, + "struct" => 60 + }, + DEFAULT => -63, + GOTOS => { + 'typedecl' => 61, + 'function' => 50, + 'bitmap' => 64, + 'definition' => 89, + 'property_list' => 53, + 'usertype' => 52, + 'const' => 65, + 'struct' => 56, + 'declare' => 66, + 'enum' => 58, + 'typedef' => 59, + 'union' => 67 + } + }, + {#State 52 + ACTIONS => { + ";" => 90 + } + }, + {#State 53 + ACTIONS => { + 'IDENTIFIER' => 9, + "union" => 49, + "enum" => 62, + "bitmap" => 63, + "[" => 7, + 'void' => 91, + "struct" => 60 + }, + GOTOS => { + 'identifier' => 93, + 'struct' => 56, + 'enum' => 58, + 'type' => 94, + 'union' => 67, + 'bitmap' => 64, + 'usertype' => 92 + } + }, + {#State 54 + DEFAULT => -10 + }, + {#State 55 + DEFAULT => -63, + GOTOS => { + 'property_list' => 95 + } + }, + {#State 56 + DEFAULT => -26 + }, + {#State 57 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 96 + } + }, + {#State 58 + DEFAULT => -28 + }, + {#State 59 + DEFAULT => -14 + }, + {#State 60 + ACTIONS => { + 'IDENTIFIER' => 86 + }, + DEFAULT => -91, + GOTOS => { + 'optional_identifier' => 97 + } + }, + {#State 61 + DEFAULT => -16 + }, + {#State 62 + ACTIONS => { + 'IDENTIFIER' => 86 + }, + DEFAULT => -91, + GOTOS => { + 'optional_identifier' => 98 + } + }, + {#State 63 + ACTIONS => { + 'IDENTIFIER' => 86 + }, + DEFAULT => -91, + GOTOS => { + 'optional_identifier' => 99 + } + }, + {#State 64 + DEFAULT => -29 + }, + {#State 65 + DEFAULT => -13 + }, + {#State 66 + DEFAULT => -15 + }, + {#State 67 + DEFAULT => -27 + }, + {#State 68 + DEFAULT => -95 + }, + {#State 69 + DEFAULT => -4 + }, + {#State 70 + ACTIONS => { + ";" => 100 + } + }, + {#State 71 + ACTIONS => { + "<" => 35, + "~" => 36, + "{" => 38 + }, + DEFAULT => -77 + }, + {#State 72 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "*" => 43, + "{" => 38, + "&" => 39, + "/" => 40, + "(" => 41, + "|" => 42, + "." => 44, + ">" => 45 + }, + DEFAULT => -81 + }, + {#State 73 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "*" => 43, + "{" => 38, + "&" => 39, + "/" => 40, + "(" => 41, + "|" => 42, + "." => 44, + ">" => 45 + }, + DEFAULT => -86 + }, + {#State 74 + ACTIONS => { + "<" => 35, + "~" => 36, + "{" => 38 + }, + DEFAULT => -85 + }, + {#State 75 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "*" => 43, + "{" => 38, + "&" => 39, + "/" => 40, + "(" => 41, + "|" => 42, + "." => 44, + ">" => 45 + }, + DEFAULT => -71 + }, + {#State 76 + ACTIONS => { + "}" => 101, + "," => 102 + } + }, + {#State 77 + ACTIONS => { + "<" => 35, + "~" => 36, + "{" => 38 + }, + DEFAULT => -83 + }, + {#State 78 + ACTIONS => { + "<" => 35, + "~" => 36, + "{" => 38 + }, + DEFAULT => -84 + }, + {#State 79 + ACTIONS => { + "," => 102, + ")" => 103 + } + }, + {#State 80 + ACTIONS => { + "<" => 35, + "~" => 36, + "{" => 38 + }, + DEFAULT => -82 + }, + {#State 81 + ACTIONS => { + "<" => 35, + "~" => 36, + "{" => 38 + }, + DEFAULT => -79 + }, + {#State 82 + ACTIONS => { + "<" => 35, + "~" => 36, + "{" => 38 + }, + DEFAULT => -78 + }, + {#State 83 + ACTIONS => { + "<" => 35, + "~" => 36, + "{" => 38 + }, + DEFAULT => -80 + }, + {#State 84 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "&" => 39, + "{" => 38, + "/" => 40, + "|" => 42, + "(" => 41, + "*" => 43, + "." => 44, + ">" => 45 + }, + DEFAULT => -70 + }, + {#State 85 + ACTIONS => { + 'IDENTIFIER' => 9, + "union" => 49, + "enum" => 62, + "bitmap" => 63, + "[" => 7, + 'void' => 91, + "struct" => 60 + }, + GOTOS => { + 'identifier' => 93, + 'struct' => 56, + 'enum' => 58, + 'type' => 104, + 'union' => 67, + 'bitmap' => 64, + 'usertype' => 92 + } + }, + {#State 86 + DEFAULT => -90 + }, + {#State 87 + ACTIONS => { + "{" => 105 + } + }, + {#State 88 + ACTIONS => { + ";" => 68 + }, + DEFAULT => -94, + GOTOS => { + 'optional_semicolon' => 106 + } + }, + {#State 89 + DEFAULT => -11 + }, + {#State 90 + DEFAULT => -30 + }, + {#State 91 + DEFAULT => -33 + }, + {#State 92 + DEFAULT => -31 + }, + {#State 93 + DEFAULT => -32 + }, + {#State 94 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 107 + } + }, + {#State 95 + ACTIONS => { + "enum" => 111, + "bitmap" => 112, + "[" => 7 + }, + GOTOS => { + 'decl_enum' => 108, + 'decl_bitmap' => 109, + 'decl_type' => 110 + } + }, + {#State 96 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 113 + } + }, + {#State 97 + ACTIONS => { + "{" => 114 + } + }, + {#State 98 + ACTIONS => { + "{" => 115 + } + }, + {#State 99 + ACTIONS => { + "{" => 116 + } + }, + {#State 100 + DEFAULT => -6 + }, + {#State 101 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 117, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 102 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 118, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 103 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 119, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 104 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 120 + } + }, + {#State 105 + DEFAULT => -48, + GOTOS => { + 'union_elements' => 121 + } + }, + {#State 106 + DEFAULT => -7 + }, + {#State 107 + ACTIONS => { + "(" => 122 + } + }, + {#State 108 + DEFAULT => -21 + }, + {#State 109 + DEFAULT => -22 + }, + {#State 110 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 123 + } + }, + {#State 111 + DEFAULT => -23 + }, + {#State 112 + DEFAULT => -24 + }, + {#State 113 + ACTIONS => { + "[" => 124, + "=" => 126 + }, + GOTOS => { + 'array_len' => 125 + } + }, + {#State 114 + DEFAULT => -54, + GOTOS => { + 'element_list1' => 127 + } + }, + {#State 115 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 128, + 'enum_element' => 129, + 'enum_elements' => 130 + } + }, + {#State 116 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 133, + 'bitmap_elements' => 132, + 'bitmap_element' => 131 + } + }, + {#State 117 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "*" => 43, + "{" => 38, + "&" => 39, + "/" => 40, + "(" => 41, + "|" => 42, + "." => 44, + ">" => 45 + }, + DEFAULT => -88 + }, + {#State 118 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "*" => 43, + "{" => 38, + "&" => 39, + "/" => 40, + "(" => 41, + "|" => 42, + "." => 44, + ">" => 45 + }, + DEFAULT => -72 + }, + {#State 119 + ACTIONS => { + "<" => 35, + "~" => 36, + "{" => 38 + }, + DEFAULT => -87 + }, + {#State 120 + ACTIONS => { + "[" => 124 + }, + DEFAULT => -60, + GOTOS => { + 'array_len' => 134 + } + }, + {#State 121 + ACTIONS => { + "}" => 135 + }, + DEFAULT => -63, + GOTOS => { + 'optional_base_element' => 137, + 'property_list' => 136 + } + }, + {#State 122 + ACTIONS => { + "," => -56, + "void" => 141, + ")" => -56 + }, + DEFAULT => -63, + GOTOS => { + 'base_element' => 138, + 'element_list2' => 140, + 'property_list' => 139 + } + }, + {#State 123 + ACTIONS => { + ";" => 142 + } + }, + {#State 124 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + "]" => 143, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 144, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 125 + ACTIONS => { + "=" => 145 + } + }, + {#State 126 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 146, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 127 + ACTIONS => { + "}" => 147 + }, + DEFAULT => -63, + GOTOS => { + 'base_element' => 148, + 'property_list' => 139 + } + }, + {#State 128 + ACTIONS => { + "=" => 149 + }, + DEFAULT => -37 + }, + {#State 129 + DEFAULT => -35 + }, + {#State 130 + ACTIONS => { + "}" => 150, + "," => 151 + } + }, + {#State 131 + DEFAULT => -40 + }, + {#State 132 + ACTIONS => { + "}" => 152, + "," => 153 + } + }, + {#State 133 + ACTIONS => { + "=" => 154 + } + }, + {#State 134 + ACTIONS => { + ";" => 155 + } + }, + {#State 135 + DEFAULT => -50 + }, + {#State 136 + ACTIONS => { + "[" => 7 + }, + DEFAULT => -63, + GOTOS => { + 'base_or_empty' => 156, + 'base_element' => 157, + 'empty_element' => 158, + 'property_list' => 159 + } + }, + {#State 137 + DEFAULT => -49 + }, + {#State 138 + DEFAULT => -58 + }, + {#State 139 + ACTIONS => { + 'IDENTIFIER' => 9, + "union" => 49, + "enum" => 62, + "bitmap" => 63, + "[" => 7, + 'void' => 91, + "struct" => 60 + }, + GOTOS => { + 'identifier' => 93, + 'struct' => 56, + 'enum' => 58, + 'type' => 160, + 'union' => 67, + 'bitmap' => 64, + 'usertype' => 92 + } + }, + {#State 140 + ACTIONS => { + "," => 161, + ")" => 162 + } + }, + {#State 141 + DEFAULT => -57 + }, + {#State 142 + DEFAULT => -20 + }, + {#State 143 + ACTIONS => { + "[" => 124 + }, + DEFAULT => -60, + GOTOS => { + 'array_len' => 163 + } + }, + {#State 144 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "&" => 39, + "{" => 38, + "/" => 40, + "|" => 42, + "(" => 41, + "*" => 43, + "." => 44, + "]" => 164, + ">" => 45 + } + }, + {#State 145 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 165, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 146 + ACTIONS => { + "-" => 34, + "<" => 35, + ";" => 166, + "+" => 37, + "~" => 36, + "&" => 39, + "{" => 38, + "/" => 40, + "|" => 42, + "(" => 41, + "*" => 43, + "." => 44, + ">" => 45 + } + }, + {#State 147 + DEFAULT => -43 + }, + {#State 148 + ACTIONS => { + ";" => 167 + } + }, + {#State 149 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 168, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 150 + DEFAULT => -34 + }, + {#State 151 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 128, + 'enum_element' => 169 + } + }, + {#State 152 + DEFAULT => -39 + }, + {#State 153 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 133, + 'bitmap_element' => 170 + } + }, + {#State 154 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 171, + 'text' => 24, + 'constant' => 27 + } + }, + {#State 155 + DEFAULT => -25 + }, + {#State 156 + DEFAULT => -47 + }, + {#State 157 + ACTIONS => { + ";" => 172 + } + }, + {#State 158 + DEFAULT => -46 + }, + {#State 159 + ACTIONS => { + 'IDENTIFIER' => 9, + "union" => 49, + ";" => 173, + "enum" => 62, + "bitmap" => 63, + 'void' => 91, + "[" => 7, + "struct" => 60 + }, + GOTOS => { + 'identifier' => 93, + 'struct' => 56, + 'enum' => 58, + 'type' => 160, + 'union' => 67, + 'bitmap' => 64, + 'usertype' => 92 + } + }, + {#State 160 + DEFAULT => -52, + GOTOS => { + 'pointers' => 174 + } + }, + {#State 161 + DEFAULT => -63, + GOTOS => { + 'base_element' => 175, + 'property_list' => 139 + } + }, + {#State 162 + ACTIONS => { + ";" => 176 + } + }, + {#State 163 + DEFAULT => -61 + }, + {#State 164 + ACTIONS => { + "[" => 124 + }, + DEFAULT => -60, + GOTOS => { + 'array_len' => 177 + } + }, + {#State 165 + ACTIONS => { + "-" => 34, + "<" => 35, + ";" => 178, + "+" => 37, + "~" => 36, + "&" => 39, + "{" => 38, + "/" => 40, + "|" => 42, + "(" => 41, + "*" => 43, + "." => 44, + ">" => 45 + } + }, + {#State 166 + DEFAULT => -17 + }, + {#State 167 + DEFAULT => -55 + }, + {#State 168 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "&" => 39, + "{" => 38, + "/" => 40, + "|" => 42, + "(" => 41, + "*" => 43, + "." => 44, + ">" => 45 + }, + DEFAULT => -38 + }, + {#State 169 + DEFAULT => -36 + }, + {#State 170 + DEFAULT => -41 + }, + {#State 171 + ACTIONS => { + "-" => 34, + "<" => 35, + "+" => 37, + "~" => 36, + "&" => 39, + "{" => 38, + "/" => 40, + "|" => 42, + "(" => 41, + "*" => 43, + "." => 44, + ">" => 45 + }, + DEFAULT => -42 + }, + {#State 172 + DEFAULT => -45 + }, + {#State 173 + DEFAULT => -44 + }, + {#State 174 + ACTIONS => { + 'IDENTIFIER' => 9, + "*" => 180 + }, + GOTOS => { + 'identifier' => 179 + } + }, + {#State 175 + DEFAULT => -59 + }, + {#State 176 + DEFAULT => -19 + }, + {#State 177 + DEFAULT => -62 + }, + {#State 178 + DEFAULT => -18 + }, + {#State 179 + ACTIONS => { + "[" => 124 + }, + DEFAULT => -60, + GOTOS => { + 'array_len' => 181 + } + }, + {#State 180 + DEFAULT => -53 + }, + {#State 181 + DEFAULT => -51 + } +], + yyrules => +[ + [#Rule 0 + '$start', 2, undef + ], + [#Rule 1 + 'idl', 0, undef + ], + [#Rule 2 + 'idl', 2, +sub +#line 19 "build/pidl/idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 3 + 'idl', 2, +sub +#line 20 "build/pidl/idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 4 + 'coclass', 7, +sub +#line 24 "build/pidl/idl.yp" +{$_[3] => { + "TYPE" => "COCLASS", + "PROPERTIES" => $_[1], + "NAME" => $_[3], + "DATA" => $_[5], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE}, + }} + ], + [#Rule 5 + 'interface_names', 0, undef + ], + [#Rule 6 + 'interface_names', 4, +sub +#line 36 "build/pidl/idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 7 + 'interface', 8, +sub +#line 40 "build/pidl/idl.yp" +{$_[3] => { + "TYPE" => "INTERFACE", + "PROPERTIES" => $_[1], + "NAME" => $_[3], + "BASE" => $_[4], + "DATA" => $_[6], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE}, + }} + ], + [#Rule 8 + 'base_interface', 0, undef + ], + [#Rule 9 + 'base_interface', 2, +sub +#line 53 "build/pidl/idl.yp" +{ $_[2] } + ], + [#Rule 10 + 'definitions', 1, +sub +#line 57 "build/pidl/idl.yp" +{ [ $_[1] ] } + ], + [#Rule 11 + 'definitions', 2, +sub +#line 58 "build/pidl/idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 12 + 'definition', 1, undef + ], + [#Rule 13 + 'definition', 1, undef + ], + [#Rule 14 + 'definition', 1, undef + ], + [#Rule 15 + 'definition', 1, undef + ], + [#Rule 16 + 'definition', 1, undef + ], + [#Rule 17 + 'const', 6, +sub +#line 66 "build/pidl/idl.yp" +{{ + "TYPE" => "CONST", + "DTYPE" => $_[2], + "NAME" => $_[3], + "VALUE" => $_[5], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE}, + }} + ], + [#Rule 18 + 'const', 7, +sub +#line 75 "build/pidl/idl.yp" +{{ + "TYPE" => "CONST", + "DTYPE" => $_[2], + "NAME" => $_[3], + "ARRAY_LEN" => $_[4], + "VALUE" => $_[6], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE}, + }} + ], + [#Rule 19 + 'function', 7, +sub +#line 88 "build/pidl/idl.yp" +{{ + "TYPE" => "FUNCTION", + "NAME" => $_[3], + "RETURN_TYPE" => $_[2], + "PROPERTIES" => $_[1], + "ELEMENTS" => $_[5], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE}, + }} + ], + [#Rule 20 + 'declare', 5, +sub +#line 100 "build/pidl/idl.yp" +{{ + "TYPE" => "DECLARE", + "PROPERTIES" => $_[2], + "NAME" => $_[4], + "DATA" => $_[3], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE}, + }} + ], + [#Rule 21 + 'decl_type', 1, undef + ], + [#Rule 22 + 'decl_type', 1, undef + ], + [#Rule 23 + 'decl_enum', 1, +sub +#line 114 "build/pidl/idl.yp" +{{ + "TYPE" => "ENUM" + }} + ], + [#Rule 24 + 'decl_bitmap', 1, +sub +#line 120 "build/pidl/idl.yp" +{{ + "TYPE" => "BITMAP" + }} + ], + [#Rule 25 + 'typedef', 6, +sub +#line 126 "build/pidl/idl.yp" +{{ + "TYPE" => "TYPEDEF", + "PROPERTIES" => $_[2], + "NAME" => $_[4], + "DATA" => $_[3], + "ARRAY_LEN" => $_[5], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE}, + }} + ], + [#Rule 26 + 'usertype', 1, undef + ], + [#Rule 27 + 'usertype', 1, undef + ], + [#Rule 28 + 'usertype', 1, undef + ], + [#Rule 29 + 'usertype', 1, undef + ], + [#Rule 30 + 'typedecl', 2, +sub +#line 139 "build/pidl/idl.yp" +{ $_[1] } + ], + [#Rule 31 + 'type', 1, undef + ], + [#Rule 32 + 'type', 1, undef + ], + [#Rule 33 + 'type', 1, +sub +#line 142 "build/pidl/idl.yp" +{ "void" } + ], + [#Rule 34 + 'enum', 5, +sub +#line 146 "build/pidl/idl.yp" +{{ + "TYPE" => "ENUM", + "NAME" => $_[2], + "ELEMENTS" => $_[4] + }} + ], + [#Rule 35 + 'enum_elements', 1, +sub +#line 154 "build/pidl/idl.yp" +{ [ $_[1] ] } + ], + [#Rule 36 + 'enum_elements', 3, +sub +#line 155 "build/pidl/idl.yp" +{ push(@{$_[1]}, $_[3]); $_[1] } + ], + [#Rule 37 + 'enum_element', 1, undef + ], + [#Rule 38 + 'enum_element', 3, +sub +#line 159 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 39 + 'bitmap', 5, +sub +#line 163 "build/pidl/idl.yp" +{{ + "TYPE" => "BITMAP", + "NAME" => $_[2], + "ELEMENTS" => $_[4] + }} + ], + [#Rule 40 + 'bitmap_elements', 1, +sub +#line 171 "build/pidl/idl.yp" +{ [ $_[1] ] } + ], + [#Rule 41 + 'bitmap_elements', 3, +sub +#line 172 "build/pidl/idl.yp" +{ push(@{$_[1]}, $_[3]); $_[1] } + ], + [#Rule 42 + 'bitmap_element', 3, +sub +#line 175 "build/pidl/idl.yp" +{ "$_[1] ( $_[3] )" } + ], + [#Rule 43 + 'struct', 5, +sub +#line 179 "build/pidl/idl.yp" +{{ + "TYPE" => "STRUCT", + "NAME" => $_[2], + "ELEMENTS" => $_[4] + }} + ], + [#Rule 44 + 'empty_element', 2, +sub +#line 187 "build/pidl/idl.yp" +{{ + "NAME" => "", + "TYPE" => "EMPTY", + "PROPERTIES" => $_[1], + "POINTERS" => 0, + "ARRAY_LEN" => [], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE}, + }} + ], + [#Rule 45 + 'base_or_empty', 2, undef + ], + [#Rule 46 + 'base_or_empty', 1, undef + ], + [#Rule 47 + 'optional_base_element', 2, +sub +#line 201 "build/pidl/idl.yp" +{ $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } + ], + [#Rule 48 + 'union_elements', 0, undef + ], + [#Rule 49 + 'union_elements', 2, +sub +#line 206 "build/pidl/idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 50 + 'union', 5, +sub +#line 210 "build/pidl/idl.yp" +{{ + "TYPE" => "UNION", + "NAME" => $_[2], + "ELEMENTS" => $_[4] + }} + ], + [#Rule 51 + 'base_element', 5, +sub +#line 218 "build/pidl/idl.yp" +{{ + "NAME" => $_[4], + "TYPE" => $_[2], + "PROPERTIES" => $_[1], + "POINTERS" => $_[3], + "ARRAY_LEN" => $_[5], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE}, + }} + ], + [#Rule 52 + 'pointers', 0, +sub +#line 232 "build/pidl/idl.yp" +{ 0 } + ], + [#Rule 53 + 'pointers', 2, +sub +#line 233 "build/pidl/idl.yp" +{ $_[1]+1 } + ], + [#Rule 54 + 'element_list1', 0, undef + ], + [#Rule 55 + 'element_list1', 3, +sub +#line 238 "build/pidl/idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 56 + 'element_list2', 0, undef + ], + [#Rule 57 + 'element_list2', 1, undef + ], + [#Rule 58 + 'element_list2', 1, +sub +#line 244 "build/pidl/idl.yp" +{ [ $_[1] ] } + ], + [#Rule 59 + 'element_list2', 3, +sub +#line 245 "build/pidl/idl.yp" +{ push(@{$_[1]}, $_[3]); $_[1] } + ], + [#Rule 60 + 'array_len', 0, undef + ], + [#Rule 61 + 'array_len', 3, +sub +#line 250 "build/pidl/idl.yp" +{ push(@{$_[3]}, "*"); $_[3] } + ], + [#Rule 62 + 'array_len', 4, +sub +#line 251 "build/pidl/idl.yp" +{ push(@{$_[4]}, "$_[2]"); $_[4] } + ], + [#Rule 63 + 'property_list', 0, undef + ], + [#Rule 64 + 'property_list', 4, +sub +#line 257 "build/pidl/idl.yp" +{ Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); } + ], + [#Rule 65 + 'properties', 1, +sub +#line 260 "build/pidl/idl.yp" +{ $_[1] } + ], + [#Rule 66 + 'properties', 3, +sub +#line 261 "build/pidl/idl.yp" +{ Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); } + ], + [#Rule 67 + 'property', 1, +sub +#line 264 "build/pidl/idl.yp" +{{ "$_[1]" => "1" }} + ], + [#Rule 68 + 'property', 4, +sub +#line 265 "build/pidl/idl.yp" +{{ "$_[1]" => "$_[3]" }} + ], + [#Rule 69 + 'listtext', 1, undef + ], + [#Rule 70 + 'listtext', 3, +sub +#line 270 "build/pidl/idl.yp" +{ "$_[1] $_[3]" } + ], + [#Rule 71 + 'commalisttext', 1, undef + ], + [#Rule 72 + 'commalisttext', 3, +sub +#line 275 "build/pidl/idl.yp" +{ "$_[1],$_[3]" } + ], + [#Rule 73 + 'anytext', 0, +sub +#line 279 "build/pidl/idl.yp" +{ "" } + ], + [#Rule 74 + 'anytext', 1, undef + ], + [#Rule 75 + 'anytext', 1, undef + ], + [#Rule 76 + 'anytext', 1, undef + ], + [#Rule 77 + 'anytext', 3, +sub +#line 281 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 78 + 'anytext', 3, +sub +#line 282 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 79 + 'anytext', 3, +sub +#line 283 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 80 + 'anytext', 3, +sub +#line 284 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 81 + 'anytext', 3, +sub +#line 285 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 82 + 'anytext', 3, +sub +#line 286 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 83 + 'anytext', 3, +sub +#line 287 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 84 + 'anytext', 3, +sub +#line 288 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 85 + 'anytext', 3, +sub +#line 289 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 86 + 'anytext', 3, +sub +#line 290 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 87 + 'anytext', 5, +sub +#line 291 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]$_[4]$_[5]" } + ], + [#Rule 88 + 'anytext', 5, +sub +#line 292 "build/pidl/idl.yp" +{ "$_[1]$_[2]$_[3]$_[4]$_[5]" } + ], + [#Rule 89 + 'identifier', 1, undef + ], + [#Rule 90 + 'optional_identifier', 1, undef + ], + [#Rule 91 + 'optional_identifier', 0, undef + ], + [#Rule 92 + 'constant', 1, undef + ], + [#Rule 93 + 'text', 1, +sub +#line 306 "build/pidl/idl.yp" +{ "\"$_[1]\"" } + ], + [#Rule 94 + 'optional_semicolon', 0, undef + ], + [#Rule 95 + 'optional_semicolon', 1, undef + ] +], + @_); + bless($self,$class); +} + +#line 317 "build/pidl/idl.yp" + + +use Parse::Pidl::Util; + +##################################################################### +# traverse a perl data structure removing any empty arrays or +# hashes and any hash elements that map to undef +sub CleanData($) +{ + sub CleanData($); + my($v) = shift; + if (ref($v) eq "ARRAY") { + foreach my $i (0 .. $#{$v}) { + CleanData($v->[$i]); + if (ref($v->[$i]) eq "ARRAY" && $#{$v->[$i]}==-1) { + $v->[$i] = undef; + next; + } + } + # this removes any undefined elements from the array + @{$v} = grep { defined $_ } @{$v}; + } elsif (ref($v) eq "HASH") { + foreach my $x (keys %{$v}) { + CleanData($v->{$x}); + if (!defined $v->{$x}) { delete($v->{$x}); next; } + if (ref($v->{$x}) eq "ARRAY" && $#{$v->{$x}}==-1) { delete($v->{$x}); next; } + } + } + return $v; +} + +sub _Error { + if (exists $_[0]->YYData->{ERRMSG}) { + print $_[0]->YYData->{ERRMSG}; + delete $_[0]->YYData->{ERRMSG}; + return; + }; + my $line = $_[0]->YYData->{LINE}; + my $last_token = $_[0]->YYData->{LAST_TOKEN}; + my $file = $_[0]->YYData->{INPUT_FILENAME}; + + print "$file:$line: Syntax error near '$last_token'\n"; +} + +sub _Lexer($) +{ + my($parser)=shift; + + $parser->YYData->{INPUT} or return('',undef); + +again: + $parser->YYData->{INPUT} =~ s/^[ \t]*//; + + for ($parser->YYData->{INPUT}) { + if (/^\#/) { + if (s/^\# (\d+) \"(.*?)\"( \d+|)//) { + $parser->YYData->{LINE} = $1-1; + $parser->YYData->{INPUT_FILENAME} = $2; + goto again; + } + if (s/^\#line (\d+) \"(.*?)\"( \d+|)//) { + $parser->YYData->{LINE} = $1-1; + $parser->YYData->{INPUT_FILENAME} = $2; + goto again; + } + if (s/^(\#.*)$//m) { + goto again; + } + } + if (s/^(\n)//) { + $parser->YYData->{LINE}++; + goto again; + } + if (s/^\"(.*?)\"//) { + $parser->YYData->{LAST_TOKEN} = $1; + return('TEXT',$1); + } + if (s/^(\d+)(\W|$)/$2/) { + $parser->YYData->{LAST_TOKEN} = $1; + return('CONSTANT',$1); + } + if (s/^([\w_]+)//) { + $parser->YYData->{LAST_TOKEN} = $1; + if ($1 =~ + /^(coclass|interface|const|typedef|declare|union + |struct|enum|bitmap|void)$/x) { + return $1; + } + return('IDENTIFIER',$1); + } + if (s/^(.)//s) { + $parser->YYData->{LAST_TOKEN} = $1; + return($1,$1); + } + } +} + +sub parse_idl($$) +{ + my ($self,$filename) = @_; + + my $saved_delim = $/; + undef $/; + my $cpp = $ENV{CPP}; + if (! defined $cpp) { + $cpp = "cpp" + } + my $data = `$cpp -D__PIDL__ -xc $filename`; + $/ = $saved_delim; + + $self->YYData->{INPUT} = $data; + $self->YYData->{LINE} = 0; + $self->YYData->{LAST_TOKEN} = "NONE"; + + my $idl = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error ); + + return CleanData($idl); +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm new file mode 100644 index 0000000000..e00a0c9828 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -0,0 +1,967 @@ +################################################### +# Samba4 NDR info tree generator +# Copyright tridge@samba.org 2000-2003 +# Copyright tpot@samba.org 2001 +# Copyright jelmer@samba.org 2004-2005 +# released under the GNU GPL + +package Parse::Pidl::NDR; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred); + +use strict; +use Parse::Pidl::Typelist qw(hasType getType); +use Parse::Pidl::Util qw(has_property property_matches); + +sub nonfatal($$) +{ + my ($e,$s) = @_; + warn ("$e->{FILE}:$e->{LINE}: Warning: $s\n"); +} + +##################################################################### +# signal a fatal validation error +sub fatal($$) +{ + my ($pos,$s) = @_; + die("$pos->{FILE}:$pos->{LINE}:$s\n"); +} + +##################################################################### +# return a table describing the order in which the parts of an element +# should be parsed +# Possible level types: +# - POINTER +# - ARRAY +# - SUBCONTEXT +# - SWITCH +# - DATA +sub GetElementLevelTable($) +{ + my $e = shift; + + my $order = []; + my $is_deferred = 0; + my @bracket_array = (); + my @length_is = (); + my @size_is = (); + + if (has_property($e, "size_is")) { + @size_is = split /,/, has_property($e, "size_is"); + } + + if (has_property($e, "length_is")) { + @length_is = split /,/, has_property($e, "length_is"); + } + + if (defined($e->{ARRAY_LEN})) { + @bracket_array = @{$e->{ARRAY_LEN}}; + } + + # Parse the [][][][] style array stuff + foreach my $d (@bracket_array) { + my $size = $d; + my $length = $d; + my $is_surrounding = 0; + my $is_varying = 0; + my $is_conformant = 0; + my $is_string = 0; + + if ($d eq "*") { + $is_conformant = 1; + if ($size = shift @size_is) { + } elsif ((scalar(@size_is) == 0) and has_property($e, "string")) { + $is_string = 1; + delete($e->{PROPERTIES}->{string}); + } else { + print "$e->{FILE}:$e->{LINE}: Must specify size_is() for conformant array!\n"; + exit 1; + } + + if (($length = shift @length_is) or $is_string) { + $is_varying = 1; + } else { + $length = $size; + } + + if ($e == $e->{PARENT}->{ELEMENTS}[-1] + and $e->{PARENT}->{TYPE} ne "FUNCTION") { + $is_surrounding = 1; + } + } + + push (@$order, { + TYPE => "ARRAY", + SIZE_IS => $size, + LENGTH_IS => $length, + IS_DEFERRED => "$is_deferred", + IS_SURROUNDING => "$is_surrounding", + IS_ZERO_TERMINATED => "$is_string", + IS_VARYING => "$is_varying", + IS_CONFORMANT => "$is_conformant", + IS_FIXED => (not $is_conformant and Parse::Pidl::Util::is_constant($size)), + IS_INLINE => (not $is_conformant and not Parse::Pidl::Util::is_constant($size)) + }); + } + + # Next, all the pointers + foreach my $i (1..$e->{POINTERS}) { + my $pt = pointer_type($e); + + my $level = "EMBEDDED"; + # Top level "ref" pointers do not have a referrent identifier + $level = "TOP" if ( defined($pt) + and $i == 1 + and $e->{PARENT}->{TYPE} eq "FUNCTION"); + + push (@$order, { + TYPE => "POINTER", + # for now, there can only be one pointer type per element + POINTER_TYPE => pointer_type($e), + IS_DEFERRED => "$is_deferred", + LEVEL => $level + }); + + # everything that follows will be deferred + $is_deferred = 1 if ($e->{PARENT}->{TYPE} ne "FUNCTION"); + + my $array_size = shift @size_is; + my $array_length; + my $is_varying; + my $is_conformant; + my $is_string = 0; + if ($array_size) { + $is_conformant = 1; + if ($array_length = shift @length_is) { + $is_varying = 1; + } else { + $array_length = $array_size; + $is_varying =0; + } + } + + if (scalar(@size_is) == 0 and has_property($e, "string")) { + $is_string = 1; + $is_varying = $is_conformant = has_property($e, "noheader")?0:1; + delete($e->{PROPERTIES}->{string}); + } + + if ($array_size or $is_string) { + push (@$order, { + TYPE => "ARRAY", + IS_ZERO_TERMINATED => "$is_string", + SIZE_IS => $array_size, + LENGTH_IS => $array_length, + IS_DEFERRED => "$is_deferred", + IS_SURROUNDING => 0, + IS_VARYING => "$is_varying", + IS_CONFORMANT => "$is_conformant", + IS_FIXED => 0, + IS_INLINE => 0, + }); + + $is_deferred = 0; + } + } + + if (defined(has_property($e, "subcontext"))) { + my $hdr_size = has_property($e, "subcontext"); + my $subsize = has_property($e, "subcontext_size"); + if (not defined($subsize)) { + $subsize = -1; + } + + push (@$order, { + TYPE => "SUBCONTEXT", + HEADER_SIZE => $hdr_size, + SUBCONTEXT_SIZE => $subsize, + IS_DEFERRED => $is_deferred, + COMPRESSION => has_property($e, "compression"), + OBFUSCATION => has_property($e, "obfuscation") + }); + } + + if (my $switch = has_property($e, "switch_is")) { + push (@$order, { + TYPE => "SWITCH", + SWITCH_IS => $switch, + IS_DEFERRED => $is_deferred + }); + } + + if (scalar(@size_is) > 0) { + nonfatal($e, "size_is() on non-array element"); + } + + if (scalar(@length_is) > 0) { + nonfatal($e, "length_is() on non-array element"); + } + + if (has_property($e, "string")) { + nonfatal($e, "string() attribute on non-array element"); + } + + push (@$order, { + TYPE => "DATA", + DATA_TYPE => $e->{TYPE}, + IS_DEFERRED => $is_deferred, + CONTAINS_DEFERRED => can_contain_deferred($e), + IS_SURROUNDING => 0 #FIXME + }); + + my $i = 0; + foreach (@$order) { $_->{LEVEL_INDEX} = $i; $i+=1; } + + return $order; +} + +##################################################################### +# see if a type contains any deferred data +sub can_contain_deferred +{ + my $e = shift; + + return 0 if (Parse::Pidl::Typelist::is_scalar($e->{TYPE})); + return 1 unless (hasType($e->{TYPE})); # assume the worst + + my $type = getType($e->{TYPE}); + + foreach my $x (@{$type->{DATA}->{ELEMENTS}}) { + return 1 if ($x->{POINTERS}); + return 1 if (can_contain_deferred ($x)); + } + + return 0; +} + +sub pointer_type($) +{ + my $e = shift; + + return undef unless $e->{POINTERS}; + + return "ref" if (has_property($e, "ref")); + return "ptr" if (has_property($e, "ptr")); + return "sptr" if (has_property($e, "sptr")); + return "unique" if (has_property($e, "unique")); + return "relative" if (has_property($e, "relative")); + return "ignore" if (has_property($e, "ignore")); + + return undef; +} + +##################################################################### +# work out the correct alignment for a structure or union +sub find_largest_alignment($) +{ + my $s = shift; + + my $align = 1; + for my $e (@{$s->{ELEMENTS}}) { + my $a = 1; + + if ($e->{POINTERS}) { + $a = 4; + } elsif (has_property($e, "subcontext")){ + $a = 1; + } else { + $a = align_type($e->{TYPE}); + } + + $align = $a if ($align < $a); + } + + return $align; +} + +##################################################################### +# align a type +sub align_type +{ + my $e = shift; + + unless (hasType($e)) { + # it must be an external type - all we can do is guess + # print "Warning: assuming alignment of unknown type '$e' is 4\n"; + return 4; + } + + my $dt = getType($e)->{DATA}; + + if ($dt->{TYPE} eq "ENUM") { + return align_type(Parse::Pidl::Typelist::enum_type_fn($dt)); + } elsif ($dt->{TYPE} eq "BITMAP") { + return align_type(Parse::Pidl::Typelist::bitmap_type_fn($dt)); + } elsif (($dt->{TYPE} eq "STRUCT") or ($dt->{TYPE} eq "UNION")) { + return find_largest_alignment($dt); + } elsif ($dt->{TYPE} eq "SCALAR") { + return Parse::Pidl::Typelist::getScalarAlignment($dt->{NAME}); + } + + die("Unknown data type type $dt->{TYPE}"); +} + +sub ParseElement($) +{ + my $e = shift; + + return { + NAME => $e->{NAME}, + TYPE => $e->{TYPE}, + PROPERTIES => $e->{PROPERTIES}, + LEVELS => GetElementLevelTable($e), + ALIGN => align_type($e->{TYPE}), + ORIGINAL => $e + }; +} + +sub ParseStruct($) +{ + my $struct = shift; + my @elements = (); + my $surrounding = undef; + + foreach my $x (@{$struct->{ELEMENTS}}) + { + push @elements, ParseElement($x); + } + + my $e = $elements[-1]; + if (defined($e) and defined($e->{LEVELS}[0]->{IS_SURROUNDING}) and + $e->{LEVELS}[0]->{IS_SURROUNDING}) { + $surrounding = $e; + } + + if (defined $e->{TYPE} && $e->{TYPE} eq "string" + && property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) { + $surrounding = $struct->{ELEMENTS}[-1]; + } + + return { + TYPE => "STRUCT", + SURROUNDING_ELEMENT => $surrounding, + ELEMENTS => \@elements, + PROPERTIES => $struct->{PROPERTIES}, + ORIGINAL => $struct + }; +} + +sub ParseUnion($) +{ + my $e = shift; + my @elements = (); + my $switch_type = has_property($e, "switch_type"); + unless (defined($switch_type)) { $switch_type = "uint32"; } + + if (has_property($e, "nodiscriminant")) { $switch_type = undef; } + + foreach my $x (@{$e->{ELEMENTS}}) + { + my $t; + if ($x->{TYPE} eq "EMPTY") { + $t = { TYPE => "EMPTY" }; + } else { + $t = ParseElement($x); + } + if (has_property($x, "default")) { + $t->{CASE} = "default"; + } elsif (defined($x->{PROPERTIES}->{case})) { + $t->{CASE} = "case $x->{PROPERTIES}->{case}"; + } else { + die("Union element $x->{NAME} has neither default nor case property"); + } + push @elements, $t; + } + + return { + TYPE => "UNION", + SWITCH_TYPE => $switch_type, + ELEMENTS => \@elements, + PROPERTIES => $e->{PROPERTIES}, + ORIGINAL => $e + }; +} + +sub ParseEnum($) +{ + my $e = shift; + + return { + TYPE => "ENUM", + BASE_TYPE => Parse::Pidl::Typelist::enum_type_fn($e), + ELEMENTS => $e->{ELEMENTS}, + PROPERTIES => $e->{PROPERTIES}, + ORIGINAL => $e + }; +} + +sub ParseBitmap($) +{ + my $e = shift; + + return { + TYPE => "BITMAP", + BASE_TYPE => Parse::Pidl::Typelist::bitmap_type_fn($e), + ELEMENTS => $e->{ELEMENTS}, + PROPERTIES => $e->{PROPERTIES}, + ORIGINAL => $e + }; +} + +sub ParseTypedef($$) +{ + my ($ndr,$d) = @_; + my $data; + + if ($d->{DATA}->{TYPE} eq "STRUCT" or $d->{DATA}->{TYPE} eq "UNION") { + CheckPointerTypes($d->{DATA}, $ndr->{PROPERTIES}->{pointer_default}); + } + + if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) { + $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES}; + } + + $data = { + STRUCT => \&ParseStruct, + UNION => \&ParseUnion, + ENUM => \&ParseEnum, + BITMAP => \&ParseBitmap + }->{$d->{DATA}->{TYPE}}->($d->{DATA}); + + $data->{ALIGN} = align_type($d->{NAME}); + + return { + NAME => $d->{NAME}, + TYPE => $d->{TYPE}, + PROPERTIES => $d->{PROPERTIES}, + DATA => $data, + ORIGINAL => $d + }; +} + +sub ParseConst($$) +{ + my ($ndr,$d) = @_; + + return $d; +} + +sub ParseFunction($$$) +{ + my ($ndr,$d,$opnum) = @_; + my @elements = (); + my $rettype = undef; + my $thisopnum = undef; + + CheckPointerTypes($d, $ndr->{PROPERTIES}->{pointer_default_top}); + + if (not defined($d->{PROPERTIES}{noopnum})) { + $thisopnum = ${$opnum}; + ${$opnum}++; + } + + foreach my $x (@{$d->{ELEMENTS}}) { + my $e = ParseElement($x); + push (@{$e->{DIRECTION}}, "in") if (has_property($x, "in")); + push (@{$e->{DIRECTION}}, "out") if (has_property($x, "out")); + push (@elements, $e); + } + + if ($d->{RETURN_TYPE} ne "void") { + $rettype = $d->{RETURN_TYPE}; + } + + return { + NAME => $d->{NAME}, + TYPE => "FUNCTION", + OPNUM => $thisopnum, + RETURN_TYPE => $rettype, + PROPERTIES => $d->{PROPERTIES}, + ELEMENTS => \@elements, + ORIGINAL => $d + }; +} + +sub CheckPointerTypes($$) +{ + my $s = shift; + my $default = shift; + + foreach my $e (@{$s->{ELEMENTS}}) { + if ($e->{POINTERS} and not defined(pointer_type($e))) { + $e->{PROPERTIES}->{$default} = 1; + } + } +} + +sub ParseInterface($) +{ + my $idl = shift; + my @typedefs = (); + my @consts = (); + my @functions = (); + my @endpoints; + my @declares = (); + my $opnum = 0; + my $version; + + if (not has_property($idl, "pointer_default")) { + # MIDL defaults to "ptr" in DCE compatible mode (/osf) + # and "unique" in Microsoft Extensions mode (default) + $idl->{PROPERTIES}->{pointer_default} = "unique"; + } + + if (not has_property($idl, "pointer_default_top")) { + $idl->{PROPERTIES}->{pointer_default_top} = "ref"; + } + + foreach my $d (@{$idl->{DATA}}) { + if ($d->{TYPE} eq "TYPEDEF") { + push (@typedefs, ParseTypedef($idl, $d)); + } + + if ($d->{TYPE} eq "DECLARE") { + push (@declares, $d); + } + + if ($d->{TYPE} eq "FUNCTION") { + push (@functions, ParseFunction($idl, $d, \$opnum)); + } + + if ($d->{TYPE} eq "CONST") { + push (@consts, ParseConst($idl, $d)); + } + } + + $version = "0.0"; + + if(defined $idl->{PROPERTIES}->{version}) { + $version = $idl->{PROPERTIES}->{version}; + } + + # If no endpoint is set, default to the interface name as a named pipe + if (!defined $idl->{PROPERTIES}->{endpoint}) { + push @endpoints, "\"ncacn_np:[\\\\pipe\\\\" . $idl->{NAME} . "]\""; + } else { + @endpoints = split / /, $idl->{PROPERTIES}->{endpoint}; + } + + return { + NAME => $idl->{NAME}, + UUID => has_property($idl, "uuid"), + VERSION => $version, + TYPE => "INTERFACE", + PROPERTIES => $idl->{PROPERTIES}, + FUNCTIONS => \@functions, + CONSTS => \@consts, + TYPEDEFS => \@typedefs, + DECLARES => \@declares, + ENDPOINTS => \@endpoints + }; +} + +# Convert a IDL tree to a NDR tree +# Gives a result tree describing all that's necessary for easily generating +# NDR parsers / generators +sub Parse($) +{ + my $idl = shift; + my @ndr = (); + + push(@ndr, ParseInterface($_)) foreach (@{$idl}); + + return \@ndr; +} + +sub GetNextLevel($$) +{ + my $e = shift; + my $fl = shift; + + my $seen = 0; + + foreach my $l (@{$e->{LEVELS}}) { + return $l if ($seen); + ($seen = 1) if ($l == $fl); + } + + return undef; +} + +sub GetPrevLevel($$) +{ + my ($e,$fl) = @_; + my $prev = undef; + + foreach my $l (@{$e->{LEVELS}}) { + (return $prev) if ($l == $fl); + $prev = $l; + } + + return undef; +} + +sub ContainsDeferred($$) +{ + my ($e,$l) = @_; + + return 1 if ($l->{CONTAINS_DEFERRED}); + + while ($l = GetNextLevel($e,$l)) + { + return 1 if ($l->{IS_DEFERRED}); + return 1 if ($l->{CONTAINS_DEFERRED}); + } + + return 0; +} + +sub el_name($) +{ + my $e = shift; + + if ($e->{PARENT} && $e->{PARENT}->{NAME}) { + return "$e->{PARENT}->{NAME}.$e->{NAME}"; + } + + if ($e->{PARENT} && $e->{PARENT}->{PARENT}->{NAME}) { + return "$e->{PARENT}->{PARENT}->{NAME}.$e->{NAME}"; + } + + if ($e->{PARENT}) { + return "$e->{PARENT}->{NAME}.$e->{NAME}"; + } + + return $e->{NAME}; +} + +################################### +# find a sibling var in a structure +sub find_sibling($$) +{ + my($e,$name) = @_; + my($fn) = $e->{PARENT}; + + if ($name =~ /\*(.*)/) { + $name = $1; + } + + for my $e2 (@{$fn->{ELEMENTS}}) { + return $e2 if ($e2->{NAME} eq $name); + } + + return undef; +} + +my %property_list = ( + # interface + "helpstring" => ["INTERFACE", "FUNCTION"], + "version" => ["INTERFACE"], + "uuid" => ["INTERFACE"], + "endpoint" => ["INTERFACE"], + "pointer_default" => ["INTERFACE"], + "pointer_default_top" => ["INTERFACE"], + "depends" => ["INTERFACE"], + "authservice" => ["INTERFACE"], + + # dcom + "object" => ["INTERFACE"], + "local" => ["INTERFACE", "FUNCTION"], + "iid_is" => ["ELEMENT"], + "call_as" => ["FUNCTION"], + "idempotent" => ["FUNCTION"], + + # function + "noopnum" => ["FUNCTION"], + "in" => ["ELEMENT"], + "out" => ["ELEMENT"], + + # pointer + "ref" => ["ELEMENT"], + "ptr" => ["ELEMENT"], + "sptr" => ["ELEMENT"], + "unique" => ["ELEMENT"], + "ignore" => ["ELEMENT"], + "relative" => ["ELEMENT"], + "relative_base" => ["TYPEDEF"], + + "gensize" => ["TYPEDEF"], + "value" => ["ELEMENT"], + "flag" => ["ELEMENT", "TYPEDEF"], + + # generic + "public" => ["FUNCTION", "TYPEDEF"], + "nopush" => ["FUNCTION", "TYPEDEF"], + "nopull" => ["FUNCTION", "TYPEDEF"], + "noprint" => ["FUNCTION", "TYPEDEF"], + "noejs" => ["FUNCTION", "TYPEDEF"], + + # union + "switch_is" => ["ELEMENT"], + "switch_type" => ["ELEMENT", "TYPEDEF"], + "nodiscriminant" => ["TYPEDEF"], + "case" => ["ELEMENT"], + "default" => ["ELEMENT"], + + # subcontext + "subcontext" => ["ELEMENT"], + "subcontext_size" => ["ELEMENT"], + "compression" => ["ELEMENT"], + "obfuscation" => ["ELEMENT"], + + # enum + "enum8bit" => ["TYPEDEF"], + "enum16bit" => ["TYPEDEF"], + "v1_enum" => ["TYPEDEF"], + + # bitmap + "bitmap8bit" => ["TYPEDEF"], + "bitmap16bit" => ["TYPEDEF"], + "bitmap32bit" => ["TYPEDEF"], + "bitmap64bit" => ["TYPEDEF"], + + # array + "range" => ["ELEMENT"], + "size_is" => ["ELEMENT"], + "string" => ["ELEMENT"], + "noheader" => ["ELEMENT"], + "charset" => ["ELEMENT"], + "length_is" => ["ELEMENT"], +); + +##################################################################### +# check for unknown properties +sub ValidProperties($$) +{ + my ($e,$t) = @_; + + return unless defined $e->{PROPERTIES}; + + foreach my $key (keys %{$e->{PROPERTIES}}) { + fatal($e, el_name($e) . ": unknown property '$key'\n") + unless defined($property_list{$key}); + + fatal($e, el_name($e) . ": property '$key' not allowed on '$t'\n") + unless grep($t, @{$property_list{$key}}); + } +} + +sub mapToScalar($) +{ + my $t = shift; + my $ti = getType($t); + + if (not defined ($ti)) { + return undef; + } elsif ($ti->{DATA}->{TYPE} eq "ENUM") { + return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA}); + } elsif ($ti->{DATA}->{TYPE} eq "BITMAP") { + return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA}); + } elsif ($ti->{DATA}->{TYPE} eq "SCALAR") { + return $t; + } + + return undef; +} + +##################################################################### +# parse a struct +sub ValidElement($) +{ + my $e = shift; + + ValidProperties($e,"ELEMENT"); + + if (has_property($e, "ptr")) { + fatal($e, el_name($e) . " : pidl does not support full NDR pointers yet\n"); + } + + # Check whether switches are used correctly. + if (my $switch = has_property($e, "switch_is")) { + my $e2 = find_sibling($e, $switch); + my $type = getType($e->{TYPE}); + + if (defined($type) and $type->{DATA}->{TYPE} ne "UNION") { + fatal($e, el_name($e) . ": switch_is() used on non-union type $e->{TYPE} which is a $type->{DATA}->{TYPE}"); + } + + if (!has_property($type, "nodiscriminant") and defined($e2)) { + my $discriminator_type = has_property($type, "switch_type"); + $discriminator_type = "uint32" unless defined ($discriminator_type); + + my $t1 = mapToScalar($discriminator_type); + + if (not defined($t1)) { + fatal($e, el_name($e) . ": unable to map discriminator type '$discriminator_type' to scalar"); + } + + my $t2 = mapToScalar($e2->{TYPE}); + if (not defined($t2)) { + fatal($e, el_name($e) . ": unable to map variable used for switch_is() to scalar"); + } + + if ($t1 ne $t2) { + nonfatal($e, el_name($e) . ": switch_is() is of type $e2->{TYPE} ($t2), while discriminator type for union $type->{NAME} is $discriminator_type ($t1)"); + } + } + } + + if (defined (has_property($e, "subcontext_size")) and not defined(has_property($e, "subcontext"))) { + fatal($e, el_name($e) . " : subcontext_size() on non-subcontext element"); + } + + if (defined (has_property($e, "compression")) and not defined(has_property($e, "subcontext"))) { + fatal($e, el_name($e) . " : compression() on non-subcontext element"); + } + + if (defined (has_property($e, "obfuscation")) and not defined(has_property($e, "subcontext"))) { + fatal($e, el_name($e) . " : obfuscation() on non-subcontext element"); + } + + if (!$e->{POINTERS} && ( + has_property($e, "ptr") or + has_property($e, "sptr") or + has_property($e, "unique") or + has_property($e, "relative") or + has_property($e, "ref"))) { + fatal($e, el_name($e) . " : pointer properties on non-pointer element\n"); + } +} + +##################################################################### +# parse a struct +sub ValidStruct($) +{ + my($struct) = shift; + + ValidProperties($struct,"STRUCT"); + + foreach my $e (@{$struct->{ELEMENTS}}) { + $e->{PARENT} = $struct; + ValidElement($e); + } +} + +##################################################################### +# parse a union +sub ValidUnion($) +{ + my($union) = shift; + + ValidProperties($union,"UNION"); + + if (has_property($union->{PARENT}, "nodiscriminant") and has_property($union->{PARENT}, "switch_type")) { + fatal($union->{PARENT}, $union->{PARENT}->{NAME} . ": switch_type() on union without discriminant"); + } + + foreach my $e (@{$union->{ELEMENTS}}) { + $e->{PARENT} = $union; + + if (defined($e->{PROPERTIES}->{default}) and + defined($e->{PROPERTIES}->{case})) { + fatal $e, "Union member $e->{NAME} can not have both default and case properties!\n"; + } + + unless (defined ($e->{PROPERTIES}->{default}) or + defined ($e->{PROPERTIES}->{case})) { + fatal $e, "Union member $e->{NAME} must have default or case property\n"; + } + + if (has_property($e, "ref")) { + fatal($e, el_name($e) . " : embedded ref pointers are not supported yet\n"); + } + + + ValidElement($e); + } +} + +##################################################################### +# parse a typedef +sub ValidTypedef($) +{ + my($typedef) = shift; + my $data = $typedef->{DATA}; + + ValidProperties($typedef,"TYPEDEF"); + + $data->{PARENT} = $typedef; + + if (ref($data) eq "HASH") { + if ($data->{TYPE} eq "STRUCT") { + ValidStruct($data); + } + + if ($data->{TYPE} eq "UNION") { + ValidUnion($data); + } + } +} + +##################################################################### +# parse a function +sub ValidFunction($) +{ + my($fn) = shift; + + ValidProperties($fn,"FUNCTION"); + + foreach my $e (@{$fn->{ELEMENTS}}) { + $e->{PARENT} = $fn; + if (has_property($e, "ref") && !$e->{POINTERS}) { + fatal $e, "[ref] variables must be pointers ($fn->{NAME}/$e->{NAME})\n"; + } + ValidElement($e); + } +} + +##################################################################### +# parse the interface definitions +sub ValidInterface($) +{ + my($interface) = shift; + my($data) = $interface->{DATA}; + + ValidProperties($interface,"INTERFACE"); + + if (has_property($interface, "pointer_default") && + $interface->{PROPERTIES}->{pointer_default} eq "ptr") { + fatal $interface, "Full pointers are not supported yet\n"; + } + + if (has_property($interface, "object")) { + if (has_property($interface, "version") && + $interface->{PROPERTIES}->{version} != 0) { + fatal $interface, "Object interfaces must have version 0.0 ($interface->{NAME})\n"; + } + + if (!defined($interface->{BASE}) && + not ($interface->{NAME} eq "IUnknown")) { + fatal $interface, "Object interfaces must all derive from IUnknown ($interface->{NAME})\n"; + } + } + + foreach my $d (@{$data}) { + ($d->{TYPE} eq "TYPEDEF") && + ValidTypedef($d); + ($d->{TYPE} eq "FUNCTION") && + ValidFunction($d); + } + +} + +##################################################################### +# Validate an IDL structure +sub Validate($) +{ + my($idl) = shift; + + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && + ValidInterface($x); + } +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/ODL.pm b/source4/pidl/lib/Parse/Pidl/ODL.pm new file mode 100644 index 0000000000..03d66bfc45 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/ODL.pm @@ -0,0 +1,92 @@ +########################################## +# Converts ODL stuctures to IDL structures +# (C) 2004-2005 Jelmer Vernooij + +package Parse::Pidl::ODL; + +use Parse::Pidl::Util qw(has_property); +use Parse::Pidl::Typelist qw(hasType getType); +use strict; + +##################################################################### +# find an interface in an array of interfaces +sub get_interface($$) +{ + my($if) = shift; + my($n) = shift; + + foreach(@{$if}) { + if($_->{NAME} eq $n) { return $_; } + } + + return 0; +} + +sub FunctionAddObjArgs($) +{ + my $e = shift; + + unshift(@{$e->{ELEMENTS}}, { + 'NAME' => 'ORPCthis', + 'POINTERS' => 0, + 'PROPERTIES' => { 'in' => '1' }, + 'TYPE' => 'ORPCTHIS' + }); + unshift(@{$e->{ELEMENTS}}, { + 'NAME' => 'ORPCthat', + 'POINTERS' => 0, + 'PROPERTIES' => { 'out' => '1' }, + 'TYPE' => 'ORPCTHAT' + }); +} + +sub ReplaceInterfacePointers($) +{ + my $e = shift; + + foreach my $x (@{$e->{ELEMENTS}}) { + next unless (hasType($x->{TYPE})); + next unless getType($x->{TYPE})->{DATA}->{TYPE} eq "INTERFACE"; + + $x->{TYPE} = "MInterfacePointer"; + } +} + +# Add ORPC specific bits to an interface. +sub ODL2IDL($) +{ + my $odl = shift; + + foreach my $x (@{$odl}) { + # Add [in] ORPCTHIS *this, [out] ORPCTHAT *that + # and replace interfacepointers with MInterfacePointer + # for 'object' interfaces + if (has_property($x, "object")) { + foreach my $e (@{$x->{DATA}}) { + ($e->{TYPE} eq "FUNCTION") && FunctionAddObjArgs($e); + ReplaceInterfacePointers($e); + } + # Object interfaces use ORPC + my @depends = (); + if(has_property($x, "depends")) { + @depends = split /,/, $x->{PROPERTIES}->{depends}; + } + push @depends, "orpc"; + $x->{PROPERTIES}->{depends} = join(',',@depends); + } + + if ($x->{BASE}) { + my $base = get_interface($odl, $x->{BASE}); + + foreach my $fn (reverse @{$base->{DATA}}) { + next unless ($fn->{TYPE} eq "FUNCTION"); + unshift (@{$x->{DATA}}, $fn); + push (@{$x->{INHERITED_FUNCTIONS}}, $fn->{NAME}); + } + } + } + + return $odl; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm new file mode 100644 index 0000000000..7b6c4db212 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm @@ -0,0 +1,139 @@ +# COM Header generation +# (C) 2005 Jelmer Vernooij + +package Parse::Pidl::Samba::COM::Header; + +use Parse::Pidl::Typelist; +use Parse::Pidl::Util qw(has_property); + +use strict; + +sub GetArgumentProtoList($) +{ + my $f = shift; + my $res = ""; + + foreach my $a (@{$f->{ELEMENTS}}) { + + $res .= ", " . Parse::Pidl::Typelist::mapType($a->{TYPE}) . " "; + + my $l = $a->{POINTERS}; + $l-- if (Parse::Pidl::Typelist::scalar_is_reference($a->{TYPE})); + foreach my $i (1..$l) { + $res .= "*"; + } + + if (defined $a->{ARRAY_LEN}[0] && + !Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0]) && + !$a->{POINTERS}) { + $res .= "*"; + } + $res .= $a->{NAME}; + if (defined $a->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0])) { + $res .= "[$a->{ARRAY_LEN}[0]]"; + } + } + + return $res; +} + +sub GetArgumentList($) +{ + my $f = shift; + my $res = ""; + + foreach my $a (@{$f->{ELEMENTS}}) { + $res .= ", $a->{NAME}"; + } + + return $res; +} + +##################################################################### +# generate vtable structure for COM interface +sub HeaderVTable($) +{ + my $interface = shift; + my $res; + $res .= "#define " . uc($interface->{NAME}) . "_METHODS \\\n"; + if (defined($interface->{BASE})) { + $res .= "\t" . uc($interface->{BASE} . "_METHODS") . "\\\n"; + } + + my $data = $interface->{DATA}; + foreach my $d (@{$data}) { + $res .= "\t" . Parse::Pidl::Typelist::mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION"); + } + $res .= "\n"; + $res .= "struct $interface->{NAME}_vtable {\n"; + $res .= "\tstruct GUID iid;\n"; + $res .= "\t" . uc($interface->{NAME}) . "_METHODS\n"; + $res .= "};\n\n"; + + return $res; +} + +sub ParseInterface($) +{ + my $if = shift; + my $res; + + $res .="\n\n/* $if->{NAME} */\n"; + + $res .="#define COM_" . uc($if->{NAME}) . "_UUID $if->{PROPERTIES}->{uuid}\n\n"; + + $res .="struct $if->{NAME}_vtable;\n\n"; + + $res .="struct $if->{NAME} { + struct com_context *ctx; + struct $if->{NAME}_vtable *vtable; + void *object_data; +};\n\n"; + + $res.=HeaderVTable($if); + + foreach my $d (@{$if->{DATA}}) { + next if ($d->{TYPE} ne "FUNCTION"); + + $res .= "#define $if->{NAME}_$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . ") "; + + $res .= "((interface)->vtable->$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . "))"; + + $res .="\n"; + } + + return $res; +} + +sub ParseCoClass($) +{ + my $c = shift; + my $res = ""; + $res .= "#define CLSID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{uuid}\n"; + if (has_property($c, "progid")) { + $res .= "#define PROGID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{progid}\n"; + } + $res .= "\n"; + return $res; +} + +sub Parse($) +{ + my $idl = shift; + my $res = ""; + + foreach my $x (@{$idl}) + { + if ($x->{TYPE} eq "INTERFACE" && has_property($x, "object")) { + $res.=ParseInterface($x); + } + + if ($x->{TYPE} eq "COCLASS") { + $res.=ParseCoClass($x); + } + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm new file mode 100644 index 0000000000..c94ef59ae9 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm @@ -0,0 +1,212 @@ +################################################### +# DCOM parser for Samba +# Basically the glue between COM and DCE/RPC with NDR +# Copyright jelmer@samba.org 2003-2005 +# released under the GNU GPL + +package Parse::Pidl::Samba::COM::Proxy; + +use Parse::Pidl::Samba::COM::Header; +use Parse::Pidl::Util qw(has_property); + +use strict; + +my($res); + +sub ParseVTable($$) +{ + my $interface = shift; + my $name = shift; + + # Generate the vtable + $res .="\tstruct $interface->{NAME}_vtable $name = {"; + + if (defined($interface->{BASE})) { + $res .= "\n\t\t{},"; + } + + my $data = $interface->{DATA}; + + foreach my $d (@{$data}) { + if ($d->{TYPE} eq "FUNCTION") { + $res .= "\n\t\tdcom_proxy_$interface->{NAME}_$d->{NAME}"; + $res .= ","; + } + } + + $res .= "\n\t};\n\n"; +} + +sub ParseRegFunc($) +{ + my $interface = shift; + + $res .= "static NTSTATUS dcom_proxy_$interface->{NAME}_init(void) +{ + struct GUID base_iid; + struct $interface->{NAME}_vtable *proxy_vtable = talloc(talloc_autofree_context(), struct $interface->{NAME}_vtable); +"; + + if (defined($interface->{BASE})) { + $res.= " + const void *base_vtable; + + GUID_from_string(DCERPC_" . (uc $interface->{BASE}) . "_UUID, &base_iid); + + base_vtable = dcom_proxy_vtable_by_iid(&base_iid); + if (base_vtable == NULL) { + DEBUG(0, (\"No proxy registered for base interface '$interface->{BASE}'\\n\")); + return NT_STATUS_FOOBAR; + } + + memcpy(&proxy_vtable, base_vtable, sizeof(struct $interface->{BASE}_vtable)); + +"; + } + foreach my $x (@{$interface->{DATA}}) { + next unless ($x->{TYPE} eq "FUNCTION"); + + $res .= "\tproxy_vtable.$x->{NAME} = dcom_proxy_$interface->{NAME}_$x->{NAME};\n"; + } + + $res.= " + GUID_from_string(DCERPC_" . (uc $interface->{NAME}) . "_UUID, &proxy_vtable.iid); + + return dcom_register_proxy(&proxy_vtable); +}\n\n"; +} + +##################################################################### +# parse a function +sub ParseFunction($$) +{ + my $interface = shift; + my $fn = shift; + my $name = $fn->{NAME}; + my $uname = uc $name; + + $res.=" +static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . Parse::Pidl::Samba::COM::Header::GetArgumentProtoList($fn) . ") +{ + struct dcerpc_pipe *p; + NTSTATUS status = dcom_get_pipe(d, &p); + struct $name r; + struct rpc_request *req; + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + ZERO_STRUCT(r.in.ORPCthis); + r.in.ORPCthis.version.MajorVersion = COM_MAJOR_VERSION; + r.in.ORPCthis.version.MinorVersion = COM_MINOR_VERSION; +"; + + # Put arguments into r + foreach my $a (@{$fn->{ELEMENTS}}) { + next unless (has_property($a, "in")); + if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) { + $res .="\tNDR_CHECK(dcom_OBJREF_from_IUnknown(&r.in.$a->{NAME}.obj, $a->{NAME}));\n"; + } else { + $res .= "\tr.in.$a->{NAME} = $a->{NAME};\n"; + } + } + + $res .=" + if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) { + NDR_PRINT_IN_DEBUG($name, &r); + } + + status = dcerpc_ndr_request(p, &d->ipid, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, &r); + + if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { + NDR_PRINT_OUT_DEBUG($name, r); + } + +"; + + # Put r info back into arguments + foreach my $a (@{$fn->{ELEMENTS}}) { + next unless (has_property($a, "out")); + + if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) { + $res .="\tNDR_CHECK(dcom_IUnknown_from_OBJREF(d->ctx, &$a->{NAME}, r.out.$a->{NAME}.obj));\n"; + } else { + $res .= "\t*$a->{NAME} = r.out.$a->{NAME};\n"; + } + + } + + if ($fn->{RETURN_TYPE} eq "NTSTATUS") { + $res .= "\tif (NT_STATUS_IS_OK(status)) status = r.out.result;\n"; + } + + $res .= + " + return r.out.result; +}\n\n"; +} + +##################################################################### +# parse the interface definitions +sub ParseInterface($) +{ + my($interface) = shift; + my($data) = $interface->{DATA}; + $res = "/* DCOM proxy for $interface->{NAME} generated by pidl */\n\n"; + foreach my $d (@{$data}) { + ($d->{TYPE} eq "FUNCTION") && + ParseFunction($interface, $d); + } + + ParseRegFunc($interface); +} + +sub RegistrationFunction($$) +{ + my $idl = shift; + my $basename = shift; + + my $res = "\n\nNTSTATUS dcom_$basename\_init(void)\n"; + $res .= "{\n"; + $res .="\tNTSTATUS status = NT_STATUS_OK;\n"; + foreach my $interface (@{$idl}) { + next if $interface->{TYPE} ne "INTERFACE"; + next if not has_property($interface, "object"); + + my $data = $interface->{DATA}; + my $count = 0; + foreach my $d (@{$data}) { + if ($d->{TYPE} eq "FUNCTION") { $count++; } + } + + next if ($count == 0); + + $res .= "\tstatus = dcom_$interface->{NAME}_init();\n"; + $res .= "\tif (NT_STATUS_IS_ERR(status)) {\n"; + $res .= "\t\treturn status;\n"; + $res .= "\t}\n\n"; + } + $res .= "\treturn status;\n"; + $res .= "}\n\n"; + + return $res; +} + +sub Parse($) +{ + my $pidl = shift; + my $res = ""; + + foreach my $x (@{$pidl}) { + next if ($x->{TYPE} ne "INTERFACE"); + next if has_property($x, "local"); + next unless has_property($x, "object"); + + $res .= ParseInterface($x); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm new file mode 100644 index 0000000000..785c34fc77 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm @@ -0,0 +1,324 @@ +################################################### +# DCOM stub boilerplate generator +# Copyright jelmer@samba.org 2004-2005 +# Copyright tridge@samba.org 2003 +# Copyright metze@samba.org 2004 +# released under the GNU GPL + +package Parse::Pidl::Samba::COM::Stub; + +use Parse::Pidl::Util qw(has_property); +use strict; + +my($res); + +sub pidl($) +{ + $res .= shift; +} + +##################################################### +# generate the switch statement for function dispatch +sub gen_dispatch_switch($) +{ + my $data = shift; + + my $count = 0; + foreach my $d (@{$data}) { + next if ($d->{TYPE} ne "FUNCTION"); + + pidl "\tcase $count: {\n"; + if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") { + pidl "\t\tNTSTATUS result;\n"; + } + pidl "\t\tstruct $d->{NAME} *r2 = r;\n"; + pidl "\t\tif (DEBUGLEVEL > 10) {\n"; + pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_IN, r2);\n"; + pidl "\t\t}\n"; + if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") { + pidl "\t\tresult = vtable->$d->{NAME}(iface, mem_ctx, r2);\n"; + } else { + pidl "\t\tvtable->$d->{NAME}(iface, mem_ctx, r2);\n"; + } + pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; + pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} will reply async\\n\"));\n"; + pidl "\t\t}\n"; + pidl "\t\tbreak;\n\t}\n"; + $count++; + } +} + +##################################################### +# generate the switch statement for function reply +sub gen_reply_switch($) +{ + my $data = shift; + + my $count = 0; + foreach my $d (@{$data}) { + next if ($d->{TYPE} ne "FUNCTION"); + + pidl "\tcase $count: {\n"; + pidl "\t\tstruct $d->{NAME} *r2 = r;\n"; + pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; + pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} replied async\\n\"));\n"; + pidl "\t\t}\n"; + pidl "\t\tif (DEBUGLEVEL > 10 && dce_call->fault_code == 0) {\n"; + pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n"; + pidl "\t\t}\n"; + pidl "\t\tif (dce_call->fault_code != 0) {\n"; + pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $d->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n"; + pidl "\t\t}\n"; + pidl "\t\tbreak;\n\t}\n"; + $count++; + } +} + +##################################################################### +# produce boilerplate code for a interface +sub Boilerplate_Iface($) +{ + my($interface) = shift; + my($data) = $interface->{DATA}; + my $name = $interface->{NAME}; + my $uname = uc $name; + my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}); + my $if_version = $interface->{PROPERTIES}->{version}; + + pidl " +static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface) +{ +#ifdef DCESRV_INTERFACE_$uname\_BIND + return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface); +#else + return NT_STATUS_OK; +#endif +} + +static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface) +{ +#ifdef DCESRV_INTERFACE_$uname\_UNBIND + DCESRV_INTERFACE_$uname\_UNBIND(context, iface); +#else + return; +#endif +} + +static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r) +{ + NTSTATUS status; + uint16_t opnum = dce_call->pkt.u.request.opnum; + + dce_call->fault_code = 0; + + if (opnum >= dcerpc_table_$name.num_calls) { + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + return NT_STATUS_NET_WRITE_FAULT; + } + + *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size); + NT_STATUS_HAVE_NO_MEMORY(*r); + + /* unravel the NDR for the packet */ + status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); + if (!NT_STATUS_IS_OK(status)) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + dce_call->fault_code = DCERPC_FAULT_NDR; + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) +{ + uint16_t opnum = dce_call->pkt.u.request.opnum; + struct GUID ipid = dce_call->pkt.u.request.object.object; + struct dcom_interface_p *iface = dcom_get_local_iface_p(&ipid); + const struct dcom_$name\_vtable *vtable = iface->vtable; + + switch (opnum) { +"; + gen_dispatch_switch($data); + +pidl " + default: + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + break; + } + + if (dce_call->fault_code != 0) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) +{ + uint16_t opnum = dce_call->pkt.u.request.opnum; + + switch (opnum) { +"; + gen_reply_switch($data); + +pidl " + default: + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + break; + } + + if (dce_call->fault_code != 0) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r) +{ + NTSTATUS status; + uint16_t opnum = dce_call->pkt.u.request.opnum; + + status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); + if (!NT_STATUS_IS_OK(status)) { + dce_call->fault_code = DCERPC_FAULT_NDR; + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static const struct dcesrv_interface $name\_interface = { + .name = \"$name\", + .uuid = $uuid, + .if_version = $if_version, + .bind = $name\__op_bind, + .unbind = $name\__op_unbind, + .ndr_pull = $name\__op_ndr_pull, + .dispatch = $name\__op_dispatch, + .reply = $name\__op_reply, + .ndr_push = $name\__op_ndr_push +}; + +"; +} + +##################################################################### +# produce boilerplate code for an endpoint server +sub Boilerplate_Ep_Server($) +{ + my($interface) = shift; + my $name = $interface->{NAME}; + my $uname = uc $name; + + pidl " +static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server) +{ + int i; + + for (i=0;icount;i++) { + NTSTATUS ret; + const char *name = dcerpc_table_$name.endpoints->names[i]; + + ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL); + if (!NT_STATUS_IS_OK(ret)) { + DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name)); + return ret; + } + } + + return NT_STATUS_OK; +} + +static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version) +{ + if (dcerpc_table_$name.if_version == if_version && + strcmp(dcerpc_table_$name.uuid, uuid)==0) { + memcpy(iface,&dcerpc_table_$name, sizeof(*iface)); + return True; + } + + return False; +} + +static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) +{ + if (strcmp(dcerpc_table_$name.name, name)==0) { + memcpy(iface,&dcerpc_table_$name, sizeof(*iface)); + return True; + } + + return False; +} + +NTSTATUS dcerpc_server_$name\_init(void) +{ + NTSTATUS ret; + struct dcesrv_endpoint_server ep_server; + + /* fill in our name */ + ep_server.name = \"$name\"; + + /* fill in all the operations */ + ep_server.init_server = $name\__op_init_server; + + ep_server.interface_by_uuid = $name\__op_interface_by_uuid; + ep_server.interface_by_name = $name\__op_interface_by_name; + + /* register ourselves with the DCERPC subsystem. */ + ret = dcerpc_register_ep_server(&ep_server); + + if (!NT_STATUS_IS_OK(ret)) { + DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\")); + return ret; + } + + return ret; +} + +"; +} + +##################################################################### +# dcom interface stub from a parsed IDL structure +sub ParseInterface($) +{ + my($interface) = shift; + + return "" if has_property($interface, "local"); + + my($data) = $interface->{DATA}; + my $count = 0; + + $res = ""; + + if (!defined $interface->{PROPERTIES}->{uuid}) { + return $res; + } + + if (!defined $interface->{PROPERTIES}->{version}) { + $interface->{PROPERTIES}->{version} = "0.0"; + } + + foreach my $d (@{$data}) { + if ($d->{TYPE} eq "FUNCTION") { $count++; } + } + + if ($count == 0) { + return $res; + } + + $res = "/* dcom interface stub generated by pidl */\n\n"; + Boilerplate_Iface($interface); + Boilerplate_Ep_Server($interface); + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm new file mode 100644 index 0000000000..743139c8cd --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm @@ -0,0 +1,835 @@ +################################################### +# EJS function wrapper generator +# Copyright jelmer@samba.org 2005 +# Copyright Andrew Tridgell 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba::EJS; + +use strict; +use Parse::Pidl::Typelist; +use Parse::Pidl::Util qw(has_property); + +my($res); +my %constants; + +my $tabs = ""; +sub pidl($) +{ + my $d = shift; + if ($d) { + $res .= $tabs; + $res .= $d; + } + $res .= "\n"; +} + +sub indent() +{ + $tabs .= "\t"; +} + +sub deindent() +{ + $tabs = substr($tabs, 0, -1); +} + +# this should probably be in ndr.pm +sub GenerateStructEnv($) +{ + my $x = shift; + my %env; + + foreach my $e (@{$x->{ELEMENTS}}) { + if ($e->{NAME}) { + $env{$e->{NAME}} = "r->$e->{NAME}"; + } + } + + $env{"this"} = "r"; + + return \%env; +} + +sub GenerateFunctionInEnv($) +{ + my $fn = shift; + my %env; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->in.$e->{NAME}"; + } + } + + return \%env; +} + +sub GenerateFunctionOutEnv($) +{ + my $fn = shift; + my %env; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/out/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->out.$e->{NAME}"; + } elsif (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->in.$e->{NAME}"; + } + } + + return \%env; +} + +sub get_pointer_to($) +{ + my $var_name = shift; + + if ($var_name =~ /^\*(.*)$/) { + return $1; + } elsif ($var_name =~ /^\&(.*)$/) { + return "&($var_name)"; + } else { + return "&$var_name"; + } +} + +sub get_value_of($) +{ + my $var_name = shift; + + if ($var_name =~ /^\&(.*)$/) { + return $1; + } else { + return "*$var_name"; + } +} + +##################################################################### +# work out is a parse function should be declared static or not +sub fn_prefix($) +{ + my $fn = shift; + + return "" if (has_property($fn, "public")); + return "static "; +} + +########################### +# pull a scalar element +sub EjsPullScalar($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + + return if (has_property($e, "value")); + + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + $var = get_pointer_to($var); + # have to handle strings specially :( + if ($e->{TYPE} eq "string" && $pl && $pl->{TYPE} eq "POINTER") { + $var = get_pointer_to($var); + } + pidl "NDR_CHECK(ejs_pull_$e->{TYPE}(ejs, v, $name, $var));"; +} + +########################### +# pull a pointer element +sub EjsPullPointer($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + pidl "if (ejs_pull_null(ejs, v, $name)) {"; + indent; + pidl "$var = NULL;"; + deindent; + pidl "} else {"; + indent; + pidl "EJS_ALLOC(ejs, $var);"; + $var = get_value_of($var); + EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); + deindent; + pidl "}"; +} + +########################### +# pull a string element +sub EjsPullString($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + $var = get_pointer_to($var); + pidl "NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));"; +} + + +########################### +# pull an array element +sub EjsPullArray($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); + my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env); + my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env); + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + if ($pl && $pl->{TYPE} eq "POINTER") { + $var = get_pointer_to($var); + } + # uint8 arrays are treated as data blobs + if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { + if (!$l->{IS_FIXED}) { + pidl "EJS_ALLOC_N(ejs, $var, $size);"; + } + pidl "ejs_pull_array_uint8(ejs, v, $name, $var, $length);"; + return; + } + my $avar = $var . "[i]"; + pidl "{"; + indent; + pidl "uint32_t i;"; + if (!$l->{IS_FIXED}) { + pidl "EJS_ALLOC_N(ejs, $var, $size);"; + } + pidl "for (i=0;i<$length;i++) {"; + indent; + pidl "char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"; + EjsPullElement($e, $nl, $avar, "id", $env); + pidl "talloc_free(id);"; + deindent; + pidl "}"; + pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);"; + deindent; + pidl "}"; +} + +########################### +# pull a switch element +sub EjsPullSwitch($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env); + pidl "ejs_set_switch(ejs, $switch_var);"; + EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); +} + +########################### +# pull a structure element +sub EjsPullElement($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + if (has_property($e, "charset")) { + EjsPullString($e, $l, $var, $name, $env); + } elsif ($l->{TYPE} eq "ARRAY") { + EjsPullArray($e, $l, $var, $name, $env); + } elsif ($l->{TYPE} eq "DATA") { + EjsPullScalar($e, $l, $var, $name, $env); + } elsif (($l->{TYPE} eq "POINTER")) { + EjsPullPointer($e, $l, $var, $name, $env); + } elsif (($l->{TYPE} eq "SWITCH")) { + EjsPullSwitch($e, $l, $var, $name, $env); + } else { + pidl "return ejs_panic(ejs, \"unhandled pull type $l->{TYPE}\");"; + } +} + +############################################# +# pull a structure/union element at top level +sub EjsPullElementTop($$) +{ + my $e = shift; + my $env = shift; + my $l = $e->{LEVELS}[0]; + my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env); + my $name = "\"$e->{NAME}\""; + EjsPullElement($e, $l, $var, $name, $env); +} + +########################### +# pull a struct +sub EjsStructPull($$) +{ + my $name = shift; + my $d = shift; + my $env = GenerateStructEnv($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)\n{"; + indent; + pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; + foreach my $e (@{$d->{ELEMENTS}}) { + EjsPullElementTop($e, $env); + } + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + +########################### +# pull a union +sub EjsUnionPull($$) +{ + my $name = shift; + my $d = shift; + my $have_default = 0; + my $env = GenerateStructEnv($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)\n{"; + indent; + pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; + pidl "switch (ejs->switch_var) {"; + indent; + foreach my $e (@{$d->{ELEMENTS}}) { + if ($e->{CASE} eq "default") { + $have_default = 1; + } + pidl "$e->{CASE}:"; + indent; + if ($e->{TYPE} ne "EMPTY") { + EjsPullElementTop($e, $env); + } + pidl "break;"; + deindent; + } + if (! $have_default) { + pidl "default:"; + indent; + pidl "return ejs_panic(ejs, \"Bad switch value\");"; + deindent; + } + deindent; + pidl "}"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; +} + +############################################## +# put the enum elements in the constants array +sub EjsEnumConstant($) +{ + my $d = shift; + my $v = 0; + foreach my $e (@{$d->{ELEMENTS}}) { + my $el = $e; + chomp $el; + if ($el =~ /^(.*)=\s*(.*)\s*$/) { + $el = $1; + $v = $2; + } + $constants{$el} = $v; + $v++; + } +} + +########################### +# pull a enum +sub EjsEnumPull($$) +{ + my $name = shift; + my $d = shift; + EjsEnumConstant($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)\n{"; + indent; + pidl "unsigned e;"; + pidl "NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));"; + pidl "*r = e;"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + +########################### +# pull a bitmap +sub EjsBitmapPull($$) +{ + my $name = shift; + my $d = shift; + my $type_fn = $d->{BASE_TYPE}; + my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE}); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)\n{"; + indent; + pidl "return ejs_pull_$type_fn(ejs, v, name, r);"; + deindent; + pidl "}"; +} + + +########################### +# generate a structure pull +sub EjsTypedefPull($) +{ + my $d = shift; + return if (has_property($d, "noejs")); + if ($d->{DATA}->{TYPE} eq 'STRUCT') { + EjsStructPull($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'UNION') { + EjsUnionPull($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'ENUM') { + EjsEnumPull($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') { + EjsBitmapPull($d->{NAME}, $d->{DATA}); + } else { + warn "Unhandled pull typedef $d->{NAME} of type $d->{DATA}->{TYPE}"; + } +} + +##################### +# generate a function +sub EjsPullFunction($) +{ + my $d = shift; + my $env = GenerateFunctionInEnv($d); + my $name = $d->{NAME}; + + pidl "\nstatic NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, struct $name *r)"; + pidl "{"; + indent; + pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));"; + + # we pull non-array elements before array elements as arrays + # may have length_is() or size_is() properties that depend + # on the non-array elements + foreach my $e (@{$d->{ELEMENTS}}) { + next unless (grep(/in/, @{$e->{DIRECTION}})); + next if (has_property($e, "length_is") || + has_property($e, "size_is")); + EjsPullElementTop($e, $env); + } + + foreach my $e (@{$d->{ELEMENTS}}) { + next unless (grep(/in/, @{$e->{DIRECTION}})); + next unless (has_property($e, "length_is") || + has_property($e, "size_is")); + EjsPullElementTop($e, $env); + } + + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + + +########################### +# push a scalar element +sub EjsPushScalar($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + # have to handle strings specially :( + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + if ($e->{TYPE} ne "string" || ($pl && $pl->{TYPE} eq "POINTER")) { + $var = get_pointer_to($var); + } + pidl "NDR_CHECK(ejs_push_$e->{TYPE}(ejs, v, $name, $var));"; +} + +########################### +# push a string element +sub EjsPushString($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + pidl "NDR_CHECK(ejs_push_string(ejs, v, $name, $var));"; +} + +########################### +# push a pointer element +sub EjsPushPointer($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + pidl "if (NULL == $var) {"; + indent; + pidl "NDR_CHECK(ejs_push_null(ejs, v, $name));"; + deindent; + pidl "} else {"; + indent; + $var = get_value_of($var); + EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); + deindent; + pidl "}"; +} + +########################### +# push a switch element +sub EjsPushSwitch($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env); + pidl "ejs_set_switch(ejs, $switch_var);"; + EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); +} + + +########################### +# push an array element +sub EjsPushArray($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); + my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env); + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + if ($pl && $pl->{TYPE} eq "POINTER") { + $var = get_pointer_to($var); + } + # uint8 arrays are treated as data blobs + if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { + pidl "ejs_push_array_uint8(ejs, v, $name, $var, $length);"; + return; + } + my $avar = $var . "[i]"; + pidl "{"; + indent; + pidl "uint32_t i;"; + pidl "for (i=0;i<$length;i++) {"; + indent; + pidl "const char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"; + EjsPushElement($e, $nl, $avar, "id", $env); + deindent; + pidl "}"; + pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);"; + deindent; + pidl "}"; +} + +################################ +# push a structure/union element +sub EjsPushElement($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + if (has_property($e, "charset")) { + EjsPushString($e, $l, $var, $name, $env); + } elsif ($l->{TYPE} eq "ARRAY") { + EjsPushArray($e, $l, $var, $name, $env); + } elsif ($l->{TYPE} eq "DATA") { + EjsPushScalar($e, $l, $var, $name, $env); + } elsif (($l->{TYPE} eq "POINTER")) { + EjsPushPointer($e, $l, $var, $name, $env); + } elsif (($l->{TYPE} eq "SWITCH")) { + EjsPushSwitch($e, $l, $var, $name, $env); + } else { + pidl "return ejs_panic(ejs, \"unhandled push type $l->{TYPE}\");"; + } +} + +############################################# +# push a structure/union element at top level +sub EjsPushElementTop($$) +{ + my $e = shift; + my $env = shift; + my $l = $e->{LEVELS}[0]; + my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env); + my $name = "\"$e->{NAME}\""; + EjsPushElement($e, $l, $var, $name, $env); +} + +########################### +# push a struct +sub EjsStructPush($$) +{ + my $name = shift; + my $d = shift; + my $env = GenerateStructEnv($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)\n{"; + indent; + pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; + foreach my $e (@{$d->{ELEMENTS}}) { + EjsPushElementTop($e, $env); + } + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + +########################### +# push a union +sub EjsUnionPush($$) +{ + my $name = shift; + my $d = shift; + my $have_default = 0; + my $env = GenerateStructEnv($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)\n{"; + indent; + pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; + pidl "switch (ejs->switch_var) {"; + indent; + foreach my $e (@{$d->{ELEMENTS}}) { + if ($e->{CASE} eq "default") { + $have_default = 1; + } + pidl "$e->{CASE}:"; + indent; + if ($e->{TYPE} ne "EMPTY") { + EjsPushElementTop($e, $env); + } + pidl "break;"; + deindent; + } + if (! $have_default) { + pidl "default:"; + indent; + pidl "return ejs_panic(ejs, \"Bad switch value\");"; + deindent; + } + deindent; + pidl "}"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; +} + +########################### +# push a enum +sub EjsEnumPush($$) +{ + my $name = shift; + my $d = shift; + EjsEnumConstant($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)\n{"; + indent; + pidl "unsigned e = *r;"; + pidl "NDR_CHECK(ejs_push_enum(ejs, v, name, &e));"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + +########################### +# push a bitmap +sub EjsBitmapPush($$) +{ + my $name = shift; + my $d = shift; + my $type_fn = $d->{BASE_TYPE}; + my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE}); + # put the bitmap elements in the constants array + foreach my $e (@{$d->{ELEMENTS}}) { + if ($e =~ /^(\w*)\s*(.*)\s*$/) { + my $bname = $1; + my $v = $2; + $constants{$bname} = $v; + } + } + pidl fn_prefix($d); + pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)\n{"; + indent; + pidl "return ejs_push_$type_fn(ejs, v, name, r);"; + deindent; + pidl "}"; +} + + +########################### +# generate a structure push +sub EjsTypedefPush($) +{ + my $d = shift; + return if (has_property($d, "noejs")); + if ($d->{DATA}->{TYPE} eq 'STRUCT') { + EjsStructPush($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'UNION') { + EjsUnionPush($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'ENUM') { + EjsEnumPush($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') { + EjsBitmapPush($d->{NAME}, $d->{DATA}); + } else { + warn "Unhandled push typedef $d->{NAME} of type $d->{DATA}->{TYPE}"; + } +} + + +##################### +# generate a function +sub EjsPushFunction($) +{ + my $d = shift; + my $env = GenerateFunctionOutEnv($d); + + pidl "\nstatic NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const struct $d->{NAME} *r)"; + pidl "{"; + indent; + pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));"; + + foreach my $e (@{$d->{ELEMENTS}}) { + next unless (grep(/out/, @{$e->{DIRECTION}})); + EjsPushElementTop($e, $env); + } + + if ($d->{RETURN_TYPE}) { + my $t = $d->{RETURN_TYPE}; + pidl "NDR_CHECK(ejs_push_$t(ejs, v, \"result\", &r->out.result));"; + } + + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + + +################################# +# generate a ejs mapping function +sub EjsFunction($$) +{ + my $d = shift; + my $iface = shift; + my $name = $d->{NAME}; + my $callnum = uc("DCERPC_$name"); + my $table = "&dcerpc_table_$iface"; + + pidl "static int ejs_$name(int eid, int argc, struct MprVar **argv)"; + pidl "{"; + indent; + pidl "return ejs_rpc_call(eid, argc, argv, $table, $callnum, (ejs_pull_function_t)ejs_pull_$name, (ejs_push_function_t)ejs_push_$name);"; + deindent; + pidl "}\n"; +} + +################### +# handle a constant +sub EjsConst($) +{ + my $const = shift; + $constants{$const->{NAME}} = $const->{VALUE}; +} + +##################################################################### +# parse the interface definitions +sub EjsInterface($$) +{ + my($interface,$needed) = @_; + my @fns = (); + my $name = $interface->{NAME}; + + %constants = (); + + foreach my $d (@{$interface->{TYPEDEFS}}) { + ($needed->{"push_$d->{NAME}"}) && EjsTypedefPush($d); + ($needed->{"pull_$d->{NAME}"}) && EjsTypedefPull($d); + } + + foreach my $d (@{$interface->{FUNCTIONS}}) { + next if not defined($d->{OPNUM}); + + EjsPullFunction($d); + EjsPushFunction($d); + EjsFunction($d, $name); + + push (@fns, $d->{NAME}); + } + + foreach my $d (@{$interface->{CONSTS}}) { + EjsConst($d); + } + + pidl "static int ejs_$name\_init(int eid, int argc, struct MprVar **argv)"; + pidl "{"; + indent; + pidl "struct MprVar *obj = mprInitObject(eid, \"$name\", argc, argv);"; + foreach (@fns) { + pidl "mprSetCFunction(obj, \"$_\", ejs_$_);"; + } + foreach my $v (keys %constants) { + my $value = $constants{$v}; + if (substr($value, 0, 1) eq "\"") { + pidl "mprSetVar(obj, \"$v\", mprString($value));"; + } else { + pidl "mprSetVar(obj, \"$v\", mprCreateNumberVar($value));"; + } + } + pidl "return ejs_rpc_init(obj, \"$name\");"; + deindent; + pidl "}\n"; + + pidl "NTSTATUS ejs_init_$name(void)"; + pidl "{"; + indent; + pidl "return smbcalls_register_ejs(\"$name\_init\", ejs_$name\_init);"; + deindent; + pidl "}"; +} + +##################################################################### +# parse a parsed IDL into a C header +sub Parse($$) +{ + my($ndr,$hdr) = @_; + + my $ejs_hdr = $hdr; + $ejs_hdr =~ s/.h$/_ejs.h/; + $res = ""; + pidl " +/* EJS wrapper functions auto-generated by pidl */ +#include \"includes.h\" +#include \"lib/appweb/ejs/ejs.h\" +#include \"scripting/ejs/ejsrpc.h\" +#include \"scripting/ejs/smbcalls.h\" +#include \"librpc/gen_ndr/ndr_misc_ejs.h\" +#include \"$hdr\" +#include \"$ejs_hdr\" + +"; + + my %needed = (); + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed); + } + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && EjsInterface($x, \%needed); + } + + return $res; +} + +sub NeededFunction($$) +{ + my ($fn,$needed) = @_; + $needed->{"pull_$fn->{NAME}"} = 1; + $needed->{"push_$fn->{NAME}"} = 1; + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/in/, @{$e->{DIRECTION}})) { + $needed->{"pull_$e->{TYPE}"} = 1; + } + if (grep (/out/, @{$e->{DIRECTION}})) { + $needed->{"push_$e->{TYPE}"} = 1; + } + } +} + +sub NeededTypedef($$) +{ + my ($t,$needed) = @_; + if (Parse::Pidl::Util::has_property($t, "public")) { + $needed->{"pull_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs"); + $needed->{"push_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs"); + } + if ($t->{DATA}->{TYPE} ne "STRUCT" && + $t->{DATA}->{TYPE} ne "UNION") { + return; + } + for my $e (@{$t->{DATA}->{ELEMENTS}}) { + if ($needed->{"pull_$t->{NAME}"}) { + $needed->{"pull_$e->{TYPE}"} = 1; + } + if ($needed->{"push_$t->{NAME}"}) { + $needed->{"push_$e->{TYPE}"} = 1; + } + } +} + +##################################################################### +# work out what parse functions are needed +sub NeededInterface($$) +{ + my ($interface,$needed) = @_; + foreach my $d (@{$interface->{FUNCTIONS}}) { + NeededFunction($d, $needed); + } + foreach my $d (reverse @{$interface->{TYPEDEFS}}) { + NeededTypedef($d, $needed); + } +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm b/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm new file mode 100644 index 0000000000..81c75705de --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm @@ -0,0 +1,76 @@ +################################################### +# create C header files for an EJS mapping functions +# Copyright tridge@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba::EJSHeader; + +use strict; +use Parse::Pidl::Typelist; +use Parse::Pidl::Util qw(has_property); + +my($res); + +sub pidl ($) +{ + $res .= shift; +} + +##################################################################### +# prototype a typedef +sub HeaderTypedefProto($) +{ + my $d = shift; + my $name = $d->{NAME}; + + return unless has_property($d, "public"); + + my $type_decl = Parse::Pidl::Typelist::mapType($name); + + pidl "NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, const $type_decl *);\n"; + pidl "NTSTATUS ejs_pull_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, $type_decl *);\n"; +} + +##################################################################### +# parse the interface definitions +sub HeaderInterface($) +{ + my($interface) = shift; + + my $count = 0; + + pidl "#ifndef _HEADER_EJS_$interface->{NAME}\n"; + pidl "#define _HEADER_EJS_$interface->{NAME}\n\n"; + + if (defined $interface->{PROPERTIES}->{depends}) { + my @d = split / /, $interface->{PROPERTIES}->{depends}; + foreach my $i (@d) { + pidl "#include \"librpc/gen_ndr/ndr_$i\_ejs\.h\"\n"; + } + } + + pidl "\n"; + + foreach my $d (@{$interface->{TYPEDEFS}}) { + HeaderTypedefProto($d); + } + + pidl "\n"; + pidl "#endif /* _HEADER_EJS_$interface->{NAME} */\n"; +} + +##################################################################### +# parse a parsed IDL into a C header +sub Parse($) +{ + my($idl) = shift; + + $res = ""; + pidl "/* header auto-generated by pidl */\n\n"; + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); + } + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/Header.pm new file mode 100644 index 0000000000..d88b37e229 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/Header.pm @@ -0,0 +1,356 @@ +################################################### +# create C header files for an IDL structure +# Copyright tridge@samba.org 2000 +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba::Header; + +use strict; +use Parse::Pidl::Typelist qw(mapType); +use Parse::Pidl::Util qw(has_property is_constant); +use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); + +my($res); +my($tab_depth); + +sub pidl ($) +{ + $res .= shift; +} + +sub tabs() +{ + my $res = ""; + $res .="\t" foreach (1..$tab_depth); + return $res; +} + +##################################################################### +# parse a properties list +sub HeaderProperties($$) +{ + my($props,$ignores) = @_; + my $ret = ""; + + foreach my $d (keys %{$props}) { + next if (grep(/^$d$/, @$ignores)); + if($props->{$d} ne "1") { + $ret.= "$d($props->{$d}),"; + } else { + $ret.="$d,"; + } + } + + if ($ret) { + pidl "/* [" . substr($ret, 0, -1) . "] */"; + } +} + +##################################################################### +# parse a structure element +sub HeaderElement($) +{ + my($element) = shift; + + pidl tabs(); + HeaderType($element, $element->{TYPE}, ""); + pidl " "; + my $numstar = $element->{POINTERS}; + foreach (@{$element->{ARRAY_LEN}}) + { + next if is_constant($_) and + not has_property($element, "charset"); + $numstar++; + } + $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); + pidl "*" foreach (1..$numstar); + pidl $element->{NAME}; + foreach (@{$element->{ARRAY_LEN}}) { + next unless (is_constant($_) and + not has_property($element, "charset")); + pidl "[$_]"; + } + + pidl ";"; + if (defined $element->{PROPERTIES}) { + HeaderProperties($element->{PROPERTIES}, ["in", "out"]); + } + pidl "\n"; +} + +##################################################################### +# parse a struct +sub HeaderStruct($$) +{ + my($struct,$name) = @_; + pidl "struct $name {\n"; + $tab_depth++; + my $el_count=0; + if (defined $struct->{ELEMENTS}) { + foreach my $e (@{$struct->{ELEMENTS}}) { + HeaderElement($e); + $el_count++; + } + } + if ($el_count == 0) { + # some compilers can't handle empty structures + pidl tabs()."char _empty_;\n"; + } + $tab_depth--; + pidl tabs()."}"; + if (defined $struct->{PROPERTIES}) { + HeaderProperties($struct->{PROPERTIES}, []); + } +} + +##################################################################### +# parse a enum +sub HeaderEnum($$) +{ + my($enum,$name) = @_; + my $first = 1; + + if (not Parse::Pidl::Util::useUintEnums()) { + pidl "enum $name {\n"; + $tab_depth++; + foreach my $e (@{$enum->{ELEMENTS}}) { + unless ($first) { pidl ",\n"; } + $first = 0; + pidl tabs(); + pidl $e; + } + pidl "\n"; + $tab_depth--; + pidl "}"; + } else { + my $count = 0; + pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n"; + my $with_val = 0; + my $without_val = 0; + foreach my $e (@{$enum->{ELEMENTS}}) { + my $t = "$e"; + my $name; + my $value; + if ($t =~ /(.*)=(.*)/) { + $name = $1; + $value = $2; + $with_val = 1; + die ("you can't mix enum member with values and without values when using --uint-enums!") + unless ($without_val == 0); + } else { + $name = $t; + $value = $count++; + $without_val = 1; + die ("you can't mix enum member with values and without values when using --uint-enums!") + unless ($with_val == 0); + } + pidl "#define $name ( $value )\n"; + } + pidl "\n"; + } +} + +##################################################################### +# parse a bitmap +sub HeaderBitmap($$) +{ + my($bitmap,$name) = @_; + + pidl "/* bitmap $name */\n"; + pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}}); + pidl "\n"; +} + +##################################################################### +# parse a union +sub HeaderUnion($$) +{ + my($union,$name) = @_; + my %done = (); + + pidl "union $name {\n"; + $tab_depth++; + foreach my $e (@{$union->{ELEMENTS}}) { + if ($e->{TYPE} ne "EMPTY") { + if (! defined $done{$e->{NAME}}) { + HeaderElement($e); + } + $done{$e->{NAME}} = 1; + } + } + $tab_depth--; + pidl "}"; + + if (defined $union->{PROPERTIES}) { + HeaderProperties($union->{PROPERTIES}, []); + } +} + +##################################################################### +# parse a type +sub HeaderType($$$) +{ + my($e,$data,$name) = @_; + if (ref($data) eq "HASH") { + ($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name); + ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data, $name); + ($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name); + ($data->{TYPE} eq "UNION") && HeaderUnion($data, $name); + return; + } + + if (has_property($e, "charset")) { + pidl "const char"; + } else { + pidl mapType($e->{TYPE}); + } +} + +##################################################################### +# parse a typedef +sub HeaderTypedef($) +{ + my($typedef) = shift; + HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); + pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP"); +} + +##################################################################### +# parse a const +sub HeaderConst($) +{ + my($const) = shift; + if (!defined($const->{ARRAY_LEN}[0])) { + pidl "#define $const->{NAME}\t( $const->{VALUE} )\n"; + } else { + pidl "#define $const->{NAME}\t $const->{VALUE}\n"; + } +} + +##################################################################### +# parse a function +sub HeaderFunctionInOut($$) +{ + my($fn,$prop) = @_; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (has_property($e, $prop)) { + HeaderElement($e); + } + } +} + +##################################################################### +# determine if we need an "in" or "out" section +sub HeaderFunctionInOut_needed($$) +{ + my($fn,$prop) = @_; + + return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void"); + + foreach (@{$fn->{ELEMENTS}}) { + return 1 if (has_property($_, $prop)); + } + + return undef; +} + +my %headerstructs = (); + +##################################################################### +# parse a function +sub HeaderFunction($) +{ + my($fn) = shift; + + return if ($headerstructs{$fn->{NAME}}); + + $headerstructs{$fn->{NAME}} = 1; + + pidl "\nstruct $fn->{NAME} {\n"; + $tab_depth++; + my $needed = 0; + + if (HeaderFunctionInOut_needed($fn, "in")) { + pidl tabs()."struct {\n"; + $tab_depth++; + HeaderFunctionInOut($fn, "in"); + $tab_depth--; + pidl tabs()."} in;\n\n"; + $needed++; + } + + if (HeaderFunctionInOut_needed($fn, "out")) { + pidl tabs()."struct {\n"; + $tab_depth++; + HeaderFunctionInOut($fn, "out"); + if ($fn->{RETURN_TYPE} ne "void") { + pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n"; + } + $tab_depth--; + pidl tabs()."} out;\n\n"; + $needed++; + } + + if (! $needed) { + # sigh - some compilers don't like empty structures + pidl tabs()."int _dummy_element;\n"; + } + + $tab_depth--; + pidl "};\n\n"; +} + +##################################################################### +# parse the interface definitions +sub HeaderInterface($) +{ + my($interface) = shift; + + my $count = 0; + + pidl "#ifndef _HEADER_$interface->{NAME}\n"; + pidl "#define _HEADER_$interface->{NAME}\n\n"; + + if (defined $interface->{PROPERTIES}->{depends}) { + my @d = split / /, $interface->{PROPERTIES}->{depends}; + foreach my $i (@d) { + pidl "#include \"librpc/gen_ndr/$i\.h\"\n"; + } + } + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "CONST"); + HeaderConst($d); + } + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "TYPEDEF"); + HeaderTypedef($d); + } + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "FUNCTION"); + HeaderFunction($d); + } + + pidl "#endif /* _HEADER_$interface->{NAME} */\n"; +} + +##################################################################### +# parse a parsed IDL into a C header +sub Parse($) +{ + my($idl) = shift; + $tab_depth = 0; + + $res = ""; + pidl "/* header auto-generated by pidl */\n\n"; + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); + } + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm new file mode 100644 index 0000000000..126dbc3ba9 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm @@ -0,0 +1,99 @@ +################################################### +# client calls generator +# Copyright tridge@samba.org 2003 +# released under the GNU GPL + +package Parse::Pidl::Samba::NDR::Client; + +use strict; + +my($res); + +##################################################################### +# parse a function +sub ParseFunction($$) +{ + my ($interface, $fn) = @_; + my $name = $fn->{NAME}; + my $uname = uc $name; + + $res .= " +struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) +{ + if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) { + NDR_PRINT_IN_DEBUG($name, r); + } + + return dcerpc_ndr_request_send(p, NULL, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, r); +} + +NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) +{ + struct rpc_request *req; + NTSTATUS status; + + req = dcerpc_$name\_send(p, mem_ctx, r); + if (req == NULL) return NT_STATUS_NO_MEMORY; + + status = dcerpc_ndr_request_recv(req); + + if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { + NDR_PRINT_OUT_DEBUG($name, r); + } +"; + + if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") { + $res .= "\tif (NT_STATUS_IS_OK(status)) status = r->out.result;\n"; + } + $res .= +" + return status; +} +"; +} + +my %done; + +##################################################################### +# parse the interface definitions +sub ParseInterface($) +{ + my($interface) = shift; + $res .= "/* $interface->{NAME} - client functions generated by pidl */\n\n"; + + foreach my $fn (@{$interface->{FUNCTIONS}}) { + next if not defined($fn->{OPNUM}); + next if defined($done{$fn->{NAME}}); + ParseFunction($interface, $fn); + $done{$fn->{NAME}} = 1; + } + + return $res; +} + +sub Parse($$) +{ + my($ndr) = shift; + my($filename) = shift; + + my $h_filename = $filename; + $res = ""; + + if ($h_filename =~ /(.*)\.c/) { + $h_filename = "$1.h"; + } + + $res .= "/* client functions auto-generated by pidl */\n"; + $res .= "\n"; + $res .= "#include \"includes.h\"\n"; + $res .= "#include \"$h_filename\"\n"; + $res .= "\n"; + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && ParseInterface($x); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm new file mode 100644 index 0000000000..9aa0ed8daf --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm @@ -0,0 +1,166 @@ +################################################### +# create C header files for an IDL structure +# Copyright tridge@samba.org 2000 +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba::NDR::Header; + +use strict; +use Parse::Pidl::Typelist qw(mapType); +use Parse::Pidl::Util qw(has_property is_constant); +use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); +use Parse::Pidl::Samba::NDR::Parser; + +my($res); +my($tab_depth); + +sub pidl ($) +{ + $res .= shift; +} + +sub tabs() +{ + my $res = ""; + $res .="\t" foreach (1..$tab_depth); + return $res; +} + +##################################################################### +# prototype a typedef +sub HeaderTypedefProto($) +{ + my($d) = shift; + + my $tf = Parse::Pidl::Samba::NDR::Parser::get_typefamily($d->{DATA}{TYPE}); + + if (has_property($d, "gensize")) { + my $size_args = $tf->{SIZE_FN_ARGS}->($d); + pidl "size_t ndr_size_$d->{NAME}($size_args);\n"; + } + + return unless has_property($d, "public"); + + unless (has_property($d, "nopush")) { + pidl "NTSTATUS ndr_push_$d->{NAME}(struct ndr_push *ndr, int ndr_flags, " . $tf->{DECL}->($d, "push") . ");\n"; + } + unless (has_property($d, "nopull")) { + pidl "NTSTATUS ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, " . $tf->{DECL}->($d, "pull") . ");\n"; + } + unless (has_property($d, "noprint")) { + pidl "void ndr_print_$d->{NAME}(struct ndr_print *ndr, const char *name, " . $tf->{DECL}->($d, "print") . ");\n"; + } +} + +##################################################################### +# output prototypes for a IDL function +sub HeaderFnProto($$) +{ + my ($interface,$fn) = @_; + my $name = $fn->{NAME}; + + pidl "void ndr_print_$name(struct ndr_print *ndr, const char *name, int flags, const struct $name *r);\n"; + + unless (has_property($fn, "noopnum")) { + pidl "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n"; + pidl "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n"; + } + + return unless has_property($fn, "public"); + + pidl "NTSTATUS ndr_push_$name(struct ndr_push *ndr, int flags, const struct $name *r);\n"; + pidl "NTSTATUS ndr_pull_$name(struct ndr_pull *ndr, int flags, struct $name *r);\n"; + + pidl "\n"; +} + +##################################################################### +# parse the interface definitions +sub HeaderInterface($) +{ + my($interface) = shift; + + if (defined $interface->{PROPERTIES}->{depends}) { + my @d = split / /, $interface->{PROPERTIES}->{depends}; + foreach my $i (@d) { + pidl "#include \"librpc/gen_ndr/ndr_$i\.h\"\n"; + } + } + + my $count = 0; + + pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n"; + pidl "#define _HEADER_NDR_$interface->{NAME}\n\n"; + + if (defined $interface->{PROPERTIES}->{uuid}) { + my $name = uc $interface->{NAME}; + pidl "#define DCERPC_$name\_UUID " . + Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}) . "\n"; + + if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; } + pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n"; + + pidl "#define DCERPC_$name\_NAME \"$interface->{NAME}\"\n"; + + if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; } + pidl "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}\n"; + + pidl "\nextern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n"; + pidl "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);\n\n"; + } + + foreach my $d (@{$interface->{DATA}}) { + next if $d->{TYPE} ne "FUNCTION"; + next if has_property($d, "noopnum"); + next if grep(/$d->{NAME}/,@{$interface->{INHERITED_FUNCTIONS}}); + my $u_name = uc $d->{NAME}; + pidl "#define DCERPC_$u_name ("; + + if (defined($interface->{BASE})) { + pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + "; + } + + pidl sprintf("0x%02x", $count) . ")\n"; + $count++; + } + + pidl "\n#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ("; + + if (defined($interface->{BASE})) { + pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + "; + } + + pidl "$count)\n\n"; + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "TYPEDEF"); + HeaderTypedefProto($d); + } + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "FUNCTION"); + HeaderFnProto($interface, $d); + } + + pidl "#endif /* _HEADER_NDR_$interface->{NAME} */\n"; +} + +##################################################################### +# parse a parsed IDL into a C header +sub Parse($$) +{ + my($idl,$basename) = @_; + $tab_depth = 0; + + $res = ""; + pidl "/* header auto-generated by pidl */\n"; + pidl "#include \"librpc/gen_ndr/$basename\.h\"\n\n"; + + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); + } + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm new file mode 100644 index 0000000000..ef22ff9788 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm @@ -0,0 +1,2341 @@ +################################################### +# Samba4 NDR parser generator for IDL structures +# Copyright tridge@samba.org 2000-2003 +# Copyright tpot@samba.org 2001 +# Copyright jelmer@samba.org 2004-2005 +# released under the GNU GPL + +package Parse::Pidl::Samba::NDR::Parser; + +use strict; +use Parse::Pidl::Typelist qw(hasType getType mapType); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); + +# list of known types +my %typefamily; + +sub get_typefamily($) +{ + my $n = shift; + return $typefamily{$n}; +} + +sub append_prefix($$) +{ + my ($e, $var_name) = @_; + my $pointers = 0; + + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER") { + $pointers++; + } elsif ($l->{TYPE} eq "ARRAY") { + if (($pointers == 0) and + (not $l->{IS_FIXED}) and + (not $l->{IS_INLINE})) { + return get_value_of($var_name); + } + } elsif ($l->{TYPE} eq "DATA") { + if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + return get_value_of($var_name) unless ($pointers); + } + } + } + + return $var_name; +} + +sub has_fast_array($$) +{ + my ($e,$l) = @_; + + return 0 if ($l->{TYPE} ne "ARRAY"); + + my $nl = GetNextLevel($e,$l); + return 0 unless ($nl->{TYPE} eq "DATA"); + return 0 unless (hasType($nl->{DATA_TYPE})); + + my $t = getType($nl->{DATA_TYPE}); + + # Only uint8 and string have fast array functions at the moment + return ($t->{NAME} eq "uint8") or ($t->{NAME} eq "string"); +} + +sub is_charset_array($$) +{ + my ($e,$l) = @_; + + return 0 if ($l->{TYPE} ne "ARRAY"); + + my $nl = GetNextLevel($e,$l); + + return 0 unless ($nl->{TYPE} eq "DATA"); + + return has_property($e, "charset"); +} + +sub get_pointer_to($) +{ + my $var_name = shift; + + if ($var_name =~ /^\*(.*)$/) { + return $1; + } elsif ($var_name =~ /^\&(.*)$/) { + return "&($var_name)"; + } else { + return "&$var_name"; + } +} + +sub get_value_of($) +{ + my $var_name = shift; + + if ($var_name =~ /^\&(.*)$/) { + return $1; + } else { + return "*$var_name"; + } +} + +my $res = ""; +my $deferred = ""; +my $tabs = ""; + +#################################### +# pidl() is our basic output routine +sub pidl($) +{ + my $d = shift; + if ($d) { + $res .= $tabs; + $res .= $d; + } + $res .="\n"; +} + +#################################### +# defer() is like pidl(), but adds to +# a deferred buffer which is then added to the +# output buffer at the end of the structure/union/function +# This is needed to cope with code that must be pushed back +# to the end of a block of elements +sub defer($) +{ + my $d = shift; + if ($d) { + $deferred .= $tabs; + $deferred .= $d; + } + $deferred .="\n"; +} + +######################################## +# add the deferred content to the current +# output +sub add_deferred() +{ + $res .= $deferred; + $deferred = ""; +} + +sub indent() +{ + $tabs .= "\t"; +} + +sub deindent() +{ + $tabs = substr($tabs, 0, -1); +} + +##################################################################### +# check that a variable we get from ParseExpr isn't a null pointer +sub check_null_pointer($) +{ + my $size = shift; + if ($size =~ /^\*/) { + my $size2 = substr($size, 1); + pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; + } +} + +##################################################################### +# check that a variable we get from ParseExpr isn't a null pointer, +# putting the check at the end of the structure/function +sub check_null_pointer_deferred($) +{ + my $size = shift; + if ($size =~ /^\*/) { + my $size2 = substr($size, 1); + defer "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; + } +} + +##################################################################### +# check that a variable we get from ParseExpr isn't a null pointer +# void return varient +sub check_null_pointer_void($) +{ + my $size = shift; + if ($size =~ /^\*/) { + my $size2 = substr($size, 1); + pidl "if ($size2 == NULL) return;"; + } +} + +##################################################################### +# work out is a parse function should be declared static or not +sub fn_prefix($) +{ + my $fn = shift; + + return "" if (has_property($fn, "public")); + return "static "; +} + +################################################################### +# setup any special flags for an element or structure +sub start_flags($) +{ + my $e = shift; + my $flags = has_property($e, "flag"); + if (defined $flags) { + pidl "{"; + indent; + pidl "uint32_t _flags_save_$e->{TYPE} = ndr->flags;"; + pidl "ndr_set_flags(&ndr->flags, $flags);"; + } +} + +################################################################### +# end any special flags for an element or structure +sub end_flags($) +{ + my $e = shift; + my $flags = has_property($e, "flag"); + if (defined $flags) { + pidl "ndr->flags = _flags_save_$e->{TYPE};"; + deindent; + pidl "}"; + } +} + +sub GenerateStructEnv($) +{ + my $x = shift; + my %env; + + foreach my $e (@{$x->{ELEMENTS}}) { + $env{$e->{NAME}} = "r->$e->{NAME}"; + } + + $env{"this"} = "r"; + + return \%env; +} + +sub GenerateFunctionInEnv($) +{ + my $fn = shift; + my %env; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->in.$e->{NAME}"; + } + } + + return \%env; +} + +sub GenerateFunctionOutEnv($) +{ + my $fn = shift; + my %env; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/out/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->out.$e->{NAME}"; + } elsif (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->in.$e->{NAME}"; + } + } + + return \%env; +} + +##################################################################### +# parse the data of an array - push side +sub ParseArrayPushHeader($$$$$) +{ + my ($e,$l,$ndr,$var_name,$env) = @_; + + my $size; + my $length; + + if ($l->{IS_ZERO_TERMINATED}) { + $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))"; + } else { + $size = ParseExpr($l->{SIZE_IS}, $env); + $length = ParseExpr($l->{LENGTH_IS}, $env); + } + + if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { + pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));"; + } + + if ($l->{IS_VARYING}) { + pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));"; # array offset + pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));"; + } + + return $length; +} + +##################################################################### +# parse an array - pull side +sub ParseArrayPullHeader($$$$$) +{ + my ($e,$l,$ndr,$var_name,$env) = @_; + + my $length; + my $size; + + if ($l->{IS_CONFORMANT}) { + $length = $size = "ndr_get_array_size($ndr, " . get_pointer_to($var_name) . ")"; + } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays + $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))"; + } else { + $length = $size = ParseExpr($l->{SIZE_IS}, $env); + } + + if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { + pidl "NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));"; + } + + + if ($l->{IS_VARYING}) { + pidl "NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));"; + $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")"; + } + + check_null_pointer($length); + + if ($length ne $size) { + pidl "if ($length > $size) {"; + indent; + pidl "return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);"; + deindent; + pidl "}"; + } + + if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { + my $size = ParseExpr($l->{SIZE_IS}, $env); + defer "if ($var_name) {"; + check_null_pointer_deferred($size); + defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"; + defer "}"; + } + + if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { + my $length = ParseExpr($l->{LENGTH_IS}, $env); + defer "if ($var_name) {"; + check_null_pointer_deferred($length); + defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"; + defer "}" + } + + if (not $l->{IS_FIXED} and not is_charset_array($e, $l)) { + AllocateArrayLevel($e,$l,$ndr,$env,$size); + } + + return $length; +} + +sub compression_alg($$) +{ + my ($e,$l) = @_; + my $compression = $l->{COMPRESSION}; + my ($alg, $clen, $dlen) = split(/ /, $compression); + + return $alg; +} + +sub compression_clen($$$) +{ + my ($e,$l,$env) = @_; + my $compression = $l->{COMPRESSION}; + my ($alg, $clen, $dlen) = split(/ /, $compression); + + return ParseExpr($clen, $env); +} + +sub compression_dlen($$$) +{ + my ($e,$l,$env) = @_; + my $compression = $l->{COMPRESSION}; + my ($alg, $clen, $dlen) = split(/ /, $compression); + + return ParseExpr($dlen, $env); +} + +sub ParseCompressionPushStart($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $comndr = "$ndr\_compressed"; + my $alg = compression_alg($e, $l); + my $dlen = compression_dlen($e, $l, $env); + + pidl "{"; + indent; + pidl "struct ndr_push *$comndr;"; + pidl "NDR_CHECK(ndr_push_compression_start($ndr, &$comndr, $alg, $dlen));"; + + return $comndr; +} + +sub ParseCompressionPushEnd($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $comndr = "$ndr\_compressed"; + my $alg = compression_alg($e, $l); + my $dlen = compression_dlen($e, $l, $env); + + pidl "NDR_CHECK(ndr_push_compression_end($ndr, $comndr, $alg, $dlen));"; + deindent; + pidl "}"; +} + +sub ParseCompressionPullStart($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $comndr = "$ndr\_compressed"; + my $alg = compression_alg($e, $l); + my $dlen = compression_dlen($e, $l, $env); + + pidl "{"; + indent; + pidl "struct ndr_pull *$comndr;"; + pidl "NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen));"; + + return $comndr; +} + +sub ParseCompressionPullEnd($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $comndr = "$ndr\_compressed"; + my $alg = compression_alg($e, $l); + my $dlen = compression_dlen($e, $l, $env); + + pidl "NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));"; + deindent; + pidl "}"; +} + +sub ParseObfuscationPushStart($$) +{ + my ($e,$ndr) = @_; + my $obfuscation = has_property($e, "obfuscation"); + + pidl "NDR_CHECK(ndr_push_obfuscation_start($ndr, $obfuscation));"; + + return $ndr; +} + +sub ParseObfuscationPushEnd($$) +{ + my ($e,$ndr) = @_; + my $obfuscation = has_property($e, "obfuscation"); + + pidl "NDR_CHECK(ndr_push_obfuscation_end($ndr, $obfuscation));"; +} + +sub ParseObfuscationPullStart($$) +{ + my ($e,$ndr) = @_; + my $obfuscation = has_property($e, "obfuscation"); + + pidl "NDR_CHECK(ndr_pull_obfuscation_start($ndr, $obfuscation));"; + + return $ndr; +} + +sub ParseObfuscationPullEnd($$) +{ + my ($e,$ndr) = @_; + my $obfuscation = has_property($e, "obfuscation"); + + pidl "NDR_CHECK(ndr_pull_obfuscation_end($ndr, $obfuscation));"; +} + +sub ParseSubcontextPushStart($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $subndr = "_ndr_$e->{NAME}"; + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + + pidl "{"; + indent; + pidl "struct ndr_push *$subndr;"; + pidl "NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + + if (defined $l->{COMPRESSION}) { + $subndr = ParseCompressionPushStart($e, $l, $subndr, $env); + } + + if (defined $l->{OBFUSCATION}) { + $subndr = ParseObfuscationPushStart($e, $subndr); + } + + return $subndr; +} + +sub ParseSubcontextPushEnd($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $subndr = "_ndr_$e->{NAME}"; + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + + if (defined $l->{COMPRESSION}) { + ParseCompressionPushEnd($e, $l, $subndr, $env); + } + + if (defined $l->{OBFUSCATION}) { + ParseObfuscationPushEnd($e, $subndr); + } + + pidl "NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + deindent; + pidl "}"; +} + +sub ParseSubcontextPullStart($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $subndr = "_ndr_$e->{NAME}"; + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + + pidl "{"; + indent; + pidl "struct ndr_pull *$subndr;"; + pidl "NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + + if (defined $l->{COMPRESSION}) { + $subndr = ParseCompressionPullStart($e, $l, $subndr, $env); + } + + if (defined $l->{OBFUSCATION}) { + $subndr = ParseObfuscationPullStart($e, $subndr); + } + + return $subndr; +} + +sub ParseSubcontextPullEnd($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $subndr = "_ndr_$e->{NAME}"; + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + + if (defined $l->{COMPRESSION}) { + ParseCompressionPullEnd($e, $l, $subndr, $env); + } + + if (defined $l->{OBFUSCATION}) { + ParseObfuscationPullEnd($e, $subndr); + } + + pidl "NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + deindent; + pidl "}"; +} + +sub ParseElementPushLevel +{ + my ($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; + + my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); + + if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING} + or is_charset_array($e, $l))) { + $var_name = get_pointer_to($var_name); + } + + if (defined($ndr_flags)) { + if ($l->{TYPE} eq "SUBCONTEXT") { + my $subndr = ParseSubcontextPushStart($e, $l, $ndr, $env); + ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1); + ParseSubcontextPushEnd($e, $l, $ndr, $env); + } elsif ($l->{TYPE} eq "POINTER") { + ParsePtrPush($e, $l, $var_name); + } elsif ($l->{TYPE} eq "ARRAY") { + my $length = ParseArrayPushHeader($e, $l, $ndr, $var_name, $env); + + my $nl = GetNextLevel($e, $l); + + # Allow speedups for arrays of scalar types + if (is_charset_array($e,$l)) { + pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; + return; + } elsif (has_fast_array($e,$l)) { + pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; + return; + } + } elsif ($l->{TYPE} eq "SWITCH") { + ParseSwitchPush($e, $l, $ndr, $var_name, $ndr_flags, $env); + } elsif ($l->{TYPE} eq "DATA") { + ParseDataPush($e, $l, $ndr, $var_name, $ndr_flags); + } + } + + if ($l->{TYPE} eq "POINTER" and $deferred) { + if ($l->{POINTER_TYPE} ne "ref") { + pidl "if ($var_name) {"; + indent; + if ($l->{POINTER_TYPE} eq "relative") { + pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));"; + } + } + $var_name = get_value_of($var_name); + ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1); + + if ($l->{POINTER_TYPE} ne "ref") { + deindent; + pidl "}"; + } + } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and + not is_charset_array($e, $l)) { + my $length = ParseExpr($l->{LENGTH_IS}, $env); + my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; + + $var_name = $var_name . "[$counter]"; + + if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { + pidl "for ($counter = 0; $counter < $length; $counter++) {"; + indent; + ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0); + deindent; + pidl "}"; + } + + if ($deferred and ContainsDeferred($e, $l)) { + pidl "for ($counter = 0; $counter < $length; $counter++) {"; + indent; + ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1); + deindent; + pidl "}"; + } + } elsif ($l->{TYPE} eq "SWITCH") { + ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred); + } +} + +##################################################################### +# parse scalars in a structure element +sub ParseElementPush($$$$$$) +{ + my ($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_; + my $subndr = undef; + + my $var_name = $var_prefix.$e->{NAME}; + + $var_name = append_prefix($e, $var_name); + + return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); + + start_flags($e); + + if (my $value = has_property($e, "value")) { + $var_name = ParseExpr($value, $env); + } + + ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred); + + end_flags($e); +} + +##################################################################### +# parse a pointer in a struct element or function +sub ParsePtrPush($$$) +{ + my ($e,$l,$var_name) = @_; + + if ($l->{POINTER_TYPE} eq "ref") { + if ($l->{LEVEL} eq "EMBEDDED") { + pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_name));"; + } else { + check_null_pointer(get_value_of($var_name)); + } + } elsif ($l->{POINTER_TYPE} eq "relative") { + pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));"; + } elsif ($l->{POINTER_TYPE} eq "unique") { + pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));"; + } elsif ($l->{POINTER_TYPE} eq "sptr") { + pidl "NDR_CHECK(ndr_push_sptr_ptr(ndr, $var_name));"; + } else { + die("Unhandled pointer type $l->{POINTER_TYPE}"); + } +} + +##################################################################### +# print scalars in a structure element +sub ParseElementPrint($$$) +{ + my($e,$var_name,$env) = @_; + + $var_name = append_prefix($e, $var_name); + return if (has_property($e, "noprint")); + + if (my $value = has_property($e, "value")) { + $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env) . ":$var_name"; + } + + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER") { + pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);"; + pidl "ndr->depth++;"; + if ($l->{POINTER_TYPE} ne "ref") { + pidl "if ($var_name) {"; + indent; + } + $var_name = get_value_of($var_name); + } elsif ($l->{TYPE} eq "ARRAY") { + my $length; + + if ($l->{IS_CONFORMANT} or $l->{IS_VARYING} or + is_charset_array($e,$l)) { + $var_name = get_pointer_to($var_name); + } + + if ($l->{IS_ZERO_TERMINATED}) { + $length = "ndr_string_length($var_name, sizeof(*$var_name))"; + } else { + $length = ParseExpr($l->{LENGTH_IS}, $env); + } + + if (is_charset_array($e,$l)) { + pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);"; + last; + } elsif (has_fast_array($e, $l)) { + my $nl = GetNextLevel($e, $l); + pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);"; + last; + } else { + my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; + + pidl "ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);"; + pidl 'ndr->depth++;'; + pidl "for ($counter=0;$counter<$length;$counter++) {"; + indent; + pidl "char *idx_$l->{LEVEL_INDEX}=NULL;"; + pidl "asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);"; + pidl "if (idx_$l->{LEVEL_INDEX}) {"; + indent; + + $var_name = $var_name . "[$counter]"; + } + } elsif ($l->{TYPE} eq "DATA") { + if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + $var_name = get_pointer_to($var_name); + } + pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; + } elsif ($l->{TYPE} eq "SWITCH") { + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); + check_null_pointer_void($switch_var); + pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"; + } + } + + foreach my $l (reverse @{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER") { + if ($l->{POINTER_TYPE} ne "ref") { + deindent; + pidl "}"; + } + pidl "ndr->depth--;"; + } elsif (($l->{TYPE} eq "ARRAY") + and not is_charset_array($e,$l) + and not has_fast_array($e,$l)) { + pidl "free(idx_$l->{LEVEL_INDEX});"; + deindent; + pidl "}"; + deindent; + pidl "}"; + pidl "ndr->depth--;"; + } + } +} + +##################################################################### +# parse scalars in a structure element - pull size +sub ParseSwitchPull($$$$$$) +{ + my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); + + check_null_pointer($switch_var); + + $var_name = get_pointer_to($var_name); + pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));"; +} + +##################################################################### +# push switch element +sub ParseSwitchPush($$$$$$) +{ + my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); + + check_null_pointer($switch_var); + $var_name = get_pointer_to($var_name); + pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"; +} + +sub ParseDataPull($$$$$) +{ + my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; + + if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + $var_name = get_pointer_to($var_name); + } + + $var_name = get_pointer_to($var_name); + + pidl "NDR_CHECK(ndr_pull_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));"; + + if (my $range = has_property($e, "range")) { + $var_name = get_value_of($var_name); + my ($low, $high) = split(/ /, $range, 2); + pidl "if ($var_name < $low || $var_name > $high) {"; + pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");"; + pidl "}"; + } +} + +sub ParseDataPush($$$$$) +{ + my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; + + # strings are passed by value rather then reference + if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + $var_name = get_pointer_to($var_name); + } + + pidl "NDR_CHECK(ndr_push_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));"; +} + +sub CalcNdrFlags($$$) +{ + my ($l,$primitives,$deferred) = @_; + + my $scalars = 0; + my $buffers = 0; + + # Add NDR_SCALARS if this one is deferred + # and deferreds may be pushed + $scalars = 1 if ($l->{IS_DEFERRED} and $deferred); + + # Add NDR_SCALARS if this one is not deferred and + # primitives may be pushed + $scalars = 1 if (!$l->{IS_DEFERRED} and $primitives); + + # Add NDR_BUFFERS if this one contains deferred stuff + # and deferreds may be pushed + $buffers = 1 if ($l->{CONTAINS_DEFERRED} and $deferred); + + return "NDR_SCALARS|NDR_BUFFERS" if ($scalars and $buffers); + return "NDR_SCALARS" if ($scalars); + return "NDR_BUFFERS" if ($buffers); + return undef; +} + +sub ParseMemCtxPullStart($$$) +{ + my $e = shift; + my $l = shift; + my $ptr_name = shift; + + my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; + my $mem_c_ctx = $ptr_name; + my $mem_c_flags = "0"; + + return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}); + + if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { + my $nl = GetNextLevel($e, $l); + my $next_is_array = ($nl->{TYPE} eq "ARRAY"); + my $next_is_string = (($nl->{TYPE} eq "DATA") and + ($nl->{DATA_TYPE} eq "string")); + if ($next_is_array or $next_is_string) { + return; + } else { + $mem_c_flags = "LIBNDR_FLAG_REF_ALLOC"; + } + } + + pidl "$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);"; + pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);"; +} + +sub ParseMemCtxPullEnd($$) +{ + my $e = shift; + my $l = shift; + + my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; + my $mem_r_flags = "0"; + + return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}); + + if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { + my $nl = GetNextLevel($e, $l); + my $next_is_array = ($nl->{TYPE} eq "ARRAY"); + my $next_is_string = (($nl->{TYPE} eq "DATA") and + ($nl->{DATA_TYPE} eq "string")); + if ($next_is_array or $next_is_string) { + return; + } else { + $mem_r_flags = "LIBNDR_FLAG_REF_ALLOC"; + } + } + + pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);"; +} + +sub ParseElementPullLevel +{ + my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; + + my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); + + if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT} + or is_charset_array($e,$l))) { + $var_name = get_pointer_to($var_name); + } + + # Only pull something if there's actually something to be pulled + if (defined($ndr_flags)) { + if ($l->{TYPE} eq "SUBCONTEXT") { + my $subndr = ParseSubcontextPullStart($e, $l, $ndr, $env); + ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1); + ParseSubcontextPullEnd($e, $l, $ndr, $env); + } elsif ($l->{TYPE} eq "ARRAY") { + my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env); + + my $nl = GetNextLevel($e, $l); + + if (is_charset_array($e,$l)) { + pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; + return; + } elsif (has_fast_array($e, $l)) { + pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; + if ($l->{IS_ZERO_TERMINATED}) { + # Make sure last element is zero! + pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));"; + } + return; + } + } elsif ($l->{TYPE} eq "POINTER") { + ParsePtrPull($e, $l, $ndr, $var_name); + } elsif ($l->{TYPE} eq "SWITCH") { + ParseSwitchPull($e, $l, $ndr, $var_name, $ndr_flags, $env); + } elsif ($l->{TYPE} eq "DATA") { + ParseDataPull($e, $l, $ndr, $var_name, $ndr_flags); + } + } + + # add additional constructions + if ($l->{TYPE} eq "POINTER" and $deferred) { + if ($l->{POINTER_TYPE} ne "ref") { + pidl "if ($var_name) {"; + indent; + + if ($l->{POINTER_TYPE} eq "relative") { + pidl "struct ndr_pull_save _relative_save;"; + pidl "ndr_pull_save(ndr, &_relative_save);"; + pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));"; + } + } + + ParseMemCtxPullStart($e,$l, $var_name); + + $var_name = get_value_of($var_name); + ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); + + ParseMemCtxPullEnd($e,$l); + + if ($l->{POINTER_TYPE} ne "ref") { + if ($l->{POINTER_TYPE} eq "relative") { + pidl "ndr_pull_restore(ndr, &_relative_save);"; + } + deindent; + pidl "}"; + } + } elsif ($l->{TYPE} eq "ARRAY" and + not has_fast_array($e,$l) and not is_charset_array($e, $l)) { + my $length = ParseExpr($l->{LENGTH_IS}, $env); + my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; + my $array_name = $var_name; + + $var_name = $var_name . "[$counter]"; + + ParseMemCtxPullStart($e,$l, $array_name); + + if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { + pidl "for ($counter = 0; $counter < $length; $counter++) {"; + indent; + ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 0); + deindent; + pidl "}"; + + if ($l->{IS_ZERO_TERMINATED}) { + # Make sure last element is zero! + pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));"; + } + } + + if ($deferred and ContainsDeferred($e, $l)) { + pidl "for ($counter = 0; $counter < $length; $counter++) {"; + indent; + ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1); + deindent; + pidl "}"; + } + + ParseMemCtxPullEnd($e,$l); + + } elsif ($l->{TYPE} eq "SWITCH") { + ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred); + } +} + +##################################################################### +# parse scalars in a structure element - pull size +sub ParseElementPull($$$$$$) +{ + my($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_; + + my $var_name = $var_prefix.$e->{NAME}; + + $var_name = append_prefix($e, $var_name); + + return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); + + start_flags($e); + + ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred); + + end_flags($e); +} + +##################################################################### +# parse a pointer in a struct element or function +sub ParsePtrPull($$$$) +{ + my($e,$l,$ndr,$var_name) = @_; + + my $nl = GetNextLevel($e, $l); + my $next_is_array = ($nl->{TYPE} eq "ARRAY"); + my $next_is_string = (($nl->{TYPE} eq "DATA") and + ($nl->{DATA_TYPE} eq "string")); + + if ($l->{POINTER_TYPE} eq "ref") { + unless ($l->{LEVEL} eq "TOP") { + pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"; + } + + unless ($next_is_array or $next_is_string) { + pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; + pidl "\tNDR_PULL_ALLOC($ndr, $var_name);"; + pidl "}"; + } + + return; + } elsif (($l->{POINTER_TYPE} eq "unique") or + ($l->{POINTER_TYPE} eq "relative") or + ($l->{POINTER_TYPE} eq "sptr")) { + pidl "NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));"; + pidl "if (_ptr_$e->{NAME}) {"; + indent; + } else { + die("Unhandled pointer type $l->{POINTER_TYPE}"); + } + + # Don't do this for arrays, they're allocated at the actual level + # of the array + unless ($next_is_array or $next_is_string) { + pidl "NDR_PULL_ALLOC($ndr, $var_name);"; + } else { + # FIXME: Yes, this is nasty. + # We allocate an array twice + # - once just to indicate that it's there, + # - then the real allocation... + pidl "NDR_PULL_ALLOC_SIZE($ndr, $var_name, 1);"; + } + + #pidl "memset($var_name, 0, sizeof($var_name));"; + if ($l->{POINTER_TYPE} eq "relative") { + pidl "NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));"; + } + deindent; + pidl "} else {"; + pidl "\t$var_name = NULL;"; + pidl "}"; +} + +##################################################################### +# parse a struct +sub ParseStructPush($$) +{ + my($struct,$name) = @_; + + return unless defined($struct->{ELEMENTS}); + + my $env = GenerateStructEnv($struct); + + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base}); + + foreach my $e (@{$struct->{ELEMENTS}}) { + DeclareArrayVariables($e); + } + + start_flags($struct); + + # see if the structure contains a conformant array. If it + # does, then it must be the last element of the structure, and + # we need to push the conformant length early, as it fits on + # the wire before the structure (and even before the structure + # alignment) + my $e = $struct->{ELEMENTS}[-1]; + if (defined($struct->{SURROUNDING_ELEMENT})) { + my $e = $struct->{SURROUNDING_ELEMENT}; + + if (defined($e->{LEVELS}[0]) and + $e->{LEVELS}[0]->{TYPE} eq "ARRAY") { + my $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env); + + pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; + } else { + pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));"; + } + } + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + + pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));"; + + if (defined($struct->{PROPERTIES}{relative_base})) { + # set the current offset as base for relative pointers + # and store it based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));"; + } + + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPush($e, "ndr", "r->", $env, 1, 0); + } + + deindent; + pidl "}"; + + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + if (defined($struct->{PROPERTIES}{relative_base})) { + # retrieve the current offset as base for relative pointers + # based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));"; + } + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPush($e, "ndr", "r->", $env, 0, 1); + } + + deindent; + pidl "}"; + + end_flags($struct); + # restore the old relative_base_offset + pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base}); +} + +##################################################################### +# generate a push function for an enum +sub ParseEnumPush($$) +{ + my($enum,$name) = @_; + my($type_fn) = $enum->{BASE_TYPE}; + + start_flags($enum); + pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; + end_flags($enum); +} + +##################################################################### +# generate a pull function for an enum +sub ParseEnumPull($$) +{ + my($enum,$name) = @_; + my($type_fn) = $enum->{BASE_TYPE}; + my($type_v_decl) = mapType($type_fn); + + pidl "$type_v_decl v;"; + start_flags($enum); + pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; + pidl "*r = v;"; + + end_flags($enum); +} + +##################################################################### +# generate a print function for an enum +sub ParseEnumPrint($$) +{ + my($enum,$name) = @_; + + pidl "const char *val = NULL;"; + pidl ""; + + start_flags($enum); + + pidl "switch (r) {"; + indent; + my $els = \@{$enum->{ELEMENTS}}; + foreach my $i (0 .. $#{$els}) { + my $e = ${$els}[$i]; + chomp $e; + if ($e =~ /^(.*)=/) { + $e = $1; + } + pidl "case $e: val = \"$e\"; break;"; + } + + deindent; + pidl "}"; + + pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);"; + + end_flags($enum); +} + +sub DeclEnum($) +{ + my ($e,$t) = @_; + return "enum $e->{NAME} " . + ($t eq "pull"?"*":"") . "r"; +} + +$typefamily{ENUM} = { + DECL => \&DeclEnum, + PUSH_FN_BODY => \&ParseEnumPush, + PULL_FN_BODY => \&ParseEnumPull, + PRINT_FN_BODY => \&ParseEnumPrint, +}; + +##################################################################### +# generate a push function for a bitmap +sub ParseBitmapPush($$) +{ + my($bitmap,$name) = @_; + my($type_fn) = $bitmap->{BASE_TYPE}; + + start_flags($bitmap); + + pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; + + end_flags($bitmap); +} + +##################################################################### +# generate a pull function for an bitmap +sub ParseBitmapPull($$) +{ + my($bitmap,$name) = @_; + my $type_fn = $bitmap->{BASE_TYPE}; + my($type_decl) = mapType($bitmap->{BASE_TYPE}); + + pidl "$type_decl v;"; + start_flags($bitmap); + pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; + pidl "*r = v;"; + + end_flags($bitmap); +} + +##################################################################### +# generate a print function for an bitmap +sub ParseBitmapPrintElement($$$) +{ + my($e,$bitmap,$name) = @_; + my($type_decl) = mapType($bitmap->{BASE_TYPE}); + my($type_fn) = $bitmap->{BASE_TYPE}; + my($flag); + + if ($e =~ /^(\w+) .*$/) { + $flag = "$1"; + } else { + die "Bitmap: \"$name\" invalid Flag: \"$e\""; + } + + pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);"; +} + +##################################################################### +# generate a print function for an bitmap +sub ParseBitmapPrint($$) +{ + my($bitmap,$name) = @_; + my($type_decl) = mapType($bitmap->{TYPE}); + my($type_fn) = $bitmap->{BASE_TYPE}; + + start_flags($bitmap); + + pidl "ndr_print_$type_fn(ndr, name, r);"; + + pidl "ndr->depth++;"; + foreach my $e (@{$bitmap->{ELEMENTS}}) { + ParseBitmapPrintElement($e, $bitmap, $name); + } + pidl "ndr->depth--;"; + + end_flags($bitmap); +} + +sub DeclBitmap($$) +{ + my ($e,$t) = @_; + return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e->{DATA})) . + ($t eq "pull"?" *":" ") . "r"; +} + +$typefamily{BITMAP} = { + DECL => \&DeclBitmap, + PUSH_FN_BODY => \&ParseBitmapPush, + PULL_FN_BODY => \&ParseBitmapPull, + PRINT_FN_BODY => \&ParseBitmapPrint, +}; + +##################################################################### +# generate a struct print function +sub ParseStructPrint($$) +{ + my($struct,$name) = @_; + + return unless defined $struct->{ELEMENTS}; + + my $env = GenerateStructEnv($struct); + + foreach my $e (@{$struct->{ELEMENTS}}) { + DeclareArrayVariables($e); + } + + pidl "ndr_print_struct(ndr, name, \"$name\");"; + + start_flags($struct); + + pidl "ndr->depth++;"; + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPrint($e, "r->$e->{NAME}", $env); + } + pidl "ndr->depth--;"; + + end_flags($struct); +} + +sub DeclarePtrVariables($) +{ + my $e = shift; + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER" and + not ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP")) { + pidl "uint32_t _ptr_$e->{NAME};"; + last; + } + } +} + +sub DeclareArrayVariables($) +{ + my $e = shift; + + foreach my $l (@{$e->{LEVELS}}) { + next if has_fast_array($e,$l); + next if is_charset_array($e,$l); + if ($l->{TYPE} eq "ARRAY") { + pidl "uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};"; + } + } +} + +sub need_decl_mem_ctx($$) +{ + my $e = shift; + my $l = shift; + + return 0 if has_fast_array($e,$l); + return 0 if is_charset_array($e,$l); + return 1 if (($l->{TYPE} eq "ARRAY") and not $l->{IS_FIXED}); + + if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { + my $nl = GetNextLevel($e, $l); + my $next_is_array = ($nl->{TYPE} eq "ARRAY"); + my $next_is_string = (($nl->{TYPE} eq "DATA") and + ($nl->{DATA_TYPE} eq "string")); + return 0 if ($next_is_array or $next_is_string); + } + return 1 if ($l->{TYPE} eq "POINTER"); + + return 0; +} + +sub DeclareMemCtxVariables($) +{ + my $e = shift; + foreach my $l (@{$e->{LEVELS}}) { + if (need_decl_mem_ctx($e, $l)) { + pidl "TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};"; + } + } +} + +##################################################################### +# parse a struct - pull side +sub ParseStructPull($$) +{ + my($struct,$name) = @_; + + return unless defined $struct->{ELEMENTS}; + + my $env = GenerateStructEnv($struct); + + # declare any internal pointers we need + foreach my $e (@{$struct->{ELEMENTS}}) { + DeclarePtrVariables($e); + DeclareArrayVariables($e); + DeclareMemCtxVariables($e); + } + + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base}); + + start_flags($struct); + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + + if (defined $struct->{SURROUNDING_ELEMENT}) { + pidl "NDR_CHECK(ndr_pull_array_size(ndr, &r->$struct->{SURROUNDING_ELEMENT}->{NAME}));"; + } + + pidl "NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));"; + + if (defined($struct->{PROPERTIES}{relative_base})) { + # set the current offset as base for relative pointers + # and store it based on the toplevel struct/union + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));"; + } + + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPull($e, "ndr", "r->", $env, 1, 0); + } + + add_deferred(); + + deindent; + pidl "}"; + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + if (defined($struct->{PROPERTIES}{relative_base})) { + # retrieve the current offset as base for relative pointers + # based on the toplevel struct/union + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));"; + } + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPull($e, "ndr", "r->", $env, 0, 1); + } + + add_deferred(); + + deindent; + pidl "}"; + + end_flags($struct); + # restore the old relative_base_offset + pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base}); +} + +##################################################################### +# calculate size of ndr struct +sub ParseStructNdrSize($) +{ + my $t = shift; + my $sizevar; + + if (my $flags = has_property($t, "flag")) { + pidl "flags |= $flags;"; + } + pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});"; +} + +sub DeclStruct($) +{ + my ($e,$t) = @_; + return ($t ne "pull"?"const ":"") . "struct $e->{NAME} *r"; +} + +sub ArgsStructNdrSize($) +{ + my $d = shift; + return "const struct $d->{NAME} *r, int flags"; +} + +$typefamily{STRUCT} = { + PUSH_FN_BODY => \&ParseStructPush, + DECL => \&DeclStruct, + PULL_FN_BODY => \&ParseStructPull, + PRINT_FN_BODY => \&ParseStructPrint, + SIZE_FN_BODY => \&ParseStructNdrSize, + SIZE_FN_ARGS => \&ArgsStructNdrSize, +}; + +##################################################################### +# calculate size of ndr struct +sub ParseUnionNdrSize($) +{ + my $t = shift; + my $sizevar; + + if (my $flags = has_property($t, "flag")) { + pidl "flags |= $flags;"; + } + + pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});"; +} + +##################################################################### +# parse a union - push side +sub ParseUnionPush($$) +{ + my ($e,$name) = @_; + my $have_default = 0; + + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base}); + pidl "int level;"; + + start_flags($e); + + pidl "level = ndr_push_get_switch_value(ndr, r);"; + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + + if (defined($e->{SWITCH_TYPE})) { + pidl "NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));"; + } + + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + if ($el->{CASE} eq "default") { + $have_default = 1; + } + pidl "$el->{CASE}:"; + + if ($el->{TYPE} ne "EMPTY") { + indent; + if (defined($e->{PROPERTIES}{relative_base})) { + pidl "NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));"; + # set the current offset as base for relative pointers + # and store it based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));"; + } + DeclareArrayVariables($el); + ParseElementPush($el, "ndr", "r->", {}, 1, 0); + deindent; + } + pidl "break;"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + } + deindent; + pidl "}"; + deindent; + pidl "}"; + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + if (defined($e->{PROPERTIES}{relative_base})) { + # retrieve the current offset as base for relative pointers + # based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));"; + } + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + pidl "$el->{CASE}:"; + if ($el->{TYPE} ne "EMPTY") { + indent; + ParseElementPush($el, "ndr", "r->", {}, 0, 1); + deindent; + } + pidl "break;"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + } + deindent; + pidl "}"; + + deindent; + pidl "}"; + end_flags($e); + # restore the old relative_base_offset + pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); +} + +##################################################################### +# print a union +sub ParseUnionPrint($$) +{ + my ($e,$name) = @_; + my $have_default = 0; + + pidl "int level = ndr_print_get_switch_value(ndr, r);"; + + foreach my $el (@{$e->{ELEMENTS}}) { + DeclareArrayVariables($el); + } + + pidl "ndr_print_union(ndr, name, level, \"$name\");"; + start_flags($e); + + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + if ($el->{CASE} eq "default") { + $have_default = 1; + } + pidl "$el->{CASE}:"; + if ($el->{TYPE} ne "EMPTY") { + indent; + ParseElementPrint($el, "r->$el->{NAME}", {}); + deindent; + } + pidl "break;"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\tndr_print_bad_level(ndr, name, level);"; + } + deindent; + pidl "}"; + + end_flags($e); +} + +##################################################################### +# parse a union - pull side +sub ParseUnionPull($$) +{ + my ($e,$name) = @_; + my $have_default = 0; + my $switch_type = $e->{SWITCH_TYPE}; + + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base}); + pidl "int level;"; + if (defined($switch_type)) { + if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) { + $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)); + } + pidl mapType($switch_type) . " _level;"; + } + + my %double_cases = (); + foreach my $el (@{$e->{ELEMENTS}}) { + next if ($el->{TYPE} eq "EMPTY"); + next if ($double_cases{"$el->{NAME}"}); + DeclareMemCtxVariables($el); + $double_cases{"$el->{NAME}"} = 1; + } + + start_flags($e); + + pidl "level = ndr_pull_get_switch_value(ndr, r);"; + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + + if (defined($switch_type)) { + pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));"; + pidl "if (_level != level) {"; + pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $name\", _level);"; + pidl "}"; + } + + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + if ($el->{CASE} eq "default") { + $have_default = 1; + } + pidl "$el->{CASE}: {"; + + if ($el->{TYPE} ne "EMPTY") { + indent; + DeclarePtrVariables($el); + DeclareArrayVariables($el); + if (defined($e->{PROPERTIES}{relative_base})) { + pidl "NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));"; + # set the current offset as base for relative pointers + # and store it based on the toplevel struct/union + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));"; + } + ParseElementPull($el, "ndr", "r->", {}, 1, 0); + deindent; + } + pidl "break; }"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + } + deindent; + pidl "}"; + deindent; + pidl "}"; + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + if (defined($e->{PROPERTIES}{relative_base})) { + # retrieve the current offset as base for relative pointers + # based on the toplevel struct/union + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));"; + } + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + pidl "$el->{CASE}:"; + if ($el->{TYPE} ne "EMPTY") { + indent; + ParseElementPull($el, "ndr", "r->", {}, 0, 1); + deindent; + } + pidl "break;"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + } + deindent; + pidl "}"; + + deindent; + pidl "}"; + + add_deferred(); + + end_flags($e); + # restore the old relative_base_offset + pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); +} + +sub DeclUnion($$) +{ + my ($e,$t) = @_; + return ($t ne "pull"?"const ":"") . "union $e->{NAME} *r"; +} + +sub ArgsUnionNdrSize($) +{ + my $d = shift; + return "const union $d->{NAME} *r, uint32_t level, int flags"; +} + +$typefamily{UNION} = { + PUSH_FN_BODY => \&ParseUnionPush, + DECL => \&DeclUnion, + PULL_FN_BODY => \&ParseUnionPull, + PRINT_FN_BODY => \&ParseUnionPrint, + SIZE_FN_ARGS => \&ArgsUnionNdrSize, + SIZE_FN_BODY => \&ParseUnionNdrSize, +}; + +##################################################################### +# parse a typedef - push side +sub ParseTypedefPush($) +{ + my($e) = shift; + + my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push"); + pidl fn_prefix($e) . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)"; + + pidl "{"; + indent; + $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $e->{NAME}); + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl "";; +} + +##################################################################### +# parse a typedef - pull side +sub ParseTypedefPull($) +{ + my($e) = shift; + + my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull"); + + pidl fn_prefix($e) . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)"; + + pidl "{"; + indent; + $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $e->{NAME}); + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse a typedef - print side +sub ParseTypedefPrint($) +{ + my($e) = shift; + + my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print"); + + pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; + pidl "{"; + indent; + $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME}); + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +## calculate the size of a structure +sub ParseTypedefNdrSize($) +{ + my($t) = shift; + + my $tf = $typefamily{$t->{DATA}->{TYPE}}; + my $args = $tf->{SIZE_FN_ARGS}->($t); + + pidl "size_t ndr_size_$t->{NAME}($args)"; + pidl "{"; + indent; + $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t); + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse a function - print side +sub ParseFunctionPrint($) +{ + my($fn) = shift; + + return if has_property($fn, "noprint"); + + pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; + pidl "{"; + indent; + + foreach my $e (@{$fn->{ELEMENTS}}) { + DeclareArrayVariables($e); + } + + pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");"; + pidl "ndr->depth++;"; + + pidl "if (flags & NDR_SET_VALUES) {"; + pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;"; + pidl "}"; + + pidl "if (flags & NDR_IN) {"; + indent; + pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");"; + pidl "ndr->depth++;"; + + my $env = GenerateFunctionInEnv($fn); + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/in/,@{$e->{DIRECTION}})) { + ParseElementPrint($e, "r->in.$e->{NAME}", $env); + } + } + pidl "ndr->depth--;"; + deindent; + pidl "}"; + + pidl "if (flags & NDR_OUT) {"; + indent; + pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");"; + pidl "ndr->depth++;"; + + $env = GenerateFunctionOutEnv($fn); + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/out/,@{$e->{DIRECTION}})) { + ParseElementPrint($e, "r->out.$e->{NAME}", $env); + } + } + if ($fn->{RETURN_TYPE}) { + pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);"; + } + pidl "ndr->depth--;"; + deindent; + pidl "}"; + + pidl "ndr->depth--;"; + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse a function +sub ParseFunctionPush($) +{ + my($fn) = shift; + + return if has_property($fn, "nopush"); + + pidl fn_prefix($fn) . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)"; + pidl "{"; + indent; + + foreach my $e (@{$fn->{ELEMENTS}}) { + DeclareArrayVariables($e); + } + + pidl "if (flags & NDR_IN) {"; + indent; + + my $env = GenerateFunctionInEnv($fn); + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/in/,@{$e->{DIRECTION}})) { + ParseElementPush($e, "ndr", "r->in.", $env, 1, 1); + } + } + + deindent; + pidl "}"; + + pidl "if (flags & NDR_OUT) {"; + indent; + + $env = GenerateFunctionOutEnv($fn); + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/out/,@{$e->{DIRECTION}})) { + ParseElementPush($e, "ndr", "r->out.", $env, 1, 1); + } + } + + if ($fn->{RETURN_TYPE}) { + pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));"; + } + + deindent; + pidl "}"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl ""; +} + +sub AllocateArrayLevel($$$$$) +{ + my ($e,$l,$ndr,$env,$size) = @_; + + my $var = ParseExpr($e->{NAME}, $env); + + check_null_pointer($size); + my $pl = GetPrevLevel($e, $l); + if (defined($pl) and + $pl->{TYPE} eq "POINTER" and + $pl->{POINTER_TYPE} eq "ref" + and not $l->{IS_ZERO_TERMINATED}) { + pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; + pidl "\tNDR_PULL_ALLOC_N($ndr, $var, $size);"; + pidl "}"; + } else { + pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);"; + } + + if (grep(/in/,@{$e->{DIRECTION}}) and + grep(/out/,@{$e->{DIRECTION}}) and + $pl->{POINTER_TYPE} eq "ref") { + pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));"; + } +} + +##################################################################### +# parse a function +sub ParseFunctionPull($) +{ + my($fn) = shift; + + return if has_property($fn, "nopull"); + + # pull function args + pidl fn_prefix($fn) . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)"; + pidl "{"; + indent; + + # declare any internal pointers we need + foreach my $e (@{$fn->{ELEMENTS}}) { + DeclarePtrVariables($e); + DeclareArrayVariables($e); + } + + my %double_cases = (); + foreach my $e (@{$fn->{ELEMENTS}}) { + next if ($e->{TYPE} eq "EMPTY"); + next if ($double_cases{"$e->{NAME}"}); + DeclareMemCtxVariables($e); + $double_cases{"$e->{NAME}"} = 1; + } + + pidl "if (flags & NDR_IN) {"; + indent; + + # auto-init the out section of a structure. I originally argued that + # this was a bad idea as it hides bugs, but coping correctly + # with initialisation and not wiping ref vars is turning + # out to be too tricky (tridge) + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless grep(/out/, @{$e->{DIRECTION}}); + pidl "ZERO_STRUCT(r->out);"; + pidl ""; + last; + } + + my $env = GenerateFunctionInEnv($fn); + + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/in/, @{$e->{DIRECTION}})); + ParseElementPull($e, "ndr", "r->in.", $env, 1, 1); + } + + # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's + # own flag rather then be in NDR_IN ? + + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/out/, @{$e->{DIRECTION}})); + next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and + $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref"); + next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and + ($e->{LEVELS}[1]->{DATA_TYPE} eq "string")); + next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY") + and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}); + + if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { + my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env); + check_null_pointer($size); + + pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"; + + if (grep(/in/, @{$e->{DIRECTION}})) { + pidl "memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));"; + } else { + pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));"; + } + } else { + pidl "NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});"; + + if (grep(/in/, @{$e->{DIRECTION}})) { + pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};"; + } else { + pidl "ZERO_STRUCTP(r->out.$e->{NAME});"; + } + } + } + + add_deferred(); + deindent; + pidl "}"; + + pidl "if (flags & NDR_OUT) {"; + indent; + + $env = GenerateFunctionOutEnv($fn); + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless grep(/out/, @{$e->{DIRECTION}}); + ParseElementPull($e, "ndr", "r->out.", $env, 1, 1); + } + + if ($fn->{RETURN_TYPE}) { + pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));"; + } + + add_deferred(); + deindent; + pidl "}"; + + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# produce a function call table +sub FunctionTable($) +{ + my($interface) = shift; + my $count = 0; + my $uname = uc $interface->{NAME}; + + $count = $#{$interface->{FUNCTIONS}}+1; + + return if ($count == 0); + + pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {"; + $count = 0; + foreach my $d (@{$interface->{FUNCTIONS}}) { + next if not defined($d->{OPNUM}); + pidl "\t{"; + pidl "\t\t\"$d->{NAME}\","; + pidl "\t\tsizeof(struct $d->{NAME}),"; + pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},"; + pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},"; + pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}"; + pidl "\t},"; + $count++; + } + pidl "\t{ NULL, 0, NULL, NULL, NULL }"; + pidl "};"; + pidl ""; + + pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {"; + foreach my $ep (@{$interface->{ENDPOINTS}}) { + pidl "\t$ep, "; + } + my $endpoint_count = $#{$interface->{ENDPOINTS}}+1; + + pidl "};"; + pidl ""; + + pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {"; + pidl "\t.count\t= $endpoint_count,"; + pidl "\t.names\t= $interface->{NAME}\_endpoint_strings"; + pidl "};"; + pidl ""; + + if (! defined $interface->{PROPERTIES}->{authservice}) { + $interface->{PROPERTIES}->{authservice} = "\"host\""; + } + + my @a = split / /, $interface->{PROPERTIES}->{authservice}; + my $authservice_count = $#a + 1; + + pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {"; + foreach my $ap (@a) { + pidl "\t$ap, "; + } + pidl "};"; + pidl ""; + + pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {"; + pidl "\t.count\t= $endpoint_count,"; + pidl "\t.names\t= $interface->{NAME}\_authservice_strings"; + pidl "};"; + pidl ""; + + pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {"; + pidl "\t.name\t\t= \"$interface->{NAME}\","; + pidl "\t.uuid\t\t= DCERPC_$uname\_UUID,"; + pidl "\t.if_version\t= DCERPC_$uname\_VERSION,"; + pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,"; + pidl "\t.num_calls\t= $count,"; + pidl "\t.calls\t\t= $interface->{NAME}\_calls,"; + pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,"; + pidl "\t.authservices\t= &$interface->{NAME}\_authservices"; + pidl "};"; + pidl ""; + + pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)"; + pidl "{"; + pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});"; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse the interface definitions +sub ParseInterface($$) +{ + my($interface,$needed) = @_; + + # Typedefs + foreach my $d (@{$interface->{TYPEDEFS}}) { + ($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d); + ($needed->{"pull_$d->{NAME}"}) && ParseTypedefPull($d); + ($needed->{"print_$d->{NAME}"}) && ParseTypedefPrint($d); + + # Make sure we don't generate a function twice... + $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = + $needed->{"print_$d->{NAME}"} = 0; + + ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypedefNdrSize($d); + } + + # Functions + foreach my $d (@{$interface->{FUNCTIONS}}) { + ($needed->{"push_$d->{NAME}"}) && ParseFunctionPush($d); + ($needed->{"pull_$d->{NAME}"}) && ParseFunctionPull($d); + ($needed->{"print_$d->{NAME}"}) && ParseFunctionPrint($d); + + # Make sure we don't generate a function twice... + $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = + $needed->{"print_$d->{NAME}"} = 0; + } + + FunctionTable($interface); +} + +sub RegistrationFunction($$) +{ + my ($idl,$filename) = @_; + + $filename =~ /.*\/ndr_(.*).c/; + my $basename = $1; + pidl "NTSTATUS dcerpc_$basename\_init(void)"; + pidl "{"; + indent; + pidl "NTSTATUS status = NT_STATUS_OK;"; + foreach my $interface (@{$idl}) { + next if $interface->{TYPE} ne "INTERFACE"; + + my $count = ($#{$interface->{FUNCTIONS}}+1); + + next if ($count == 0); + + pidl "status = dcerpc_ndr_$interface->{NAME}_init();"; + pidl "if (NT_STATUS_IS_ERR(status)) {"; + pidl "\treturn status;"; + pidl "}"; + pidl ""; + } + pidl "return status;"; + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse a parsed IDL structure back into an IDL file +sub Parse($$) +{ + my($ndr,$filename) = @_; + + $tabs = ""; + my $h_filename = $filename; + $res = ""; + + if ($h_filename =~ /(.*)\.c/) { + $h_filename = "$1.h"; + } + + pidl "/* parser auto-generated by pidl */"; + pidl ""; + pidl "#include \"includes.h\""; + pidl "#include \"librpc/gen_ndr/ndr_misc.h\""; + pidl "#include \"librpc/gen_ndr/ndr_dcerpc.h\""; + pidl "#include \"$h_filename\""; + pidl ""; + + my %needed = (); + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed); + } + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && ParseInterface($x, \%needed); + } + + RegistrationFunction($ndr, $filename); + + return $res; +} + +sub NeededFunction($$) +{ + my ($fn,$needed) = @_; + $needed->{"pull_$fn->{NAME}"} = 1; + $needed->{"push_$fn->{NAME}"} = 1; + $needed->{"print_$fn->{NAME}"} = 1; + foreach my $e (@{$fn->{ELEMENTS}}) { + $e->{PARENT} = $fn; + unless(defined($needed->{"pull_$e->{TYPE}"})) { + $needed->{"pull_$e->{TYPE}"} = 1; + } + unless(defined($needed->{"push_$e->{TYPE}"})) { + $needed->{"push_$e->{TYPE}"} = 1; + } + unless(defined($needed->{"print_$e->{TYPE}"})) { + $needed->{"print_$e->{TYPE}"} = 1; + } + } +} + +sub NeededTypedef($$) +{ + my ($t,$needed) = @_; + if (has_property($t, "public")) { + $needed->{"pull_$t->{NAME}"} = not has_property($t, "nopull"); + $needed->{"push_$t->{NAME}"} = not has_property($t, "nopush"); + $needed->{"print_$t->{NAME}"} = not has_property($t, "noprint"); + } + + if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") { + if (has_property($t, "gensize")) { + $needed->{"ndr_size_$t->{NAME}"} = 1; + } + + for my $e (@{$t->{DATA}->{ELEMENTS}}) { + $e->{PARENT} = $t->{DATA}; + if ($needed->{"pull_$t->{NAME}"} and + not defined($needed->{"pull_$e->{TYPE}"})) { + $needed->{"pull_$e->{TYPE}"} = 1; + } + if ($needed->{"push_$t->{NAME}"} and + not defined($needed->{"push_$e->{TYPE}"})) { + $needed->{"push_$e->{TYPE}"} = 1; + } + if ($needed->{"print_$t->{NAME}"} and + not defined($needed->{"print_$e->{TYPE}"})) { + $needed->{"print_$e->{TYPE}"} = 1; + } + } + } +} + +##################################################################### +# work out what parse functions are needed +sub NeededInterface($$) +{ + my ($interface,$needed) = @_; + foreach my $d (@{$interface->{FUNCTIONS}}) { + NeededFunction($d, $needed); + } + foreach my $d (reverse @{$interface->{TYPEDEFS}}) { + NeededTypedef($d, $needed); + } +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm new file mode 100644 index 0000000000..a8c159572b --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm @@ -0,0 +1,322 @@ +################################################### +# server boilerplate generator +# Copyright tridge@samba.org 2003 +# Copyright metze@samba.org 2004 +# released under the GNU GPL + +package Parse::Pidl::Samba::NDR::Server; + +use strict; + +my($res); + +sub pidl($) +{ + $res .= shift; +} + + +##################################################### +# generate the switch statement for function dispatch +sub gen_dispatch_switch($) +{ + my $interface = shift; + + foreach my $fn (@{$interface->{FUNCTIONS}}) { + next if not defined($fn->{OPNUM}); + + pidl "\tcase $fn->{OPNUM}: {\n"; + pidl "\t\tstruct $fn->{NAME} *r2 = r;\n"; + pidl "\t\tif (DEBUGLEVEL >= 10) {\n"; + pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_IN, r2);\n"; + pidl "\t\t}\n"; + if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") { + pidl "\t\tr2->out.result = $fn->{NAME}(dce_call, mem_ctx, r2);\n"; + } else { + pidl "\t\t$fn->{NAME}(dce_call, mem_ctx, r2);\n"; + } + pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; + pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} will reply async\\n\"));\n"; + pidl "\t\t}\n"; + pidl "\t\tbreak;\n\t}\n"; + } +} + +##################################################### +# generate the switch statement for function reply +sub gen_reply_switch($) +{ + my $interface = shift; + + foreach my $fn (@{$interface->{FUNCTIONS}}) { + next if not defined($fn->{OPNUM}); + + pidl "\tcase $fn->{OPNUM}: {\n"; + pidl "\t\tstruct $fn->{NAME} *r2 = r;\n"; + pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; + pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} replied async\\n\"));\n"; + pidl "\t\t}\n"; + pidl "\t\tif (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {\n"; + pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n"; + pidl "\t\t}\n"; + pidl "\t\tif (dce_call->fault_code != 0) {\n"; + pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $fn->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n"; + pidl "\t\t}\n"; + pidl "\t\tbreak;\n\t}\n"; + } +} + +##################################################################### +# produce boilerplate code for a interface +sub Boilerplate_Iface($) +{ + my($interface) = shift; + my $name = $interface->{NAME}; + my $uname = uc $name; + my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}); + my $if_version = $interface->{PROPERTIES}->{version}; + + pidl " +static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface) +{ +#ifdef DCESRV_INTERFACE_$uname\_BIND + return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface); +#else + return NT_STATUS_OK; +#endif +} + +static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface) +{ +#ifdef DCESRV_INTERFACE_$uname\_UNBIND + DCESRV_INTERFACE_$uname\_UNBIND(context, iface); +#else + return; +#endif +} + +static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r) +{ + NTSTATUS status; + uint16_t opnum = dce_call->pkt.u.request.opnum; + + dce_call->fault_code = 0; + + if (opnum >= dcerpc_table_$name.num_calls) { + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + return NT_STATUS_NET_WRITE_FAULT; + } + + *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size); + NT_STATUS_HAVE_NO_MEMORY(*r); + + /* unravel the NDR for the packet */ + status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); + if (!NT_STATUS_IS_OK(status)) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + dce_call->fault_code = DCERPC_FAULT_NDR; + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) +{ + uint16_t opnum = dce_call->pkt.u.request.opnum; + + switch (opnum) { +"; + gen_dispatch_switch($interface); + +pidl " + default: + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + break; + } + + if (dce_call->fault_code != 0) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) +{ + uint16_t opnum = dce_call->pkt.u.request.opnum; + + switch (opnum) { +"; + gen_reply_switch($interface); + +pidl " + default: + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + break; + } + + if (dce_call->fault_code != 0) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r) +{ + NTSTATUS status; + uint16_t opnum = dce_call->pkt.u.request.opnum; + + status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); + if (!NT_STATUS_IS_OK(status)) { + dce_call->fault_code = DCERPC_FAULT_NDR; + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static const struct dcesrv_interface $name\_interface = { + .name = \"$name\", + .uuid = $uuid, + .if_version = $if_version, + .bind = $name\__op_bind, + .unbind = $name\__op_unbind, + .ndr_pull = $name\__op_ndr_pull, + .dispatch = $name\__op_dispatch, + .reply = $name\__op_reply, + .ndr_push = $name\__op_ndr_push +}; + +"; +} + +##################################################################### +# produce boilerplate code for an endpoint server +sub Boilerplate_Ep_Server($) +{ + my($interface) = shift; + my $name = $interface->{NAME}; + my $uname = uc $name; + + pidl " +static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server) +{ + int i; + + for (i=0;icount;i++) { + NTSTATUS ret; + const char *name = dcerpc_table_$name.endpoints->names[i]; + + ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL); + if (!NT_STATUS_IS_OK(ret)) { + DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name)); + return ret; + } + } + + return NT_STATUS_OK; +} + +static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version) +{ + if ($name\_interface.if_version == if_version && + strcmp($name\_interface.uuid, uuid)==0) { + memcpy(iface,&$name\_interface, sizeof(*iface)); + return True; + } + + return False; +} + +static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) +{ + if (strcmp($name\_interface.name, name)==0) { + memcpy(iface,&$name\_interface, sizeof(*iface)); + return True; + } + + return False; +} + +NTSTATUS dcerpc_server_$name\_init(void) +{ + NTSTATUS ret; + struct dcesrv_endpoint_server ep_server; + + /* fill in our name */ + ep_server.name = \"$name\"; + + /* fill in all the operations */ + ep_server.init_server = $name\__op_init_server; + + ep_server.interface_by_uuid = $name\__op_interface_by_uuid; + ep_server.interface_by_name = $name\__op_interface_by_name; + + /* register ourselves with the DCERPC subsystem. */ + ret = dcerpc_register_ep_server(&ep_server); + + if (!NT_STATUS_IS_OK(ret)) { + DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\")); + return ret; + } + + return ret; +} + +"; +} + +##################################################################### +# dcerpc server boilerplate from a parsed IDL structure +sub ParseInterface($) +{ + my($interface) = shift; + my $count = 0; + + if (!defined $interface->{PROPERTIES}->{uuid}) { + return $res; + } + + if (!defined $interface->{PROPERTIES}->{version}) { + $interface->{PROPERTIES}->{version} = "0.0"; + } + + foreach my $fn (@{$interface->{FUNCTIONS}}) { + if (defined($fn->{OPNUM})) { $count++; } + } + + if ($count == 0) { + return $res; + } + + $res .= "/* $interface->{NAME} - dcerpc server boilerplate generated by pidl */\n\n"; + Boilerplate_Iface($interface); + Boilerplate_Ep_Server($interface); + + return $res; +} + +sub Parse($$) +{ + my($ndr) = shift; + my($filename) = shift; + + $res = ""; + $res .= "/* server functions auto-generated by pidl */\n"; + $res .= "\n"; + + foreach my $x (@{$ndr}) { + ParseInterface($x) if ($x->{TYPE} eq "INTERFACE" and not defined($x->{PROPERTIES}{object})); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm new file mode 100644 index 0000000000..409095804f --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm @@ -0,0 +1,76 @@ +################################################### +# Samba4 parser generator for swig wrappers +# Copyright tpot@samba.org 2004,2005 +# released under the GNU GPL + +package Parse::Pidl::Samba::SWIG; + +use strict; + +sub pidl($) +{ + print OUT shift; +} + +##################################################################### +# rewrite autogenerated header file +sub RewriteHeader($$$) +{ + my($idl) = shift; + my($input) = shift; + my($output) = shift; + + open(IN, "<$input") || die "can't open $input for reading"; + open(OUT, ">$output") || die "can't open $output for writing"; + + pidl "%{\n"; + pidl "#define data_in in\n"; + pidl "#define data_out out\n"; + pidl "%}\n\n"; + + while() { + + # Rename dom_sid2 to dom_sid as we don't care about the difference + # for the swig wrappers. + + s/dom_sid2/dom_sid/g; + + # Copy structure and union definitions + + if (/^(struct|union) .*? {$/ .. /^\};$/) { + s/\} (in|out);/\} data_$1;/; # "in" is a Python keyword + pidl $_; + next; + } + + # Copy dcerpc functions + + pidl $_ if /^NTSTATUS dcerpc_.*?\(struct dcerpc_pipe/; + + # Copy interface definitions + + pidl $_ + if /^\#define DCERPC_.*?_UUID/ or /^\#define DCERPC_.*?_VERSION/; + } + + close(OUT); +} + +##################################################################### +# rewrite autogenerated header file +sub RewriteC($$$) +{ + my($idl) = shift; + my($input) = shift; + my($output) = shift; + + open(IN, "<$input") || die "can't open $input for reading"; + open(OUT, ">>$output") || die "can't open $output for writing"; + + while() { + } + + close(OUT); +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm new file mode 100644 index 0000000000..b9bfd83e41 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm @@ -0,0 +1,266 @@ +################################################### +# Trivial Parser Generator +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba::TDR; +use Parse::Pidl::Util qw(has_property ParseExpr is_constant); +use Data::Dumper; + +use strict; + +my $ret = ""; +my $tabs = ""; + +sub indent() { $tabs.="\t"; } +sub deindent() { $tabs = substr($tabs, 1); } +sub pidl($) { $ret .= $tabs.(shift)."\n"; } +sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } +sub static($) { my $p = shift; return("static ") unless ($p); return ""; } +sub printarg($) { + my $t = shift; + return(", const char *name") if ($t eq "print"); + return(""); +} + +sub ContainsArray($) +{ + my $e = shift; + foreach (@{$e->{ELEMENTS}}) { + next if (has_property($_, "charset") and + scalar(@{$_->{ARRAY_LEN}}) == 1); + return 1 if (defined($_->{ARRAY_LEN}) and + scalar(@{$_->{ARRAY_LEN}}) > 0); + } + return 0; +} + +sub ParserElement($$$) +{ + my ($e,$t,$env) = @_; + my $switch = ""; + my $array = ""; + my $name = ""; + + fatal($e,"Pointers not supported in TDR") if ($e->{POINTERS} > 0); + fatal($e,"size_is() not supported in TDR") if (has_property($e, "size_is")); + fatal($e,"length_is() not supported in TDR") if (has_property($e, "length_is")); + + if ($t eq "print") { + $name = ", \"$e->{NAME}\"$array"; + } + + if (has_property($e, "flag")) { + pidl "{"; + indent; + pidl "uint32_t saved_flags = tdr->flags;"; + pidl "tdr->flags |= $e->{PROPERTIES}->{flag};"; + } + + if (has_property($e, "charset")) { + fatal($e,"charset() on non-array element") unless (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0); + + my $len = @{$e->{ARRAY_LEN}}[0]; + if ($len eq "*") { $len = "-1"; } + pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));"; + return; + } + + + if (has_property($e, "switch_is")) { + $switch = ", " . ParseExpr($e->{PROPERTIES}->{switch_is}, $env); + } + + if (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0) { + my $len = ParseExpr($e->{ARRAY_LEN}[0], $env); + + if ($t eq "pull" and not is_constant($len)) { + pidl "TDR_ALLOC(tdr, v->$e->{NAME}, $len);" + } + + pidl "for (i = 0; i < $len; i++) {"; + indent; + $array = "[i]"; + } + + if (has_property($e, "value") && $t eq "push") { + pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env).";"; + } + + pidl "TDR_CHECK(tdr_$t\_$e->{TYPE}(tdr$name$switch, &v->$e->{NAME}$array));"; + + if ($array) { deindent; pidl "}"; } + + if (has_property($e, "flag")) { + pidl "tdr->flags = saved_flags;"; + deindent; + pidl "}"; + } +} + +sub ParserStruct($$$$) +{ + my ($e,$n,$t,$p) = @_; + + pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", struct $n *v)"; + pidl "{"; indent; + pidl "int i;" if (ContainsArray($e)); + + if ($t eq "print") { + pidl "tdr->print(tdr, \"\%-25s: struct $n\", name);"; + pidl "tdr->level++;"; + } + + my %env = map { $_->{NAME} => "v->$_->{NAME}" } @{$e->{ELEMENTS}}; + ParserElement($_, $t, \%env) foreach (@{$e->{ELEMENTS}}); + + if ($t eq "print") { + pidl "tdr->level--;"; + } + + pidl "return NT_STATUS_OK;"; + + deindent; pidl "}"; +} + +sub ParserUnion($$$$) +{ + my ($e,$n,$t,$p) = @_; + + pidl static($p)."NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".printarg($t).", int level, union $n *v)"; + pidl "{"; indent; + pidl "int i;" if (ContainsArray($e)); + + if ($t eq "print") { + pidl "tdr->print(tdr, \"\%-25s: union $n\", name);"; + pidl "tdr->level++;"; + } + + pidl "switch (level) {"; indent; + foreach (@{$e->{ELEMENTS}}) { + if (has_property($_, "case")) { + pidl "case " . $_->{PROPERTIES}->{case} . ":"; + } elsif (has_property($_, "default")) { + pidl "default:"; + } + indent; ParserElement($_, $t, {}); deindent; + pidl "break;"; + } + deindent; pidl "}"; + + if ($t eq "print") { + pidl "tdr->level--;"; + } + + pidl "return NT_STATUS_OK;\n"; + deindent; pidl "}"; +} + +sub ParserBitmap($$$$) +{ + my ($e,$n,$t,$p) = @_; + return if ($p); + pidl "#define tdr_$t\_$n tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e); +} + +sub ParserEnum($$$$) +{ + my ($e,$n,$t,$p) = @_; + my $bt = Parse::Pidl::Typelist::enum_type_fn($e); + + pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", enum $n *v)"; + pidl "{"; + if ($t eq "pull") { + pidl "\t$bt\_t r;"; + pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, \&r));"; + pidl "\t*v = r;"; + } elsif ($t eq "push") { + pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));"; + } elsif ($t eq "print") { + pidl "\t/* FIXME */"; + } + pidl "\treturn NT_STATUS_OK;"; + pidl "}"; +} + +sub ParserTypedef($$) +{ + my ($e,$t) = @_; + + return if (has_property($e, "no$t")); + + { STRUCT => \&ParserStruct, UNION => \&ParserUnion, + ENUM => \&ParserEnum, BITMAP => \&ParserBitmap + }->{$e->{DATA}->{TYPE}}($e->{DATA}, $e->{NAME}, $t, has_property($e, "public")); + + pidl ""; +} + +sub ParserInterface($) +{ + my $x = shift; + + foreach (@{$x->{DATA}}) { + next if ($_->{TYPE} ne "TYPEDEF"); + ParserTypedef($_, "pull"); + ParserTypedef($_, "push"); + ParserTypedef($_, "print"); + } +} + +sub Parser($$) +{ + my ($idl,$hdrname) = @_; + $ret = ""; + pidl "/* autogenerated by pidl */"; + pidl "#include \"includes.h\""; + pidl "#include \"$hdrname\""; + foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } + return $ret; +} + +sub HeaderInterface($$) +{ + my ($x,$outputdir) = @_; + + pidl "#ifndef __TDR_$x->{NAME}_HEADER__"; + pidl "#define __TDR_$x->{NAME}_HEADER__"; + + pidl "#include \"$outputdir/$x->{NAME}.h\""; + + foreach my $e (@{$x->{DATA}}) { + next unless ($e->{TYPE} eq "TYPEDEF"); + next unless has_property($e, "public"); + + my $switch = ""; + + $switch = ", int level" if ($e->{DATA}->{TYPE} eq "UNION"); + + if ($e->{DATA}->{TYPE} eq "BITMAP") { + # FIXME + } else { + my ($n, $d) = ($e->{NAME}, lc($e->{DATA}->{TYPE})); + pidl "NTSTATUS tdr_pull\_$n(struct tdr_pull *tdr$switch, $d $n *v);"; + pidl "NTSTATUS tdr_print\_$n(struct tdr_print *tdr, const char *name$switch, $d $n *v);"; + pidl "NTSTATUS tdr_push\_$n(struct tdr_push *tdr$switch, $d $n *v);"; + } + + pidl ""; + } + + pidl "#endif /* __TDR_$x->{NAME}_HEADER__ */"; +} + +sub Header($$) +{ + my ($idl,$outputdir) = @_; + $ret = ""; + pidl "/* Generated by pidl */"; + + foreach (@$idl) { + HeaderInterface($_, $outputdir) if ($_->{TYPE} eq "INTERFACE"); + } + return $ret; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm new file mode 100644 index 0000000000..eb71b6d707 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm @@ -0,0 +1,88 @@ +################################################### +# server template function generator +# Copyright tridge@samba.org 2003 +# released under the GNU GPL + +package Parse::Pidl::Samba::Template; + +use strict; + +my($res); + +##################################################################### +# produce boilerplate code for a interface +sub Template($) +{ + my($interface) = shift; + my($data) = $interface->{DATA}; + my $name = $interface->{NAME}; + + $res .= +"/* + Unix SMB/CIFS implementation. + + endpoint server for the $name pipe + + Copyright (C) YOUR NAME HERE YEAR + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include \"includes.h\" +#include \"rpc_server/dcerpc_server.h\" +#include \"librpc/gen_ndr/ndr_$name.h\" + +"; + + foreach my $d (@{$data}) { + if ($d->{TYPE} eq "FUNCTION") { + my $fname = $d->{NAME}; + $res .= +" +/* + $fname +*/ +static $d->{RETURN_TYPE} $fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, + struct $fname *r) +{ + DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR); +} + +"; + } + } + + $res .= +" +/* include the generated boilerplate */ +#include \"librpc/gen_ndr/ndr_$name\_s.c\" +" +} + + +##################################################################### +# parse a parsed IDL structure back into an IDL file +sub Parse($) +{ + my($idl) = shift; + $res = ""; + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && + Template($x); + } + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Test.pm b/source4/pidl/lib/Parse/Pidl/Test.pm new file mode 100644 index 0000000000..34ea80c95c --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Test.pm @@ -0,0 +1,169 @@ +# Simple system for running tests against pidl +# (C) 2005 Jelmer Vernooij +# Published under the GNU General Public License + +package Parse::Pidl::Test; + +use strict; +use Parse::Pidl::Util; +use Getopt::Long; + +my $cc = $ENV{CC}; +my @cflags = split / /, $ENV{CFLAGS}; +my @ldflags = split / /, $ENV{LDFLAGS}; + +$cc = "cc" if ($cc eq ""); + +sub generate_cfile($$$) +{ + my ($filename, $fragment, $incfiles) = @_; + + unless (open (OUT, ">$filename")) { + print STDERR "Unable to open $filename\n"; + return -1; + } + print OUT ' +/* This file was autogenerated. All changes made will be lost! */ +#include "include/includes.h" +'; + + foreach (@$incfiles) { + print OUT "#include \"$_\"\n"; + } + + print OUT ' +int main(int argc, char **argv) +{ + TALLOC_CTX *mem_ctx = talloc_init(NULL); + '; + print OUT $fragment; + print OUT "\treturn 0;\n}\n"; + close OUT; + + return 0; +} + +sub generate_idlfile($$) +{ + my ($filename,$fragment) = @_; + + unless (open(OUT, ">$filename")) { + print STDERR "Unable to open $filename\n"; + return -1; + } + + print OUT ' +[uuid("1-2-3-4-5")] interface test_if +{ +'; + print OUT $fragment; + print OUT "\n}\n"; + close OUT; + + return 0; +} + +sub compile_idl($$$) +{ + my ($filename,$idl_path, $idlargs) = @_; + + my @args = @$idlargs; + push (@args, $filename); + + unless (system($idl_path, @args) == 0) { + print STDERR "Error compiling IDL file $filename: $!\n"; + return -1; + } +} + +sub compile_cfile($) +{ + my ($filename) = @_; + + return system($cc, @cflags, '-I.', '-Iinclude', '-c', $filename); +} + +sub link_files($$) +{ + my ($exe_name,$objs) = @_; + + return system($cc, @ldflags, '-Lbin', '-lrpc', '-o', $exe_name, @$objs); +} + +sub test_idl($$$$) +{ + my ($name,$settings,$idl,$c) = @_; + + $| = 1; + + print "Running $name... "; + + my $outputdir = $settings->{OutputDir}; + + my $c_filename = $outputdir."/".$name."_test.c"; + my $idl_filename = $outputdir."/".$name."_idl.idl"; + my $exe_filename = $outputdir."/".$name."_exe"; + + return -1 if (generate_cfile($c_filename, $c, $settings->{IncludeFiles}) == -1); + + return -1 if (generate_idlfile($idl_filename, $idl) == -1); + + return -1 if (compile_idl($idl_filename, $settings->{'IDL-Compiler'}, $settings->{'IDL-Arguments'}) == -1); + + my @srcs = ($c_filename); + push (@srcs, @{$settings->{'ExtraFiles'}}); + + foreach (@srcs) { + next unless /\.c$/; + return -1 if (compile_cfile($_) == -1); + } + + my @objs; + foreach (@srcs) { + if (/\.c$/) { s/\.c$/\.o/g; } + push(@objs, $_); + } + + return -1 if (link_files($exe_filename, \@objs) == -1); + + my $ret = system("./$exe_filename"); + if ($ret != 0) { + $ret = $? >> 8; + print "failed with return value $ret\n"; + return $ret; + } + + unless ($settings->{Keep}) { + unlink(@srcs, @objs, $exe_filename, $idl_filename); + } + + print "Ok\n"; + + return $ret; +} + +sub GetSettings($) +{ + my $settings = { + OutputDir => ".", + 'IDL-Compiler' => "./pidl" + }; + + my %opts = (); + GetOptions('idl-compiler=s' => \$settings->{'IDL-Compiler'}, + 'outputdir=s' => \$settings->{OutputDir}, + 'keep' => \$settings->{Keep}, + 'help' => sub { ShowHelp(); exit 1; } ); + + return %$settings; +} + +sub ShowHelp() +{ + print " --idl-compiler=PATH-TO-PIDL Override path to IDL compiler\n"; + print " --outputdir=OUTPUTDIR Write temporary files to OUTPUTDIR rather then .\n"; + print " --keep Keep intermediate files after running test"; + print " --help Show this help message\n"; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm new file mode 100644 index 0000000000..10a4baf7e7 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -0,0 +1,336 @@ +################################################### +# Samba4 parser generator for IDL structures +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Typelist; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(hasType getType mapType); + +use Parse::Pidl::Util qw(has_property); +use strict; + +my %typedefs = (); + +# a list of known scalar types +my $scalars = { + # 0 byte types + "void" => { + C_TYPE => "void", + IS_REFERENCE => 0, + NDR_ALIGN => 0 + }, + + # 1 byte types + "char" => { + C_TYPE => "char", + IS_REFERENCE => 0, + NDR_ALIGN => 1 + }, + "int8" => { + C_TYPE => "int8_t", + IS_REFERENCE => 0, + NDR_ALIGN => 1 + }, + "uint8" => { + C_TYPE => "uint8_t", + IS_REFERENCE => 0, + NDR_ALIGN => 1 + }, + + # 2 byte types + "int16" => { + C_TYPE => "int16_t", + IS_REFERENCE => 0, + NDR_ALIGN => 2 + }, + "uint16" => { C_TYPE => "uint16_t", + IS_REFERENCE => 0, + NDR_ALIGN => 2 + }, + + # 4 byte types + "int32" => { + C_TYPE => "int32_t", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + "uint32" => { C_TYPE => "uint32_t", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + + # 8 byte types + "hyper" => { + C_TYPE => "uint64_t", + IS_REFERENCE => 0, + NDR_ALIGN => 8 + }, + "dlong" => { + C_TYPE => "int64_t", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + "udlong" => { + C_TYPE => "uint64_t", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + "udlongr" => { + C_TYPE => "uint64_t", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + + # DATA_BLOB types + "DATA_BLOB" => { + C_TYPE => "DATA_BLOB", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + + # string types + "string" => { + C_TYPE => "const char *", + IS_REFERENCE => 1, + NDR_ALIGN => 4 #??? + }, + "string_array" => { + C_TYPE => "const char **", + IS_REFERENCE => 1, + NDR_ALIGN => 4 #??? + }, + + # time types + "time_t" => { + C_TYPE => "time_t", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + "NTTIME" => { + C_TYPE => "NTTIME", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + "NTTIME_1sec" => { + C_TYPE => "NTTIME", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + "NTTIME_hyper" => { + C_TYPE => "NTTIME", + IS_REFERENCE => 0, + NDR_ALIGN => 8 + }, + + + # error code types + "WERROR" => { + C_TYPE => "WERROR", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + "NTSTATUS" => { + C_TYPE => "NTSTATUS", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + "COMRESULT" => { + "C_TYPE" => "COMRESULT", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, + + # special types + "nbt_string" => { + C_TYPE => "const char *", + IS_REFERENCE => 1, + NDR_ALIGN => 4 #??? + }, + "ipv4address" => { + C_TYPE => "const char *", + IS_REFERENCE => 1, + NDR_ALIGN => 4 + } +}; + +# map from a IDL type to a C header type +sub mapScalarType($) +{ + my $name = shift; + + # it's a bug when a type is not in the list + # of known scalars or has no mapping + return $typedefs{$name}->{DATA}->{C_TYPE} if defined($typedefs{$name}) and defined($typedefs{$name}->{DATA}->{C_TYPE}); + + die("Unknown scalar type $name"); +} + +sub getScalarAlignment($) +{ + my $name = shift; + + # it's a bug when a type is not in the list + # of known scalars or has no mapping + return $scalars->{$name}{NDR_ALIGN} if defined($scalars->{$name}) and defined($scalars->{$name}{NDR_ALIGN}); + + die("Unknown scalar type $name"); +} + +sub addType($) +{ + my $t = shift; + $typedefs{$t->{NAME}} = $t; +} + +sub getType($) +{ + my $t = shift; + return undef if not hasType($t); + return $typedefs{$t}; +} + +sub typeIs($$) +{ + my $t = shift; + my $tt = shift; + + return 1 if (hasType($t) and getType($t)->{DATA}->{TYPE} eq $tt); + return 0; +} + +sub hasType($) +{ + my $t = shift; + return 1 if defined($typedefs{$t}); + return 0; +} + +sub is_scalar($) +{ + my $type = shift; + + return 0 unless(hasType($type)); + + if (my $dt = getType($type)->{DATA}->{TYPE}) { + return 1 if ($dt eq "SCALAR" or $dt eq "ENUM" or $dt eq "BITMAP"); + } + + return 0; +} + +sub scalar_is_reference($) +{ + my $name = shift; + + return $scalars->{$name}{IS_REFERENCE} if defined($scalars->{$name}) and defined($scalars->{$name}{IS_REFERENCE}); + return 0; +} + +sub RegisterScalars() +{ + foreach my $k (keys %{$scalars}) { + $typedefs{$k} = { + NAME => $k, + TYPE => "TYPEDEF", + DATA => $scalars->{$k} + }; + $typedefs{$k}->{DATA}->{TYPE} = "SCALAR"; + $typedefs{$k}->{DATA}->{NAME} = $k; + } +} + +my $aliases = { + "DWORD" => "uint32", + "int" => "int32", + "WORD" => "uint16", + "char" => "uint8", + "long" => "int32", + "short" => "int16", + "HYPER_T" => "hyper", + "HRESULT" => "COMRESULT", +}; + +sub RegisterAliases() +{ + foreach my $k (keys %{$aliases}) { + $typedefs{$k} = $typedefs{$aliases->{$k}}; + } +} + +sub enum_type_fn($) +{ + my $enum = shift; + if (has_property($enum->{PARENT}, "enum8bit")) { + return "uint8"; + } elsif (has_property($enum->{PARENT}, "v1_enum")) { + return "uint32"; + } + return "uint16"; +} + +sub bitmap_type_fn($) +{ + my $bitmap = shift; + + if (has_property($bitmap, "bitmap8bit")) { + return "uint8"; + } elsif (has_property($bitmap, "bitmap16bit")) { + return "uint16"; + } elsif (has_property($bitmap, "bitmap64bit")) { + return "hyper"; + } + return "uint32"; +} + +sub mapType($) +{ + my $t = shift; + die("Undef passed to mapType") unless defined($t); + my $dt; + + unless ($dt or ($dt = getType($t))) { + # Best guess + return "struct $t"; + } + return mapScalarType($t) if ($dt->{DATA}->{TYPE} eq "SCALAR"); + return "enum $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "ENUM"); + return "struct $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "STRUCT"); + return "struct $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "INTERFACE"); + return "union $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "UNION"); + + if ($dt->{DATA}->{TYPE} eq "BITMAP") { + return mapScalarType(bitmap_type_fn($dt->{DATA})); + } + + die("Unknown type $dt->{DATA}->{TYPE}"); +} + +sub LoadIdl($) +{ + my $idl = shift; + + foreach my $x (@{$idl}) { + next if $x->{TYPE} ne "INTERFACE"; + + # DCOM interfaces can be types as well + addType({ + NAME => $x->{NAME}, + TYPE => "TYPEDEF", + DATA => $x + }) if (has_property($x, "object")); + + foreach my $y (@{$x->{DATA}}) { + addType($y) if ( + $y->{TYPE} eq "TYPEDEF" + or $y->{TYPE} eq "DECLARE"); + } + } +} + +RegisterScalars(); +RegisterAliases(); + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm new file mode 100644 index 0000000000..8854be9d74 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -0,0 +1,149 @@ +################################################### +# utility functions to support pidl +# Copyright tridge@samba.org 2000 +# released under the GNU GPL +package Parse::Pidl::Util; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(has_property property_matches ParseExpr is_constant); + +use strict; + +##################################################################### +# flatten an array of arrays into a single array +sub FlattenArray2($) +{ + my $a = shift; + my @b; + for my $d (@{$a}) { + for my $d1 (@{$d}) { + push(@b, $d1); + } + } + return \@b; +} + +##################################################################### +# flatten an array of arrays into a single array +sub FlattenArray($) +{ + my $a = shift; + my @b; + for my $d (@{$a}) { + for my $d1 (@{$d}) { + push(@b, $d1); + } + } + return \@b; +} + +##################################################################### +# flatten an array of hashes into a single hash +sub FlattenHash($) +{ + my $a = shift; + my %b; + for my $d (@{$a}) { + for my $k (keys %{$d}) { + $b{$k} = $d->{$k}; + } + } + return \%b; +} + +##################################################################### +# a dumper wrapper to prevent dependence on the Data::Dumper module +# unless we actually need it +sub MyDumper($) +{ + require Data::Dumper; + my $s = shift; + return Data::Dumper::Dumper($s); +} + +##################################################################### +# see if a pidl property list contains a given property +sub has_property($$) +{ + my($e) = shift; + my($p) = shift; + + if (!defined $e->{PROPERTIES}) { + return undef; + } + + return $e->{PROPERTIES}->{$p}; +} + +##################################################################### +# see if a pidl property matches a value +sub property_matches($$$) +{ + my($e) = shift; + my($p) = shift; + my($v) = shift; + + if (!defined has_property($e, $p)) { + return undef; + } + + if ($e->{PROPERTIES}->{$p} =~ /$v/) { + return 1; + } + + return undef; +} + +# return 1 if the string is a C constant +sub is_constant($) +{ + my $s = shift; + if (defined $s && $s =~ /^\d/) { + return 1; + } + return 0; +} + +# return a "" quoted string, unless already quoted +sub make_str($) +{ + my $str = shift; + if (substr($str, 0, 1) eq "\"") { + return $str; + } + return "\"" . $str . "\""; +} + +# a hack to build on platforms that don't like negative enum values +my $useUintEnums = 0; +sub setUseUintEnums($) +{ + $useUintEnums = shift; +} +sub useUintEnums() +{ + return $useUintEnums; +} + +sub ParseExpr($$) +{ + my($expr,$varlist) = @_; + + die("Undefined value in ParseExpr") if not defined($expr); + + my @tokens = split /((?:[A-Za-z_])(?:(?:(?:[A-Za-z0-9_.])|(?:->))+))/, $expr; + my $ret = ""; + + foreach my $t (@tokens) { + if (defined($varlist->{$t})) { + $ret .= $varlist->{$t}; + } else { + $ret .= $t; + } + } + + return $ret; +} + +1; -- cgit From 2280017bbd8c21f4dc00f28692f57fe0692fcd8a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 22 Aug 2005 00:06:35 +0000 Subject: r9462: Fix locations for generating the yapp files (This used to be commit 714f96b9bf2c6271f23bfcd35c58d5bf7b29aae2) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 120 ++++++++++++++++++------------------- 1 file changed, 60 insertions(+), 60 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 7f7e5bcdca..a73451d142 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -1936,19 +1936,19 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "build/pidl/idl.yp" +#line 19 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "build/pidl/idl.yp" +#line 20 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'coclass', 7, sub -#line 24 "build/pidl/idl.yp" +#line 24 "idl.yp" {$_[3] => { "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -1964,13 +1964,13 @@ sub [#Rule 6 'interface_names', 4, sub -#line 36 "build/pidl/idl.yp" +#line 36 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'interface', 8, sub -#line 40 "build/pidl/idl.yp" +#line 40 "idl.yp" {$_[3] => { "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -1987,19 +1987,19 @@ sub [#Rule 9 'base_interface', 2, sub -#line 53 "build/pidl/idl.yp" +#line 53 "idl.yp" { $_[2] } ], [#Rule 10 'definitions', 1, sub -#line 57 "build/pidl/idl.yp" +#line 57 "idl.yp" { [ $_[1] ] } ], [#Rule 11 'definitions', 2, sub -#line 58 "build/pidl/idl.yp" +#line 58 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 12 @@ -2020,7 +2020,7 @@ sub [#Rule 17 'const', 6, sub -#line 66 "build/pidl/idl.yp" +#line 66 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2033,7 +2033,7 @@ sub [#Rule 18 'const', 7, sub -#line 75 "build/pidl/idl.yp" +#line 75 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2047,7 +2047,7 @@ sub [#Rule 19 'function', 7, sub -#line 88 "build/pidl/idl.yp" +#line 88 "idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2061,7 +2061,7 @@ sub [#Rule 20 'declare', 5, sub -#line 100 "build/pidl/idl.yp" +#line 100 "idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2080,7 +2080,7 @@ sub [#Rule 23 'decl_enum', 1, sub -#line 114 "build/pidl/idl.yp" +#line 114 "idl.yp" {{ "TYPE" => "ENUM" }} @@ -2088,7 +2088,7 @@ sub [#Rule 24 'decl_bitmap', 1, sub -#line 120 "build/pidl/idl.yp" +#line 120 "idl.yp" {{ "TYPE" => "BITMAP" }} @@ -2096,7 +2096,7 @@ sub [#Rule 25 'typedef', 6, sub -#line 126 "build/pidl/idl.yp" +#line 126 "idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], @@ -2122,7 +2122,7 @@ sub [#Rule 30 'typedecl', 2, sub -#line 139 "build/pidl/idl.yp" +#line 139 "idl.yp" { $_[1] } ], [#Rule 31 @@ -2134,13 +2134,13 @@ sub [#Rule 33 'type', 1, sub -#line 142 "build/pidl/idl.yp" +#line 142 "idl.yp" { "void" } ], [#Rule 34 'enum', 5, sub -#line 146 "build/pidl/idl.yp" +#line 146 "idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], @@ -2150,13 +2150,13 @@ sub [#Rule 35 'enum_elements', 1, sub -#line 154 "build/pidl/idl.yp" +#line 154 "idl.yp" { [ $_[1] ] } ], [#Rule 36 'enum_elements', 3, sub -#line 155 "build/pidl/idl.yp" +#line 155 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 37 @@ -2165,13 +2165,13 @@ sub [#Rule 38 'enum_element', 3, sub -#line 159 "build/pidl/idl.yp" +#line 159 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 39 'bitmap', 5, sub -#line 163 "build/pidl/idl.yp" +#line 163 "idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], @@ -2181,25 +2181,25 @@ sub [#Rule 40 'bitmap_elements', 1, sub -#line 171 "build/pidl/idl.yp" +#line 171 "idl.yp" { [ $_[1] ] } ], [#Rule 41 'bitmap_elements', 3, sub -#line 172 "build/pidl/idl.yp" +#line 172 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 42 'bitmap_element', 3, sub -#line 175 "build/pidl/idl.yp" +#line 175 "idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 43 'struct', 5, sub -#line 179 "build/pidl/idl.yp" +#line 179 "idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], @@ -2209,7 +2209,7 @@ sub [#Rule 44 'empty_element', 2, sub -#line 187 "build/pidl/idl.yp" +#line 187 "idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2229,7 +2229,7 @@ sub [#Rule 47 'optional_base_element', 2, sub -#line 201 "build/pidl/idl.yp" +#line 201 "idl.yp" { $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 48 @@ -2238,13 +2238,13 @@ sub [#Rule 49 'union_elements', 2, sub -#line 206 "build/pidl/idl.yp" +#line 206 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 50 'union', 5, sub -#line 210 "build/pidl/idl.yp" +#line 210 "idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], @@ -2254,7 +2254,7 @@ sub [#Rule 51 'base_element', 5, sub -#line 218 "build/pidl/idl.yp" +#line 218 "idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2268,13 +2268,13 @@ sub [#Rule 52 'pointers', 0, sub -#line 232 "build/pidl/idl.yp" +#line 232 "idl.yp" { 0 } ], [#Rule 53 'pointers', 2, sub -#line 233 "build/pidl/idl.yp" +#line 233 "idl.yp" { $_[1]+1 } ], [#Rule 54 @@ -2283,7 +2283,7 @@ sub [#Rule 55 'element_list1', 3, sub -#line 238 "build/pidl/idl.yp" +#line 238 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 56 @@ -2295,13 +2295,13 @@ sub [#Rule 58 'element_list2', 1, sub -#line 244 "build/pidl/idl.yp" +#line 244 "idl.yp" { [ $_[1] ] } ], [#Rule 59 'element_list2', 3, sub -#line 245 "build/pidl/idl.yp" +#line 245 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 60 @@ -2310,13 +2310,13 @@ sub [#Rule 61 'array_len', 3, sub -#line 250 "build/pidl/idl.yp" +#line 250 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 62 'array_len', 4, sub -#line 251 "build/pidl/idl.yp" +#line 251 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 63 @@ -2325,31 +2325,31 @@ sub [#Rule 64 'property_list', 4, sub -#line 257 "build/pidl/idl.yp" +#line 257 "idl.yp" { Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); } ], [#Rule 65 'properties', 1, sub -#line 260 "build/pidl/idl.yp" +#line 260 "idl.yp" { $_[1] } ], [#Rule 66 'properties', 3, sub -#line 261 "build/pidl/idl.yp" +#line 261 "idl.yp" { Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); } ], [#Rule 67 'property', 1, sub -#line 264 "build/pidl/idl.yp" +#line 264 "idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 68 'property', 4, sub -#line 265 "build/pidl/idl.yp" +#line 265 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 69 @@ -2358,7 +2358,7 @@ sub [#Rule 70 'listtext', 3, sub -#line 270 "build/pidl/idl.yp" +#line 270 "idl.yp" { "$_[1] $_[3]" } ], [#Rule 71 @@ -2367,13 +2367,13 @@ sub [#Rule 72 'commalisttext', 3, sub -#line 275 "build/pidl/idl.yp" +#line 275 "idl.yp" { "$_[1],$_[3]" } ], [#Rule 73 'anytext', 0, sub -#line 279 "build/pidl/idl.yp" +#line 279 "idl.yp" { "" } ], [#Rule 74 @@ -2388,73 +2388,73 @@ sub [#Rule 77 'anytext', 3, sub -#line 281 "build/pidl/idl.yp" +#line 281 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 78 'anytext', 3, sub -#line 282 "build/pidl/idl.yp" +#line 282 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 79 'anytext', 3, sub -#line 283 "build/pidl/idl.yp" +#line 283 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 80 'anytext', 3, sub -#line 284 "build/pidl/idl.yp" +#line 284 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 81 'anytext', 3, sub -#line 285 "build/pidl/idl.yp" +#line 285 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 82 'anytext', 3, sub -#line 286 "build/pidl/idl.yp" +#line 286 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 83 'anytext', 3, sub -#line 287 "build/pidl/idl.yp" +#line 287 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 84 'anytext', 3, sub -#line 288 "build/pidl/idl.yp" +#line 288 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 85 'anytext', 3, sub -#line 289 "build/pidl/idl.yp" +#line 289 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 86 'anytext', 3, sub -#line 290 "build/pidl/idl.yp" +#line 290 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 87 'anytext', 5, sub -#line 291 "build/pidl/idl.yp" +#line 291 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 88 'anytext', 5, sub -#line 292 "build/pidl/idl.yp" +#line 292 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 89 @@ -2472,7 +2472,7 @@ sub [#Rule 93 'text', 1, sub -#line 306 "build/pidl/idl.yp" +#line 306 "idl.yp" { "\"$_[1]\"" } ], [#Rule 94 @@ -2486,7 +2486,7 @@ sub bless($self,$class); } -#line 317 "build/pidl/idl.yp" +#line 317 "idl.yp" use Parse::Pidl::Util; -- cgit From 86e796643e2993ef3e3fb8b88faecf1261f01f10 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 22 Aug 2005 00:22:21 +0000 Subject: r9463: Fix DumpFunction() (was ignoring elements) Fix use of pidl for people that don't have it installed... Generate documentation for pidl debian package (This used to be commit de66450c242b943cfb226187b0ad14f380f08479) --- source4/pidl/lib/Parse/Pidl/Dump.pm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Dump.pm b/source4/pidl/lib/Parse/Pidl/Dump.pm index bca599262a..7f426c1c0b 100644 --- a/source4/pidl/lib/Parse/Pidl/Dump.pm +++ b/source4/pidl/lib/Parse/Pidl/Dump.pm @@ -208,9 +208,9 @@ sub DumpFunction($) $res .= DumpType($function->{RETURN_TYPE}); $res .= " $function->{NAME}(\n"; - for my $d (@{$function->{DATA}}) { - $first || ($res .= ",\n"); $first = 0; - $res .= DumpElement($d); + for my $d (@{$function->{ELEMENTS}}) { + unless ($first) { $res .= ",\n"; } $first = 0; + $res .= DumpElement($d); } $res .= "\n);\n\n"; -- cgit From ae88822b8c7fd45d9d96ef0d08f9d39ecaf3ba83 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 23 Aug 2005 13:19:33 +0000 Subject: r9519: Use the value() value of an element when that element is used in limited expressions (size_is,length_is,subcontext_size,etc) (This used to be commit 886780c298a794f304b0fce851bbb58c53605d17) --- source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm index ef22ff9788..513fa0826d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm @@ -235,6 +235,20 @@ sub GenerateStructEnv($) return \%env; } +sub EnvSubstituteValue($$) +{ + my ($env,$s) = @_; + + # Substitute the value() values in the env + foreach my $e (@{$s->{ELEMENTS}}) { + next unless (my $v = has_property($e, "value")); + + $env->{$e->{NAME}} = ParseExpr($v, $env); + } + + return $env; +} + sub GenerateFunctionInEnv($) { my $fn = shift; @@ -1095,6 +1109,8 @@ sub ParseStructPush($$) my $env = GenerateStructEnv($struct); + EnvSubstituteValue($env, $struct); + # save the old relative_base_offset pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base}); @@ -1326,6 +1342,8 @@ sub ParseStructPrint($$) my $env = GenerateStructEnv($struct); + EnvSubstituteValue($env, $struct); + foreach my $e (@{$struct->{ELEMENTS}}) { DeclareArrayVariables($e); } @@ -1870,6 +1888,7 @@ sub ParseFunctionPrint($) pidl "ndr->depth++;"; my $env = GenerateFunctionInEnv($fn); + EnvSubstituteValue($env, $fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { @@ -1925,6 +1944,8 @@ sub ParseFunctionPush($) my $env = GenerateFunctionInEnv($fn); + EnvSubstituteValue($env, $fn); + foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { ParseElementPush($e, "ndr", "r->in.", $env, 1, 1); -- cgit From 2cd71e51018835d04968c239eb8539d0f2f6ee71 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Wed, 24 Aug 2005 00:04:48 +0000 Subject: r9553: Some cosmetic things to make the atsvc dissector output look prettier and be more usable: - nicer formatting for summary of set fields in bitmap. - say "Pointer to Foo" in proto_tree instead of just "Foo" when dissecting pointers. - append string value to proto_tree when dissecting pointers to strings. - strip librpc/gen_ndr prefix from includes so generated files can live in the ethereal epan/dissectors directory. Now to work on getting the winreg dissector compiling... (This used to be commit ab00976699a2deeb3ddca510864520fcb46714bc) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 73dd34096e..7a7db4280e 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -1,7 +1,7 @@ ################################################## # Samba4 NDR parser generator for IDL structures # Copyright tridge@samba.org 2000-2003 -# Copyright tpot@samba.org 2001 +# Copyright tpot@samba.org 2001,2005 # Copyright jelmer@samba.org 2004-2005 # Portions based on idl2eth.c by Ronnie Sahlberg # released under the GNU GPL @@ -180,6 +180,10 @@ sub Bitmap($$$) pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);"; + pidl_code "proto_item_append_text(item, \": \");\n"; + pidl_code "if (!flags)"; + pidl_code "\tproto_item_append_text(item, \"(No values set)\");\n"; + foreach (@{$e->{ELEMENTS}}) { next unless (/([^ ]*) (.*)/); my ($en,$ev) = ($1,$2); @@ -195,14 +199,16 @@ sub Bitmap($$$) pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);"; pidl_code "if (flags&$ev){"; - pidl_code "\tproto_item_append_text(item,\"$en \");"; + pidl_code "\tproto_item_append_text(item,\"$en\");"; + pidl_code "\tif (flags & (~$ev))"; + pidl_code "\t\tproto_item_append_text(item, \", \");"; pidl_code "}"; pidl_code "flags&=(~$ev);"; pidl_code ""; } pidl_code "if(flags){"; - pidl_code "\tproto_item_append_text(item, \"UNKNOWN-FLAGS\");"; + pidl_code "\tproto_item_append_text(item, \"Unknown bitmap value 0x%x\", flags);"; pidl_code "}\n"; pidl_code "return offset;"; deindent; @@ -230,7 +236,7 @@ sub ElementLevel($$$$$) } elsif ($l->{LEVEL} eq "EMBEDDED") { $type = "embedded"; } - pidl_code "offset=dissect_ndr_$type\_pointer(tvb,offset,pinfo,tree,drep,$myname\_,$ptrtype_mappings{$l->{POINTER_TYPE}},\"".field2name(StripPrefixes($e->{NAME})) . " (".StripPrefixes($e->{TYPE}).")\",$hf);"; + pidl_code "offset=dissect_ndr_$type\_pointer(tvb,offset,pinfo,tree,drep,$myname\_,$ptrtype_mappings{$l->{POINTER_TYPE}},\"Pointer to ".field2name(StripPrefixes($e->{NAME})) . " ($e->{TYPE})\",$hf);"; } elsif ($l->{TYPE} eq "ARRAY") { if ($l->{IS_INLINE}) { @@ -256,7 +262,9 @@ sub ElementLevel($$$$$) ($bs = 1) if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_ASCII.*")); if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) { - pidl_code "offset=dissect_ndr_cvstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);"; + pidl_code "char *data;\n"; + pidl_code "offset=dissect_ndr_cvstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,&data);"; + pidl_code "proto_item_append_text(tree, \": %s\", data);"; } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*")) { pidl_code "offset=dissect_ndr_vstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);"; } else { @@ -708,7 +716,11 @@ sub Parse($$) $res{headers} .= "#include \"packet-dcerpc.h\"\n"; $res{headers} .= "#include \"packet-dcerpc-nt.h\"\n"; $res{headers} .= "#include \"packet-windows-common.h\"\n"; - $res{headers} .= "#include \"$h_filename\"\n"; + + use File::Basename; + my $h_basename = basename($h_filename); + + $res{headers} .= "#include \"$h_basename\"\n"; pidl_code ""; # Ethereal protocol registration -- cgit From cdb6d52372624b937db6b3d3cbc9353d4064af11 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Wed, 24 Aug 2005 00:53:37 +0000 Subject: r9554: Do a quick once-over to make the ethereal auto-generated parser code a bit more readable. (This used to be commit da3ca9e3c1df09983629eeee8baab2196f2135a9) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 105 ++++++++++++++-------------- 1 file changed, 54 insertions(+), 51 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 7a7db4280e..c013d5670a 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -95,6 +95,8 @@ sub PrintIdl($) foreach (split /\n/, $idl) { pidl_code "/* IDL: $_ */"; } + + pidl_code ""; } ##################################################################### @@ -136,14 +138,14 @@ sub Enum($$$) pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)"; pidl_code "{"; indent; - pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, NULL);"; + pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, NULL);"; pidl_code "return offset;"; deindent; pidl_code "}\n"; my $enum_size = $e->{BASE_TYPE}; $enum_size =~ s/uint//g; - register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8); + register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8); } sub Bitmap($$$) @@ -160,8 +162,8 @@ sub Bitmap($$$) pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; pidl_code "{"; indent; - pidl_code "proto_item *item=NULL;"; - pidl_code "proto_tree *tree=NULL;"; + pidl_code "proto_item *item = NULL;"; + pidl_code "proto_tree *tree = NULL;"; pidl_code ""; pidl_code "g$e->{BASE_TYPE} flags;"; @@ -173,12 +175,12 @@ sub Bitmap($$$) pidl_code "if(parent_tree) {"; indent; - pidl_code "item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);"; + pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);"; pidl_code "tree=proto_item_add_subtree(item,ett_$ifname\_$name);"; deindent; pidl_code "}\n"; - pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);"; + pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);"; pidl_code "proto_item_append_text(item, \": \");\n"; pidl_code "if (!flags)"; @@ -199,7 +201,7 @@ sub Bitmap($$$) pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);"; pidl_code "if (flags&$ev){"; - pidl_code "\tproto_item_append_text(item,\"$en\");"; + pidl_code "\tproto_item_append_text(item, \"$en\");"; pidl_code "\tif (flags & (~$ev))"; pidl_code "\t\tproto_item_append_text(item, \", \");"; pidl_code "}"; @@ -216,7 +218,7 @@ sub Bitmap($$$) my $size = $e->{BASE_TYPE}; $size =~ s/uint//g; - register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "NULL", $size/8); + register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "NULL", $size/8); } sub ElementLevel($$$$$) @@ -236,7 +238,7 @@ sub ElementLevel($$$$$) } elsif ($l->{LEVEL} eq "EMBEDDED") { $type = "embedded"; } - pidl_code "offset=dissect_ndr_$type\_pointer(tvb,offset,pinfo,tree,drep,$myname\_,$ptrtype_mappings{$l->{POINTER_TYPE}},\"Pointer to ".field2name(StripPrefixes($e->{NAME})) . " ($e->{TYPE})\",$hf);"; + pidl_code "offset = dissect_ndr_$type\_pointer(tvb, offset, pinfo, tree, drep, $myname\_, $ptrtype_mappings{$l->{POINTER_TYPE}}, \"Pointer to ".field2name(StripPrefixes($e->{NAME})) . " ($e->{TYPE})\",$hf);"; } elsif ($l->{TYPE} eq "ARRAY") { if ($l->{IS_INLINE}) { @@ -245,14 +247,14 @@ sub ElementLevel($$$$$) } elsif ($l->{IS_FIXED}) { pidl_code "int i;"; pidl_code "for (i = 0; i < $l->{SIZE_IS}; i++)"; - pidl_code "\toffset=$myname\_(tvb,offset,pinfo,tree,drep);"; + pidl_code "\toffset = $myname\_(tvb, offset, pinfo, tree, drep);"; } else { my $af = ""; ($af = "ucarray") if ($l->{IS_CONFORMANT}); ($af = "uvarray") if ($l->{IS_VARYING}); ($af = "ucvarray") if ($l->{IS_CONFORMANT} and $l->{IS_VARYING}); - pidl_code "offset=dissect_ndr_$af(tvb,offset,pinfo,tree,drep,$myname\_);"; + pidl_code "offset = dissect_ndr_$af(tvb, offset, pinfo, tree, drep, $myname\_);"; } } elsif ($l->{TYPE} eq "DATA") { if ($l->{DATA_TYPE} eq "string") { @@ -263,10 +265,10 @@ sub ElementLevel($$$$$) if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) { pidl_code "char *data;\n"; - pidl_code "offset=dissect_ndr_cvstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,&data);"; + pidl_code "offset = dissect_ndr_cvstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, &data);"; pidl_code "proto_item_append_text(tree, \": %s\", data);"; } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*")) { - pidl_code "offset=dissect_ndr_vstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);"; + pidl_code "offset = dissect_ndr_vstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, NULL);"; } else { warn("Unable to handle string with flags $e->{PROPERTIES}->{flag}"); } @@ -282,7 +284,7 @@ sub ElementLevel($$$$$) pidl_code "/* FIXME: Handle unknown data type $l->{DATA_TYPE} */"; if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/) { - pidl_code "offset=$1_dissect_$2(tvb,offset,pinfo,tree,drep,$hf,$param);"; + pidl_code "offset = $1_dissect_$2(tvb,offset,pinfo,tree,drep,$hf,$param);"; } return; @@ -295,13 +297,13 @@ sub ElementLevel($$$$$) } elsif ($_->{TYPE} eq "SUBCONTEXT") { my $num_bits = ($l->{HEADER_SIZE}*8); pidl_code "guint$num_bits size;"; - pidl_code "int start_offset=offset;"; + pidl_code "int start_offset = offset;"; pidl_code "tvbuff_t *subtvb;"; - pidl_code "offset=dissect_ndr_uint$num_bits(tvb,offset,pinfo,tree,drep,$hf,&size);"; - pidl_code "proto_tree_add_text(tree,tvb,start_offset,offset-start_offset+size,\"Subcontext size\");"; + pidl_code "offset = dissect_ndr_uint$num_bits(tvb, offset, pinfo, tree, drep, $hf, &size);"; + pidl_code "proto_tree_add_text(tree, tvb, start_offset, offset - start_offset + size, \"Subcontext size\");"; - pidl_code "subtvb = tvb_new_subset(tvb,offset,size,-1);"; - pidl_code "$myname\_(subtvb,0,pinfo,tree,drep);"; + pidl_code "subtvb = tvb_new_subset(tvb, offset, size, -1);"; + pidl_code "$myname\_(subtvb, 0, pinfo, tree, drep);"; } else { die("Unknown type `$_->{TYPE}'"); } @@ -313,7 +315,7 @@ sub Element($$$) my $dissectorname = "$ifname\_dissect\_".StripPrefixes($pn)."\_".StripPrefixes($e->{NAME}); - my $call_code = "offset=$dissectorname(tvb,offset,pinfo,tree,drep);"; + my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", type2ft($e->{TYPE}), "BASE_HEX", "NULL", 0, ""); @@ -333,6 +335,7 @@ sub Element($$$) ElementLevel($e,$_,$hf,$dissectorname.$add,$pn); + pidl_code ""; pidl_code "return offset;"; deindent; pidl_code "}\n"; @@ -363,16 +366,16 @@ sub Function($$$) foreach (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$_->{DIRECTION}})) { pidl_code "$dissectornames{$_->{NAME}}"; - pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);"; + pidl_code "offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"; pidl_code ""; } } if (not defined($fn->{RETURN_TYPE})) { } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { - pidl_code "offset=dissect_ntstatus(tvb,offset,pinfo,tree,drep,hf\_$ifname\_status, NULL);"; + pidl_code "offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, NULL);"; } elsif ($fn->{RETURN_TYPE} eq "WERROR") { - pidl_code "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,hf\_$ifname\_werror, NULL);"; + pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, NULL);"; } pidl_code "return offset;"; @@ -386,7 +389,7 @@ sub Function($$$) foreach (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$_->{DIRECTION}})) { pidl_code "$dissectornames{$_->{NAME}}"; - pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);"; + pidl_code "offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"; } } @@ -424,23 +427,23 @@ sub Struct($$$) } pidl_code ""; - pidl_code "old_offset=offset;"; + pidl_code "old_offset = offset;"; pidl_code ""; pidl_code "if(parent_tree){"; indent; - pidl_code "item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);"; - pidl_code "tree=proto_item_add_subtree(item, ett_$ifname\_$name);"; + pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);"; + pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; deindent; pidl_code "}"; pidl_code "\n$res"; - pidl_code "proto_item_set_len(item, offset-old_offset);"; + pidl_code "proto_item_set_len(item, offset-old_offset);\n"; pidl_code "return offset;"; deindent; pidl_code "}\n"; - register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); + register_type($name, "offset = $dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); } sub Union($$$) @@ -465,8 +468,8 @@ sub Union($$$) pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; pidl_code "{"; indent; - pidl_code "proto_item *item=NULL;"; - pidl_code "proto_tree *tree=NULL;"; + pidl_code "proto_item *item = NULL;"; + pidl_code "proto_tree *tree = NULL;"; pidl_code "int old_offset;"; pidl_code "g$e->{SWITCH_TYPE} level;"; pidl_code ""; @@ -477,11 +480,11 @@ sub Union($$$) pidl_code ""; - pidl_code "old_offset=offset;"; + pidl_code "old_offset = offset;"; pidl_code "if(parent_tree){"; indent; - pidl_code "item=proto_tree_add_text(parent_tree,tvb,offset,-1,\"$name\");"; - pidl_code "tree=proto_item_add_subtree(item,ett_$ifname\_$name);"; + pidl_code "item = proto_tree_add_text(parent_tree, tvb, offset, -1, \"$name\");"; + pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; deindent; pidl_code "}"; @@ -490,12 +493,12 @@ sub Union($$$) pidl_code "offset = dissect_ndr_$e->{SWITCH_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, &level);"; pidl_code "switch(level) {$res\t}"; - pidl_code "proto_item_set_len(item, offset-old_offset);"; + pidl_code "proto_item_set_len(item, offset-old_offset);\n"; pidl_code "return offset;"; deindent; pidl_code "}"; - register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); + register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); } sub Const($$) @@ -665,30 +668,30 @@ sub Initialize($) foreach my $bytes (qw(1 2 4 8)) { my $bits = $bytes * 8; - register_type("uint$bits", "offset=dissect_ndr_uint$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes); - register_type("int$bits", "offset=dissect_ndr_uint$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes); + register_type("uint$bits", "offset = dissect_ndr_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@,NULL);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes); + register_type("int$bits", "offset = dissect_ndr_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes); } - register_type("udlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4); - register_type("bool8", "offset=dissect_ndr_uint8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); - register_type("char", "offset=dissect_ndr_uint8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); - register_type("long", "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4); - register_type("dlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8); - register_type("GUID", "offset=dissect_ndr_uuid_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4); - register_type("policy_handle", "offset=dissect_nt_policy_hnd(tvb,offset,pinfo,tree,drep,\@HF\@,NULL,NULL,\@PARAM\@&0x01,\@PARAM\@&0x02);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); - register_type("NTTIME", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); - register_type("NTTIME_hyper", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); - register_type("time_t", "offset=dissect_ndr_time_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4); - register_type("NTTIME_1sec", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + register_type("udlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4); + register_type("bool8", "offset = dissect_ndr_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + register_type("char", "offset = dissect_ndr_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + register_type("long", "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4); + register_type("dlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8); + register_type("GUID", "offset = dissect_ndr_uuid_t(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4); + register_type("policy_handle", "offset = dissect_nt_policy_hnd(tvb, offset, pinfo, tree, drep, \@HF\@, NULL, NULL, \@PARAM\@&0x01, \@PARAM\@&0x02);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); + register_type("NTTIME", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + register_type("NTTIME_hyper", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + register_type("time_t", "offset = dissect_ndr_time_t(tvb, offset, pinfo,tree, drep, \@HF\@, NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4); + register_type("NTTIME_1sec", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); register_type("SID", " dcerpc_info *di = (dcerpc_info *)pinfo->private_data; di->hf_index = \@HF\@; - offset=dissect_ndr_nt_SID_with_options(tvb,offset,pinfo,tree,drep,param); + offset = dissect_ndr_nt_SID_with_options(tvb, offset, pinfo, tree, drep, param); ","FT_STRING", "BASE_DEC", 0, "NULL", 4); register_type("WERROR", - "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4); + "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4); } -- cgit From 12e269c9381da19058f57b313f70066bc06030ac Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Wed, 24 Aug 2005 01:58:36 +0000 Subject: r9558: Add more whitespace to generated output. Change conformance file warning to something more understandable. Don't generate duplicate duplicate element dissectors for function call arguments. Hey this makes the winreg dissector compile, but not link. (This used to be commit 545d3deaa43ed2e837a7fb5e0cf5761281a9451f) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index c013d5670a..72ff819b68 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -176,7 +176,7 @@ sub Bitmap($$$) pidl_code "if(parent_tree) {"; indent; pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);"; - pidl_code "tree=proto_item_add_subtree(item,ett_$ifname\_$name);"; + pidl_code "tree = proto_item_add_subtree(item,ett_$ifname\_$name);"; deindent; pidl_code "}\n"; @@ -352,7 +352,7 @@ sub Function($$$) my %dissectornames; foreach (@{$fn->{ELEMENTS}}) { - $dissectornames{$_->{NAME}} = Element($_, $fn->{NAME}, $ifname) + $dissectornames{$_->{NAME}} = Element($_, $fn->{NAME}, $ifname) if not defined($dissectornames{$_->{NAME}}); } my $fn_name = $_->{NAME}; @@ -664,7 +664,7 @@ sub Initialize($) $conformance = {}; - ReadConformance($cnf_file, $conformance) or print "Warning: Not using conformance file `$cnf_file'\n"; + ReadConformance($cnf_file, $conformance) or print "Warning: No conformance file `$cnf_file'\n"; foreach my $bytes (qw(1 2 4 8)) { my $bits = $bytes * 8; -- cgit From b42f358d511096689916d75584583bd4dd08e41b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 24 Aug 2005 11:17:28 +0000 Subject: r9576: Couple of small fixes. Generate notice indicating that the parsers were autogenerated. (This used to be commit a37e2134e61eb38e9cbc54f8533113622f013037) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 72ff819b68..f61ce89ee8 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -542,7 +542,7 @@ sub RegisterInterface($) # in epan/dissctors are deleted. my $name = "\"" . uc($x->{NAME}) . " (pidl)\""; - my $short_name = $x->{NAME}; + my $short_name = uc($x->{NAME}); my $filter_name = $x->{NAME}; if (has_property($x, "helpstring")) { @@ -697,16 +697,29 @@ sub Initialize($) ##################################################################### # Generate ethereal parser and header code -sub Parse($$) +sub Parse($$$$) { - my($ndr,$h_filename,$cnf_file) = @_; + my($ndr,$idl_file,$h_filename,$cnf_file) = @_; Initialize($cnf_file); $tabs = ""; %res = (code=>"",def=>"",hdr=>""); - pidl_hdr "/* header auto-generated by pidl */"; + my $notice = +"/* DO NOT EDIT + This filter was automatically generated + from $idl_file and $cnf_file. + + Pidl is a perl based IDL compiler for DCE/RPC idl files. + It is maintained by the Samba team, not the Ethereal team. + Instructions on how to download and install Pidl can be + found at http://wiki.ethereal.com/Pidl +*/ + +"; + + pidl_hdr $notice; $res{headers} = "\n"; $res{headers} .= "#ifdef HAVE_CONFIG_H\n"; @@ -733,7 +746,7 @@ sub Parse($$) $res{ett} = DumpEttDeclaration(); $res{hf} = DumpHfDeclaration(); - my $parser = "/* parser auto-generated by pidl */"; + my $parser = $notice; $parser.= $res{headers}; $parser.=$res{ett}; $parser.=$res{hf}; -- cgit From 50004c6905613f66a112717e604bc6eaf93cb38d Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Thu, 25 Aug 2005 11:05:49 +0000 Subject: r9611: Reset global variables (hf and ett lists) for each parser run. This avoids building up buckets of unecessary definitions from other parsers. Get rid of warning and FIXME for unknown data types. This is handled by the interface depends list and including the appropriate header files. (This used to be commit eb5e3b031cd18fb1f83d9ccbb21e5148c8c1cdd0) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index f61ce89ee8..a4c6ecdba0 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -16,6 +16,8 @@ use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); use Parse::Pidl::Ethereal::Conformance qw(ReadConformance); my %types; +my %hf; +my @ett; my $conformance = {imports=>{}}; @@ -280,8 +282,6 @@ sub ElementLevel($$$$$) } elsif ($conformance->{imports}->{$l->{DATA_TYPE}}) { $call = $conformance->{imports}->{$l->{DATA_TYPE}}; } else { - warn("Unknown data type `$l->{DATA_TYPE}'"); - pidl_code "/* FIXME: Handle unknown data type $l->{DATA_TYPE} */"; if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/) { pidl_code "offset = $1_dissect_$2(tvb,offset,pinfo,tree,drep,$hf,$param);"; @@ -705,6 +705,8 @@ sub Parse($$$$) $tabs = ""; %res = (code=>"",def=>"",hdr=>""); + %hf = (); + @ett = (); my $notice = "/* DO NOT EDIT @@ -764,8 +766,6 @@ sub Parse($$$$) # ETT ############################################################################### -my @ett = (); - sub register_ett($) { my $name = shift; @@ -797,8 +797,6 @@ sub DumpEttDeclaration() # HF ############################################################################### -my %hf = (); - sub register_hf_field($$$$$$$$) { my ($index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; -- cgit From 05065108f4da76e6152b9f75fc266d15c316c32d Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Thu, 25 Aug 2005 11:39:23 +0000 Subject: r9612: Don't generate handoff code for idl files that don't implement a pipe (e.g security.idl) (This used to be commit 178d040dbb07f53c29e945a2109bb3c8f355e3d3) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index a4c6ecdba0..016a95e01b 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -572,14 +572,17 @@ sub RegisterInterface($) sub RegisterInterfaceHandoff($) { my $x = shift; - pidl_code "void proto_reg_handoff_dcerpc_$x->{NAME}(void)"; - pidl_code "{"; - indent; - pidl_code "dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},"; - pidl_code "\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},"; - pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);"; - deindent; - pidl_code "}"; + + if (defined($x->{UUID})) { + pidl_code "void proto_reg_handoff_dcerpc_$x->{NAME}(void)"; + pidl_code "{"; + indent; + pidl_code "dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},"; + pidl_code "\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},"; + pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);"; + deindent; + pidl_code "}"; + } } sub ProcessInterface($) -- cgit From 3567c7b2a79cbc0992f0257f1dc958bf5d4b0c28 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Sat, 27 Aug 2005 08:47:35 +0000 Subject: r9677: Don't generate duplicate function names when processing structure elements that are bitmaps or enums. (This used to be commit 1b0e65359cc9caee56a63690af142e8599ea6926) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 016a95e01b..92199e13f1 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -115,7 +115,8 @@ sub Enum($$$) { my ($e,$name,$ifname) = @_; my $valsstring = "$ifname\_$name\_vals"; - my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name); + my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name)."_enum"; + return if (defined($conformance->{noemit}->{$dissectorname})); foreach (@{$e->{ELEMENTS}}) { @@ -153,11 +154,10 @@ sub Enum($$$) sub Bitmap($$$) { my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name); + my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name)."_bitmap"; register_ett("ett_$ifname\_$name"); - pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; pidl_code "int"; -- cgit From 54dc527a9e2bdc0f73b4638189a051070f0328bf Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Sat, 27 Aug 2005 12:24:02 +0000 Subject: r9682: Jelmer, I think this fixes another case where the parser generator was producing duplicate function definitions. Can you check this out? (This used to be commit e9bb695e74c98ea1f2647dacc7c9c4b8ad37bd72) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 92199e13f1..60b2371108 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -326,7 +326,7 @@ sub Element($$$) my $add = ""; foreach (@{$e->{LEVELS}}) { - next if ($_->{TYPE} eq "SWITCH"); + last if ($_->{TYPE} eq "SWITCH"); pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);"; pidl_code "static int"; pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)"; -- cgit From 81045abddc359ffad3a20c9661ad7439e592166d Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Sat, 27 Aug 2005 12:39:56 +0000 Subject: r9683: OK that last fix was too good to be true. (-: (This used to be commit b33774b693f9866295fc11758c826ff150bfb02d) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 60b2371108..92199e13f1 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -326,7 +326,7 @@ sub Element($$$) my $add = ""; foreach (@{$e->{LEVELS}}) { - last if ($_->{TYPE} eq "SWITCH"); + next if ($_->{TYPE} eq "SWITCH"); pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);"; pidl_code "static int"; pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)"; -- cgit From 054f206599e9d74de6429dc8f17d9c58342bcc98 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Mon, 29 Aug 2005 12:22:48 +0000 Subject: r9734: The ethereal parser generator was generating duplicate functions for fields in structures with the same name as a structure (i.e security_ace.object and security_ace_object). I've twiddled the naming scheme a bit and things are a bit more unique but there is still may be some naming conflicts in other IDL files. We are now getting confused over fields with the same name in unions (e.g security_ace_object_ctr.object) plus some other union weirdness. (This used to be commit c2ad9f49a204d0075a3b460c5ea2ca9741fc7125) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 92199e13f1..ad466b246a 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -115,7 +115,7 @@ sub Enum($$$) { my ($e,$name,$ifname) = @_; my $valsstring = "$ifname\_$name\_vals"; - my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name)."_enum"; + my $dissectorname = "$ifname\_dissect\_enum\_".StripPrefixes($name); return if (defined($conformance->{noemit}->{$dissectorname})); @@ -154,7 +154,7 @@ sub Enum($$$) sub Bitmap($$$) { my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name)."_bitmap"; + my $dissectorname = "$ifname\_dissect\_bitmap\_".StripPrefixes($name); register_ett("ett_$ifname\_$name"); @@ -313,7 +313,7 @@ sub Element($$$) { my ($e,$pn,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_".StripPrefixes($pn)."\_".StripPrefixes($e->{NAME}); + my $dissectorname = "$ifname\_dissect\_element\_".StripPrefixes($pn)."\_".StripPrefixes($e->{NAME}); my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; @@ -402,7 +402,7 @@ sub Function($$$) sub Struct($$$) { my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name); + my $dissectorname = "$ifname\_dissect\_struct\_".StripPrefixes($name); return if (defined($conformance->{noemit}->{$dissectorname})); -- cgit From 7a81e529dc295d9da5980a88257bf903f321519a Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Sat, 3 Sep 2005 01:50:56 +0000 Subject: r9982: Strip prefixes off the check for noemit in the conformance info so you can use the typedef names in the IDL rather than the autogenerated function names. This means you can say "NOEMIT security_descriptor" instead of "NOEMIT dissect_security_descriptor_type" or whatever. (This used to be commit ec80c5ceec3c96dc847d171967472cce99edcdc7) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index ad466b246a..a0e8f4126b 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -117,7 +117,7 @@ sub Enum($$$) my $valsstring = "$ifname\_$name\_vals"; my $dissectorname = "$ifname\_dissect\_enum\_".StripPrefixes($name); - return if (defined($conformance->{noemit}->{$dissectorname})); + return if (defined($conformance->{noemit}->{StripPrefixes($name)})); foreach (@{$e->{ELEMENTS}}) { if (/([^=]*)=(.*)/) { @@ -319,7 +319,8 @@ sub Element($$$) my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", type2ft($e->{TYPE}), "BASE_HEX", "NULL", 0, ""); - if (defined($conformance->{noemit}->{$dissectorname})) { + my $eltname = StripPrefixes($pn) . ".$e->{NAME}"; + if (defined($conformance->{noemit}->{$eltname})) { return $call_code; } @@ -404,7 +405,7 @@ sub Struct($$$) my ($e,$name,$ifname) = @_; my $dissectorname = "$ifname\_dissect\_struct\_".StripPrefixes($name); - return if (defined($conformance->{noemit}->{$dissectorname})); + return if (defined($conformance->{noemit}->{StripPrefixes($name)})); register_ett("ett_$ifname\_$name"); @@ -451,7 +452,8 @@ sub Union($$$) my ($e,$name,$ifname) = @_; my $dissectorname = "$ifname\_dissect_".StripPrefixes($name); - return if (defined($conformance->{noemit}->{$dissectorname})); + + return if (defined($conformance->{noemit}->{StripPrefixes($name)})); register_ett("ett_$ifname\_$name"); -- cgit From 563be66ccbd6473212314708cced9d134e2b5f8f Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Sat, 3 Sep 2005 02:06:32 +0000 Subject: r9983: Make the NOEMIT conformance directive with no argument mean do not emit any dissectors for this IDL. (This used to be commit 55a98b3dfdef21df172dac6cff4ebc114b35df00) --- source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index 45654fe6aa..8a4782073d 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -68,9 +68,16 @@ sub handle_strip_prefix($$) sub handle_noemit($$) { - my ($data,$type) = @_; + my ($data) = shift; + my $type; - $data->{noemit}->{$type} = 1; + $type = shift if ($#_ == 1); + + if (defined($type)) { + $data->{noemit}->{$type} = 1; + } else { + $data->{noemit_dissector} = 1; + } } sub handle_protocol($$$$$) -- cgit From 40d70b92e0d0ec5d29d975c49a4ca7a62f592f17 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Sat, 3 Sep 2005 02:08:25 +0000 Subject: r9984: Honour the NOEMIT conformance directive for entire IDL files. (This used to be commit 73dffade2c008b26eaf3924d31693c27328b8586) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index a0e8f4126b..dbaf12b572 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -707,6 +707,8 @@ sub Parse($$$$) my($ndr,$idl_file,$h_filename,$cnf_file) = @_; Initialize($cnf_file); + return (undef, undef) if defined($conformance->{noemit_dissector}); + $tabs = ""; %res = (code=>"",def=>"",hdr=>""); -- cgit From 0eea337a6f11c3a86414fbd31b065fc59a481435 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 3 Sep 2005 17:16:18 +0000 Subject: r10006: Insert correct header file. (This used to be commit dfa45ec1b329ad01daf81beeb31985811ce4f5af) --- source4/pidl/lib/Parse/Pidl/Samba/TDR.pm | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm index b9bfd83e41..aa41e9419c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm @@ -60,7 +60,7 @@ sub ParserElement($$$) if (has_property($e, "charset")) { fatal($e,"charset() on non-array element") unless (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0); - my $len = @{$e->{ARRAY_LEN}}[0]; + my $len = ParseExpr(@{$e->{ARRAY_LEN}}[0], $env); if ($len eq "*") { $len = "-1"; } pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));"; return; @@ -112,6 +112,7 @@ sub ParserStruct($$$$) } my %env = map { $_->{NAME} => "v->$_->{NAME}" } @{$e->{ELEMENTS}}; + $env{"this"} = "v"; ParserElement($_, $t, \%env) foreach (@{$e->{ELEMENTS}}); if ($t eq "print") { @@ -215,6 +216,7 @@ sub Parser($$) pidl "/* autogenerated by pidl */"; pidl "#include \"includes.h\""; pidl "#include \"$hdrname\""; + pidl ""; foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } return $ret; } @@ -226,8 +228,6 @@ sub HeaderInterface($$) pidl "#ifndef __TDR_$x->{NAME}_HEADER__"; pidl "#define __TDR_$x->{NAME}_HEADER__"; - pidl "#include \"$outputdir/$x->{NAME}.h\""; - foreach my $e (@{$x->{DATA}}) { next unless ($e->{TYPE} eq "TYPEDEF"); next unless has_property($e, "public"); @@ -251,11 +251,14 @@ sub HeaderInterface($$) pidl "#endif /* __TDR_$x->{NAME}_HEADER__ */"; } -sub Header($$) +sub Header($$$) { - my ($idl,$outputdir) = @_; + my ($idl,$outputdir,$basename) = @_; $ret = ""; pidl "/* Generated by pidl */"; + + pidl "#include \"$outputdir/$basename.h\""; + pidl ""; foreach (@$idl) { HeaderInterface($_, $outputdir) if ($_->{TYPE} eq "INTERFACE"); -- cgit From e9b5bf90e646af31c23631d08a73dcc8adca456e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 3 Sep 2005 20:09:19 +0000 Subject: r10010: Support base_type() attribute (This used to be commit c0bae9b0b5cb56aea98e33b4d0a9d29c6622dd27) --- source4/pidl/lib/Parse/Pidl/Samba/TDR.pm | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm index aa41e9419c..041170c152 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm @@ -167,7 +167,7 @@ sub ParserBitmap($$$$) sub ParserEnum($$$$) { my ($e,$n,$t,$p) = @_; - my $bt = Parse::Pidl::Typelist::enum_type_fn($e); + my $bt = ($e->{PROPERTIES}->{base_type} or "uint8"); pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", enum $n *v)"; pidl "{"; @@ -190,6 +190,8 @@ sub ParserTypedef($$) return if (has_property($e, "no$t")); + $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES}; + { STRUCT => \&ParserStruct, UNION => \&ParserUnion, ENUM => \&ParserEnum, BITMAP => \&ParserBitmap }->{$e->{DATA}->{TYPE}}($e->{DATA}, $e->{NAME}, $t, has_property($e, "public")); -- cgit From 40cbd4625ae7f9799238594faa4f8cc54ead72e4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 3 Sep 2005 22:58:04 +0000 Subject: r10015: Change the NT4 registry backend to use the IDL-generate parse functions. (This used to be commit 0ad46ef804c0654e927f9c14ea93c45f9e3c718c) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 1387 ++++++++++++++++++++---------------- 1 file changed, 785 insertions(+), 602 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index a73451d142..203e052022 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -559,7 +559,7 @@ sub new { } }, {#State 9 - DEFAULT => -89 + DEFAULT => -92 }, {#State 10 ACTIONS => { @@ -643,7 +643,7 @@ sub new { } }, {#State 22 - DEFAULT => -93 + DEFAULT => -96 }, {#State 23 DEFAULT => -74 @@ -653,32 +653,35 @@ sub new { }, {#State 25 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "&" => 39, - "{" => 38, - "/" => 40, - "(" => 41, - "|" => 42, - "*" => 43, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 }, DEFAULT => -69 }, {#State 26 ACTIONS => { - "," => 46, - ")" => 47 + "," => 49, + ")" => 50 } }, {#State 27 DEFAULT => -75 }, {#State 28 - DEFAULT => -92 + DEFAULT => -95 }, {#State 29 DEFAULT => -66 @@ -688,38 +691,38 @@ sub new { }, {#State 31 ACTIONS => { - "typedef" => 48, - "union" => 49, - "enum" => 62, - "bitmap" => 63, - "declare" => 55, - "const" => 57, - "struct" => 60 + "typedef" => 51, + "union" => 52, + "enum" => 65, + "bitmap" => 66, + "declare" => 58, + "const" => 60, + "struct" => 63 }, DEFAULT => -63, GOTOS => { - 'typedecl' => 61, - 'function' => 50, - 'bitmap' => 64, - 'definitions' => 51, - 'definition' => 54, - 'property_list' => 53, - 'usertype' => 52, - 'declare' => 66, - 'const' => 65, - 'struct' => 56, - 'enum' => 58, - 'typedef' => 59, - 'union' => 67 + 'typedecl' => 64, + 'function' => 53, + 'bitmap' => 67, + 'definitions' => 54, + 'definition' => 57, + 'property_list' => 56, + 'usertype' => 55, + 'declare' => 69, + 'const' => 68, + 'struct' => 59, + 'enum' => 61, + 'typedef' => 62, + 'union' => 70 } }, {#State 32 ACTIONS => { - ";" => 68 + ";" => 71 }, - DEFAULT => -94, + DEFAULT => -97, GOTOS => { - 'optional_semicolon' => 69 + 'optional_semicolon' => 72 } }, {#State 33 @@ -727,7 +730,7 @@ sub new { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 70 + 'identifier' => 73 } }, {#State 34 @@ -739,7 +742,7 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 71, + 'anytext' => 74, 'text' => 24, 'constant' => 27 } @@ -753,7 +756,7 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 72, + 'anytext' => 75, 'text' => 24, 'constant' => 27 } @@ -767,7 +770,7 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 73, + 'anytext' => 76, 'text' => 24, 'constant' => 27 } @@ -781,7 +784,7 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 74, + 'anytext' => 77, 'text' => 24, 'constant' => 27 } @@ -795,10 +798,9 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 75, + 'anytext' => 78, 'text' => 24, - 'constant' => 27, - 'commalisttext' => 76 + 'constant' => 27 } }, {#State 39 @@ -810,7 +812,7 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 77, + 'anytext' => 79, 'text' => 24, 'constant' => 27 } @@ -824,9 +826,10 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 78, + 'anytext' => 80, 'text' => 24, - 'constant' => 27 + 'constant' => 27, + 'commalisttext' => 81 } }, {#State 41 @@ -838,10 +841,9 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 75, + 'anytext' => 82, 'text' => 24, - 'constant' => 27, - 'commalisttext' => 79 + 'constant' => 27 } }, {#State 42 @@ -853,7 +855,7 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 80, + 'anytext' => 83, 'text' => 24, 'constant' => 27 } @@ -867,7 +869,7 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 81, + 'anytext' => 84, 'text' => 24, 'constant' => 27 } @@ -881,9 +883,10 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 82, + 'anytext' => 80, 'text' => 24, - 'constant' => 27 + 'constant' => 27, + 'commalisttext' => 85 } }, {#State 45 @@ -895,7 +898,7 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 83, + 'anytext' => 86, 'text' => 24, 'constant' => 27 } @@ -909,406 +912,544 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 84, + 'anytext' => 87, 'text' => 24, 'constant' => 27 } }, {#State 47 - DEFAULT => -68 + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 88, + 'text' => 24, + 'constant' => 27 + } }, {#State 48 - DEFAULT => -63, + ACTIONS => { + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, GOTOS => { - 'property_list' => 85 + 'identifier' => 23, + 'anytext' => 89, + 'text' => 24, + 'constant' => 27 } }, {#State 49 ACTIONS => { - 'IDENTIFIER' => 86 + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 }, - DEFAULT => -91, + DEFAULT => -73, GOTOS => { - 'optional_identifier' => 87 + 'identifier' => 23, + 'anytext' => 90, + 'text' => 24, + 'constant' => 27 } }, {#State 50 - DEFAULT => -12 + DEFAULT => -68 }, {#State 51 - ACTIONS => { - "}" => 88, - "typedef" => 48, - "union" => 49, - "enum" => 62, - "bitmap" => 63, - "declare" => 55, - "const" => 57, - "struct" => 60 - }, DEFAULT => -63, GOTOS => { - 'typedecl' => 61, - 'function' => 50, - 'bitmap' => 64, - 'definition' => 89, - 'property_list' => 53, - 'usertype' => 52, - 'const' => 65, - 'struct' => 56, - 'declare' => 66, - 'enum' => 58, - 'typedef' => 59, - 'union' => 67 + 'property_list' => 91 } }, {#State 52 ACTIONS => { - ";" => 90 + 'IDENTIFIER' => 92 + }, + DEFAULT => -94, + GOTOS => { + 'optional_identifier' => 93 } }, {#State 53 + DEFAULT => -12 + }, + {#State 54 + ACTIONS => { + "}" => 94, + "typedef" => 51, + "union" => 52, + "enum" => 65, + "bitmap" => 66, + "declare" => 58, + "const" => 60, + "struct" => 63 + }, + DEFAULT => -63, + GOTOS => { + 'typedecl' => 64, + 'function' => 53, + 'bitmap' => 67, + 'definition' => 95, + 'property_list' => 56, + 'usertype' => 55, + 'const' => 68, + 'struct' => 59, + 'declare' => 69, + 'enum' => 61, + 'typedef' => 62, + 'union' => 70 + } + }, + {#State 55 + ACTIONS => { + ";" => 96 + } + }, + {#State 56 ACTIONS => { 'IDENTIFIER' => 9, - "union" => 49, - "enum" => 62, - "bitmap" => 63, + "union" => 52, + "enum" => 65, + "bitmap" => 66, "[" => 7, - 'void' => 91, - "struct" => 60 + 'void' => 97, + "struct" => 63 }, GOTOS => { - 'identifier' => 93, - 'struct' => 56, - 'enum' => 58, - 'type' => 94, - 'union' => 67, - 'bitmap' => 64, - 'usertype' => 92 + 'identifier' => 99, + 'struct' => 59, + 'enum' => 61, + 'type' => 100, + 'union' => 70, + 'bitmap' => 67, + 'usertype' => 98 } }, - {#State 54 + {#State 57 DEFAULT => -10 }, - {#State 55 + {#State 58 DEFAULT => -63, GOTOS => { - 'property_list' => 95 + 'property_list' => 101 } }, - {#State 56 + {#State 59 DEFAULT => -26 }, - {#State 57 + {#State 60 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 96 + 'identifier' => 102 } }, - {#State 58 + {#State 61 DEFAULT => -28 }, - {#State 59 + {#State 62 DEFAULT => -14 }, - {#State 60 + {#State 63 ACTIONS => { - 'IDENTIFIER' => 86 + 'IDENTIFIER' => 92 }, - DEFAULT => -91, + DEFAULT => -94, GOTOS => { - 'optional_identifier' => 97 + 'optional_identifier' => 103 } }, - {#State 61 + {#State 64 DEFAULT => -16 }, - {#State 62 + {#State 65 ACTIONS => { - 'IDENTIFIER' => 86 + 'IDENTIFIER' => 92 }, - DEFAULT => -91, + DEFAULT => -94, GOTOS => { - 'optional_identifier' => 98 + 'optional_identifier' => 104 } }, - {#State 63 + {#State 66 ACTIONS => { - 'IDENTIFIER' => 86 + 'IDENTIFIER' => 92 }, - DEFAULT => -91, + DEFAULT => -94, GOTOS => { - 'optional_identifier' => 99 + 'optional_identifier' => 105 } }, - {#State 64 + {#State 67 DEFAULT => -29 }, - {#State 65 + {#State 68 DEFAULT => -13 }, - {#State 66 + {#State 69 DEFAULT => -15 }, - {#State 67 + {#State 70 DEFAULT => -27 }, - {#State 68 - DEFAULT => -95 + {#State 71 + DEFAULT => -98 }, - {#State 69 + {#State 72 DEFAULT => -4 }, - {#State 70 + {#State 73 ACTIONS => { - ";" => 100 + ";" => 106 } }, - {#State 71 + {#State 74 ACTIONS => { - "<" => 35, - "~" => 36, - "{" => 38 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 + }, + DEFAULT => -86 + }, + {#State 75 + ACTIONS => { + ":" => 34, + "<" => 37, + "~" => 38, + "?" => 36, + "{" => 40, + "=" => 43 }, DEFAULT => -77 }, - {#State 72 + {#State 76 + ACTIONS => { + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 + }, + DEFAULT => -85 + }, + {#State 77 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "*" => 43, - "{" => 38, - "&" => 39, - "/" => 40, - "(" => 41, - "|" => 42, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 }, DEFAULT => -81 }, - {#State 73 + {#State 78 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "*" => 43, - "{" => 38, - "&" => 39, - "/" => 40, - "(" => 41, - "|" => 42, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 }, - DEFAULT => -86 + DEFAULT => -89 }, - {#State 74 + {#State 79 ACTIONS => { - "<" => 35, - "~" => 36, - "{" => 38 + ":" => 34, + "<" => 37, + "~" => 38, + "?" => 36, + "{" => 40, + "=" => 43 }, - DEFAULT => -85 + DEFAULT => -88 }, - {#State 75 + {#State 80 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "*" => 43, - "{" => 38, - "&" => 39, - "/" => 40, - "(" => 41, - "|" => 42, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 }, DEFAULT => -71 }, - {#State 76 + {#State 81 ACTIONS => { - "}" => 101, - "," => 102 + "}" => 107, + "," => 108 } }, - {#State 77 + {#State 82 ACTIONS => { - "<" => 35, - "~" => 36, - "{" => 38 + ":" => 34, + "<" => 37, + "~" => 38, + "?" => 36, + "{" => 40, + "=" => 43 }, DEFAULT => -83 }, - {#State 78 + {#State 83 ACTIONS => { - "<" => 35, - "~" => 36, - "{" => 38 + ":" => 34, + "<" => 37, + "~" => 38, + "?" => 36, + "{" => 40, + "=" => 43 }, DEFAULT => -84 }, - {#State 79 + {#State 84 ACTIONS => { - "," => 102, - ")" => 103 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 + }, + DEFAULT => -87 + }, + {#State 85 + ACTIONS => { + "," => 108, + ")" => 109 } }, - {#State 80 + {#State 86 ACTIONS => { - "<" => 35, - "~" => 36, - "{" => 38 + ":" => 34, + "<" => 37, + "~" => 38, + "?" => 36, + "{" => 40, + "=" => 43 }, DEFAULT => -82 }, - {#State 81 + {#State 87 ACTIONS => { - "<" => 35, - "~" => 36, - "{" => 38 + ":" => 34, + "<" => 37, + "~" => 38, + "?" => 36, + "{" => 40, + "=" => 43 }, DEFAULT => -79 }, - {#State 82 + {#State 88 ACTIONS => { - "<" => 35, - "~" => 36, - "{" => 38 + ":" => 34, + "<" => 37, + "~" => 38, + "?" => 36, + "{" => 40, + "=" => 43 }, DEFAULT => -78 }, - {#State 83 + {#State 89 ACTIONS => { - "<" => 35, - "~" => 36, - "{" => 38 + ":" => 34, + "<" => 37, + "~" => 38, + "?" => 36, + "{" => 40, + "=" => 43 }, DEFAULT => -80 }, - {#State 84 + {#State 90 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "&" => 39, - "{" => 38, - "/" => 40, - "|" => 42, - "(" => 41, - "*" => 43, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 }, DEFAULT => -70 }, - {#State 85 + {#State 91 ACTIONS => { 'IDENTIFIER' => 9, - "union" => 49, - "enum" => 62, - "bitmap" => 63, + "union" => 52, + "enum" => 65, + "bitmap" => 66, "[" => 7, - 'void' => 91, - "struct" => 60 + 'void' => 97, + "struct" => 63 }, GOTOS => { - 'identifier' => 93, - 'struct' => 56, - 'enum' => 58, - 'type' => 104, - 'union' => 67, - 'bitmap' => 64, - 'usertype' => 92 + 'identifier' => 99, + 'struct' => 59, + 'enum' => 61, + 'type' => 110, + 'union' => 70, + 'bitmap' => 67, + 'usertype' => 98 } }, - {#State 86 - DEFAULT => -90 + {#State 92 + DEFAULT => -93 }, - {#State 87 + {#State 93 ACTIONS => { - "{" => 105 + "{" => 111 } }, - {#State 88 + {#State 94 ACTIONS => { - ";" => 68 + ";" => 71 }, - DEFAULT => -94, + DEFAULT => -97, GOTOS => { - 'optional_semicolon' => 106 + 'optional_semicolon' => 112 } }, - {#State 89 + {#State 95 DEFAULT => -11 }, - {#State 90 + {#State 96 DEFAULT => -30 }, - {#State 91 + {#State 97 DEFAULT => -33 }, - {#State 92 + {#State 98 DEFAULT => -31 }, - {#State 93 + {#State 99 DEFAULT => -32 }, - {#State 94 + {#State 100 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 107 + 'identifier' => 113 } }, - {#State 95 + {#State 101 ACTIONS => { - "enum" => 111, - "bitmap" => 112, + "enum" => 117, + "bitmap" => 118, "[" => 7 }, GOTOS => { - 'decl_enum' => 108, - 'decl_bitmap' => 109, - 'decl_type' => 110 + 'decl_enum' => 114, + 'decl_bitmap' => 115, + 'decl_type' => 116 } }, - {#State 96 + {#State 102 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 113 + 'identifier' => 119 } }, - {#State 97 + {#State 103 ACTIONS => { - "{" => 114 + "{" => 120 } }, - {#State 98 + {#State 104 ACTIONS => { - "{" => 115 + "{" => 121 } }, - {#State 99 + {#State 105 ACTIONS => { - "{" => 116 + "{" => 122 } }, - {#State 100 + {#State 106 DEFAULT => -6 }, - {#State 101 + {#State 107 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1317,12 +1458,12 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 117, + 'anytext' => 123, 'text' => 24, 'constant' => 27 } }, - {#State 102 + {#State 108 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1331,12 +1472,12 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 118, + 'anytext' => 124, 'text' => 24, 'constant' => 27 } }, - {#State 103 + {#State 109 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1345,188 +1486,197 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 119, + 'anytext' => 125, 'text' => 24, 'constant' => 27 } }, - {#State 104 + {#State 110 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 120 + 'identifier' => 126 } }, - {#State 105 + {#State 111 DEFAULT => -48, GOTOS => { - 'union_elements' => 121 + 'union_elements' => 127 } }, - {#State 106 + {#State 112 DEFAULT => -7 }, - {#State 107 + {#State 113 ACTIONS => { - "(" => 122 + "(" => 128 } }, - {#State 108 + {#State 114 DEFAULT => -21 }, - {#State 109 + {#State 115 DEFAULT => -22 }, - {#State 110 + {#State 116 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 123 + 'identifier' => 129 } }, - {#State 111 + {#State 117 DEFAULT => -23 }, - {#State 112 + {#State 118 DEFAULT => -24 }, - {#State 113 + {#State 119 ACTIONS => { - "[" => 124, - "=" => 126 + "[" => 130, + "=" => 132 }, GOTOS => { - 'array_len' => 125 + 'array_len' => 131 } }, - {#State 114 + {#State 120 DEFAULT => -54, GOTOS => { - 'element_list1' => 127 + 'element_list1' => 133 } }, - {#State 115 + {#State 121 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 128, - 'enum_element' => 129, - 'enum_elements' => 130 + 'identifier' => 134, + 'enum_element' => 135, + 'enum_elements' => 136 } }, - {#State 116 + {#State 122 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 133, - 'bitmap_elements' => 132, - 'bitmap_element' => 131 + 'identifier' => 139, + 'bitmap_elements' => 138, + 'bitmap_element' => 137 } }, - {#State 117 + {#State 123 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "*" => 43, - "{" => 38, - "&" => 39, - "/" => 40, - "(" => 41, - "|" => 42, - "." => 44, - ">" => 45 - }, - DEFAULT => -88 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 + }, + DEFAULT => -91 }, - {#State 118 + {#State 124 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "*" => 43, - "{" => 38, - "&" => 39, - "/" => 40, - "(" => 41, - "|" => 42, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 }, DEFAULT => -72 }, - {#State 119 + {#State 125 ACTIONS => { - "<" => 35, - "~" => 36, - "{" => 38 + ":" => 34, + "<" => 37, + "~" => 38, + "?" => 36, + "{" => 40, + "=" => 43 }, - DEFAULT => -87 + DEFAULT => -90 }, - {#State 120 + {#State 126 ACTIONS => { - "[" => 124 + "[" => 130 }, DEFAULT => -60, GOTOS => { - 'array_len' => 134 + 'array_len' => 140 } }, - {#State 121 + {#State 127 ACTIONS => { - "}" => 135 + "}" => 141 }, DEFAULT => -63, GOTOS => { - 'optional_base_element' => 137, - 'property_list' => 136 + 'optional_base_element' => 143, + 'property_list' => 142 } }, - {#State 122 + {#State 128 ACTIONS => { "," => -56, - "void" => 141, + "void" => 147, ")" => -56 }, DEFAULT => -63, GOTOS => { - 'base_element' => 138, - 'element_list2' => 140, - 'property_list' => 139 + 'base_element' => 144, + 'element_list2' => 146, + 'property_list' => 145 } }, - {#State 123 + {#State 129 ACTIONS => { - ";" => 142 + ";" => 148 } }, - {#State 124 + {#State 130 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, - "]" => 143, + "]" => 149, 'IDENTIFIER' => 9 }, DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 144, + 'anytext' => 150, 'text' => 24, 'constant' => 27 } }, - {#State 125 + {#State 131 ACTIONS => { - "=" => 145 + "=" => 151 } }, - {#State 126 + {#State 132 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1535,135 +1685,138 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 146, + 'anytext' => 152, 'text' => 24, 'constant' => 27 } }, - {#State 127 + {#State 133 ACTIONS => { - "}" => 147 + "}" => 153 }, DEFAULT => -63, GOTOS => { - 'base_element' => 148, - 'property_list' => 139 + 'base_element' => 154, + 'property_list' => 145 } }, - {#State 128 + {#State 134 ACTIONS => { - "=" => 149 + "=" => 155 }, DEFAULT => -37 }, - {#State 129 + {#State 135 DEFAULT => -35 }, - {#State 130 + {#State 136 ACTIONS => { - "}" => 150, - "," => 151 + "}" => 156, + "," => 157 } }, - {#State 131 + {#State 137 DEFAULT => -40 }, - {#State 132 + {#State 138 ACTIONS => { - "}" => 152, - "," => 153 + "}" => 158, + "," => 159 } }, - {#State 133 + {#State 139 ACTIONS => { - "=" => 154 + "=" => 160 } }, - {#State 134 + {#State 140 ACTIONS => { - ";" => 155 + ";" => 161 } }, - {#State 135 + {#State 141 DEFAULT => -50 }, - {#State 136 + {#State 142 ACTIONS => { "[" => 7 }, DEFAULT => -63, GOTOS => { - 'base_or_empty' => 156, - 'base_element' => 157, - 'empty_element' => 158, - 'property_list' => 159 + 'base_or_empty' => 162, + 'base_element' => 163, + 'empty_element' => 164, + 'property_list' => 165 } }, - {#State 137 + {#State 143 DEFAULT => -49 }, - {#State 138 + {#State 144 DEFAULT => -58 }, - {#State 139 + {#State 145 ACTIONS => { 'IDENTIFIER' => 9, - "union" => 49, - "enum" => 62, - "bitmap" => 63, + "union" => 52, + "enum" => 65, + "bitmap" => 66, "[" => 7, - 'void' => 91, - "struct" => 60 + 'void' => 97, + "struct" => 63 }, GOTOS => { - 'identifier' => 93, - 'struct' => 56, - 'enum' => 58, - 'type' => 160, - 'union' => 67, - 'bitmap' => 64, - 'usertype' => 92 + 'identifier' => 99, + 'struct' => 59, + 'enum' => 61, + 'type' => 166, + 'union' => 70, + 'bitmap' => 67, + 'usertype' => 98 } }, - {#State 140 + {#State 146 ACTIONS => { - "," => 161, - ")" => 162 + "," => 167, + ")" => 168 } }, - {#State 141 + {#State 147 DEFAULT => -57 }, - {#State 142 + {#State 148 DEFAULT => -20 }, - {#State 143 + {#State 149 ACTIONS => { - "[" => 124 + "[" => 130 }, DEFAULT => -60, GOTOS => { - 'array_len' => 163 + 'array_len' => 169 } }, - {#State 144 + {#State 150 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "&" => 39, - "{" => 38, - "/" => 40, - "|" => 42, - "(" => 41, - "*" => 43, - "." => 44, - "]" => 164, - ">" => 45 + "-" => 35, + ":" => 34, + "?" => 36, + "<" => 37, + "+" => 39, + "~" => 38, + "&" => 41, + "{" => 40, + "/" => 42, + "=" => 43, + "|" => 45, + "(" => 44, + "*" => 46, + "." => 47, + "]" => 170, + ">" => 48 } }, - {#State 145 + {#State 151 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1672,37 +1825,40 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 165, + 'anytext' => 171, 'text' => 24, 'constant' => 27 } }, - {#State 146 + {#State 152 ACTIONS => { - "-" => 34, - "<" => 35, - ";" => 166, - "+" => 37, - "~" => 36, - "&" => 39, - "{" => 38, - "/" => 40, - "|" => 42, - "(" => 41, - "*" => 43, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "?" => 36, + "<" => 37, + ";" => 172, + "+" => 39, + "~" => 38, + "&" => 41, + "{" => 40, + "/" => 42, + "=" => 43, + "|" => 45, + "(" => 44, + "*" => 46, + "." => 47, + ">" => 48 } }, - {#State 147 + {#State 153 DEFAULT => -43 }, - {#State 148 + {#State 154 ACTIONS => { - ";" => 167 + ";" => 173 } }, - {#State 149 + {#State 155 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1711,36 +1867,36 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 168, + 'anytext' => 174, 'text' => 24, 'constant' => 27 } }, - {#State 150 + {#State 156 DEFAULT => -34 }, - {#State 151 + {#State 157 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 128, - 'enum_element' => 169 + 'identifier' => 134, + 'enum_element' => 175 } }, - {#State 152 + {#State 158 DEFAULT => -39 }, - {#State 153 + {#State 159 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 133, - 'bitmap_element' => 170 + 'identifier' => 139, + 'bitmap_element' => 176 } }, - {#State 154 + {#State 160 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1749,179 +1905,188 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 171, + 'anytext' => 177, 'text' => 24, 'constant' => 27 } }, - {#State 155 + {#State 161 DEFAULT => -25 }, - {#State 156 + {#State 162 DEFAULT => -47 }, - {#State 157 + {#State 163 ACTIONS => { - ";" => 172 + ";" => 178 } }, - {#State 158 + {#State 164 DEFAULT => -46 }, - {#State 159 + {#State 165 ACTIONS => { 'IDENTIFIER' => 9, - "union" => 49, - ";" => 173, - "enum" => 62, - "bitmap" => 63, - 'void' => 91, + "union" => 52, + ";" => 179, + "enum" => 65, + "bitmap" => 66, + 'void' => 97, "[" => 7, - "struct" => 60 + "struct" => 63 }, GOTOS => { - 'identifier' => 93, - 'struct' => 56, - 'enum' => 58, - 'type' => 160, - 'union' => 67, - 'bitmap' => 64, - 'usertype' => 92 + 'identifier' => 99, + 'struct' => 59, + 'enum' => 61, + 'type' => 166, + 'union' => 70, + 'bitmap' => 67, + 'usertype' => 98 } }, - {#State 160 + {#State 166 DEFAULT => -52, GOTOS => { - 'pointers' => 174 + 'pointers' => 180 } }, - {#State 161 + {#State 167 DEFAULT => -63, GOTOS => { - 'base_element' => 175, - 'property_list' => 139 + 'base_element' => 181, + 'property_list' => 145 } }, - {#State 162 + {#State 168 ACTIONS => { - ";" => 176 + ";" => 182 } }, - {#State 163 + {#State 169 DEFAULT => -61 }, - {#State 164 + {#State 170 ACTIONS => { - "[" => 124 + "[" => 130 }, DEFAULT => -60, GOTOS => { - 'array_len' => 177 + 'array_len' => 183 } }, - {#State 165 + {#State 171 ACTIONS => { - "-" => 34, - "<" => 35, - ";" => 178, - "+" => 37, - "~" => 36, - "&" => 39, - "{" => 38, - "/" => 40, - "|" => 42, - "(" => 41, - "*" => 43, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "?" => 36, + "<" => 37, + ";" => 184, + "+" => 39, + "~" => 38, + "&" => 41, + "{" => 40, + "/" => 42, + "=" => 43, + "|" => 45, + "(" => 44, + "*" => 46, + "." => 47, + ">" => 48 } }, - {#State 166 + {#State 172 DEFAULT => -17 }, - {#State 167 + {#State 173 DEFAULT => -55 }, - {#State 168 + {#State 174 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "&" => 39, - "{" => 38, - "/" => 40, - "|" => 42, - "(" => 41, - "*" => 43, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 }, DEFAULT => -38 }, - {#State 169 + {#State 175 DEFAULT => -36 }, - {#State 170 + {#State 176 DEFAULT => -41 }, - {#State 171 + {#State 177 ACTIONS => { - "-" => 34, - "<" => 35, - "+" => 37, - "~" => 36, - "&" => 39, - "{" => 38, - "/" => 40, - "|" => 42, - "(" => 41, - "*" => 43, - "." => 44, - ">" => 45 + "-" => 35, + ":" => 34, + "<" => 37, + "+" => 39, + "~" => 38, + "*" => 46, + "?" => 36, + "{" => 40, + "&" => 41, + "/" => 42, + "=" => 43, + "(" => 44, + "|" => 45, + "." => 47, + ">" => 48 }, DEFAULT => -42 }, - {#State 172 + {#State 178 DEFAULT => -45 }, - {#State 173 + {#State 179 DEFAULT => -44 }, - {#State 174 + {#State 180 ACTIONS => { 'IDENTIFIER' => 9, - "*" => 180 + "*" => 186 }, GOTOS => { - 'identifier' => 179 + 'identifier' => 185 } }, - {#State 175 + {#State 181 DEFAULT => -59 }, - {#State 176 + {#State 182 DEFAULT => -19 }, - {#State 177 + {#State 183 DEFAULT => -62 }, - {#State 178 + {#State 184 DEFAULT => -18 }, - {#State 179 + {#State 185 ACTIONS => { - "[" => 124 + "[" => 130 }, DEFAULT => -60, GOTOS => { - 'array_len' => 181 + 'array_len' => 187 } }, - {#State 180 + {#State 186 DEFAULT => -53 }, - {#State 181 + {#State 187 DEFAULT => -51 } ], @@ -1936,19 +2101,19 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "idl.yp" +#line 19 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "idl.yp" +#line 20 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'coclass', 7, sub -#line 24 "idl.yp" +#line 24 "pidl/idl.yp" {$_[3] => { "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -1964,13 +2129,13 @@ sub [#Rule 6 'interface_names', 4, sub -#line 36 "idl.yp" +#line 36 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'interface', 8, sub -#line 40 "idl.yp" +#line 40 "pidl/idl.yp" {$_[3] => { "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -1987,19 +2152,19 @@ sub [#Rule 9 'base_interface', 2, sub -#line 53 "idl.yp" +#line 53 "pidl/idl.yp" { $_[2] } ], [#Rule 10 'definitions', 1, sub -#line 57 "idl.yp" +#line 57 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 11 'definitions', 2, sub -#line 58 "idl.yp" +#line 58 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 12 @@ -2020,7 +2185,7 @@ sub [#Rule 17 'const', 6, sub -#line 66 "idl.yp" +#line 66 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2033,7 +2198,7 @@ sub [#Rule 18 'const', 7, sub -#line 75 "idl.yp" +#line 75 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2047,7 +2212,7 @@ sub [#Rule 19 'function', 7, sub -#line 88 "idl.yp" +#line 88 "pidl/idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2061,7 +2226,7 @@ sub [#Rule 20 'declare', 5, sub -#line 100 "idl.yp" +#line 100 "pidl/idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2080,7 +2245,7 @@ sub [#Rule 23 'decl_enum', 1, sub -#line 114 "idl.yp" +#line 114 "pidl/idl.yp" {{ "TYPE" => "ENUM" }} @@ -2088,7 +2253,7 @@ sub [#Rule 24 'decl_bitmap', 1, sub -#line 120 "idl.yp" +#line 120 "pidl/idl.yp" {{ "TYPE" => "BITMAP" }} @@ -2096,7 +2261,7 @@ sub [#Rule 25 'typedef', 6, sub -#line 126 "idl.yp" +#line 126 "pidl/idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], @@ -2122,7 +2287,7 @@ sub [#Rule 30 'typedecl', 2, sub -#line 139 "idl.yp" +#line 139 "pidl/idl.yp" { $_[1] } ], [#Rule 31 @@ -2134,13 +2299,13 @@ sub [#Rule 33 'type', 1, sub -#line 142 "idl.yp" +#line 142 "pidl/idl.yp" { "void" } ], [#Rule 34 'enum', 5, sub -#line 146 "idl.yp" +#line 146 "pidl/idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], @@ -2150,13 +2315,13 @@ sub [#Rule 35 'enum_elements', 1, sub -#line 154 "idl.yp" +#line 154 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 36 'enum_elements', 3, sub -#line 155 "idl.yp" +#line 155 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 37 @@ -2165,13 +2330,13 @@ sub [#Rule 38 'enum_element', 3, sub -#line 159 "idl.yp" +#line 159 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 39 'bitmap', 5, sub -#line 163 "idl.yp" +#line 163 "pidl/idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], @@ -2181,25 +2346,25 @@ sub [#Rule 40 'bitmap_elements', 1, sub -#line 171 "idl.yp" +#line 171 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 41 'bitmap_elements', 3, sub -#line 172 "idl.yp" +#line 172 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 42 'bitmap_element', 3, sub -#line 175 "idl.yp" +#line 175 "pidl/idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 43 'struct', 5, sub -#line 179 "idl.yp" +#line 179 "pidl/idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], @@ -2209,7 +2374,7 @@ sub [#Rule 44 'empty_element', 2, sub -#line 187 "idl.yp" +#line 187 "pidl/idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2229,7 +2394,7 @@ sub [#Rule 47 'optional_base_element', 2, sub -#line 201 "idl.yp" +#line 201 "pidl/idl.yp" { $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 48 @@ -2238,13 +2403,13 @@ sub [#Rule 49 'union_elements', 2, sub -#line 206 "idl.yp" +#line 206 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 50 'union', 5, sub -#line 210 "idl.yp" +#line 210 "pidl/idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], @@ -2254,7 +2419,7 @@ sub [#Rule 51 'base_element', 5, sub -#line 218 "idl.yp" +#line 218 "pidl/idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2268,13 +2433,13 @@ sub [#Rule 52 'pointers', 0, sub -#line 232 "idl.yp" +#line 232 "pidl/idl.yp" { 0 } ], [#Rule 53 'pointers', 2, sub -#line 233 "idl.yp" +#line 233 "pidl/idl.yp" { $_[1]+1 } ], [#Rule 54 @@ -2283,7 +2448,7 @@ sub [#Rule 55 'element_list1', 3, sub -#line 238 "idl.yp" +#line 238 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 56 @@ -2295,13 +2460,13 @@ sub [#Rule 58 'element_list2', 1, sub -#line 244 "idl.yp" +#line 244 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 59 'element_list2', 3, sub -#line 245 "idl.yp" +#line 245 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 60 @@ -2310,13 +2475,13 @@ sub [#Rule 61 'array_len', 3, sub -#line 250 "idl.yp" +#line 250 "pidl/idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 62 'array_len', 4, sub -#line 251 "idl.yp" +#line 251 "pidl/idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 63 @@ -2325,31 +2490,31 @@ sub [#Rule 64 'property_list', 4, sub -#line 257 "idl.yp" +#line 257 "pidl/idl.yp" { Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); } ], [#Rule 65 'properties', 1, sub -#line 260 "idl.yp" +#line 260 "pidl/idl.yp" { $_[1] } ], [#Rule 66 'properties', 3, sub -#line 261 "idl.yp" +#line 261 "pidl/idl.yp" { Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); } ], [#Rule 67 'property', 1, sub -#line 264 "idl.yp" +#line 264 "pidl/idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 68 'property', 4, sub -#line 265 "idl.yp" +#line 265 "pidl/idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 69 @@ -2358,7 +2523,7 @@ sub [#Rule 70 'listtext', 3, sub -#line 270 "idl.yp" +#line 270 "pidl/idl.yp" { "$_[1] $_[3]" } ], [#Rule 71 @@ -2367,13 +2532,13 @@ sub [#Rule 72 'commalisttext', 3, sub -#line 275 "idl.yp" +#line 275 "pidl/idl.yp" { "$_[1],$_[3]" } ], [#Rule 73 'anytext', 0, sub -#line 279 "idl.yp" +#line 279 "pidl/idl.yp" { "" } ], [#Rule 74 @@ -2388,97 +2553,115 @@ sub [#Rule 77 'anytext', 3, sub -#line 281 "idl.yp" +#line 281 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 78 'anytext', 3, sub -#line 282 "idl.yp" +#line 282 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 79 'anytext', 3, sub -#line 283 "idl.yp" +#line 283 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 80 'anytext', 3, sub -#line 284 "idl.yp" +#line 284 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 81 'anytext', 3, sub -#line 285 "idl.yp" +#line 285 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 82 'anytext', 3, sub -#line 286 "idl.yp" +#line 286 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 83 'anytext', 3, sub -#line 287 "idl.yp" +#line 287 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 84 'anytext', 3, sub -#line 288 "idl.yp" +#line 288 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 85 'anytext', 3, sub -#line 289 "idl.yp" +#line 289 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 86 'anytext', 3, sub -#line 290 "idl.yp" +#line 290 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 87 + 'anytext', 3, +sub +#line 291 "pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 88 + 'anytext', 3, +sub +#line 292 "pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 89 + 'anytext', 3, +sub +#line 293 "pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 90 'anytext', 5, sub -#line 291 "idl.yp" +#line 294 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 88 + [#Rule 91 'anytext', 5, sub -#line 292 "idl.yp" +#line 295 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 89 + [#Rule 92 'identifier', 1, undef ], - [#Rule 90 + [#Rule 93 'optional_identifier', 1, undef ], - [#Rule 91 + [#Rule 94 'optional_identifier', 0, undef ], - [#Rule 92 + [#Rule 95 'constant', 1, undef ], - [#Rule 93 + [#Rule 96 'text', 1, sub -#line 306 "idl.yp" +#line 309 "pidl/idl.yp" { "\"$_[1]\"" } ], - [#Rule 94 + [#Rule 97 'optional_semicolon', 0, undef ], - [#Rule 95 + [#Rule 98 'optional_semicolon', 1, undef ] ], @@ -2486,7 +2669,7 @@ sub bless($self,$class); } -#line 317 "idl.yp" +#line 320 "pidl/idl.yp" use Parse::Pidl::Util; -- cgit From a3e0e69196cc5e3420ebb1a83b026ee36cbaab83 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 4 Sep 2005 20:17:21 +0000 Subject: r10030: Add hierarchical memory allocation to TDR's pull functions (This used to be commit 0e358de93a007db921ad5e9a892114122254de39) --- source4/pidl/lib/Parse/Pidl/Samba/TDR.pm | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm index 041170c152..9bcf7f1a77 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm @@ -17,9 +17,10 @@ sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $ret .= $tabs.(shift)."\n"; } sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } sub static($) { my $p = shift; return("static ") unless ($p); return ""; } -sub printarg($) { +sub typearg($) { my $t = shift; return(", const char *name") if ($t eq "print"); + return(", TALLOC_CTX *mem_ctx") if ($t eq "pull"); return(""); } @@ -41,6 +42,7 @@ sub ParserElement($$$) my $switch = ""; my $array = ""; my $name = ""; + my $mem_ctx = "mem_ctx"; fatal($e,"Pointers not supported in TDR") if ($e->{POINTERS} > 0); fatal($e,"size_is() not supported in TDR") if (has_property($e, "size_is")); @@ -62,11 +64,11 @@ sub ParserElement($$$) my $len = ParseExpr(@{$e->{ARRAY_LEN}}[0], $env); if ($len eq "*") { $len = "-1"; } + $name = ", mem_ctx" if ($t eq "pull"); pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));"; return; } - if (has_property($e, "switch_is")) { $switch = ", " . ParseExpr($e->{PROPERTIES}->{switch_is}, $env); } @@ -75,7 +77,8 @@ sub ParserElement($$$) my $len = ParseExpr($e->{ARRAY_LEN}[0], $env); if ($t eq "pull" and not is_constant($len)) { - pidl "TDR_ALLOC(tdr, v->$e->{NAME}, $len);" + pidl "TDR_ALLOC(mem_ctx, v->$e->{NAME}, $len);"; + $mem_ctx = "v->$e->{NAME}"; } pidl "for (i = 0; i < $len; i++) {"; @@ -83,6 +86,10 @@ sub ParserElement($$$) $array = "[i]"; } + if ($t eq "pull") { + $name = ", $mem_ctx"; + } + if (has_property($e, "value") && $t eq "push") { pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env).";"; } @@ -102,7 +109,7 @@ sub ParserStruct($$$$) { my ($e,$n,$t,$p) = @_; - pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", struct $n *v)"; + pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", struct $n *v)"; pidl "{"; indent; pidl "int i;" if (ContainsArray($e)); @@ -128,7 +135,7 @@ sub ParserUnion($$$$) { my ($e,$n,$t,$p) = @_; - pidl static($p)."NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".printarg($t).", int level, union $n *v)"; + pidl static($p)."NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".typearg($t).", int level, union $n *v)"; pidl "{"; indent; pidl "int i;" if (ContainsArray($e)); @@ -169,11 +176,11 @@ sub ParserEnum($$$$) my ($e,$n,$t,$p) = @_; my $bt = ($e->{PROPERTIES}->{base_type} or "uint8"); - pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", enum $n *v)"; + pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", enum $n *v)"; pidl "{"; if ($t eq "pull") { pidl "\t$bt\_t r;"; - pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, \&r));"; + pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, mem_ctx, \&r));"; pidl "\t*v = r;"; } elsif ($t eq "push") { pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));"; @@ -242,7 +249,7 @@ sub HeaderInterface($$) # FIXME } else { my ($n, $d) = ($e->{NAME}, lc($e->{DATA}->{TYPE})); - pidl "NTSTATUS tdr_pull\_$n(struct tdr_pull *tdr$switch, $d $n *v);"; + pidl "NTSTATUS tdr_pull\_$n(struct tdr_pull *tdr, TALLOC_CTX *ctx$switch, $d $n *v);"; pidl "NTSTATUS tdr_print\_$n(struct tdr_print *tdr, const char *name$switch, $d $n *v);"; pidl "NTSTATUS tdr_push\_$n(struct tdr_push *tdr$switch, $d $n *v);"; } -- cgit From e817e44bfe3f9af27d3ce8cba563e559d79e5eb5 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Tue, 6 Sep 2005 01:52:34 +0000 Subject: r10047: Translate an idl NTTIME to an ethereal FT_ABSOLUTE_TIME instead of a FT_UINT64. Not sure about a NTTIME_hyper though. (This used to be commit 42568d3f286679656417301d1cf29d3f0cd71030) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index dbaf12b572..ee774d1898 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -33,8 +33,12 @@ sub type2ft($) return "FT_UINT$1" if $t =~ /uint(8|16|32|64)/; return "FT_INT$1" if $t =~ /int(8|16|32|64)/; - return "FT_UINT64", if $t eq "HYPER_T" or $t eq "NTTIME" - or $t eq "NTTIME_1sec" or $t eq "NTTIME_hyper" or $t eq "hyper"; + return "FT_UINT64", if $t eq "HYPER_T" or $t eq "NTTIME_hyper" + or $t eq "hyper"; + + # TODO: should NTTIME_hyper be a FT_ABSOLUTE_TIME as well? + + return "FT_ABSOLUTE_TIME" if $t eq "NTTIME" or $t eq "NTTIME_1sec"; return "FT_STRING" if ($t eq "string"); -- cgit From e6190e6be55c8e6037b0cb2b357e133f5b313a02 Mon Sep 17 00:00:00 2001 From: James Peach Date: Thu, 8 Sep 2005 08:18:08 +0000 Subject: r10071: Configure checks for IRIX build environment. Test whether we can use the MIPSPro 7.4 -c99 option to get C99 support. Try to find a common perl that is more modern than /usr/bin/perl. (This used to be commit 82fab8b747bf68d8548c6f0f2f4bff98bd428d22) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 203e052022..2e73bd8410 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -2672,6 +2672,7 @@ sub #line 320 "pidl/idl.yp" +use config qw(%config); use Parse::Pidl::Util; ##################################################################### @@ -2775,7 +2776,7 @@ sub parse_idl($$) undef $/; my $cpp = $ENV{CPP}; if (! defined $cpp) { - $cpp = "cpp" + $cpp = $config::config{'CPP'}; } my $data = `$cpp -D__PIDL__ -xc $filename`; $/ = $saved_delim; -- cgit From c070fd62228a4fb0af0d275edc3d141e44dff389 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 8 Sep 2005 10:35:55 +0000 Subject: r10074: Pass CPP to pidl via environment variables rather then config.pm. This fixes the standalone pidl build (as used for ethereal) (This used to be commit 9c9ebd2214423c58357854f09bd744e13e807d8f) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 2e73bd8410..dd667cb9eb 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -2672,7 +2672,6 @@ sub #line 320 "pidl/idl.yp" -use config qw(%config); use Parse::Pidl::Util; ##################################################################### @@ -2776,7 +2775,7 @@ sub parse_idl($$) undef $/; my $cpp = $ENV{CPP}; if (! defined $cpp) { - $cpp = $config::config{'CPP'}; + $cpp = "CPP"; } my $data = `$cpp -D__PIDL__ -xc $filename`; $/ = $saved_delim; -- cgit From d9cdaccaa7049c773e876047320839dd6d2d9459 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 8 Sep 2005 21:59:40 +0000 Subject: r10093: Fix the HF_FIELD conformance file command (This used to be commit 0c0a4b55cff4079276073060dae91ff0c19af42f) --- source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 9 ++++----- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 19 ++++++++++--------- source4/pidl/lib/Parse/Pidl/IDL.pm | 2 +- 3 files changed, 15 insertions(+), 15 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index 8a4782073d..d0a3047939 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -29,7 +29,6 @@ sub handle_type($$$$$$$$) }; } - sub handle_hf_rename($$$) { my ($data,$old,$new) = @_; @@ -45,11 +44,11 @@ sub handle_param_value($$$) sub handle_hf_field($$$$$$$$$) { - my ($data,$hf,$title,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; + my ($data,$index,$name,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; - $data->{header_fields}->{$hf} = { - HF => $hf, - TITLE => $title, + $data->{header_fields}->{$index} = { + INDEX => $index, + NAME => $name, FILTER => $filter, FT_TYPE => $ft_type, BASE_TYPE => $base_type, diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index ee774d1898..315c31a6f6 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -16,10 +16,9 @@ use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); use Parse::Pidl::Ethereal::Conformance qw(ReadConformance); my %types; -my %hf; my @ett; -my $conformance = {imports=>{}}; +my $conformance = undef; my %ptrtype_mappings = ( "unique" => "NDR_POINTER_UNIQUE", @@ -671,7 +670,10 @@ sub Initialize($) { my $cnf_file = shift; - $conformance = {}; + $conformance = { + imports => {}, + header_fields=> {} + }; ReadConformance($cnf_file, $conformance) or print "Warning: No conformance file `$cnf_file'\n"; @@ -716,7 +718,6 @@ sub Parse($$$$) $tabs = ""; %res = (code=>"",def=>"",hdr=>""); - %hf = (); @ett = (); my $notice = @@ -814,13 +815,13 @@ sub register_hf_field($$$$$$$$) return $conformance->{hf_renames}->{$index} if defined ($conformance->{hf_renames}->{$index}); - $hf{$index} = { + $conformance->{header_fields}->{$index} = { INDEX => $index, NAME => $name, FILTER => $filter_name, FT_TYPE => $ft_type, BASE_TYPE => $base_type, - VALS => $valsstring, + VALSSTRING => $valsstring, MASK => $mask, BLURB => $blurb }; @@ -834,7 +835,7 @@ sub DumpHfDeclaration() $res = "\n/* Header field declarations */\n"; - foreach (keys %hf) + foreach (keys %{$conformance->{header_fields}}) { $res .= "static gint $_ = -1;\n"; } @@ -846,10 +847,10 @@ sub DumpHfList() { my $res = "\tstatic hf_register_info hf[] = {\n"; - foreach (values %hf) + foreach (values %{$conformance->{header_fields}}) { $res .= "\t{ &$_->{INDEX}, - { \"$_->{NAME}\", \"$_->{FILTER}\", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALS}, $_->{MASK}, \"$_->{BLURB}\", HFILL }}, + { \"$_->{NAME}\", \"$_->{FILTER}\", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALSSTRING}, $_->{MASK}, \"$_->{BLURB}\", HFILL }}, "; } diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index dd667cb9eb..1aa4426cd6 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -2775,7 +2775,7 @@ sub parse_idl($$) undef $/; my $cpp = $ENV{CPP}; if (! defined $cpp) { - $cpp = "CPP"; + $cpp = "cpp"; } my $data = `$cpp -D__PIDL__ -xc $filename`; $/ = $saved_delim; -- cgit From b2f3a85f78dcdb5a14ecefcd02949e528c35988b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 8 Sep 2005 22:33:48 +0000 Subject: r10094: Support quoted arguments in conformance files Update pidl manpage (This used to be commit a69e88e7b19b8f05222b54aea88395b51b96c003) --- source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index d0a3047939..7ba6af3815 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -147,10 +147,11 @@ sub ReadConformance($$) next; } - my @fields = split(/ /); + my @fields = split(/([^ ]+|"[^"]+")/); - my $cmd = $fields[0]; + my $cmd = $fields[1]; + shift @fields; shift @fields; if (not defined($field_handlers{$cmd})) { -- cgit From 79f476a1126cc1426eb7f42d9d2b1f63051e69b1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 9 Sep 2005 10:30:19 +0000 Subject: r10110: Add some more warnings, implement FIELD_DESCRIPTION (This used to be commit 1caeb3238dac6321bde8e254a8efaf090b4d56b0) --- .../pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 106 +++++++++++++++++---- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 6 ++ 2 files changed, 91 insertions(+), 21 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index 7ba6af3815..9e6147b166 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -14,12 +14,31 @@ use strict; use Parse::Pidl::Util qw(has_property); -sub handle_type($$$$$$$$) +sub handle_type($$$$$$$$$$) { - my ($data,$name,$dissectorname,$ft_type,$base_type,$mask,$valsstring,$alignment) = @_; + my ($pos,$data,$name,$dissectorname,$ft_type,$base_type,$mask,$valsstring,$alignment) = @_; + + unless(defined($alignment)) { + print "$pos: error incomplete TYPE command\n"; + return; + } + + unless ($dissectorname =~ /.*dissect_.*/) { + print "$pos: warning: dissector name does not contain `dissect'\n"; + } + + unless(valid_ft_type($ft_type)) { + print "$pos: warning: invalid FT_TYPE `$ft_type'\n"; + } + + unless(alid_base_type($base_type)) { + print "$pos: warning: invalid BASE_TYPE `$base_type'\n"; + } $data->{types}->{$name} = { NAME => $name, + POS => $pos, + USED => 0, DISSECTOR_NAME => $dissectorname, FT_TYPE => $ft_type, BASE_TYPE => $base_type, @@ -29,25 +48,65 @@ sub handle_type($$$$$$$$) }; } -sub handle_hf_rename($$$) +sub handle_hf_rename($$$$) { - my ($data,$old,$new) = @_; - $data->{hf_renames}{$old} = $new; + my ($pos,$data,$old,$new) = @_; + + unless(defined($new)) { + print "$pos: error incomplete HF_RENAME command\n"; + return; + } + + $data->{hf_renames}->{$old} = $new; } -sub handle_param_value($$$) +sub handle_param_value($$$$) { - my ($data,$dissector_name,$value) = @_; + my ($pos,$data,$dissector_name,$value) = @_; + + unless(defined($value)) { + print "$pos: error: incomplete PARAM_VALUE command\n"; + return; + } $data->{dissectorparams}->{$dissector_name} = $value; } -sub handle_hf_field($$$$$$$$$) +sub valid_base_type($) +{ + my $t = shift; + return 0 unless($t =~ /^BASE_.*/); + return 1; +} + +sub valid_ft_type($) { - my ($data,$index,$name,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; + my $t = shift; + return 0 unless($t =~ /^FT_.*/); + return 1; +} + +sub handle_hf_field($$$$$$$$$$) +{ + my ($pos,$data,$index,$name,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; + + unless(defined($blurb)) { + print "$pos: error: incomplete HF_FIELD command\n"; + return; + } + + unless(valid_ft_type($ft_type)) { + print "$pos: warning: invalid FT_TYPE `$ft_type'\n"; + } + + unless(valid_base_type($base_type)) { + print "$pos: warning: invalid BASE_TYPE `$base_type'\n"; + } $data->{header_fields}->{$index} = { INDEX => $index, + POS => $pos, + USED => 0, NAME => $name, FILTER => $filter, FT_TYPE => $ft_type, @@ -58,16 +117,16 @@ sub handle_hf_field($$$$$$$$$) }; } -sub handle_strip_prefix($$) +sub handle_strip_prefix($$$) { - my ($data,$x) = @_; + my ($pos,$data,$x) = @_; push (@{$data->{strip_prefixes}}, $x); } -sub handle_noemit($$) +sub handle_noemit($$$) { - my ($data) = shift; + my ($pos,$data) = @_; my $type; $type = shift if ($#_ == 1); @@ -79,9 +138,9 @@ sub handle_noemit($$) } } -sub handle_protocol($$$$$) +sub handle_protocol($$$$$$) { - my ($data, $name, $longname, $shortname, $filtername) = @_; + my ($pos, $data, $name, $longname, $shortname, $filtername) = @_; $data->{protocols}->{$name} = { LONGNAME => $longname, @@ -90,18 +149,24 @@ sub handle_protocol($$$$$) }; } -sub handle_fielddescription($$$) +sub handle_fielddescription($$$$) { - my ($data,$field,$desc) = @_; + my ($pos,$data,$field,$desc) = @_; $data->{fielddescription}->{$field} = $desc; } sub handle_import { + my $pos = shift @_; my $data = shift @_; my $dissectorname = shift @_; + unless(defined($dissectorname)) { + print "$pos: error: no dissectorname specified\n"; + return; + } + $data->{imports}->{$dissectorname} = join(' ', @_); } @@ -147,11 +212,10 @@ sub ReadConformance($$) next; } - my @fields = split(/([^ ]+|"[^"]+")/); + my @fields = /([^ "]+|"[^"]+")/g; - my $cmd = $fields[1]; + my $cmd = $fields[0]; - shift @fields; shift @fields; if (not defined($field_handlers{$cmd})) { @@ -159,7 +223,7 @@ sub ReadConformance($$) next; } - $field_handlers{$cmd}($data, @fields); + $field_handlers{$cmd}("$f:$ln", $data, @fields); } close(IN); diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 315c31a6f6..119dc46707 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -826,6 +826,12 @@ sub register_hf_field($$$$$$$$) BLURB => $blurb }; + if ((not defined($blurb) or $blurb eq "") and + defined($conformance->{fielddescription}->{$index})) { + $conformance->{header_fields}->{$index}->{BLURB} = + $conformance->{fielddescription}->{$index}; + } + return $index; } -- cgit From 6635e7b2ad97d482f74d696cfb1b277d62d949c1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 9 Sep 2005 16:23:50 +0000 Subject: r10116: Print out a couple more warnings. (This used to be commit 0628dfa5c3c74614a86b4f61b8d1555ef41c41bb) --- .../pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 7 ++- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 54 ++++++++++++++++++++-- 2 files changed, 57 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index 9e6147b166..47107b5969 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -57,7 +57,12 @@ sub handle_hf_rename($$$$) return; } - $data->{hf_renames}->{$old} = $new; + $data->{hf_renames}->{$old} = { + OLDNAME => $old, + NEWNAME => $new, + POS => $pos, + USED => 0 + }; } sub handle_param_value($$$$) diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 119dc46707..de936eb97d 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -18,6 +18,9 @@ use Parse::Pidl::Ethereal::Conformance qw(ReadConformance); my %types; my @ett; +my %hf_used = (); +my %dissector_used = (); + my $conformance = undef; my %ptrtype_mappings = ( @@ -196,6 +199,8 @@ sub Bitmap($$$) my ($en,$ev) = ($1,$2); my $hf_bitname = "hf_$ifname\_$name\_$en"; my $filtername = "$ifname\.$name\.$en"; + + $hf_used{$hf_bitname} = 1; register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, ""); @@ -321,6 +326,7 @@ sub Element($$$) my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", type2ft($e->{TYPE}), "BASE_HEX", "NULL", 0, ""); + $hf_used{$hf} = 1; my $eltname = StripPrefixes($pn) . ".$e->{NAME}"; if (defined($conformance->{noemit}->{$eltname})) { @@ -378,9 +384,14 @@ sub Function($$$) if (not defined($fn->{RETURN_TYPE})) { } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { pidl_code "offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, NULL);"; + $hf_used{"hf\_$ifname\_status"} = 1; } elsif ($fn->{RETURN_TYPE} eq "WERROR") { pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, NULL);"; + $hf_used{"hf\_$ifname\_werror"} = 1; + } else { + print "$fn->{FILE}:$fn->{LINE}: error: return type `$fn->{RETURN_TYPE}' not yet supported\n"; } + pidl_code "return offset;"; deindent; @@ -587,6 +598,8 @@ sub RegisterInterfaceHandoff($) pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);"; deindent; pidl_code "}"; + + $hf_used{"hf_$x->{NAME}_opnum"} = 1; } } @@ -611,8 +624,6 @@ sub ProcessInterface($) pidl_def "static gint proto_dcerpc_$x->{NAME} = -1;"; register_ett("ett_dcerpc_$x->{NAME}"); register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, ""); - register_hf_field("hf_$x->{NAME}_status", "Status", "$x->{NAME}.status", "FT_UINT32", "BASE_HEX", "VALS(NT_errors)", 0, ""); - register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "NULL", 0, ""); if (defined($x->{UUID})) { my $if_uuid = $x->{UUID}; @@ -643,6 +654,15 @@ sub ProcessInterface($) pidl_code "\n".DumpFunctionTable($x); + # Only register these two return types if they were actually used + if (defined($hf_used{"hf_$x->{NAME}_status"})) { + register_hf_field("hf_$x->{NAME}_status", "Status", "$x->{NAME}.status", "FT_UINT32", "BASE_HEX", "VALS(NT_errors)", 0, ""); + } + + if (defined($hf_used{"hf_$x->{NAME}_werror"})) { + register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "NULL", 0, ""); + } + RegisterInterface($x); RegisterInterfaceHandoff($x); @@ -770,6 +790,8 @@ sub Parse($$$$) my $header = "/* autogenerated by pidl */\n\n"; $header.=$res{hdr}; + + CheckUsed($conformance); return ($parser,$header); } @@ -813,7 +835,10 @@ sub register_hf_field($$$$$$$$) { my ($index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; - return $conformance->{hf_renames}->{$index} if defined ($conformance->{hf_renames}->{$index}); + if (defined ($conformance->{hf_renames}->{$index})) { + $conformance->{hf_renames}->{$index}->{USED} = 1; + return $conformance->{hf_renames}->{$index}->{NEWNAME}; + } $conformance->{header_fields}->{$index} = { INDEX => $index, @@ -885,4 +910,27 @@ sub DumpFunctionTable($) return "$res};\n"; } +sub CheckUsed($) +{ + my $conformance = shift; + foreach (values %{$conformance->{header_fields}}) { + if (not defined($hf_used{$_->{INDEX}})) { + print "$_->{POS}: warning: hf field `$_->{INDEX}' not used\n"; + } + } + + foreach (values %{$conformance->{hf_renames}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: hf field `$_->{OLDNAME}' not used\n"; + } + } + + #FIXME: PARAM_VALUE's + #FIXME: TYPE + #FIXME: FIELDDESCRIPTION + #FIXME: Import +} + + + 1; -- cgit From 5d6706e0775b6c9a9920966f6ef9fcd4a8d34345 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 9 Sep 2005 18:21:59 +0000 Subject: r10123: Add more warnings. Support quotes in conformance command arguments (This used to be commit e6842fcc9809bcf8de678199a6f28fbbde6c0b83) --- .../pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 22 ++++++-- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 62 ++++++++++++++-------- source4/pidl/lib/Parse/Pidl/Util.pm | 2 +- 3 files changed, 60 insertions(+), 26 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index 47107b5969..c12731eca2 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -31,7 +31,7 @@ sub handle_type($$$$$$$$$$) print "$pos: warning: invalid FT_TYPE `$ft_type'\n"; } - unless(alid_base_type($base_type)) { + unless (valid_base_type($base_type)) { print "$pos: warning: invalid BASE_TYPE `$base_type'\n"; } @@ -74,7 +74,12 @@ sub handle_param_value($$$$) return; } - $data->{dissectorparams}->{$dissector_name} = $value; + $data->{dissectorparams}->{$dissector_name} = { + DISSECTOR => $dissector_name, + PARAM => $value, + POS => $pos, + USED => 0 + }; } sub valid_base_type($) @@ -158,7 +163,11 @@ sub handle_fielddescription($$$$) { my ($pos,$data,$field,$desc) = @_; - $data->{fielddescription}->{$field} = $desc; + $data->{fielddescription}->{$field} = { + DESCRIPTION => $desc, + POS => $pos, + USED => 0 + }; } sub handle_import @@ -172,7 +181,12 @@ sub handle_import return; } - $data->{imports}->{$dissectorname} = join(' ', @_); + $data->{imports}->{$dissectorname} = { + NAME => $dissectorname, + DATA => join(' ', @_), + USED => 0, + POS => $pos + }; } my %field_handlers = ( diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index de936eb97d..08acdc4172 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -10,12 +10,11 @@ package Parse::Pidl::Ethereal::NDR; use strict; use Parse::Pidl::Typelist; -use Parse::Pidl::Util qw(has_property ParseExpr property_matches); +use Parse::Pidl::Util qw(has_property ParseExpr property_matches make_str); use Parse::Pidl::NDR; use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); use Parse::Pidl::Ethereal::Conformance qw(ReadConformance); -my %types; my @ett; my %hf_used = (); @@ -238,7 +237,8 @@ sub ElementLevel($$$$$) my $param = 0; if (defined($conformance->{dissectorparams}->{$myname})) { - $param = $conformance->{dissectorparams}->{$myname}; + $conformance->{dissectorparams}->{$myname}->{PARAM} = 1; + $param = $conformance->{dissectorparams}->{$myname}->{PARAM}; } if ($l->{TYPE} eq "POINTER") { @@ -285,10 +285,12 @@ sub ElementLevel($$$$$) } else { my $call; - if (defined($types{$l->{DATA_TYPE}})) { - $call= $types{$l->{DATA_TYPE}}->{CALL}; - } elsif ($conformance->{imports}->{$l->{DATA_TYPE}}) { - $call = $conformance->{imports}->{$l->{DATA_TYPE}}; + if ($conformance->{imports}->{$l->{DATA_TYPE}}) { + $call = $conformance->{imports}->{$l->{DATA_TYPE}}->{DATA}; + $conformance->{imports}->{$l->{DATA_TYPE}}->{USED} = 1; + } elsif (defined($conformance->{types}->{$l->{DATA_TYPE}})) { + $call= $conformance->{types}->{$l->{DATA_TYPE}}->{DISSECTOR_NAME}; + $conformance->{types}->{$l->{DATA_TYPE}}->{USED} = 1; } else { if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/) { @@ -557,7 +559,7 @@ sub RegisterInterface($) # These can be changed to non-pidl_code names if the old dissectors # in epan/dissctors are deleted. - my $name = "\"" . uc($x->{NAME}) . " (pidl)\""; + my $name = uc($x->{NAME}) . " (pidl)"; my $short_name = uc($x->{NAME}); my $filter_name = $x->{NAME}; @@ -571,7 +573,7 @@ sub RegisterInterface($) $filter_name = $conformance->{protocols}->{$x->{NAME}}->{FILTERNAME}; } - pidl_code "proto_dcerpc_$x->{NAME} = proto_register_protocol($name, \"$short_name\", \"$filter_name\");"; + pidl_code "proto_dcerpc_$x->{NAME} = proto_register_protocol(".make_str($name).", ".make_str($short_name).", ".make_str($filter_name).");"; pidl_code "proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));"; pidl_code "proto_register_subtree_array(ett, array_length(ett));"; @@ -674,14 +676,14 @@ sub register_type($$$$$$$) { my ($type,$call,$ft,$base,$mask,$vals,$length) = @_; - $types{$type} = { - TYPE => $type, - CALL => $call, + $conformance->{types}->{$type} = { + NAME => $type, + DISSECTOR_NAME => $call, FT_TYPE => $ft, - BASE => $base, + BASE_TYPE => $base, MASK => $mask, VALSSTRING => $vals, - LENGTH => $length + ALIGNMENT => $length }; } @@ -854,7 +856,8 @@ sub register_hf_field($$$$$$$$) if ((not defined($blurb) or $blurb eq "") and defined($conformance->{fielddescription}->{$index})) { $conformance->{header_fields}->{$index}->{BLURB} = - $conformance->{fielddescription}->{$index}; + $conformance->{fielddescription}->{$index}->{DESCRIPTION}; + $conformance->{fielddescription}->{$index}->{USED} = 1; } return $index; @@ -881,7 +884,7 @@ sub DumpHfList() foreach (values %{$conformance->{header_fields}}) { $res .= "\t{ &$_->{INDEX}, - { \"$_->{NAME}\", \"$_->{FILTER}\", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALSSTRING}, $_->{MASK}, \"$_->{BLURB}\", HFILL }}, + { ".make_str($_->{NAME}).", ".make_str($_->{FILTER}).", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALSSTRING}, $_->{MASK}, ".make_str($_->{BLURB}).", HFILL }}, "; } @@ -925,12 +928,29 @@ sub CheckUsed($) } } - #FIXME: PARAM_VALUE's - #FIXME: TYPE - #FIXME: FIELDDESCRIPTION - #FIXME: Import -} + foreach (values %{$conformance->{dissectorparams}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: dissector param never used\n"; + } + } + + foreach (values %{$conformance->{imports}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: import never used\n"; + } + } + foreach (values %{$conformance->{types}}) { + if (not $_->{USED} and defined($_->{POS})) { + print "$_->{POS}: warning: type never used\n"; + } + } + foreach (values %{$conformance->{fielddescription}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: description never used\n"; + } + } +} 1; diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 8854be9d74..572df0dc09 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -6,7 +6,7 @@ package Parse::Pidl::Util; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(has_property property_matches ParseExpr is_constant); +@EXPORT = qw(has_property property_matches ParseExpr is_constant make_str); use strict; -- cgit From 6c22a5bcbd50a2e727e0d8f203f24ec6321d25af Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Tue, 13 Sep 2005 06:39:40 +0000 Subject: r10197: Assume that external dissectors are structs which I think is always the case. (This used to be commit 515f456facfeb2cd9893ac65dd96cdda16c9d1ca) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 08acdc4172..4b1dd26876 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -294,7 +294,7 @@ sub ElementLevel($$$$$) } else { if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/) { - pidl_code "offset = $1_dissect_$2(tvb,offset,pinfo,tree,drep,$hf,$param);"; + pidl_code "offset = $1_dissect_struct_$2(tvb,offset,pinfo,tree,drep,$hf,$param);"; } return; -- cgit From 8aa2c913a0c2c7cdd1e1becacc825749b1d2bd44 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 17 Sep 2005 14:13:36 +0000 Subject: r10295: Remove dependency on Data::Dumper (This used to be commit 26f2903dab833fbf420af7104757b26f8398e99d) --- source4/pidl/lib/Parse/Pidl/Samba/TDR.pm | 1 - 1 file changed, 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm index 9bcf7f1a77..b5637f8cbf 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm @@ -5,7 +5,6 @@ package Parse::Pidl::Samba::TDR; use Parse::Pidl::Util qw(has_property ParseExpr is_constant); -use Data::Dumper; use strict; -- cgit From f1d065128d8715e9ee34a31bbdc60d9d4e00a6a8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 17 Sep 2005 14:36:35 +0000 Subject: r10296: Fix function pointer handling for older perl versions (This used to be commit 0949db8119af548c199930c64449d6ca2228bcb5) --- source4/pidl/lib/Parse/Pidl/Samba/TDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm index b5637f8cbf..124cb61bb4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm @@ -200,7 +200,7 @@ sub ParserTypedef($$) { STRUCT => \&ParserStruct, UNION => \&ParserUnion, ENUM => \&ParserEnum, BITMAP => \&ParserBitmap - }->{$e->{DATA}->{TYPE}}($e->{DATA}, $e->{NAME}, $t, has_property($e, "public")); + }->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $t, has_property($e, "public")); pidl ""; } -- cgit From 58a399d76699792f48fa6d121895a688d5987c80 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 21 Sep 2005 12:57:18 +0000 Subject: r10388: Add version numbers (required for CPAN) (This used to be commit 786329576bf14ae774f9d5a24268e46b7dcb634a) --- source4/pidl/lib/Parse/Pidl/Compat.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Dump.pm | 2 ++ source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 2 ++ source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 3 +++ source4/pidl/lib/Parse/Pidl/NDR.pm | 2 ++ source4/pidl/lib/Parse/Pidl/ODL.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/EJS.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/Header.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/TDR.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Samba/Template.pm | 3 +++ source4/pidl/lib/Parse/Pidl/Test.pm | 2 ++ source4/pidl/lib/Parse/Pidl/Typelist.pm | 2 ++ source4/pidl/lib/Parse/Pidl/Util.pm | 2 ++ 22 files changed, 60 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Compat.pm b/source4/pidl/lib/Parse/Pidl/Compat.pm index 39cb67fd71..2e7d686249 100644 --- a/source4/pidl/lib/Parse/Pidl/Compat.pm +++ b/source4/pidl/lib/Parse/Pidl/Compat.pm @@ -8,6 +8,9 @@ package Parse::Pidl::Compat; use Parse::Pidl::Util qw(has_property); use strict; +use vars qw($VERSION); +$VERSION = '0.01'; + my %supported_properties = ( # interface "helpstring" => ["INTERFACE", "FUNCTION"], diff --git a/source4/pidl/lib/Parse/Pidl/Dump.pm b/source4/pidl/lib/Parse/Pidl/Dump.pm index 7f426c1c0b..80219a8f1a 100644 --- a/source4/pidl/lib/Parse/Pidl/Dump.pm +++ b/source4/pidl/lib/Parse/Pidl/Dump.pm @@ -7,6 +7,8 @@ package Parse::Pidl::Dump; use Exporter; +use vars qw($VERSION); +$VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT_OK = qw(DumpTypedef DumpStruct DumpEnum DumpBitmap DumpUnion DumpFunction); diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index c12731eca2..706a259306 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -6,6 +6,8 @@ package Parse::Pidl::Ethereal::Conformance; require Exporter; +use vars qw($VERSION); +$VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT_OK = qw(ReadConformance); diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 4b1dd26876..8441ea25b9 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -15,6 +15,9 @@ use Parse::Pidl::NDR; use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); use Parse::Pidl::Ethereal::Conformance qw(ReadConformance); +use vars qw($VERSION); +$VERSION = '0.01'; + my @ett; my %hf_used = (); diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index e00a0c9828..42c9fd133b 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -8,6 +8,8 @@ package Parse::Pidl::NDR; require Exporter; +use vars qw($VERSION); +$VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred); diff --git a/source4/pidl/lib/Parse/Pidl/ODL.pm b/source4/pidl/lib/Parse/Pidl/ODL.pm index 03d66bfc45..082deaea1d 100644 --- a/source4/pidl/lib/Parse/Pidl/ODL.pm +++ b/source4/pidl/lib/Parse/Pidl/ODL.pm @@ -8,6 +8,9 @@ use Parse::Pidl::Util qw(has_property); use Parse::Pidl::Typelist qw(hasType getType); use strict; +use vars qw($VERSION); +$VERSION = '0.01'; + ##################################################################### # find an interface in an array of interfaces sub get_interface($$) diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm index 7b6c4db212..0289a688ba 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm @@ -6,6 +6,9 @@ package Parse::Pidl::Samba::COM::Header; use Parse::Pidl::Typelist; use Parse::Pidl::Util qw(has_property); +use vars qw($VERSION); +$VERSION = '0.01'; + use strict; sub GetArgumentProtoList($) diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm index c94ef59ae9..ab56d87492 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm @@ -9,6 +9,9 @@ package Parse::Pidl::Samba::COM::Proxy; use Parse::Pidl::Samba::COM::Header; use Parse::Pidl::Util qw(has_property); +use vars qw($VERSION); +$VERSION = '0.01'; + use strict; my($res); diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm index 785c34fc77..17b33a6872 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm @@ -10,6 +10,9 @@ package Parse::Pidl::Samba::COM::Stub; use Parse::Pidl::Util qw(has_property); use strict; +use vars qw($VERSION); +$VERSION = '0.01'; + my($res); sub pidl($) diff --git a/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm index 743139c8cd..2cac7d81af 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm @@ -10,6 +10,9 @@ use strict; use Parse::Pidl::Typelist; use Parse::Pidl::Util qw(has_property); +use vars qw($VERSION); +$VERSION = '0.01'; + my($res); my %constants; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm b/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm index 81c75705de..fed717cad0 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm @@ -9,6 +9,9 @@ use strict; use Parse::Pidl::Typelist; use Parse::Pidl::Util qw(has_property); +use vars qw($VERSION); +$VERSION = '0.01'; + my($res); sub pidl ($) diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/Header.pm index d88b37e229..ed8952e746 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/Header.pm @@ -11,6 +11,9 @@ use Parse::Pidl::Typelist qw(mapType); use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); +use vars qw($VERSION); +$VERSION = '0.01'; + my($res); my($tab_depth); diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm index 126dbc3ba9..10b8dc71d8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm @@ -5,6 +5,9 @@ package Parse::Pidl::Samba::NDR::Client; +use vars qw($VERSION); +$VERSION = '0.01'; + use strict; my($res); diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm index 9aa0ed8daf..daf7ba0238 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm @@ -12,6 +12,9 @@ use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); use Parse::Pidl::Samba::NDR::Parser; +use vars qw($VERSION); +$VERSION = '0.01'; + my($res); my($tab_depth); diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm index 513fa0826d..3f08cbb527 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm @@ -12,6 +12,9 @@ use Parse::Pidl::Typelist qw(hasType getType mapType); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use vars qw($VERSION); +$VERSION = '0.01'; + # list of known types my %typefamily; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm index a8c159572b..99982e4ad1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm @@ -8,6 +8,9 @@ package Parse::Pidl::Samba::NDR::Server; use strict; +use vars qw($VERSION); +$VERSION = '0.01'; + my($res); sub pidl($) diff --git a/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm index 409095804f..471c3e9927 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm @@ -5,6 +5,9 @@ package Parse::Pidl::Samba::SWIG; +use vars qw($VERSION); +$VERSION = '0.01'; + use strict; sub pidl($) diff --git a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm index 124cb61bb4..5d3d236e43 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm @@ -6,6 +6,9 @@ package Parse::Pidl::Samba::TDR; use Parse::Pidl::Util qw(has_property ParseExpr is_constant); +use vars qw($VERSION); +$VERSION = '0.01'; + use strict; my $ret = ""; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm index eb71b6d707..fea4b47dee 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm @@ -5,6 +5,9 @@ package Parse::Pidl::Samba::Template; +use vars qw($VERSION); +$VERSION = '0.01'; + use strict; my($res); diff --git a/source4/pidl/lib/Parse/Pidl/Test.pm b/source4/pidl/lib/Parse/Pidl/Test.pm index 34ea80c95c..66f5c73595 100644 --- a/source4/pidl/lib/Parse/Pidl/Test.pm +++ b/source4/pidl/lib/Parse/Pidl/Test.pm @@ -8,6 +8,8 @@ use strict; use Parse::Pidl::Util; use Getopt::Long; +use vars qw($VERSION); +$VERSION = '0.01'; my $cc = $ENV{CC}; my @cflags = split / /, $ENV{CFLAGS}; my @ldflags = split / /, $ENV{LDFLAGS}; diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 10a4baf7e7..7dfbe761de 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -8,6 +8,8 @@ package Parse::Pidl::Typelist; require Exporter; @ISA = qw(Exporter); @EXPORT = qw(hasType getType mapType); +use vars qw($VERSION); +$VERSION = '0.01'; use Parse::Pidl::Util qw(has_property); use strict; diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 572df0dc09..fec1301a59 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -7,6 +7,8 @@ package Parse::Pidl::Util; require Exporter; @ISA = qw(Exporter); @EXPORT = qw(has_property property_matches ParseExpr is_constant make_str); +use vars qw($VERSION); +$VERSION = '0.01'; use strict; -- cgit From 08f16292a0cfab57c484661c1f05e1a49ec06942 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 29 Sep 2005 14:00:07 +0000 Subject: r10608: - fix hierachical memory handling in ndr_pull_nbt_name - add wrepl_nbt_name scalar type and do the pull/push in the ndr layer instead of the caller - give the flags and group_flag in the wrepl_name a meaning metze (This used to be commit b98efc2905e1147eb97111b46a877bdb9d8dd154) --- source4/pidl/lib/Parse/Pidl/Typelist.pm | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 7dfbe761de..d81fedf71e 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -140,9 +140,9 @@ my $scalars = { NDR_ALIGN => 4 }, "COMRESULT" => { - "C_TYPE" => "COMRESULT", - IS_REFERENCE => 0, - NDR_ALIGN => 4 + C_TYPE => "COMRESULT", + IS_REFERENCE => 0, + NDR_ALIGN => 4 }, # special types @@ -151,6 +151,11 @@ my $scalars = { IS_REFERENCE => 1, NDR_ALIGN => 4 #??? }, + "wrepl_nbt_name"=> { + C_TYPE => "struct nbt_name", + IS_REFERENCE => 0, + NDR_ALIGN => 4 + }, "ipv4address" => { C_TYPE => "const char *", IS_REFERENCE => 1, -- cgit From f9a416743401121e1bc2961402cd6f87de68ca00 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 3 Oct 2005 23:27:33 +0000 Subject: r10694: Add some work I did this afternoon on getting pidl to output Samba3 RPC parsers. Currently the following files can be generated: - include/rpc_BASENAME.h - rpc_server/srv_BASENAME.c - rpc_server/srv_BASENAME_nt.c (template only, user has to fill in functions) - rpc_client/cli_BASENAME.c - rpc_parse/parse_BASENAME.c So far, I have been working on getting DFS working. Currently still to do (all in rpc_parse/parse_BASENAME.c): - Proper handling of declarations - Proper handling of scalar/buffer parts of structs and unions - Subcontexts - Proper handling of arrays - Support for custom (non-scalar) types I hope to have a somewhat more working version later this week. Some files as currently generated are available from: http://samba.org/~jelmer/pidl_samba3/ (This used to be commit 8af8eaeeef6d46f4d25ccb1d25890e1eef063e4f) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 6 +- source4/pidl/lib/Parse/Pidl/NDR.pm | 33 ++- source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 104 ++++++++++ source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 160 +++++++++++++++ source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 269 +++++++++++++++++++++++++ source4/pidl/lib/Parse/Pidl/Samba3/Server.pm | 115 +++++++++++ source4/pidl/lib/Parse/Pidl/Samba3/Template.pm | 66 ++++++ source4/pidl/lib/Parse/Pidl/Samba3/Util.pm | 29 +++ source4/pidl/lib/Parse/Pidl/Typelist.pm | 38 +--- 9 files changed, 780 insertions(+), 40 deletions(-) create mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Client.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Header.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Server.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Template.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Util.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 8441ea25b9..b497f87403 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -485,6 +485,8 @@ sub Union($$$) $res.="\t\tbreak;\n"; } + my $switch_type = $e->{SWITCH_TYPE}; + pidl_code "static int"; pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; pidl_code "{"; @@ -492,7 +494,7 @@ sub Union($$$) pidl_code "proto_item *item = NULL;"; pidl_code "proto_tree *tree = NULL;"; pidl_code "int old_offset;"; - pidl_code "g$e->{SWITCH_TYPE} level;"; + pidl_code "g$switch_type level;"; pidl_code ""; if ($e->{ALIGN} > 1) { @@ -511,7 +513,7 @@ sub Union($$$) pidl_code ""; - pidl_code "offset = dissect_ndr_$e->{SWITCH_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, &level);"; + pidl_code "offset = dissect_ndr_$switch_type(tvb, offset, pinfo, tree, drep, hf_index, &level);"; pidl_code "switch(level) {$res\t}"; pidl_code "proto_item_set_len(item, offset-old_offset);\n"; diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 42c9fd133b..6bb92a3b50 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -17,6 +17,37 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType); use Parse::Pidl::Util qw(has_property property_matches); +# Alignment of the built-in scalar types +my $scalar_alignment = { + 'void' => 0, + 'char' => 1, + 'int8' => 1, + 'uint8' => 1, + 'int16' => 2, + 'uint16' => 2, + 'int32' => 4, + 'uint32' => 4, + 'hyper' => 8, + 'dlong' => 4, + 'udlong' => 4, + 'udlongr' => 4, + 'DATA_BLOB' => 4, + 'string' => 4, + 'string_array' => 4, #??? + 'time_t' => 4, + 'NTTIME' => 4, + 'NTTIME_1sec' => 4, + 'NTTIME_hyper' => 8, + 'WERROR' => 4, + 'NTSTATUS' => 4, + 'COMRESULT' => 4, + 'nbt_string' => 4, + 'wrepl_nbt_name' => 4, + 'ipv4address' => 4 +}; + + + sub nonfatal($$) { my ($e,$s) = @_; @@ -299,7 +330,7 @@ sub align_type } elsif (($dt->{TYPE} eq "STRUCT") or ($dt->{TYPE} eq "UNION")) { return find_largest_alignment($dt); } elsif ($dt->{TYPE} eq "SCALAR") { - return Parse::Pidl::Typelist::getScalarAlignment($dt->{NAME}); + return $scalar_alignment->{$dt->{NAME}}; } die("Unknown data type type $dt->{TYPE}"); diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm new file mode 100644 index 0000000000..59d048176f --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm @@ -0,0 +1,104 @@ +################################################### +# Samba3 NDR client generator for IDL structures +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba3::Client; + +use strict; +use Parse::Pidl::Typelist qw(hasType getType mapType); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::Samba3::Util qw(MapSamba3Type); + +use vars qw($VERSION); +$VERSION = '0.01'; + +my $res = ""; +my $tabs = ""; +sub indent() { $tabs.="\t"; } +sub deindent() { $tabs = substr($tabs, 1); } +sub pidl($) { $res .= $tabs.(shift)."\n"; } +sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } + +sub ParseFunction($$) +{ + my ($if,$fn) = @_; + + my $args = ""; + my $defargs = ""; + foreach (@{$fn->{ELEMENTS}}) { + $defargs .= ", " . MapSamba3Type($_); + $args .= ", $_->{NAME}"; + } + + my $uif = uc($if->{NAME}); + my $ufn = uc($fn->{NAME}); + + pidl "NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"; + pidl "{"; + indent; + pidl "prs_struct qbuf, rbuf;"; + pidl "$uif\_Q_$ufn q;"; + pidl "$uif\_R_$ufn r;"; + pidl ""; + pidl "ZERO_STRUCT(q);"; + pidl "ZERO_STRUCT(r);"; + pidl ""; + pidl "/* Marshall data and send request */"; + pidl ""; + pidl "init_$if->{NAME}_q_$fn->{NAME}(&q$args);"; + pidl ""; + pidl "CLI_DO_RPC(cli, mem_ctx, PI_$uif, $ufn,"; + pidl "\tq, r,"; + pidl "\tqbuf, rbuf, "; + pidl "\t$if->{NAME}_q_$fn->{NAME},"; + pidl "\t$if->{NAME}_r_$fn->{NAME},"; + pidl "\tNT_STATUS_UNSUCCESSFUL);"; + pidl ""; + pidl "/* Return result */"; + if (not $fn->{RETURN_TYPE}) { + pidl "return NT_STATUS_OK;"; + } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { + pidl "return r.status;"; + } elsif ($fn->{RETURN_TYPE} eq "WERROR") { + pidl "return werror_to_ntstatus(r.status);"; + } else { + pidl "/* Sorry, don't know how to convert $fn->{RETURN_TYPE} to NTSTATUS */"; + pidl "return NT_STATUS_OK;"; + } + + deindent; + pidl "}"; + pidl ""; +} + +sub ParseInterface($) +{ + my $if = shift; + + ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); +} + +sub Parse($$) +{ + my($ndr,$filename) = @_; + + $res = ""; + + pidl "/*"; + pidl " * Unix SMB/CIFS implementation."; + pidl " * client auto-generated by pidl. DO NOT MODIFY!"; + pidl " */"; + pidl ""; + pidl "#include \"includes.h\""; + pidl ""; + + foreach (@$ndr) { + ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm new file mode 100644 index 0000000000..be7f1ca5c4 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -0,0 +1,160 @@ +################################################### +# Samba3 NDR header generator for IDL structures +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba3::Header; + +use strict; +use Parse::Pidl::Typelist qw(hasType getType); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::Samba3::Util qw(MapSamba3Type); + +use vars qw($VERSION); +$VERSION = '0.01'; + +my $res = ""; +sub pidl($) { my $x = shift; $res .= "$x\n"; } +sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } + +sub CreateStruct($$$$) +{ + my ($if,$fn,$n,$t) = @_; + + pidl "typedef struct $n {"; + foreach my $e (@$t) { + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER") { + return if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "top"); + pidl "\tuint32 ptr_$e->{NAME};"; + } elsif ($l->{TYPE} eq "SWITCH") { + pidl "\tuint32 level_$e->{NAME};"; + } elsif ($l->{TYPE} eq "DATA") { + pidl "\t" . MapSamba3Type($e) . ";"; + } + } + } + + if (not @$t) { + # Some compilers don't like empty structs + pidl "\tuint32 dummy;"; + } + + pidl "} " . uc($n) . ";"; + pidl ""; +} + +sub ParseFunction($$) +{ + my ($if,$fn) = @_; + + my @in = (); + my @out = (); + + foreach (@{$_->{ELEMENTS}}) { + push (@in, $_) if (grep(/in/, @{$_->{DIRECTION}})); + push (@out, $_) if (grep(/out/, @{$_->{DIRECTION}})); + } + + if (defined($fn->{RETURN_TYPE})) { + push (@out, { + NAME => "status", + TYPE => $fn->{RETURN_TYPE}, + LEVELS => [ + { + TYPE => "DATA", + DATA_TYPE => $fn->{RETURN_TYPE} + } + ] + } ); + } + + # define Q + R structures for functions + + CreateStruct($if, $fn, "$if->{NAME}_q_$fn->{NAME}", \@in); + CreateStruct($if, $fn, "$if->{NAME}_r_$fn->{NAME}", \@out); +} + +sub ParseStruct($$$) +{ + my ($if,$s,$n) = @_; + + CreateStruct($if, $s, "$if->{NAME}_$n", $s->{ELEMENTS}); +} + +sub ParseEnum($$$) +{ + my ($if,$s,$n) = @_; + + pidl "typedef enum {"; + + foreach (@{$s->{ELEMENTS}}) { + pidl "$_,"; + } + + pidl "} $n;"; +} + +sub ParseBitmap($$$) +{ + my ($if,$s,$n) = @_; + + pidl "#define $_" foreach (@{$s->{ELEMENTS}}); +} + +sub ParseInterface($) +{ + my $if = shift; + + my $def = "_RPC_" . uc($if->{NAME}) . "_H"; + + pidl ""; + + pidl "\#ifndef $def"; + pidl "\#define $def"; + + pidl ""; + + foreach (@{$if->{FUNCTIONS}}) { + pidl "\#define " . uc($_->{NAME}) . " $_->{OPNUM}" ; + } + + pidl ""; + + ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); + + foreach (@{$if->{TYPEDEFS}}) { + ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "STRUCT"); + ParseEnum($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "ENUM"); + ParseBitmap($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "BITMAP"); + fatal($_, "Unions not supported for Samba3 yet") if ($_->{TYPE} eq "STRUCT"); + } + + foreach (@{$if->{CONSTS}}) { + pidl "$_->{NAME} ($_->{VALUE})"; + } + + pidl "\#endif /* $def */"; +} + +sub Parse($$) +{ + my($ndr,$filename) = @_; + + $res = ""; + + pidl "/*"; + pidl " * Unix SMB/CIFS implementation."; + pidl " * header auto-generated by pidl. DO NOT MODIFY!"; + pidl " */"; + pidl ""; + + # Loop over interfaces + foreach (@{$ndr}) { + ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + } + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm new file mode 100644 index 0000000000..8518537ddb --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -0,0 +1,269 @@ +################################################### +# Samba3 NDR parser generator for IDL structures +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba3::Parser; + +use strict; +use Parse::Pidl::Typelist qw(hasType getType mapType); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::Samba3::Util qw(MapSamba3Type); + +use vars qw($VERSION); +$VERSION = '0.01'; + +my $res = ""; +my $tabs = ""; +sub indent() { $tabs.="\t"; } +sub deindent() { $tabs = substr($tabs, 1); } +sub pidl($) { $res .= $tabs.(shift)."\n"; } +sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } + +sub ParseElementLevelData($$$$$) +{ + my ($e,$l,$nl,$env,$varname) = @_; + + #FIXME: This only works for scalar types + pidl "if (!prs_$l->{DATA_TYPE}(\"$e->{NAME}\", ps, depth, &$varname))"; + pidl "\treturn False;"; + pidl ""; +} + +sub ParseElementLevelArray($$$$$) +{ + my ($e,$l,$nl,$env,$varname) = @_; + + #FIXME + pidl "for (i=0; i<".ParseExpr("length_$e->{NAME}", $env) .";i++) {"; + indent; + ParseElementLevel($e,$nl,$env,"$varname\[i]"); + deindent; + pidl "}"; +} + +sub ParseElementLevelSwitch($$$$$) +{ + my ($e,$l,$nl,$env,$varname) = @_; + + pidl "if (!prs_uint32(\"level\", ps, depth, " . ParseExpr("level_$e->{NAME}", $env) . ", ps, depth))"; + pidl "\treturn False;"; + pidl ""; + + ParseElementLevel($e,$nl,$env,$varname); +} + +sub ParseElementLevelPtr($$$$$) +{ + my ($e,$l,$nl,$env,$varname) = @_; + + # No top-level ref pointers for Samba 3 + return if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP"); + + pidl "if (!prs_uint32(\"ptr_$e->{NAME}\",ps,depth,&" . ParseExpr("ptr_$e->{NAME}", $env) . ", ps, depth))"; + pidl "\treturn False;"; + pidl ""; + + pidl "if (" . ParseExpr("ptr_$e->{NAME}", $env) . ") {"; + indent; + ParseElementLevel($e,$nl,$env,$varname); + deindent; + pidl "}"; +} + +sub ParseElementLevelSubcontext($$$$$) +{ + my ($e,$l,$nl,$env,$varname) = @_; + + fatal($e, "subcontext() not supported for Samba 3"); +} + +sub ParseElementLevel($$$$) +{ + my ($e,$l,$env,$varname) = @_; + + { + DATA => \&ParseElementLevelData, + SUBCONTEXT => \&ParseElementLevelSubcontext, + POINTER => \&ParseElementLevelPtr, + SWITCH => \&ParseElementLevelSwitch, + ARRAY => \&ParseElementLevelArray + }->{$l->{TYPE}}->($e,$l,GetNextLevel($e,$l),$env,$varname); +} + +sub ParseElement($$) +{ + my ($e,$env) = @_; + + ParseElementLevel($e, $e->{LEVELS}[0], $env, ParseExpr($e->{NAME}, $env)); +} + +sub CreateStruct($$$) +{ + my ($fn,$s,$es) = @_; + + my $args = ""; + foreach my $e (@$es) { + $args .= ", " . MapSamba3Type($_); + } + + pidl "BOOL init_$fn($s *v$args)"; + pidl "{"; + indent; + pidl "DEBUG(5,(\"init_$fn\\n\"));"; + # Call init for all arguments + foreach my $e (@$es) { + foreach my $l (@{$e->{LEVELS}}) { + #FIXME + } + } + pidl "return True;"; + deindent; + pidl "}"; + pidl ""; + + pidl "BOOL $fn(const char *desc, $s *v, prs_struct *ps, int depth)"; + pidl "{"; + indent; + pidl "if (v == NULL)"; + pidl "\treturn False;"; + pidl ""; + pidl "prs_debug(ps, depth, desc, \"$fn\");"; + pidl "depth++;"; + pidl "if (!prs_align(ps))"; + pidl "\treturn False;"; + pidl ""; + + my $env = {}; + foreach my $e (@$es) { + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "DATA") { + $env->{"$e->{NAME}"} = $e->{"v->$e->{NAME}"}; + } elsif ($l->{TYPE} eq "POINTER") { + $env->{"ptr_$e->{NAME}"} = $e->{"v->ptr_$e->{NAME}"}; + } elsif ($l->{TYPE} eq "SWITCH") { + $env->{"level_$e->{NAME}"} = $e->{"v->level_$e->{NAME}"}; + } + } + } + + ParseElement($_, $env) foreach (@$es); + + pidl "return True;"; + deindent; + pidl "}"; + pidl ""; +} + +sub ParseStruct($$$) +{ + my ($if,$s,$n) = @_; + + my $fn = "$if->{NAME}_io_$n"; + my $sn = uc("$if->{NAME}_$n"); + + CreateStruct($fn, $sn, $s->{ELEMENTS}); +} + +sub ParseUnion($$$) +{ + my ($if,$u,$n) = @_; + + my $fn = "$if->{NAME}_io_$n"; + my $sn = uc("$if->{NAME}_$n"); + + pidl "BOOL $fn(const char *desc, $sn* v, uint32 level, prs_struct *ps, int depth)"; + pidl "{"; + indent; + pidl "switch (level) {"; + indent; + + foreach (@{$u->{ELEMENTS}}) { + pidl "$_->{CASE}:"; + indent; + pidl "depth++;"; + ParseElement($_, {}); + deindent; + pidl "depth--;"; + pidl "break"; + } + + deindent; + pidl "}"; + pidl ""; + pidl "return True;"; + deindent; + pidl "}"; +} + +sub ParseFunction($$) +{ + my ($if,$fn) = @_; + + my @in = (); + my @out = (); + + foreach (@{$fn->{ELEMENTS}}) { + push (@in, $_) if (grep(/in/, @{$_->{DIRECTION}})); + push (@out, $_) if (grep(/out/, @{$_->{DIRECTION}})); + } + + if (defined($fn->{RETURN_TYPE})) { + push (@out, { + NAME => "status", + TYPE => $fn->{RETURN_TYPE}, + LEVELS => [ + { + TYPE => "DATA", + DATA_TYPE => $fn->{RETURN_TYPE} + } + ] + } ); + } + + CreateStruct("$if->{NAME}_io_q_$fn->{NAME}", uc("$if->{NAME}_q_$fn->{NAME}"), \@in); + CreateStruct("$if->{NAME}_io_r_$fn->{NAME}", uc("$if->{NAME}_r_$fn->{NAME}"), \@out); +} + +sub ParseInterface($) +{ + my $if = shift; + + # Structures first + pidl "/* $if->{NAME} structures */"; + foreach (@{$if->{TYPEDEFS}}) { + ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "STRUCT"); + ParseUnion($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "UNION"); + } + + pidl "/* $if->{NAME} functions */"; + ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); +} + +sub Parse($$) +{ + my($ndr,$filename) = @_; + + $tabs = ""; + $res = ""; + + pidl "/*"; + pidl " * Unix SMB/CIFS implementation."; + pidl " * parser auto-generated by pidl. DO NOT MODIFY!"; + pidl " */"; + pidl ""; + pidl "#include \"includes.h\""; + pidl ""; + pidl "#undef DBGC_CLASS"; + pidl "#define DBGC_CLASS DBGC_RPC_PARSE"; + pidl ""; + + foreach (@$ndr) { + ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm new file mode 100644 index 0000000000..0372cf1117 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm @@ -0,0 +1,115 @@ +################################################### +# Samba3 NDR server generator for IDL structures +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba3::Server; + +use strict; +use Parse::Pidl::Typelist qw(hasType getType mapType); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); + +my $res = ""; +my $tabs = ""; + +sub indent() { $tabs.="\t"; } +sub deindent() { $tabs = substr($tabs, 1); } +sub pidl($) { $res .= $tabs.(shift)."\n"; } + +use vars qw($VERSION); +$VERSION = '0.01'; + +sub ParseFunction($$) +{ + my ($if,$fn) = @_; + + pidl "/******************************************************************"; + pidl " api_$fn->{NAME}"; + pidl " *****************************************************************/"; + pidl ""; + pidl "static BOOL api_$fn->{NAME}(pipes_struct *p)"; + pidl "{"; + indent; + pidl uc("$if->{NAME}_q_$fn->{NAME}") . " q_u;"; + pidl uc("$if->{NAME}_r_$fn->{NAME}") . " r_u;"; + pidl "prs_struct *data = &p->in_data.data"; + pidl "prs_struct *rdata = &p->out_data.rdata"; + pidl ""; + pidl "if (!$if->{NAME}_io_q_$fn->{NAME}(\"\", &q_u, data, 0))"; + pidl "\treturn False;"; + pidl ""; + pidl "r_u.status = _$fn->{NAME}(p, &q_u, &r_u);"; + pidl ""; + pidl "if (!$if->{NAME}_io_r_$fn->{NAME}(\"\", &r_u, rdata, 0))"; + pidl "\treturn False;"; + pidl ""; + pidl "return True;"; + deindent; + pidl "}"; +} + +sub ParseInterface($) +{ + my $if = shift; + + ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); + + pidl ""; + pidl "/* Tables */"; + pidl "static struct api_struct api_$if->{NAME}_cmds[] = "; + pidl "{"; + indent; + foreach (@{$if->{FUNCTIONS}}) { + pidl "{\"" . uc($_->{NAME}) . "\", " . uc($_->{NAME}) . ", api_$_->{NAME}},"; + } + deindent; + pidl "};"; + + pidl ""; + + pidl "void $if->{NAME}_get_pipe_fns(struct api_struct **fns, int *n_fns)"; + pidl "{"; + indent; + pidl "*fns = api_$if->{NAME}_cmds;"; + pidl "*n_fns = sizeof(api_$if->{NAME}_cmds) / sizeof(struct api_struct);"; + deindent; + pidl "}"; + + pidl ""; + + pidl "NTSTATUS rpc_$if->{NAME}_init(void)"; + pidl "{"; + indent; + pidl "return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, \"$if->{NAME}\", \"$if->{NAME}\", api_$if->{NAME}_cmds, sizeof(api_$if->{NAME}_cmds) / sizeof(struct api_struct));"; + deindent; + pidl "}"; +} + +sub Parse($$) +{ + my($ndr,$filename) = @_; + + $tabs = ""; + $res = ""; + + pidl "/*"; + pidl " * Unix SMB/CIFS implementation."; + pidl " * server auto-generated by pidl. DO NOT MODIFY!"; + pidl " */"; + pidl ""; + pidl "#include \"includes.h\""; + pidl "#include \"nterr.h\""; + pidl ""; + pidl "#undef DBGC_CLASS"; + pidl "#define DBGC_CLASS DBGC_RPC"; + pidl ""; + + foreach (@$ndr) { + ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm new file mode 100644 index 0000000000..072aa07850 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm @@ -0,0 +1,66 @@ +################################################### +# Samba3 NDR client generator for IDL structures +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba3::Template; + +use strict; +use Parse::Pidl::Typelist qw(hasType getType mapType); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); + +use vars qw($VERSION); +$VERSION = '0.01'; + +my $res; +sub pidl($) { my $x = shift; $res.="$x\n"; } + +sub ParseInterface($) +{ + my $if = shift; + + foreach (@{$if->{FUNCTIONS}}) { + my $ret = $_->{RETURN_TYPE}; + if (not $ret) { $ret = "void"; } + pidl "$ret _$_->{NAME}(pipes_struct *p, " . uc($if->{NAME}) . "_Q_" . uc($_->{NAME}) . " *q_u, " . uc($if->{NAME}) . "_R_" . uc($_->{NAME}) . " *r_u)"; + pidl "{"; + pidl "\t/* FIXME: Implement your code here */"; + if (not defined($_->{RETURN_TYPE})) { + } elsif ($_->{RETURN_TYPE} eq "WERROR") { + pidl "\treturn WERR_NOT_SUPPORTED;"; + } elsif ($_->{RETURN_TYPE} eq "NTSTATUS") { + pidl "\treturn NT_STATUS_NOT_IMPLEMENTED;"; + } elsif ($_->{RETURN_TYPE} eq "uint32") { + pidl "\treturn 0;"; + } + pidl "}"; + pidl ""; + } +} + +sub Parse($$) +{ + my($ndr,$filename) = @_; + + $res = ""; + + pidl "/*"; + pidl " * Unix SMB/CIFS implementation."; + pidl " * template auto-generated by pidl. Modify to your needs"; + pidl " */"; + pidl ""; + pidl "#include \"includes.h\""; + pidl ""; + pidl "#undef DBGC_CLASS"; + pidl "#define DBGC_CLASS DBGC_MSRPC"; + pidl ""; + + foreach (@$ndr) { + ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Util.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Util.pm new file mode 100644 index 0000000000..2d4179df76 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Util.pm @@ -0,0 +1,29 @@ +################################################### +# Samba3 common helper functions +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba3::Util; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT_OK = qw(MapSamba3Type); + +use strict; +use Parse::Pidl::Typelist qw(hasType getType mapType); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); + +use vars qw($VERSION); +$VERSION = '0.01'; + +sub MapSamba3Type($) +{ + my $e = shift; + + return "UNISTR2 $e->{NAME}" if ($e->{TYPE} eq "string"); + + return "$e->{TYPE} $e->{NAME}"; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index d81fedf71e..111ce9ba11 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Typelist; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(hasType getType mapType); +@EXPORT_OK = qw(hasType getType mapType); use vars qw($VERSION); $VERSION = '0.01'; @@ -22,109 +22,90 @@ my $scalars = { "void" => { C_TYPE => "void", IS_REFERENCE => 0, - NDR_ALIGN => 0 }, # 1 byte types "char" => { C_TYPE => "char", IS_REFERENCE => 0, - NDR_ALIGN => 1 }, "int8" => { C_TYPE => "int8_t", IS_REFERENCE => 0, - NDR_ALIGN => 1 }, "uint8" => { C_TYPE => "uint8_t", IS_REFERENCE => 0, - NDR_ALIGN => 1 }, # 2 byte types "int16" => { C_TYPE => "int16_t", IS_REFERENCE => 0, - NDR_ALIGN => 2 }, "uint16" => { C_TYPE => "uint16_t", IS_REFERENCE => 0, - NDR_ALIGN => 2 }, # 4 byte types "int32" => { C_TYPE => "int32_t", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, "uint32" => { C_TYPE => "uint32_t", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, # 8 byte types "hyper" => { C_TYPE => "uint64_t", IS_REFERENCE => 0, - NDR_ALIGN => 8 }, "dlong" => { C_TYPE => "int64_t", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, "udlong" => { C_TYPE => "uint64_t", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, "udlongr" => { C_TYPE => "uint64_t", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, # DATA_BLOB types "DATA_BLOB" => { C_TYPE => "DATA_BLOB", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, # string types "string" => { C_TYPE => "const char *", IS_REFERENCE => 1, - NDR_ALIGN => 4 #??? }, "string_array" => { C_TYPE => "const char **", IS_REFERENCE => 1, - NDR_ALIGN => 4 #??? }, # time types "time_t" => { C_TYPE => "time_t", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, "NTTIME" => { C_TYPE => "NTTIME", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, "NTTIME_1sec" => { C_TYPE => "NTTIME", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, "NTTIME_hyper" => { C_TYPE => "NTTIME", IS_REFERENCE => 0, - NDR_ALIGN => 8 }, @@ -132,34 +113,28 @@ my $scalars = { "WERROR" => { C_TYPE => "WERROR", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, "NTSTATUS" => { C_TYPE => "NTSTATUS", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, "COMRESULT" => { C_TYPE => "COMRESULT", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, # special types "nbt_string" => { C_TYPE => "const char *", IS_REFERENCE => 1, - NDR_ALIGN => 4 #??? }, "wrepl_nbt_name"=> { C_TYPE => "struct nbt_name", IS_REFERENCE => 0, - NDR_ALIGN => 4 }, "ipv4address" => { C_TYPE => "const char *", IS_REFERENCE => 1, - NDR_ALIGN => 4 } }; @@ -175,17 +150,6 @@ sub mapScalarType($) die("Unknown scalar type $name"); } -sub getScalarAlignment($) -{ - my $name = shift; - - # it's a bug when a type is not in the list - # of known scalars or has no mapping - return $scalars->{$name}{NDR_ALIGN} if defined($scalars->{$name}) and defined($scalars->{$name}{NDR_ALIGN}); - - die("Unknown scalar type $name"); -} - sub addType($) { my $t = shift; -- cgit From e0040ff537f080a77ceb041915f6d04ac138955c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 3 Oct 2005 23:54:44 +0000 Subject: r10698: Fix support of enums in switch_type() in the ethereal parser generator (This used to be commit 9fac8dfeb393212e16be7156de466077bc90232d) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index b497f87403..e7a6b80b7b 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -9,7 +9,7 @@ package Parse::Pidl::Ethereal::NDR; use strict; -use Parse::Pidl::Typelist; +use Parse::Pidl::Typelist qw(getType); use Parse::Pidl::Util qw(has_property ParseExpr property_matches make_str); use Parse::Pidl::NDR; use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); @@ -485,7 +485,16 @@ sub Union($$$) $res.="\t\tbreak;\n"; } - my $switch_type = $e->{SWITCH_TYPE}; + my $switch_type; + my $switch_dissect; + my $switch_dt = getType($e->{SWITCH_TYPE}); + if ($switch_dt->{DATA}->{TYPE} eq "ENUM") { + $switch_type = "g".Parse::Pidl::Typelist::enum_type_fn($switch_dt); + $switch_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($switch_dt); + } elsif ($switch_dt->{DATA}->{TYPE} eq "SCALAR") { + $switch_type = "g$e->{SWITCH_TYPE}"; + $switch_dissect = "dissect_ndr_$e->{SWITCH_TYPE}"; + } pidl_code "static int"; pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; @@ -494,7 +503,7 @@ sub Union($$$) pidl_code "proto_item *item = NULL;"; pidl_code "proto_tree *tree = NULL;"; pidl_code "int old_offset;"; - pidl_code "g$switch_type level;"; + pidl_code "$switch_type level;"; pidl_code ""; if ($e->{ALIGN} > 1) { @@ -513,7 +522,7 @@ sub Union($$$) pidl_code ""; - pidl_code "offset = dissect_ndr_$switch_type(tvb, offset, pinfo, tree, drep, hf_index, &level);"; + pidl_code "offset = $switch_dissect(tvb, offset, pinfo, tree, drep, hf_index, &level);"; pidl_code "switch(level) {$res\t}"; pidl_code "proto_item_set_len(item, offset-old_offset);\n"; -- cgit From 55065d27cede4e2cdc0e1240b1b5952fa5697391 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 4 Oct 2005 13:07:23 +0000 Subject: r10713: Couple more updates to the Samba3 parser generators. Unions and enums have been improved, init functions are now generated properly, some other small improvements. (This used to be commit 8a60e79175eb27ef9fa4b8dea72a518bbaab900f) --- source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 4 +- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 61 ++++++---- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 127 ++++++++++++++------ source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 169 +++++++++++++++++++++++++++ source4/pidl/lib/Parse/Pidl/Samba3/Util.pm | 29 ----- 5 files changed, 300 insertions(+), 90 deletions(-) create mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Types.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Util.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm index 59d048176f..83762719ea 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm @@ -9,7 +9,7 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba3::Util qw(MapSamba3Type); +use Parse::Pidl::Samba3::Types qw(DeclLong); use vars qw($VERSION); $VERSION = '0.01'; @@ -28,7 +28,7 @@ sub ParseFunction($$) my $args = ""; my $defargs = ""; foreach (@{$fn->{ELEMENTS}}) { - $defargs .= ", " . MapSamba3Type($_); + $defargs .= ", " . DeclLong($_); $args .= ", $_->{NAME}"; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index be7f1ca5c4..13f506a7da 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -9,7 +9,7 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba3::Util qw(MapSamba3Type); +use Parse::Pidl::Samba3::Types qw(DeclShort); use vars qw($VERSION); $VERSION = '0.01'; @@ -17,24 +17,30 @@ $VERSION = '0.01'; my $res = ""; sub pidl($) { my $x = shift; $res .= "$x\n"; } sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } +sub warning($$) { my ($e,$s) = @_; warn("$e->{FILE}:$e->{LINE}: $s\n"); } + +sub ParseElement($) +{ + my $e = shift; + + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER") { + return if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "top"); + pidl "\tuint32 ptr_$e->{NAME};"; + } elsif ($l->{TYPE} eq "SWITCH") { + pidl "\tuint32 level_$e->{NAME};"; + } elsif ($l->{TYPE} eq "DATA") { + pidl "\t" . DeclShort($e) . ";"; + } + } +} sub CreateStruct($$$$) { my ($if,$fn,$n,$t) = @_; pidl "typedef struct $n {"; - foreach my $e (@$t) { - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "POINTER") { - return if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "top"); - pidl "\tuint32 ptr_$e->{NAME};"; - } elsif ($l->{TYPE} eq "SWITCH") { - pidl "\tuint32 level_$e->{NAME};"; - } elsif ($l->{TYPE} eq "DATA") { - pidl "\t" . MapSamba3Type($e) . ";"; - } - } - } + ParseElement($_) foreach (@$t); if (not @$t) { # Some compilers don't like empty structs @@ -83,16 +89,23 @@ sub ParseStruct($$$) CreateStruct($if, $s, "$if->{NAME}_$n", $s->{ELEMENTS}); } +sub ParseUnion($$$) +{ + my ($if,$u,$n) = @_; + + pidl "typedef union {"; + #FIXME: What about elements that require more then one variable? + ParseElement($_) foreach (@{$u->{ELEMENTS}}); + pidl "} $n;"; + pidl ""; +} + sub ParseEnum($$$) { my ($if,$s,$n) = @_; pidl "typedef enum {"; - - foreach (@{$s->{ELEMENTS}}) { - pidl "$_,"; - } - + pidl "$_," foreach (@{$s->{ELEMENTS}}); pidl "} $n;"; } @@ -122,15 +135,15 @@ sub ParseInterface($) pidl ""; - ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); - foreach (@{$if->{TYPEDEFS}}) { - ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "STRUCT"); - ParseEnum($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "ENUM"); - ParseBitmap($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "BITMAP"); - fatal($_, "Unions not supported for Samba3 yet") if ($_->{TYPE} eq "STRUCT"); + ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "STRUCT"); + ParseEnum($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "ENUM"); + ParseBitmap($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "BITMAP"); + ParseUnion($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "UNION"); } + ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); + foreach (@{$if->{CONSTS}}) { pidl "$_->{NAME} ($_->{VALUE})"; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index 8518537ddb..5caab5da0c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -9,7 +9,7 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba3::Util qw(MapSamba3Type); +use Parse::Pidl::Samba3::Types qw(DeclShort DeclLong InitType DissectType); use vars qw($VERSION); $VERSION = '0.01'; @@ -21,24 +21,40 @@ sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $res .= $tabs.(shift)."\n"; } sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } +#TODO: +# - Different scalars / buffers functions for arrays + unions +# - Register own types with Types::AddType() +# - Find external types somehow? + +sub DeclareArrayVariables($) +{ + my $es = shift; + + foreach my $e (@$es) { + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "ARRAY") { + pidl "uint32 i_$e->{NAME}_$l->{LEVEL_INDEX};"; + } + } + } +} + sub ParseElementLevelData($$$$$) { my ($e,$l,$nl,$env,$varname) = @_; - #FIXME: This only works for scalar types - pidl "if (!prs_$l->{DATA_TYPE}(\"$e->{NAME}\", ps, depth, &$varname))"; + pidl "if (!".DissectType($e, $l, $varname).")"; pidl "\treturn False;"; - pidl ""; } sub ParseElementLevelArray($$$$$) { my ($e,$l,$nl,$env,$varname) = @_; - #FIXME - pidl "for (i=0; i<".ParseExpr("length_$e->{NAME}", $env) .";i++) {"; + my $i = "i_$e->{NAME}_$l->{LEVEL_INDEX}"; + pidl "for ($i=0; $i<".ParseExpr("length_$e->{NAME}", $env) .";$i++) {"; indent; - ParseElementLevel($e,$nl,$env,"$varname\[i]"); + ParseElementLevel($e,$nl,$env,$varname."[$i]"); deindent; pidl "}"; } @@ -58,8 +74,9 @@ sub ParseElementLevelPtr($$$$$) { my ($e,$l,$nl,$env,$varname) = @_; - # No top-level ref pointers for Samba 3 - return if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP"); + if ($l->{POINTER_TYPE} eq "relative") { + fatal($e, "relative pointers not supported for Samba 3"); + } pidl "if (!prs_uint32(\"ptr_$e->{NAME}\",ps,depth,&" . ParseExpr("ptr_$e->{NAME}", $env) . ", ps, depth))"; pidl "\treturn False;"; @@ -99,24 +116,65 @@ sub ParseElement($$) ParseElementLevel($e, $e->{LEVELS}[0], $env, ParseExpr($e->{NAME}, $env)); } -sub CreateStruct($$$) +sub InitLevel($$$$); + +sub InitLevel($$$$) +{ + my ($e,$l,$varname,$env) = @_; + + if ($l->{TYPE} eq "POINTER") { + pidl "if ($varname) {"; + indent; + pidl ParseExpr("ptr_$e->{NAME}", $env) . " = 1;"; + InitLevel($e, GetNextLevel($e,$l), $varname, $env); + deindent; + pidl "} else {"; + pidl "\t" . ParseExpr("ptr_$e->{NAME}", $env) . " = 0;"; + pidl "}"; + } elsif ($l->{TYPE} eq "ARRAY") { + pidl "for (i = 0; i < " . ParseExpr("len_$e->{NAME}", $env) . "; i++) {"; + indent; + InitLevel($e, GetNextLevel($e,$l), $varname."[i]", $env); + deindent; + pidl "}"; + } elsif ($l->{TYPE} eq "DATA") { + pidl InitType($e, $l, $varname, $varname); + } elsif ($l->{TYPE} eq "SWITCH") { + InitLevel($e, GetNextLevel($e,$l), $varname, $env); + } +} + +sub CreateStruct($$$$) { - my ($fn,$s,$es) = @_; + my ($fn,$s,$es,$a) = @_; my $args = ""; foreach my $e (@$es) { - $args .= ", " . MapSamba3Type($_); + $args .= ", " . DeclLong($_); + } + + my $env = {}; + foreach my $e (@$es) { + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "DATA") { + $env->{"$e->{NAME}"} = $e->{"v->$e->{NAME}"}; + } elsif ($l->{TYPE} eq "POINTER") { + $env->{"ptr_$e->{NAME}"} = $e->{"v->ptr_$e->{NAME}"}; + } elsif ($l->{TYPE} eq "SWITCH") { + $env->{"level_$e->{NAME}"} = $e->{"v->level_$e->{NAME}"}; + } + } } pidl "BOOL init_$fn($s *v$args)"; pidl "{"; indent; pidl "DEBUG(5,(\"init_$fn\\n\"));"; + pidl ""; # Call init for all arguments - foreach my $e (@$es) { - foreach my $l (@{$e->{LEVELS}}) { - #FIXME - } + foreach (@$es) { + InitLevel($_, $_->{LEVELS}[0], ParseExpr($_->{NAME}, $env), $env); + pidl ""; } pidl "return True;"; deindent; @@ -126,29 +184,22 @@ sub CreateStruct($$$) pidl "BOOL $fn(const char *desc, $s *v, prs_struct *ps, int depth)"; pidl "{"; indent; + DeclareArrayVariables($es); pidl "if (v == NULL)"; pidl "\treturn False;"; pidl ""; pidl "prs_debug(ps, depth, desc, \"$fn\");"; pidl "depth++;"; - pidl "if (!prs_align(ps))"; - pidl "\treturn False;"; - pidl ""; - - my $env = {}; - foreach my $e (@$es) { - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "DATA") { - $env->{"$e->{NAME}"} = $e->{"v->$e->{NAME}"}; - } elsif ($l->{TYPE} eq "POINTER") { - $env->{"ptr_$e->{NAME}"} = $e->{"v->ptr_$e->{NAME}"}; - } elsif ($l->{TYPE} eq "SWITCH") { - $env->{"level_$e->{NAME}"} = $e->{"v->level_$e->{NAME}"}; - } - } + if ($a > 0) { + pidl "if (!prs_align(ps, $a))"; + pidl "\treturn False;"; + pidl ""; } - ParseElement($_, $env) foreach (@$es); + foreach (@$es) { + ParseElement($_, $env); + pidl ""; + } pidl "return True;"; deindent; @@ -163,7 +214,7 @@ sub ParseStruct($$$) my $fn = "$if->{NAME}_io_$n"; my $sn = uc("$if->{NAME}_$n"); - CreateStruct($fn, $sn, $s->{ELEMENTS}); + CreateStruct($fn, $sn, $s->{ELEMENTS}, $s->{ALIGN}); } sub ParseUnion($$$) @@ -176,6 +227,11 @@ sub ParseUnion($$$) pidl "BOOL $fn(const char *desc, $sn* v, uint32 level, prs_struct *ps, int depth)"; pidl "{"; indent; + DeclareArrayVariables($u->{ELEMENTS}); + pidl "if (!prs_align(ps, $u->{ALIGN}))"; + pidl "\treturn False;"; + pidl ""; + pidl "switch (level) {"; indent; @@ -187,6 +243,7 @@ sub ParseUnion($$$) deindent; pidl "depth--;"; pidl "break"; + pidl ""; } deindent; @@ -222,8 +279,8 @@ sub ParseFunction($$) } ); } - CreateStruct("$if->{NAME}_io_q_$fn->{NAME}", uc("$if->{NAME}_q_$fn->{NAME}"), \@in); - CreateStruct("$if->{NAME}_io_r_$fn->{NAME}", uc("$if->{NAME}_r_$fn->{NAME}"), \@out); + CreateStruct("$if->{NAME}_io_q_$fn->{NAME}", uc("$if->{NAME}_q_$fn->{NAME}"), \@in, 0); + CreateStruct("$if->{NAME}_io_r_$fn->{NAME}", uc("$if->{NAME}_r_$fn->{NAME}"), \@out, 0); } sub ParseInterface($) diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm new file mode 100644 index 0000000000..68bea0d024 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -0,0 +1,169 @@ +################################################### +# Samba3 common helper functions +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba3::Types; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT_OK = qw(DeclShort DeclLong InitType DissectType AddType); + +use strict; +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); + +use vars qw($VERSION); +$VERSION = '0.01'; + +sub init_scalar($$$$) +{ + my ($e,$l,$n,$v) = @_; + + return "$n = $v;"; +} + +sub dissect_scalar($$$) +{ + my ($e,$l,$n) = @_; + + my $t = lc($e->{TYPE}); + + return "prs_$t(\"$e->{NAME}\", ps, depth, &$n)"; +} + +sub decl_string($) +{ + my $e = shift; + + return "UNISTR2"; +} + +sub init_string($$$$) +{ + my ($e,$l,$n,$v) = @_; + + return "init_unistr2(&$n, $v, UNI_FLAGS_NONE);"; +} + +sub dissect_string($$$) +{ + my ($e,$l,$n) = @_; + + return "FIXME"; +} + +my $known_types = { + uint8 => { + DECL => "uint8", + INIT => \&init_scalar, + DISSECT => \&dissect_scalar, + }, + uint16 => { + DECL => "uint16", + INIT => \&init_scalar, + DISSECT => \&dissect_scalar, + }, + uint32 => { + DECL => "uint32", + INIT => \&init_scalar, + DISSECT => \&dissect_scalar, + }, + string => { + DECL => \&decl_string, + INIT => \&init_string, + DISSECT => \&dissect_string, + }, + NTSTATUS => { + DECL => "NTSTATUS", + INIT => \&init_scalar, + DISSECT => \&dissect_scalar, + }, + WERROR => { + DECL => "WERROR", + INIT => \&init_scalar, + DISSECT => \&dissect_scalar, + }, +}; + +sub AddType($$) +{ + my ($t,$d) = @_; + + warn("Reregistering type $t") if (defined($known_types->{$t})); + + $known_types->{$t} = $d; +} + +sub GetType($) +{ + my $e = shift; + + my $t = $known_types->{$e->{TYPE}}; + + return undef if not $t; + + # DECL can be a function + if (ref($t->{DECL}) eq "CODE") { + return $t->{DECL}->($e); + } else { + return $t->{DECL}; + } +} + +# Return type without special stuff, as used in +# struct declarations +sub DeclShort($) +{ + my $e = shift; + + my $t = GetType($e); + return undef if not $t; + + return "$t $e->{NAME}"; +} + +sub DeclLong($) +{ + my $e = shift; + + my $t = GetType($e); + + return undef if not $t; + + return "$t $e->{NAME}"; +} + +sub InitType($$$$) +{ + my ($e, $l, $varname, $value) = @_; + + my $t = $known_types->{$l->{DATA_TYPE}}; + + return undef if not $t; + + # INIT can be a function + if (ref($t->{INIT}) eq "CODE") { + return $t->{INIT}->($e, $l, $varname, $value); + } else { + return $t->{INIT}; + } +} + +sub DissectType($$$) +{ + my ($e, $l, $varname) = @_; + + my $t = $known_types->{$l->{DATA_TYPE}}; + + return undef if not $t; + + # DISSECT can be a function + if (ref($t->{DISSECT}) eq "CODE") { + return $t->{DISSECT}->($e, $l, $varname); + } else { + return $t->{DISSECT}; + } +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Util.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Util.pm deleted file mode 100644 index 2d4179df76..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Util.pm +++ /dev/null @@ -1,29 +0,0 @@ -################################################### -# Samba3 common helper functions -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba3::Util; - -require Exporter; -@ISA = qw(Exporter); -@EXPORT_OK = qw(MapSamba3Type); - -use strict; -use Parse::Pidl::Typelist qw(hasType getType mapType); -use Parse::Pidl::Util qw(has_property ParseExpr); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); - -use vars qw($VERSION); -$VERSION = '0.01'; - -sub MapSamba3Type($) -{ - my $e = shift; - - return "UNISTR2 $e->{NAME}" if ($e->{TYPE} eq "string"); - - return "$e->{TYPE} $e->{NAME}"; -} - -1; -- cgit From 81c306472a9c6bf6238e916e49076525d4920ed8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 4 Oct 2005 17:21:31 +0000 Subject: r10715: More Samba3 parser generator improvements: - Actually generate parsers for unions and structs. - Support some more builtin types. - Some more work on supporting arrays. - Several other small fixes. I've updated the example output at http://samba.org/~jelmer/ (This used to be commit b229c033ebc7ec972b32f1b75b60a9c68a36db97) --- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 37 ++++++----- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 97 ++++++++++++++++++++++++---- 2 files changed, 104 insertions(+), 30 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index 5caab5da0c..57ee1543ff 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -23,8 +23,7 @@ sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } #TODO: # - Different scalars / buffers functions for arrays + unions -# - Register own types with Types::AddType() -# - Find external types somehow? +# - Memory allocation for arrays? sub DeclareArrayVariables($) { @@ -78,7 +77,7 @@ sub ParseElementLevelPtr($$$$$) fatal($e, "relative pointers not supported for Samba 3"); } - pidl "if (!prs_uint32(\"ptr_$e->{NAME}\",ps,depth,&" . ParseExpr("ptr_$e->{NAME}", $env) . ", ps, depth))"; + pidl "if (!prs_uint32(\"ptr_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr_$e->{NAME}", $env) . ", ps, depth))"; pidl "\treturn False;"; pidl ""; @@ -138,7 +137,7 @@ sub InitLevel($$$$) deindent; pidl "}"; } elsif ($l->{TYPE} eq "DATA") { - pidl InitType($e, $l, $varname, $varname); + pidl InitType($e, $l, ParseExpr($e->{NAME}, $env), $varname); } elsif ($l->{TYPE} eq "SWITCH") { InitLevel($e, GetNextLevel($e,$l), $varname, $env); } @@ -149,20 +148,22 @@ sub CreateStruct($$$$) my ($fn,$s,$es,$a) = @_; my $args = ""; - foreach my $e (@$es) { + foreach (@$es) { $args .= ", " . DeclLong($_); } - my $env = {}; + my $env = { "this" => "v" }; foreach my $e (@$es) { foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "DATA") { - $env->{"$e->{NAME}"} = $e->{"v->$e->{NAME}"}; + $env->{$e->{NAME}} = "v->$e->{NAME}"; } elsif ($l->{TYPE} eq "POINTER") { - $env->{"ptr_$e->{NAME}"} = $e->{"v->ptr_$e->{NAME}"}; + $env->{"ptr_$e->{NAME}"} = "v->ptr_$e->{NAME}"; } elsif ($l->{TYPE} eq "SWITCH") { - $env->{"level_$e->{NAME}"} = $e->{"v->level_$e->{NAME}"}; - } + $env->{"level_$e->{NAME}"} = "v->level_$e->{NAME}"; + } elsif ($l->{TYPE} eq "ARRAY") { + $env->{"length_$e->{NAME}"} = "v->length_$e->{NAME}"; + } } } @@ -173,7 +174,7 @@ sub CreateStruct($$$$) pidl ""; # Call init for all arguments foreach (@$es) { - InitLevel($_, $_->{LEVELS}[0], ParseExpr($_->{NAME}, $env), $env); + InitLevel($_, $_->{LEVELS}[0], $_->{NAME}, $env); pidl ""; } pidl "return True;"; @@ -238,11 +239,13 @@ sub ParseUnion($$$) foreach (@{$u->{ELEMENTS}}) { pidl "$_->{CASE}:"; indent; - pidl "depth++;"; - ParseElement($_, {}); + if ($_->{TYPE} ne "EMPTY") { + pidl "depth++;"; + ParseElement($_, {}); + pidl "depth--;"; + } + pidl "break;"; deindent; - pidl "depth--;"; - pidl "break"; pidl ""; } @@ -290,8 +293,8 @@ sub ParseInterface($) # Structures first pidl "/* $if->{NAME} structures */"; foreach (@{$if->{TYPEDEFS}}) { - ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "STRUCT"); - ParseUnion($if, $_->{DATA}, $_->{NAME}) if ($_->{TYPE} eq "UNION"); + ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "STRUCT"); + ParseUnion($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "UNION"); } pidl "/* $if->{NAME} functions */"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index 68bea0d024..b9d969216c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -1,5 +1,5 @@ ################################################### -# Samba3 common helper functions +# Samba3 type-specific declarations / initialization / marshalling # Copyright jelmer@samba.org 2005 # released under the GNU GPL @@ -16,6 +16,10 @@ use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use vars qw($VERSION); $VERSION = '0.01'; +# TODO: Find external types somehow? + +sub warning($$) { my ($e,$s) = @_; print STDERR "$e->{FILE}:$e->{LINE}: $s\n"; } + sub init_scalar($$$$) { my ($e,$l,$n,$v) = @_; @@ -36,6 +40,8 @@ sub decl_string($) { my $e = shift; + # FIXME: More intelligent code here - select between UNISTR2 and other + # variants return "UNISTR2"; } @@ -50,40 +56,67 @@ sub dissect_string($$$) { my ($e,$l,$n) = @_; - return "FIXME"; + return "prs_unistr2(True, \"$e->{NAME}\", ps, depth, &n)"; +} + +sub init_uuid($$$$) +{ + my ($e,$l,$n,$v) = @_; + + return ""; +} + +sub dissect_uuid($$$) +{ + my ($e,$l,$n) = @_; + + return "smb_io_uuid(\"$e->{NAME}\", &$n, ps, depth)"; } -my $known_types = { - uint8 => { +my $known_types = +{ + uint8 => + { DECL => "uint8", INIT => \&init_scalar, DISSECT => \&dissect_scalar, }, - uint16 => { + uint16 => + { DECL => "uint16", INIT => \&init_scalar, DISSECT => \&dissect_scalar, }, - uint32 => { + uint32 => + { DECL => "uint32", INIT => \&init_scalar, DISSECT => \&dissect_scalar, }, - string => { + string => + { DECL => \&decl_string, INIT => \&init_string, DISSECT => \&dissect_string, }, - NTSTATUS => { + NTSTATUS => + { DECL => "NTSTATUS", INIT => \&init_scalar, DISSECT => \&dissect_scalar, }, - WERROR => { + WERROR => + { DECL => "WERROR", INIT => \&init_scalar, DISSECT => \&dissect_scalar, }, + GUID => + { + DECL => "struct uuid", + INIT => \&init_uuid, + DISSECT => \&dissect_uuid, + } }; sub AddType($$) @@ -101,7 +134,10 @@ sub GetType($) my $t = $known_types->{$e->{TYPE}}; - return undef if not $t; + if (not $t) { + warning($e, "Can't declare unknown type $e->{TYPE}"); + return undef; + } # DECL can be a function if (ref($t->{DECL}) eq "CODE") { @@ -131,7 +167,13 @@ sub DeclLong($) return undef if not $t; - return "$t $e->{NAME}"; + my $ptrs = ""; + + foreach my $l (@{$e->{LEVELS}}) { + ($ptrs.="*") if ($l->{TYPE} eq "POINTER"); + } + + return "$t $ptrs$e->{NAME}"; } sub InitType($$$$) @@ -140,7 +182,10 @@ sub InitType($$$$) my $t = $known_types->{$l->{DATA_TYPE}}; - return undef if not $t; + if (not $t) { + warning($e, "Don't know how to initialize type $l->{DATA_TYPE}"); + return undef; + } # INIT can be a function if (ref($t->{INIT}) eq "CODE") { @@ -156,7 +201,10 @@ sub DissectType($$$) my $t = $known_types->{$l->{DATA_TYPE}}; - return undef if not $t; + if (not $t) { + warning($e, "Don't know how to dissect type $l->{DATA_TYPE}"); + return undef; + } # DISSECT can be a function if (ref($t->{DISSECT}) eq "CODE") { @@ -166,4 +214,27 @@ sub DissectType($$$) } } +sub LoadTypes($) +{ + my $ndr = shift; + foreach my $if (@{$ndr}) { + next unless ($if->{TYPE} eq "INTERFACE"); + + foreach my $td (@{$if->{TYPEDEFS}}) { + AddType($td->{NAME}, { + DECL => uc("$if->{NAME}_$td->{NAME}"), + INIT => sub { + my ($e,$l,$n,$v) = @_; + return "init_$td->{NAME}(&$n/*FIXME:OTHER ARGS*/);"; + }, + DISSECT => sub { + my ($e,$l,$n) = @_; + + return "$if->{NAME}_io_$td->{NAME}(\"$e->{NAME}\", &$n, ps, depth)"; + } + }); + } + } +} + 1; -- cgit From eea74cde05c1532d59b9f8ecc4f88c191a4b200f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 4 Oct 2005 18:24:21 +0000 Subject: r10716: Use correct Samba3 data types for strings. Also use Samba3 types for a couple of other types (policy handles, SIDs, times) (This used to be commit c2527217b4b4c120d82044e65b979dd3b7d2609e) --- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 87 +++++++++++++++++++++-------- 1 file changed, 65 insertions(+), 22 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index b9d969216c..f93e90fe1f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -10,7 +10,7 @@ require Exporter; @EXPORT_OK = qw(DeclShort DeclLong InitType DissectType AddType); use strict; -use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::Util qw(has_property ParseExpr property_matches); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use vars qw($VERSION); @@ -40,37 +40,44 @@ sub decl_string($) { my $e = shift; - # FIXME: More intelligent code here - select between UNISTR2 and other - # variants - return "UNISTR2"; -} + my $is_conformant = property_matches($e, "flag", ".*STR_SIZE4.*"); + my $is_varying = property_matches($e, "flag", ".*STR_LEN4.*"); + my $is_ascii = property_matches($e, "flag", ".*STR_ASCII.*"); -sub init_string($$$$) -{ - my ($e,$l,$n,$v) = @_; - - return "init_unistr2(&$n, $v, UNI_FLAGS_NONE);"; -} + return "STRING2" if ($is_conformant and $is_varying and $is_ascii); -sub dissect_string($$$) -{ - my ($e,$l,$n) = @_; + return "UNISTR2" if ($is_conformant and $is_varying); + return "UNISTR3" if ($is_varying); + # We don't do UNISTR4, as we have lsa_String for that in Samba4's IDL - return "prs_unistr2(True, \"$e->{NAME}\", ps, depth, &n)"; + die("Don't know what string type to use"); } -sub init_uuid($$$$) +sub init_string($$$$) { my ($e,$l,$n,$v) = @_; - return ""; + my $t = lc(decl_string($e)); + + my $flags; + if (property_matches($e, "flag", ".*STR_NULLTERM.*")) { + $flags = "UNI_STR_TERMINATE"; + } elsif (property_matches($e, "flag", ".*STR_NOTERM.*")) { + $flags = "UNI_STR_NOTERM"; + } else { + $flags = "UNI_FLAGS_NONE"; + } + + return "init_$t(&$n, $v, $flags);"; } -sub dissect_uuid($$$) +sub dissect_string($$$) { my ($e,$l,$n) = @_; - return "smb_io_uuid(\"$e->{NAME}\", &$n, ps, depth)"; + my $t = lc(decl_string($e)); + + return "prs_$t(True, \"$e->{NAME}\", ps, depth, &n)"; } my $known_types = @@ -93,6 +100,12 @@ my $known_types = INIT => \&init_scalar, DISSECT => \&dissect_scalar, }, + uint64 => + { + DECL => "uint64", + INIT => \&init_scalar, + DISSECT => \&dissect_scalar, + }, string => { DECL => \&decl_string, @@ -114,9 +127,39 @@ my $known_types = GUID => { DECL => "struct uuid", - INIT => \&init_uuid, - DISSECT => \&dissect_uuid, - } + INIT => "", + DISSECT => sub { + my ($e,$l,$n) = @_; + return "smb_io_uuid(\"$e->{NAME}\", &$n, ps, depth)"; + } + }, + NTTIME => + { + DECL => "NTTIME", + INIT => "", + DISSECT => sub { + my ($e,$l,$n) = @_; + return "smb_io_nttime(\"$e->{NAME}\", &n, ps, depth)"; + } + }, + dom_sid => + { + DECL => "DOM_SID", + INIT => "", + DISSECT => sub { + my ($e,$l,$n) = @_; + return "smb_io_dom_sid(\"$e->{NAME}\", &n, ps, depth)"; + } + }, + policy_handle => + { + DECL => "POLICY_HND", + INIT => "", + DISSECT => sub { + my ($e,$l,$n) = @_; + return "smb_io_pol_hnd(\"$e->{NAME}\", &n, ps, depth)"; + } + }, }; sub AddType($$) -- cgit From 9879bc6aa6c7997220079b3501b9a4fb3682c813 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 4 Oct 2005 19:38:35 +0000 Subject: r10717: Another bunch of small updates. All generated files except parse_dfs.c compile now when generated from Samba4's dfs.idl. (This used to be commit 2b315b1942e77640eca8e0a3347b2a9ed1920f6a) --- source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 12 +++++++----- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 6 +++--- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 20 +++++++++++++------- source4/pidl/lib/Parse/Pidl/Samba3/Server.pm | 10 +++++++--- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 2 +- 5 files changed, 31 insertions(+), 19 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm index 83762719ea..d79aede138 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm @@ -25,11 +25,13 @@ sub ParseFunction($$) { my ($if,$fn) = @_; - my $args = ""; + my $inargs = ""; my $defargs = ""; foreach (@{$fn->{ELEMENTS}}) { $defargs .= ", " . DeclLong($_); - $args .= ", $_->{NAME}"; + if (grep(/in/, @{$_->{DIRECTION}})) { + $inargs .= ", $_->{NAME}"; + } } my $uif = uc($if->{NAME}); @@ -47,13 +49,13 @@ sub ParseFunction($$) pidl ""; pidl "/* Marshall data and send request */"; pidl ""; - pidl "init_$if->{NAME}_q_$fn->{NAME}(&q$args);"; + pidl "init_$if->{NAME}_q_$fn->{NAME}(&q$inargs);"; pidl ""; pidl "CLI_DO_RPC(cli, mem_ctx, PI_$uif, $ufn,"; pidl "\tq, r,"; pidl "\tqbuf, rbuf, "; - pidl "\t$if->{NAME}_q_$fn->{NAME},"; - pidl "\t$if->{NAME}_r_$fn->{NAME},"; + pidl "\t$if->{NAME}_io_q_$fn->{NAME},"; + pidl "\t$if->{NAME}_io_r_$fn->{NAME},"; pidl "\tNT_STATUS_UNSUCCESSFUL);"; pidl ""; pidl "/* Return result */"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 13f506a7da..1e0e2c7270 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -58,7 +58,7 @@ sub ParseFunction($$) my @in = (); my @out = (); - foreach (@{$_->{ELEMENTS}}) { + foreach (@{$fn->{ELEMENTS}}) { push (@in, $_) if (grep(/in/, @{$_->{DIRECTION}})); push (@out, $_) if (grep(/out/, @{$_->{DIRECTION}})); } @@ -93,10 +93,10 @@ sub ParseUnion($$$) { my ($if,$u,$n) = @_; - pidl "typedef union {"; + pidl "typedef union $if->{NAME}_$n {"; #FIXME: What about elements that require more then one variable? ParseElement($_) foreach (@{$u->{ELEMENTS}}); - pidl "} $n;"; + pidl "} ".uc($if->{NAME}."_".$n) .";"; pidl ""; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index 57ee1543ff..9a7c7d2578 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -143,9 +143,9 @@ sub InitLevel($$$$) } } -sub CreateStruct($$$$) +sub CreateStruct($$$$$) { - my ($fn,$s,$es,$a) = @_; + my ($fn,$ifn, $s,$es,$a) = @_; my $args = ""; foreach (@$es) { @@ -167,10 +167,10 @@ sub CreateStruct($$$$) } } - pidl "BOOL init_$fn($s *v$args)"; + pidl "BOOL $ifn($s *v$args)"; pidl "{"; indent; - pidl "DEBUG(5,(\"init_$fn\\n\"));"; + pidl "DEBUG(5,(\"$ifn\\n\"));"; pidl ""; # Call init for all arguments foreach (@$es) { @@ -215,7 +215,7 @@ sub ParseStruct($$$) my $fn = "$if->{NAME}_io_$n"; my $sn = uc("$if->{NAME}_$n"); - CreateStruct($fn, $sn, $s->{ELEMENTS}, $s->{ALIGN}); + CreateStruct($fn, "init_$if->{NAME}_$n", $sn, $s->{ELEMENTS}, $s->{ALIGN}); } sub ParseUnion($$$) @@ -282,8 +282,14 @@ sub ParseFunction($$) } ); } - CreateStruct("$if->{NAME}_io_q_$fn->{NAME}", uc("$if->{NAME}_q_$fn->{NAME}"), \@in, 0); - CreateStruct("$if->{NAME}_io_r_$fn->{NAME}", uc("$if->{NAME}_r_$fn->{NAME}"), \@out, 0); + CreateStruct("$if->{NAME}_io_q_$fn->{NAME}", + "init_$if->{NAME}_q_$fn->{NAME}", + uc("$if->{NAME}_q_$fn->{NAME}"), + \@in, 0); + CreateStruct("$if->{NAME}_io_r_$fn->{NAME}", + "init_$if->{NAME}_r_$fn->{NAME}", + uc("$if->{NAME}_r_$fn->{NAME}"), + \@out, 0); } sub ParseInterface($) diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm index 0372cf1117..3f1f4645a1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm @@ -33,13 +33,17 @@ sub ParseFunction($$) indent; pidl uc("$if->{NAME}_q_$fn->{NAME}") . " q_u;"; pidl uc("$if->{NAME}_r_$fn->{NAME}") . " r_u;"; - pidl "prs_struct *data = &p->in_data.data"; - pidl "prs_struct *rdata = &p->out_data.rdata"; + pidl "prs_struct *data = &p->in_data.data;"; + pidl "prs_struct *rdata = &p->out_data.rdata;"; pidl ""; pidl "if (!$if->{NAME}_io_q_$fn->{NAME}(\"\", &q_u, data, 0))"; pidl "\treturn False;"; pidl ""; - pidl "r_u.status = _$fn->{NAME}(p, &q_u, &r_u);"; + if ($fn->{RETURN_TYPE}) { + pidl "r_u.status = _$fn->{NAME}(p, &q_u, &r_u);"; + } else { + pidl "_$fn->{NAME}(p, &q_u, &r_u);"; + } pidl ""; pidl "if (!$if->{NAME}_io_r_$fn->{NAME}(\"\", &r_u, rdata, 0))"; pidl "\treturn False;"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index f93e90fe1f..c09246e5a9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -268,7 +268,7 @@ sub LoadTypes($) DECL => uc("$if->{NAME}_$td->{NAME}"), INIT => sub { my ($e,$l,$n,$v) = @_; - return "init_$td->{NAME}(&$n/*FIXME:OTHER ARGS*/);"; + return "$n = $v;"; }, DISSECT => sub { my ($e,$l,$n) = @_; -- cgit From 3d6279402caa862db4a7bc4697c667fbd1faa83d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 4 Oct 2005 21:25:18 +0000 Subject: r10718: Another large set of small improvements. All generated files compile without warnings now. The only things left to do that are required for DFS: - add allocation of arrays in marshalling phase - handling primitive and deferred data in embedded structures / unions. Example output is again available from http://samba.org/~jelmer/pidl_samba3/ (This used to be commit 9fe724f6fb026d95306587f696c065f348aaf219) --- source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 8 ++ source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 7 ++ source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 73 +++++++++------ source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 128 +++++++++++++++++++++------ 4 files changed, 160 insertions(+), 56 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm index d79aede138..b48a1b519f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm @@ -58,6 +58,14 @@ sub ParseFunction($$) pidl "\t$if->{NAME}_io_r_$fn->{NAME},"; pidl "\tNT_STATUS_UNSUCCESSFUL);"; pidl ""; + pidl "/* Return variables */"; + foreach (@{$fn->{ELEMENTS}}) { + next unless (grep(/out/, @{$_->{DIRECTION}})); + + pidl "*$_->{NAME} = r.$_->{NAME};"; + } + + pidl""; pidl "/* Return result */"; if (not $fn->{RETURN_TYPE}) { pidl "return NT_STATUS_OK;"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 1e0e2c7270..21a56e4c2d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -31,6 +31,13 @@ sub ParseElement($) pidl "\tuint32 level_$e->{NAME};"; } elsif ($l->{TYPE} eq "DATA") { pidl "\t" . DeclShort($e) . ";"; + } elsif ($l->{TYPE} eq "ARRAY") { + if ($l->{IS_CONFORMANT}) { + pidl "\tuint32 size_$e->{NAME};"; + } + if ($l->{IS_VARYING}) { + pidl "\tuint32 length_$e->{NAME};"; + } } } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index 9a7c7d2578..166d98bfb1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -23,26 +23,38 @@ sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } #TODO: # - Different scalars / buffers functions for arrays + unions -# - Memory allocation for arrays? +# - Memory allocation for arrays sub DeclareArrayVariables($) { my $es = shift; + my $output = 0; + foreach my $e (@$es) { foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "ARRAY") { pidl "uint32 i_$e->{NAME}_$l->{LEVEL_INDEX};"; + $output = 1; } } } + pidl "" if $output; } sub ParseElementLevelData($$$$$) { my ($e,$l,$nl,$env,$varname) = @_; - pidl "if (!".DissectType($e, $l, $varname).")"; + my @args = ($e,$l,$varname); + + # See if we need to add a level argument because we're parsing a union + foreach (@{$e->{LEVELS}}) { + push (@args, ParseExpr("level_$e->{NAME}", $env)) + if ($_->{TYPE} eq "SWITCH"); + } + + pidl "if (!".DissectType(@args).")"; pidl "\treturn False;"; } @@ -50,8 +62,10 @@ sub ParseElementLevelArray($$$$$) { my ($e,$l,$nl,$env,$varname) = @_; + my $len = ParseExpr($l->{LENGTH_IS}, $env); + my $i = "i_$e->{NAME}_$l->{LEVEL_INDEX}"; - pidl "for ($i=0; $i<".ParseExpr("length_$e->{NAME}", $env) .";$i++) {"; + pidl "for ($i=0; $i<$len;$i++) {"; indent; ParseElementLevel($e,$nl,$env,$varname."[$i]"); deindent; @@ -62,7 +76,7 @@ sub ParseElementLevelSwitch($$$$$) { my ($e,$l,$nl,$env,$varname) = @_; - pidl "if (!prs_uint32(\"level\", ps, depth, " . ParseExpr("level_$e->{NAME}", $env) . ", ps, depth))"; + pidl "if (!prs_uint32(\"level\", ps, depth, &" . ParseExpr("level_$e->{NAME}", $env) . "))"; pidl "\treturn False;"; pidl ""; @@ -77,7 +91,7 @@ sub ParseElementLevelPtr($$$$$) fatal($e, "relative pointers not supported for Samba 3"); } - pidl "if (!prs_uint32(\"ptr_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr_$e->{NAME}", $env) . ", ps, depth))"; + pidl "if (!prs_uint32(\"ptr_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr_$e->{NAME}", $env) . "))"; pidl "\treturn False;"; pidl ""; @@ -115,27 +129,22 @@ sub ParseElement($$) ParseElementLevel($e, $e->{LEVELS}[0], $env, ParseExpr($e->{NAME}, $env)); } -sub InitLevel($$$$); - sub InitLevel($$$$) { + sub InitLevel($$$$); my ($e,$l,$varname,$env) = @_; if ($l->{TYPE} eq "POINTER") { pidl "if ($varname) {"; indent; pidl ParseExpr("ptr_$e->{NAME}", $env) . " = 1;"; - InitLevel($e, GetNextLevel($e,$l), $varname, $env); + InitLevel($e, GetNextLevel($e,$l), "*$varname", $env); deindent; pidl "} else {"; pidl "\t" . ParseExpr("ptr_$e->{NAME}", $env) . " = 0;"; pidl "}"; } elsif ($l->{TYPE} eq "ARRAY") { - pidl "for (i = 0; i < " . ParseExpr("len_$e->{NAME}", $env) . "; i++) {"; - indent; - InitLevel($e, GetNextLevel($e,$l), $varname."[i]", $env); - deindent; - pidl "}"; + pidl ParseExpr($e->{NAME}, $env) . " = $varname;"; } elsif ($l->{TYPE} eq "DATA") { pidl InitType($e, $l, ParseExpr($e->{NAME}, $env), $varname); } elsif ($l->{TYPE} eq "SWITCH") { @@ -143,6 +152,22 @@ sub InitLevel($$$$) } } +sub GenerateEnvElement($$) +{ + my ($e,$env) = @_; + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "DATA") { + $env->{$e->{NAME}} = "v->$e->{NAME}"; + } elsif ($l->{TYPE} eq "POINTER") { + $env->{"ptr_$e->{NAME}"} = "v->ptr_$e->{NAME}"; + } elsif ($l->{TYPE} eq "SWITCH") { + $env->{"level_$e->{NAME}"} = "v->level_$e->{NAME}"; + } elsif ($l->{TYPE} eq "ARRAY") { + $env->{"length_$e->{NAME}"} = "v->length_$e->{NAME}"; + } + } +} + sub CreateStruct($$$$$) { my ($fn,$ifn, $s,$es,$a) = @_; @@ -153,19 +178,7 @@ sub CreateStruct($$$$$) } my $env = { "this" => "v" }; - foreach my $e (@$es) { - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "DATA") { - $env->{$e->{NAME}} = "v->$e->{NAME}"; - } elsif ($l->{TYPE} eq "POINTER") { - $env->{"ptr_$e->{NAME}"} = "v->ptr_$e->{NAME}"; - } elsif ($l->{TYPE} eq "SWITCH") { - $env->{"level_$e->{NAME}"} = "v->level_$e->{NAME}"; - } elsif ($l->{TYPE} eq "ARRAY") { - $env->{"length_$e->{NAME}"} = "v->length_$e->{NAME}"; - } - } - } + GenerateEnvElement($_, $env) foreach (@$es); pidl "BOOL $ifn($s *v$args)"; pidl "{"; @@ -192,7 +205,7 @@ sub CreateStruct($$$$$) pidl "prs_debug(ps, depth, desc, \"$fn\");"; pidl "depth++;"; if ($a > 0) { - pidl "if (!prs_align(ps, $a))"; + pidl "if (!prs_align_custom(ps, $a))"; pidl "\treturn False;"; pidl ""; } @@ -229,7 +242,7 @@ sub ParseUnion($$$) pidl "{"; indent; DeclareArrayVariables($u->{ELEMENTS}); - pidl "if (!prs_align(ps, $u->{ALIGN}))"; + pidl "if (!prs_align_custom(ps, $u->{ALIGN}))"; pidl "\treturn False;"; pidl ""; @@ -241,7 +254,9 @@ sub ParseUnion($$$) indent; if ($_->{TYPE} ne "EMPTY") { pidl "depth++;"; - ParseElement($_, {}); + my $env = {}; + GenerateEnvElement($_, $env); + ParseElement($_, $env); pidl "depth--;"; } pidl "break;"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index c09246e5a9..a3bf91d54f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -53,6 +53,26 @@ sub decl_string($) die("Don't know what string type to use"); } +sub contains_pointer($) +{ + my $e = shift; + + foreach my $l (@{$e->{LEVELS}}) { + return 1 if ($l->{TYPE} eq "POINTER"); + } + + return 0; +} + +sub ext_decl_string($) +{ + my $e = shift; + + # One pointer is sufficient.. + return "const char" if (contains_pointer($e)); + return "const char *"; +} + sub init_string($$$$) { my ($e,$l,$n,$v) = @_; @@ -67,6 +87,9 @@ sub init_string($$$$) } else { $flags = "UNI_FLAGS_NONE"; } + + # One pointer is sufficient + if (substr($v, 0, 1) eq "*") { $v = substr($v, 1); } return "init_$t(&$n, $v, $flags);"; } @@ -77,7 +100,7 @@ sub dissect_string($$$) my $t = lc(decl_string($e)); - return "prs_$t(True, \"$e->{NAME}\", ps, depth, &n)"; + return "prs_$t(True, \"$e->{NAME}\", ps, depth, &$n)"; } my $known_types = @@ -109,6 +132,7 @@ my $known_types = string => { DECL => \&decl_string, + EXT_DECL => \&ext_decl_string, INIT => \&init_string, DISSECT => \&dissect_string, }, @@ -172,6 +196,14 @@ sub AddType($$) } sub GetType($) +{ + my $e = shift; + +} + +# Return type without special stuff, as used in +# declarations for internal structs +sub DeclShort($) { my $e = shift; @@ -182,41 +214,66 @@ sub GetType($) return undef; } + my $p; + # DECL can be a function if (ref($t->{DECL}) eq "CODE") { - return $t->{DECL}->($e); + $p = $t->{DECL}->($e); } else { - return $t->{DECL}; + $p = $t->{DECL}; } -} -# Return type without special stuff, as used in -# struct declarations -sub DeclShort($) -{ - my $e = shift; - - my $t = GetType($e); - return undef if not $t; + my $prefixes = ""; + my $suffixes = ""; + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "ARRAY" and not $l->{IS_FIXED}) { + $prefixes = "*$prefixes"; + } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}) { + $suffixes.="[$l->{SIZE_IS}]"; + } + } - return "$t $e->{NAME}"; + return "$p $prefixes$e->{NAME}$suffixes"; } +# Return type including special stuff (pointers, etc). sub DeclLong($) { my $e = shift; - my $t = GetType($e); + my $t = $known_types->{$e->{TYPE}}; + + if (not $t) { + warning($e, "Can't declare unknown type $e->{TYPE}"); + return undef; + } + + my $p; - return undef if not $t; + if (defined($t->{EXT_DECL})) { + $p = $t->{EXT_DECL} + } else { + $p = $t->{DECL}; + } - my $ptrs = ""; + if (ref($p) eq "CODE") { + $p = $p->($e); + } + + my $prefixes = ""; + my $suffixes = ""; foreach my $l (@{$e->{LEVELS}}) { - ($ptrs.="*") if ($l->{TYPE} eq "POINTER"); + if ($l->{TYPE} eq "ARRAY" and not $l->{IS_FIXED}) { + $prefixes = "*$prefixes"; + } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}) { + $suffixes.="[$l->{SIZE_IS}]"; + } elsif ($l->{TYPE} eq "POINTER") { + $prefixes = "*$prefixes"; + } } - return "$t $ptrs$e->{NAME}"; + return "$p $prefixes$e->{NAME}$suffixes"; } sub InitType($$$$) @@ -238,9 +295,12 @@ sub InitType($$$$) } } -sub DissectType($$$) +sub DissectType { - my ($e, $l, $varname) = @_; + my @args = @_; + my $e = shift @_; + my $l = shift @_; + my $varname = shift @_; my $t = $known_types->{$l->{DATA_TYPE}}; @@ -251,7 +311,7 @@ sub DissectType($$$) # DISSECT can be a function if (ref($t->{DISSECT}) eq "CODE") { - return $t->{DISSECT}->($e, $l, $varname); + return $t->{DISSECT}->(@args); } else { return $t->{DISSECT}; } @@ -264,17 +324,31 @@ sub LoadTypes($) next unless ($if->{TYPE} eq "INTERFACE"); foreach my $td (@{$if->{TYPEDEFS}}) { - AddType($td->{NAME}, { - DECL => uc("$if->{NAME}_$td->{NAME}"), - INIT => sub { + my $decl = uc("$if->{NAME}_$td->{NAME}"); + my $init = sub { my ($e,$l,$n,$v) = @_; return "$n = $v;"; - }, - DISSECT => sub { + }; + + my $dissect; + if ($td->{DATA}->{TYPE} eq "UNION") { + $dissect = sub { + my ($e,$l,$n,$s) = @_; + + return "$if->{NAME}_io_$td->{NAME}(\"$e->{NAME}\", &$n, $s, ps, depth)"; + }; + } else { + $dissect = sub { my ($e,$l,$n) = @_; return "$if->{NAME}_io_$td->{NAME}(\"$e->{NAME}\", &$n, ps, depth)"; - } + }; + } + + AddType($td->{NAME}, { + DECL => $decl, + INIT => $init, + DISSECT => $dissect }); } } -- cgit From d220237b19f361a2c3c09b292e11f54c8d522fdf Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 5 Oct 2005 00:29:47 +0000 Subject: r10721: Handle allocations and primitive / deferred data correctly. In theory, the generated output for DFS should work now (it compiles cleanly, but I haven't tested it yet). Not supported: - subcontexts() - relative pointers - unions of pointers - DATA_BLOB - several other things Also still need to do: - Remove some spurious spaces in the output - Do range() checking Example output is still available at http://samba.org/~jelmer/pidl_samba3/ (This used to be commit e2d7e382bb645f1bddd2047669bed10f121b59d2) --- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 1 + source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 286 +++++++++++++++++++++------ source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 69 ++++--- 3 files changed, 273 insertions(+), 83 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 21a56e4c2d..5b7fddc14f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -37,6 +37,7 @@ sub ParseElement($) } if ($l->{IS_VARYING}) { pidl "\tuint32 length_$e->{NAME};"; + pidl "\tuint32 offset_$e->{NAME};"; } } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index 166d98bfb1..702835c378 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -14,6 +14,9 @@ use Parse::Pidl::Samba3::Types qw(DeclShort DeclLong InitType DissectType); use vars qw($VERSION); $VERSION = '0.01'; +use constant PRIMITIVES => 1; +use constant DEFERRED => 2; + my $res = ""; my $tabs = ""; sub indent() { $tabs.="\t"; } @@ -22,17 +25,22 @@ sub pidl($) { $res .= $tabs.(shift)."\n"; } sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } #TODO: -# - Different scalars / buffers functions for arrays + unions -# - Memory allocation for arrays +# - Add some security checks (array sizes, memory alloc == NULL, etc) +# - Don't add seperate _p and _d functions if there is no deferred data -sub DeclareArrayVariables($) +sub DeclareArrayVariables { my $es = shift; + my $what = shift; my $output = 0; foreach my $e (@$es) { foreach my $l (@{$e->{LEVELS}}) { + if ($what) { + next if ($l->{IS_DEFERRED} and $what == PRIMITIVES); + next if (not $l->{IS_DEFERRED} and $what == DEFERRED); + } if ($l->{TYPE} eq "ARRAY") { pidl "uint32 i_$e->{NAME}_$l->{LEVEL_INDEX};"; $output = 1; @@ -42,11 +50,11 @@ sub DeclareArrayVariables($) pidl "" if $output; } -sub ParseElementLevelData($$$$$) +sub ParseElementLevelData($$$$$$) { - my ($e,$l,$nl,$env,$varname) = @_; + my ($e,$l,$nl,$env,$varname,$what) = @_; - my @args = ($e,$l,$varname); + my @args = ($e,$l,$varname,$what); # See if we need to add a level argument because we're parsing a union foreach (@{$e->{LEVELS}}) { @@ -54,64 +62,107 @@ sub ParseElementLevelData($$$$$) if ($_->{TYPE} eq "SWITCH"); } - pidl "if (!".DissectType(@args).")"; + my $c = DissectType(@args); + return if not $c; + + pidl "if (!$c)"; pidl "\treturn False;"; } -sub ParseElementLevelArray($$$$$) +sub ParseElementLevelArray($$$$$$) { - my ($e,$l,$nl,$env,$varname) = @_; + my ($e,$l,$nl,$env,$varname,$what) = @_; my $len = ParseExpr($l->{LENGTH_IS}, $env); + my $size = ParseExpr($l->{SIZE_IS}, $env); + + if ($what == PRIMITIVES) { + # Fetch headers + if ($l->{IS_CONFORMANT} and not $l->{IS_SURROUNDING}) { + pidl "if (!prs_uint32(\"size_$e->{NAME}\", ps, depth, &" . ParseExpr("size_$e->{NAME}", $env) . "))"; + pidl "\treturn False;"; + pidl ""; + } + + if ($l->{IS_VARYING}) { + pidl "if (!prs_uint32(\"offset_$e->{NAME}\", ps, depth, &" . ParseExpr("offset_$e->{NAME}", $env) . "))"; + pidl "\treturn False;"; + pidl ""; + + pidl "if (!prs_uint32(\"length_$e->{NAME}\", ps, depth, &" . ParseExpr("length_$e->{NAME}", $env) . "))"; + pidl "\treturn False;"; + pidl ""; + } + } + + # Everything but fixed arrays have to be allocated + if (!$l->{IS_FIXED} and $what == PRIMITIVES) { + pidl "if (UNMARSHALLING(ps)) {"; + indent; + pidl "$varname = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*$varname)*$size);"; + deindent; + pidl "}"; + } + + return if ($what == DEFERRED and not ContainsDeferred($e,$l)); my $i = "i_$e->{NAME}_$l->{LEVEL_INDEX}"; pidl "for ($i=0; $i<$len;$i++) {"; indent; - ParseElementLevel($e,$nl,$env,$varname."[$i]"); + ParseElementLevel($e,$nl,$env,$varname."[$i]",$what); deindent; pidl "}"; } -sub ParseElementLevelSwitch($$$$$) +sub ParseElementLevelSwitch($$$$$$) { - my ($e,$l,$nl,$env,$varname) = @_; + my ($e,$l,$nl,$env,$varname,$what) = @_; - pidl "if (!prs_uint32(\"level\", ps, depth, &" . ParseExpr("level_$e->{NAME}", $env) . "))"; - pidl "\treturn False;"; - pidl ""; + if ($what == PRIMITIVES) { + pidl "if (!prs_uint32(\"level\", ps, depth, &" . ParseExpr("level_$e->{NAME}", $env) . "))"; + pidl "\treturn False;"; + pidl ""; + } - ParseElementLevel($e,$nl,$env,$varname); + ParseElementLevel($e,$nl,$env,$varname,$what); } -sub ParseElementLevelPtr($$$$$) +sub ParseElementLevelPtr($$$$$$) { - my ($e,$l,$nl,$env,$varname) = @_; + my ($e,$l,$nl,$env,$varname,$what) = @_; + + if ($what == PRIMITIVES) { + pidl "if (!prs_uint32(\"ptr_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr_$e->{NAME}", $env) . "))"; + pidl "\treturn False;"; + pidl ""; + } if ($l->{POINTER_TYPE} eq "relative") { fatal($e, "relative pointers not supported for Samba 3"); + #FIXME } - - pidl "if (!prs_uint32(\"ptr_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr_$e->{NAME}", $env) . "))"; - pidl "\treturn False;"; - pidl ""; - pidl "if (" . ParseExpr("ptr_$e->{NAME}", $env) . ") {"; - indent; - ParseElementLevel($e,$nl,$env,$varname); - deindent; - pidl "}"; + if ($what == DEFERRED) { + pidl "if (" . ParseExpr("ptr_$e->{NAME}", $env) . ") {"; + indent; + ParseElementLevel($e,$nl,$env,$varname,PRIMITIVES); + ParseElementLevel($e,$nl,$env,$varname,DEFERRED); + deindent; + pidl "}"; + } } -sub ParseElementLevelSubcontext($$$$$) +sub ParseElementLevelSubcontext($$$$$$) { - my ($e,$l,$nl,$env,$varname) = @_; + my ($e,$l,$nl,$env,$varname,$what) = @_; fatal($e, "subcontext() not supported for Samba 3"); + #FIXME } -sub ParseElementLevel($$$$) +sub ParseElementLevel($$$$$) { - my ($e,$l,$env,$varname) = @_; + my ($e,$l,$env,$varname,$what) = @_; { DATA => \&ParseElementLevelData, @@ -119,14 +170,14 @@ sub ParseElementLevel($$$$) POINTER => \&ParseElementLevelPtr, SWITCH => \&ParseElementLevelSwitch, ARRAY => \&ParseElementLevelArray - }->{$l->{TYPE}}->($e,$l,GetNextLevel($e,$l),$env,$varname); + }->{$l->{TYPE}}->($e,$l,GetNextLevel($e,$l),$env,$varname,$what); } -sub ParseElement($$) +sub ParseElement($$$) { - my ($e,$env) = @_; + my ($e,$env,$what) = @_; - ParseElementLevel($e, $e->{LEVELS}[0], $env, ParseExpr($e->{NAME}, $env)); + ParseElementLevel($e, $e->{LEVELS}[0], $env, ParseExpr($e->{NAME}, $env), $what); } sub InitLevel($$$$) @@ -164,29 +215,35 @@ sub GenerateEnvElement($$) $env->{"level_$e->{NAME}"} = "v->level_$e->{NAME}"; } elsif ($l->{TYPE} eq "ARRAY") { $env->{"length_$e->{NAME}"} = "v->length_$e->{NAME}"; + $env->{"size_$e->{NAME}"} = "v->size_$e->{NAME}"; + $env->{"offset_$e->{NAME}"} = "v->offset_$e->{NAME}"; } } } -sub CreateStruct($$$$$) +sub ParseStruct($$$) { - my ($fn,$ifn, $s,$es,$a) = @_; + my ($if,$s,$n) = @_; + + my $fn = "$if->{NAME}_io_$n"; + my $sn = uc("$if->{NAME}_$n"); + my $ifn = "init_$if->{NAME}_$n"; my $args = ""; - foreach (@$es) { + foreach (@{$s->{ELEMENTS}}) { $args .= ", " . DeclLong($_); } my $env = { "this" => "v" }; - GenerateEnvElement($_, $env) foreach (@$es); + GenerateEnvElement($_, $env) foreach (@{$s->{ELEMENTS}}); - pidl "BOOL $ifn($s *v$args)"; + pidl "BOOL $ifn($sn *v$args)"; pidl "{"; indent; pidl "DEBUG(5,(\"$ifn\\n\"));"; pidl ""; # Call init for all arguments - foreach (@$es) { + foreach (@{$s->{ELEMENTS}}) { InitLevel($_, $_->{LEVELS}[0], $_->{NAME}, $env); pidl ""; } @@ -194,24 +251,31 @@ sub CreateStruct($$$$$) deindent; pidl "}"; pidl ""; + + my $pfn = "$fn\_p"; + my $dfn = "$fn\_d"; - pidl "BOOL $fn(const char *desc, $s *v, prs_struct *ps, int depth)"; + pidl "BOOL $pfn(const char *desc, $sn *v, prs_struct *ps, int depth)"; pidl "{"; indent; - DeclareArrayVariables($es); + DeclareArrayVariables($s->{ELEMENTS}, PRIMITIVES); pidl "if (v == NULL)"; pidl "\treturn False;"; pidl ""; - pidl "prs_debug(ps, depth, desc, \"$fn\");"; + pidl "prs_debug(ps, depth, desc, \"$pfn\");"; pidl "depth++;"; - if ($a > 0) { - pidl "if (!prs_align_custom(ps, $a))"; + pidl "if (!prs_align_custom(ps, $s->{ALIGN}))"; + pidl "\treturn False;"; + pidl ""; + + if ($s->{SURROUNDING_ELEMENT}) { + pidl "if (!prs_uint32(\"size_$s->{SURROUNDING_ELEMENT}->{NAME}\", ps, depth, &" . ParseExpr("size_$s->{SURROUNDING_ELEMENT}->{NAME}", $env) . "))"; pidl "\treturn False;"; pidl ""; } - foreach (@$es) { - ParseElement($_, $env); + foreach (@{$s->{ELEMENTS}}) { + ParseElement($_, $env, PRIMITIVES); pidl ""; } @@ -219,16 +283,29 @@ sub CreateStruct($$$$$) deindent; pidl "}"; pidl ""; -} -sub ParseStruct($$$) -{ - my ($if,$s,$n) = @_; + pidl "BOOL $dfn(const char *desc, $sn *v, prs_struct *ps, int depth)"; + pidl "{"; + indent; + DeclareArrayVariables($s->{ELEMENTS}, DEFERRED); + pidl "if (v == NULL)"; + pidl "\treturn False;"; + pidl ""; + pidl "prs_debug(ps, depth, desc, \"$dfn\");"; + pidl "depth++;"; + pidl "if (!prs_align_custom(ps, $s->{ALIGN}))"; + pidl "\treturn False;"; + pidl ""; - my $fn = "$if->{NAME}_io_$n"; - my $sn = uc("$if->{NAME}_$n"); + foreach (@{$s->{ELEMENTS}}) { + ParseElement($_, $env, DEFERRED); + pidl ""; + } - CreateStruct($fn, "init_$if->{NAME}_$n", $sn, $s->{ELEMENTS}, $s->{ALIGN}); + pidl "return True;"; + deindent; + pidl "}"; + pidl ""; } sub ParseUnion($$$) @@ -238,7 +315,44 @@ sub ParseUnion($$$) my $fn = "$if->{NAME}_io_$n"; my $sn = uc("$if->{NAME}_$n"); - pidl "BOOL $fn(const char *desc, $sn* v, uint32 level, prs_struct *ps, int depth)"; + my $pfn = "$fn\_p"; + my $dfn = "$fn\_d"; + + pidl "BOOL $pfn(const char *desc, $sn* v, uint32 level, prs_struct *ps, int depth)"; + pidl "{"; + indent; + DeclareArrayVariables($u->{ELEMENTS}); + pidl "if (!prs_align_custom(ps, $u->{ALIGN}))"; + pidl "\treturn False;"; + pidl ""; + + pidl "switch (level) {"; + indent; + + foreach (@{$u->{ELEMENTS}}) { + pidl "$_->{CASE}:"; + indent; + if ($_->{TYPE} ne "EMPTY") { + pidl "depth++;"; + my $env = {}; + GenerateEnvElement($_, $env); + ParseElement($_, $env, PRIMITIVES); + ParseElement($_, $env, DEFERRED); + pidl "depth--;"; + } + pidl "break;"; + deindent; + pidl ""; + } + + deindent; + pidl "}"; + pidl ""; + pidl "return True;"; + deindent; + pidl "}"; + + pidl "BOOL $dfn(const char *desc, $sn* v, uint32 level, prs_struct *ps, int depth)"; pidl "{"; indent; DeclareArrayVariables($u->{ELEMENTS}); @@ -256,7 +370,7 @@ sub ParseUnion($$$) pidl "depth++;"; my $env = {}; GenerateEnvElement($_, $env); - ParseElement($_, $env); + ParseElement($_, $env, DEFERRED); pidl "depth--;"; } pidl "break;"; @@ -270,6 +384,56 @@ sub ParseUnion($$$) pidl "return True;"; deindent; pidl "}"; + +} + +sub CreateFnDirection($$$$) +{ + my ($fn,$ifn, $s,$es) = @_; + + my $args = ""; + foreach (@$es) { + $args .= ", " . DeclLong($_); + } + + my $env = { "this" => "v" }; + GenerateEnvElement($_, $env) foreach (@$es); + + pidl "BOOL $ifn($s *v$args)"; + pidl "{"; + indent; + pidl "DEBUG(5,(\"$ifn\\n\"));"; + pidl ""; + # Call init for all arguments + foreach (@$es) { + InitLevel($_, $_->{LEVELS}[0], $_->{NAME}, $env); + pidl ""; + } + pidl "return True;"; + deindent; + pidl "}"; + pidl ""; + + pidl "BOOL $fn(const char *desc, $s *v, prs_struct *ps, int depth)"; + pidl "{"; + indent; + DeclareArrayVariables($es); + pidl "if (v == NULL)"; + pidl "\treturn False;"; + pidl ""; + pidl "prs_debug(ps, depth, desc, \"$fn\");"; + pidl "depth++;"; + + foreach (@$es) { + ParseElement($_, $env, PRIMITIVES); + ParseElement($_, $env, DEFERRED); + pidl ""; + } + + pidl "return True;"; + deindent; + pidl "}"; + pidl ""; } sub ParseFunction($$) @@ -297,14 +461,14 @@ sub ParseFunction($$) } ); } - CreateStruct("$if->{NAME}_io_q_$fn->{NAME}", + CreateFnDirection("$if->{NAME}_io_q_$fn->{NAME}", "init_$if->{NAME}_q_$fn->{NAME}", uc("$if->{NAME}_q_$fn->{NAME}"), - \@in, 0); - CreateStruct("$if->{NAME}_io_r_$fn->{NAME}", + \@in); + CreateFnDirection("$if->{NAME}_io_r_$fn->{NAME}", "init_$if->{NAME}_r_$fn->{NAME}", uc("$if->{NAME}_r_$fn->{NAME}"), - \@out, 0); + \@out); } sub ParseInterface($) diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index a3bf91d54f..9a7a31a6bb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -109,50 +109,50 @@ my $known_types = { DECL => "uint8", INIT => \&init_scalar, - DISSECT => \&dissect_scalar, + DISSECT_P => \&dissect_scalar, }, uint16 => { DECL => "uint16", INIT => \&init_scalar, - DISSECT => \&dissect_scalar, + DISSECT_P => \&dissect_scalar, }, uint32 => { DECL => "uint32", INIT => \&init_scalar, - DISSECT => \&dissect_scalar, + DISSECT_P => \&dissect_scalar, }, uint64 => { DECL => "uint64", INIT => \&init_scalar, - DISSECT => \&dissect_scalar, + DISSECT_P => \&dissect_scalar, }, string => { DECL => \&decl_string, EXT_DECL => \&ext_decl_string, INIT => \&init_string, - DISSECT => \&dissect_string, + DISSECT_P => \&dissect_string, }, NTSTATUS => { DECL => "NTSTATUS", INIT => \&init_scalar, - DISSECT => \&dissect_scalar, + DISSECT_P => \&dissect_scalar, }, WERROR => { DECL => "WERROR", INIT => \&init_scalar, - DISSECT => \&dissect_scalar, + DISSECT_P => \&dissect_scalar, }, GUID => { DECL => "struct uuid", INIT => "", - DISSECT => sub { + DISSECT_P => sub { my ($e,$l,$n) = @_; return "smb_io_uuid(\"$e->{NAME}\", &$n, ps, depth)"; } @@ -161,7 +161,7 @@ my $known_types = { DECL => "NTTIME", INIT => "", - DISSECT => sub { + DISSECT_P => sub { my ($e,$l,$n) = @_; return "smb_io_nttime(\"$e->{NAME}\", &n, ps, depth)"; } @@ -170,7 +170,7 @@ my $known_types = { DECL => "DOM_SID", INIT => "", - DISSECT => sub { + DISSECT_P => sub { my ($e,$l,$n) = @_; return "smb_io_dom_sid(\"$e->{NAME}\", &n, ps, depth)"; } @@ -179,7 +179,7 @@ my $known_types = { DECL => "POLICY_HND", INIT => "", - DISSECT => sub { + DISSECT_P => sub { my ($e,$l,$n) = @_; return "smb_io_pol_hnd(\"$e->{NAME}\", &n, ps, depth)"; } @@ -301,6 +301,7 @@ sub DissectType my $e = shift @_; my $l = shift @_; my $varname = shift @_; + my $what = shift @_; my $t = $known_types->{$l->{DATA_TYPE}}; @@ -309,11 +310,20 @@ sub DissectType return undef; } + my $dissect; + if ($what == 1) { #primitives + $dissect = $t->{DISSECT_P}; + } elsif ($what == 2) { + $dissect = $t->{DISSECT_D}; + } + + return "" if not defined($dissect); + # DISSECT can be a function - if (ref($t->{DISSECT}) eq "CODE") { - return $t->{DISSECT}->(@args); + if (ref($dissect) eq "CODE") { + return $dissect->(@args); } else { - return $t->{DISSECT}; + return $dissect; } } @@ -330,25 +340,40 @@ sub LoadTypes($) return "$n = $v;"; }; - my $dissect; + my $dissect_d; + my $dissect_p; if ($td->{DATA}->{TYPE} eq "UNION") { - $dissect = sub { - my ($e,$l,$n,$s) = @_; + $dissect_p = sub { + my ($e,$l,$n,$w,$s) = @_; + + return "$if->{NAME}_io_$td->{NAME}_p(\"$e->{NAME}\", &$n, $s, ps, depth)"; + }; - return "$if->{NAME}_io_$td->{NAME}(\"$e->{NAME}\", &$n, $s, ps, depth)"; + $dissect_d = sub { + my ($e,$l,$n,$w,$s) = @_; + + return "$if->{NAME}_io_$td->{NAME}_d(\"$e->{NAME}\", &$n, $s, ps, depth)"; }; + } else { - $dissect = sub { - my ($e,$l,$n) = @_; + $dissect_p = sub { + my ($e,$l,$n,$w) = @_; - return "$if->{NAME}_io_$td->{NAME}(\"$e->{NAME}\", &$n, ps, depth)"; + return "$if->{NAME}_io_$td->{NAME}_p(\"$e->{NAME}\", &$n, ps, depth)"; }; + $dissect_d = sub { + my ($e,$l,$n,$w) = @_; + + return "$if->{NAME}_io_$td->{NAME}_d(\"$e->{NAME}\", &$n, ps, depth)"; + }; + } AddType($td->{NAME}, { DECL => $decl, INIT => $init, - DISSECT => $dissect + DISSECT_D => $dissect_d, + DISSECT_P => $dissect_p }); } } -- cgit From 5df3b426ee691adaaaa65424aa2cee22dcc10607 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 5 Oct 2005 14:52:35 +0000 Subject: r10732: Generate _ctr structures for unions (This used to be commit bd8fcb05003ad75f521783ad9603c923eacafc1a) --- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 27 ++++++++++++++++++--- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 35 ++++++++++++++++++++++++---- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 11 +++++++++ 3 files changed, 65 insertions(+), 8 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 5b7fddc14f..6254abaa2d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -101,10 +101,31 @@ sub ParseUnion($$$) { my ($if,$u,$n) = @_; - pidl "typedef union $if->{NAME}_$n {"; - #FIXME: What about elements that require more then one variable? + my $extra = {"switch_value" => 1}; + + foreach my $e (@{$u->{ELEMENTS}}) { + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "ARRAY") { + if ($l->{IS_CONFORMANT}) { + $extra->{"size"} = 1; + } + if ($l->{IS_VARYING}) { + $extra->{"length"} = $extra->{"offset"} = 1; + } + } elsif ($l->{TYPE} eq "POINTER") { + $extra->{"ptr"} = 1; + } elsif ($l->{TYPE} eq "SWITCH") { + $extra->{"level"} = 1; + } + } + } + + pidl "typedef struct $if->{NAME}_$n\_ctr {"; + pidl "\tuint32 $_;" foreach (keys %$extra); + pidl "\tunion {"; ParseElement($_) foreach (@{$u->{ELEMENTS}}); - pidl "} ".uc($if->{NAME}."_".$n) .";"; + pidl "\t} u;"; + pidl "} ".uc("$if->{NAME}_$n\_ctr") .";"; pidl ""; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index 702835c378..49c7cf5e81 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -73,6 +73,11 @@ sub ParseElementLevelArray($$$$$$) { my ($e,$l,$nl,$env,$varname,$what) = @_; + if ($l->{IS_ZERO_TERMINATED}) { + fatal($e, "[string] attribute not supported for Samba3 yet"); + #FIXME + } + my $len = ParseExpr($l->{LENGTH_IS}, $env); my $size = ParseExpr($l->{SIZE_IS}, $env); @@ -308,12 +313,34 @@ sub ParseStruct($$$) pidl ""; } +sub UnionGenerateEnvElement($) +{ + my $e = shift; + my $env = {}; + + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "DATA") { + $env->{$e->{NAME}} = "v->u.$e->{NAME}"; + } elsif ($l->{TYPE} eq "POINTER") { + $env->{"ptr_$e->{NAME}"} = "v->ptr"; + } elsif ($l->{TYPE} eq "SWITCH") { + $env->{"level_$e->{NAME}"} = "v->level"; + } elsif ($l->{TYPE} eq "ARRAY") { + $env->{"length_$e->{NAME}"} = "v->length"; + $env->{"size_$e->{NAME}"} = "v->size"; + $env->{"offset_$e->{NAME}"} = "v->offset"; + } + } + + return $env; +} + sub ParseUnion($$$) { my ($if,$u,$n) = @_; my $fn = "$if->{NAME}_io_$n"; - my $sn = uc("$if->{NAME}_$n"); + my $sn = uc("$if->{NAME}_$n\_ctr"); my $pfn = "$fn\_p"; my $dfn = "$fn\_d"; @@ -334,8 +361,7 @@ sub ParseUnion($$$) indent; if ($_->{TYPE} ne "EMPTY") { pidl "depth++;"; - my $env = {}; - GenerateEnvElement($_, $env); + my $env = UnionGenerateEnvElement($_); ParseElement($_, $env, PRIMITIVES); ParseElement($_, $env, DEFERRED); pidl "depth--;"; @@ -368,8 +394,7 @@ sub ParseUnion($$$) indent; if ($_->{TYPE} ne "EMPTY") { pidl "depth++;"; - my $env = {}; - GenerateEnvElement($_, $env); + my $env = UnionGenerateEnvElement($_); ParseElement($_, $env, DEFERRED); pidl "depth--;"; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index 9a7a31a6bb..38e740189b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -184,6 +184,15 @@ my $known_types = return "smb_io_pol_hnd(\"$e->{NAME}\", &n, ps, depth)"; } }, + hyper => + { + DECL => "uint64", + INIT => "", + DISSECT_P => sub { + my ($e,$l,$n) = @_; + return "prs_uint64(\"$e->{NAME}\", ps, depth, &$n)"; + } + }, }; sub AddType($$) @@ -335,6 +344,7 @@ sub LoadTypes($) foreach my $td (@{$if->{TYPEDEFS}}) { my $decl = uc("$if->{NAME}_$td->{NAME}"); + my $init = sub { my ($e,$l,$n,$v) = @_; return "$n = $v;"; @@ -343,6 +353,7 @@ sub LoadTypes($) my $dissect_d; my $dissect_p; if ($td->{DATA}->{TYPE} eq "UNION") { + $decl.="_CTR"; $dissect_p = sub { my ($e,$l,$n,$w,$s) = @_; -- cgit From 4bbb584ff0dcc172bbaeeff9e8f6dff6d2b94e66 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 5 Oct 2005 17:13:29 +0000 Subject: r10734: Generate ptr, size, offset, and length elements in unions just once. (This used to be commit 12bfa5d01bcb4cb9dad5167e1a3721fd68f06275) --- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 27 +++++++++++++++++++++------ source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 15 +++++++++------ 2 files changed, 30 insertions(+), 12 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 6254abaa2d..4579ae2ec0 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -15,7 +15,10 @@ use vars qw($VERSION); $VERSION = '0.01'; my $res = ""; -sub pidl($) { my $x = shift; $res .= "$x\n"; } +my $tabs = ""; +sub indent() { $tabs.="\t"; } +sub deindent() { $tabs = substr($tabs, 1); } +sub pidl($) { $res .= $tabs.(shift)."\n"; } sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } sub warning($$) { my ($e,$s) = @_; warn("$e->{FILE}:$e->{LINE}: $s\n"); } @@ -101,7 +104,11 @@ sub ParseUnion($$$) { my ($if,$u,$n) = @_; - my $extra = {"switch_value" => 1}; + my $extra = {}; + + unless (has_property($u, "nodiscriminant")) { + $extra->{switch_value} = 1; + } foreach my $e (@{$u->{ELEMENTS}}) { foreach my $l (@{$e->{LEVELS}}) { @@ -121,10 +128,17 @@ sub ParseUnion($$$) } pidl "typedef struct $if->{NAME}_$n\_ctr {"; - pidl "\tuint32 $_;" foreach (keys %$extra); - pidl "\tunion {"; - ParseElement($_) foreach (@{$u->{ELEMENTS}}); - pidl "\t} u;"; + indent; + pidl "uint32 $_;" foreach (keys %$extra); + pidl "union {"; + indent; + foreach (@{$u->{ELEMENTS}}) { + next if ($_->{TYPE} eq "EMPTY"); + pidl "\t" . DeclShort($_) . ";"; + } + deindent; + pidl "} u;"; + deindent; pidl "} ".uc("$if->{NAME}_$n\_ctr") .";"; pidl ""; } @@ -185,6 +199,7 @@ sub Parse($$) my($ndr,$filename) = @_; $res = ""; + $tabs = ""; pidl "/*"; pidl " * Unix SMB/CIFS implementation."; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index 49c7cf5e81..d1188e7011 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -75,6 +75,7 @@ sub ParseElementLevelArray($$$$$$) if ($l->{IS_ZERO_TERMINATED}) { fatal($e, "[string] attribute not supported for Samba3 yet"); + #FIXME } @@ -123,12 +124,6 @@ sub ParseElementLevelSwitch($$$$$$) { my ($e,$l,$nl,$env,$varname,$what) = @_; - if ($what == PRIMITIVES) { - pidl "if (!prs_uint32(\"level\", ps, depth, &" . ParseExpr("level_$e->{NAME}", $env) . "))"; - pidl "\treturn False;"; - pidl ""; - } - ParseElementLevel($e,$nl,$env,$varname,$what); } @@ -353,6 +348,14 @@ sub ParseUnion($$$) pidl "\treturn False;"; pidl ""; + if (has_property($u, "nodiscriminant")) { + pidl "if (!prs_uint32(\"switch_value\", ps, depth, &v->switch_value))"; + pidl "\treturn False;"; + pidl ""; + } + + # Maybe check here that level and v->switch_value are equal? + pidl "switch (level) {"; indent; -- cgit From f72dee9e3908fb5c4ea3428e3cba703509a7e16f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 5 Oct 2005 19:41:53 +0000 Subject: r10737: Fix some alignment issues (This used to be commit 2b4270a2e965eb5c6fe0b25d22d2977e60bb7d43) --- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 111 +++++++++++++++++---------- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 2 +- 2 files changed, 70 insertions(+), 43 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index d1188e7011..b65ece5a12 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -27,6 +27,23 @@ sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } #TODO: # - Add some security checks (array sizes, memory alloc == NULL, etc) # - Don't add seperate _p and _d functions if there is no deferred data +# - [string] +# - subcontext() +# - DATA_BLOB + +sub Align($$) +{ + my ($a,$b) = @_; + + # Only align if previous element was smaller then current one + if ($$a < $b) { + pidl "if (!prs_align_custom(ps, $b))"; + pidl "\treturn False;"; + pidl ""; + } + + $$a = $b; +} sub DeclareArrayVariables { @@ -50,12 +67,19 @@ sub DeclareArrayVariables pidl "" if $output; } -sub ParseElementLevelData($$$$$$) +sub ParseElementLevelData($$$$$$$) { - my ($e,$l,$nl,$env,$varname,$what) = @_; + my ($e,$l,$nl,$env,$varname,$what,$align) = @_; my @args = ($e,$l,$varname,$what); + if (defined($e->{ALIGN})) { + Align($align, $e->{ALIGN}); + } else { + # Default to 4 + Align($align, 4); + } + # See if we need to add a level argument because we're parsing a union foreach (@{$e->{LEVELS}}) { push (@args, ParseExpr("level_$e->{NAME}", $env)) @@ -69,9 +93,9 @@ sub ParseElementLevelData($$$$$$) pidl "\treturn False;"; } -sub ParseElementLevelArray($$$$$$) +sub ParseElementLevelArray($$$$$$$) { - my ($e,$l,$nl,$env,$varname,$what) = @_; + my ($e,$l,$nl,$env,$varname,$what,$align) = @_; if ($l->{IS_ZERO_TERMINATED}) { fatal($e, "[string] attribute not supported for Samba3 yet"); @@ -85,12 +109,14 @@ sub ParseElementLevelArray($$$$$$) if ($what == PRIMITIVES) { # Fetch headers if ($l->{IS_CONFORMANT} and not $l->{IS_SURROUNDING}) { + Align($align, 4); pidl "if (!prs_uint32(\"size_$e->{NAME}\", ps, depth, &" . ParseExpr("size_$e->{NAME}", $env) . "))"; pidl "\treturn False;"; pidl ""; } if ($l->{IS_VARYING}) { + Align($align, 4); pidl "if (!prs_uint32(\"offset_$e->{NAME}\", ps, depth, &" . ParseExpr("offset_$e->{NAME}", $env) . "))"; pidl "\treturn False;"; pidl ""; @@ -115,26 +141,34 @@ sub ParseElementLevelArray($$$$$$) my $i = "i_$e->{NAME}_$l->{LEVEL_INDEX}"; pidl "for ($i=0; $i<$len;$i++) {"; indent; - ParseElementLevel($e,$nl,$env,$varname."[$i]",$what); + ParseElementLevel($e,$nl,$env,$varname."[$i]",$what,$align); deindent; pidl "}"; } -sub ParseElementLevelSwitch($$$$$$) +sub ParseElementLevelSwitch($$$$$$$) { - my ($e,$l,$nl,$env,$varname,$what) = @_; + my ($e,$l,$nl,$env,$varname,$what,$align) = @_; - ParseElementLevel($e,$nl,$env,$varname,$what); + ParseElementLevel($e,$nl,$env,$varname,$what,$align); } -sub ParseElementLevelPtr($$$$$$) +sub ParseElementLevelPtr($$$$$$$) { - my ($e,$l,$nl,$env,$varname,$what) = @_; + my ($e,$l,$nl,$env,$varname,$what,$align) = @_; if ($what == PRIMITIVES) { - pidl "if (!prs_uint32(\"ptr_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr_$e->{NAME}", $env) . "))"; - pidl "\treturn False;"; - pidl ""; + if ($l->{POINTER_TYPE} eq "ref" and + $l->{LEVEL} eq "TOP") { + pidl "if (!" . ParseExpr("ptr_$e->{NAME}", $env) . ")"; + pidl "\treturn False;"; + pidl ""; + } else { + Align($align, 4); + pidl "if (!prs_uint32(\"ptr_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr_$e->{NAME}", $env) . "))"; + pidl "\treturn False;"; + pidl ""; + } } if ($l->{POINTER_TYPE} eq "relative") { @@ -145,24 +179,25 @@ sub ParseElementLevelPtr($$$$$$) if ($what == DEFERRED) { pidl "if (" . ParseExpr("ptr_$e->{NAME}", $env) . ") {"; indent; - ParseElementLevel($e,$nl,$env,$varname,PRIMITIVES); - ParseElementLevel($e,$nl,$env,$varname,DEFERRED); + ParseElementLevel($e,$nl,$env,$varname,PRIMITIVES,$align); + ParseElementLevel($e,$nl,$env,$varname,DEFERRED,$align); deindent; pidl "}"; + $$align = 0; } } -sub ParseElementLevelSubcontext($$$$$$) +sub ParseElementLevelSubcontext($$$$$$$) { - my ($e,$l,$nl,$env,$varname,$what) = @_; + my ($e,$l,$nl,$env,$varname,$what,$align) = @_; fatal($e, "subcontext() not supported for Samba 3"); #FIXME } -sub ParseElementLevel($$$$$) +sub ParseElementLevel($$$$$$) { - my ($e,$l,$env,$varname,$what) = @_; + my ($e,$l,$env,$varname,$what,$align) = @_; { DATA => \&ParseElementLevelData, @@ -170,14 +205,14 @@ sub ParseElementLevel($$$$$) POINTER => \&ParseElementLevelPtr, SWITCH => \&ParseElementLevelSwitch, ARRAY => \&ParseElementLevelArray - }->{$l->{TYPE}}->($e,$l,GetNextLevel($e,$l),$env,$varname,$what); + }->{$l->{TYPE}}->($e,$l,GetNextLevel($e,$l),$env,$varname,$what,$align); } -sub ParseElement($$$) +sub ParseElement($$$$) { - my ($e,$env,$what) = @_; + my ($e,$env,$what,$align) = @_; - ParseElementLevel($e, $e->{LEVELS}[0], $env, ParseExpr($e->{NAME}, $env), $what); + ParseElementLevel($e, $e->{LEVELS}[0], $env, ParseExpr($e->{NAME}, $env), $what, $align); } sub InitLevel($$$$) @@ -264,9 +299,6 @@ sub ParseStruct($$$) pidl ""; pidl "prs_debug(ps, depth, desc, \"$pfn\");"; pidl "depth++;"; - pidl "if (!prs_align_custom(ps, $s->{ALIGN}))"; - pidl "\treturn False;"; - pidl ""; if ($s->{SURROUNDING_ELEMENT}) { pidl "if (!prs_uint32(\"size_$s->{SURROUNDING_ELEMENT}->{NAME}\", ps, depth, &" . ParseExpr("size_$s->{SURROUNDING_ELEMENT}->{NAME}", $env) . "))"; @@ -274,8 +306,9 @@ sub ParseStruct($$$) pidl ""; } + my $align = 0; foreach (@{$s->{ELEMENTS}}) { - ParseElement($_, $env, PRIMITIVES); + ParseElement($_, $env, PRIMITIVES, \$align); pidl ""; } @@ -293,12 +326,10 @@ sub ParseStruct($$$) pidl ""; pidl "prs_debug(ps, depth, desc, \"$dfn\");"; pidl "depth++;"; - pidl "if (!prs_align_custom(ps, $s->{ALIGN}))"; - pidl "\treturn False;"; - pidl ""; + $align = 0; foreach (@{$s->{ELEMENTS}}) { - ParseElement($_, $env, DEFERRED); + ParseElement($_, $env, DEFERRED, \$align); pidl ""; } @@ -344,9 +375,6 @@ sub ParseUnion($$$) pidl "{"; indent; DeclareArrayVariables($u->{ELEMENTS}); - pidl "if (!prs_align_custom(ps, $u->{ALIGN}))"; - pidl "\treturn False;"; - pidl ""; if (has_property($u, "nodiscriminant")) { pidl "if (!prs_uint32(\"switch_value\", ps, depth, &v->switch_value))"; @@ -365,8 +393,8 @@ sub ParseUnion($$$) if ($_->{TYPE} ne "EMPTY") { pidl "depth++;"; my $env = UnionGenerateEnvElement($_); - ParseElement($_, $env, PRIMITIVES); - ParseElement($_, $env, DEFERRED); + my $align = 0; + ParseElement($_, $env, PRIMITIVES, \$align); pidl "depth--;"; } pidl "break;"; @@ -385,9 +413,6 @@ sub ParseUnion($$$) pidl "{"; indent; DeclareArrayVariables($u->{ELEMENTS}); - pidl "if (!prs_align_custom(ps, $u->{ALIGN}))"; - pidl "\treturn False;"; - pidl ""; pidl "switch (level) {"; indent; @@ -398,7 +423,8 @@ sub ParseUnion($$$) if ($_->{TYPE} ne "EMPTY") { pidl "depth++;"; my $env = UnionGenerateEnvElement($_); - ParseElement($_, $env, DEFERRED); + my $align = 0; + ParseElement($_, $env, DEFERRED, \$align); pidl "depth--;"; } pidl "break;"; @@ -452,9 +478,10 @@ sub CreateFnDirection($$$$) pidl "prs_debug(ps, depth, desc, \"$fn\");"; pidl "depth++;"; + my $align = 0; foreach (@$es) { - ParseElement($_, $env, PRIMITIVES); - ParseElement($_, $env, DEFERRED); + ParseElement($_, $env, PRIMITIVES, \$align); + ParseElement($_, $env, DEFERRED, \$align); pidl ""; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index 38e740189b..0c66d2c6ad 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -100,7 +100,7 @@ sub dissect_string($$$) my $t = lc(decl_string($e)); - return "prs_$t(True, \"$e->{NAME}\", ps, depth, &$n)"; + return "smb_io_$t(\"$e->{NAME}\", &$n, 1, ps, depth)"; } my $known_types = -- cgit From 765f69ce42068cc2a41e010d08922a496da96054 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 5 Oct 2005 19:53:41 +0000 Subject: r10739: Reduce number of calls to prs_align_custom() (This used to be commit ebeeec5406308d493d45b1088963a87cdb953cac) --- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 22 ++++++++++++---------- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 26 ++++++++++++++------------ 2 files changed, 26 insertions(+), 22 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index b65ece5a12..ac7fde69a6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -71,14 +71,7 @@ sub ParseElementLevelData($$$$$$$) { my ($e,$l,$nl,$env,$varname,$what,$align) = @_; - my @args = ($e,$l,$varname,$what); - - if (defined($e->{ALIGN})) { - Align($align, $e->{ALIGN}); - } else { - # Default to 4 - Align($align, 4); - } + my @args = ($e,$l,$varname,$what,$align); # See if we need to add a level argument because we're parsing a union foreach (@{$e->{LEVELS}}) { @@ -89,6 +82,13 @@ sub ParseElementLevelData($$$$$$$) my $c = DissectType(@args); return if not $c; + if (defined($e->{ALIGN})) { + Align($align, $e->{ALIGN}); + } else { + # Default to 4 + Align($align, 4); + } + pidl "if (!$c)"; pidl "\treturn False;"; } @@ -300,13 +300,15 @@ sub ParseStruct($$$) pidl "prs_debug(ps, depth, desc, \"$pfn\");"; pidl "depth++;"; + my $align = 8; if ($s->{SURROUNDING_ELEMENT}) { pidl "if (!prs_uint32(\"size_$s->{SURROUNDING_ELEMENT}->{NAME}\", ps, depth, &" . ParseExpr("size_$s->{SURROUNDING_ELEMENT}->{NAME}", $env) . "))"; pidl "\treturn False;"; pidl ""; + $align = 4; + } - my $align = 0; foreach (@{$s->{ELEMENTS}}) { ParseElement($_, $env, PRIMITIVES, \$align); pidl ""; @@ -393,7 +395,7 @@ sub ParseUnion($$$) if ($_->{TYPE} ne "EMPTY") { pidl "depth++;"; my $env = UnionGenerateEnvElement($_); - my $align = 0; + my $align = 8; ParseElement($_, $env, PRIMITIVES, \$align); pidl "depth--;"; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index 0c66d2c6ad..8cb09343ac 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -27,9 +27,9 @@ sub init_scalar($$$$) return "$n = $v;"; } -sub dissect_scalar($$$) +sub dissect_scalar($$$$$) { - my ($e,$l,$n) = @_; + my ($e,$l,$n,$w,$a) = @_; my $t = lc($e->{TYPE}); @@ -94,12 +94,13 @@ sub init_string($$$$) return "init_$t(&$n, $v, $flags);"; } -sub dissect_string($$$) +sub dissect_string($$$$$) { - my ($e,$l,$n) = @_; + my ($e,$l,$n,$w,$a) = @_; my $t = lc(decl_string($e)); + $$a = 1; return "smb_io_$t(\"$e->{NAME}\", &$n, 1, ps, depth)"; } @@ -162,7 +163,7 @@ my $known_types = DECL => "NTTIME", INIT => "", DISSECT_P => sub { - my ($e,$l,$n) = @_; + my ($e,$l,$n,$w,$a) = @_; return "smb_io_nttime(\"$e->{NAME}\", &n, ps, depth)"; } }, @@ -171,7 +172,7 @@ my $known_types = DECL => "DOM_SID", INIT => "", DISSECT_P => sub { - my ($e,$l,$n) = @_; + my ($e,$l,$n,$w,$a) = @_; return "smb_io_dom_sid(\"$e->{NAME}\", &n, ps, depth)"; } }, @@ -180,7 +181,7 @@ my $known_types = DECL => "POLICY_HND", INIT => "", DISSECT_P => sub { - my ($e,$l,$n) = @_; + my ($e,$l,$n,$w,$a) = @_; return "smb_io_pol_hnd(\"$e->{NAME}\", &n, ps, depth)"; } }, @@ -189,7 +190,7 @@ my $known_types = DECL => "uint64", INIT => "", DISSECT_P => sub { - my ($e,$l,$n) = @_; + my ($e,$l,$n,$w,$a) = @_; return "prs_uint64(\"$e->{NAME}\", ps, depth, &$n)"; } }, @@ -311,6 +312,7 @@ sub DissectType my $l = shift @_; my $varname = shift @_; my $what = shift @_; + my $align = shift @_; my $t = $known_types->{$l->{DATA_TYPE}}; @@ -355,25 +357,25 @@ sub LoadTypes($) if ($td->{DATA}->{TYPE} eq "UNION") { $decl.="_CTR"; $dissect_p = sub { - my ($e,$l,$n,$w,$s) = @_; + my ($e,$l,$n,$w,$a,$s) = @_; return "$if->{NAME}_io_$td->{NAME}_p(\"$e->{NAME}\", &$n, $s, ps, depth)"; }; $dissect_d = sub { - my ($e,$l,$n,$w,$s) = @_; + my ($e,$l,$n,$w,$a,$s) = @_; return "$if->{NAME}_io_$td->{NAME}_d(\"$e->{NAME}\", &$n, $s, ps, depth)"; }; } else { $dissect_p = sub { - my ($e,$l,$n,$w) = @_; + my ($e,$l,$n,$w,$a) = @_; return "$if->{NAME}_io_$td->{NAME}_p(\"$e->{NAME}\", &$n, ps, depth)"; }; $dissect_d = sub { - my ($e,$l,$n,$w) = @_; + my ($e,$l,$n,$w,$a) = @_; return "$if->{NAME}_io_$td->{NAME}_d(\"$e->{NAME}\", &$n, ps, depth)"; }; -- cgit From be9af1a4e8d474a544840f657b1be0c302986417 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 5 Oct 2005 22:18:59 +0000 Subject: r10742: Support multi-level pointers + ref pointer fixes (This used to be commit 258b762dc62b257f99d1d859c5a3d850aba3e9fa) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 4 +++ source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 34 +++++++++++++++--- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 4 +-- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 54 ++++++++++++++++++---------- 4 files changed, 71 insertions(+), 25 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 6bb92a3b50..64190e87b8 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -80,6 +80,7 @@ sub GetElementLevelTable($) my @bracket_array = (); my @length_is = (); my @size_is = (); + my $pointer_idx = 0; if (has_property($e, "size_is")) { @size_is = split /,/, has_property($e, "size_is"); @@ -153,9 +154,12 @@ sub GetElementLevelTable($) TYPE => "POINTER", # for now, there can only be one pointer type per element POINTER_TYPE => pointer_type($e), + POINTER_INDEX => $pointer_idx, IS_DEFERRED => "$is_deferred", LEVEL => $level }); + + $pointer_idx++; # everything that follows will be deferred $is_deferred = 1 if ($e->{PARENT}->{TYPE} ne "FUNCTION"); diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm index b48a1b519f..164f53d06b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm @@ -20,6 +20,28 @@ sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $res .= $tabs.(shift)."\n"; } sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } +sub warning($$) { my ($e,$s) = @_; warn("$e->{FILE}:$e->{LINE}: $s\n"); } + +sub CopyLevel($$$$) +{ + sub CopyLevel($$$$); + my ($e,$l,$argument,$member) = @_; + + if ($l->{TYPE} eq "DATA") { + pidl "*$argument = $member;"; + } elsif ($l->{TYPE} eq "POINTER") { + pidl "if (r.ptr$l->{POINTER_INDEX}_$e->{NAME}) {"; + indent; + pidl "*$argument = talloc_size(mem_ctx, sizeof(void *));"; + CopyLevel($e,GetNextLevel($e,$l),"*$argument", $member); + deindent; + pidl "}"; + } elsif ($l->{TYPE} eq "SWITCH") { + CopyLevel($e,GetNextLevel($e,$l),$argument,$member); + } elsif ($l->{TYPE} eq "ARRAY") { + pidl "*$argument = $member;"; + } +} sub ParseFunction($$) { @@ -59,10 +81,14 @@ sub ParseFunction($$) pidl "\tNT_STATUS_UNSUCCESSFUL);"; pidl ""; pidl "/* Return variables */"; - foreach (@{$fn->{ELEMENTS}}) { - next unless (grep(/out/, @{$_->{DIRECTION}})); - - pidl "*$_->{NAME} = r.$_->{NAME};"; + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/out/, @{$e->{DIRECTION}})); + + if ($e->{LEVELS}[0]->{TYPE} ne "POINTER") { + warning($e->{ORIGINAL}, "First element not a pointer for [out] argument"); + next; + } + CopyLevel($e, $e->{LEVELS}[1], $e->{NAME}, "r.$e->{NAME}"); } pidl""; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 4579ae2ec0..1bcaa5c672 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -29,7 +29,7 @@ sub ParseElement($) foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { return if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "top"); - pidl "\tuint32 ptr_$e->{NAME};"; + pidl "\tuint32 ptr$l->{POINTER_INDEX}_$e->{NAME};"; } elsif ($l->{TYPE} eq "SWITCH") { pidl "\tuint32 level_$e->{NAME};"; } elsif ($l->{TYPE} eq "DATA") { @@ -120,7 +120,7 @@ sub ParseUnion($$$) $extra->{"length"} = $extra->{"offset"} = 1; } } elsif ($l->{TYPE} eq "POINTER") { - $extra->{"ptr"} = 1; + $extra->{"ptr$l->{POINTER_INDEX}"} = 1; } elsif ($l->{TYPE} eq "SWITCH") { $extra->{"level"} = 1; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index ac7fde69a6..7cd1255a40 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -158,14 +158,16 @@ sub ParseElementLevelPtr($$$$$$$) my ($e,$l,$nl,$env,$varname,$what,$align) = @_; if ($what == PRIMITIVES) { - if ($l->{POINTER_TYPE} eq "ref" and - $l->{LEVEL} eq "TOP") { - pidl "if (!" . ParseExpr("ptr_$e->{NAME}", $env) . ")"; + if (($l->{POINTER_TYPE} eq "ref") and ($l->{LEVEL} eq "EMBEDDED")) { + # Ref pointers always have to be non-NULL + pidl "if (MARSHALLING(ps) && !" . ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . ")"; pidl "\treturn False;"; pidl ""; - } else { + } + + unless ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP") { Align($align, 4); - pidl "if (!prs_uint32(\"ptr_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr_$e->{NAME}", $env) . "))"; + pidl "if (!prs_uint32(\"ptr$l->{POINTER_INDEX}_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . "))"; pidl "\treturn False;"; pidl ""; } @@ -177,12 +179,16 @@ sub ParseElementLevelPtr($$$$$$$) } if ($what == DEFERRED) { - pidl "if (" . ParseExpr("ptr_$e->{NAME}", $env) . ") {"; - indent; + if ($l->{POINTER_TYPE} ne "ref") { + pidl "if (" . ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . ") {"; + indent; + } ParseElementLevel($e,$nl,$env,$varname,PRIMITIVES,$align); ParseElementLevel($e,$nl,$env,$varname,DEFERRED,$align); - deindent; - pidl "}"; + if ($l->{POINTER_TYPE} ne "ref") { + deindent; + pidl "}"; + } $$align = 0; } } @@ -221,14 +227,24 @@ sub InitLevel($$$$) my ($e,$l,$varname,$env) = @_; if ($l->{TYPE} eq "POINTER") { - pidl "if ($varname) {"; - indent; - pidl ParseExpr("ptr_$e->{NAME}", $env) . " = 1;"; + if ($l->{POINTER_TYPE} eq "ref") { + pidl "if (!$varname)"; + pidl "\treturn False;"; + pidl ""; + } else { + pidl "if ($varname) {"; + indent; + } + + pidl ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . " = 1;"; InitLevel($e, GetNextLevel($e,$l), "*$varname", $env); - deindent; - pidl "} else {"; - pidl "\t" . ParseExpr("ptr_$e->{NAME}", $env) . " = 0;"; - pidl "}"; + + if ($l->{POINTER_TYPE} ne "ref") { + deindent; + pidl "} else {"; + pidl "\t" . ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . " = 0;"; + pidl "}"; + } } elsif ($l->{TYPE} eq "ARRAY") { pidl ParseExpr($e->{NAME}, $env) . " = $varname;"; } elsif ($l->{TYPE} eq "DATA") { @@ -245,7 +261,7 @@ sub GenerateEnvElement($$) if ($l->{TYPE} eq "DATA") { $env->{$e->{NAME}} = "v->$e->{NAME}"; } elsif ($l->{TYPE} eq "POINTER") { - $env->{"ptr_$e->{NAME}"} = "v->ptr_$e->{NAME}"; + $env->{"ptr$l->{POINTER_INDEX}_$e->{NAME}"} = "v->ptr$l->{POINTER_INDEX}_$e->{NAME}"; } elsif ($l->{TYPE} eq "SWITCH") { $env->{"level_$e->{NAME}"} = "v->level_$e->{NAME}"; } elsif ($l->{TYPE} eq "ARRAY") { @@ -350,7 +366,7 @@ sub UnionGenerateEnvElement($) if ($l->{TYPE} eq "DATA") { $env->{$e->{NAME}} = "v->u.$e->{NAME}"; } elsif ($l->{TYPE} eq "POINTER") { - $env->{"ptr_$e->{NAME}"} = "v->ptr"; + $env->{"ptr$l->{POINTER_INDEX}_$e->{NAME}"} = "v->ptr$l->{POINTER_INDEX}"; } elsif ($l->{TYPE} eq "SWITCH") { $env->{"level_$e->{NAME}"} = "v->level"; } elsif ($l->{TYPE} eq "ARRAY") { @@ -480,7 +496,7 @@ sub CreateFnDirection($$$$) pidl "prs_debug(ps, depth, desc, \"$fn\");"; pidl "depth++;"; - my $align = 0; + my $align = 8; foreach (@$es) { ParseElement($_, $env, PRIMITIVES, \$align); ParseElement($_, $env, DEFERRED, \$align); -- cgit From 4812a5d3fd394cf1fdbba1eb01bb0d0b3b171628 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 6 Oct 2005 07:04:36 +0000 Subject: r10760: remove only one star from the pointers, and not from the stars that come from the array nesting this fixes a compiler warning and but in the eventlog.h, where the idl uses nstring strings[num_strings] metze (This used to be commit c4a252bd4678ef991705aaaf91c03c697f2f568e) --- source4/pidl/lib/Parse/Pidl/Samba/Header.pm | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/Header.pm index ed8952e746..f235a96cb8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/Header.pm @@ -60,13 +60,15 @@ sub HeaderElement($) HeaderType($element, $element->{TYPE}, ""); pidl " "; my $numstar = $element->{POINTERS}; + if ($numstar >= 1) { + $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); + } foreach (@{$element->{ARRAY_LEN}}) { next if is_constant($_) and not has_property($element, "charset"); $numstar++; } - $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); pidl "*" foreach (1..$numstar); pidl $element->{NAME}; foreach (@{$element->{ARRAY_LEN}}) { -- cgit From 03b634042f937a6085a6cb96a1eb1e302e27c991 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 6 Oct 2005 07:26:05 +0000 Subject: r10761: we need to use a pointer to a nbt_name to fix compiler warnings, because we can only use a pointers to unknown types in proto.h metze (This used to be commit 2f46e54e1bcf43f1bee062ff9a21e646cc3676e9) --- source4/pidl/lib/Parse/Pidl/Typelist.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 111ce9ba11..67e348c5fe 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -129,8 +129,8 @@ my $scalars = { IS_REFERENCE => 1, }, "wrepl_nbt_name"=> { - C_TYPE => "struct nbt_name", - IS_REFERENCE => 0, + C_TYPE => "struct nbt_name *", + IS_REFERENCE => 1, }, "ipv4address" => { C_TYPE => "const char *", -- cgit From 093a30d7ed86e0772d1f590b25b74969b5c0b0ff Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 6 Oct 2005 11:57:25 +0000 Subject: r10765: Actually use VALS() setting for enums (This used to be commit 6b33e3eedd13ade5c7c9f4b5062e8b8f919fe39c) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 42 ++++++++++++++--------------- 1 file changed, 21 insertions(+), 21 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index e7a6b80b7b..be542638ef 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -31,24 +31,6 @@ my %ptrtype_mappings = ( "ptr" => "NDR_POINTER_PTR" ); -sub type2ft($) -{ - my($t) = shift; - - return "FT_UINT$1" if $t =~ /uint(8|16|32|64)/; - return "FT_INT$1" if $t =~ /int(8|16|32|64)/; - return "FT_UINT64", if $t eq "HYPER_T" or $t eq "NTTIME_hyper" - or $t eq "hyper"; - - # TODO: should NTTIME_hyper be a FT_ABSOLUTE_TIME as well? - - return "FT_ABSOLUTE_TIME" if $t eq "NTTIME" or $t eq "NTTIME_1sec"; - - return "FT_STRING" if ($t eq "string"); - - return "FT_NONE"; -} - sub StripPrefixes($) { my ($s) = @_; @@ -156,7 +138,7 @@ sub Enum($$$) my $enum_size = $e->{BASE_TYPE}; $enum_size =~ s/uint//g; - register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8); + register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$enum_size", "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8); } sub Bitmap($$$) @@ -230,7 +212,7 @@ sub Bitmap($$$) my $size = $e->{BASE_TYPE}; $size =~ s/uint//g; - register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "NULL", $size/8); + register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$size", "BASE_DEC", "0", "NULL", $size/8); } sub ElementLevel($$$$$) @@ -330,7 +312,19 @@ sub Element($$$) my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; - my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", type2ft($e->{TYPE}), "BASE_HEX", "NULL", 0, ""); + my $type = find_type($e->{TYPE}); + + if (not defined($type)) { + # default settings + $type = { + MASK => 0, + VALSSTRING => "NULL", + FT_TYPE => "FT_NONE", + BASE_TYPE => "BASE_HEX" + }; + } + + my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", $type->{FT_TYPE}, $type->{BASE_TYPE}, $type->{VALSSTRING}, $type->{MASK}, ""); $hf_used{$hf} = 1; my $eltname = StripPrefixes($pn) . ".$e->{NAME}"; @@ -685,6 +679,12 @@ sub ProcessInterface($) pidl_hdr "#endif /* $define */"; } +sub find_type($) +{ + my $n = shift; + + return $conformance->{types}->{$n}; +} sub register_type($$$$$$$) { -- cgit From 0ef04670398f27d36bf9dabf39a925a2ba2b29d0 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 6 Oct 2005 20:07:53 +0000 Subject: r10787: Fix silly nodiscriminant-issue (This used to be commit 43a5c863bf81af9b8415b6ccf8a386c36d4fa7f9) --- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index 7cd1255a40..eaab50b553 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -394,7 +394,7 @@ sub ParseUnion($$$) indent; DeclareArrayVariables($u->{ELEMENTS}); - if (has_property($u, "nodiscriminant")) { + unless (has_property($u, "nodiscriminant")) { pidl "if (!prs_uint32(\"switch_value\", ps, depth, &v->switch_value))"; pidl "\treturn False;"; pidl ""; -- cgit From c5069ba7e3dbabd586a3a313d6c2d287b0a46e2f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 6 Oct 2005 20:53:55 +0000 Subject: r10788: - Give unions a name - Check initialisation function return value (This used to be commit ebb8e75ebd572d62bdb3615d41c210bcc918fa41) --- source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 3 ++- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm index 164f53d06b..ee1ab09324 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm @@ -71,7 +71,8 @@ sub ParseFunction($$) pidl ""; pidl "/* Marshall data and send request */"; pidl ""; - pidl "init_$if->{NAME}_q_$fn->{NAME}(&q$inargs);"; + pidl "if (!init_$if->{NAME}_q_$fn->{NAME}(&q$inargs))"; + pidl "\treturn NT_STATUS_INVALID_PARAMETER;"; pidl ""; pidl "CLI_DO_RPC(cli, mem_ctx, PI_$uif, $ufn,"; pidl "\tq, r,"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 1bcaa5c672..78bd8fe339 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -130,7 +130,7 @@ sub ParseUnion($$$) pidl "typedef struct $if->{NAME}_$n\_ctr {"; indent; pidl "uint32 $_;" foreach (keys %$extra); - pidl "union {"; + pidl "union $if->{NAME}_$n {"; indent; foreach (@{$u->{ELEMENTS}}) { next if ($_->{TYPE} eq "EMPTY"); -- cgit From 848dff8f0d9242c0c7a417a1482c14ac289deb6f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 8 Oct 2005 00:33:19 +0000 Subject: r10829: Documentation updates Update TODO Some small fixes to the modules (This used to be commit 0c53e7c3cf7fd91fd34c48a5e68c1bcf70569854) --- source4/pidl/lib/Parse/Pidl/Dump.pm | 14 ++++ .../pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 75 ++++++++++++++++++++++ source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 8 +++ source4/pidl/lib/Parse/Pidl/NDR.pm | 32 ++++++--- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 15 ++--- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 40 +++++++++--- 6 files changed, 158 insertions(+), 26 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Dump.pm b/source4/pidl/lib/Parse/Pidl/Dump.pm index 80219a8f1a..3a1cec1b59 100644 --- a/source4/pidl/lib/Parse/Pidl/Dump.pm +++ b/source4/pidl/lib/Parse/Pidl/Dump.pm @@ -1,8 +1,22 @@ ################################################### # dump function for IDL structures # Copyright tridge@samba.org 2000 +# Copyright jelmer@samba.org 2005 # released under the GNU GPL +=pod + +=head1 NAME + +Parse::Pidl::Dump - Dump support + +=head1 DESCRIPTION + +This module provides functions that can generate IDL code from +internal pidl data structures. + +=cut + package Parse::Pidl::Dump; use Exporter; diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index 706a259306..1b550ae1e7 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -3,6 +3,81 @@ # Copyright jelmer@samba.org 2005 # released under the GNU GPL +=pod + +=head1 NAME + +Parse::Pidl::Ethereal::Conformance - Conformance file parser for Ethereal + +=head1 DESCRIPTION + +This module supports parsing Ethereal conformance files (*.cnf). + +=head1 FILE FORMAT + +Pidl needs additional data for ethereal output. This data is read from +so-called conformance files. This section describes the format of these +files. + +Conformance files are simple text files with a single command on each line. +Empty lines and lines starting with a '#' character are ignored. +Arguments to commands are seperated by spaces. + +The following commands are currently supported: + +=over 4 + +=item I name dissector ft_type base_type mask valsstring alignment + +Register new data type with specified name, what dissector function to call +and what properties to give header fields for elements of this type. + +=item I type + +Suppress emitting a dissect_type function for the specified type + +=item I type param + +Set parameter to specify to dissector function for given type. + +=item I hf title filter ft_type base_type valsstring mask description + +Generate a custom header field with specified properties. + +=item I old_hf_name new_hf_name + +Force the use of new_hf_name when the parser generator was going to +use old_hf_name. + +This can be used in conjunction with HF_FIELD in order to make more then +one element use the same filter name. + +=item I prefix + +Remove the specified prefix from all function names (if present). + +=item I longname shortname filtername + +Change the short-, long- and filter-name for the current interface in +Ethereal. + +=item I field desc + +Change description for the specified header field. `field' is the hf name of the field. + +=item I dissector code... + +Code to insert when generating the specified dissector. @HF@ and +@PARAM@ will be substituted. + +=back + +=head1 EXAMPLE + + INFO_KEY OpenKey.Ke + +=cut + package Parse::Pidl::Ethereal::Conformance; require Exporter; diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index be542638ef..8a4c0ed60c 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -6,6 +6,14 @@ # Portions based on idl2eth.c by Ronnie Sahlberg # released under the GNU GPL +=pod + +=head1 NAME + +Parse::Pidl::Ethereal::NDR - Parser generator for Ethereal + +=cut + package Parse::Pidl::Ethereal::NDR; use strict; diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 64190e87b8..f975e07b15 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -5,6 +5,26 @@ # Copyright jelmer@samba.org 2004-2005 # released under the GNU GPL +=pod + +=head1 NAME + +Parse::Pidl::NDR - NDR parsing information generator + +=head1 DESCRIPTION + +##################################################################### +# return a table describing the order in which the parts of an element +# should be parsed +# Possible level types: +# - POINTER +# - ARRAY +# - SUBCONTEXT +# - SWITCH +# - DATA + +=cut + package Parse::Pidl::NDR; require Exporter; @@ -62,15 +82,6 @@ sub fatal($$) die("$pos->{FILE}:$pos->{LINE}:$s\n"); } -##################################################################### -# return a table describing the order in which the parts of an element -# should be parsed -# Possible level types: -# - POINTER -# - ARRAY -# - SUBCONTEXT -# - SWITCH -# - DATA sub GetElementLevelTable($) { my $e = shift; @@ -394,6 +405,7 @@ sub ParseUnion($) if (has_property($e, "nodiscriminant")) { $switch_type = undef; } + my $hasdefault = 0; foreach my $x (@{$e->{ELEMENTS}}) { my $t; @@ -404,6 +416,7 @@ sub ParseUnion($) } if (has_property($x, "default")) { $t->{CASE} = "default"; + $hasdefault = 1; } elsif (defined($x->{PROPERTIES}->{case})) { $t->{CASE} = "case $x->{PROPERTIES}->{case}"; } else { @@ -417,6 +430,7 @@ sub ParseUnion($) SWITCH_TYPE => $switch_type, ELEMENTS => \@elements, PROPERTIES => $e->{PROPERTIES}, + HAS_DEFAULT => $hasdefault, ORIGINAL => $e }; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 78bd8fe339..25102e511a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -31,7 +31,6 @@ sub ParseElement($) return if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "top"); pidl "\tuint32 ptr$l->{POINTER_INDEX}_$e->{NAME};"; } elsif ($l->{TYPE} eq "SWITCH") { - pidl "\tuint32 level_$e->{NAME};"; } elsif ($l->{TYPE} eq "DATA") { pidl "\t" . DeclShort($e) . ";"; } elsif ($l->{TYPE} eq "ARRAY") { @@ -106,30 +105,28 @@ sub ParseUnion($$$) my $extra = {}; - unless (has_property($u, "nodiscriminant")) { - $extra->{switch_value} = 1; - } + $extra->{switch_value} = $u->{SWITCH_TYPE}; foreach my $e (@{$u->{ELEMENTS}}) { foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "ARRAY") { if ($l->{IS_CONFORMANT}) { - $extra->{"size"} = 1; + $extra->{"size"} = "uint32"; } if ($l->{IS_VARYING}) { - $extra->{"length"} = $extra->{"offset"} = 1; + $extra->{"length"} = $extra->{"offset"} = "uint32"; } } elsif ($l->{TYPE} eq "POINTER") { - $extra->{"ptr$l->{POINTER_INDEX}"} = 1; + $extra->{"ptr$l->{POINTER_INDEX}"} = "uint32"; } elsif ($l->{TYPE} eq "SWITCH") { - $extra->{"level"} = 1; + $extra->{"level"} = "uint32"; } } } pidl "typedef struct $if->{NAME}_$n\_ctr {"; indent; - pidl "uint32 $_;" foreach (keys %$extra); + pidl "$extra->{$_} $_;" foreach (keys %$extra); pidl "union $if->{NAME}_$n {"; indent; foreach (@{$u->{ELEMENTS}}) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index eaab50b553..c6cc188391 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -75,8 +75,18 @@ sub ParseElementLevelData($$$$$$$) # See if we need to add a level argument because we're parsing a union foreach (@{$e->{LEVELS}}) { - push (@args, ParseExpr("level_$e->{NAME}", $env)) - if ($_->{TYPE} eq "SWITCH"); + next unless ($_->{TYPE} eq "SWITCH"); + my $t = getType($l->{DATA_TYPE}); + + # Set 0 here because one of the variables referenced in SWITCH_IS + # might be an in variable while this one is [out] + if (grep(/in/, @{$e->{DIRECTION}}) or + not defined($t) or + has_property($t->{DATA}, "nodiscriminant")) { + push (@args, ParseExpr($_->{SWITCH_IS}, $env)); + } else { + push (@args, -1); + } } my $c = DissectType(@args); @@ -263,7 +273,6 @@ sub GenerateEnvElement($$) } elsif ($l->{TYPE} eq "POINTER") { $env->{"ptr$l->{POINTER_INDEX}_$e->{NAME}"} = "v->ptr$l->{POINTER_INDEX}_$e->{NAME}"; } elsif ($l->{TYPE} eq "SWITCH") { - $env->{"level_$e->{NAME}"} = "v->level_$e->{NAME}"; } elsif ($l->{TYPE} eq "ARRAY") { $env->{"length_$e->{NAME}"} = "v->length_$e->{NAME}"; $env->{"size_$e->{NAME}"} = "v->size_$e->{NAME}"; @@ -368,7 +377,6 @@ sub UnionGenerateEnvElement($) } elsif ($l->{TYPE} eq "POINTER") { $env->{"ptr$l->{POINTER_INDEX}_$e->{NAME}"} = "v->ptr$l->{POINTER_INDEX}"; } elsif ($l->{TYPE} eq "SWITCH") { - $env->{"level_$e->{NAME}"} = "v->level"; } elsif ($l->{TYPE} eq "ARRAY") { $env->{"length_$e->{NAME}"} = "v->length"; $env->{"size_$e->{NAME}"} = "v->size"; @@ -394,15 +402,20 @@ sub ParseUnion($$$) indent; DeclareArrayVariables($u->{ELEMENTS}); - unless (has_property($u, "nodiscriminant")) { - pidl "if (!prs_uint32(\"switch_value\", ps, depth, &v->switch_value))"; + if (defined ($u->{SWITCH_TYPE})) { + pidl "if (MARSHALLING(ps)) "; + pidl "\tv->switch_value = level;"; + pidl ""; + pidl "if (!prs_$u->{SWITCH_TYPE}(\"switch_value\", ps, depth, &v->switch_value))"; pidl "\treturn False;"; pidl ""; + } else { + pidl "v->switch_value = level;"; } # Maybe check here that level and v->switch_value are equal? - pidl "switch (level) {"; + pidl "switch (v->switch_value) {"; indent; foreach (@{$u->{ELEMENTS}}) { @@ -420,19 +433,30 @@ sub ParseUnion($$$) pidl ""; } + unless ($u->{HAS_DEFAULT}) { + pidl "default:"; + pidl "\treturn False;"; + pidl ""; + } + deindent; pidl "}"; pidl ""; pidl "return True;"; deindent; pidl "}"; + pidl ""; pidl "BOOL $dfn(const char *desc, $sn* v, uint32 level, prs_struct *ps, int depth)"; pidl "{"; indent; DeclareArrayVariables($u->{ELEMENTS}); - pidl "switch (level) {"; + if (defined($u->{SWITCH_TYPE})) { + pidl "switch (v->switch_value) {"; + } else { + pidl "switch (level) {"; + } indent; foreach (@{$u->{ELEMENTS}}) { -- cgit From fa0fbb46b8268ebaec4f8f2c7b18e3ceebb58b53 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 8 Oct 2005 17:55:56 +0000 Subject: r10840: Fix indentation (This used to be commit 7877d436576a1e7c6b02347f87e3f7e14e683888) --- source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm index 10b8dc71d8..3ec19fa158 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm @@ -40,7 +40,7 @@ NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name * status = dcerpc_ndr_request_recv(req); - if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { + if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { NDR_PRINT_OUT_DEBUG($name, r); } "; -- cgit From 36517c801cb7116df635dea8a129730c5bc014ea Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 8 Oct 2005 20:19:35 +0000 Subject: r10842: Fix some issues with [out] unions that have a discriminator that is only [in] (This used to be commit 3a4086d6142fa73b3adb2d66b1bfc9cd2585f31d) --- source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 3 +- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 10 ++++-- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 52 +++++++++------------------- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 48 +++++++------------------ 4 files changed, 37 insertions(+), 76 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm index ee1ab09324..ceeb81c3d7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm @@ -84,11 +84,12 @@ sub ParseFunction($$) pidl "/* Return variables */"; foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); - + if ($e->{LEVELS}[0]->{TYPE} ne "POINTER") { warning($e->{ORIGINAL}, "First element not a pointer for [out] argument"); next; } + CopyLevel($e, $e->{LEVELS}[1], $e->{NAME}, "r.$e->{NAME}"); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 25102e511a..d14bac2df7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -103,9 +103,13 @@ sub ParseUnion($$$) { my ($if,$u,$n) = @_; - my $extra = {}; - - $extra->{switch_value} = $u->{SWITCH_TYPE}; + my $extra = { + switch_value => $u->{SWITCH_TYPE} + }; + + if (not defined($extra->{switch_value})) { + $extra->{switch_value} = "uint32"; + } foreach my $e (@{$u->{ELEMENTS}}) { foreach my $l (@{$e->{LEVELS}}) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index c6cc188391..b87951adee 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -71,25 +71,7 @@ sub ParseElementLevelData($$$$$$$) { my ($e,$l,$nl,$env,$varname,$what,$align) = @_; - my @args = ($e,$l,$varname,$what,$align); - - # See if we need to add a level argument because we're parsing a union - foreach (@{$e->{LEVELS}}) { - next unless ($_->{TYPE} eq "SWITCH"); - my $t = getType($l->{DATA_TYPE}); - - # Set 0 here because one of the variables referenced in SWITCH_IS - # might be an in variable while this one is [out] - if (grep(/in/, @{$e->{DIRECTION}}) or - not defined($t) or - has_property($t->{DATA}, "nodiscriminant")) { - push (@args, ParseExpr($_->{SWITCH_IS}, $env)); - } else { - push (@args, -1); - } - } - - my $c = DissectType(@args); + my $c = DissectType($e,$l,$varname,$what,$align); return if not $c; if (defined($e->{ALIGN})) { @@ -261,6 +243,7 @@ sub InitLevel($$$$) pidl InitType($e, $l, ParseExpr($e->{NAME}, $env), $varname); } elsif ($l->{TYPE} eq "SWITCH") { InitLevel($e, GetNextLevel($e,$l), $varname, $env); + pidl ParseExpr($e->{NAME}, $env) . ".switch_value = " . ParseExpr($l->{SWITCH_IS}, $env) . ";"; } } @@ -397,20 +380,15 @@ sub ParseUnion($$$) my $pfn = "$fn\_p"; my $dfn = "$fn\_d"; - pidl "BOOL $pfn(const char *desc, $sn* v, uint32 level, prs_struct *ps, int depth)"; + pidl "BOOL $pfn(const char *desc, $sn* v, prs_struct *ps, int depth)"; pidl "{"; indent; DeclareArrayVariables($u->{ELEMENTS}); if (defined ($u->{SWITCH_TYPE})) { - pidl "if (MARSHALLING(ps)) "; - pidl "\tv->switch_value = level;"; - pidl ""; pidl "if (!prs_$u->{SWITCH_TYPE}(\"switch_value\", ps, depth, &v->switch_value))"; pidl "\treturn False;"; pidl ""; - } else { - pidl "v->switch_value = level;"; } # Maybe check here that level and v->switch_value are equal? @@ -447,7 +425,7 @@ sub ParseUnion($$$) pidl "}"; pidl ""; - pidl "BOOL $dfn(const char *desc, $sn* v, uint32 level, prs_struct *ps, int depth)"; + pidl "BOOL $dfn(const char *desc, $sn* v, prs_struct *ps, int depth)"; pidl "{"; indent; DeclareArrayVariables($u->{ELEMENTS}); @@ -483,16 +461,14 @@ sub ParseUnion($$$) } -sub CreateFnDirection($$$$) +sub CreateFnDirection($$$$$) { - my ($fn,$ifn, $s,$es) = @_; + my ($fn,$ifn,$s,$all,$es) = @_; my $args = ""; - foreach (@$es) { - $args .= ", " . DeclLong($_); - } + foreach (@$all) { $args .= ", " . DeclLong($_); } - my $env = { "this" => "v" }; + my $env = { }; GenerateEnvElement($_, $env) foreach (@$es); pidl "BOOL $ifn($s *v$args)"; @@ -539,6 +515,7 @@ sub ParseFunction($$) my @in = (); my @out = (); + my @all = @{$fn->{ELEMENTS}}; foreach (@{$fn->{ELEMENTS}}) { push (@in, $_) if (grep(/in/, @{$_->{DIRECTION}})); @@ -546,7 +523,7 @@ sub ParseFunction($$) } if (defined($fn->{RETURN_TYPE})) { - push (@out, { + my $status = { NAME => "status", TYPE => $fn->{RETURN_TYPE}, LEVELS => [ @@ -555,17 +532,20 @@ sub ParseFunction($$) DATA_TYPE => $fn->{RETURN_TYPE} } ] - } ); + }; + + push (@out, $status); + push (@all, $status); } CreateFnDirection("$if->{NAME}_io_q_$fn->{NAME}", "init_$if->{NAME}_q_$fn->{NAME}", uc("$if->{NAME}_q_$fn->{NAME}"), - \@in); + \@in, \@in); CreateFnDirection("$if->{NAME}_io_r_$fn->{NAME}", "init_$if->{NAME}_r_$fn->{NAME}", uc("$if->{NAME}_r_$fn->{NAME}"), - \@out); + \@all, \@out); } sub ParseInterface($) diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index 8cb09343ac..135b02f1e3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -205,12 +205,6 @@ sub AddType($$) $known_types->{$t} = $d; } -sub GetType($) -{ - my $e = shift; - -} - # Return type without special stuff, as used in # declarations for internal structs sub DeclShort($) @@ -305,14 +299,9 @@ sub InitType($$$$) } } -sub DissectType +sub DissectType($$$$$) { - my @args = @_; - my $e = shift @_; - my $l = shift @_; - my $varname = shift @_; - my $what = shift @_; - my $align = shift @_; + my ($e,$l,$varname,$what,$align) = @_; my $t = $known_types->{$l->{DATA_TYPE}}; @@ -332,7 +321,7 @@ sub DissectType # DISSECT can be a function if (ref($dissect) eq "CODE") { - return $dissect->(@args); + return $dissect->($e,$l,$varname,$what,$align); } else { return $dissect; } @@ -356,31 +345,18 @@ sub LoadTypes($) my $dissect_p; if ($td->{DATA}->{TYPE} eq "UNION") { $decl.="_CTR"; - $dissect_p = sub { - my ($e,$l,$n,$w,$a,$s) = @_; - - return "$if->{NAME}_io_$td->{NAME}_p(\"$e->{NAME}\", &$n, $s, ps, depth)"; - }; + } - $dissect_d = sub { - my ($e,$l,$n,$w,$a,$s) = @_; + $dissect_p = sub { + my ($e,$l,$n,$w,$a) = @_; - return "$if->{NAME}_io_$td->{NAME}_d(\"$e->{NAME}\", &$n, $s, ps, depth)"; - }; - - } else { - $dissect_p = sub { - my ($e,$l,$n,$w,$a) = @_; - - return "$if->{NAME}_io_$td->{NAME}_p(\"$e->{NAME}\", &$n, ps, depth)"; - }; - $dissect_d = sub { - my ($e,$l,$n,$w,$a) = @_; - - return "$if->{NAME}_io_$td->{NAME}_d(\"$e->{NAME}\", &$n, ps, depth)"; - }; + return "$if->{NAME}_io_$td->{NAME}_p(\"$e->{NAME}\", &$n, ps, depth)"; + }; + $dissect_d = sub { + my ($e,$l,$n,$w,$a) = @_; - } + return "$if->{NAME}_io_$td->{NAME}_d(\"$e->{NAME}\", &$n, ps, depth)"; + }; AddType($td->{NAME}, { DECL => $decl, -- cgit From 01d23b0e5454f317c1529fed829d24a32fdcc44d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 9 Oct 2005 13:53:48 +0000 Subject: r10849: Fix handling of [charset] for strings with fixed or "inline" size (This used to be commit 3c2558d11ec1d0b41e5b36b793d9e64db2e203b6) --- source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm index 3f08cbb527..da60a02059 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm @@ -575,8 +575,7 @@ sub ParseElementPushLevel my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING} - or is_charset_array($e, $l))) { + if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING})) { $var_name = get_pointer_to($var_name); } @@ -721,8 +720,7 @@ sub ParseElementPrint($$$) } elsif ($l->{TYPE} eq "ARRAY") { my $length; - if ($l->{IS_CONFORMANT} or $l->{IS_VARYING} or - is_charset_array($e,$l)) { + if ($l->{IS_CONFORMANT} or $l->{IS_VARYING}) { $var_name = get_pointer_to($var_name); } @@ -927,8 +925,7 @@ sub ParseElementPullLevel my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT} - or is_charset_array($e,$l))) { + if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT})) { $var_name = get_pointer_to($var_name); } -- cgit From b94fcbd306bbf758d26fb40c7c0a1b00ba6fe38d Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 10 Oct 2005 11:47:23 +0000 Subject: r10868: make flag(NDR_PAHEX) possible to use and show the union level in hex metze (This used to be commit 7efb92adc057ad8a993eb9de66c3806608747104) --- source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm index da60a02059..2ccbc057fc 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm @@ -1624,15 +1624,17 @@ sub ParseUnionPrint($$) my ($e,$name) = @_; my $have_default = 0; - pidl "int level = ndr_print_get_switch_value(ndr, r);"; - + pidl "int level;"; foreach my $el (@{$e->{ELEMENTS}}) { DeclareArrayVariables($el); } - pidl "ndr_print_union(ndr, name, level, \"$name\");"; start_flags($e); + pidl "level = ndr_print_get_switch_value(ndr, r);"; + + pidl "ndr_print_union(ndr, name, level, \"$name\");"; + pidl "switch (level) {"; indent; foreach my $el (@{$e->{ELEMENTS}}) { -- cgit From 399533dc6465e9010e3d6ef06e54e138513f12c5 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Mon, 10 Oct 2005 20:03:34 +0000 Subject: r10879: Added the ZERO_STRUCT(q_u), (r_u) entries to the generated Samba3 code. Jelmer please check ! Jeremy. (This used to be commit 534e8d16228ad4f1306ddf21ea9c9b988d736525) --- source4/pidl/lib/Parse/Pidl/Samba3/Server.pm | 3 +++ 1 file changed, 3 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm index 3f1f4645a1..b4eb6329eb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm @@ -36,6 +36,9 @@ sub ParseFunction($$) pidl "prs_struct *data = &p->in_data.data;"; pidl "prs_struct *rdata = &p->out_data.rdata;"; pidl ""; + pidl "ZERO_STRUCT(q_u);" + pidl "ZERO_STRUCT(r_u);" + pidl ""; pidl "if (!$if->{NAME}_io_q_$fn->{NAME}(\"\", &q_u, data, 0))"; pidl "\treturn False;"; pidl ""; -- cgit From d2376d70b280a0642ecac23cfc526b76819d6bb1 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Mon, 10 Oct 2005 20:05:29 +0000 Subject: r10880: Missed terminating ';', sorry. Jeremy. (This used to be commit 2680aeffb1e40a7d1d59c98f0ee533d7c4362f40) --- source4/pidl/lib/Parse/Pidl/Samba3/Server.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm index b4eb6329eb..179ace7dbb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm @@ -36,8 +36,8 @@ sub ParseFunction($$) pidl "prs_struct *data = &p->in_data.data;"; pidl "prs_struct *rdata = &p->out_data.rdata;"; pidl ""; - pidl "ZERO_STRUCT(q_u);" - pidl "ZERO_STRUCT(r_u);" + pidl "ZERO_STRUCT(q_u);"; + pidl "ZERO_STRUCT(r_u);"; pidl ""; pidl "if (!$if->{NAME}_io_q_$fn->{NAME}(\"\", &q_u, data, 0))"; pidl "\treturn False;"; -- cgit From ee49ed7a204753e0755f79304a2d4ac32f6e8fdf Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 14 Oct 2005 12:43:50 +0000 Subject: r11011: r10124@SERNOX: metze | 2005-09-09 20:22:00 +0200 r10113@SERNOX: metze | 2005-09-09 18:00:02 +0200 rename libcli/wins to libcli/wrepl metze r10115@SERNOX: metze | 2005-09-09 18:01:49 +0200 bind client connection to the best interface, to the partner metze r10116@SERNOX: jelmer | 2005-09-09 18:23:50 +0200 Print out a couple more warnings. (This used to be commit 66f931071e41dbd871ca8e1c2de8414a6230ab33) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 8a4c0ed60c..c4832e251a 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -321,6 +321,7 @@ sub Element($$$) my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; my $type = find_type($e->{TYPE}); + $hf_used{$hf} = 1; if (not defined($type)) { # default settings -- cgit From cffd522b5c806508dfacfb10234e4c0a115c0a98 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 14 Oct 2005 14:02:47 +0000 Subject: r11052: bring samba4 uptodate with the samba4-winsrepl branch, before the bad merge metze (This used to be commit 471c0ca4abb17fb5f73c0efed195c67628c1c06e) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 1 - 1 file changed, 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index c4832e251a..8a4c0ed60c 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -321,7 +321,6 @@ sub Element($$$) my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; my $type = find_type($e->{TYPE}); - $hf_used{$hf} = 1; if (not defined($type)) { # default settings -- cgit From 6f3caf73e13f32e5482d09b3fd2fbcf61ac88bc1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 14 Oct 2005 16:40:47 +0000 Subject: r11061: Samba3 parser generator fixes: * Add (limited) support for [string] * Don't generate (and set) header elements for top level ref pointers as they don't appear on the wire (This used to be commit 765adaf19be264e2d23a22eaed3027faededf8b6) --- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 8 ++++++-- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 28 +++++++++++++++++++--------- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 16 +++++++++++++++- 3 files changed, 40 insertions(+), 12 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index d14bac2df7..b49e64c337 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -9,7 +9,7 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba3::Types qw(DeclShort); +use Parse::Pidl::Samba3::Types qw(DeclShort StringType); use vars qw($VERSION); $VERSION = '0.01'; @@ -28,11 +28,15 @@ sub ParseElement($) foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { - return if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "top"); + next if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP"); pidl "\tuint32 ptr$l->{POINTER_INDEX}_$e->{NAME};"; } elsif ($l->{TYPE} eq "SWITCH") { } elsif ($l->{TYPE} eq "DATA") { pidl "\t" . DeclShort($e) . ";"; + } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED}) { + my ($t,$f) = StringType($e,$l); + pidl "\t" . uc($t) . " $e->{NAME};"; + return; } elsif ($l->{TYPE} eq "ARRAY") { if ($l->{IS_CONFORMANT}) { pidl "\tuint32 size_$e->{NAME};"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index b87951adee..d582305326 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -9,7 +9,7 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba3::Types qw(DeclShort DeclLong InitType DissectType); +use Parse::Pidl::Samba3::Types qw(DeclShort DeclLong InitType DissectType StringType); use vars qw($VERSION); $VERSION = '0.01'; @@ -27,7 +27,7 @@ sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } #TODO: # - Add some security checks (array sizes, memory alloc == NULL, etc) # - Don't add seperate _p and _d functions if there is no deferred data -# - [string] +# - [string] with non-varying arrays # - subcontext() # - DATA_BLOB @@ -58,7 +58,7 @@ sub DeclareArrayVariables next if ($l->{IS_DEFERRED} and $what == PRIMITIVES); next if (not $l->{IS_DEFERRED} and $what == DEFERRED); } - if ($l->{TYPE} eq "ARRAY") { + if ($l->{TYPE} eq "ARRAY" and not $l->{IS_ZERO_TERMINATED}) { pidl "uint32 i_$e->{NAME}_$l->{LEVEL_INDEX};"; $output = 1; } @@ -90,9 +90,14 @@ sub ParseElementLevelArray($$$$$$$) my ($e,$l,$nl,$env,$varname,$what,$align) = @_; if ($l->{IS_ZERO_TERMINATED}) { - fatal($e, "[string] attribute not supported for Samba3 yet"); - - #FIXME + my ($t,$f) = StringType($e,$l); + + pidl "if (!prs_io_$t(\"$e->{VARNAME}\", ps, depth, $varname))"; + pidl "\treturn False;"; + pidl ""; + + $$align = 0; + return; } my $len = ParseExpr($l->{LENGTH_IS}, $env); @@ -228,7 +233,9 @@ sub InitLevel($$$$) indent; } - pidl ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . " = 1;"; + unless ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP") { + pidl ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . " = 1;"; + } InitLevel($e, GetNextLevel($e,$l), "*$varname", $env); if ($l->{POINTER_TYPE} ne "ref") { @@ -237,6 +244,9 @@ sub InitLevel($$$$) pidl "\t" . ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . " = 0;"; pidl "}"; } + } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED}) { + my ($t,$f) = StringType($e,$l); + pidl "init_$t(" . ParseExpr($e->{NAME}, $env) . ", $varname, $f);"; } elsif ($l->{TYPE} eq "ARRAY") { pidl ParseExpr($e->{NAME}, $env) . " = $varname;"; } elsif ($l->{TYPE} eq "DATA") { @@ -256,7 +266,7 @@ sub GenerateEnvElement($$) } elsif ($l->{TYPE} eq "POINTER") { $env->{"ptr$l->{POINTER_INDEX}_$e->{NAME}"} = "v->ptr$l->{POINTER_INDEX}_$e->{NAME}"; } elsif ($l->{TYPE} eq "SWITCH") { - } elsif ($l->{TYPE} eq "ARRAY") { + } elsif ($l->{TYPE} eq "ARRAY" and not $l->{IS_ZERO_TERMINATED}) { $env->{"length_$e->{NAME}"} = "v->length_$e->{NAME}"; $env->{"size_$e->{NAME}"} = "v->size_$e->{NAME}"; $env->{"offset_$e->{NAME}"} = "v->offset_$e->{NAME}"; @@ -360,7 +370,7 @@ sub UnionGenerateEnvElement($) } elsif ($l->{TYPE} eq "POINTER") { $env->{"ptr$l->{POINTER_INDEX}_$e->{NAME}"} = "v->ptr$l->{POINTER_INDEX}"; } elsif ($l->{TYPE} eq "SWITCH") { - } elsif ($l->{TYPE} eq "ARRAY") { + } elsif ($l->{TYPE} eq "ARRAY" and not $l->{IS_ZERO_TERMINATED}) { $env->{"length_$e->{NAME}"} = "v->length"; $env->{"size_$e->{NAME}"} = "v->size"; $env->{"offset_$e->{NAME}"} = "v->offset"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index 135b02f1e3..db20372bba 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Samba3::Types; require Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(DeclShort DeclLong InitType DissectType AddType); +@EXPORT_OK = qw(DeclShort DeclLong InitType DissectType AddType StringType); use strict; use Parse::Pidl::Util qw(has_property ParseExpr property_matches); @@ -104,6 +104,20 @@ sub dissect_string($$$$$) return "smb_io_$t(\"$e->{NAME}\", &$n, 1, ps, depth)"; } +sub StringType($$) +{ + my ($e,$l) = @_; + my $nl = GetNextLevel($e,$l); + + if ($l->{IS_VARYING} and $l->{IS_CONFORMANT} and $nl->{DATA_TYPE} eq "uint16") { + return ("unistr2", 0); + } elsif ($l->{IS_CONFORMANT} and $l->{IS_VARYING} and $nl->{DATA_TYPE} eq "uint8") { + return ("string2", 0); + } else { + fatal($e, "[string] non-varying string not supported for Samba3 yet"); + } +} + my $known_types = { uint8 => -- cgit From 8a58b806e90b177107cb6a21ab43a88ff8516ec8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 14 Oct 2005 19:57:41 +0000 Subject: r11067: Support for [string] in the Ethereal parser generator (This used to be commit 1d5db487bb4afffac13b0d0904aea6b8664b75a8) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 39 ++++++++++++++++++++++------- source4/pidl/lib/Parse/Pidl/NDR.pm | 13 +++++++++- 2 files changed, 42 insertions(+), 10 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 8a4c0ed60c..be2e48a686 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -19,13 +19,19 @@ package Parse::Pidl::Ethereal::NDR; use strict; use Parse::Pidl::Typelist qw(getType); use Parse::Pidl::Util qw(has_property ParseExpr property_matches make_str); -use Parse::Pidl::NDR; +use Parse::Pidl::NDR qw(ContainsString GetNextLevel); use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); use Parse::Pidl::Ethereal::Conformance qw(ReadConformance); use vars qw($VERSION); $VERSION = '0.01'; +sub error($$) +{ + my ($e,$t) = @_; + print "$e->{FILE}:$e->{LINE}: $t\n"; +} + my @ett; my %hf_used = (); @@ -243,21 +249,26 @@ sub ElementLevel($$$$$) } pidl_code "offset = dissect_ndr_$type\_pointer(tvb, offset, pinfo, tree, drep, $myname\_, $ptrtype_mappings{$l->{POINTER_TYPE}}, \"Pointer to ".field2name(StripPrefixes($e->{NAME})) . " ($e->{TYPE})\",$hf);"; } elsif ($l->{TYPE} eq "ARRAY") { - if ($l->{IS_INLINE}) { - warn ("Inline arrays not supported"); - pidl_code "/* FIXME: Handle inline array */"; + error($e->{ORIGINAL}, "Inline arrays not supported"); } elsif ($l->{IS_FIXED}) { pidl_code "int i;"; pidl_code "for (i = 0; i < $l->{SIZE_IS}; i++)"; pidl_code "\toffset = $myname\_(tvb, offset, pinfo, tree, drep);"; } else { - my $af = ""; - ($af = "ucarray") if ($l->{IS_CONFORMANT}); - ($af = "uvarray") if ($l->{IS_VARYING}); - ($af = "ucvarray") if ($l->{IS_CONFORMANT} and $l->{IS_VARYING}); + my $type = ""; + $type .= "c" if ($l->{IS_CONFORMANT}); + $type .= "v" if ($l->{IS_VARYING}); - pidl_code "offset = dissect_ndr_$af(tvb, offset, pinfo, tree, drep, $myname\_);"; + unless ($l->{IS_ZERO_TERMINATED}) { + pidl_code "offset = dissect_ndr_u" . $type . "array(tvb, offset, pinfo, tree, drep, $myname\_);"; + } else { + my $nl = GetNextLevel($e,$l); + pidl_code "char *data;"; + pidl_code ""; + pidl_code "offset = dissect_ndr_$type" . "string(tvb, offset, pinfo, tree, drep, sizeof(g$nl->{DATA_TYPE}), $hf, FALSE, &data);"; + pidl_code "proto_item_append_text(tree, \": %s\", data);"; + } } } elsif ($l->{TYPE} eq "DATA") { if ($l->{DATA_TYPE} eq "string") { @@ -332,6 +343,15 @@ sub Element($$$) }; } + if (ContainsString($e)) { + $type = { + MASK => 0, + VALSSTRING => "NULL", + FT_TYPE => "FT_STRING", + BASE_TYPE => "BASE_DEC" + }; + } + my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", $type->{FT_TYPE}, $type->{BASE_TYPE}, $type->{VALSSTRING}, $type->{MASK}, ""); $hf_used{$hf} = 1; @@ -357,6 +377,7 @@ sub Element($$$) deindent; pidl_code "}\n"; $add.="_"; + last if ($_->{TYPE} eq "ARRAY" and $_->{IS_ZERO_TERMINATED}); } return $call_code; diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index f975e07b15..73104758dd 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -31,7 +31,7 @@ require Exporter; use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); -@EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred); +@EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); use strict; use Parse::Pidl::Typelist qw(hasType getType); @@ -654,6 +654,17 @@ sub GetPrevLevel($$) return undef; } +sub ContainsString($) +{ + my ($e) = @_; + + foreach my $l (@{$e->{LEVELS}}) { + return 1 if ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED}); + } + + return 0; +} + sub ContainsDeferred($$) { my ($e,$l) = @_; -- cgit From 5a937a0f6f62de25ce7721413a4bbf3b9b31ea59 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 15 Oct 2005 00:45:16 +0000 Subject: r11077: Fix [string] for Samba3 (This used to be commit 2f76e2a6bf8ff99ac2f9b61669d09d76a2fe920a) --- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 10 ++++++---- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 9 ++++++--- 2 files changed, 12 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index d582305326..9ef8f09dc4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -27,7 +27,7 @@ sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } #TODO: # - Add some security checks (array sizes, memory alloc == NULL, etc) # - Don't add seperate _p and _d functions if there is no deferred data -# - [string] with non-varying arrays +# - [string] with non-varying arrays and "surrounding" strings # - subcontext() # - DATA_BLOB @@ -90,11 +90,13 @@ sub ParseElementLevelArray($$$$$$$) my ($e,$l,$nl,$env,$varname,$what,$align) = @_; if ($l->{IS_ZERO_TERMINATED}) { + return if ($what == DEFERRED); + my ($t,$f) = StringType($e,$l); - pidl "if (!prs_io_$t(\"$e->{VARNAME}\", ps, depth, $varname))"; + Align($align, 4); + pidl "if (!smb_io_$t(\"$e->{NAME}\", &$varname, 1, ps, depth))"; pidl "\treturn False;"; - pidl ""; $$align = 0; return; @@ -246,7 +248,7 @@ sub InitLevel($$$$) } } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED}) { my ($t,$f) = StringType($e,$l); - pidl "init_$t(" . ParseExpr($e->{NAME}, $env) . ", $varname, $f);"; + pidl "init_$t(&" . ParseExpr($e->{NAME}, $env) . ", ".substr($varname, 1) . ", $f);"; } elsif ($l->{TYPE} eq "ARRAY") { pidl ParseExpr($e->{NAME}, $env) . " = $varname;"; } elsif ($l->{TYPE} eq "DATA") { diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index db20372bba..3f7e8ae134 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -11,7 +11,7 @@ require Exporter; use strict; use Parse::Pidl::Util qw(has_property ParseExpr property_matches); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); use vars qw($VERSION); $VERSION = '0.01'; @@ -110,7 +110,7 @@ sub StringType($$) my $nl = GetNextLevel($e,$l); if ($l->{IS_VARYING} and $l->{IS_CONFORMANT} and $nl->{DATA_TYPE} eq "uint16") { - return ("unistr2", 0); + return ("unistr2", "UNI_FLAGS_NONE"); } elsif ($l->{IS_CONFORMANT} and $l->{IS_VARYING} and $nl->{DATA_TYPE} eq "uint8") { return ("string2", 0); } else { @@ -282,7 +282,10 @@ sub DeclLong($) my $suffixes = ""; foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "ARRAY" and not $l->{IS_FIXED}) { + if ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED}) { + $p = "const char"; + last; + } elsif ($l->{TYPE} eq "ARRAY" and not $l->{IS_FIXED}) { $prefixes = "*$prefixes"; } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}) { $suffixes.="[$l->{SIZE_IS}]"; -- cgit From c008f951cff74e5218c7ef7bbc90487433ab72c5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 16 Oct 2005 17:17:42 +0000 Subject: r11097: Allow pointers in "const" (This used to be commit 88fcd56fb55ac3f7e1eef3b3c92a2593c79599d3) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 405 +++++++++++++++++++------------------ 1 file changed, 207 insertions(+), 198 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 1aa4426cd6..59a9aef76a 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -1424,11 +1424,9 @@ sub new { } }, {#State 102 - ACTIONS => { - 'IDENTIFIER' => 9 - }, + DEFAULT => -52, GOTOS => { - 'identifier' => 119 + 'pointers' => 119 } }, {#State 103 @@ -1535,17 +1533,17 @@ sub new { }, {#State 119 ACTIONS => { - "[" => 130, - "=" => 132 + 'IDENTIFIER' => 9, + "*" => 131 }, GOTOS => { - 'array_len' => 131 + 'identifier' => 130 } }, {#State 120 DEFAULT => -54, GOTOS => { - 'element_list1' => 133 + 'element_list1' => 132 } }, {#State 121 @@ -1553,9 +1551,9 @@ sub new { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 134, - 'enum_element' => 135, - 'enum_elements' => 136 + 'identifier' => 133, + 'enum_element' => 134, + 'enum_elements' => 135 } }, {#State 122 @@ -1563,9 +1561,9 @@ sub new { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 139, - 'bitmap_elements' => 138, - 'bitmap_element' => 137 + 'identifier' => 138, + 'bitmap_elements' => 137, + 'bitmap_element' => 136 } }, {#State 123 @@ -1621,7 +1619,7 @@ sub new { }, {#State 126 ACTIONS => { - "[" => 130 + "[" => 139 }, DEFAULT => -60, GOTOS => { @@ -1658,75 +1656,68 @@ sub new { }, {#State 130 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - "]" => 149, - 'IDENTIFIER' => 9 + "[" => 139, + "=" => 150 }, - DEFAULT => -73, GOTOS => { - 'identifier' => 23, - 'anytext' => 150, - 'text' => 24, - 'constant' => 27 + 'array_len' => 149 } }, {#State 131 - ACTIONS => { - "=" => 151 - } + DEFAULT => -53 }, {#State 132 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -73, - GOTOS => { - 'identifier' => 23, - 'anytext' => 152, - 'text' => 24, - 'constant' => 27 - } - }, - {#State 133 - ACTIONS => { - "}" => 153 + "}" => 151 }, DEFAULT => -63, GOTOS => { - 'base_element' => 154, + 'base_element' => 152, 'property_list' => 145 } }, - {#State 134 + {#State 133 ACTIONS => { - "=" => 155 + "=" => 153 }, DEFAULT => -37 }, - {#State 135 + {#State 134 DEFAULT => -35 }, + {#State 135 + ACTIONS => { + "}" => 154, + "," => 155 + } + }, {#State 136 + DEFAULT => -40 + }, + {#State 137 ACTIONS => { "}" => 156, "," => 157 } }, - {#State 137 - DEFAULT => -40 - }, {#State 138 ACTIONS => { - "}" => 158, - "," => 159 + "=" => 158 } }, {#State 139 ACTIONS => { - "=" => 160 + 'CONSTANT' => 28, + 'TEXT' => 22, + "]" => 159, + 'IDENTIFIER' => 9 + }, + DEFAULT => -73, + GOTOS => { + 'identifier' => 23, + 'anytext' => 160, + 'text' => 24, + 'constant' => 27 } }, {#State 140 @@ -1789,34 +1780,10 @@ sub new { }, {#State 149 ACTIONS => { - "[" => 130 - }, - DEFAULT => -60, - GOTOS => { - 'array_len' => 169 + "=" => 169 } }, {#State 150 - ACTIONS => { - "-" => 35, - ":" => 34, - "?" => 36, - "<" => 37, - "+" => 39, - "~" => 38, - "&" => 41, - "{" => 40, - "/" => 42, - "=" => 43, - "|" => 45, - "(" => 44, - "*" => 46, - "." => 47, - "]" => 170, - ">" => 48 - } - }, - {#State 151 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1825,40 +1792,20 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 171, + 'anytext' => 170, 'text' => 24, 'constant' => 27 } }, - {#State 152 - ACTIONS => { - "-" => 35, - ":" => 34, - "?" => 36, - "<" => 37, - ";" => 172, - "+" => 39, - "~" => 38, - "&" => 41, - "{" => 40, - "/" => 42, - "=" => 43, - "|" => 45, - "(" => 44, - "*" => 46, - "." => 47, - ">" => 48 - } - }, - {#State 153 + {#State 151 DEFAULT => -43 }, - {#State 154 + {#State 152 ACTIONS => { - ";" => 173 + ";" => 171 } }, - {#State 155 + {#State 153 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1867,36 +1814,36 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 174, + 'anytext' => 172, 'text' => 24, 'constant' => 27 } }, - {#State 156 + {#State 154 DEFAULT => -34 }, - {#State 157 + {#State 155 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 134, - 'enum_element' => 175 + 'identifier' => 133, + 'enum_element' => 173 } }, - {#State 158 + {#State 156 DEFAULT => -39 }, - {#State 159 + {#State 157 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 139, - 'bitmap_element' => 176 + 'identifier' => 138, + 'bitmap_element' => 174 } }, - {#State 160 + {#State 158 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, @@ -1905,11 +1852,40 @@ sub new { DEFAULT => -73, GOTOS => { 'identifier' => 23, - 'anytext' => 177, + 'anytext' => 175, 'text' => 24, 'constant' => 27 } }, + {#State 159 + ACTIONS => { + "[" => 139 + }, + DEFAULT => -60, + GOTOS => { + 'array_len' => 176 + } + }, + {#State 160 + ACTIONS => { + "-" => 35, + ":" => 34, + "?" => 36, + "<" => 37, + "+" => 39, + "~" => 38, + "&" => 41, + "{" => 40, + "/" => 42, + "=" => 43, + "|" => 45, + "(" => 44, + "*" => 46, + "." => 47, + "]" => 177, + ">" => 48 + } + }, {#State 161 DEFAULT => -25 }, @@ -1964,18 +1940,20 @@ sub new { } }, {#State 169 - DEFAULT => -61 - }, - {#State 170 ACTIONS => { - "[" => 130 + 'CONSTANT' => 28, + 'TEXT' => 22, + 'IDENTIFIER' => 9 }, - DEFAULT => -60, + DEFAULT => -73, GOTOS => { - 'array_len' => 183 + 'identifier' => 23, + 'anytext' => 183, + 'text' => 24, + 'constant' => 27 } }, - {#State 171 + {#State 170 ACTIONS => { "-" => 35, ":" => 34, @@ -1995,13 +1973,10 @@ sub new { ">" => 48 } }, - {#State 172 - DEFAULT => -17 - }, - {#State 173 + {#State 171 DEFAULT => -55 }, - {#State 174 + {#State 172 ACTIONS => { "-" => 35, ":" => 34, @@ -2021,13 +1996,13 @@ sub new { }, DEFAULT => -38 }, - {#State 175 + {#State 173 DEFAULT => -36 }, - {#State 176 + {#State 174 DEFAULT => -41 }, - {#State 177 + {#State 175 ACTIONS => { "-" => 35, ":" => 34, @@ -2047,6 +2022,18 @@ sub new { }, DEFAULT => -42 }, + {#State 176 + DEFAULT => -61 + }, + {#State 177 + ACTIONS => { + "[" => 139 + }, + DEFAULT => -60, + GOTOS => { + 'array_len' => 185 + } + }, {#State 178 DEFAULT => -45 }, @@ -2056,10 +2043,10 @@ sub new { {#State 180 ACTIONS => { 'IDENTIFIER' => 9, - "*" => 186 + "*" => 131 }, GOTOS => { - 'identifier' => 185 + 'identifier' => 186 } }, {#State 181 @@ -2069,24 +2056,44 @@ sub new { DEFAULT => -19 }, {#State 183 - DEFAULT => -62 + ACTIONS => { + "-" => 35, + ":" => 34, + "?" => 36, + "<" => 37, + ";" => 187, + "+" => 39, + "~" => 38, + "&" => 41, + "{" => 40, + "/" => 42, + "=" => 43, + "|" => 45, + "(" => 44, + "*" => 46, + "." => 47, + ">" => 48 + } }, {#State 184 - DEFAULT => -18 + DEFAULT => -17 }, {#State 185 + DEFAULT => -62 + }, + {#State 186 ACTIONS => { - "[" => 130 + "[" => 139 }, DEFAULT => -60, GOTOS => { - 'array_len' => 187 + 'array_len' => 188 } }, - {#State 186 - DEFAULT => -53 - }, {#State 187 + DEFAULT => -18 + }, + {#State 188 DEFAULT => -51 } ], @@ -2183,28 +2190,30 @@ sub 'definition', 1, undef ], [#Rule 17 - 'const', 6, + 'const', 7, sub #line 66 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], - "NAME" => $_[3], - "VALUE" => $_[5], + "POINTERS" => $_[3], + "NAME" => $_[4], + "VALUE" => $_[6], "FILE" => $_[0]->YYData->{INPUT_FILENAME}, "LINE" => $_[0]->YYData->{LINE}, }} ], [#Rule 18 - 'const', 7, + 'const', 8, sub -#line 75 "pidl/idl.yp" +#line 76 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], - "NAME" => $_[3], - "ARRAY_LEN" => $_[4], - "VALUE" => $_[6], + "POINTERS" => $_[3], + "NAME" => $_[4], + "ARRAY_LEN" => $_[5], + "VALUE" => $_[7], "FILE" => $_[0]->YYData->{INPUT_FILENAME}, "LINE" => $_[0]->YYData->{LINE}, }} @@ -2212,7 +2221,7 @@ sub [#Rule 19 'function', 7, sub -#line 88 "pidl/idl.yp" +#line 90 "pidl/idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2226,7 +2235,7 @@ sub [#Rule 20 'declare', 5, sub -#line 100 "pidl/idl.yp" +#line 102 "pidl/idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2245,7 +2254,7 @@ sub [#Rule 23 'decl_enum', 1, sub -#line 114 "pidl/idl.yp" +#line 116 "pidl/idl.yp" {{ "TYPE" => "ENUM" }} @@ -2253,7 +2262,7 @@ sub [#Rule 24 'decl_bitmap', 1, sub -#line 120 "pidl/idl.yp" +#line 122 "pidl/idl.yp" {{ "TYPE" => "BITMAP" }} @@ -2261,7 +2270,7 @@ sub [#Rule 25 'typedef', 6, sub -#line 126 "pidl/idl.yp" +#line 128 "pidl/idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], @@ -2287,7 +2296,7 @@ sub [#Rule 30 'typedecl', 2, sub -#line 139 "pidl/idl.yp" +#line 141 "pidl/idl.yp" { $_[1] } ], [#Rule 31 @@ -2299,13 +2308,13 @@ sub [#Rule 33 'type', 1, sub -#line 142 "pidl/idl.yp" +#line 144 "pidl/idl.yp" { "void" } ], [#Rule 34 'enum', 5, sub -#line 146 "pidl/idl.yp" +#line 148 "pidl/idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], @@ -2315,13 +2324,13 @@ sub [#Rule 35 'enum_elements', 1, sub -#line 154 "pidl/idl.yp" +#line 156 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 36 'enum_elements', 3, sub -#line 155 "pidl/idl.yp" +#line 157 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 37 @@ -2330,13 +2339,13 @@ sub [#Rule 38 'enum_element', 3, sub -#line 159 "pidl/idl.yp" +#line 161 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 39 'bitmap', 5, sub -#line 163 "pidl/idl.yp" +#line 165 "pidl/idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], @@ -2346,25 +2355,25 @@ sub [#Rule 40 'bitmap_elements', 1, sub -#line 171 "pidl/idl.yp" +#line 173 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 41 'bitmap_elements', 3, sub -#line 172 "pidl/idl.yp" +#line 174 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 42 'bitmap_element', 3, sub -#line 175 "pidl/idl.yp" +#line 177 "pidl/idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 43 'struct', 5, sub -#line 179 "pidl/idl.yp" +#line 181 "pidl/idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], @@ -2374,7 +2383,7 @@ sub [#Rule 44 'empty_element', 2, sub -#line 187 "pidl/idl.yp" +#line 189 "pidl/idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2394,7 +2403,7 @@ sub [#Rule 47 'optional_base_element', 2, sub -#line 201 "pidl/idl.yp" +#line 203 "pidl/idl.yp" { $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 48 @@ -2403,13 +2412,13 @@ sub [#Rule 49 'union_elements', 2, sub -#line 206 "pidl/idl.yp" +#line 208 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 50 'union', 5, sub -#line 210 "pidl/idl.yp" +#line 212 "pidl/idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], @@ -2419,7 +2428,7 @@ sub [#Rule 51 'base_element', 5, sub -#line 218 "pidl/idl.yp" +#line 220 "pidl/idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2433,13 +2442,13 @@ sub [#Rule 52 'pointers', 0, sub -#line 232 "pidl/idl.yp" +#line 234 "pidl/idl.yp" { 0 } ], [#Rule 53 'pointers', 2, sub -#line 233 "pidl/idl.yp" +#line 235 "pidl/idl.yp" { $_[1]+1 } ], [#Rule 54 @@ -2448,7 +2457,7 @@ sub [#Rule 55 'element_list1', 3, sub -#line 238 "pidl/idl.yp" +#line 240 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 56 @@ -2460,13 +2469,13 @@ sub [#Rule 58 'element_list2', 1, sub -#line 244 "pidl/idl.yp" +#line 246 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 59 'element_list2', 3, sub -#line 245 "pidl/idl.yp" +#line 247 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 60 @@ -2475,13 +2484,13 @@ sub [#Rule 61 'array_len', 3, sub -#line 250 "pidl/idl.yp" +#line 252 "pidl/idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 62 'array_len', 4, sub -#line 251 "pidl/idl.yp" +#line 253 "pidl/idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 63 @@ -2490,31 +2499,31 @@ sub [#Rule 64 'property_list', 4, sub -#line 257 "pidl/idl.yp" +#line 259 "pidl/idl.yp" { Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); } ], [#Rule 65 'properties', 1, sub -#line 260 "pidl/idl.yp" +#line 262 "pidl/idl.yp" { $_[1] } ], [#Rule 66 'properties', 3, sub -#line 261 "pidl/idl.yp" +#line 263 "pidl/idl.yp" { Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); } ], [#Rule 67 'property', 1, sub -#line 264 "pidl/idl.yp" +#line 266 "pidl/idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 68 'property', 4, sub -#line 265 "pidl/idl.yp" +#line 267 "pidl/idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 69 @@ -2523,7 +2532,7 @@ sub [#Rule 70 'listtext', 3, sub -#line 270 "pidl/idl.yp" +#line 272 "pidl/idl.yp" { "$_[1] $_[3]" } ], [#Rule 71 @@ -2532,13 +2541,13 @@ sub [#Rule 72 'commalisttext', 3, sub -#line 275 "pidl/idl.yp" +#line 277 "pidl/idl.yp" { "$_[1],$_[3]" } ], [#Rule 73 'anytext', 0, sub -#line 279 "pidl/idl.yp" +#line 281 "pidl/idl.yp" { "" } ], [#Rule 74 @@ -2553,91 +2562,91 @@ sub [#Rule 77 'anytext', 3, sub -#line 281 "pidl/idl.yp" +#line 283 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 78 'anytext', 3, sub -#line 282 "pidl/idl.yp" +#line 284 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 79 'anytext', 3, sub -#line 283 "pidl/idl.yp" +#line 285 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 80 'anytext', 3, sub -#line 284 "pidl/idl.yp" +#line 286 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 81 'anytext', 3, sub -#line 285 "pidl/idl.yp" +#line 287 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 82 'anytext', 3, sub -#line 286 "pidl/idl.yp" +#line 288 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 83 'anytext', 3, sub -#line 287 "pidl/idl.yp" +#line 289 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 84 'anytext', 3, sub -#line 288 "pidl/idl.yp" +#line 290 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 85 'anytext', 3, sub -#line 289 "pidl/idl.yp" +#line 291 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 86 'anytext', 3, sub -#line 290 "pidl/idl.yp" +#line 292 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 87 'anytext', 3, sub -#line 291 "pidl/idl.yp" +#line 293 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 88 'anytext', 3, sub -#line 292 "pidl/idl.yp" +#line 294 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 89 'anytext', 3, sub -#line 293 "pidl/idl.yp" +#line 295 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 90 'anytext', 5, sub -#line 294 "pidl/idl.yp" +#line 296 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 91 'anytext', 5, sub -#line 295 "pidl/idl.yp" +#line 297 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 92 @@ -2655,7 +2664,7 @@ sub [#Rule 96 'text', 1, sub -#line 309 "pidl/idl.yp" +#line 311 "pidl/idl.yp" { "\"$_[1]\"" } ], [#Rule 97 @@ -2669,7 +2678,7 @@ sub bless($self,$class); } -#line 320 "pidl/idl.yp" +#line 322 "pidl/idl.yp" use Parse::Pidl::Util; -- cgit From f598135c6b3dabd1435ea7eed5d8ab69dac97407 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 16 Oct 2005 23:47:09 +0000 Subject: r11105: Warn if conformant arrays are not at the end of a struct Support conformant [string] arrays Eliminate utf8string This breaks xattr binary compatibility with previous versions - is that a problem? (This used to be commit 7596c708ba6642473319a1b699a5a910a639e50d) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 7 ++++++- source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 19 ++++++++++++++++--- 2 files changed, 22 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 73104758dd..d0b6708bf6 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -373,7 +373,12 @@ sub ParseStruct($) foreach my $x (@{$struct->{ELEMENTS}}) { - push @elements, ParseElement($x); + my $e = ParseElement($x); + if ($x != $struct->{ELEMENTS}[-1] and + $e->{LEVELS}[0]->{IS_SURROUNDING}) { + print "$x->{FILE}:$x->{LINE}: error: conformant member not at end of struct\n"; + } + push @elements, $e; } my $e = $elements[-1]; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm index 2ccbc057fc..d203c4fa43 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm @@ -292,7 +292,11 @@ sub ParseArrayPushHeader($$$$$) my $length; if ($l->{IS_ZERO_TERMINATED}) { - $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))"; + if (has_property($e, "charset")) { + $size = $length = "ndr_charset_length($var_name, CH_$e->{PROPERTIES}->{charset})"; + } else { + $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))"; + } } else { $size = ParseExpr($l->{SIZE_IS}, $env); $length = ParseExpr($l->{LENGTH_IS}, $env); @@ -1125,13 +1129,22 @@ sub ParseStructPush($$) # we need to push the conformant length early, as it fits on # the wire before the structure (and even before the structure # alignment) - my $e = $struct->{ELEMENTS}[-1]; if (defined($struct->{SURROUNDING_ELEMENT})) { my $e = $struct->{SURROUNDING_ELEMENT}; if (defined($e->{LEVELS}[0]) and $e->{LEVELS}[0]->{TYPE} eq "ARRAY") { - my $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env); + my $size; + + if ($e->{LEVELS}[0]->{IS_ZERO_TERMINATED}) { + if (has_property($e, "charset")) { + $size = "ndr_charset_length(r->$e->{NAME}, CH_$e->{PROPERTIES}->{charset})"; + } else { + $size = "ndr_string_length(r->$e->{NAME}, sizeof(*r->$e->{NAME}))"; + } + } else { + $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env); + } pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; } else { -- cgit From 087dd76232b8e7471db5f90fff4e49b2359f1557 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 18 Oct 2005 14:12:33 +0000 Subject: r11141: Re-add paranoid string terminator check (This used to be commit 55805b5ed9493160ff17c26d2e1361947f368707) --- source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 30 +++++++++++++++++-------- 1 file changed, 21 insertions(+), 9 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm index d203c4fa43..0454f90c9a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm @@ -923,6 +923,15 @@ sub ParseMemCtxPullEnd($$) pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);"; } +sub CheckStringTerminator($$$$) +{ + my ($ndr,$e,$l,$length) = @_; + my $nl = GetNextLevel($e, $l); + + # Make sure last element is zero! + pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $length, sizeof($nl->{DATA_TYPE}_t)));"; +} + sub ParseElementPullLevel { my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; @@ -945,14 +954,16 @@ sub ParseElementPullLevel my $nl = GetNextLevel($e, $l); if (is_charset_array($e,$l)) { + if ($l->{IS_ZERO_TERMINATED}) { + CheckStringTerminator($ndr, $e, $l, $length); + } pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; return; } elsif (has_fast_array($e, $l)) { - pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; if ($l->{IS_ZERO_TERMINATED}) { - # Make sure last element is zero! - pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));"; + CheckStringTerminator($ndr,$e,$l,$length); } + pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; return; } } elsif ($l->{TYPE} eq "POINTER") { @@ -1002,16 +1013,17 @@ sub ParseElementPullLevel ParseMemCtxPullStart($e,$l, $array_name); if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { + my $nl = GetNextLevel($e,$l); + + if ($l->{IS_ZERO_TERMINATED}) { + CheckStringTerminator($ndr,$e,$l,$length); + } + pidl "for ($counter = 0; $counter < $length; $counter++) {"; indent; - ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 0); + ParseElementPullLevel($e, $nl, $ndr, $var_name, $env, 1, 0); deindent; pidl "}"; - - if ($l->{IS_ZERO_TERMINATED}) { - # Make sure last element is zero! - pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));"; - } } if ($deferred and ContainsDeferred($e, $l)) { -- cgit From 7514f906c2e491dbd807833d6b536081d7665d37 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Thu, 20 Oct 2005 07:06:49 +0000 Subject: r11211: Append an error message to COL_INFO if the RPC call returned an error. (This used to be commit b70dd7a757e7341d90c89dffa7e1c4eab790020a) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index be2e48a686..41ccaf54dd 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -401,6 +401,7 @@ sub Function($$$) pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; pidl_code "{"; indent; + pidl_code "guint32 status;\n"; foreach (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$_->{DIRECTION}})) { pidl_code "$dissectornames{$_->{NAME}}"; @@ -411,10 +412,15 @@ sub Function($$$) if (not defined($fn->{RETURN_TYPE})) { } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { - pidl_code "offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, NULL);"; + pidl_code "offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, &status);\n"; + pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; + pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, NT_errors, \"Unknown NT status 0x%08x\"));\n"; $hf_used{"hf\_$ifname\_status"} = 1; } elsif ($fn->{RETURN_TYPE} eq "WERROR") { - pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, NULL);"; + pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, &status);\n"; + pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; + pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, DOS_errors, \"Unknown DOS error 0x%08x\"));\n"; + $hf_used{"hf\_$ifname\_werror"} = 1; } else { print "$fn->{FILE}:$fn->{LINE}: error: return type `$fn->{RETURN_TYPE}' not yet supported\n"; -- cgit From 79b667eda998596d6a9020fe61821f6878ece376 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Sun, 23 Oct 2005 01:19:38 +0000 Subject: r11262: Try to get the equivalent of a subcontext in pidl ethereal conformance files working. It doesn't quite work though. (-: This patch also allows a struct.field format to be used in an IMPORT statement instead of a type name. Jelmer, what do you think? (This used to be commit d770f853475d12a33d23fc86ab30223dfde22dd7) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 41ccaf54dd..24423d9292 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -292,6 +292,10 @@ sub ElementLevel($$$$$) if ($conformance->{imports}->{$l->{DATA_TYPE}}) { $call = $conformance->{imports}->{$l->{DATA_TYPE}}->{DATA}; $conformance->{imports}->{$l->{DATA_TYPE}}->{USED} = 1; + } elsif (defined($conformance->{imports}->{"$pn.$e->{NAME}"})) { + $call = $conformance->{imports}->{"$pn.$e->{NAME}"}->{DATA}; + $conformance->{imports}->{"$pn.$e->{NAME}"}->{USED} = 1; + } elsif (defined($conformance->{types}->{$l->{DATA_TYPE}})) { $call= $conformance->{types}->{$l->{DATA_TYPE}}->{DISSECTOR_NAME}; $conformance->{types}->{$l->{DATA_TYPE}}->{USED} = 1; -- cgit From 66d3ee9ccb9807ca443962ef2a887627505c537c Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Wed, 2 Nov 2005 05:34:17 +0000 Subject: r11473: Based on work by Jelmer, implement the [async] flag for rpc requests. If it's not there (it's not yet on *any* call... :-)), the rpc client strictly sequences calls to an rpc pipe. Might need some more work on the exact sequencing semantics when a pipe with both sync and async calls is actually deployed, but I want it in for winbind simplification. Volker (This used to be commit b8f324e4f000971b7dafc263c16dd4af958ee7f9) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 5 +++++ source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 5 +++-- 2 files changed, 8 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index d0b6708bf6..8405873589 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -529,10 +529,14 @@ sub ParseFunction($$$) $rettype = $d->{RETURN_TYPE}; } + my $async = 0; + if (has_property($d, "async")) { $async = 1; } + return { NAME => $d->{NAME}, TYPE => "FUNCTION", OPNUM => $thisopnum, + ASYNC => $async, RETURN_TYPE => $rettype, PROPERTIES => $d->{PROPERTIES}, ELEMENTS => \@elements, @@ -744,6 +748,7 @@ my %property_list = ( "noopnum" => ["FUNCTION"], "in" => ["ELEMENT"], "out" => ["ELEMENT"], + "async" => ["FUNCTION"], # pointer "ref" => ["ELEMENT"], diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm index 0454f90c9a..05946b44f5 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm @@ -2160,11 +2160,12 @@ sub FunctionTable($) pidl "\t\tsizeof(struct $d->{NAME}),"; pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},"; pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},"; - pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}"; + pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME},"; + pidl "\t\t".($d->{ASYNC}?"True":"False").","; pidl "\t},"; $count++; } - pidl "\t{ NULL, 0, NULL, NULL, NULL }"; + pidl "\t{ NULL, 0, NULL, NULL, NULL, False }"; pidl "};"; pidl ""; -- cgit From df5b70db2c228bd781d8472440858dcdf502f9f9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 6 Nov 2005 13:53:37 +0000 Subject: r11535: Support void functions when generating templates. (This used to be commit e8926a4e171a7bf74c220fa825ef5fa9e297fa47) --- source4/pidl/lib/Parse/Pidl/Samba/Template.pm | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm index fea4b47dee..1960c89154 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm @@ -46,6 +46,7 @@ sub Template($) #include \"includes.h\" #include \"rpc_server/dcerpc_server.h\" #include \"librpc/gen_ndr/ndr_$name.h\" +#include \"rpc_server/common/common.h\" "; @@ -59,8 +60,15 @@ sub Template($) */ static $d->{RETURN_TYPE} $fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct $fname *r) -{ - DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR); +{"; + + if ($d->{RETURN_TYPE} eq "void") { + $res .= "DCESRV_FAULT_VOID(DCERPC_FAULT_OP_RNG_ERROR);\n"; + } else { + $res .= "DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);\n"; + } + + $res .= " } "; -- cgit From cca42c611a3f39b18395bcc40b097c65dd3469ae Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 6 Nov 2005 14:31:01 +0000 Subject: r11539: Fix indentation in templates. Always generate lower-case UUID strings as GUID_from_string seems to have trouble with uppercased ones. (This used to be commit 16ea96c81ed88f197007335f442c9e62b4ccd6de) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba/Template.pm | 10 +++++----- 4 files changed, 8 insertions(+), 8 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 8405873589..882ebeccb5 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -610,7 +610,7 @@ sub ParseInterface($) return { NAME => $idl->{NAME}, - UUID => has_property($idl, "uuid"), + UUID => lc(has_property($idl, "uuid")), VERSION => $version, TYPE => "INTERFACE", PROPERTIES => $idl->{PROPERTIES}, diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm index daf7ba0238..dd1848152e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm @@ -99,7 +99,7 @@ sub HeaderInterface($) if (defined $interface->{PROPERTIES}->{uuid}) { my $name = uc $interface->{NAME}; pidl "#define DCERPC_$name\_UUID " . - Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}) . "\n"; + Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})) . "\n"; if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; } pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm index 99982e4ad1..1ee497e206 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm @@ -76,7 +76,7 @@ sub Boilerplate_Iface($) my($interface) = shift; my $name = $interface->{NAME}; my $uname = uc $name; - my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}); + my $uuid = Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})); my $if_version = $interface->{PROPERTIES}->{version}; pidl " diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm index 1960c89154..52bc2b2d3d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm @@ -60,16 +60,16 @@ sub Template($) */ static $d->{RETURN_TYPE} $fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct $fname *r) -{"; +{ +"; if ($d->{RETURN_TYPE} eq "void") { - $res .= "DCESRV_FAULT_VOID(DCERPC_FAULT_OP_RNG_ERROR);\n"; + $res .= "\tDCESRV_FAULT_VOID(DCERPC_FAULT_OP_RNG_ERROR);\n"; } else { - $res .= "DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);\n"; + $res .= "\tDCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);\n"; } - $res .= " -} + $res .= "} "; } -- cgit From 6672d8aeaa50c7bb48a950248df7631a63d54845 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 29 Nov 2005 13:54:51 +0000 Subject: r11959: Use DOS_errors array for displaying WERROR values (This used to be commit 0830ed0d60cdbd00e6f42dae2c7e295363bca17d) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 24423d9292..24d6af8e60 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -709,7 +709,7 @@ sub ProcessInterface($) } if (defined($hf_used{"hf_$x->{NAME}_werror"})) { - register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "NULL", 0, ""); + register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "VALS(DOS_errors)", 0, ""); } RegisterInterface($x); -- cgit From 7da0f7d76da1d779f324486df568fe884bcf6328 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 30 Nov 2005 12:40:26 +0000 Subject: r11972: handle [noejs] property also on functions metze (This used to be commit e5fef8519b28f66ce8a401fc866c8b9bf08c584d) --- source4/pidl/lib/Parse/Pidl/Samba/EJS.pm | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm index 2cac7d81af..1e73696cc1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm @@ -713,7 +713,8 @@ sub EjsInterface($$) foreach my $d (@{$interface->{FUNCTIONS}}) { next if not defined($d->{OPNUM}); - + next if Parse::Pidl::Util::has_property($d, "noejs"); + EjsPullFunction($d); EjsPushFunction($d); EjsFunction($d, $name); -- cgit From a9cdc6321ac1aeafae6200afefd12f83c5786868 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 30 Nov 2005 17:07:02 +0000 Subject: r11974: only look at $pl->{POINTER_TYPE} when $pl is defined metze (This used to be commit 271d0af16d50bc89a384b56db70d569914273f6c) --- source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm index 05946b44f5..84f3091586 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm @@ -2019,15 +2019,14 @@ sub AllocateArrayLevel($$$$$) pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; pidl "\tNDR_PULL_ALLOC_N($ndr, $var, $size);"; pidl "}"; - } else { - pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);"; + if (grep(/in/,@{$e->{DIRECTION}}) and + grep(/out/,@{$e->{DIRECTION}})) { + pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));"; + } + return; } - if (grep(/in/,@{$e->{DIRECTION}}) and - grep(/out/,@{$e->{DIRECTION}}) and - $pl->{POINTER_TYPE} eq "ref") { - pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));"; - } + pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);"; } ##################################################################### -- cgit From f536c4a608bc8de3a9a0fd73f4c75f3183caa547 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 1 Dec 2005 12:39:33 +0000 Subject: r11997: for multidimentional array like this: uint32 [num_level2][num_level1][num_level0] fix the order they're pushed and pulled, it should be like this for (l2=0; l2 < num_level2; l2++) { for (l1=0; l1 < num_level1; l1++) { for (l0=0; l0 < num_level0; l0++) { ndr_pull_uint32(...); } } } metze (This used to be commit c10195f31383f51911edd8a32f8b5d5857d5bf2d) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 882ebeccb5..9ff69f8757 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -104,9 +104,10 @@ sub GetElementLevelTable($) if (defined($e->{ARRAY_LEN})) { @bracket_array = @{$e->{ARRAY_LEN}}; } - + # Parse the [][][][] style array stuff - foreach my $d (@bracket_array) { + for my $i (0 .. $#bracket_array) { + my $d = $bracket_array[$#bracket_array - $i]; my $size = $d; my $length = $d; my $is_surrounding = 0; -- cgit From 9e00afdcbe53895f73afb6eaa94b43ba79668012 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 11 Dec 2005 14:44:38 +0000 Subject: r12181: Use BASE_HEX rather then BASE_DEC by default for bitmaps. Patch by Guy Harris. Fixes #3313 (This used to be commit daff0cba2c8e4d56055673b1113e19c265a8bf63) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 24d6af8e60..40767ef535 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -226,7 +226,7 @@ sub Bitmap($$$) my $size = $e->{BASE_TYPE}; $size =~ s/uint//g; - register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$size", "BASE_DEC", "0", "NULL", $size/8); + register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$size", "BASE_HEX", "0", "NULL", $size/8); } sub ElementLevel($$$$$) -- cgit From 5352b3892832ca4055dd01a19b2093b4902dfd4c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 13 Dec 2005 01:56:04 +0000 Subject: r12205: Support 'TFS' command in conformance files (This used to be commit 3241ce7ad75a2f91327815374ad698e8bedb2e73) --- .../pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 22 +++++++++++++++++++++- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 9 +++++++-- 2 files changed, 28 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index 1b550ae1e7..12eb718586 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -70,6 +70,10 @@ Change description for the specified header field. `field' is the hf name of the Code to insert when generating the specified dissector. @HF@ and @PARAM@ will be substituted. +=item I hf_name "true string" "false string" + +Override the text shown when a bitmap boolean value is enabled or disabled. + =back =head1 EXAMPLE @@ -125,12 +129,27 @@ sub handle_type($$$$$$$$$$) }; } +sub handle_tfs($$$$$) +{ + my ($pos,$data,$hf,$trues,$falses) = @_; + + unless(defined($falses)) { + print "$pos: error: incomplete TFS command\n"; + return; + } + + $data->{tfs}->{$hf} = { + TRUE_STRING => $trues, + FALSE_STRING => $falses + }; +} + sub handle_hf_rename($$$$) { my ($pos,$data,$old,$new) = @_; unless(defined($new)) { - print "$pos: error incomplete HF_RENAME command\n"; + print "$pos: error: incomplete HF_RENAME command\n"; return; } @@ -272,6 +291,7 @@ my %field_handlers = ( PARAM_VALUE => \&handle_param_value, HF_FIELD => \&handle_hf_field, HF_RENAME => \&handle_hf_rename, + TFS => \&handle_tfs, STRIP_PREFIX => \&handle_strip_prefix, PROTOCOL => \&handle_protocol, FIELD_DESCRIPTION => \&handle_fielddescription, diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 40767ef535..7dc94763ea 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -203,8 +203,13 @@ sub Bitmap($$$) register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, ""); pidl_def "static const true_false_string $name\_$en\_tfs = {"; - pidl_def " \"$en is SET\","; - pidl_def " \"$en is NOT SET\","; + if (defined($conformance->{tfs}->{$hf_bitname})) { + pidl_def " $conformance->{tfs}->{$hf_bitname}->{TRUE_STRING},"; + pidl_def " $conformance->{tfs}->{$hf_bitname}->{FALSE_STRING},"; + } else { + pidl_def " \"$en is SET\","; + pidl_def " \"$en is NOT SET\","; + } pidl_def "};"; pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);"; -- cgit From a3b0f53f4762ee54179e367770acc85633853f13 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 13 Dec 2005 13:14:23 +0000 Subject: r12206: Fix some issues in NOEMIT (This used to be commit 905cebd117f3b05a286f014e2c21b0843e8f7caf) --- source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 7 +++---- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 9 ++++++++- 2 files changed, 11 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index 12eb718586..e3296c1629 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -232,10 +232,9 @@ sub handle_strip_prefix($$$) sub handle_noemit($$$) { - my ($pos,$data) = @_; - my $type; - - $type = shift if ($#_ == 1); + my $pos = shift; + my $data = shift; + my $type = shift; if (defined($type)) { $data->{noemit}->{$type} = 1; diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 7dc94763ea..b400d1ade0 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -22,6 +22,7 @@ use Parse::Pidl::Util qw(has_property ParseExpr property_matches make_str); use Parse::Pidl::NDR qw(ContainsString GetNextLevel); use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); use Parse::Pidl::Ethereal::Conformance qw(ReadConformance); +use File::Basename; use vars qw($VERSION); $VERSION = '0.01'; @@ -206,6 +207,7 @@ sub Bitmap($$$) if (defined($conformance->{tfs}->{$hf_bitname})) { pidl_def " $conformance->{tfs}->{$hf_bitname}->{TRUE_STRING},"; pidl_def " $conformance->{tfs}->{$hf_bitname}->{FALSE_STRING},"; + $conformance->{tfs}->{$hf_bitname}->{USED} = 1; } else { pidl_def " \"$en is SET\","; pidl_def " \"$en is NOT SET\","; @@ -827,7 +829,6 @@ sub Parse($$$$) $res{headers} .= "#include \"packet-dcerpc-nt.h\"\n"; $res{headers} .= "#include \"packet-windows-common.h\"\n"; - use File::Basename; my $h_basename = basename($h_filename); $res{headers} .= "#include \"$h_basename\"\n"; @@ -1009,6 +1010,12 @@ sub CheckUsed($) print "$_->{POS}: warning: description never used\n"; } } + + foreach (values %{$conformance->{tfs}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: True/False description never used\n"; + } + } } 1; -- cgit From e791dd73b98308b949f4ecfb91b5c87183b5de76 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 Dec 2005 21:57:51 +0000 Subject: r12462: Hide oo magic from callers of the parser (This used to be commit 0c225d2978b11898d334ec2d6da910e0cca0f4cd) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 153 ++++++++++++++++++++----------------- 1 file changed, 81 insertions(+), 72 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 59a9aef76a..c948f1af33 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -2108,19 +2108,19 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "pidl/idl.yp" +#line 19 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "pidl/idl.yp" +#line 20 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'coclass', 7, sub -#line 24 "pidl/idl.yp" +#line 24 "idl.yp" {$_[3] => { "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -2136,13 +2136,13 @@ sub [#Rule 6 'interface_names', 4, sub -#line 36 "pidl/idl.yp" +#line 36 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'interface', 8, sub -#line 40 "pidl/idl.yp" +#line 40 "idl.yp" {$_[3] => { "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -2159,19 +2159,19 @@ sub [#Rule 9 'base_interface', 2, sub -#line 53 "pidl/idl.yp" +#line 53 "idl.yp" { $_[2] } ], [#Rule 10 'definitions', 1, sub -#line 57 "pidl/idl.yp" +#line 57 "idl.yp" { [ $_[1] ] } ], [#Rule 11 'definitions', 2, sub -#line 58 "pidl/idl.yp" +#line 58 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 12 @@ -2192,7 +2192,7 @@ sub [#Rule 17 'const', 7, sub -#line 66 "pidl/idl.yp" +#line 66 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2206,7 +2206,7 @@ sub [#Rule 18 'const', 8, sub -#line 76 "pidl/idl.yp" +#line 76 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2221,7 +2221,7 @@ sub [#Rule 19 'function', 7, sub -#line 90 "pidl/idl.yp" +#line 90 "idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2235,7 +2235,7 @@ sub [#Rule 20 'declare', 5, sub -#line 102 "pidl/idl.yp" +#line 102 "idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2254,7 +2254,7 @@ sub [#Rule 23 'decl_enum', 1, sub -#line 116 "pidl/idl.yp" +#line 116 "idl.yp" {{ "TYPE" => "ENUM" }} @@ -2262,7 +2262,7 @@ sub [#Rule 24 'decl_bitmap', 1, sub -#line 122 "pidl/idl.yp" +#line 122 "idl.yp" {{ "TYPE" => "BITMAP" }} @@ -2270,7 +2270,7 @@ sub [#Rule 25 'typedef', 6, sub -#line 128 "pidl/idl.yp" +#line 128 "idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], @@ -2296,7 +2296,7 @@ sub [#Rule 30 'typedecl', 2, sub -#line 141 "pidl/idl.yp" +#line 141 "idl.yp" { $_[1] } ], [#Rule 31 @@ -2308,13 +2308,13 @@ sub [#Rule 33 'type', 1, sub -#line 144 "pidl/idl.yp" +#line 144 "idl.yp" { "void" } ], [#Rule 34 'enum', 5, sub -#line 148 "pidl/idl.yp" +#line 148 "idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], @@ -2324,13 +2324,13 @@ sub [#Rule 35 'enum_elements', 1, sub -#line 156 "pidl/idl.yp" +#line 156 "idl.yp" { [ $_[1] ] } ], [#Rule 36 'enum_elements', 3, sub -#line 157 "pidl/idl.yp" +#line 157 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 37 @@ -2339,13 +2339,13 @@ sub [#Rule 38 'enum_element', 3, sub -#line 161 "pidl/idl.yp" +#line 161 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 39 'bitmap', 5, sub -#line 165 "pidl/idl.yp" +#line 165 "idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], @@ -2355,25 +2355,25 @@ sub [#Rule 40 'bitmap_elements', 1, sub -#line 173 "pidl/idl.yp" +#line 173 "idl.yp" { [ $_[1] ] } ], [#Rule 41 'bitmap_elements', 3, sub -#line 174 "pidl/idl.yp" +#line 174 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 42 'bitmap_element', 3, sub -#line 177 "pidl/idl.yp" +#line 177 "idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 43 'struct', 5, sub -#line 181 "pidl/idl.yp" +#line 181 "idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], @@ -2383,7 +2383,7 @@ sub [#Rule 44 'empty_element', 2, sub -#line 189 "pidl/idl.yp" +#line 189 "idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2403,7 +2403,7 @@ sub [#Rule 47 'optional_base_element', 2, sub -#line 203 "pidl/idl.yp" +#line 203 "idl.yp" { $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 48 @@ -2412,13 +2412,13 @@ sub [#Rule 49 'union_elements', 2, sub -#line 208 "pidl/idl.yp" +#line 208 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 50 'union', 5, sub -#line 212 "pidl/idl.yp" +#line 212 "idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], @@ -2428,7 +2428,7 @@ sub [#Rule 51 'base_element', 5, sub -#line 220 "pidl/idl.yp" +#line 220 "idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2442,13 +2442,13 @@ sub [#Rule 52 'pointers', 0, sub -#line 234 "pidl/idl.yp" +#line 234 "idl.yp" { 0 } ], [#Rule 53 'pointers', 2, sub -#line 235 "pidl/idl.yp" +#line 235 "idl.yp" { $_[1]+1 } ], [#Rule 54 @@ -2457,7 +2457,7 @@ sub [#Rule 55 'element_list1', 3, sub -#line 240 "pidl/idl.yp" +#line 240 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 56 @@ -2469,13 +2469,13 @@ sub [#Rule 58 'element_list2', 1, sub -#line 246 "pidl/idl.yp" +#line 246 "idl.yp" { [ $_[1] ] } ], [#Rule 59 'element_list2', 3, sub -#line 247 "pidl/idl.yp" +#line 247 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 60 @@ -2484,13 +2484,13 @@ sub [#Rule 61 'array_len', 3, sub -#line 252 "pidl/idl.yp" +#line 252 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 62 'array_len', 4, sub -#line 253 "pidl/idl.yp" +#line 253 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 63 @@ -2499,31 +2499,31 @@ sub [#Rule 64 'property_list', 4, sub -#line 259 "pidl/idl.yp" +#line 259 "idl.yp" { Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); } ], [#Rule 65 'properties', 1, sub -#line 262 "pidl/idl.yp" +#line 262 "idl.yp" { $_[1] } ], [#Rule 66 'properties', 3, sub -#line 263 "pidl/idl.yp" +#line 263 "idl.yp" { Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); } ], [#Rule 67 'property', 1, sub -#line 266 "pidl/idl.yp" +#line 266 "idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 68 'property', 4, sub -#line 267 "pidl/idl.yp" +#line 267 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 69 @@ -2532,7 +2532,7 @@ sub [#Rule 70 'listtext', 3, sub -#line 272 "pidl/idl.yp" +#line 272 "idl.yp" { "$_[1] $_[3]" } ], [#Rule 71 @@ -2541,13 +2541,13 @@ sub [#Rule 72 'commalisttext', 3, sub -#line 277 "pidl/idl.yp" +#line 277 "idl.yp" { "$_[1],$_[3]" } ], [#Rule 73 'anytext', 0, sub -#line 281 "pidl/idl.yp" +#line 281 "idl.yp" { "" } ], [#Rule 74 @@ -2562,91 +2562,91 @@ sub [#Rule 77 'anytext', 3, sub -#line 283 "pidl/idl.yp" +#line 283 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 78 'anytext', 3, sub -#line 284 "pidl/idl.yp" +#line 284 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 79 'anytext', 3, sub -#line 285 "pidl/idl.yp" +#line 285 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 80 'anytext', 3, sub -#line 286 "pidl/idl.yp" +#line 286 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 81 'anytext', 3, sub -#line 287 "pidl/idl.yp" +#line 287 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 82 'anytext', 3, sub -#line 288 "pidl/idl.yp" +#line 288 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 83 'anytext', 3, sub -#line 289 "pidl/idl.yp" +#line 289 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 84 'anytext', 3, sub -#line 290 "pidl/idl.yp" +#line 290 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 85 'anytext', 3, sub -#line 291 "pidl/idl.yp" +#line 291 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 86 'anytext', 3, sub -#line 292 "pidl/idl.yp" +#line 292 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 87 'anytext', 3, sub -#line 293 "pidl/idl.yp" +#line 293 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 88 'anytext', 3, sub -#line 294 "pidl/idl.yp" +#line 294 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 89 'anytext', 3, sub -#line 295 "pidl/idl.yp" +#line 295 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 90 'anytext', 5, sub -#line 296 "pidl/idl.yp" +#line 296 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 91 'anytext', 5, sub -#line 297 "pidl/idl.yp" +#line 297 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 92 @@ -2664,7 +2664,7 @@ sub [#Rule 96 'text', 1, sub -#line 311 "pidl/idl.yp" +#line 311 "idl.yp" { "\"$_[1]\"" } ], [#Rule 97 @@ -2678,7 +2678,7 @@ sub bless($self,$class); } -#line 322 "pidl/idl.yp" +#line 322 "idl.yp" use Parse::Pidl::Util; @@ -2776,9 +2776,24 @@ again: } } -sub parse_idl($$) +sub parse_string($) { - my ($self,$filename) = @_; + my ($data) = @_; + + my $self = new Parse::Pidl::IDL; + + $self->YYData->{INPUT} = $data; + $self->YYData->{LINE} = 0; + $self->YYData->{LAST_TOKEN} = "NONE"; + + my $idl = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error ); + + return CleanData($idl); +} + +sub parse_file($) +{ + my ($filename) = @_; my $saved_delim = $/; undef $/; @@ -2789,13 +2804,7 @@ sub parse_idl($$) my $data = `$cpp -D__PIDL__ -xc $filename`; $/ = $saved_delim; - $self->YYData->{INPUT} = $data; - $self->YYData->{LINE} = 0; - $self->YYData->{LAST_TOKEN} = "NONE"; - - my $idl = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error ); - - return CleanData($idl); + return parse_string($data); } 1; -- cgit From ebfbb2a7abe33e47af48d69164c37f4c24b7f8ed Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 Dec 2005 22:11:44 +0000 Subject: r12463: Rename 'Samba' namespace to 'Samba4' (This used to be commit f25358270d44a5642adbb85ecaa50b2e5730d7f0) --- source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm | 142 -- source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm | 215 -- source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm | 327 --- source4/pidl/lib/Parse/Pidl/Samba/EJS.pm | 839 -------- source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm | 79 - source4/pidl/lib/Parse/Pidl/Samba/Header.pm | 361 ---- source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm | 102 - source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm | 169 -- source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm | 2389 ---------------------- source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm | 325 --- source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm | 79 - source4/pidl/lib/Parse/Pidl/Samba/TDR.pm | 280 --- source4/pidl/lib/Parse/Pidl/Samba/Template.pm | 99 - source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm | 142 ++ source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm | 215 ++ source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm | 327 +++ source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 839 ++++++++ source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm | 79 + source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 361 ++++ source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 102 + source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm | 169 ++ source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 2389 ++++++++++++++++++++++ source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 325 +++ source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 79 + source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 280 +++ source4/pidl/lib/Parse/Pidl/Samba4/Template.pm | 99 + 26 files changed, 5406 insertions(+), 5406 deletions(-) delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/EJS.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/Header.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/TDR.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba/Template.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/Header.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/Template.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm deleted file mode 100644 index 0289a688ba..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/COM/Header.pm +++ /dev/null @@ -1,142 +0,0 @@ -# COM Header generation -# (C) 2005 Jelmer Vernooij - -package Parse::Pidl::Samba::COM::Header; - -use Parse::Pidl::Typelist; -use Parse::Pidl::Util qw(has_property); - -use vars qw($VERSION); -$VERSION = '0.01'; - -use strict; - -sub GetArgumentProtoList($) -{ - my $f = shift; - my $res = ""; - - foreach my $a (@{$f->{ELEMENTS}}) { - - $res .= ", " . Parse::Pidl::Typelist::mapType($a->{TYPE}) . " "; - - my $l = $a->{POINTERS}; - $l-- if (Parse::Pidl::Typelist::scalar_is_reference($a->{TYPE})); - foreach my $i (1..$l) { - $res .= "*"; - } - - if (defined $a->{ARRAY_LEN}[0] && - !Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0]) && - !$a->{POINTERS}) { - $res .= "*"; - } - $res .= $a->{NAME}; - if (defined $a->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0])) { - $res .= "[$a->{ARRAY_LEN}[0]]"; - } - } - - return $res; -} - -sub GetArgumentList($) -{ - my $f = shift; - my $res = ""; - - foreach my $a (@{$f->{ELEMENTS}}) { - $res .= ", $a->{NAME}"; - } - - return $res; -} - -##################################################################### -# generate vtable structure for COM interface -sub HeaderVTable($) -{ - my $interface = shift; - my $res; - $res .= "#define " . uc($interface->{NAME}) . "_METHODS \\\n"; - if (defined($interface->{BASE})) { - $res .= "\t" . uc($interface->{BASE} . "_METHODS") . "\\\n"; - } - - my $data = $interface->{DATA}; - foreach my $d (@{$data}) { - $res .= "\t" . Parse::Pidl::Typelist::mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION"); - } - $res .= "\n"; - $res .= "struct $interface->{NAME}_vtable {\n"; - $res .= "\tstruct GUID iid;\n"; - $res .= "\t" . uc($interface->{NAME}) . "_METHODS\n"; - $res .= "};\n\n"; - - return $res; -} - -sub ParseInterface($) -{ - my $if = shift; - my $res; - - $res .="\n\n/* $if->{NAME} */\n"; - - $res .="#define COM_" . uc($if->{NAME}) . "_UUID $if->{PROPERTIES}->{uuid}\n\n"; - - $res .="struct $if->{NAME}_vtable;\n\n"; - - $res .="struct $if->{NAME} { - struct com_context *ctx; - struct $if->{NAME}_vtable *vtable; - void *object_data; -};\n\n"; - - $res.=HeaderVTable($if); - - foreach my $d (@{$if->{DATA}}) { - next if ($d->{TYPE} ne "FUNCTION"); - - $res .= "#define $if->{NAME}_$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . ") "; - - $res .= "((interface)->vtable->$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . "))"; - - $res .="\n"; - } - - return $res; -} - -sub ParseCoClass($) -{ - my $c = shift; - my $res = ""; - $res .= "#define CLSID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{uuid}\n"; - if (has_property($c, "progid")) { - $res .= "#define PROGID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{progid}\n"; - } - $res .= "\n"; - return $res; -} - -sub Parse($) -{ - my $idl = shift; - my $res = ""; - - foreach my $x (@{$idl}) - { - if ($x->{TYPE} eq "INTERFACE" && has_property($x, "object")) { - $res.=ParseInterface($x); - } - - if ($x->{TYPE} eq "COCLASS") { - $res.=ParseCoClass($x); - } - } - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm deleted file mode 100644 index ab56d87492..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/COM/Proxy.pm +++ /dev/null @@ -1,215 +0,0 @@ -################################################### -# DCOM parser for Samba -# Basically the glue between COM and DCE/RPC with NDR -# Copyright jelmer@samba.org 2003-2005 -# released under the GNU GPL - -package Parse::Pidl::Samba::COM::Proxy; - -use Parse::Pidl::Samba::COM::Header; -use Parse::Pidl::Util qw(has_property); - -use vars qw($VERSION); -$VERSION = '0.01'; - -use strict; - -my($res); - -sub ParseVTable($$) -{ - my $interface = shift; - my $name = shift; - - # Generate the vtable - $res .="\tstruct $interface->{NAME}_vtable $name = {"; - - if (defined($interface->{BASE})) { - $res .= "\n\t\t{},"; - } - - my $data = $interface->{DATA}; - - foreach my $d (@{$data}) { - if ($d->{TYPE} eq "FUNCTION") { - $res .= "\n\t\tdcom_proxy_$interface->{NAME}_$d->{NAME}"; - $res .= ","; - } - } - - $res .= "\n\t};\n\n"; -} - -sub ParseRegFunc($) -{ - my $interface = shift; - - $res .= "static NTSTATUS dcom_proxy_$interface->{NAME}_init(void) -{ - struct GUID base_iid; - struct $interface->{NAME}_vtable *proxy_vtable = talloc(talloc_autofree_context(), struct $interface->{NAME}_vtable); -"; - - if (defined($interface->{BASE})) { - $res.= " - const void *base_vtable; - - GUID_from_string(DCERPC_" . (uc $interface->{BASE}) . "_UUID, &base_iid); - - base_vtable = dcom_proxy_vtable_by_iid(&base_iid); - if (base_vtable == NULL) { - DEBUG(0, (\"No proxy registered for base interface '$interface->{BASE}'\\n\")); - return NT_STATUS_FOOBAR; - } - - memcpy(&proxy_vtable, base_vtable, sizeof(struct $interface->{BASE}_vtable)); - -"; - } - foreach my $x (@{$interface->{DATA}}) { - next unless ($x->{TYPE} eq "FUNCTION"); - - $res .= "\tproxy_vtable.$x->{NAME} = dcom_proxy_$interface->{NAME}_$x->{NAME};\n"; - } - - $res.= " - GUID_from_string(DCERPC_" . (uc $interface->{NAME}) . "_UUID, &proxy_vtable.iid); - - return dcom_register_proxy(&proxy_vtable); -}\n\n"; -} - -##################################################################### -# parse a function -sub ParseFunction($$) -{ - my $interface = shift; - my $fn = shift; - my $name = $fn->{NAME}; - my $uname = uc $name; - - $res.=" -static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . Parse::Pidl::Samba::COM::Header::GetArgumentProtoList($fn) . ") -{ - struct dcerpc_pipe *p; - NTSTATUS status = dcom_get_pipe(d, &p); - struct $name r; - struct rpc_request *req; - - if (NT_STATUS_IS_ERR(status)) { - return status; - } - - ZERO_STRUCT(r.in.ORPCthis); - r.in.ORPCthis.version.MajorVersion = COM_MAJOR_VERSION; - r.in.ORPCthis.version.MinorVersion = COM_MINOR_VERSION; -"; - - # Put arguments into r - foreach my $a (@{$fn->{ELEMENTS}}) { - next unless (has_property($a, "in")); - if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) { - $res .="\tNDR_CHECK(dcom_OBJREF_from_IUnknown(&r.in.$a->{NAME}.obj, $a->{NAME}));\n"; - } else { - $res .= "\tr.in.$a->{NAME} = $a->{NAME};\n"; - } - } - - $res .=" - if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) { - NDR_PRINT_IN_DEBUG($name, &r); - } - - status = dcerpc_ndr_request(p, &d->ipid, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, &r); - - if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { - NDR_PRINT_OUT_DEBUG($name, r); - } - -"; - - # Put r info back into arguments - foreach my $a (@{$fn->{ELEMENTS}}) { - next unless (has_property($a, "out")); - - if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) { - $res .="\tNDR_CHECK(dcom_IUnknown_from_OBJREF(d->ctx, &$a->{NAME}, r.out.$a->{NAME}.obj));\n"; - } else { - $res .= "\t*$a->{NAME} = r.out.$a->{NAME};\n"; - } - - } - - if ($fn->{RETURN_TYPE} eq "NTSTATUS") { - $res .= "\tif (NT_STATUS_IS_OK(status)) status = r.out.result;\n"; - } - - $res .= - " - return r.out.result; -}\n\n"; -} - -##################################################################### -# parse the interface definitions -sub ParseInterface($) -{ - my($interface) = shift; - my($data) = $interface->{DATA}; - $res = "/* DCOM proxy for $interface->{NAME} generated by pidl */\n\n"; - foreach my $d (@{$data}) { - ($d->{TYPE} eq "FUNCTION") && - ParseFunction($interface, $d); - } - - ParseRegFunc($interface); -} - -sub RegistrationFunction($$) -{ - my $idl = shift; - my $basename = shift; - - my $res = "\n\nNTSTATUS dcom_$basename\_init(void)\n"; - $res .= "{\n"; - $res .="\tNTSTATUS status = NT_STATUS_OK;\n"; - foreach my $interface (@{$idl}) { - next if $interface->{TYPE} ne "INTERFACE"; - next if not has_property($interface, "object"); - - my $data = $interface->{DATA}; - my $count = 0; - foreach my $d (@{$data}) { - if ($d->{TYPE} eq "FUNCTION") { $count++; } - } - - next if ($count == 0); - - $res .= "\tstatus = dcom_$interface->{NAME}_init();\n"; - $res .= "\tif (NT_STATUS_IS_ERR(status)) {\n"; - $res .= "\t\treturn status;\n"; - $res .= "\t}\n\n"; - } - $res .= "\treturn status;\n"; - $res .= "}\n\n"; - - return $res; -} - -sub Parse($) -{ - my $pidl = shift; - my $res = ""; - - foreach my $x (@{$pidl}) { - next if ($x->{TYPE} ne "INTERFACE"); - next if has_property($x, "local"); - next unless has_property($x, "object"); - - $res .= ParseInterface($x); - } - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm b/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm deleted file mode 100644 index 17b33a6872..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/COM/Stub.pm +++ /dev/null @@ -1,327 +0,0 @@ -################################################### -# DCOM stub boilerplate generator -# Copyright jelmer@samba.org 2004-2005 -# Copyright tridge@samba.org 2003 -# Copyright metze@samba.org 2004 -# released under the GNU GPL - -package Parse::Pidl::Samba::COM::Stub; - -use Parse::Pidl::Util qw(has_property); -use strict; - -use vars qw($VERSION); -$VERSION = '0.01'; - -my($res); - -sub pidl($) -{ - $res .= shift; -} - -##################################################### -# generate the switch statement for function dispatch -sub gen_dispatch_switch($) -{ - my $data = shift; - - my $count = 0; - foreach my $d (@{$data}) { - next if ($d->{TYPE} ne "FUNCTION"); - - pidl "\tcase $count: {\n"; - if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") { - pidl "\t\tNTSTATUS result;\n"; - } - pidl "\t\tstruct $d->{NAME} *r2 = r;\n"; - pidl "\t\tif (DEBUGLEVEL > 10) {\n"; - pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_IN, r2);\n"; - pidl "\t\t}\n"; - if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") { - pidl "\t\tresult = vtable->$d->{NAME}(iface, mem_ctx, r2);\n"; - } else { - pidl "\t\tvtable->$d->{NAME}(iface, mem_ctx, r2);\n"; - } - pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; - pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} will reply async\\n\"));\n"; - pidl "\t\t}\n"; - pidl "\t\tbreak;\n\t}\n"; - $count++; - } -} - -##################################################### -# generate the switch statement for function reply -sub gen_reply_switch($) -{ - my $data = shift; - - my $count = 0; - foreach my $d (@{$data}) { - next if ($d->{TYPE} ne "FUNCTION"); - - pidl "\tcase $count: {\n"; - pidl "\t\tstruct $d->{NAME} *r2 = r;\n"; - pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; - pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} replied async\\n\"));\n"; - pidl "\t\t}\n"; - pidl "\t\tif (DEBUGLEVEL > 10 && dce_call->fault_code == 0) {\n"; - pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n"; - pidl "\t\t}\n"; - pidl "\t\tif (dce_call->fault_code != 0) {\n"; - pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $d->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n"; - pidl "\t\t}\n"; - pidl "\t\tbreak;\n\t}\n"; - $count++; - } -} - -##################################################################### -# produce boilerplate code for a interface -sub Boilerplate_Iface($) -{ - my($interface) = shift; - my($data) = $interface->{DATA}; - my $name = $interface->{NAME}; - my $uname = uc $name; - my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}); - my $if_version = $interface->{PROPERTIES}->{version}; - - pidl " -static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface) -{ -#ifdef DCESRV_INTERFACE_$uname\_BIND - return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface); -#else - return NT_STATUS_OK; -#endif -} - -static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface) -{ -#ifdef DCESRV_INTERFACE_$uname\_UNBIND - DCESRV_INTERFACE_$uname\_UNBIND(context, iface); -#else - return; -#endif -} - -static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r) -{ - NTSTATUS status; - uint16_t opnum = dce_call->pkt.u.request.opnum; - - dce_call->fault_code = 0; - - if (opnum >= dcerpc_table_$name.num_calls) { - dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; - return NT_STATUS_NET_WRITE_FAULT; - } - - *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size); - NT_STATUS_HAVE_NO_MEMORY(*r); - - /* unravel the NDR for the packet */ - status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); - if (!NT_STATUS_IS_OK(status)) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, - &dce_call->pkt.u.request.stub_and_verifier); - dce_call->fault_code = DCERPC_FAULT_NDR; - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) -{ - uint16_t opnum = dce_call->pkt.u.request.opnum; - struct GUID ipid = dce_call->pkt.u.request.object.object; - struct dcom_interface_p *iface = dcom_get_local_iface_p(&ipid); - const struct dcom_$name\_vtable *vtable = iface->vtable; - - switch (opnum) { -"; - gen_dispatch_switch($data); - -pidl " - default: - dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; - break; - } - - if (dce_call->fault_code != 0) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, - &dce_call->pkt.u.request.stub_and_verifier); - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) -{ - uint16_t opnum = dce_call->pkt.u.request.opnum; - - switch (opnum) { -"; - gen_reply_switch($data); - -pidl " - default: - dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; - break; - } - - if (dce_call->fault_code != 0) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, - &dce_call->pkt.u.request.stub_and_verifier); - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r) -{ - NTSTATUS status; - uint16_t opnum = dce_call->pkt.u.request.opnum; - - status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); - if (!NT_STATUS_IS_OK(status)) { - dce_call->fault_code = DCERPC_FAULT_NDR; - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static const struct dcesrv_interface $name\_interface = { - .name = \"$name\", - .uuid = $uuid, - .if_version = $if_version, - .bind = $name\__op_bind, - .unbind = $name\__op_unbind, - .ndr_pull = $name\__op_ndr_pull, - .dispatch = $name\__op_dispatch, - .reply = $name\__op_reply, - .ndr_push = $name\__op_ndr_push -}; - -"; -} - -##################################################################### -# produce boilerplate code for an endpoint server -sub Boilerplate_Ep_Server($) -{ - my($interface) = shift; - my $name = $interface->{NAME}; - my $uname = uc $name; - - pidl " -static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server) -{ - int i; - - for (i=0;icount;i++) { - NTSTATUS ret; - const char *name = dcerpc_table_$name.endpoints->names[i]; - - ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL); - if (!NT_STATUS_IS_OK(ret)) { - DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name)); - return ret; - } - } - - return NT_STATUS_OK; -} - -static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version) -{ - if (dcerpc_table_$name.if_version == if_version && - strcmp(dcerpc_table_$name.uuid, uuid)==0) { - memcpy(iface,&dcerpc_table_$name, sizeof(*iface)); - return True; - } - - return False; -} - -static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) -{ - if (strcmp(dcerpc_table_$name.name, name)==0) { - memcpy(iface,&dcerpc_table_$name, sizeof(*iface)); - return True; - } - - return False; -} - -NTSTATUS dcerpc_server_$name\_init(void) -{ - NTSTATUS ret; - struct dcesrv_endpoint_server ep_server; - - /* fill in our name */ - ep_server.name = \"$name\"; - - /* fill in all the operations */ - ep_server.init_server = $name\__op_init_server; - - ep_server.interface_by_uuid = $name\__op_interface_by_uuid; - ep_server.interface_by_name = $name\__op_interface_by_name; - - /* register ourselves with the DCERPC subsystem. */ - ret = dcerpc_register_ep_server(&ep_server); - - if (!NT_STATUS_IS_OK(ret)) { - DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\")); - return ret; - } - - return ret; -} - -"; -} - -##################################################################### -# dcom interface stub from a parsed IDL structure -sub ParseInterface($) -{ - my($interface) = shift; - - return "" if has_property($interface, "local"); - - my($data) = $interface->{DATA}; - my $count = 0; - - $res = ""; - - if (!defined $interface->{PROPERTIES}->{uuid}) { - return $res; - } - - if (!defined $interface->{PROPERTIES}->{version}) { - $interface->{PROPERTIES}->{version} = "0.0"; - } - - foreach my $d (@{$data}) { - if ($d->{TYPE} eq "FUNCTION") { $count++; } - } - - if ($count == 0) { - return $res; - } - - $res = "/* dcom interface stub generated by pidl */\n\n"; - Boilerplate_Iface($interface); - Boilerplate_Ep_Server($interface); - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm deleted file mode 100644 index 1e73696cc1..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/EJS.pm +++ /dev/null @@ -1,839 +0,0 @@ -################################################### -# EJS function wrapper generator -# Copyright jelmer@samba.org 2005 -# Copyright Andrew Tridgell 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba::EJS; - -use strict; -use Parse::Pidl::Typelist; -use Parse::Pidl::Util qw(has_property); - -use vars qw($VERSION); -$VERSION = '0.01'; - -my($res); -my %constants; - -my $tabs = ""; -sub pidl($) -{ - my $d = shift; - if ($d) { - $res .= $tabs; - $res .= $d; - } - $res .= "\n"; -} - -sub indent() -{ - $tabs .= "\t"; -} - -sub deindent() -{ - $tabs = substr($tabs, 0, -1); -} - -# this should probably be in ndr.pm -sub GenerateStructEnv($) -{ - my $x = shift; - my %env; - - foreach my $e (@{$x->{ELEMENTS}}) { - if ($e->{NAME}) { - $env{$e->{NAME}} = "r->$e->{NAME}"; - } - } - - $env{"this"} = "r"; - - return \%env; -} - -sub GenerateFunctionInEnv($) -{ - my $fn = shift; - my %env; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->in.$e->{NAME}"; - } - } - - return \%env; -} - -sub GenerateFunctionOutEnv($) -{ - my $fn = shift; - my %env; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/out/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->out.$e->{NAME}"; - } elsif (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->in.$e->{NAME}"; - } - } - - return \%env; -} - -sub get_pointer_to($) -{ - my $var_name = shift; - - if ($var_name =~ /^\*(.*)$/) { - return $1; - } elsif ($var_name =~ /^\&(.*)$/) { - return "&($var_name)"; - } else { - return "&$var_name"; - } -} - -sub get_value_of($) -{ - my $var_name = shift; - - if ($var_name =~ /^\&(.*)$/) { - return $1; - } else { - return "*$var_name"; - } -} - -##################################################################### -# work out is a parse function should be declared static or not -sub fn_prefix($) -{ - my $fn = shift; - - return "" if (has_property($fn, "public")); - return "static "; -} - -########################### -# pull a scalar element -sub EjsPullScalar($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - - return if (has_property($e, "value")); - - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); - $var = get_pointer_to($var); - # have to handle strings specially :( - if ($e->{TYPE} eq "string" && $pl && $pl->{TYPE} eq "POINTER") { - $var = get_pointer_to($var); - } - pidl "NDR_CHECK(ejs_pull_$e->{TYPE}(ejs, v, $name, $var));"; -} - -########################### -# pull a pointer element -sub EjsPullPointer($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - pidl "if (ejs_pull_null(ejs, v, $name)) {"; - indent; - pidl "$var = NULL;"; - deindent; - pidl "} else {"; - indent; - pidl "EJS_ALLOC(ejs, $var);"; - $var = get_value_of($var); - EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); - deindent; - pidl "}"; -} - -########################### -# pull a string element -sub EjsPullString($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - $var = get_pointer_to($var); - pidl "NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));"; -} - - -########################### -# pull an array element -sub EjsPullArray($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); - my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env); - my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env); - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); - if ($pl && $pl->{TYPE} eq "POINTER") { - $var = get_pointer_to($var); - } - # uint8 arrays are treated as data blobs - if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { - if (!$l->{IS_FIXED}) { - pidl "EJS_ALLOC_N(ejs, $var, $size);"; - } - pidl "ejs_pull_array_uint8(ejs, v, $name, $var, $length);"; - return; - } - my $avar = $var . "[i]"; - pidl "{"; - indent; - pidl "uint32_t i;"; - if (!$l->{IS_FIXED}) { - pidl "EJS_ALLOC_N(ejs, $var, $size);"; - } - pidl "for (i=0;i<$length;i++) {"; - indent; - pidl "char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"; - EjsPullElement($e, $nl, $avar, "id", $env); - pidl "talloc_free(id);"; - deindent; - pidl "}"; - pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);"; - deindent; - pidl "}"; -} - -########################### -# pull a switch element -sub EjsPullSwitch($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env); - pidl "ejs_set_switch(ejs, $switch_var);"; - EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); -} - -########################### -# pull a structure element -sub EjsPullElement($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - if (has_property($e, "charset")) { - EjsPullString($e, $l, $var, $name, $env); - } elsif ($l->{TYPE} eq "ARRAY") { - EjsPullArray($e, $l, $var, $name, $env); - } elsif ($l->{TYPE} eq "DATA") { - EjsPullScalar($e, $l, $var, $name, $env); - } elsif (($l->{TYPE} eq "POINTER")) { - EjsPullPointer($e, $l, $var, $name, $env); - } elsif (($l->{TYPE} eq "SWITCH")) { - EjsPullSwitch($e, $l, $var, $name, $env); - } else { - pidl "return ejs_panic(ejs, \"unhandled pull type $l->{TYPE}\");"; - } -} - -############################################# -# pull a structure/union element at top level -sub EjsPullElementTop($$) -{ - my $e = shift; - my $env = shift; - my $l = $e->{LEVELS}[0]; - my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env); - my $name = "\"$e->{NAME}\""; - EjsPullElement($e, $l, $var, $name, $env); -} - -########################### -# pull a struct -sub EjsStructPull($$) -{ - my $name = shift; - my $d = shift; - my $env = GenerateStructEnv($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)\n{"; - indent; - pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; - foreach my $e (@{$d->{ELEMENTS}}) { - EjsPullElementTop($e, $env); - } - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; -} - -########################### -# pull a union -sub EjsUnionPull($$) -{ - my $name = shift; - my $d = shift; - my $have_default = 0; - my $env = GenerateStructEnv($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)\n{"; - indent; - pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; - pidl "switch (ejs->switch_var) {"; - indent; - foreach my $e (@{$d->{ELEMENTS}}) { - if ($e->{CASE} eq "default") { - $have_default = 1; - } - pidl "$e->{CASE}:"; - indent; - if ($e->{TYPE} ne "EMPTY") { - EjsPullElementTop($e, $env); - } - pidl "break;"; - deindent; - } - if (! $have_default) { - pidl "default:"; - indent; - pidl "return ejs_panic(ejs, \"Bad switch value\");"; - deindent; - } - deindent; - pidl "}"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; -} - -############################################## -# put the enum elements in the constants array -sub EjsEnumConstant($) -{ - my $d = shift; - my $v = 0; - foreach my $e (@{$d->{ELEMENTS}}) { - my $el = $e; - chomp $el; - if ($el =~ /^(.*)=\s*(.*)\s*$/) { - $el = $1; - $v = $2; - } - $constants{$el} = $v; - $v++; - } -} - -########################### -# pull a enum -sub EjsEnumPull($$) -{ - my $name = shift; - my $d = shift; - EjsEnumConstant($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)\n{"; - indent; - pidl "unsigned e;"; - pidl "NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));"; - pidl "*r = e;"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; -} - -########################### -# pull a bitmap -sub EjsBitmapPull($$) -{ - my $name = shift; - my $d = shift; - my $type_fn = $d->{BASE_TYPE}; - my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE}); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)\n{"; - indent; - pidl "return ejs_pull_$type_fn(ejs, v, name, r);"; - deindent; - pidl "}"; -} - - -########################### -# generate a structure pull -sub EjsTypedefPull($) -{ - my $d = shift; - return if (has_property($d, "noejs")); - if ($d->{DATA}->{TYPE} eq 'STRUCT') { - EjsStructPull($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'UNION') { - EjsUnionPull($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'ENUM') { - EjsEnumPull($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') { - EjsBitmapPull($d->{NAME}, $d->{DATA}); - } else { - warn "Unhandled pull typedef $d->{NAME} of type $d->{DATA}->{TYPE}"; - } -} - -##################### -# generate a function -sub EjsPullFunction($) -{ - my $d = shift; - my $env = GenerateFunctionInEnv($d); - my $name = $d->{NAME}; - - pidl "\nstatic NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, struct $name *r)"; - pidl "{"; - indent; - pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));"; - - # we pull non-array elements before array elements as arrays - # may have length_is() or size_is() properties that depend - # on the non-array elements - foreach my $e (@{$d->{ELEMENTS}}) { - next unless (grep(/in/, @{$e->{DIRECTION}})); - next if (has_property($e, "length_is") || - has_property($e, "size_is")); - EjsPullElementTop($e, $env); - } - - foreach my $e (@{$d->{ELEMENTS}}) { - next unless (grep(/in/, @{$e->{DIRECTION}})); - next unless (has_property($e, "length_is") || - has_property($e, "size_is")); - EjsPullElementTop($e, $env); - } - - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; -} - - -########################### -# push a scalar element -sub EjsPushScalar($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - # have to handle strings specially :( - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); - if ($e->{TYPE} ne "string" || ($pl && $pl->{TYPE} eq "POINTER")) { - $var = get_pointer_to($var); - } - pidl "NDR_CHECK(ejs_push_$e->{TYPE}(ejs, v, $name, $var));"; -} - -########################### -# push a string element -sub EjsPushString($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - pidl "NDR_CHECK(ejs_push_string(ejs, v, $name, $var));"; -} - -########################### -# push a pointer element -sub EjsPushPointer($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - pidl "if (NULL == $var) {"; - indent; - pidl "NDR_CHECK(ejs_push_null(ejs, v, $name));"; - deindent; - pidl "} else {"; - indent; - $var = get_value_of($var); - EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); - deindent; - pidl "}"; -} - -########################### -# push a switch element -sub EjsPushSwitch($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env); - pidl "ejs_set_switch(ejs, $switch_var);"; - EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); -} - - -########################### -# push an array element -sub EjsPushArray($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); - my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env); - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); - if ($pl && $pl->{TYPE} eq "POINTER") { - $var = get_pointer_to($var); - } - # uint8 arrays are treated as data blobs - if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { - pidl "ejs_push_array_uint8(ejs, v, $name, $var, $length);"; - return; - } - my $avar = $var . "[i]"; - pidl "{"; - indent; - pidl "uint32_t i;"; - pidl "for (i=0;i<$length;i++) {"; - indent; - pidl "const char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"; - EjsPushElement($e, $nl, $avar, "id", $env); - deindent; - pidl "}"; - pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);"; - deindent; - pidl "}"; -} - -################################ -# push a structure/union element -sub EjsPushElement($$$$$) -{ - my ($e, $l, $var, $name, $env) = @_; - if (has_property($e, "charset")) { - EjsPushString($e, $l, $var, $name, $env); - } elsif ($l->{TYPE} eq "ARRAY") { - EjsPushArray($e, $l, $var, $name, $env); - } elsif ($l->{TYPE} eq "DATA") { - EjsPushScalar($e, $l, $var, $name, $env); - } elsif (($l->{TYPE} eq "POINTER")) { - EjsPushPointer($e, $l, $var, $name, $env); - } elsif (($l->{TYPE} eq "SWITCH")) { - EjsPushSwitch($e, $l, $var, $name, $env); - } else { - pidl "return ejs_panic(ejs, \"unhandled push type $l->{TYPE}\");"; - } -} - -############################################# -# push a structure/union element at top level -sub EjsPushElementTop($$) -{ - my $e = shift; - my $env = shift; - my $l = $e->{LEVELS}[0]; - my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env); - my $name = "\"$e->{NAME}\""; - EjsPushElement($e, $l, $var, $name, $env); -} - -########################### -# push a struct -sub EjsStructPush($$) -{ - my $name = shift; - my $d = shift; - my $env = GenerateStructEnv($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)\n{"; - indent; - pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; - foreach my $e (@{$d->{ELEMENTS}}) { - EjsPushElementTop($e, $env); - } - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; -} - -########################### -# push a union -sub EjsUnionPush($$) -{ - my $name = shift; - my $d = shift; - my $have_default = 0; - my $env = GenerateStructEnv($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)\n{"; - indent; - pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; - pidl "switch (ejs->switch_var) {"; - indent; - foreach my $e (@{$d->{ELEMENTS}}) { - if ($e->{CASE} eq "default") { - $have_default = 1; - } - pidl "$e->{CASE}:"; - indent; - if ($e->{TYPE} ne "EMPTY") { - EjsPushElementTop($e, $env); - } - pidl "break;"; - deindent; - } - if (! $have_default) { - pidl "default:"; - indent; - pidl "return ejs_panic(ejs, \"Bad switch value\");"; - deindent; - } - deindent; - pidl "}"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; -} - -########################### -# push a enum -sub EjsEnumPush($$) -{ - my $name = shift; - my $d = shift; - EjsEnumConstant($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)\n{"; - indent; - pidl "unsigned e = *r;"; - pidl "NDR_CHECK(ejs_push_enum(ejs, v, name, &e));"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; -} - -########################### -# push a bitmap -sub EjsBitmapPush($$) -{ - my $name = shift; - my $d = shift; - my $type_fn = $d->{BASE_TYPE}; - my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE}); - # put the bitmap elements in the constants array - foreach my $e (@{$d->{ELEMENTS}}) { - if ($e =~ /^(\w*)\s*(.*)\s*$/) { - my $bname = $1; - my $v = $2; - $constants{$bname} = $v; - } - } - pidl fn_prefix($d); - pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)\n{"; - indent; - pidl "return ejs_push_$type_fn(ejs, v, name, r);"; - deindent; - pidl "}"; -} - - -########################### -# generate a structure push -sub EjsTypedefPush($) -{ - my $d = shift; - return if (has_property($d, "noejs")); - if ($d->{DATA}->{TYPE} eq 'STRUCT') { - EjsStructPush($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'UNION') { - EjsUnionPush($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'ENUM') { - EjsEnumPush($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') { - EjsBitmapPush($d->{NAME}, $d->{DATA}); - } else { - warn "Unhandled push typedef $d->{NAME} of type $d->{DATA}->{TYPE}"; - } -} - - -##################### -# generate a function -sub EjsPushFunction($) -{ - my $d = shift; - my $env = GenerateFunctionOutEnv($d); - - pidl "\nstatic NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const struct $d->{NAME} *r)"; - pidl "{"; - indent; - pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));"; - - foreach my $e (@{$d->{ELEMENTS}}) { - next unless (grep(/out/, @{$e->{DIRECTION}})); - EjsPushElementTop($e, $env); - } - - if ($d->{RETURN_TYPE}) { - my $t = $d->{RETURN_TYPE}; - pidl "NDR_CHECK(ejs_push_$t(ejs, v, \"result\", &r->out.result));"; - } - - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; -} - - -################################# -# generate a ejs mapping function -sub EjsFunction($$) -{ - my $d = shift; - my $iface = shift; - my $name = $d->{NAME}; - my $callnum = uc("DCERPC_$name"); - my $table = "&dcerpc_table_$iface"; - - pidl "static int ejs_$name(int eid, int argc, struct MprVar **argv)"; - pidl "{"; - indent; - pidl "return ejs_rpc_call(eid, argc, argv, $table, $callnum, (ejs_pull_function_t)ejs_pull_$name, (ejs_push_function_t)ejs_push_$name);"; - deindent; - pidl "}\n"; -} - -################### -# handle a constant -sub EjsConst($) -{ - my $const = shift; - $constants{$const->{NAME}} = $const->{VALUE}; -} - -##################################################################### -# parse the interface definitions -sub EjsInterface($$) -{ - my($interface,$needed) = @_; - my @fns = (); - my $name = $interface->{NAME}; - - %constants = (); - - foreach my $d (@{$interface->{TYPEDEFS}}) { - ($needed->{"push_$d->{NAME}"}) && EjsTypedefPush($d); - ($needed->{"pull_$d->{NAME}"}) && EjsTypedefPull($d); - } - - foreach my $d (@{$interface->{FUNCTIONS}}) { - next if not defined($d->{OPNUM}); - next if Parse::Pidl::Util::has_property($d, "noejs"); - - EjsPullFunction($d); - EjsPushFunction($d); - EjsFunction($d, $name); - - push (@fns, $d->{NAME}); - } - - foreach my $d (@{$interface->{CONSTS}}) { - EjsConst($d); - } - - pidl "static int ejs_$name\_init(int eid, int argc, struct MprVar **argv)"; - pidl "{"; - indent; - pidl "struct MprVar *obj = mprInitObject(eid, \"$name\", argc, argv);"; - foreach (@fns) { - pidl "mprSetCFunction(obj, \"$_\", ejs_$_);"; - } - foreach my $v (keys %constants) { - my $value = $constants{$v}; - if (substr($value, 0, 1) eq "\"") { - pidl "mprSetVar(obj, \"$v\", mprString($value));"; - } else { - pidl "mprSetVar(obj, \"$v\", mprCreateNumberVar($value));"; - } - } - pidl "return ejs_rpc_init(obj, \"$name\");"; - deindent; - pidl "}\n"; - - pidl "NTSTATUS ejs_init_$name(void)"; - pidl "{"; - indent; - pidl "return smbcalls_register_ejs(\"$name\_init\", ejs_$name\_init);"; - deindent; - pidl "}"; -} - -##################################################################### -# parse a parsed IDL into a C header -sub Parse($$) -{ - my($ndr,$hdr) = @_; - - my $ejs_hdr = $hdr; - $ejs_hdr =~ s/.h$/_ejs.h/; - $res = ""; - pidl " -/* EJS wrapper functions auto-generated by pidl */ -#include \"includes.h\" -#include \"lib/appweb/ejs/ejs.h\" -#include \"scripting/ejs/ejsrpc.h\" -#include \"scripting/ejs/smbcalls.h\" -#include \"librpc/gen_ndr/ndr_misc_ejs.h\" -#include \"$hdr\" -#include \"$ejs_hdr\" - -"; - - my %needed = (); - - foreach my $x (@{$ndr}) { - ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed); - } - - foreach my $x (@{$ndr}) { - ($x->{TYPE} eq "INTERFACE") && EjsInterface($x, \%needed); - } - - return $res; -} - -sub NeededFunction($$) -{ - my ($fn,$needed) = @_; - $needed->{"pull_$fn->{NAME}"} = 1; - $needed->{"push_$fn->{NAME}"} = 1; - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/in/, @{$e->{DIRECTION}})) { - $needed->{"pull_$e->{TYPE}"} = 1; - } - if (grep (/out/, @{$e->{DIRECTION}})) { - $needed->{"push_$e->{TYPE}"} = 1; - } - } -} - -sub NeededTypedef($$) -{ - my ($t,$needed) = @_; - if (Parse::Pidl::Util::has_property($t, "public")) { - $needed->{"pull_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs"); - $needed->{"push_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs"); - } - if ($t->{DATA}->{TYPE} ne "STRUCT" && - $t->{DATA}->{TYPE} ne "UNION") { - return; - } - for my $e (@{$t->{DATA}->{ELEMENTS}}) { - if ($needed->{"pull_$t->{NAME}"}) { - $needed->{"pull_$e->{TYPE}"} = 1; - } - if ($needed->{"push_$t->{NAME}"}) { - $needed->{"push_$e->{TYPE}"} = 1; - } - } -} - -##################################################################### -# work out what parse functions are needed -sub NeededInterface($$) -{ - my ($interface,$needed) = @_; - foreach my $d (@{$interface->{FUNCTIONS}}) { - NeededFunction($d, $needed); - } - foreach my $d (reverse @{$interface->{TYPEDEFS}}) { - NeededTypedef($d, $needed); - } -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm b/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm deleted file mode 100644 index fed717cad0..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/EJSHeader.pm +++ /dev/null @@ -1,79 +0,0 @@ -################################################### -# create C header files for an EJS mapping functions -# Copyright tridge@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba::EJSHeader; - -use strict; -use Parse::Pidl::Typelist; -use Parse::Pidl::Util qw(has_property); - -use vars qw($VERSION); -$VERSION = '0.01'; - -my($res); - -sub pidl ($) -{ - $res .= shift; -} - -##################################################################### -# prototype a typedef -sub HeaderTypedefProto($) -{ - my $d = shift; - my $name = $d->{NAME}; - - return unless has_property($d, "public"); - - my $type_decl = Parse::Pidl::Typelist::mapType($name); - - pidl "NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, const $type_decl *);\n"; - pidl "NTSTATUS ejs_pull_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, $type_decl *);\n"; -} - -##################################################################### -# parse the interface definitions -sub HeaderInterface($) -{ - my($interface) = shift; - - my $count = 0; - - pidl "#ifndef _HEADER_EJS_$interface->{NAME}\n"; - pidl "#define _HEADER_EJS_$interface->{NAME}\n\n"; - - if (defined $interface->{PROPERTIES}->{depends}) { - my @d = split / /, $interface->{PROPERTIES}->{depends}; - foreach my $i (@d) { - pidl "#include \"librpc/gen_ndr/ndr_$i\_ejs\.h\"\n"; - } - } - - pidl "\n"; - - foreach my $d (@{$interface->{TYPEDEFS}}) { - HeaderTypedefProto($d); - } - - pidl "\n"; - pidl "#endif /* _HEADER_EJS_$interface->{NAME} */\n"; -} - -##################################################################### -# parse a parsed IDL into a C header -sub Parse($) -{ - my($idl) = shift; - - $res = ""; - pidl "/* header auto-generated by pidl */\n\n"; - foreach my $x (@{$idl}) { - ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); - } - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/Header.pm deleted file mode 100644 index f235a96cb8..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/Header.pm +++ /dev/null @@ -1,361 +0,0 @@ -################################################### -# create C header files for an IDL structure -# Copyright tridge@samba.org 2000 -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba::Header; - -use strict; -use Parse::Pidl::Typelist qw(mapType); -use Parse::Pidl::Util qw(has_property is_constant); -use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); - -use vars qw($VERSION); -$VERSION = '0.01'; - -my($res); -my($tab_depth); - -sub pidl ($) -{ - $res .= shift; -} - -sub tabs() -{ - my $res = ""; - $res .="\t" foreach (1..$tab_depth); - return $res; -} - -##################################################################### -# parse a properties list -sub HeaderProperties($$) -{ - my($props,$ignores) = @_; - my $ret = ""; - - foreach my $d (keys %{$props}) { - next if (grep(/^$d$/, @$ignores)); - if($props->{$d} ne "1") { - $ret.= "$d($props->{$d}),"; - } else { - $ret.="$d,"; - } - } - - if ($ret) { - pidl "/* [" . substr($ret, 0, -1) . "] */"; - } -} - -##################################################################### -# parse a structure element -sub HeaderElement($) -{ - my($element) = shift; - - pidl tabs(); - HeaderType($element, $element->{TYPE}, ""); - pidl " "; - my $numstar = $element->{POINTERS}; - if ($numstar >= 1) { - $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); - } - foreach (@{$element->{ARRAY_LEN}}) - { - next if is_constant($_) and - not has_property($element, "charset"); - $numstar++; - } - pidl "*" foreach (1..$numstar); - pidl $element->{NAME}; - foreach (@{$element->{ARRAY_LEN}}) { - next unless (is_constant($_) and - not has_property($element, "charset")); - pidl "[$_]"; - } - - pidl ";"; - if (defined $element->{PROPERTIES}) { - HeaderProperties($element->{PROPERTIES}, ["in", "out"]); - } - pidl "\n"; -} - -##################################################################### -# parse a struct -sub HeaderStruct($$) -{ - my($struct,$name) = @_; - pidl "struct $name {\n"; - $tab_depth++; - my $el_count=0; - if (defined $struct->{ELEMENTS}) { - foreach my $e (@{$struct->{ELEMENTS}}) { - HeaderElement($e); - $el_count++; - } - } - if ($el_count == 0) { - # some compilers can't handle empty structures - pidl tabs()."char _empty_;\n"; - } - $tab_depth--; - pidl tabs()."}"; - if (defined $struct->{PROPERTIES}) { - HeaderProperties($struct->{PROPERTIES}, []); - } -} - -##################################################################### -# parse a enum -sub HeaderEnum($$) -{ - my($enum,$name) = @_; - my $first = 1; - - if (not Parse::Pidl::Util::useUintEnums()) { - pidl "enum $name {\n"; - $tab_depth++; - foreach my $e (@{$enum->{ELEMENTS}}) { - unless ($first) { pidl ",\n"; } - $first = 0; - pidl tabs(); - pidl $e; - } - pidl "\n"; - $tab_depth--; - pidl "}"; - } else { - my $count = 0; - pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n"; - my $with_val = 0; - my $without_val = 0; - foreach my $e (@{$enum->{ELEMENTS}}) { - my $t = "$e"; - my $name; - my $value; - if ($t =~ /(.*)=(.*)/) { - $name = $1; - $value = $2; - $with_val = 1; - die ("you can't mix enum member with values and without values when using --uint-enums!") - unless ($without_val == 0); - } else { - $name = $t; - $value = $count++; - $without_val = 1; - die ("you can't mix enum member with values and without values when using --uint-enums!") - unless ($with_val == 0); - } - pidl "#define $name ( $value )\n"; - } - pidl "\n"; - } -} - -##################################################################### -# parse a bitmap -sub HeaderBitmap($$) -{ - my($bitmap,$name) = @_; - - pidl "/* bitmap $name */\n"; - pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}}); - pidl "\n"; -} - -##################################################################### -# parse a union -sub HeaderUnion($$) -{ - my($union,$name) = @_; - my %done = (); - - pidl "union $name {\n"; - $tab_depth++; - foreach my $e (@{$union->{ELEMENTS}}) { - if ($e->{TYPE} ne "EMPTY") { - if (! defined $done{$e->{NAME}}) { - HeaderElement($e); - } - $done{$e->{NAME}} = 1; - } - } - $tab_depth--; - pidl "}"; - - if (defined $union->{PROPERTIES}) { - HeaderProperties($union->{PROPERTIES}, []); - } -} - -##################################################################### -# parse a type -sub HeaderType($$$) -{ - my($e,$data,$name) = @_; - if (ref($data) eq "HASH") { - ($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name); - ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data, $name); - ($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name); - ($data->{TYPE} eq "UNION") && HeaderUnion($data, $name); - return; - } - - if (has_property($e, "charset")) { - pidl "const char"; - } else { - pidl mapType($e->{TYPE}); - } -} - -##################################################################### -# parse a typedef -sub HeaderTypedef($) -{ - my($typedef) = shift; - HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); - pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP"); -} - -##################################################################### -# parse a const -sub HeaderConst($) -{ - my($const) = shift; - if (!defined($const->{ARRAY_LEN}[0])) { - pidl "#define $const->{NAME}\t( $const->{VALUE} )\n"; - } else { - pidl "#define $const->{NAME}\t $const->{VALUE}\n"; - } -} - -##################################################################### -# parse a function -sub HeaderFunctionInOut($$) -{ - my($fn,$prop) = @_; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (has_property($e, $prop)) { - HeaderElement($e); - } - } -} - -##################################################################### -# determine if we need an "in" or "out" section -sub HeaderFunctionInOut_needed($$) -{ - my($fn,$prop) = @_; - - return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void"); - - foreach (@{$fn->{ELEMENTS}}) { - return 1 if (has_property($_, $prop)); - } - - return undef; -} - -my %headerstructs = (); - -##################################################################### -# parse a function -sub HeaderFunction($) -{ - my($fn) = shift; - - return if ($headerstructs{$fn->{NAME}}); - - $headerstructs{$fn->{NAME}} = 1; - - pidl "\nstruct $fn->{NAME} {\n"; - $tab_depth++; - my $needed = 0; - - if (HeaderFunctionInOut_needed($fn, "in")) { - pidl tabs()."struct {\n"; - $tab_depth++; - HeaderFunctionInOut($fn, "in"); - $tab_depth--; - pidl tabs()."} in;\n\n"; - $needed++; - } - - if (HeaderFunctionInOut_needed($fn, "out")) { - pidl tabs()."struct {\n"; - $tab_depth++; - HeaderFunctionInOut($fn, "out"); - if ($fn->{RETURN_TYPE} ne "void") { - pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n"; - } - $tab_depth--; - pidl tabs()."} out;\n\n"; - $needed++; - } - - if (! $needed) { - # sigh - some compilers don't like empty structures - pidl tabs()."int _dummy_element;\n"; - } - - $tab_depth--; - pidl "};\n\n"; -} - -##################################################################### -# parse the interface definitions -sub HeaderInterface($) -{ - my($interface) = shift; - - my $count = 0; - - pidl "#ifndef _HEADER_$interface->{NAME}\n"; - pidl "#define _HEADER_$interface->{NAME}\n\n"; - - if (defined $interface->{PROPERTIES}->{depends}) { - my @d = split / /, $interface->{PROPERTIES}->{depends}; - foreach my $i (@d) { - pidl "#include \"librpc/gen_ndr/$i\.h\"\n"; - } - } - - foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "CONST"); - HeaderConst($d); - } - - foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "TYPEDEF"); - HeaderTypedef($d); - } - - foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "FUNCTION"); - HeaderFunction($d); - } - - pidl "#endif /* _HEADER_$interface->{NAME} */\n"; -} - -##################################################################### -# parse a parsed IDL into a C header -sub Parse($) -{ - my($idl) = shift; - $tab_depth = 0; - - $res = ""; - pidl "/* header auto-generated by pidl */\n\n"; - foreach my $x (@{$idl}) { - ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); - } - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm deleted file mode 100644 index 3ec19fa158..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Client.pm +++ /dev/null @@ -1,102 +0,0 @@ -################################################### -# client calls generator -# Copyright tridge@samba.org 2003 -# released under the GNU GPL - -package Parse::Pidl::Samba::NDR::Client; - -use vars qw($VERSION); -$VERSION = '0.01'; - -use strict; - -my($res); - -##################################################################### -# parse a function -sub ParseFunction($$) -{ - my ($interface, $fn) = @_; - my $name = $fn->{NAME}; - my $uname = uc $name; - - $res .= " -struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) -{ - if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) { - NDR_PRINT_IN_DEBUG($name, r); - } - - return dcerpc_ndr_request_send(p, NULL, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, r); -} - -NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) -{ - struct rpc_request *req; - NTSTATUS status; - - req = dcerpc_$name\_send(p, mem_ctx, r); - if (req == NULL) return NT_STATUS_NO_MEMORY; - - status = dcerpc_ndr_request_recv(req); - - if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { - NDR_PRINT_OUT_DEBUG($name, r); - } -"; - - if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") { - $res .= "\tif (NT_STATUS_IS_OK(status)) status = r->out.result;\n"; - } - $res .= -" - return status; -} -"; -} - -my %done; - -##################################################################### -# parse the interface definitions -sub ParseInterface($) -{ - my($interface) = shift; - $res .= "/* $interface->{NAME} - client functions generated by pidl */\n\n"; - - foreach my $fn (@{$interface->{FUNCTIONS}}) { - next if not defined($fn->{OPNUM}); - next if defined($done{$fn->{NAME}}); - ParseFunction($interface, $fn); - $done{$fn->{NAME}} = 1; - } - - return $res; -} - -sub Parse($$) -{ - my($ndr) = shift; - my($filename) = shift; - - my $h_filename = $filename; - $res = ""; - - if ($h_filename =~ /(.*)\.c/) { - $h_filename = "$1.h"; - } - - $res .= "/* client functions auto-generated by pidl */\n"; - $res .= "\n"; - $res .= "#include \"includes.h\"\n"; - $res .= "#include \"$h_filename\"\n"; - $res .= "\n"; - - foreach my $x (@{$ndr}) { - ($x->{TYPE} eq "INTERFACE") && ParseInterface($x); - } - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm deleted file mode 100644 index dd1848152e..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Header.pm +++ /dev/null @@ -1,169 +0,0 @@ -################################################### -# create C header files for an IDL structure -# Copyright tridge@samba.org 2000 -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba::NDR::Header; - -use strict; -use Parse::Pidl::Typelist qw(mapType); -use Parse::Pidl::Util qw(has_property is_constant); -use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); -use Parse::Pidl::Samba::NDR::Parser; - -use vars qw($VERSION); -$VERSION = '0.01'; - -my($res); -my($tab_depth); - -sub pidl ($) -{ - $res .= shift; -} - -sub tabs() -{ - my $res = ""; - $res .="\t" foreach (1..$tab_depth); - return $res; -} - -##################################################################### -# prototype a typedef -sub HeaderTypedefProto($) -{ - my($d) = shift; - - my $tf = Parse::Pidl::Samba::NDR::Parser::get_typefamily($d->{DATA}{TYPE}); - - if (has_property($d, "gensize")) { - my $size_args = $tf->{SIZE_FN_ARGS}->($d); - pidl "size_t ndr_size_$d->{NAME}($size_args);\n"; - } - - return unless has_property($d, "public"); - - unless (has_property($d, "nopush")) { - pidl "NTSTATUS ndr_push_$d->{NAME}(struct ndr_push *ndr, int ndr_flags, " . $tf->{DECL}->($d, "push") . ");\n"; - } - unless (has_property($d, "nopull")) { - pidl "NTSTATUS ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, " . $tf->{DECL}->($d, "pull") . ");\n"; - } - unless (has_property($d, "noprint")) { - pidl "void ndr_print_$d->{NAME}(struct ndr_print *ndr, const char *name, " . $tf->{DECL}->($d, "print") . ");\n"; - } -} - -##################################################################### -# output prototypes for a IDL function -sub HeaderFnProto($$) -{ - my ($interface,$fn) = @_; - my $name = $fn->{NAME}; - - pidl "void ndr_print_$name(struct ndr_print *ndr, const char *name, int flags, const struct $name *r);\n"; - - unless (has_property($fn, "noopnum")) { - pidl "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n"; - pidl "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n"; - } - - return unless has_property($fn, "public"); - - pidl "NTSTATUS ndr_push_$name(struct ndr_push *ndr, int flags, const struct $name *r);\n"; - pidl "NTSTATUS ndr_pull_$name(struct ndr_pull *ndr, int flags, struct $name *r);\n"; - - pidl "\n"; -} - -##################################################################### -# parse the interface definitions -sub HeaderInterface($) -{ - my($interface) = shift; - - if (defined $interface->{PROPERTIES}->{depends}) { - my @d = split / /, $interface->{PROPERTIES}->{depends}; - foreach my $i (@d) { - pidl "#include \"librpc/gen_ndr/ndr_$i\.h\"\n"; - } - } - - my $count = 0; - - pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n"; - pidl "#define _HEADER_NDR_$interface->{NAME}\n\n"; - - if (defined $interface->{PROPERTIES}->{uuid}) { - my $name = uc $interface->{NAME}; - pidl "#define DCERPC_$name\_UUID " . - Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})) . "\n"; - - if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; } - pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n"; - - pidl "#define DCERPC_$name\_NAME \"$interface->{NAME}\"\n"; - - if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; } - pidl "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}\n"; - - pidl "\nextern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n"; - pidl "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);\n\n"; - } - - foreach my $d (@{$interface->{DATA}}) { - next if $d->{TYPE} ne "FUNCTION"; - next if has_property($d, "noopnum"); - next if grep(/$d->{NAME}/,@{$interface->{INHERITED_FUNCTIONS}}); - my $u_name = uc $d->{NAME}; - pidl "#define DCERPC_$u_name ("; - - if (defined($interface->{BASE})) { - pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + "; - } - - pidl sprintf("0x%02x", $count) . ")\n"; - $count++; - } - - pidl "\n#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ("; - - if (defined($interface->{BASE})) { - pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + "; - } - - pidl "$count)\n\n"; - - foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "TYPEDEF"); - HeaderTypedefProto($d); - } - - foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "FUNCTION"); - HeaderFnProto($interface, $d); - } - - pidl "#endif /* _HEADER_NDR_$interface->{NAME} */\n"; -} - -##################################################################### -# parse a parsed IDL into a C header -sub Parse($$) -{ - my($idl,$basename) = @_; - $tab_depth = 0; - - $res = ""; - pidl "/* header auto-generated by pidl */\n"; - pidl "#include \"librpc/gen_ndr/$basename\.h\"\n\n"; - - foreach my $x (@{$idl}) { - ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); - } - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm deleted file mode 100644 index 84f3091586..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Parser.pm +++ /dev/null @@ -1,2389 +0,0 @@ -################################################### -# Samba4 NDR parser generator for IDL structures -# Copyright tridge@samba.org 2000-2003 -# Copyright tpot@samba.org 2001 -# Copyright jelmer@samba.org 2004-2005 -# released under the GNU GPL - -package Parse::Pidl::Samba::NDR::Parser; - -use strict; -use Parse::Pidl::Typelist qw(hasType getType mapType); -use Parse::Pidl::Util qw(has_property ParseExpr); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); - -use vars qw($VERSION); -$VERSION = '0.01'; - -# list of known types -my %typefamily; - -sub get_typefamily($) -{ - my $n = shift; - return $typefamily{$n}; -} - -sub append_prefix($$) -{ - my ($e, $var_name) = @_; - my $pointers = 0; - - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "POINTER") { - $pointers++; - } elsif ($l->{TYPE} eq "ARRAY") { - if (($pointers == 0) and - (not $l->{IS_FIXED}) and - (not $l->{IS_INLINE})) { - return get_value_of($var_name); - } - } elsif ($l->{TYPE} eq "DATA") { - if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - return get_value_of($var_name) unless ($pointers); - } - } - } - - return $var_name; -} - -sub has_fast_array($$) -{ - my ($e,$l) = @_; - - return 0 if ($l->{TYPE} ne "ARRAY"); - - my $nl = GetNextLevel($e,$l); - return 0 unless ($nl->{TYPE} eq "DATA"); - return 0 unless (hasType($nl->{DATA_TYPE})); - - my $t = getType($nl->{DATA_TYPE}); - - # Only uint8 and string have fast array functions at the moment - return ($t->{NAME} eq "uint8") or ($t->{NAME} eq "string"); -} - -sub is_charset_array($$) -{ - my ($e,$l) = @_; - - return 0 if ($l->{TYPE} ne "ARRAY"); - - my $nl = GetNextLevel($e,$l); - - return 0 unless ($nl->{TYPE} eq "DATA"); - - return has_property($e, "charset"); -} - -sub get_pointer_to($) -{ - my $var_name = shift; - - if ($var_name =~ /^\*(.*)$/) { - return $1; - } elsif ($var_name =~ /^\&(.*)$/) { - return "&($var_name)"; - } else { - return "&$var_name"; - } -} - -sub get_value_of($) -{ - my $var_name = shift; - - if ($var_name =~ /^\&(.*)$/) { - return $1; - } else { - return "*$var_name"; - } -} - -my $res = ""; -my $deferred = ""; -my $tabs = ""; - -#################################### -# pidl() is our basic output routine -sub pidl($) -{ - my $d = shift; - if ($d) { - $res .= $tabs; - $res .= $d; - } - $res .="\n"; -} - -#################################### -# defer() is like pidl(), but adds to -# a deferred buffer which is then added to the -# output buffer at the end of the structure/union/function -# This is needed to cope with code that must be pushed back -# to the end of a block of elements -sub defer($) -{ - my $d = shift; - if ($d) { - $deferred .= $tabs; - $deferred .= $d; - } - $deferred .="\n"; -} - -######################################## -# add the deferred content to the current -# output -sub add_deferred() -{ - $res .= $deferred; - $deferred = ""; -} - -sub indent() -{ - $tabs .= "\t"; -} - -sub deindent() -{ - $tabs = substr($tabs, 0, -1); -} - -##################################################################### -# check that a variable we get from ParseExpr isn't a null pointer -sub check_null_pointer($) -{ - my $size = shift; - if ($size =~ /^\*/) { - my $size2 = substr($size, 1); - pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; - } -} - -##################################################################### -# check that a variable we get from ParseExpr isn't a null pointer, -# putting the check at the end of the structure/function -sub check_null_pointer_deferred($) -{ - my $size = shift; - if ($size =~ /^\*/) { - my $size2 = substr($size, 1); - defer "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; - } -} - -##################################################################### -# check that a variable we get from ParseExpr isn't a null pointer -# void return varient -sub check_null_pointer_void($) -{ - my $size = shift; - if ($size =~ /^\*/) { - my $size2 = substr($size, 1); - pidl "if ($size2 == NULL) return;"; - } -} - -##################################################################### -# work out is a parse function should be declared static or not -sub fn_prefix($) -{ - my $fn = shift; - - return "" if (has_property($fn, "public")); - return "static "; -} - -################################################################### -# setup any special flags for an element or structure -sub start_flags($) -{ - my $e = shift; - my $flags = has_property($e, "flag"); - if (defined $flags) { - pidl "{"; - indent; - pidl "uint32_t _flags_save_$e->{TYPE} = ndr->flags;"; - pidl "ndr_set_flags(&ndr->flags, $flags);"; - } -} - -################################################################### -# end any special flags for an element or structure -sub end_flags($) -{ - my $e = shift; - my $flags = has_property($e, "flag"); - if (defined $flags) { - pidl "ndr->flags = _flags_save_$e->{TYPE};"; - deindent; - pidl "}"; - } -} - -sub GenerateStructEnv($) -{ - my $x = shift; - my %env; - - foreach my $e (@{$x->{ELEMENTS}}) { - $env{$e->{NAME}} = "r->$e->{NAME}"; - } - - $env{"this"} = "r"; - - return \%env; -} - -sub EnvSubstituteValue($$) -{ - my ($env,$s) = @_; - - # Substitute the value() values in the env - foreach my $e (@{$s->{ELEMENTS}}) { - next unless (my $v = has_property($e, "value")); - - $env->{$e->{NAME}} = ParseExpr($v, $env); - } - - return $env; -} - -sub GenerateFunctionInEnv($) -{ - my $fn = shift; - my %env; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->in.$e->{NAME}"; - } - } - - return \%env; -} - -sub GenerateFunctionOutEnv($) -{ - my $fn = shift; - my %env; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/out/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->out.$e->{NAME}"; - } elsif (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->in.$e->{NAME}"; - } - } - - return \%env; -} - -##################################################################### -# parse the data of an array - push side -sub ParseArrayPushHeader($$$$$) -{ - my ($e,$l,$ndr,$var_name,$env) = @_; - - my $size; - my $length; - - if ($l->{IS_ZERO_TERMINATED}) { - if (has_property($e, "charset")) { - $size = $length = "ndr_charset_length($var_name, CH_$e->{PROPERTIES}->{charset})"; - } else { - $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))"; - } - } else { - $size = ParseExpr($l->{SIZE_IS}, $env); - $length = ParseExpr($l->{LENGTH_IS}, $env); - } - - if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { - pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));"; - } - - if ($l->{IS_VARYING}) { - pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));"; # array offset - pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));"; - } - - return $length; -} - -##################################################################### -# parse an array - pull side -sub ParseArrayPullHeader($$$$$) -{ - my ($e,$l,$ndr,$var_name,$env) = @_; - - my $length; - my $size; - - if ($l->{IS_CONFORMANT}) { - $length = $size = "ndr_get_array_size($ndr, " . get_pointer_to($var_name) . ")"; - } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays - $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))"; - } else { - $length = $size = ParseExpr($l->{SIZE_IS}, $env); - } - - if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { - pidl "NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));"; - } - - - if ($l->{IS_VARYING}) { - pidl "NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));"; - $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")"; - } - - check_null_pointer($length); - - if ($length ne $size) { - pidl "if ($length > $size) {"; - indent; - pidl "return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);"; - deindent; - pidl "}"; - } - - if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { - my $size = ParseExpr($l->{SIZE_IS}, $env); - defer "if ($var_name) {"; - check_null_pointer_deferred($size); - defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"; - defer "}"; - } - - if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { - my $length = ParseExpr($l->{LENGTH_IS}, $env); - defer "if ($var_name) {"; - check_null_pointer_deferred($length); - defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"; - defer "}" - } - - if (not $l->{IS_FIXED} and not is_charset_array($e, $l)) { - AllocateArrayLevel($e,$l,$ndr,$env,$size); - } - - return $length; -} - -sub compression_alg($$) -{ - my ($e,$l) = @_; - my $compression = $l->{COMPRESSION}; - my ($alg, $clen, $dlen) = split(/ /, $compression); - - return $alg; -} - -sub compression_clen($$$) -{ - my ($e,$l,$env) = @_; - my $compression = $l->{COMPRESSION}; - my ($alg, $clen, $dlen) = split(/ /, $compression); - - return ParseExpr($clen, $env); -} - -sub compression_dlen($$$) -{ - my ($e,$l,$env) = @_; - my $compression = $l->{COMPRESSION}; - my ($alg, $clen, $dlen) = split(/ /, $compression); - - return ParseExpr($dlen, $env); -} - -sub ParseCompressionPushStart($$$$) -{ - my ($e,$l,$ndr,$env) = @_; - my $comndr = "$ndr\_compressed"; - my $alg = compression_alg($e, $l); - my $dlen = compression_dlen($e, $l, $env); - - pidl "{"; - indent; - pidl "struct ndr_push *$comndr;"; - pidl "NDR_CHECK(ndr_push_compression_start($ndr, &$comndr, $alg, $dlen));"; - - return $comndr; -} - -sub ParseCompressionPushEnd($$$$) -{ - my ($e,$l,$ndr,$env) = @_; - my $comndr = "$ndr\_compressed"; - my $alg = compression_alg($e, $l); - my $dlen = compression_dlen($e, $l, $env); - - pidl "NDR_CHECK(ndr_push_compression_end($ndr, $comndr, $alg, $dlen));"; - deindent; - pidl "}"; -} - -sub ParseCompressionPullStart($$$$) -{ - my ($e,$l,$ndr,$env) = @_; - my $comndr = "$ndr\_compressed"; - my $alg = compression_alg($e, $l); - my $dlen = compression_dlen($e, $l, $env); - - pidl "{"; - indent; - pidl "struct ndr_pull *$comndr;"; - pidl "NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen));"; - - return $comndr; -} - -sub ParseCompressionPullEnd($$$$) -{ - my ($e,$l,$ndr,$env) = @_; - my $comndr = "$ndr\_compressed"; - my $alg = compression_alg($e, $l); - my $dlen = compression_dlen($e, $l, $env); - - pidl "NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));"; - deindent; - pidl "}"; -} - -sub ParseObfuscationPushStart($$) -{ - my ($e,$ndr) = @_; - my $obfuscation = has_property($e, "obfuscation"); - - pidl "NDR_CHECK(ndr_push_obfuscation_start($ndr, $obfuscation));"; - - return $ndr; -} - -sub ParseObfuscationPushEnd($$) -{ - my ($e,$ndr) = @_; - my $obfuscation = has_property($e, "obfuscation"); - - pidl "NDR_CHECK(ndr_push_obfuscation_end($ndr, $obfuscation));"; -} - -sub ParseObfuscationPullStart($$) -{ - my ($e,$ndr) = @_; - my $obfuscation = has_property($e, "obfuscation"); - - pidl "NDR_CHECK(ndr_pull_obfuscation_start($ndr, $obfuscation));"; - - return $ndr; -} - -sub ParseObfuscationPullEnd($$) -{ - my ($e,$ndr) = @_; - my $obfuscation = has_property($e, "obfuscation"); - - pidl "NDR_CHECK(ndr_pull_obfuscation_end($ndr, $obfuscation));"; -} - -sub ParseSubcontextPushStart($$$$) -{ - my ($e,$l,$ndr,$env) = @_; - my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); - - pidl "{"; - indent; - pidl "struct ndr_push *$subndr;"; - pidl "NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"; - - if (defined $l->{COMPRESSION}) { - $subndr = ParseCompressionPushStart($e, $l, $subndr, $env); - } - - if (defined $l->{OBFUSCATION}) { - $subndr = ParseObfuscationPushStart($e, $subndr); - } - - return $subndr; -} - -sub ParseSubcontextPushEnd($$$$) -{ - my ($e,$l,$ndr,$env) = @_; - my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); - - if (defined $l->{COMPRESSION}) { - ParseCompressionPushEnd($e, $l, $subndr, $env); - } - - if (defined $l->{OBFUSCATION}) { - ParseObfuscationPushEnd($e, $subndr); - } - - pidl "NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; - deindent; - pidl "}"; -} - -sub ParseSubcontextPullStart($$$$) -{ - my ($e,$l,$ndr,$env) = @_; - my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); - - pidl "{"; - indent; - pidl "struct ndr_pull *$subndr;"; - pidl "NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"; - - if (defined $l->{COMPRESSION}) { - $subndr = ParseCompressionPullStart($e, $l, $subndr, $env); - } - - if (defined $l->{OBFUSCATION}) { - $subndr = ParseObfuscationPullStart($e, $subndr); - } - - return $subndr; -} - -sub ParseSubcontextPullEnd($$$$) -{ - my ($e,$l,$ndr,$env) = @_; - my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); - - if (defined $l->{COMPRESSION}) { - ParseCompressionPullEnd($e, $l, $subndr, $env); - } - - if (defined $l->{OBFUSCATION}) { - ParseObfuscationPullEnd($e, $subndr); - } - - pidl "NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; - deindent; - pidl "}"; -} - -sub ParseElementPushLevel -{ - my ($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; - - my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - - if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING})) { - $var_name = get_pointer_to($var_name); - } - - if (defined($ndr_flags)) { - if ($l->{TYPE} eq "SUBCONTEXT") { - my $subndr = ParseSubcontextPushStart($e, $l, $ndr, $env); - ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1); - ParseSubcontextPushEnd($e, $l, $ndr, $env); - } elsif ($l->{TYPE} eq "POINTER") { - ParsePtrPush($e, $l, $var_name); - } elsif ($l->{TYPE} eq "ARRAY") { - my $length = ParseArrayPushHeader($e, $l, $ndr, $var_name, $env); - - my $nl = GetNextLevel($e, $l); - - # Allow speedups for arrays of scalar types - if (is_charset_array($e,$l)) { - pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; - return; - } elsif (has_fast_array($e,$l)) { - pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; - return; - } - } elsif ($l->{TYPE} eq "SWITCH") { - ParseSwitchPush($e, $l, $ndr, $var_name, $ndr_flags, $env); - } elsif ($l->{TYPE} eq "DATA") { - ParseDataPush($e, $l, $ndr, $var_name, $ndr_flags); - } - } - - if ($l->{TYPE} eq "POINTER" and $deferred) { - if ($l->{POINTER_TYPE} ne "ref") { - pidl "if ($var_name) {"; - indent; - if ($l->{POINTER_TYPE} eq "relative") { - pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));"; - } - } - $var_name = get_value_of($var_name); - ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1); - - if ($l->{POINTER_TYPE} ne "ref") { - deindent; - pidl "}"; - } - } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and - not is_charset_array($e, $l)) { - my $length = ParseExpr($l->{LENGTH_IS}, $env); - my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; - - $var_name = $var_name . "[$counter]"; - - if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { - pidl "for ($counter = 0; $counter < $length; $counter++) {"; - indent; - ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0); - deindent; - pidl "}"; - } - - if ($deferred and ContainsDeferred($e, $l)) { - pidl "for ($counter = 0; $counter < $length; $counter++) {"; - indent; - ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1); - deindent; - pidl "}"; - } - } elsif ($l->{TYPE} eq "SWITCH") { - ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred); - } -} - -##################################################################### -# parse scalars in a structure element -sub ParseElementPush($$$$$$) -{ - my ($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_; - my $subndr = undef; - - my $var_name = $var_prefix.$e->{NAME}; - - $var_name = append_prefix($e, $var_name); - - return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); - - start_flags($e); - - if (my $value = has_property($e, "value")) { - $var_name = ParseExpr($value, $env); - } - - ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred); - - end_flags($e); -} - -##################################################################### -# parse a pointer in a struct element or function -sub ParsePtrPush($$$) -{ - my ($e,$l,$var_name) = @_; - - if ($l->{POINTER_TYPE} eq "ref") { - if ($l->{LEVEL} eq "EMBEDDED") { - pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_name));"; - } else { - check_null_pointer(get_value_of($var_name)); - } - } elsif ($l->{POINTER_TYPE} eq "relative") { - pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));"; - } elsif ($l->{POINTER_TYPE} eq "unique") { - pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));"; - } elsif ($l->{POINTER_TYPE} eq "sptr") { - pidl "NDR_CHECK(ndr_push_sptr_ptr(ndr, $var_name));"; - } else { - die("Unhandled pointer type $l->{POINTER_TYPE}"); - } -} - -##################################################################### -# print scalars in a structure element -sub ParseElementPrint($$$) -{ - my($e,$var_name,$env) = @_; - - $var_name = append_prefix($e, $var_name); - return if (has_property($e, "noprint")); - - if (my $value = has_property($e, "value")) { - $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env) . ":$var_name"; - } - - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "POINTER") { - pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);"; - pidl "ndr->depth++;"; - if ($l->{POINTER_TYPE} ne "ref") { - pidl "if ($var_name) {"; - indent; - } - $var_name = get_value_of($var_name); - } elsif ($l->{TYPE} eq "ARRAY") { - my $length; - - if ($l->{IS_CONFORMANT} or $l->{IS_VARYING}) { - $var_name = get_pointer_to($var_name); - } - - if ($l->{IS_ZERO_TERMINATED}) { - $length = "ndr_string_length($var_name, sizeof(*$var_name))"; - } else { - $length = ParseExpr($l->{LENGTH_IS}, $env); - } - - if (is_charset_array($e,$l)) { - pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);"; - last; - } elsif (has_fast_array($e, $l)) { - my $nl = GetNextLevel($e, $l); - pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);"; - last; - } else { - my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; - - pidl "ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);"; - pidl 'ndr->depth++;'; - pidl "for ($counter=0;$counter<$length;$counter++) {"; - indent; - pidl "char *idx_$l->{LEVEL_INDEX}=NULL;"; - pidl "asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);"; - pidl "if (idx_$l->{LEVEL_INDEX}) {"; - indent; - - $var_name = $var_name . "[$counter]"; - } - } elsif ($l->{TYPE} eq "DATA") { - if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - $var_name = get_pointer_to($var_name); - } - pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; - } elsif ($l->{TYPE} eq "SWITCH") { - my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); - check_null_pointer_void($switch_var); - pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"; - } - } - - foreach my $l (reverse @{$e->{LEVELS}}) { - if ($l->{TYPE} eq "POINTER") { - if ($l->{POINTER_TYPE} ne "ref") { - deindent; - pidl "}"; - } - pidl "ndr->depth--;"; - } elsif (($l->{TYPE} eq "ARRAY") - and not is_charset_array($e,$l) - and not has_fast_array($e,$l)) { - pidl "free(idx_$l->{LEVEL_INDEX});"; - deindent; - pidl "}"; - deindent; - pidl "}"; - pidl "ndr->depth--;"; - } - } -} - -##################################################################### -# parse scalars in a structure element - pull size -sub ParseSwitchPull($$$$$$) -{ - my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); - - check_null_pointer($switch_var); - - $var_name = get_pointer_to($var_name); - pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));"; -} - -##################################################################### -# push switch element -sub ParseSwitchPush($$$$$$) -{ - my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); - - check_null_pointer($switch_var); - $var_name = get_pointer_to($var_name); - pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"; -} - -sub ParseDataPull($$$$$) -{ - my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; - - if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - $var_name = get_pointer_to($var_name); - } - - $var_name = get_pointer_to($var_name); - - pidl "NDR_CHECK(ndr_pull_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));"; - - if (my $range = has_property($e, "range")) { - $var_name = get_value_of($var_name); - my ($low, $high) = split(/ /, $range, 2); - pidl "if ($var_name < $low || $var_name > $high) {"; - pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");"; - pidl "}"; - } -} - -sub ParseDataPush($$$$$) -{ - my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; - - # strings are passed by value rather then reference - if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - $var_name = get_pointer_to($var_name); - } - - pidl "NDR_CHECK(ndr_push_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));"; -} - -sub CalcNdrFlags($$$) -{ - my ($l,$primitives,$deferred) = @_; - - my $scalars = 0; - my $buffers = 0; - - # Add NDR_SCALARS if this one is deferred - # and deferreds may be pushed - $scalars = 1 if ($l->{IS_DEFERRED} and $deferred); - - # Add NDR_SCALARS if this one is not deferred and - # primitives may be pushed - $scalars = 1 if (!$l->{IS_DEFERRED} and $primitives); - - # Add NDR_BUFFERS if this one contains deferred stuff - # and deferreds may be pushed - $buffers = 1 if ($l->{CONTAINS_DEFERRED} and $deferred); - - return "NDR_SCALARS|NDR_BUFFERS" if ($scalars and $buffers); - return "NDR_SCALARS" if ($scalars); - return "NDR_BUFFERS" if ($buffers); - return undef; -} - -sub ParseMemCtxPullStart($$$) -{ - my $e = shift; - my $l = shift; - my $ptr_name = shift; - - my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; - my $mem_c_ctx = $ptr_name; - my $mem_c_flags = "0"; - - return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}); - - if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { - my $nl = GetNextLevel($e, $l); - my $next_is_array = ($nl->{TYPE} eq "ARRAY"); - my $next_is_string = (($nl->{TYPE} eq "DATA") and - ($nl->{DATA_TYPE} eq "string")); - if ($next_is_array or $next_is_string) { - return; - } else { - $mem_c_flags = "LIBNDR_FLAG_REF_ALLOC"; - } - } - - pidl "$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);"; - pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);"; -} - -sub ParseMemCtxPullEnd($$) -{ - my $e = shift; - my $l = shift; - - my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; - my $mem_r_flags = "0"; - - return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}); - - if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { - my $nl = GetNextLevel($e, $l); - my $next_is_array = ($nl->{TYPE} eq "ARRAY"); - my $next_is_string = (($nl->{TYPE} eq "DATA") and - ($nl->{DATA_TYPE} eq "string")); - if ($next_is_array or $next_is_string) { - return; - } else { - $mem_r_flags = "LIBNDR_FLAG_REF_ALLOC"; - } - } - - pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);"; -} - -sub CheckStringTerminator($$$$) -{ - my ($ndr,$e,$l,$length) = @_; - my $nl = GetNextLevel($e, $l); - - # Make sure last element is zero! - pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $length, sizeof($nl->{DATA_TYPE}_t)));"; -} - -sub ParseElementPullLevel -{ - my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; - - my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - - if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT})) { - $var_name = get_pointer_to($var_name); - } - - # Only pull something if there's actually something to be pulled - if (defined($ndr_flags)) { - if ($l->{TYPE} eq "SUBCONTEXT") { - my $subndr = ParseSubcontextPullStart($e, $l, $ndr, $env); - ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1); - ParseSubcontextPullEnd($e, $l, $ndr, $env); - } elsif ($l->{TYPE} eq "ARRAY") { - my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env); - - my $nl = GetNextLevel($e, $l); - - if (is_charset_array($e,$l)) { - if ($l->{IS_ZERO_TERMINATED}) { - CheckStringTerminator($ndr, $e, $l, $length); - } - pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; - return; - } elsif (has_fast_array($e, $l)) { - if ($l->{IS_ZERO_TERMINATED}) { - CheckStringTerminator($ndr,$e,$l,$length); - } - pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; - return; - } - } elsif ($l->{TYPE} eq "POINTER") { - ParsePtrPull($e, $l, $ndr, $var_name); - } elsif ($l->{TYPE} eq "SWITCH") { - ParseSwitchPull($e, $l, $ndr, $var_name, $ndr_flags, $env); - } elsif ($l->{TYPE} eq "DATA") { - ParseDataPull($e, $l, $ndr, $var_name, $ndr_flags); - } - } - - # add additional constructions - if ($l->{TYPE} eq "POINTER" and $deferred) { - if ($l->{POINTER_TYPE} ne "ref") { - pidl "if ($var_name) {"; - indent; - - if ($l->{POINTER_TYPE} eq "relative") { - pidl "struct ndr_pull_save _relative_save;"; - pidl "ndr_pull_save(ndr, &_relative_save);"; - pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));"; - } - } - - ParseMemCtxPullStart($e,$l, $var_name); - - $var_name = get_value_of($var_name); - ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); - - ParseMemCtxPullEnd($e,$l); - - if ($l->{POINTER_TYPE} ne "ref") { - if ($l->{POINTER_TYPE} eq "relative") { - pidl "ndr_pull_restore(ndr, &_relative_save);"; - } - deindent; - pidl "}"; - } - } elsif ($l->{TYPE} eq "ARRAY" and - not has_fast_array($e,$l) and not is_charset_array($e, $l)) { - my $length = ParseExpr($l->{LENGTH_IS}, $env); - my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; - my $array_name = $var_name; - - $var_name = $var_name . "[$counter]"; - - ParseMemCtxPullStart($e,$l, $array_name); - - if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { - my $nl = GetNextLevel($e,$l); - - if ($l->{IS_ZERO_TERMINATED}) { - CheckStringTerminator($ndr,$e,$l,$length); - } - - pidl "for ($counter = 0; $counter < $length; $counter++) {"; - indent; - ParseElementPullLevel($e, $nl, $ndr, $var_name, $env, 1, 0); - deindent; - pidl "}"; - } - - if ($deferred and ContainsDeferred($e, $l)) { - pidl "for ($counter = 0; $counter < $length; $counter++) {"; - indent; - ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1); - deindent; - pidl "}"; - } - - ParseMemCtxPullEnd($e,$l); - - } elsif ($l->{TYPE} eq "SWITCH") { - ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred); - } -} - -##################################################################### -# parse scalars in a structure element - pull size -sub ParseElementPull($$$$$$) -{ - my($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_; - - my $var_name = $var_prefix.$e->{NAME}; - - $var_name = append_prefix($e, $var_name); - - return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); - - start_flags($e); - - ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred); - - end_flags($e); -} - -##################################################################### -# parse a pointer in a struct element or function -sub ParsePtrPull($$$$) -{ - my($e,$l,$ndr,$var_name) = @_; - - my $nl = GetNextLevel($e, $l); - my $next_is_array = ($nl->{TYPE} eq "ARRAY"); - my $next_is_string = (($nl->{TYPE} eq "DATA") and - ($nl->{DATA_TYPE} eq "string")); - - if ($l->{POINTER_TYPE} eq "ref") { - unless ($l->{LEVEL} eq "TOP") { - pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"; - } - - unless ($next_is_array or $next_is_string) { - pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; - pidl "\tNDR_PULL_ALLOC($ndr, $var_name);"; - pidl "}"; - } - - return; - } elsif (($l->{POINTER_TYPE} eq "unique") or - ($l->{POINTER_TYPE} eq "relative") or - ($l->{POINTER_TYPE} eq "sptr")) { - pidl "NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));"; - pidl "if (_ptr_$e->{NAME}) {"; - indent; - } else { - die("Unhandled pointer type $l->{POINTER_TYPE}"); - } - - # Don't do this for arrays, they're allocated at the actual level - # of the array - unless ($next_is_array or $next_is_string) { - pidl "NDR_PULL_ALLOC($ndr, $var_name);"; - } else { - # FIXME: Yes, this is nasty. - # We allocate an array twice - # - once just to indicate that it's there, - # - then the real allocation... - pidl "NDR_PULL_ALLOC_SIZE($ndr, $var_name, 1);"; - } - - #pidl "memset($var_name, 0, sizeof($var_name));"; - if ($l->{POINTER_TYPE} eq "relative") { - pidl "NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));"; - } - deindent; - pidl "} else {"; - pidl "\t$var_name = NULL;"; - pidl "}"; -} - -##################################################################### -# parse a struct -sub ParseStructPush($$) -{ - my($struct,$name) = @_; - - return unless defined($struct->{ELEMENTS}); - - my $env = GenerateStructEnv($struct); - - EnvSubstituteValue($env, $struct); - - # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base}); - - foreach my $e (@{$struct->{ELEMENTS}}) { - DeclareArrayVariables($e); - } - - start_flags($struct); - - # see if the structure contains a conformant array. If it - # does, then it must be the last element of the structure, and - # we need to push the conformant length early, as it fits on - # the wire before the structure (and even before the structure - # alignment) - if (defined($struct->{SURROUNDING_ELEMENT})) { - my $e = $struct->{SURROUNDING_ELEMENT}; - - if (defined($e->{LEVELS}[0]) and - $e->{LEVELS}[0]->{TYPE} eq "ARRAY") { - my $size; - - if ($e->{LEVELS}[0]->{IS_ZERO_TERMINATED}) { - if (has_property($e, "charset")) { - $size = "ndr_charset_length(r->$e->{NAME}, CH_$e->{PROPERTIES}->{charset})"; - } else { - $size = "ndr_string_length(r->$e->{NAME}, sizeof(*r->$e->{NAME}))"; - } - } else { - $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env); - } - - pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; - } else { - pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));"; - } - } - - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; - - pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));"; - - if (defined($struct->{PROPERTIES}{relative_base})) { - # set the current offset as base for relative pointers - # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));"; - } - - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPush($e, "ndr", "r->", $env, 1, 0); - } - - deindent; - pidl "}"; - - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; - if (defined($struct->{PROPERTIES}{relative_base})) { - # retrieve the current offset as base for relative pointers - # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));"; - } - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPush($e, "ndr", "r->", $env, 0, 1); - } - - deindent; - pidl "}"; - - end_flags($struct); - # restore the old relative_base_offset - pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base}); -} - -##################################################################### -# generate a push function for an enum -sub ParseEnumPush($$) -{ - my($enum,$name) = @_; - my($type_fn) = $enum->{BASE_TYPE}; - - start_flags($enum); - pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; - end_flags($enum); -} - -##################################################################### -# generate a pull function for an enum -sub ParseEnumPull($$) -{ - my($enum,$name) = @_; - my($type_fn) = $enum->{BASE_TYPE}; - my($type_v_decl) = mapType($type_fn); - - pidl "$type_v_decl v;"; - start_flags($enum); - pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; - pidl "*r = v;"; - - end_flags($enum); -} - -##################################################################### -# generate a print function for an enum -sub ParseEnumPrint($$) -{ - my($enum,$name) = @_; - - pidl "const char *val = NULL;"; - pidl ""; - - start_flags($enum); - - pidl "switch (r) {"; - indent; - my $els = \@{$enum->{ELEMENTS}}; - foreach my $i (0 .. $#{$els}) { - my $e = ${$els}[$i]; - chomp $e; - if ($e =~ /^(.*)=/) { - $e = $1; - } - pidl "case $e: val = \"$e\"; break;"; - } - - deindent; - pidl "}"; - - pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);"; - - end_flags($enum); -} - -sub DeclEnum($) -{ - my ($e,$t) = @_; - return "enum $e->{NAME} " . - ($t eq "pull"?"*":"") . "r"; -} - -$typefamily{ENUM} = { - DECL => \&DeclEnum, - PUSH_FN_BODY => \&ParseEnumPush, - PULL_FN_BODY => \&ParseEnumPull, - PRINT_FN_BODY => \&ParseEnumPrint, -}; - -##################################################################### -# generate a push function for a bitmap -sub ParseBitmapPush($$) -{ - my($bitmap,$name) = @_; - my($type_fn) = $bitmap->{BASE_TYPE}; - - start_flags($bitmap); - - pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; - - end_flags($bitmap); -} - -##################################################################### -# generate a pull function for an bitmap -sub ParseBitmapPull($$) -{ - my($bitmap,$name) = @_; - my $type_fn = $bitmap->{BASE_TYPE}; - my($type_decl) = mapType($bitmap->{BASE_TYPE}); - - pidl "$type_decl v;"; - start_flags($bitmap); - pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; - pidl "*r = v;"; - - end_flags($bitmap); -} - -##################################################################### -# generate a print function for an bitmap -sub ParseBitmapPrintElement($$$) -{ - my($e,$bitmap,$name) = @_; - my($type_decl) = mapType($bitmap->{BASE_TYPE}); - my($type_fn) = $bitmap->{BASE_TYPE}; - my($flag); - - if ($e =~ /^(\w+) .*$/) { - $flag = "$1"; - } else { - die "Bitmap: \"$name\" invalid Flag: \"$e\""; - } - - pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);"; -} - -##################################################################### -# generate a print function for an bitmap -sub ParseBitmapPrint($$) -{ - my($bitmap,$name) = @_; - my($type_decl) = mapType($bitmap->{TYPE}); - my($type_fn) = $bitmap->{BASE_TYPE}; - - start_flags($bitmap); - - pidl "ndr_print_$type_fn(ndr, name, r);"; - - pidl "ndr->depth++;"; - foreach my $e (@{$bitmap->{ELEMENTS}}) { - ParseBitmapPrintElement($e, $bitmap, $name); - } - pidl "ndr->depth--;"; - - end_flags($bitmap); -} - -sub DeclBitmap($$) -{ - my ($e,$t) = @_; - return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e->{DATA})) . - ($t eq "pull"?" *":" ") . "r"; -} - -$typefamily{BITMAP} = { - DECL => \&DeclBitmap, - PUSH_FN_BODY => \&ParseBitmapPush, - PULL_FN_BODY => \&ParseBitmapPull, - PRINT_FN_BODY => \&ParseBitmapPrint, -}; - -##################################################################### -# generate a struct print function -sub ParseStructPrint($$) -{ - my($struct,$name) = @_; - - return unless defined $struct->{ELEMENTS}; - - my $env = GenerateStructEnv($struct); - - EnvSubstituteValue($env, $struct); - - foreach my $e (@{$struct->{ELEMENTS}}) { - DeclareArrayVariables($e); - } - - pidl "ndr_print_struct(ndr, name, \"$name\");"; - - start_flags($struct); - - pidl "ndr->depth++;"; - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPrint($e, "r->$e->{NAME}", $env); - } - pidl "ndr->depth--;"; - - end_flags($struct); -} - -sub DeclarePtrVariables($) -{ - my $e = shift; - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "POINTER" and - not ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP")) { - pidl "uint32_t _ptr_$e->{NAME};"; - last; - } - } -} - -sub DeclareArrayVariables($) -{ - my $e = shift; - - foreach my $l (@{$e->{LEVELS}}) { - next if has_fast_array($e,$l); - next if is_charset_array($e,$l); - if ($l->{TYPE} eq "ARRAY") { - pidl "uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};"; - } - } -} - -sub need_decl_mem_ctx($$) -{ - my $e = shift; - my $l = shift; - - return 0 if has_fast_array($e,$l); - return 0 if is_charset_array($e,$l); - return 1 if (($l->{TYPE} eq "ARRAY") and not $l->{IS_FIXED}); - - if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { - my $nl = GetNextLevel($e, $l); - my $next_is_array = ($nl->{TYPE} eq "ARRAY"); - my $next_is_string = (($nl->{TYPE} eq "DATA") and - ($nl->{DATA_TYPE} eq "string")); - return 0 if ($next_is_array or $next_is_string); - } - return 1 if ($l->{TYPE} eq "POINTER"); - - return 0; -} - -sub DeclareMemCtxVariables($) -{ - my $e = shift; - foreach my $l (@{$e->{LEVELS}}) { - if (need_decl_mem_ctx($e, $l)) { - pidl "TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};"; - } - } -} - -##################################################################### -# parse a struct - pull side -sub ParseStructPull($$) -{ - my($struct,$name) = @_; - - return unless defined $struct->{ELEMENTS}; - - my $env = GenerateStructEnv($struct); - - # declare any internal pointers we need - foreach my $e (@{$struct->{ELEMENTS}}) { - DeclarePtrVariables($e); - DeclareArrayVariables($e); - DeclareMemCtxVariables($e); - } - - # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base}); - - start_flags($struct); - - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; - - if (defined $struct->{SURROUNDING_ELEMENT}) { - pidl "NDR_CHECK(ndr_pull_array_size(ndr, &r->$struct->{SURROUNDING_ELEMENT}->{NAME}));"; - } - - pidl "NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));"; - - if (defined($struct->{PROPERTIES}{relative_base})) { - # set the current offset as base for relative pointers - # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));"; - } - - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPull($e, "ndr", "r->", $env, 1, 0); - } - - add_deferred(); - - deindent; - pidl "}"; - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; - if (defined($struct->{PROPERTIES}{relative_base})) { - # retrieve the current offset as base for relative pointers - # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));"; - } - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPull($e, "ndr", "r->", $env, 0, 1); - } - - add_deferred(); - - deindent; - pidl "}"; - - end_flags($struct); - # restore the old relative_base_offset - pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base}); -} - -##################################################################### -# calculate size of ndr struct -sub ParseStructNdrSize($) -{ - my $t = shift; - my $sizevar; - - if (my $flags = has_property($t, "flag")) { - pidl "flags |= $flags;"; - } - pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});"; -} - -sub DeclStruct($) -{ - my ($e,$t) = @_; - return ($t ne "pull"?"const ":"") . "struct $e->{NAME} *r"; -} - -sub ArgsStructNdrSize($) -{ - my $d = shift; - return "const struct $d->{NAME} *r, int flags"; -} - -$typefamily{STRUCT} = { - PUSH_FN_BODY => \&ParseStructPush, - DECL => \&DeclStruct, - PULL_FN_BODY => \&ParseStructPull, - PRINT_FN_BODY => \&ParseStructPrint, - SIZE_FN_BODY => \&ParseStructNdrSize, - SIZE_FN_ARGS => \&ArgsStructNdrSize, -}; - -##################################################################### -# calculate size of ndr struct -sub ParseUnionNdrSize($) -{ - my $t = shift; - my $sizevar; - - if (my $flags = has_property($t, "flag")) { - pidl "flags |= $flags;"; - } - - pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});"; -} - -##################################################################### -# parse a union - push side -sub ParseUnionPush($$) -{ - my ($e,$name) = @_; - my $have_default = 0; - - # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base}); - pidl "int level;"; - - start_flags($e); - - pidl "level = ndr_push_get_switch_value(ndr, r);"; - - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; - - if (defined($e->{SWITCH_TYPE})) { - pidl "NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));"; - } - - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - if ($el->{CASE} eq "default") { - $have_default = 1; - } - pidl "$el->{CASE}:"; - - if ($el->{TYPE} ne "EMPTY") { - indent; - if (defined($e->{PROPERTIES}{relative_base})) { - pidl "NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));"; - # set the current offset as base for relative pointers - # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));"; - } - DeclareArrayVariables($el); - ParseElementPush($el, "ndr", "r->", {}, 1, 0); - deindent; - } - pidl "break;"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; - } - deindent; - pidl "}"; - deindent; - pidl "}"; - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; - if (defined($e->{PROPERTIES}{relative_base})) { - # retrieve the current offset as base for relative pointers - # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));"; - } - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - pidl "$el->{CASE}:"; - if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPush($el, "ndr", "r->", {}, 0, 1); - deindent; - } - pidl "break;"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; - } - deindent; - pidl "}"; - - deindent; - pidl "}"; - end_flags($e); - # restore the old relative_base_offset - pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); -} - -##################################################################### -# print a union -sub ParseUnionPrint($$) -{ - my ($e,$name) = @_; - my $have_default = 0; - - pidl "int level;"; - foreach my $el (@{$e->{ELEMENTS}}) { - DeclareArrayVariables($el); - } - - start_flags($e); - - pidl "level = ndr_print_get_switch_value(ndr, r);"; - - pidl "ndr_print_union(ndr, name, level, \"$name\");"; - - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - if ($el->{CASE} eq "default") { - $have_default = 1; - } - pidl "$el->{CASE}:"; - if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPrint($el, "r->$el->{NAME}", {}); - deindent; - } - pidl "break;"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\tndr_print_bad_level(ndr, name, level);"; - } - deindent; - pidl "}"; - - end_flags($e); -} - -##################################################################### -# parse a union - pull side -sub ParseUnionPull($$) -{ - my ($e,$name) = @_; - my $have_default = 0; - my $switch_type = $e->{SWITCH_TYPE}; - - # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base}); - pidl "int level;"; - if (defined($switch_type)) { - if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) { - $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)); - } - pidl mapType($switch_type) . " _level;"; - } - - my %double_cases = (); - foreach my $el (@{$e->{ELEMENTS}}) { - next if ($el->{TYPE} eq "EMPTY"); - next if ($double_cases{"$el->{NAME}"}); - DeclareMemCtxVariables($el); - $double_cases{"$el->{NAME}"} = 1; - } - - start_flags($e); - - pidl "level = ndr_pull_get_switch_value(ndr, r);"; - - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; - - if (defined($switch_type)) { - pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));"; - pidl "if (_level != level) {"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $name\", _level);"; - pidl "}"; - } - - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - if ($el->{CASE} eq "default") { - $have_default = 1; - } - pidl "$el->{CASE}: {"; - - if ($el->{TYPE} ne "EMPTY") { - indent; - DeclarePtrVariables($el); - DeclareArrayVariables($el); - if (defined($e->{PROPERTIES}{relative_base})) { - pidl "NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));"; - # set the current offset as base for relative pointers - # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));"; - } - ParseElementPull($el, "ndr", "r->", {}, 1, 0); - deindent; - } - pidl "break; }"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; - } - deindent; - pidl "}"; - deindent; - pidl "}"; - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; - if (defined($e->{PROPERTIES}{relative_base})) { - # retrieve the current offset as base for relative pointers - # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));"; - } - pidl "switch (level) {"; - indent; - foreach my $el (@{$e->{ELEMENTS}}) { - pidl "$el->{CASE}:"; - if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPull($el, "ndr", "r->", {}, 0, 1); - deindent; - } - pidl "break;"; - pidl ""; - } - if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; - } - deindent; - pidl "}"; - - deindent; - pidl "}"; - - add_deferred(); - - end_flags($e); - # restore the old relative_base_offset - pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); -} - -sub DeclUnion($$) -{ - my ($e,$t) = @_; - return ($t ne "pull"?"const ":"") . "union $e->{NAME} *r"; -} - -sub ArgsUnionNdrSize($) -{ - my $d = shift; - return "const union $d->{NAME} *r, uint32_t level, int flags"; -} - -$typefamily{UNION} = { - PUSH_FN_BODY => \&ParseUnionPush, - DECL => \&DeclUnion, - PULL_FN_BODY => \&ParseUnionPull, - PRINT_FN_BODY => \&ParseUnionPrint, - SIZE_FN_ARGS => \&ArgsUnionNdrSize, - SIZE_FN_BODY => \&ParseUnionNdrSize, -}; - -##################################################################### -# parse a typedef - push side -sub ParseTypedefPush($) -{ - my($e) = shift; - - my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push"); - pidl fn_prefix($e) . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)"; - - pidl "{"; - indent; - $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $e->{NAME}); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl "";; -} - -##################################################################### -# parse a typedef - pull side -sub ParseTypedefPull($) -{ - my($e) = shift; - - my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull"); - - pidl fn_prefix($e) . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)"; - - pidl "{"; - indent; - $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $e->{NAME}); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse a typedef - print side -sub ParseTypedefPrint($) -{ - my($e) = shift; - - my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print"); - - pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; - pidl "{"; - indent; - $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME}); - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -## calculate the size of a structure -sub ParseTypedefNdrSize($) -{ - my($t) = shift; - - my $tf = $typefamily{$t->{DATA}->{TYPE}}; - my $args = $tf->{SIZE_FN_ARGS}->($t); - - pidl "size_t ndr_size_$t->{NAME}($args)"; - pidl "{"; - indent; - $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t); - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse a function - print side -sub ParseFunctionPrint($) -{ - my($fn) = shift; - - return if has_property($fn, "noprint"); - - pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; - pidl "{"; - indent; - - foreach my $e (@{$fn->{ELEMENTS}}) { - DeclareArrayVariables($e); - } - - pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");"; - pidl "ndr->depth++;"; - - pidl "if (flags & NDR_SET_VALUES) {"; - pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;"; - pidl "}"; - - pidl "if (flags & NDR_IN) {"; - indent; - pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");"; - pidl "ndr->depth++;"; - - my $env = GenerateFunctionInEnv($fn); - EnvSubstituteValue($env, $fn); - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep(/in/,@{$e->{DIRECTION}})) { - ParseElementPrint($e, "r->in.$e->{NAME}", $env); - } - } - pidl "ndr->depth--;"; - deindent; - pidl "}"; - - pidl "if (flags & NDR_OUT) {"; - indent; - pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");"; - pidl "ndr->depth++;"; - - $env = GenerateFunctionOutEnv($fn); - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep(/out/,@{$e->{DIRECTION}})) { - ParseElementPrint($e, "r->out.$e->{NAME}", $env); - } - } - if ($fn->{RETURN_TYPE}) { - pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);"; - } - pidl "ndr->depth--;"; - deindent; - pidl "}"; - - pidl "ndr->depth--;"; - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse a function -sub ParseFunctionPush($) -{ - my($fn) = shift; - - return if has_property($fn, "nopush"); - - pidl fn_prefix($fn) . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)"; - pidl "{"; - indent; - - foreach my $e (@{$fn->{ELEMENTS}}) { - DeclareArrayVariables($e); - } - - pidl "if (flags & NDR_IN) {"; - indent; - - my $env = GenerateFunctionInEnv($fn); - - EnvSubstituteValue($env, $fn); - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep(/in/,@{$e->{DIRECTION}})) { - ParseElementPush($e, "ndr", "r->in.", $env, 1, 1); - } - } - - deindent; - pidl "}"; - - pidl "if (flags & NDR_OUT) {"; - indent; - - $env = GenerateFunctionOutEnv($fn); - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep(/out/,@{$e->{DIRECTION}})) { - ParseElementPush($e, "ndr", "r->out.", $env, 1, 1); - } - } - - if ($fn->{RETURN_TYPE}) { - pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));"; - } - - deindent; - pidl "}"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; -} - -sub AllocateArrayLevel($$$$$) -{ - my ($e,$l,$ndr,$env,$size) = @_; - - my $var = ParseExpr($e->{NAME}, $env); - - check_null_pointer($size); - my $pl = GetPrevLevel($e, $l); - if (defined($pl) and - $pl->{TYPE} eq "POINTER" and - $pl->{POINTER_TYPE} eq "ref" - and not $l->{IS_ZERO_TERMINATED}) { - pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; - pidl "\tNDR_PULL_ALLOC_N($ndr, $var, $size);"; - pidl "}"; - if (grep(/in/,@{$e->{DIRECTION}}) and - grep(/out/,@{$e->{DIRECTION}})) { - pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));"; - } - return; - } - - pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);"; -} - -##################################################################### -# parse a function -sub ParseFunctionPull($) -{ - my($fn) = shift; - - return if has_property($fn, "nopull"); - - # pull function args - pidl fn_prefix($fn) . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)"; - pidl "{"; - indent; - - # declare any internal pointers we need - foreach my $e (@{$fn->{ELEMENTS}}) { - DeclarePtrVariables($e); - DeclareArrayVariables($e); - } - - my %double_cases = (); - foreach my $e (@{$fn->{ELEMENTS}}) { - next if ($e->{TYPE} eq "EMPTY"); - next if ($double_cases{"$e->{NAME}"}); - DeclareMemCtxVariables($e); - $double_cases{"$e->{NAME}"} = 1; - } - - pidl "if (flags & NDR_IN) {"; - indent; - - # auto-init the out section of a structure. I originally argued that - # this was a bad idea as it hides bugs, but coping correctly - # with initialisation and not wiping ref vars is turning - # out to be too tricky (tridge) - foreach my $e (@{$fn->{ELEMENTS}}) { - next unless grep(/out/, @{$e->{DIRECTION}}); - pidl "ZERO_STRUCT(r->out);"; - pidl ""; - last; - } - - my $env = GenerateFunctionInEnv($fn); - - foreach my $e (@{$fn->{ELEMENTS}}) { - next unless (grep(/in/, @{$e->{DIRECTION}})); - ParseElementPull($e, "ndr", "r->in.", $env, 1, 1); - } - - # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's - # own flag rather then be in NDR_IN ? - - foreach my $e (@{$fn->{ELEMENTS}}) { - next unless (grep(/out/, @{$e->{DIRECTION}})); - next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and - $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref"); - next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and - ($e->{LEVELS}[1]->{DATA_TYPE} eq "string")); - next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY") - and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}); - - if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { - my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env); - check_null_pointer($size); - - pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"; - - if (grep(/in/, @{$e->{DIRECTION}})) { - pidl "memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));"; - } else { - pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));"; - } - } else { - pidl "NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});"; - - if (grep(/in/, @{$e->{DIRECTION}})) { - pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};"; - } else { - pidl "ZERO_STRUCTP(r->out.$e->{NAME});"; - } - } - } - - add_deferred(); - deindent; - pidl "}"; - - pidl "if (flags & NDR_OUT) {"; - indent; - - $env = GenerateFunctionOutEnv($fn); - foreach my $e (@{$fn->{ELEMENTS}}) { - next unless grep(/out/, @{$e->{DIRECTION}}); - ParseElementPull($e, "ndr", "r->out.", $env, 1, 1); - } - - if ($fn->{RETURN_TYPE}) { - pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));"; - } - - add_deferred(); - deindent; - pidl "}"; - - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# produce a function call table -sub FunctionTable($) -{ - my($interface) = shift; - my $count = 0; - my $uname = uc $interface->{NAME}; - - $count = $#{$interface->{FUNCTIONS}}+1; - - return if ($count == 0); - - pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {"; - $count = 0; - foreach my $d (@{$interface->{FUNCTIONS}}) { - next if not defined($d->{OPNUM}); - pidl "\t{"; - pidl "\t\t\"$d->{NAME}\","; - pidl "\t\tsizeof(struct $d->{NAME}),"; - pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},"; - pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},"; - pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME},"; - pidl "\t\t".($d->{ASYNC}?"True":"False").","; - pidl "\t},"; - $count++; - } - pidl "\t{ NULL, 0, NULL, NULL, NULL, False }"; - pidl "};"; - pidl ""; - - pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {"; - foreach my $ep (@{$interface->{ENDPOINTS}}) { - pidl "\t$ep, "; - } - my $endpoint_count = $#{$interface->{ENDPOINTS}}+1; - - pidl "};"; - pidl ""; - - pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {"; - pidl "\t.count\t= $endpoint_count,"; - pidl "\t.names\t= $interface->{NAME}\_endpoint_strings"; - pidl "};"; - pidl ""; - - if (! defined $interface->{PROPERTIES}->{authservice}) { - $interface->{PROPERTIES}->{authservice} = "\"host\""; - } - - my @a = split / /, $interface->{PROPERTIES}->{authservice}; - my $authservice_count = $#a + 1; - - pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {"; - foreach my $ap (@a) { - pidl "\t$ap, "; - } - pidl "};"; - pidl ""; - - pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {"; - pidl "\t.count\t= $endpoint_count,"; - pidl "\t.names\t= $interface->{NAME}\_authservice_strings"; - pidl "};"; - pidl ""; - - pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {"; - pidl "\t.name\t\t= \"$interface->{NAME}\","; - pidl "\t.uuid\t\t= DCERPC_$uname\_UUID,"; - pidl "\t.if_version\t= DCERPC_$uname\_VERSION,"; - pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,"; - pidl "\t.num_calls\t= $count,"; - pidl "\t.calls\t\t= $interface->{NAME}\_calls,"; - pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,"; - pidl "\t.authservices\t= &$interface->{NAME}\_authservices"; - pidl "};"; - pidl ""; - - pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)"; - pidl "{"; - pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});"; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse the interface definitions -sub ParseInterface($$) -{ - my($interface,$needed) = @_; - - # Typedefs - foreach my $d (@{$interface->{TYPEDEFS}}) { - ($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d); - ($needed->{"pull_$d->{NAME}"}) && ParseTypedefPull($d); - ($needed->{"print_$d->{NAME}"}) && ParseTypedefPrint($d); - - # Make sure we don't generate a function twice... - $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = - $needed->{"print_$d->{NAME}"} = 0; - - ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypedefNdrSize($d); - } - - # Functions - foreach my $d (@{$interface->{FUNCTIONS}}) { - ($needed->{"push_$d->{NAME}"}) && ParseFunctionPush($d); - ($needed->{"pull_$d->{NAME}"}) && ParseFunctionPull($d); - ($needed->{"print_$d->{NAME}"}) && ParseFunctionPrint($d); - - # Make sure we don't generate a function twice... - $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = - $needed->{"print_$d->{NAME}"} = 0; - } - - FunctionTable($interface); -} - -sub RegistrationFunction($$) -{ - my ($idl,$filename) = @_; - - $filename =~ /.*\/ndr_(.*).c/; - my $basename = $1; - pidl "NTSTATUS dcerpc_$basename\_init(void)"; - pidl "{"; - indent; - pidl "NTSTATUS status = NT_STATUS_OK;"; - foreach my $interface (@{$idl}) { - next if $interface->{TYPE} ne "INTERFACE"; - - my $count = ($#{$interface->{FUNCTIONS}}+1); - - next if ($count == 0); - - pidl "status = dcerpc_ndr_$interface->{NAME}_init();"; - pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\treturn status;"; - pidl "}"; - pidl ""; - } - pidl "return status;"; - deindent; - pidl "}"; - pidl ""; -} - -##################################################################### -# parse a parsed IDL structure back into an IDL file -sub Parse($$) -{ - my($ndr,$filename) = @_; - - $tabs = ""; - my $h_filename = $filename; - $res = ""; - - if ($h_filename =~ /(.*)\.c/) { - $h_filename = "$1.h"; - } - - pidl "/* parser auto-generated by pidl */"; - pidl ""; - pidl "#include \"includes.h\""; - pidl "#include \"librpc/gen_ndr/ndr_misc.h\""; - pidl "#include \"librpc/gen_ndr/ndr_dcerpc.h\""; - pidl "#include \"$h_filename\""; - pidl ""; - - my %needed = (); - - foreach my $x (@{$ndr}) { - ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed); - } - - foreach my $x (@{$ndr}) { - ($x->{TYPE} eq "INTERFACE") && ParseInterface($x, \%needed); - } - - RegistrationFunction($ndr, $filename); - - return $res; -} - -sub NeededFunction($$) -{ - my ($fn,$needed) = @_; - $needed->{"pull_$fn->{NAME}"} = 1; - $needed->{"push_$fn->{NAME}"} = 1; - $needed->{"print_$fn->{NAME}"} = 1; - foreach my $e (@{$fn->{ELEMENTS}}) { - $e->{PARENT} = $fn; - unless(defined($needed->{"pull_$e->{TYPE}"})) { - $needed->{"pull_$e->{TYPE}"} = 1; - } - unless(defined($needed->{"push_$e->{TYPE}"})) { - $needed->{"push_$e->{TYPE}"} = 1; - } - unless(defined($needed->{"print_$e->{TYPE}"})) { - $needed->{"print_$e->{TYPE}"} = 1; - } - } -} - -sub NeededTypedef($$) -{ - my ($t,$needed) = @_; - if (has_property($t, "public")) { - $needed->{"pull_$t->{NAME}"} = not has_property($t, "nopull"); - $needed->{"push_$t->{NAME}"} = not has_property($t, "nopush"); - $needed->{"print_$t->{NAME}"} = not has_property($t, "noprint"); - } - - if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") { - if (has_property($t, "gensize")) { - $needed->{"ndr_size_$t->{NAME}"} = 1; - } - - for my $e (@{$t->{DATA}->{ELEMENTS}}) { - $e->{PARENT} = $t->{DATA}; - if ($needed->{"pull_$t->{NAME}"} and - not defined($needed->{"pull_$e->{TYPE}"})) { - $needed->{"pull_$e->{TYPE}"} = 1; - } - if ($needed->{"push_$t->{NAME}"} and - not defined($needed->{"push_$e->{TYPE}"})) { - $needed->{"push_$e->{TYPE}"} = 1; - } - if ($needed->{"print_$t->{NAME}"} and - not defined($needed->{"print_$e->{TYPE}"})) { - $needed->{"print_$e->{TYPE}"} = 1; - } - } - } -} - -##################################################################### -# work out what parse functions are needed -sub NeededInterface($$) -{ - my ($interface,$needed) = @_; - foreach my $d (@{$interface->{FUNCTIONS}}) { - NeededFunction($d, $needed); - } - foreach my $d (reverse @{$interface->{TYPEDEFS}}) { - NeededTypedef($d, $needed); - } -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm deleted file mode 100644 index 1ee497e206..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/NDR/Server.pm +++ /dev/null @@ -1,325 +0,0 @@ -################################################### -# server boilerplate generator -# Copyright tridge@samba.org 2003 -# Copyright metze@samba.org 2004 -# released under the GNU GPL - -package Parse::Pidl::Samba::NDR::Server; - -use strict; - -use vars qw($VERSION); -$VERSION = '0.01'; - -my($res); - -sub pidl($) -{ - $res .= shift; -} - - -##################################################### -# generate the switch statement for function dispatch -sub gen_dispatch_switch($) -{ - my $interface = shift; - - foreach my $fn (@{$interface->{FUNCTIONS}}) { - next if not defined($fn->{OPNUM}); - - pidl "\tcase $fn->{OPNUM}: {\n"; - pidl "\t\tstruct $fn->{NAME} *r2 = r;\n"; - pidl "\t\tif (DEBUGLEVEL >= 10) {\n"; - pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_IN, r2);\n"; - pidl "\t\t}\n"; - if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") { - pidl "\t\tr2->out.result = $fn->{NAME}(dce_call, mem_ctx, r2);\n"; - } else { - pidl "\t\t$fn->{NAME}(dce_call, mem_ctx, r2);\n"; - } - pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; - pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} will reply async\\n\"));\n"; - pidl "\t\t}\n"; - pidl "\t\tbreak;\n\t}\n"; - } -} - -##################################################### -# generate the switch statement for function reply -sub gen_reply_switch($) -{ - my $interface = shift; - - foreach my $fn (@{$interface->{FUNCTIONS}}) { - next if not defined($fn->{OPNUM}); - - pidl "\tcase $fn->{OPNUM}: {\n"; - pidl "\t\tstruct $fn->{NAME} *r2 = r;\n"; - pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; - pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} replied async\\n\"));\n"; - pidl "\t\t}\n"; - pidl "\t\tif (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {\n"; - pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n"; - pidl "\t\t}\n"; - pidl "\t\tif (dce_call->fault_code != 0) {\n"; - pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $fn->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n"; - pidl "\t\t}\n"; - pidl "\t\tbreak;\n\t}\n"; - } -} - -##################################################################### -# produce boilerplate code for a interface -sub Boilerplate_Iface($) -{ - my($interface) = shift; - my $name = $interface->{NAME}; - my $uname = uc $name; - my $uuid = Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})); - my $if_version = $interface->{PROPERTIES}->{version}; - - pidl " -static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface) -{ -#ifdef DCESRV_INTERFACE_$uname\_BIND - return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface); -#else - return NT_STATUS_OK; -#endif -} - -static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface) -{ -#ifdef DCESRV_INTERFACE_$uname\_UNBIND - DCESRV_INTERFACE_$uname\_UNBIND(context, iface); -#else - return; -#endif -} - -static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r) -{ - NTSTATUS status; - uint16_t opnum = dce_call->pkt.u.request.opnum; - - dce_call->fault_code = 0; - - if (opnum >= dcerpc_table_$name.num_calls) { - dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; - return NT_STATUS_NET_WRITE_FAULT; - } - - *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size); - NT_STATUS_HAVE_NO_MEMORY(*r); - - /* unravel the NDR for the packet */ - status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); - if (!NT_STATUS_IS_OK(status)) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, - &dce_call->pkt.u.request.stub_and_verifier); - dce_call->fault_code = DCERPC_FAULT_NDR; - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) -{ - uint16_t opnum = dce_call->pkt.u.request.opnum; - - switch (opnum) { -"; - gen_dispatch_switch($interface); - -pidl " - default: - dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; - break; - } - - if (dce_call->fault_code != 0) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, - &dce_call->pkt.u.request.stub_and_verifier); - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) -{ - uint16_t opnum = dce_call->pkt.u.request.opnum; - - switch (opnum) { -"; - gen_reply_switch($interface); - -pidl " - default: - dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; - break; - } - - if (dce_call->fault_code != 0) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, - &dce_call->pkt.u.request.stub_and_verifier); - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r) -{ - NTSTATUS status; - uint16_t opnum = dce_call->pkt.u.request.opnum; - - status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); - if (!NT_STATUS_IS_OK(status)) { - dce_call->fault_code = DCERPC_FAULT_NDR; - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static const struct dcesrv_interface $name\_interface = { - .name = \"$name\", - .uuid = $uuid, - .if_version = $if_version, - .bind = $name\__op_bind, - .unbind = $name\__op_unbind, - .ndr_pull = $name\__op_ndr_pull, - .dispatch = $name\__op_dispatch, - .reply = $name\__op_reply, - .ndr_push = $name\__op_ndr_push -}; - -"; -} - -##################################################################### -# produce boilerplate code for an endpoint server -sub Boilerplate_Ep_Server($) -{ - my($interface) = shift; - my $name = $interface->{NAME}; - my $uname = uc $name; - - pidl " -static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server) -{ - int i; - - for (i=0;icount;i++) { - NTSTATUS ret; - const char *name = dcerpc_table_$name.endpoints->names[i]; - - ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL); - if (!NT_STATUS_IS_OK(ret)) { - DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name)); - return ret; - } - } - - return NT_STATUS_OK; -} - -static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version) -{ - if ($name\_interface.if_version == if_version && - strcmp($name\_interface.uuid, uuid)==0) { - memcpy(iface,&$name\_interface, sizeof(*iface)); - return True; - } - - return False; -} - -static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) -{ - if (strcmp($name\_interface.name, name)==0) { - memcpy(iface,&$name\_interface, sizeof(*iface)); - return True; - } - - return False; -} - -NTSTATUS dcerpc_server_$name\_init(void) -{ - NTSTATUS ret; - struct dcesrv_endpoint_server ep_server; - - /* fill in our name */ - ep_server.name = \"$name\"; - - /* fill in all the operations */ - ep_server.init_server = $name\__op_init_server; - - ep_server.interface_by_uuid = $name\__op_interface_by_uuid; - ep_server.interface_by_name = $name\__op_interface_by_name; - - /* register ourselves with the DCERPC subsystem. */ - ret = dcerpc_register_ep_server(&ep_server); - - if (!NT_STATUS_IS_OK(ret)) { - DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\")); - return ret; - } - - return ret; -} - -"; -} - -##################################################################### -# dcerpc server boilerplate from a parsed IDL structure -sub ParseInterface($) -{ - my($interface) = shift; - my $count = 0; - - if (!defined $interface->{PROPERTIES}->{uuid}) { - return $res; - } - - if (!defined $interface->{PROPERTIES}->{version}) { - $interface->{PROPERTIES}->{version} = "0.0"; - } - - foreach my $fn (@{$interface->{FUNCTIONS}}) { - if (defined($fn->{OPNUM})) { $count++; } - } - - if ($count == 0) { - return $res; - } - - $res .= "/* $interface->{NAME} - dcerpc server boilerplate generated by pidl */\n\n"; - Boilerplate_Iface($interface); - Boilerplate_Ep_Server($interface); - - return $res; -} - -sub Parse($$) -{ - my($ndr) = shift; - my($filename) = shift; - - $res = ""; - $res .= "/* server functions auto-generated by pidl */\n"; - $res .= "\n"; - - foreach my $x (@{$ndr}) { - ParseInterface($x) if ($x->{TYPE} eq "INTERFACE" and not defined($x->{PROPERTIES}{object})); - } - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm deleted file mode 100644 index 471c3e9927..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/SWIG.pm +++ /dev/null @@ -1,79 +0,0 @@ -################################################### -# Samba4 parser generator for swig wrappers -# Copyright tpot@samba.org 2004,2005 -# released under the GNU GPL - -package Parse::Pidl::Samba::SWIG; - -use vars qw($VERSION); -$VERSION = '0.01'; - -use strict; - -sub pidl($) -{ - print OUT shift; -} - -##################################################################### -# rewrite autogenerated header file -sub RewriteHeader($$$) -{ - my($idl) = shift; - my($input) = shift; - my($output) = shift; - - open(IN, "<$input") || die "can't open $input for reading"; - open(OUT, ">$output") || die "can't open $output for writing"; - - pidl "%{\n"; - pidl "#define data_in in\n"; - pidl "#define data_out out\n"; - pidl "%}\n\n"; - - while() { - - # Rename dom_sid2 to dom_sid as we don't care about the difference - # for the swig wrappers. - - s/dom_sid2/dom_sid/g; - - # Copy structure and union definitions - - if (/^(struct|union) .*? {$/ .. /^\};$/) { - s/\} (in|out);/\} data_$1;/; # "in" is a Python keyword - pidl $_; - next; - } - - # Copy dcerpc functions - - pidl $_ if /^NTSTATUS dcerpc_.*?\(struct dcerpc_pipe/; - - # Copy interface definitions - - pidl $_ - if /^\#define DCERPC_.*?_UUID/ or /^\#define DCERPC_.*?_VERSION/; - } - - close(OUT); -} - -##################################################################### -# rewrite autogenerated header file -sub RewriteC($$$) -{ - my($idl) = shift; - my($input) = shift; - my($output) = shift; - - open(IN, "<$input") || die "can't open $input for reading"; - open(OUT, ">>$output") || die "can't open $output for writing"; - - while() { - } - - close(OUT); -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm deleted file mode 100644 index 5d3d236e43..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/TDR.pm +++ /dev/null @@ -1,280 +0,0 @@ -################################################### -# Trivial Parser Generator -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba::TDR; -use Parse::Pidl::Util qw(has_property ParseExpr is_constant); - -use vars qw($VERSION); -$VERSION = '0.01'; - -use strict; - -my $ret = ""; -my $tabs = ""; - -sub indent() { $tabs.="\t"; } -sub deindent() { $tabs = substr($tabs, 1); } -sub pidl($) { $ret .= $tabs.(shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } -sub static($) { my $p = shift; return("static ") unless ($p); return ""; } -sub typearg($) { - my $t = shift; - return(", const char *name") if ($t eq "print"); - return(", TALLOC_CTX *mem_ctx") if ($t eq "pull"); - return(""); -} - -sub ContainsArray($) -{ - my $e = shift; - foreach (@{$e->{ELEMENTS}}) { - next if (has_property($_, "charset") and - scalar(@{$_->{ARRAY_LEN}}) == 1); - return 1 if (defined($_->{ARRAY_LEN}) and - scalar(@{$_->{ARRAY_LEN}}) > 0); - } - return 0; -} - -sub ParserElement($$$) -{ - my ($e,$t,$env) = @_; - my $switch = ""; - my $array = ""; - my $name = ""; - my $mem_ctx = "mem_ctx"; - - fatal($e,"Pointers not supported in TDR") if ($e->{POINTERS} > 0); - fatal($e,"size_is() not supported in TDR") if (has_property($e, "size_is")); - fatal($e,"length_is() not supported in TDR") if (has_property($e, "length_is")); - - if ($t eq "print") { - $name = ", \"$e->{NAME}\"$array"; - } - - if (has_property($e, "flag")) { - pidl "{"; - indent; - pidl "uint32_t saved_flags = tdr->flags;"; - pidl "tdr->flags |= $e->{PROPERTIES}->{flag};"; - } - - if (has_property($e, "charset")) { - fatal($e,"charset() on non-array element") unless (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0); - - my $len = ParseExpr(@{$e->{ARRAY_LEN}}[0], $env); - if ($len eq "*") { $len = "-1"; } - $name = ", mem_ctx" if ($t eq "pull"); - pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));"; - return; - } - - if (has_property($e, "switch_is")) { - $switch = ", " . ParseExpr($e->{PROPERTIES}->{switch_is}, $env); - } - - if (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0) { - my $len = ParseExpr($e->{ARRAY_LEN}[0], $env); - - if ($t eq "pull" and not is_constant($len)) { - pidl "TDR_ALLOC(mem_ctx, v->$e->{NAME}, $len);"; - $mem_ctx = "v->$e->{NAME}"; - } - - pidl "for (i = 0; i < $len; i++) {"; - indent; - $array = "[i]"; - } - - if ($t eq "pull") { - $name = ", $mem_ctx"; - } - - if (has_property($e, "value") && $t eq "push") { - pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env).";"; - } - - pidl "TDR_CHECK(tdr_$t\_$e->{TYPE}(tdr$name$switch, &v->$e->{NAME}$array));"; - - if ($array) { deindent; pidl "}"; } - - if (has_property($e, "flag")) { - pidl "tdr->flags = saved_flags;"; - deindent; - pidl "}"; - } -} - -sub ParserStruct($$$$) -{ - my ($e,$n,$t,$p) = @_; - - pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", struct $n *v)"; - pidl "{"; indent; - pidl "int i;" if (ContainsArray($e)); - - if ($t eq "print") { - pidl "tdr->print(tdr, \"\%-25s: struct $n\", name);"; - pidl "tdr->level++;"; - } - - my %env = map { $_->{NAME} => "v->$_->{NAME}" } @{$e->{ELEMENTS}}; - $env{"this"} = "v"; - ParserElement($_, $t, \%env) foreach (@{$e->{ELEMENTS}}); - - if ($t eq "print") { - pidl "tdr->level--;"; - } - - pidl "return NT_STATUS_OK;"; - - deindent; pidl "}"; -} - -sub ParserUnion($$$$) -{ - my ($e,$n,$t,$p) = @_; - - pidl static($p)."NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".typearg($t).", int level, union $n *v)"; - pidl "{"; indent; - pidl "int i;" if (ContainsArray($e)); - - if ($t eq "print") { - pidl "tdr->print(tdr, \"\%-25s: union $n\", name);"; - pidl "tdr->level++;"; - } - - pidl "switch (level) {"; indent; - foreach (@{$e->{ELEMENTS}}) { - if (has_property($_, "case")) { - pidl "case " . $_->{PROPERTIES}->{case} . ":"; - } elsif (has_property($_, "default")) { - pidl "default:"; - } - indent; ParserElement($_, $t, {}); deindent; - pidl "break;"; - } - deindent; pidl "}"; - - if ($t eq "print") { - pidl "tdr->level--;"; - } - - pidl "return NT_STATUS_OK;\n"; - deindent; pidl "}"; -} - -sub ParserBitmap($$$$) -{ - my ($e,$n,$t,$p) = @_; - return if ($p); - pidl "#define tdr_$t\_$n tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e); -} - -sub ParserEnum($$$$) -{ - my ($e,$n,$t,$p) = @_; - my $bt = ($e->{PROPERTIES}->{base_type} or "uint8"); - - pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", enum $n *v)"; - pidl "{"; - if ($t eq "pull") { - pidl "\t$bt\_t r;"; - pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, mem_ctx, \&r));"; - pidl "\t*v = r;"; - } elsif ($t eq "push") { - pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));"; - } elsif ($t eq "print") { - pidl "\t/* FIXME */"; - } - pidl "\treturn NT_STATUS_OK;"; - pidl "}"; -} - -sub ParserTypedef($$) -{ - my ($e,$t) = @_; - - return if (has_property($e, "no$t")); - - $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES}; - - { STRUCT => \&ParserStruct, UNION => \&ParserUnion, - ENUM => \&ParserEnum, BITMAP => \&ParserBitmap - }->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $t, has_property($e, "public")); - - pidl ""; -} - -sub ParserInterface($) -{ - my $x = shift; - - foreach (@{$x->{DATA}}) { - next if ($_->{TYPE} ne "TYPEDEF"); - ParserTypedef($_, "pull"); - ParserTypedef($_, "push"); - ParserTypedef($_, "print"); - } -} - -sub Parser($$) -{ - my ($idl,$hdrname) = @_; - $ret = ""; - pidl "/* autogenerated by pidl */"; - pidl "#include \"includes.h\""; - pidl "#include \"$hdrname\""; - pidl ""; - foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } - return $ret; -} - -sub HeaderInterface($$) -{ - my ($x,$outputdir) = @_; - - pidl "#ifndef __TDR_$x->{NAME}_HEADER__"; - pidl "#define __TDR_$x->{NAME}_HEADER__"; - - foreach my $e (@{$x->{DATA}}) { - next unless ($e->{TYPE} eq "TYPEDEF"); - next unless has_property($e, "public"); - - my $switch = ""; - - $switch = ", int level" if ($e->{DATA}->{TYPE} eq "UNION"); - - if ($e->{DATA}->{TYPE} eq "BITMAP") { - # FIXME - } else { - my ($n, $d) = ($e->{NAME}, lc($e->{DATA}->{TYPE})); - pidl "NTSTATUS tdr_pull\_$n(struct tdr_pull *tdr, TALLOC_CTX *ctx$switch, $d $n *v);"; - pidl "NTSTATUS tdr_print\_$n(struct tdr_print *tdr, const char *name$switch, $d $n *v);"; - pidl "NTSTATUS tdr_push\_$n(struct tdr_push *tdr$switch, $d $n *v);"; - } - - pidl ""; - } - - pidl "#endif /* __TDR_$x->{NAME}_HEADER__ */"; -} - -sub Header($$$) -{ - my ($idl,$outputdir,$basename) = @_; - $ret = ""; - pidl "/* Generated by pidl */"; - - pidl "#include \"$outputdir/$basename.h\""; - pidl ""; - - foreach (@$idl) { - HeaderInterface($_, $outputdir) if ($_->{TYPE} eq "INTERFACE"); - } - return $ret; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba/Template.pm deleted file mode 100644 index 52bc2b2d3d..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba/Template.pm +++ /dev/null @@ -1,99 +0,0 @@ -################################################### -# server template function generator -# Copyright tridge@samba.org 2003 -# released under the GNU GPL - -package Parse::Pidl::Samba::Template; - -use vars qw($VERSION); -$VERSION = '0.01'; - -use strict; - -my($res); - -##################################################################### -# produce boilerplate code for a interface -sub Template($) -{ - my($interface) = shift; - my($data) = $interface->{DATA}; - my $name = $interface->{NAME}; - - $res .= -"/* - Unix SMB/CIFS implementation. - - endpoint server for the $name pipe - - Copyright (C) YOUR NAME HERE YEAR - - 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. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. -*/ - -#include \"includes.h\" -#include \"rpc_server/dcerpc_server.h\" -#include \"librpc/gen_ndr/ndr_$name.h\" -#include \"rpc_server/common/common.h\" - -"; - - foreach my $d (@{$data}) { - if ($d->{TYPE} eq "FUNCTION") { - my $fname = $d->{NAME}; - $res .= -" -/* - $fname -*/ -static $d->{RETURN_TYPE} $fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, - struct $fname *r) -{ -"; - - if ($d->{RETURN_TYPE} eq "void") { - $res .= "\tDCESRV_FAULT_VOID(DCERPC_FAULT_OP_RNG_ERROR);\n"; - } else { - $res .= "\tDCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);\n"; - } - - $res .= "} - -"; - } - } - - $res .= -" -/* include the generated boilerplate */ -#include \"librpc/gen_ndr/ndr_$name\_s.c\" -" -} - - -##################################################################### -# parse a parsed IDL structure back into an IDL file -sub Parse($) -{ - my($idl) = shift; - $res = ""; - foreach my $x (@{$idl}) { - ($x->{TYPE} eq "INTERFACE") && - Template($x); - } - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm new file mode 100644 index 0000000000..b9044078ea --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm @@ -0,0 +1,142 @@ +# COM Header generation +# (C) 2005 Jelmer Vernooij + +package Parse::Pidl::Samba4::COM::Header; + +use Parse::Pidl::Typelist; +use Parse::Pidl::Util qw(has_property); + +use vars qw($VERSION); +$VERSION = '0.01'; + +use strict; + +sub GetArgumentProtoList($) +{ + my $f = shift; + my $res = ""; + + foreach my $a (@{$f->{ELEMENTS}}) { + + $res .= ", " . Parse::Pidl::Typelist::mapType($a->{TYPE}) . " "; + + my $l = $a->{POINTERS}; + $l-- if (Parse::Pidl::Typelist::scalar_is_reference($a->{TYPE})); + foreach my $i (1..$l) { + $res .= "*"; + } + + if (defined $a->{ARRAY_LEN}[0] && + !Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0]) && + !$a->{POINTERS}) { + $res .= "*"; + } + $res .= $a->{NAME}; + if (defined $a->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0])) { + $res .= "[$a->{ARRAY_LEN}[0]]"; + } + } + + return $res; +} + +sub GetArgumentList($) +{ + my $f = shift; + my $res = ""; + + foreach my $a (@{$f->{ELEMENTS}}) { + $res .= ", $a->{NAME}"; + } + + return $res; +} + +##################################################################### +# generate vtable structure for COM interface +sub HeaderVTable($) +{ + my $interface = shift; + my $res; + $res .= "#define " . uc($interface->{NAME}) . "_METHODS \\\n"; + if (defined($interface->{BASE})) { + $res .= "\t" . uc($interface->{BASE} . "_METHODS") . "\\\n"; + } + + my $data = $interface->{DATA}; + foreach my $d (@{$data}) { + $res .= "\t" . Parse::Pidl::Typelist::mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION"); + } + $res .= "\n"; + $res .= "struct $interface->{NAME}_vtable {\n"; + $res .= "\tstruct GUID iid;\n"; + $res .= "\t" . uc($interface->{NAME}) . "_METHODS\n"; + $res .= "};\n\n"; + + return $res; +} + +sub ParseInterface($) +{ + my $if = shift; + my $res; + + $res .="\n\n/* $if->{NAME} */\n"; + + $res .="#define COM_" . uc($if->{NAME}) . "_UUID $if->{PROPERTIES}->{uuid}\n\n"; + + $res .="struct $if->{NAME}_vtable;\n\n"; + + $res .="struct $if->{NAME} { + struct com_context *ctx; + struct $if->{NAME}_vtable *vtable; + void *object_data; +};\n\n"; + + $res.=HeaderVTable($if); + + foreach my $d (@{$if->{DATA}}) { + next if ($d->{TYPE} ne "FUNCTION"); + + $res .= "#define $if->{NAME}_$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . ") "; + + $res .= "((interface)->vtable->$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . "))"; + + $res .="\n"; + } + + return $res; +} + +sub ParseCoClass($) +{ + my $c = shift; + my $res = ""; + $res .= "#define CLSID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{uuid}\n"; + if (has_property($c, "progid")) { + $res .= "#define PROGID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{progid}\n"; + } + $res .= "\n"; + return $res; +} + +sub Parse($) +{ + my $idl = shift; + my $res = ""; + + foreach my $x (@{$idl}) + { + if ($x->{TYPE} eq "INTERFACE" && has_property($x, "object")) { + $res.=ParseInterface($x); + } + + if ($x->{TYPE} eq "COCLASS") { + $res.=ParseCoClass($x); + } + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm new file mode 100644 index 0000000000..26a1225590 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm @@ -0,0 +1,215 @@ +################################################### +# DCOM parser for Samba +# Basically the glue between COM and DCE/RPC with NDR +# Copyright jelmer@samba.org 2003-2005 +# released under the GNU GPL + +package Parse::Pidl::Samba4::COM::Proxy; + +use Parse::Pidl::Samba4::COM::Header; +use Parse::Pidl::Util qw(has_property); + +use vars qw($VERSION); +$VERSION = '0.01'; + +use strict; + +my($res); + +sub ParseVTable($$) +{ + my $interface = shift; + my $name = shift; + + # Generate the vtable + $res .="\tstruct $interface->{NAME}_vtable $name = {"; + + if (defined($interface->{BASE})) { + $res .= "\n\t\t{},"; + } + + my $data = $interface->{DATA}; + + foreach my $d (@{$data}) { + if ($d->{TYPE} eq "FUNCTION") { + $res .= "\n\t\tdcom_proxy_$interface->{NAME}_$d->{NAME}"; + $res .= ","; + } + } + + $res .= "\n\t};\n\n"; +} + +sub ParseRegFunc($) +{ + my $interface = shift; + + $res .= "static NTSTATUS dcom_proxy_$interface->{NAME}_init(void) +{ + struct GUID base_iid; + struct $interface->{NAME}_vtable *proxy_vtable = talloc(talloc_autofree_context(), struct $interface->{NAME}_vtable); +"; + + if (defined($interface->{BASE})) { + $res.= " + const void *base_vtable; + + GUID_from_string(DCERPC_" . (uc $interface->{BASE}) . "_UUID, &base_iid); + + base_vtable = dcom_proxy_vtable_by_iid(&base_iid); + if (base_vtable == NULL) { + DEBUG(0, (\"No proxy registered for base interface '$interface->{BASE}'\\n\")); + return NT_STATUS_FOOBAR; + } + + memcpy(&proxy_vtable, base_vtable, sizeof(struct $interface->{BASE}_vtable)); + +"; + } + foreach my $x (@{$interface->{DATA}}) { + next unless ($x->{TYPE} eq "FUNCTION"); + + $res .= "\tproxy_vtable.$x->{NAME} = dcom_proxy_$interface->{NAME}_$x->{NAME};\n"; + } + + $res.= " + GUID_from_string(DCERPC_" . (uc $interface->{NAME}) . "_UUID, &proxy_vtable.iid); + + return dcom_register_proxy(&proxy_vtable); +}\n\n"; +} + +##################################################################### +# parse a function +sub ParseFunction($$) +{ + my $interface = shift; + my $fn = shift; + my $name = $fn->{NAME}; + my $uname = uc $name; + + $res.=" +static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . Parse::Pidl::Samba4::COM::Header::GetArgumentProtoList($fn) . ") +{ + struct dcerpc_pipe *p; + NTSTATUS status = dcom_get_pipe(d, &p); + struct $name r; + struct rpc_request *req; + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + ZERO_STRUCT(r.in.ORPCthis); + r.in.ORPCthis.version.MajorVersion = COM_MAJOR_VERSION; + r.in.ORPCthis.version.MinorVersion = COM_MINOR_VERSION; +"; + + # Put arguments into r + foreach my $a (@{$fn->{ELEMENTS}}) { + next unless (has_property($a, "in")); + if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) { + $res .="\tNDR_CHECK(dcom_OBJREF_from_IUnknown(&r.in.$a->{NAME}.obj, $a->{NAME}));\n"; + } else { + $res .= "\tr.in.$a->{NAME} = $a->{NAME};\n"; + } + } + + $res .=" + if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) { + NDR_PRINT_IN_DEBUG($name, &r); + } + + status = dcerpc_ndr_request(p, &d->ipid, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, &r); + + if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { + NDR_PRINT_OUT_DEBUG($name, r); + } + +"; + + # Put r info back into arguments + foreach my $a (@{$fn->{ELEMENTS}}) { + next unless (has_property($a, "out")); + + if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) { + $res .="\tNDR_CHECK(dcom_IUnknown_from_OBJREF(d->ctx, &$a->{NAME}, r.out.$a->{NAME}.obj));\n"; + } else { + $res .= "\t*$a->{NAME} = r.out.$a->{NAME};\n"; + } + + } + + if ($fn->{RETURN_TYPE} eq "NTSTATUS") { + $res .= "\tif (NT_STATUS_IS_OK(status)) status = r.out.result;\n"; + } + + $res .= + " + return r.out.result; +}\n\n"; +} + +##################################################################### +# parse the interface definitions +sub ParseInterface($) +{ + my($interface) = shift; + my($data) = $interface->{DATA}; + $res = "/* DCOM proxy for $interface->{NAME} generated by pidl */\n\n"; + foreach my $d (@{$data}) { + ($d->{TYPE} eq "FUNCTION") && + ParseFunction($interface, $d); + } + + ParseRegFunc($interface); +} + +sub RegistrationFunction($$) +{ + my $idl = shift; + my $basename = shift; + + my $res = "\n\nNTSTATUS dcom_$basename\_init(void)\n"; + $res .= "{\n"; + $res .="\tNTSTATUS status = NT_STATUS_OK;\n"; + foreach my $interface (@{$idl}) { + next if $interface->{TYPE} ne "INTERFACE"; + next if not has_property($interface, "object"); + + my $data = $interface->{DATA}; + my $count = 0; + foreach my $d (@{$data}) { + if ($d->{TYPE} eq "FUNCTION") { $count++; } + } + + next if ($count == 0); + + $res .= "\tstatus = dcom_$interface->{NAME}_init();\n"; + $res .= "\tif (NT_STATUS_IS_ERR(status)) {\n"; + $res .= "\t\treturn status;\n"; + $res .= "\t}\n\n"; + } + $res .= "\treturn status;\n"; + $res .= "}\n\n"; + + return $res; +} + +sub Parse($) +{ + my $pidl = shift; + my $res = ""; + + foreach my $x (@{$pidl}) { + next if ($x->{TYPE} ne "INTERFACE"); + next if has_property($x, "local"); + next unless has_property($x, "object"); + + $res .= ParseInterface($x); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm new file mode 100644 index 0000000000..150acbfde9 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm @@ -0,0 +1,327 @@ +################################################### +# DCOM stub boilerplate generator +# Copyright jelmer@samba.org 2004-2005 +# Copyright tridge@samba.org 2003 +# Copyright metze@samba.org 2004 +# released under the GNU GPL + +package Parse::Pidl::Samba4::COM::Stub; + +use Parse::Pidl::Util qw(has_property); +use strict; + +use vars qw($VERSION); +$VERSION = '0.01'; + +my($res); + +sub pidl($) +{ + $res .= shift; +} + +##################################################### +# generate the switch statement for function dispatch +sub gen_dispatch_switch($) +{ + my $data = shift; + + my $count = 0; + foreach my $d (@{$data}) { + next if ($d->{TYPE} ne "FUNCTION"); + + pidl "\tcase $count: {\n"; + if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") { + pidl "\t\tNTSTATUS result;\n"; + } + pidl "\t\tstruct $d->{NAME} *r2 = r;\n"; + pidl "\t\tif (DEBUGLEVEL > 10) {\n"; + pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_IN, r2);\n"; + pidl "\t\t}\n"; + if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") { + pidl "\t\tresult = vtable->$d->{NAME}(iface, mem_ctx, r2);\n"; + } else { + pidl "\t\tvtable->$d->{NAME}(iface, mem_ctx, r2);\n"; + } + pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; + pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} will reply async\\n\"));\n"; + pidl "\t\t}\n"; + pidl "\t\tbreak;\n\t}\n"; + $count++; + } +} + +##################################################### +# generate the switch statement for function reply +sub gen_reply_switch($) +{ + my $data = shift; + + my $count = 0; + foreach my $d (@{$data}) { + next if ($d->{TYPE} ne "FUNCTION"); + + pidl "\tcase $count: {\n"; + pidl "\t\tstruct $d->{NAME} *r2 = r;\n"; + pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; + pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} replied async\\n\"));\n"; + pidl "\t\t}\n"; + pidl "\t\tif (DEBUGLEVEL > 10 && dce_call->fault_code == 0) {\n"; + pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n"; + pidl "\t\t}\n"; + pidl "\t\tif (dce_call->fault_code != 0) {\n"; + pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $d->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n"; + pidl "\t\t}\n"; + pidl "\t\tbreak;\n\t}\n"; + $count++; + } +} + +##################################################################### +# produce boilerplate code for a interface +sub Boilerplate_Iface($) +{ + my($interface) = shift; + my($data) = $interface->{DATA}; + my $name = $interface->{NAME}; + my $uname = uc $name; + my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}); + my $if_version = $interface->{PROPERTIES}->{version}; + + pidl " +static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface) +{ +#ifdef DCESRV_INTERFACE_$uname\_BIND + return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface); +#else + return NT_STATUS_OK; +#endif +} + +static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface) +{ +#ifdef DCESRV_INTERFACE_$uname\_UNBIND + DCESRV_INTERFACE_$uname\_UNBIND(context, iface); +#else + return; +#endif +} + +static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r) +{ + NTSTATUS status; + uint16_t opnum = dce_call->pkt.u.request.opnum; + + dce_call->fault_code = 0; + + if (opnum >= dcerpc_table_$name.num_calls) { + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + return NT_STATUS_NET_WRITE_FAULT; + } + + *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size); + NT_STATUS_HAVE_NO_MEMORY(*r); + + /* unravel the NDR for the packet */ + status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); + if (!NT_STATUS_IS_OK(status)) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + dce_call->fault_code = DCERPC_FAULT_NDR; + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) +{ + uint16_t opnum = dce_call->pkt.u.request.opnum; + struct GUID ipid = dce_call->pkt.u.request.object.object; + struct dcom_interface_p *iface = dcom_get_local_iface_p(&ipid); + const struct dcom_$name\_vtable *vtable = iface->vtable; + + switch (opnum) { +"; + gen_dispatch_switch($data); + +pidl " + default: + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + break; + } + + if (dce_call->fault_code != 0) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) +{ + uint16_t opnum = dce_call->pkt.u.request.opnum; + + switch (opnum) { +"; + gen_reply_switch($data); + +pidl " + default: + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + break; + } + + if (dce_call->fault_code != 0) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r) +{ + NTSTATUS status; + uint16_t opnum = dce_call->pkt.u.request.opnum; + + status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); + if (!NT_STATUS_IS_OK(status)) { + dce_call->fault_code = DCERPC_FAULT_NDR; + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static const struct dcesrv_interface $name\_interface = { + .name = \"$name\", + .uuid = $uuid, + .if_version = $if_version, + .bind = $name\__op_bind, + .unbind = $name\__op_unbind, + .ndr_pull = $name\__op_ndr_pull, + .dispatch = $name\__op_dispatch, + .reply = $name\__op_reply, + .ndr_push = $name\__op_ndr_push +}; + +"; +} + +##################################################################### +# produce boilerplate code for an endpoint server +sub Boilerplate_Ep_Server($) +{ + my($interface) = shift; + my $name = $interface->{NAME}; + my $uname = uc $name; + + pidl " +static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server) +{ + int i; + + for (i=0;icount;i++) { + NTSTATUS ret; + const char *name = dcerpc_table_$name.endpoints->names[i]; + + ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL); + if (!NT_STATUS_IS_OK(ret)) { + DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name)); + return ret; + } + } + + return NT_STATUS_OK; +} + +static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version) +{ + if (dcerpc_table_$name.if_version == if_version && + strcmp(dcerpc_table_$name.uuid, uuid)==0) { + memcpy(iface,&dcerpc_table_$name, sizeof(*iface)); + return True; + } + + return False; +} + +static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) +{ + if (strcmp(dcerpc_table_$name.name, name)==0) { + memcpy(iface,&dcerpc_table_$name, sizeof(*iface)); + return True; + } + + return False; +} + +NTSTATUS dcerpc_server_$name\_init(void) +{ + NTSTATUS ret; + struct dcesrv_endpoint_server ep_server; + + /* fill in our name */ + ep_server.name = \"$name\"; + + /* fill in all the operations */ + ep_server.init_server = $name\__op_init_server; + + ep_server.interface_by_uuid = $name\__op_interface_by_uuid; + ep_server.interface_by_name = $name\__op_interface_by_name; + + /* register ourselves with the DCERPC subsystem. */ + ret = dcerpc_register_ep_server(&ep_server); + + if (!NT_STATUS_IS_OK(ret)) { + DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\")); + return ret; + } + + return ret; +} + +"; +} + +##################################################################### +# dcom interface stub from a parsed IDL structure +sub ParseInterface($) +{ + my($interface) = shift; + + return "" if has_property($interface, "local"); + + my($data) = $interface->{DATA}; + my $count = 0; + + $res = ""; + + if (!defined $interface->{PROPERTIES}->{uuid}) { + return $res; + } + + if (!defined $interface->{PROPERTIES}->{version}) { + $interface->{PROPERTIES}->{version} = "0.0"; + } + + foreach my $d (@{$data}) { + if ($d->{TYPE} eq "FUNCTION") { $count++; } + } + + if ($count == 0) { + return $res; + } + + $res = "/* dcom interface stub generated by pidl */\n\n"; + Boilerplate_Iface($interface); + Boilerplate_Ep_Server($interface); + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm new file mode 100644 index 0000000000..f5aea73d12 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -0,0 +1,839 @@ +################################################### +# EJS function wrapper generator +# Copyright jelmer@samba.org 2005 +# Copyright Andrew Tridgell 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba4::EJS; + +use strict; +use Parse::Pidl::Typelist; +use Parse::Pidl::Util qw(has_property); + +use vars qw($VERSION); +$VERSION = '0.01'; + +my($res); +my %constants; + +my $tabs = ""; +sub pidl($) +{ + my $d = shift; + if ($d) { + $res .= $tabs; + $res .= $d; + } + $res .= "\n"; +} + +sub indent() +{ + $tabs .= "\t"; +} + +sub deindent() +{ + $tabs = substr($tabs, 0, -1); +} + +# this should probably be in ndr.pm +sub GenerateStructEnv($) +{ + my $x = shift; + my %env; + + foreach my $e (@{$x->{ELEMENTS}}) { + if ($e->{NAME}) { + $env{$e->{NAME}} = "r->$e->{NAME}"; + } + } + + $env{"this"} = "r"; + + return \%env; +} + +sub GenerateFunctionInEnv($) +{ + my $fn = shift; + my %env; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->in.$e->{NAME}"; + } + } + + return \%env; +} + +sub GenerateFunctionOutEnv($) +{ + my $fn = shift; + my %env; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/out/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->out.$e->{NAME}"; + } elsif (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->in.$e->{NAME}"; + } + } + + return \%env; +} + +sub get_pointer_to($) +{ + my $var_name = shift; + + if ($var_name =~ /^\*(.*)$/) { + return $1; + } elsif ($var_name =~ /^\&(.*)$/) { + return "&($var_name)"; + } else { + return "&$var_name"; + } +} + +sub get_value_of($) +{ + my $var_name = shift; + + if ($var_name =~ /^\&(.*)$/) { + return $1; + } else { + return "*$var_name"; + } +} + +##################################################################### +# work out is a parse function should be declared static or not +sub fn_prefix($) +{ + my $fn = shift; + + return "" if (has_property($fn, "public")); + return "static "; +} + +########################### +# pull a scalar element +sub EjsPullScalar($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + + return if (has_property($e, "value")); + + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + $var = get_pointer_to($var); + # have to handle strings specially :( + if ($e->{TYPE} eq "string" && $pl && $pl->{TYPE} eq "POINTER") { + $var = get_pointer_to($var); + } + pidl "NDR_CHECK(ejs_pull_$e->{TYPE}(ejs, v, $name, $var));"; +} + +########################### +# pull a pointer element +sub EjsPullPointer($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + pidl "if (ejs_pull_null(ejs, v, $name)) {"; + indent; + pidl "$var = NULL;"; + deindent; + pidl "} else {"; + indent; + pidl "EJS_ALLOC(ejs, $var);"; + $var = get_value_of($var); + EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); + deindent; + pidl "}"; +} + +########################### +# pull a string element +sub EjsPullString($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + $var = get_pointer_to($var); + pidl "NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));"; +} + + +########################### +# pull an array element +sub EjsPullArray($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); + my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env); + my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env); + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + if ($pl && $pl->{TYPE} eq "POINTER") { + $var = get_pointer_to($var); + } + # uint8 arrays are treated as data blobs + if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { + if (!$l->{IS_FIXED}) { + pidl "EJS_ALLOC_N(ejs, $var, $size);"; + } + pidl "ejs_pull_array_uint8(ejs, v, $name, $var, $length);"; + return; + } + my $avar = $var . "[i]"; + pidl "{"; + indent; + pidl "uint32_t i;"; + if (!$l->{IS_FIXED}) { + pidl "EJS_ALLOC_N(ejs, $var, $size);"; + } + pidl "for (i=0;i<$length;i++) {"; + indent; + pidl "char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"; + EjsPullElement($e, $nl, $avar, "id", $env); + pidl "talloc_free(id);"; + deindent; + pidl "}"; + pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);"; + deindent; + pidl "}"; +} + +########################### +# pull a switch element +sub EjsPullSwitch($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env); + pidl "ejs_set_switch(ejs, $switch_var);"; + EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); +} + +########################### +# pull a structure element +sub EjsPullElement($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + if (has_property($e, "charset")) { + EjsPullString($e, $l, $var, $name, $env); + } elsif ($l->{TYPE} eq "ARRAY") { + EjsPullArray($e, $l, $var, $name, $env); + } elsif ($l->{TYPE} eq "DATA") { + EjsPullScalar($e, $l, $var, $name, $env); + } elsif (($l->{TYPE} eq "POINTER")) { + EjsPullPointer($e, $l, $var, $name, $env); + } elsif (($l->{TYPE} eq "SWITCH")) { + EjsPullSwitch($e, $l, $var, $name, $env); + } else { + pidl "return ejs_panic(ejs, \"unhandled pull type $l->{TYPE}\");"; + } +} + +############################################# +# pull a structure/union element at top level +sub EjsPullElementTop($$) +{ + my $e = shift; + my $env = shift; + my $l = $e->{LEVELS}[0]; + my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env); + my $name = "\"$e->{NAME}\""; + EjsPullElement($e, $l, $var, $name, $env); +} + +########################### +# pull a struct +sub EjsStructPull($$) +{ + my $name = shift; + my $d = shift; + my $env = GenerateStructEnv($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)\n{"; + indent; + pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; + foreach my $e (@{$d->{ELEMENTS}}) { + EjsPullElementTop($e, $env); + } + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + +########################### +# pull a union +sub EjsUnionPull($$) +{ + my $name = shift; + my $d = shift; + my $have_default = 0; + my $env = GenerateStructEnv($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)\n{"; + indent; + pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; + pidl "switch (ejs->switch_var) {"; + indent; + foreach my $e (@{$d->{ELEMENTS}}) { + if ($e->{CASE} eq "default") { + $have_default = 1; + } + pidl "$e->{CASE}:"; + indent; + if ($e->{TYPE} ne "EMPTY") { + EjsPullElementTop($e, $env); + } + pidl "break;"; + deindent; + } + if (! $have_default) { + pidl "default:"; + indent; + pidl "return ejs_panic(ejs, \"Bad switch value\");"; + deindent; + } + deindent; + pidl "}"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; +} + +############################################## +# put the enum elements in the constants array +sub EjsEnumConstant($) +{ + my $d = shift; + my $v = 0; + foreach my $e (@{$d->{ELEMENTS}}) { + my $el = $e; + chomp $el; + if ($el =~ /^(.*)=\s*(.*)\s*$/) { + $el = $1; + $v = $2; + } + $constants{$el} = $v; + $v++; + } +} + +########################### +# pull a enum +sub EjsEnumPull($$) +{ + my $name = shift; + my $d = shift; + EjsEnumConstant($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)\n{"; + indent; + pidl "unsigned e;"; + pidl "NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));"; + pidl "*r = e;"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + +########################### +# pull a bitmap +sub EjsBitmapPull($$) +{ + my $name = shift; + my $d = shift; + my $type_fn = $d->{BASE_TYPE}; + my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE}); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)\n{"; + indent; + pidl "return ejs_pull_$type_fn(ejs, v, name, r);"; + deindent; + pidl "}"; +} + + +########################### +# generate a structure pull +sub EjsTypedefPull($) +{ + my $d = shift; + return if (has_property($d, "noejs")); + if ($d->{DATA}->{TYPE} eq 'STRUCT') { + EjsStructPull($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'UNION') { + EjsUnionPull($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'ENUM') { + EjsEnumPull($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') { + EjsBitmapPull($d->{NAME}, $d->{DATA}); + } else { + warn "Unhandled pull typedef $d->{NAME} of type $d->{DATA}->{TYPE}"; + } +} + +##################### +# generate a function +sub EjsPullFunction($) +{ + my $d = shift; + my $env = GenerateFunctionInEnv($d); + my $name = $d->{NAME}; + + pidl "\nstatic NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, struct $name *r)"; + pidl "{"; + indent; + pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));"; + + # we pull non-array elements before array elements as arrays + # may have length_is() or size_is() properties that depend + # on the non-array elements + foreach my $e (@{$d->{ELEMENTS}}) { + next unless (grep(/in/, @{$e->{DIRECTION}})); + next if (has_property($e, "length_is") || + has_property($e, "size_is")); + EjsPullElementTop($e, $env); + } + + foreach my $e (@{$d->{ELEMENTS}}) { + next unless (grep(/in/, @{$e->{DIRECTION}})); + next unless (has_property($e, "length_is") || + has_property($e, "size_is")); + EjsPullElementTop($e, $env); + } + + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + + +########################### +# push a scalar element +sub EjsPushScalar($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + # have to handle strings specially :( + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + if ($e->{TYPE} ne "string" || ($pl && $pl->{TYPE} eq "POINTER")) { + $var = get_pointer_to($var); + } + pidl "NDR_CHECK(ejs_push_$e->{TYPE}(ejs, v, $name, $var));"; +} + +########################### +# push a string element +sub EjsPushString($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + pidl "NDR_CHECK(ejs_push_string(ejs, v, $name, $var));"; +} + +########################### +# push a pointer element +sub EjsPushPointer($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + pidl "if (NULL == $var) {"; + indent; + pidl "NDR_CHECK(ejs_push_null(ejs, v, $name));"; + deindent; + pidl "} else {"; + indent; + $var = get_value_of($var); + EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); + deindent; + pidl "}"; +} + +########################### +# push a switch element +sub EjsPushSwitch($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env); + pidl "ejs_set_switch(ejs, $switch_var);"; + EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); +} + + +########################### +# push an array element +sub EjsPushArray($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); + my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env); + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + if ($pl && $pl->{TYPE} eq "POINTER") { + $var = get_pointer_to($var); + } + # uint8 arrays are treated as data blobs + if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { + pidl "ejs_push_array_uint8(ejs, v, $name, $var, $length);"; + return; + } + my $avar = $var . "[i]"; + pidl "{"; + indent; + pidl "uint32_t i;"; + pidl "for (i=0;i<$length;i++) {"; + indent; + pidl "const char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"; + EjsPushElement($e, $nl, $avar, "id", $env); + deindent; + pidl "}"; + pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);"; + deindent; + pidl "}"; +} + +################################ +# push a structure/union element +sub EjsPushElement($$$$$) +{ + my ($e, $l, $var, $name, $env) = @_; + if (has_property($e, "charset")) { + EjsPushString($e, $l, $var, $name, $env); + } elsif ($l->{TYPE} eq "ARRAY") { + EjsPushArray($e, $l, $var, $name, $env); + } elsif ($l->{TYPE} eq "DATA") { + EjsPushScalar($e, $l, $var, $name, $env); + } elsif (($l->{TYPE} eq "POINTER")) { + EjsPushPointer($e, $l, $var, $name, $env); + } elsif (($l->{TYPE} eq "SWITCH")) { + EjsPushSwitch($e, $l, $var, $name, $env); + } else { + pidl "return ejs_panic(ejs, \"unhandled push type $l->{TYPE}\");"; + } +} + +############################################# +# push a structure/union element at top level +sub EjsPushElementTop($$) +{ + my $e = shift; + my $env = shift; + my $l = $e->{LEVELS}[0]; + my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env); + my $name = "\"$e->{NAME}\""; + EjsPushElement($e, $l, $var, $name, $env); +} + +########################### +# push a struct +sub EjsStructPush($$) +{ + my $name = shift; + my $d = shift; + my $env = GenerateStructEnv($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)\n{"; + indent; + pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; + foreach my $e (@{$d->{ELEMENTS}}) { + EjsPushElementTop($e, $env); + } + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + +########################### +# push a union +sub EjsUnionPush($$) +{ + my $name = shift; + my $d = shift; + my $have_default = 0; + my $env = GenerateStructEnv($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)\n{"; + indent; + pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; + pidl "switch (ejs->switch_var) {"; + indent; + foreach my $e (@{$d->{ELEMENTS}}) { + if ($e->{CASE} eq "default") { + $have_default = 1; + } + pidl "$e->{CASE}:"; + indent; + if ($e->{TYPE} ne "EMPTY") { + EjsPushElementTop($e, $env); + } + pidl "break;"; + deindent; + } + if (! $have_default) { + pidl "default:"; + indent; + pidl "return ejs_panic(ejs, \"Bad switch value\");"; + deindent; + } + deindent; + pidl "}"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; +} + +########################### +# push a enum +sub EjsEnumPush($$) +{ + my $name = shift; + my $d = shift; + EjsEnumConstant($d); + pidl fn_prefix($d); + pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)\n{"; + indent; + pidl "unsigned e = *r;"; + pidl "NDR_CHECK(ejs_push_enum(ejs, v, name, &e));"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + +########################### +# push a bitmap +sub EjsBitmapPush($$) +{ + my $name = shift; + my $d = shift; + my $type_fn = $d->{BASE_TYPE}; + my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE}); + # put the bitmap elements in the constants array + foreach my $e (@{$d->{ELEMENTS}}) { + if ($e =~ /^(\w*)\s*(.*)\s*$/) { + my $bname = $1; + my $v = $2; + $constants{$bname} = $v; + } + } + pidl fn_prefix($d); + pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)\n{"; + indent; + pidl "return ejs_push_$type_fn(ejs, v, name, r);"; + deindent; + pidl "}"; +} + + +########################### +# generate a structure push +sub EjsTypedefPush($) +{ + my $d = shift; + return if (has_property($d, "noejs")); + if ($d->{DATA}->{TYPE} eq 'STRUCT') { + EjsStructPush($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'UNION') { + EjsUnionPush($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'ENUM') { + EjsEnumPush($d->{NAME}, $d->{DATA}); + } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') { + EjsBitmapPush($d->{NAME}, $d->{DATA}); + } else { + warn "Unhandled push typedef $d->{NAME} of type $d->{DATA}->{TYPE}"; + } +} + + +##################### +# generate a function +sub EjsPushFunction($) +{ + my $d = shift; + my $env = GenerateFunctionOutEnv($d); + + pidl "\nstatic NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const struct $d->{NAME} *r)"; + pidl "{"; + indent; + pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));"; + + foreach my $e (@{$d->{ELEMENTS}}) { + next unless (grep(/out/, @{$e->{DIRECTION}})); + EjsPushElementTop($e, $env); + } + + if ($d->{RETURN_TYPE}) { + my $t = $d->{RETURN_TYPE}; + pidl "NDR_CHECK(ejs_push_$t(ejs, v, \"result\", &r->out.result));"; + } + + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}\n"; +} + + +################################# +# generate a ejs mapping function +sub EjsFunction($$) +{ + my $d = shift; + my $iface = shift; + my $name = $d->{NAME}; + my $callnum = uc("DCERPC_$name"); + my $table = "&dcerpc_table_$iface"; + + pidl "static int ejs_$name(int eid, int argc, struct MprVar **argv)"; + pidl "{"; + indent; + pidl "return ejs_rpc_call(eid, argc, argv, $table, $callnum, (ejs_pull_function_t)ejs_pull_$name, (ejs_push_function_t)ejs_push_$name);"; + deindent; + pidl "}\n"; +} + +################### +# handle a constant +sub EjsConst($) +{ + my $const = shift; + $constants{$const->{NAME}} = $const->{VALUE}; +} + +##################################################################### +# parse the interface definitions +sub EjsInterface($$) +{ + my($interface,$needed) = @_; + my @fns = (); + my $name = $interface->{NAME}; + + %constants = (); + + foreach my $d (@{$interface->{TYPEDEFS}}) { + ($needed->{"push_$d->{NAME}"}) && EjsTypedefPush($d); + ($needed->{"pull_$d->{NAME}"}) && EjsTypedefPull($d); + } + + foreach my $d (@{$interface->{FUNCTIONS}}) { + next if not defined($d->{OPNUM}); + next if Parse::Pidl::Util::has_property($d, "noejs"); + + EjsPullFunction($d); + EjsPushFunction($d); + EjsFunction($d, $name); + + push (@fns, $d->{NAME}); + } + + foreach my $d (@{$interface->{CONSTS}}) { + EjsConst($d); + } + + pidl "static int ejs_$name\_init(int eid, int argc, struct MprVar **argv)"; + pidl "{"; + indent; + pidl "struct MprVar *obj = mprInitObject(eid, \"$name\", argc, argv);"; + foreach (@fns) { + pidl "mprSetCFunction(obj, \"$_\", ejs_$_);"; + } + foreach my $v (keys %constants) { + my $value = $constants{$v}; + if (substr($value, 0, 1) eq "\"") { + pidl "mprSetVar(obj, \"$v\", mprString($value));"; + } else { + pidl "mprSetVar(obj, \"$v\", mprCreateNumberVar($value));"; + } + } + pidl "return ejs_rpc_init(obj, \"$name\");"; + deindent; + pidl "}\n"; + + pidl "NTSTATUS ejs_init_$name(void)"; + pidl "{"; + indent; + pidl "return smbcalls_register_ejs(\"$name\_init\", ejs_$name\_init);"; + deindent; + pidl "}"; +} + +##################################################################### +# parse a parsed IDL into a C header +sub Parse($$) +{ + my($ndr,$hdr) = @_; + + my $ejs_hdr = $hdr; + $ejs_hdr =~ s/.h$/_ejs.h/; + $res = ""; + pidl " +/* EJS wrapper functions auto-generated by pidl */ +#include \"includes.h\" +#include \"lib/appweb/ejs/ejs.h\" +#include \"scripting/ejs/ejsrpc.h\" +#include \"scripting/ejs/smbcalls.h\" +#include \"librpc/gen_ndr/ndr_misc_ejs.h\" +#include \"$hdr\" +#include \"$ejs_hdr\" + +"; + + my %needed = (); + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed); + } + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && EjsInterface($x, \%needed); + } + + return $res; +} + +sub NeededFunction($$) +{ + my ($fn,$needed) = @_; + $needed->{"pull_$fn->{NAME}"} = 1; + $needed->{"push_$fn->{NAME}"} = 1; + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/in/, @{$e->{DIRECTION}})) { + $needed->{"pull_$e->{TYPE}"} = 1; + } + if (grep (/out/, @{$e->{DIRECTION}})) { + $needed->{"push_$e->{TYPE}"} = 1; + } + } +} + +sub NeededTypedef($$) +{ + my ($t,$needed) = @_; + if (Parse::Pidl::Util::has_property($t, "public")) { + $needed->{"pull_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs"); + $needed->{"push_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs"); + } + if ($t->{DATA}->{TYPE} ne "STRUCT" && + $t->{DATA}->{TYPE} ne "UNION") { + return; + } + for my $e (@{$t->{DATA}->{ELEMENTS}}) { + if ($needed->{"pull_$t->{NAME}"}) { + $needed->{"pull_$e->{TYPE}"} = 1; + } + if ($needed->{"push_$t->{NAME}"}) { + $needed->{"push_$e->{TYPE}"} = 1; + } + } +} + +##################################################################### +# work out what parse functions are needed +sub NeededInterface($$) +{ + my ($interface,$needed) = @_; + foreach my $d (@{$interface->{FUNCTIONS}}) { + NeededFunction($d, $needed); + } + foreach my $d (reverse @{$interface->{TYPEDEFS}}) { + NeededTypedef($d, $needed); + } +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm new file mode 100644 index 0000000000..a204ee7a56 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm @@ -0,0 +1,79 @@ +################################################### +# create C header files for an EJS mapping functions +# Copyright tridge@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba4::EJSHeader; + +use strict; +use Parse::Pidl::Typelist; +use Parse::Pidl::Util qw(has_property); + +use vars qw($VERSION); +$VERSION = '0.01'; + +my($res); + +sub pidl ($) +{ + $res .= shift; +} + +##################################################################### +# prototype a typedef +sub HeaderTypedefProto($) +{ + my $d = shift; + my $name = $d->{NAME}; + + return unless has_property($d, "public"); + + my $type_decl = Parse::Pidl::Typelist::mapType($name); + + pidl "NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, const $type_decl *);\n"; + pidl "NTSTATUS ejs_pull_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, $type_decl *);\n"; +} + +##################################################################### +# parse the interface definitions +sub HeaderInterface($) +{ + my($interface) = shift; + + my $count = 0; + + pidl "#ifndef _HEADER_EJS_$interface->{NAME}\n"; + pidl "#define _HEADER_EJS_$interface->{NAME}\n\n"; + + if (defined $interface->{PROPERTIES}->{depends}) { + my @d = split / /, $interface->{PROPERTIES}->{depends}; + foreach my $i (@d) { + pidl "#include \"librpc/gen_ndr/ndr_$i\_ejs\.h\"\n"; + } + } + + pidl "\n"; + + foreach my $d (@{$interface->{TYPEDEFS}}) { + HeaderTypedefProto($d); + } + + pidl "\n"; + pidl "#endif /* _HEADER_EJS_$interface->{NAME} */\n"; +} + +##################################################################### +# parse a parsed IDL into a C header +sub Parse($) +{ + my($idl) = shift; + + $res = ""; + pidl "/* header auto-generated by pidl */\n\n"; + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); + } + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm new file mode 100644 index 0000000000..a1c568cdc7 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -0,0 +1,361 @@ +################################################### +# create C header files for an IDL structure +# Copyright tridge@samba.org 2000 +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba4::Header; + +use strict; +use Parse::Pidl::Typelist qw(mapType); +use Parse::Pidl::Util qw(has_property is_constant); +use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); + +use vars qw($VERSION); +$VERSION = '0.01'; + +my($res); +my($tab_depth); + +sub pidl ($) +{ + $res .= shift; +} + +sub tabs() +{ + my $res = ""; + $res .="\t" foreach (1..$tab_depth); + return $res; +} + +##################################################################### +# parse a properties list +sub HeaderProperties($$) +{ + my($props,$ignores) = @_; + my $ret = ""; + + foreach my $d (keys %{$props}) { + next if (grep(/^$d$/, @$ignores)); + if($props->{$d} ne "1") { + $ret.= "$d($props->{$d}),"; + } else { + $ret.="$d,"; + } + } + + if ($ret) { + pidl "/* [" . substr($ret, 0, -1) . "] */"; + } +} + +##################################################################### +# parse a structure element +sub HeaderElement($) +{ + my($element) = shift; + + pidl tabs(); + HeaderType($element, $element->{TYPE}, ""); + pidl " "; + my $numstar = $element->{POINTERS}; + if ($numstar >= 1) { + $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); + } + foreach (@{$element->{ARRAY_LEN}}) + { + next if is_constant($_) and + not has_property($element, "charset"); + $numstar++; + } + pidl "*" foreach (1..$numstar); + pidl $element->{NAME}; + foreach (@{$element->{ARRAY_LEN}}) { + next unless (is_constant($_) and + not has_property($element, "charset")); + pidl "[$_]"; + } + + pidl ";"; + if (defined $element->{PROPERTIES}) { + HeaderProperties($element->{PROPERTIES}, ["in", "out"]); + } + pidl "\n"; +} + +##################################################################### +# parse a struct +sub HeaderStruct($$) +{ + my($struct,$name) = @_; + pidl "struct $name {\n"; + $tab_depth++; + my $el_count=0; + if (defined $struct->{ELEMENTS}) { + foreach my $e (@{$struct->{ELEMENTS}}) { + HeaderElement($e); + $el_count++; + } + } + if ($el_count == 0) { + # some compilers can't handle empty structures + pidl tabs()."char _empty_;\n"; + } + $tab_depth--; + pidl tabs()."}"; + if (defined $struct->{PROPERTIES}) { + HeaderProperties($struct->{PROPERTIES}, []); + } +} + +##################################################################### +# parse a enum +sub HeaderEnum($$) +{ + my($enum,$name) = @_; + my $first = 1; + + if (not Parse::Pidl::Util::useUintEnums()) { + pidl "enum $name {\n"; + $tab_depth++; + foreach my $e (@{$enum->{ELEMENTS}}) { + unless ($first) { pidl ",\n"; } + $first = 0; + pidl tabs(); + pidl $e; + } + pidl "\n"; + $tab_depth--; + pidl "}"; + } else { + my $count = 0; + pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n"; + my $with_val = 0; + my $without_val = 0; + foreach my $e (@{$enum->{ELEMENTS}}) { + my $t = "$e"; + my $name; + my $value; + if ($t =~ /(.*)=(.*)/) { + $name = $1; + $value = $2; + $with_val = 1; + die ("you can't mix enum member with values and without values when using --uint-enums!") + unless ($without_val == 0); + } else { + $name = $t; + $value = $count++; + $without_val = 1; + die ("you can't mix enum member with values and without values when using --uint-enums!") + unless ($with_val == 0); + } + pidl "#define $name ( $value )\n"; + } + pidl "\n"; + } +} + +##################################################################### +# parse a bitmap +sub HeaderBitmap($$) +{ + my($bitmap,$name) = @_; + + pidl "/* bitmap $name */\n"; + pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}}); + pidl "\n"; +} + +##################################################################### +# parse a union +sub HeaderUnion($$) +{ + my($union,$name) = @_; + my %done = (); + + pidl "union $name {\n"; + $tab_depth++; + foreach my $e (@{$union->{ELEMENTS}}) { + if ($e->{TYPE} ne "EMPTY") { + if (! defined $done{$e->{NAME}}) { + HeaderElement($e); + } + $done{$e->{NAME}} = 1; + } + } + $tab_depth--; + pidl "}"; + + if (defined $union->{PROPERTIES}) { + HeaderProperties($union->{PROPERTIES}, []); + } +} + +##################################################################### +# parse a type +sub HeaderType($$$) +{ + my($e,$data,$name) = @_; + if (ref($data) eq "HASH") { + ($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name); + ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data, $name); + ($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name); + ($data->{TYPE} eq "UNION") && HeaderUnion($data, $name); + return; + } + + if (has_property($e, "charset")) { + pidl "const char"; + } else { + pidl mapType($e->{TYPE}); + } +} + +##################################################################### +# parse a typedef +sub HeaderTypedef($) +{ + my($typedef) = shift; + HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); + pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP"); +} + +##################################################################### +# parse a const +sub HeaderConst($) +{ + my($const) = shift; + if (!defined($const->{ARRAY_LEN}[0])) { + pidl "#define $const->{NAME}\t( $const->{VALUE} )\n"; + } else { + pidl "#define $const->{NAME}\t $const->{VALUE}\n"; + } +} + +##################################################################### +# parse a function +sub HeaderFunctionInOut($$) +{ + my($fn,$prop) = @_; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (has_property($e, $prop)) { + HeaderElement($e); + } + } +} + +##################################################################### +# determine if we need an "in" or "out" section +sub HeaderFunctionInOut_needed($$) +{ + my($fn,$prop) = @_; + + return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void"); + + foreach (@{$fn->{ELEMENTS}}) { + return 1 if (has_property($_, $prop)); + } + + return undef; +} + +my %headerstructs = (); + +##################################################################### +# parse a function +sub HeaderFunction($) +{ + my($fn) = shift; + + return if ($headerstructs{$fn->{NAME}}); + + $headerstructs{$fn->{NAME}} = 1; + + pidl "\nstruct $fn->{NAME} {\n"; + $tab_depth++; + my $needed = 0; + + if (HeaderFunctionInOut_needed($fn, "in")) { + pidl tabs()."struct {\n"; + $tab_depth++; + HeaderFunctionInOut($fn, "in"); + $tab_depth--; + pidl tabs()."} in;\n\n"; + $needed++; + } + + if (HeaderFunctionInOut_needed($fn, "out")) { + pidl tabs()."struct {\n"; + $tab_depth++; + HeaderFunctionInOut($fn, "out"); + if ($fn->{RETURN_TYPE} ne "void") { + pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n"; + } + $tab_depth--; + pidl tabs()."} out;\n\n"; + $needed++; + } + + if (! $needed) { + # sigh - some compilers don't like empty structures + pidl tabs()."int _dummy_element;\n"; + } + + $tab_depth--; + pidl "};\n\n"; +} + +##################################################################### +# parse the interface definitions +sub HeaderInterface($) +{ + my($interface) = shift; + + my $count = 0; + + pidl "#ifndef _HEADER_$interface->{NAME}\n"; + pidl "#define _HEADER_$interface->{NAME}\n\n"; + + if (defined $interface->{PROPERTIES}->{depends}) { + my @d = split / /, $interface->{PROPERTIES}->{depends}; + foreach my $i (@d) { + pidl "#include \"librpc/gen_ndr/$i\.h\"\n"; + } + } + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "CONST"); + HeaderConst($d); + } + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "TYPEDEF"); + HeaderTypedef($d); + } + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "FUNCTION"); + HeaderFunction($d); + } + + pidl "#endif /* _HEADER_$interface->{NAME} */\n"; +} + +##################################################################### +# parse a parsed IDL into a C header +sub Parse($) +{ + my($idl) = shift; + $tab_depth = 0; + + $res = ""; + pidl "/* header auto-generated by pidl */\n\n"; + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); + } + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm new file mode 100644 index 0000000000..83f9034c7c --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -0,0 +1,102 @@ +################################################### +# client calls generator +# Copyright tridge@samba.org 2003 +# released under the GNU GPL + +package Parse::Pidl::Samba4::NDR::Client; + +use vars qw($VERSION); +$VERSION = '0.01'; + +use strict; + +my($res); + +##################################################################### +# parse a function +sub ParseFunction($$) +{ + my ($interface, $fn) = @_; + my $name = $fn->{NAME}; + my $uname = uc $name; + + $res .= " +struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) +{ + if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) { + NDR_PRINT_IN_DEBUG($name, r); + } + + return dcerpc_ndr_request_send(p, NULL, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, r); +} + +NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) +{ + struct rpc_request *req; + NTSTATUS status; + + req = dcerpc_$name\_send(p, mem_ctx, r); + if (req == NULL) return NT_STATUS_NO_MEMORY; + + status = dcerpc_ndr_request_recv(req); + + if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { + NDR_PRINT_OUT_DEBUG($name, r); + } +"; + + if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") { + $res .= "\tif (NT_STATUS_IS_OK(status)) status = r->out.result;\n"; + } + $res .= +" + return status; +} +"; +} + +my %done; + +##################################################################### +# parse the interface definitions +sub ParseInterface($) +{ + my($interface) = shift; + $res .= "/* $interface->{NAME} - client functions generated by pidl */\n\n"; + + foreach my $fn (@{$interface->{FUNCTIONS}}) { + next if not defined($fn->{OPNUM}); + next if defined($done{$fn->{NAME}}); + ParseFunction($interface, $fn); + $done{$fn->{NAME}} = 1; + } + + return $res; +} + +sub Parse($$) +{ + my($ndr) = shift; + my($filename) = shift; + + my $h_filename = $filename; + $res = ""; + + if ($h_filename =~ /(.*)\.c/) { + $h_filename = "$1.h"; + } + + $res .= "/* client functions auto-generated by pidl */\n"; + $res .= "\n"; + $res .= "#include \"includes.h\"\n"; + $res .= "#include \"$h_filename\"\n"; + $res .= "\n"; + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && ParseInterface($x); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm new file mode 100644 index 0000000000..d55a7a12af --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm @@ -0,0 +1,169 @@ +################################################### +# create C header files for an IDL structure +# Copyright tridge@samba.org 2000 +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba4::NDR::Header; + +use strict; +use Parse::Pidl::Typelist qw(mapType); +use Parse::Pidl::Util qw(has_property is_constant); +use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); +use Parse::Pidl::Samba4::NDR::Parser; + +use vars qw($VERSION); +$VERSION = '0.01'; + +my($res); +my($tab_depth); + +sub pidl ($) +{ + $res .= shift; +} + +sub tabs() +{ + my $res = ""; + $res .="\t" foreach (1..$tab_depth); + return $res; +} + +##################################################################### +# prototype a typedef +sub HeaderTypedefProto($) +{ + my($d) = shift; + + my $tf = Parse::Pidl::Samba4::NDR::Parser::get_typefamily($d->{DATA}{TYPE}); + + if (has_property($d, "gensize")) { + my $size_args = $tf->{SIZE_FN_ARGS}->($d); + pidl "size_t ndr_size_$d->{NAME}($size_args);\n"; + } + + return unless has_property($d, "public"); + + unless (has_property($d, "nopush")) { + pidl "NTSTATUS ndr_push_$d->{NAME}(struct ndr_push *ndr, int ndr_flags, " . $tf->{DECL}->($d, "push") . ");\n"; + } + unless (has_property($d, "nopull")) { + pidl "NTSTATUS ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, " . $tf->{DECL}->($d, "pull") . ");\n"; + } + unless (has_property($d, "noprint")) { + pidl "void ndr_print_$d->{NAME}(struct ndr_print *ndr, const char *name, " . $tf->{DECL}->($d, "print") . ");\n"; + } +} + +##################################################################### +# output prototypes for a IDL function +sub HeaderFnProto($$) +{ + my ($interface,$fn) = @_; + my $name = $fn->{NAME}; + + pidl "void ndr_print_$name(struct ndr_print *ndr, const char *name, int flags, const struct $name *r);\n"; + + unless (has_property($fn, "noopnum")) { + pidl "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n"; + pidl "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n"; + } + + return unless has_property($fn, "public"); + + pidl "NTSTATUS ndr_push_$name(struct ndr_push *ndr, int flags, const struct $name *r);\n"; + pidl "NTSTATUS ndr_pull_$name(struct ndr_pull *ndr, int flags, struct $name *r);\n"; + + pidl "\n"; +} + +##################################################################### +# parse the interface definitions +sub HeaderInterface($) +{ + my($interface) = shift; + + if (defined $interface->{PROPERTIES}->{depends}) { + my @d = split / /, $interface->{PROPERTIES}->{depends}; + foreach my $i (@d) { + pidl "#include \"librpc/gen_ndr/ndr_$i\.h\"\n"; + } + } + + my $count = 0; + + pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n"; + pidl "#define _HEADER_NDR_$interface->{NAME}\n\n"; + + if (defined $interface->{PROPERTIES}->{uuid}) { + my $name = uc $interface->{NAME}; + pidl "#define DCERPC_$name\_UUID " . + Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})) . "\n"; + + if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; } + pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n"; + + pidl "#define DCERPC_$name\_NAME \"$interface->{NAME}\"\n"; + + if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; } + pidl "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}\n"; + + pidl "\nextern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n"; + pidl "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);\n\n"; + } + + foreach my $d (@{$interface->{DATA}}) { + next if $d->{TYPE} ne "FUNCTION"; + next if has_property($d, "noopnum"); + next if grep(/$d->{NAME}/,@{$interface->{INHERITED_FUNCTIONS}}); + my $u_name = uc $d->{NAME}; + pidl "#define DCERPC_$u_name ("; + + if (defined($interface->{BASE})) { + pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + "; + } + + pidl sprintf("0x%02x", $count) . ")\n"; + $count++; + } + + pidl "\n#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ("; + + if (defined($interface->{BASE})) { + pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + "; + } + + pidl "$count)\n\n"; + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "TYPEDEF"); + HeaderTypedefProto($d); + } + + foreach my $d (@{$interface->{DATA}}) { + next if ($d->{TYPE} ne "FUNCTION"); + HeaderFnProto($interface, $d); + } + + pidl "#endif /* _HEADER_NDR_$interface->{NAME} */\n"; +} + +##################################################################### +# parse a parsed IDL into a C header +sub Parse($$) +{ + my($idl,$basename) = @_; + $tab_depth = 0; + + $res = ""; + pidl "/* header auto-generated by pidl */\n"; + pidl "#include \"librpc/gen_ndr/$basename\.h\"\n\n"; + + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); + } + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm new file mode 100644 index 0000000000..a7ea60b2e4 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -0,0 +1,2389 @@ +################################################### +# Samba4 NDR parser generator for IDL structures +# Copyright tridge@samba.org 2000-2003 +# Copyright tpot@samba.org 2001 +# Copyright jelmer@samba.org 2004-2005 +# released under the GNU GPL + +package Parse::Pidl::Samba4::NDR::Parser; + +use strict; +use Parse::Pidl::Typelist qw(hasType getType mapType); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); + +use vars qw($VERSION); +$VERSION = '0.01'; + +# list of known types +my %typefamily; + +sub get_typefamily($) +{ + my $n = shift; + return $typefamily{$n}; +} + +sub append_prefix($$) +{ + my ($e, $var_name) = @_; + my $pointers = 0; + + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER") { + $pointers++; + } elsif ($l->{TYPE} eq "ARRAY") { + if (($pointers == 0) and + (not $l->{IS_FIXED}) and + (not $l->{IS_INLINE})) { + return get_value_of($var_name); + } + } elsif ($l->{TYPE} eq "DATA") { + if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + return get_value_of($var_name) unless ($pointers); + } + } + } + + return $var_name; +} + +sub has_fast_array($$) +{ + my ($e,$l) = @_; + + return 0 if ($l->{TYPE} ne "ARRAY"); + + my $nl = GetNextLevel($e,$l); + return 0 unless ($nl->{TYPE} eq "DATA"); + return 0 unless (hasType($nl->{DATA_TYPE})); + + my $t = getType($nl->{DATA_TYPE}); + + # Only uint8 and string have fast array functions at the moment + return ($t->{NAME} eq "uint8") or ($t->{NAME} eq "string"); +} + +sub is_charset_array($$) +{ + my ($e,$l) = @_; + + return 0 if ($l->{TYPE} ne "ARRAY"); + + my $nl = GetNextLevel($e,$l); + + return 0 unless ($nl->{TYPE} eq "DATA"); + + return has_property($e, "charset"); +} + +sub get_pointer_to($) +{ + my $var_name = shift; + + if ($var_name =~ /^\*(.*)$/) { + return $1; + } elsif ($var_name =~ /^\&(.*)$/) { + return "&($var_name)"; + } else { + return "&$var_name"; + } +} + +sub get_value_of($) +{ + my $var_name = shift; + + if ($var_name =~ /^\&(.*)$/) { + return $1; + } else { + return "*$var_name"; + } +} + +my $res = ""; +my $deferred = ""; +my $tabs = ""; + +#################################### +# pidl() is our basic output routine +sub pidl($) +{ + my $d = shift; + if ($d) { + $res .= $tabs; + $res .= $d; + } + $res .="\n"; +} + +#################################### +# defer() is like pidl(), but adds to +# a deferred buffer which is then added to the +# output buffer at the end of the structure/union/function +# This is needed to cope with code that must be pushed back +# to the end of a block of elements +sub defer($) +{ + my $d = shift; + if ($d) { + $deferred .= $tabs; + $deferred .= $d; + } + $deferred .="\n"; +} + +######################################## +# add the deferred content to the current +# output +sub add_deferred() +{ + $res .= $deferred; + $deferred = ""; +} + +sub indent() +{ + $tabs .= "\t"; +} + +sub deindent() +{ + $tabs = substr($tabs, 0, -1); +} + +##################################################################### +# check that a variable we get from ParseExpr isn't a null pointer +sub check_null_pointer($) +{ + my $size = shift; + if ($size =~ /^\*/) { + my $size2 = substr($size, 1); + pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; + } +} + +##################################################################### +# check that a variable we get from ParseExpr isn't a null pointer, +# putting the check at the end of the structure/function +sub check_null_pointer_deferred($) +{ + my $size = shift; + if ($size =~ /^\*/) { + my $size2 = substr($size, 1); + defer "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; + } +} + +##################################################################### +# check that a variable we get from ParseExpr isn't a null pointer +# void return varient +sub check_null_pointer_void($) +{ + my $size = shift; + if ($size =~ /^\*/) { + my $size2 = substr($size, 1); + pidl "if ($size2 == NULL) return;"; + } +} + +##################################################################### +# work out is a parse function should be declared static or not +sub fn_prefix($) +{ + my $fn = shift; + + return "" if (has_property($fn, "public")); + return "static "; +} + +################################################################### +# setup any special flags for an element or structure +sub start_flags($) +{ + my $e = shift; + my $flags = has_property($e, "flag"); + if (defined $flags) { + pidl "{"; + indent; + pidl "uint32_t _flags_save_$e->{TYPE} = ndr->flags;"; + pidl "ndr_set_flags(&ndr->flags, $flags);"; + } +} + +################################################################### +# end any special flags for an element or structure +sub end_flags($) +{ + my $e = shift; + my $flags = has_property($e, "flag"); + if (defined $flags) { + pidl "ndr->flags = _flags_save_$e->{TYPE};"; + deindent; + pidl "}"; + } +} + +sub GenerateStructEnv($) +{ + my $x = shift; + my %env; + + foreach my $e (@{$x->{ELEMENTS}}) { + $env{$e->{NAME}} = "r->$e->{NAME}"; + } + + $env{"this"} = "r"; + + return \%env; +} + +sub EnvSubstituteValue($$) +{ + my ($env,$s) = @_; + + # Substitute the value() values in the env + foreach my $e (@{$s->{ELEMENTS}}) { + next unless (my $v = has_property($e, "value")); + + $env->{$e->{NAME}} = ParseExpr($v, $env); + } + + return $env; +} + +sub GenerateFunctionInEnv($) +{ + my $fn = shift; + my %env; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->in.$e->{NAME}"; + } + } + + return \%env; +} + +sub GenerateFunctionOutEnv($) +{ + my $fn = shift; + my %env; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/out/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->out.$e->{NAME}"; + } elsif (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r->in.$e->{NAME}"; + } + } + + return \%env; +} + +##################################################################### +# parse the data of an array - push side +sub ParseArrayPushHeader($$$$$) +{ + my ($e,$l,$ndr,$var_name,$env) = @_; + + my $size; + my $length; + + if ($l->{IS_ZERO_TERMINATED}) { + if (has_property($e, "charset")) { + $size = $length = "ndr_charset_length($var_name, CH_$e->{PROPERTIES}->{charset})"; + } else { + $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))"; + } + } else { + $size = ParseExpr($l->{SIZE_IS}, $env); + $length = ParseExpr($l->{LENGTH_IS}, $env); + } + + if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { + pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));"; + } + + if ($l->{IS_VARYING}) { + pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));"; # array offset + pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));"; + } + + return $length; +} + +##################################################################### +# parse an array - pull side +sub ParseArrayPullHeader($$$$$) +{ + my ($e,$l,$ndr,$var_name,$env) = @_; + + my $length; + my $size; + + if ($l->{IS_CONFORMANT}) { + $length = $size = "ndr_get_array_size($ndr, " . get_pointer_to($var_name) . ")"; + } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays + $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))"; + } else { + $length = $size = ParseExpr($l->{SIZE_IS}, $env); + } + + if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { + pidl "NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));"; + } + + + if ($l->{IS_VARYING}) { + pidl "NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));"; + $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")"; + } + + check_null_pointer($length); + + if ($length ne $size) { + pidl "if ($length > $size) {"; + indent; + pidl "return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);"; + deindent; + pidl "}"; + } + + if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { + my $size = ParseExpr($l->{SIZE_IS}, $env); + defer "if ($var_name) {"; + check_null_pointer_deferred($size); + defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"; + defer "}"; + } + + if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { + my $length = ParseExpr($l->{LENGTH_IS}, $env); + defer "if ($var_name) {"; + check_null_pointer_deferred($length); + defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"; + defer "}" + } + + if (not $l->{IS_FIXED} and not is_charset_array($e, $l)) { + AllocateArrayLevel($e,$l,$ndr,$env,$size); + } + + return $length; +} + +sub compression_alg($$) +{ + my ($e,$l) = @_; + my $compression = $l->{COMPRESSION}; + my ($alg, $clen, $dlen) = split(/ /, $compression); + + return $alg; +} + +sub compression_clen($$$) +{ + my ($e,$l,$env) = @_; + my $compression = $l->{COMPRESSION}; + my ($alg, $clen, $dlen) = split(/ /, $compression); + + return ParseExpr($clen, $env); +} + +sub compression_dlen($$$) +{ + my ($e,$l,$env) = @_; + my $compression = $l->{COMPRESSION}; + my ($alg, $clen, $dlen) = split(/ /, $compression); + + return ParseExpr($dlen, $env); +} + +sub ParseCompressionPushStart($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $comndr = "$ndr\_compressed"; + my $alg = compression_alg($e, $l); + my $dlen = compression_dlen($e, $l, $env); + + pidl "{"; + indent; + pidl "struct ndr_push *$comndr;"; + pidl "NDR_CHECK(ndr_push_compression_start($ndr, &$comndr, $alg, $dlen));"; + + return $comndr; +} + +sub ParseCompressionPushEnd($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $comndr = "$ndr\_compressed"; + my $alg = compression_alg($e, $l); + my $dlen = compression_dlen($e, $l, $env); + + pidl "NDR_CHECK(ndr_push_compression_end($ndr, $comndr, $alg, $dlen));"; + deindent; + pidl "}"; +} + +sub ParseCompressionPullStart($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $comndr = "$ndr\_compressed"; + my $alg = compression_alg($e, $l); + my $dlen = compression_dlen($e, $l, $env); + + pidl "{"; + indent; + pidl "struct ndr_pull *$comndr;"; + pidl "NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen));"; + + return $comndr; +} + +sub ParseCompressionPullEnd($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $comndr = "$ndr\_compressed"; + my $alg = compression_alg($e, $l); + my $dlen = compression_dlen($e, $l, $env); + + pidl "NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));"; + deindent; + pidl "}"; +} + +sub ParseObfuscationPushStart($$) +{ + my ($e,$ndr) = @_; + my $obfuscation = has_property($e, "obfuscation"); + + pidl "NDR_CHECK(ndr_push_obfuscation_start($ndr, $obfuscation));"; + + return $ndr; +} + +sub ParseObfuscationPushEnd($$) +{ + my ($e,$ndr) = @_; + my $obfuscation = has_property($e, "obfuscation"); + + pidl "NDR_CHECK(ndr_push_obfuscation_end($ndr, $obfuscation));"; +} + +sub ParseObfuscationPullStart($$) +{ + my ($e,$ndr) = @_; + my $obfuscation = has_property($e, "obfuscation"); + + pidl "NDR_CHECK(ndr_pull_obfuscation_start($ndr, $obfuscation));"; + + return $ndr; +} + +sub ParseObfuscationPullEnd($$) +{ + my ($e,$ndr) = @_; + my $obfuscation = has_property($e, "obfuscation"); + + pidl "NDR_CHECK(ndr_pull_obfuscation_end($ndr, $obfuscation));"; +} + +sub ParseSubcontextPushStart($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $subndr = "_ndr_$e->{NAME}"; + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + + pidl "{"; + indent; + pidl "struct ndr_push *$subndr;"; + pidl "NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + + if (defined $l->{COMPRESSION}) { + $subndr = ParseCompressionPushStart($e, $l, $subndr, $env); + } + + if (defined $l->{OBFUSCATION}) { + $subndr = ParseObfuscationPushStart($e, $subndr); + } + + return $subndr; +} + +sub ParseSubcontextPushEnd($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $subndr = "_ndr_$e->{NAME}"; + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + + if (defined $l->{COMPRESSION}) { + ParseCompressionPushEnd($e, $l, $subndr, $env); + } + + if (defined $l->{OBFUSCATION}) { + ParseObfuscationPushEnd($e, $subndr); + } + + pidl "NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + deindent; + pidl "}"; +} + +sub ParseSubcontextPullStart($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $subndr = "_ndr_$e->{NAME}"; + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + + pidl "{"; + indent; + pidl "struct ndr_pull *$subndr;"; + pidl "NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + + if (defined $l->{COMPRESSION}) { + $subndr = ParseCompressionPullStart($e, $l, $subndr, $env); + } + + if (defined $l->{OBFUSCATION}) { + $subndr = ParseObfuscationPullStart($e, $subndr); + } + + return $subndr; +} + +sub ParseSubcontextPullEnd($$$$) +{ + my ($e,$l,$ndr,$env) = @_; + my $subndr = "_ndr_$e->{NAME}"; + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + + if (defined $l->{COMPRESSION}) { + ParseCompressionPullEnd($e, $l, $subndr, $env); + } + + if (defined $l->{OBFUSCATION}) { + ParseObfuscationPullEnd($e, $subndr); + } + + pidl "NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + deindent; + pidl "}"; +} + +sub ParseElementPushLevel +{ + my ($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; + + my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); + + if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING})) { + $var_name = get_pointer_to($var_name); + } + + if (defined($ndr_flags)) { + if ($l->{TYPE} eq "SUBCONTEXT") { + my $subndr = ParseSubcontextPushStart($e, $l, $ndr, $env); + ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1); + ParseSubcontextPushEnd($e, $l, $ndr, $env); + } elsif ($l->{TYPE} eq "POINTER") { + ParsePtrPush($e, $l, $var_name); + } elsif ($l->{TYPE} eq "ARRAY") { + my $length = ParseArrayPushHeader($e, $l, $ndr, $var_name, $env); + + my $nl = GetNextLevel($e, $l); + + # Allow speedups for arrays of scalar types + if (is_charset_array($e,$l)) { + pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; + return; + } elsif (has_fast_array($e,$l)) { + pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; + return; + } + } elsif ($l->{TYPE} eq "SWITCH") { + ParseSwitchPush($e, $l, $ndr, $var_name, $ndr_flags, $env); + } elsif ($l->{TYPE} eq "DATA") { + ParseDataPush($e, $l, $ndr, $var_name, $ndr_flags); + } + } + + if ($l->{TYPE} eq "POINTER" and $deferred) { + if ($l->{POINTER_TYPE} ne "ref") { + pidl "if ($var_name) {"; + indent; + if ($l->{POINTER_TYPE} eq "relative") { + pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));"; + } + } + $var_name = get_value_of($var_name); + ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1); + + if ($l->{POINTER_TYPE} ne "ref") { + deindent; + pidl "}"; + } + } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and + not is_charset_array($e, $l)) { + my $length = ParseExpr($l->{LENGTH_IS}, $env); + my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; + + $var_name = $var_name . "[$counter]"; + + if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { + pidl "for ($counter = 0; $counter < $length; $counter++) {"; + indent; + ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0); + deindent; + pidl "}"; + } + + if ($deferred and ContainsDeferred($e, $l)) { + pidl "for ($counter = 0; $counter < $length; $counter++) {"; + indent; + ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1); + deindent; + pidl "}"; + } + } elsif ($l->{TYPE} eq "SWITCH") { + ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred); + } +} + +##################################################################### +# parse scalars in a structure element +sub ParseElementPush($$$$$$) +{ + my ($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_; + my $subndr = undef; + + my $var_name = $var_prefix.$e->{NAME}; + + $var_name = append_prefix($e, $var_name); + + return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); + + start_flags($e); + + if (my $value = has_property($e, "value")) { + $var_name = ParseExpr($value, $env); + } + + ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred); + + end_flags($e); +} + +##################################################################### +# parse a pointer in a struct element or function +sub ParsePtrPush($$$) +{ + my ($e,$l,$var_name) = @_; + + if ($l->{POINTER_TYPE} eq "ref") { + if ($l->{LEVEL} eq "EMBEDDED") { + pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_name));"; + } else { + check_null_pointer(get_value_of($var_name)); + } + } elsif ($l->{POINTER_TYPE} eq "relative") { + pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));"; + } elsif ($l->{POINTER_TYPE} eq "unique") { + pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));"; + } elsif ($l->{POINTER_TYPE} eq "sptr") { + pidl "NDR_CHECK(ndr_push_sptr_ptr(ndr, $var_name));"; + } else { + die("Unhandled pointer type $l->{POINTER_TYPE}"); + } +} + +##################################################################### +# print scalars in a structure element +sub ParseElementPrint($$$) +{ + my($e,$var_name,$env) = @_; + + $var_name = append_prefix($e, $var_name); + return if (has_property($e, "noprint")); + + if (my $value = has_property($e, "value")) { + $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env) . ":$var_name"; + } + + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER") { + pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);"; + pidl "ndr->depth++;"; + if ($l->{POINTER_TYPE} ne "ref") { + pidl "if ($var_name) {"; + indent; + } + $var_name = get_value_of($var_name); + } elsif ($l->{TYPE} eq "ARRAY") { + my $length; + + if ($l->{IS_CONFORMANT} or $l->{IS_VARYING}) { + $var_name = get_pointer_to($var_name); + } + + if ($l->{IS_ZERO_TERMINATED}) { + $length = "ndr_string_length($var_name, sizeof(*$var_name))"; + } else { + $length = ParseExpr($l->{LENGTH_IS}, $env); + } + + if (is_charset_array($e,$l)) { + pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);"; + last; + } elsif (has_fast_array($e, $l)) { + my $nl = GetNextLevel($e, $l); + pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);"; + last; + } else { + my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; + + pidl "ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);"; + pidl 'ndr->depth++;'; + pidl "for ($counter=0;$counter<$length;$counter++) {"; + indent; + pidl "char *idx_$l->{LEVEL_INDEX}=NULL;"; + pidl "asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);"; + pidl "if (idx_$l->{LEVEL_INDEX}) {"; + indent; + + $var_name = $var_name . "[$counter]"; + } + } elsif ($l->{TYPE} eq "DATA") { + if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + $var_name = get_pointer_to($var_name); + } + pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; + } elsif ($l->{TYPE} eq "SWITCH") { + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); + check_null_pointer_void($switch_var); + pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"; + } + } + + foreach my $l (reverse @{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER") { + if ($l->{POINTER_TYPE} ne "ref") { + deindent; + pidl "}"; + } + pidl "ndr->depth--;"; + } elsif (($l->{TYPE} eq "ARRAY") + and not is_charset_array($e,$l) + and not has_fast_array($e,$l)) { + pidl "free(idx_$l->{LEVEL_INDEX});"; + deindent; + pidl "}"; + deindent; + pidl "}"; + pidl "ndr->depth--;"; + } + } +} + +##################################################################### +# parse scalars in a structure element - pull size +sub ParseSwitchPull($$$$$$) +{ + my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); + + check_null_pointer($switch_var); + + $var_name = get_pointer_to($var_name); + pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));"; +} + +##################################################################### +# push switch element +sub ParseSwitchPush($$$$$$) +{ + my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); + + check_null_pointer($switch_var); + $var_name = get_pointer_to($var_name); + pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"; +} + +sub ParseDataPull($$$$$) +{ + my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; + + if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + $var_name = get_pointer_to($var_name); + } + + $var_name = get_pointer_to($var_name); + + pidl "NDR_CHECK(ndr_pull_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));"; + + if (my $range = has_property($e, "range")) { + $var_name = get_value_of($var_name); + my ($low, $high) = split(/ /, $range, 2); + pidl "if ($var_name < $low || $var_name > $high) {"; + pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");"; + pidl "}"; + } +} + +sub ParseDataPush($$$$$) +{ + my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; + + # strings are passed by value rather then reference + if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + $var_name = get_pointer_to($var_name); + } + + pidl "NDR_CHECK(ndr_push_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));"; +} + +sub CalcNdrFlags($$$) +{ + my ($l,$primitives,$deferred) = @_; + + my $scalars = 0; + my $buffers = 0; + + # Add NDR_SCALARS if this one is deferred + # and deferreds may be pushed + $scalars = 1 if ($l->{IS_DEFERRED} and $deferred); + + # Add NDR_SCALARS if this one is not deferred and + # primitives may be pushed + $scalars = 1 if (!$l->{IS_DEFERRED} and $primitives); + + # Add NDR_BUFFERS if this one contains deferred stuff + # and deferreds may be pushed + $buffers = 1 if ($l->{CONTAINS_DEFERRED} and $deferred); + + return "NDR_SCALARS|NDR_BUFFERS" if ($scalars and $buffers); + return "NDR_SCALARS" if ($scalars); + return "NDR_BUFFERS" if ($buffers); + return undef; +} + +sub ParseMemCtxPullStart($$$) +{ + my $e = shift; + my $l = shift; + my $ptr_name = shift; + + my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; + my $mem_c_ctx = $ptr_name; + my $mem_c_flags = "0"; + + return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}); + + if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { + my $nl = GetNextLevel($e, $l); + my $next_is_array = ($nl->{TYPE} eq "ARRAY"); + my $next_is_string = (($nl->{TYPE} eq "DATA") and + ($nl->{DATA_TYPE} eq "string")); + if ($next_is_array or $next_is_string) { + return; + } else { + $mem_c_flags = "LIBNDR_FLAG_REF_ALLOC"; + } + } + + pidl "$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);"; + pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);"; +} + +sub ParseMemCtxPullEnd($$) +{ + my $e = shift; + my $l = shift; + + my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; + my $mem_r_flags = "0"; + + return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}); + + if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { + my $nl = GetNextLevel($e, $l); + my $next_is_array = ($nl->{TYPE} eq "ARRAY"); + my $next_is_string = (($nl->{TYPE} eq "DATA") and + ($nl->{DATA_TYPE} eq "string")); + if ($next_is_array or $next_is_string) { + return; + } else { + $mem_r_flags = "LIBNDR_FLAG_REF_ALLOC"; + } + } + + pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);"; +} + +sub CheckStringTerminator($$$$) +{ + my ($ndr,$e,$l,$length) = @_; + my $nl = GetNextLevel($e, $l); + + # Make sure last element is zero! + pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $length, sizeof($nl->{DATA_TYPE}_t)));"; +} + +sub ParseElementPullLevel +{ + my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; + + my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); + + if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT})) { + $var_name = get_pointer_to($var_name); + } + + # Only pull something if there's actually something to be pulled + if (defined($ndr_flags)) { + if ($l->{TYPE} eq "SUBCONTEXT") { + my $subndr = ParseSubcontextPullStart($e, $l, $ndr, $env); + ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1); + ParseSubcontextPullEnd($e, $l, $ndr, $env); + } elsif ($l->{TYPE} eq "ARRAY") { + my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env); + + my $nl = GetNextLevel($e, $l); + + if (is_charset_array($e,$l)) { + if ($l->{IS_ZERO_TERMINATED}) { + CheckStringTerminator($ndr, $e, $l, $length); + } + pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; + return; + } elsif (has_fast_array($e, $l)) { + if ($l->{IS_ZERO_TERMINATED}) { + CheckStringTerminator($ndr,$e,$l,$length); + } + pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; + return; + } + } elsif ($l->{TYPE} eq "POINTER") { + ParsePtrPull($e, $l, $ndr, $var_name); + } elsif ($l->{TYPE} eq "SWITCH") { + ParseSwitchPull($e, $l, $ndr, $var_name, $ndr_flags, $env); + } elsif ($l->{TYPE} eq "DATA") { + ParseDataPull($e, $l, $ndr, $var_name, $ndr_flags); + } + } + + # add additional constructions + if ($l->{TYPE} eq "POINTER" and $deferred) { + if ($l->{POINTER_TYPE} ne "ref") { + pidl "if ($var_name) {"; + indent; + + if ($l->{POINTER_TYPE} eq "relative") { + pidl "struct ndr_pull_save _relative_save;"; + pidl "ndr_pull_save(ndr, &_relative_save);"; + pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));"; + } + } + + ParseMemCtxPullStart($e,$l, $var_name); + + $var_name = get_value_of($var_name); + ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); + + ParseMemCtxPullEnd($e,$l); + + if ($l->{POINTER_TYPE} ne "ref") { + if ($l->{POINTER_TYPE} eq "relative") { + pidl "ndr_pull_restore(ndr, &_relative_save);"; + } + deindent; + pidl "}"; + } + } elsif ($l->{TYPE} eq "ARRAY" and + not has_fast_array($e,$l) and not is_charset_array($e, $l)) { + my $length = ParseExpr($l->{LENGTH_IS}, $env); + my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; + my $array_name = $var_name; + + $var_name = $var_name . "[$counter]"; + + ParseMemCtxPullStart($e,$l, $array_name); + + if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { + my $nl = GetNextLevel($e,$l); + + if ($l->{IS_ZERO_TERMINATED}) { + CheckStringTerminator($ndr,$e,$l,$length); + } + + pidl "for ($counter = 0; $counter < $length; $counter++) {"; + indent; + ParseElementPullLevel($e, $nl, $ndr, $var_name, $env, 1, 0); + deindent; + pidl "}"; + } + + if ($deferred and ContainsDeferred($e, $l)) { + pidl "for ($counter = 0; $counter < $length; $counter++) {"; + indent; + ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1); + deindent; + pidl "}"; + } + + ParseMemCtxPullEnd($e,$l); + + } elsif ($l->{TYPE} eq "SWITCH") { + ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred); + } +} + +##################################################################### +# parse scalars in a structure element - pull size +sub ParseElementPull($$$$$$) +{ + my($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_; + + my $var_name = $var_prefix.$e->{NAME}; + + $var_name = append_prefix($e, $var_name); + + return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); + + start_flags($e); + + ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred); + + end_flags($e); +} + +##################################################################### +# parse a pointer in a struct element or function +sub ParsePtrPull($$$$) +{ + my($e,$l,$ndr,$var_name) = @_; + + my $nl = GetNextLevel($e, $l); + my $next_is_array = ($nl->{TYPE} eq "ARRAY"); + my $next_is_string = (($nl->{TYPE} eq "DATA") and + ($nl->{DATA_TYPE} eq "string")); + + if ($l->{POINTER_TYPE} eq "ref") { + unless ($l->{LEVEL} eq "TOP") { + pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"; + } + + unless ($next_is_array or $next_is_string) { + pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; + pidl "\tNDR_PULL_ALLOC($ndr, $var_name);"; + pidl "}"; + } + + return; + } elsif (($l->{POINTER_TYPE} eq "unique") or + ($l->{POINTER_TYPE} eq "relative") or + ($l->{POINTER_TYPE} eq "sptr")) { + pidl "NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));"; + pidl "if (_ptr_$e->{NAME}) {"; + indent; + } else { + die("Unhandled pointer type $l->{POINTER_TYPE}"); + } + + # Don't do this for arrays, they're allocated at the actual level + # of the array + unless ($next_is_array or $next_is_string) { + pidl "NDR_PULL_ALLOC($ndr, $var_name);"; + } else { + # FIXME: Yes, this is nasty. + # We allocate an array twice + # - once just to indicate that it's there, + # - then the real allocation... + pidl "NDR_PULL_ALLOC_SIZE($ndr, $var_name, 1);"; + } + + #pidl "memset($var_name, 0, sizeof($var_name));"; + if ($l->{POINTER_TYPE} eq "relative") { + pidl "NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));"; + } + deindent; + pidl "} else {"; + pidl "\t$var_name = NULL;"; + pidl "}"; +} + +##################################################################### +# parse a struct +sub ParseStructPush($$) +{ + my($struct,$name) = @_; + + return unless defined($struct->{ELEMENTS}); + + my $env = GenerateStructEnv($struct); + + EnvSubstituteValue($env, $struct); + + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base}); + + foreach my $e (@{$struct->{ELEMENTS}}) { + DeclareArrayVariables($e); + } + + start_flags($struct); + + # see if the structure contains a conformant array. If it + # does, then it must be the last element of the structure, and + # we need to push the conformant length early, as it fits on + # the wire before the structure (and even before the structure + # alignment) + if (defined($struct->{SURROUNDING_ELEMENT})) { + my $e = $struct->{SURROUNDING_ELEMENT}; + + if (defined($e->{LEVELS}[0]) and + $e->{LEVELS}[0]->{TYPE} eq "ARRAY") { + my $size; + + if ($e->{LEVELS}[0]->{IS_ZERO_TERMINATED}) { + if (has_property($e, "charset")) { + $size = "ndr_charset_length(r->$e->{NAME}, CH_$e->{PROPERTIES}->{charset})"; + } else { + $size = "ndr_string_length(r->$e->{NAME}, sizeof(*r->$e->{NAME}))"; + } + } else { + $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env); + } + + pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; + } else { + pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));"; + } + } + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + + pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));"; + + if (defined($struct->{PROPERTIES}{relative_base})) { + # set the current offset as base for relative pointers + # and store it based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));"; + } + + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPush($e, "ndr", "r->", $env, 1, 0); + } + + deindent; + pidl "}"; + + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + if (defined($struct->{PROPERTIES}{relative_base})) { + # retrieve the current offset as base for relative pointers + # based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));"; + } + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPush($e, "ndr", "r->", $env, 0, 1); + } + + deindent; + pidl "}"; + + end_flags($struct); + # restore the old relative_base_offset + pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base}); +} + +##################################################################### +# generate a push function for an enum +sub ParseEnumPush($$) +{ + my($enum,$name) = @_; + my($type_fn) = $enum->{BASE_TYPE}; + + start_flags($enum); + pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; + end_flags($enum); +} + +##################################################################### +# generate a pull function for an enum +sub ParseEnumPull($$) +{ + my($enum,$name) = @_; + my($type_fn) = $enum->{BASE_TYPE}; + my($type_v_decl) = mapType($type_fn); + + pidl "$type_v_decl v;"; + start_flags($enum); + pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; + pidl "*r = v;"; + + end_flags($enum); +} + +##################################################################### +# generate a print function for an enum +sub ParseEnumPrint($$) +{ + my($enum,$name) = @_; + + pidl "const char *val = NULL;"; + pidl ""; + + start_flags($enum); + + pidl "switch (r) {"; + indent; + my $els = \@{$enum->{ELEMENTS}}; + foreach my $i (0 .. $#{$els}) { + my $e = ${$els}[$i]; + chomp $e; + if ($e =~ /^(.*)=/) { + $e = $1; + } + pidl "case $e: val = \"$e\"; break;"; + } + + deindent; + pidl "}"; + + pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);"; + + end_flags($enum); +} + +sub DeclEnum($) +{ + my ($e,$t) = @_; + return "enum $e->{NAME} " . + ($t eq "pull"?"*":"") . "r"; +} + +$typefamily{ENUM} = { + DECL => \&DeclEnum, + PUSH_FN_BODY => \&ParseEnumPush, + PULL_FN_BODY => \&ParseEnumPull, + PRINT_FN_BODY => \&ParseEnumPrint, +}; + +##################################################################### +# generate a push function for a bitmap +sub ParseBitmapPush($$) +{ + my($bitmap,$name) = @_; + my($type_fn) = $bitmap->{BASE_TYPE}; + + start_flags($bitmap); + + pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; + + end_flags($bitmap); +} + +##################################################################### +# generate a pull function for an bitmap +sub ParseBitmapPull($$) +{ + my($bitmap,$name) = @_; + my $type_fn = $bitmap->{BASE_TYPE}; + my($type_decl) = mapType($bitmap->{BASE_TYPE}); + + pidl "$type_decl v;"; + start_flags($bitmap); + pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; + pidl "*r = v;"; + + end_flags($bitmap); +} + +##################################################################### +# generate a print function for an bitmap +sub ParseBitmapPrintElement($$$) +{ + my($e,$bitmap,$name) = @_; + my($type_decl) = mapType($bitmap->{BASE_TYPE}); + my($type_fn) = $bitmap->{BASE_TYPE}; + my($flag); + + if ($e =~ /^(\w+) .*$/) { + $flag = "$1"; + } else { + die "Bitmap: \"$name\" invalid Flag: \"$e\""; + } + + pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);"; +} + +##################################################################### +# generate a print function for an bitmap +sub ParseBitmapPrint($$) +{ + my($bitmap,$name) = @_; + my($type_decl) = mapType($bitmap->{TYPE}); + my($type_fn) = $bitmap->{BASE_TYPE}; + + start_flags($bitmap); + + pidl "ndr_print_$type_fn(ndr, name, r);"; + + pidl "ndr->depth++;"; + foreach my $e (@{$bitmap->{ELEMENTS}}) { + ParseBitmapPrintElement($e, $bitmap, $name); + } + pidl "ndr->depth--;"; + + end_flags($bitmap); +} + +sub DeclBitmap($$) +{ + my ($e,$t) = @_; + return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e->{DATA})) . + ($t eq "pull"?" *":" ") . "r"; +} + +$typefamily{BITMAP} = { + DECL => \&DeclBitmap, + PUSH_FN_BODY => \&ParseBitmapPush, + PULL_FN_BODY => \&ParseBitmapPull, + PRINT_FN_BODY => \&ParseBitmapPrint, +}; + +##################################################################### +# generate a struct print function +sub ParseStructPrint($$) +{ + my($struct,$name) = @_; + + return unless defined $struct->{ELEMENTS}; + + my $env = GenerateStructEnv($struct); + + EnvSubstituteValue($env, $struct); + + foreach my $e (@{$struct->{ELEMENTS}}) { + DeclareArrayVariables($e); + } + + pidl "ndr_print_struct(ndr, name, \"$name\");"; + + start_flags($struct); + + pidl "ndr->depth++;"; + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPrint($e, "r->$e->{NAME}", $env); + } + pidl "ndr->depth--;"; + + end_flags($struct); +} + +sub DeclarePtrVariables($) +{ + my $e = shift; + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER" and + not ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP")) { + pidl "uint32_t _ptr_$e->{NAME};"; + last; + } + } +} + +sub DeclareArrayVariables($) +{ + my $e = shift; + + foreach my $l (@{$e->{LEVELS}}) { + next if has_fast_array($e,$l); + next if is_charset_array($e,$l); + if ($l->{TYPE} eq "ARRAY") { + pidl "uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};"; + } + } +} + +sub need_decl_mem_ctx($$) +{ + my $e = shift; + my $l = shift; + + return 0 if has_fast_array($e,$l); + return 0 if is_charset_array($e,$l); + return 1 if (($l->{TYPE} eq "ARRAY") and not $l->{IS_FIXED}); + + if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { + my $nl = GetNextLevel($e, $l); + my $next_is_array = ($nl->{TYPE} eq "ARRAY"); + my $next_is_string = (($nl->{TYPE} eq "DATA") and + ($nl->{DATA_TYPE} eq "string")); + return 0 if ($next_is_array or $next_is_string); + } + return 1 if ($l->{TYPE} eq "POINTER"); + + return 0; +} + +sub DeclareMemCtxVariables($) +{ + my $e = shift; + foreach my $l (@{$e->{LEVELS}}) { + if (need_decl_mem_ctx($e, $l)) { + pidl "TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};"; + } + } +} + +##################################################################### +# parse a struct - pull side +sub ParseStructPull($$) +{ + my($struct,$name) = @_; + + return unless defined $struct->{ELEMENTS}; + + my $env = GenerateStructEnv($struct); + + # declare any internal pointers we need + foreach my $e (@{$struct->{ELEMENTS}}) { + DeclarePtrVariables($e); + DeclareArrayVariables($e); + DeclareMemCtxVariables($e); + } + + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base}); + + start_flags($struct); + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + + if (defined $struct->{SURROUNDING_ELEMENT}) { + pidl "NDR_CHECK(ndr_pull_array_size(ndr, &r->$struct->{SURROUNDING_ELEMENT}->{NAME}));"; + } + + pidl "NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));"; + + if (defined($struct->{PROPERTIES}{relative_base})) { + # set the current offset as base for relative pointers + # and store it based on the toplevel struct/union + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));"; + } + + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPull($e, "ndr", "r->", $env, 1, 0); + } + + add_deferred(); + + deindent; + pidl "}"; + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + if (defined($struct->{PROPERTIES}{relative_base})) { + # retrieve the current offset as base for relative pointers + # based on the toplevel struct/union + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));"; + } + foreach my $e (@{$struct->{ELEMENTS}}) { + ParseElementPull($e, "ndr", "r->", $env, 0, 1); + } + + add_deferred(); + + deindent; + pidl "}"; + + end_flags($struct); + # restore the old relative_base_offset + pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base}); +} + +##################################################################### +# calculate size of ndr struct +sub ParseStructNdrSize($) +{ + my $t = shift; + my $sizevar; + + if (my $flags = has_property($t, "flag")) { + pidl "flags |= $flags;"; + } + pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});"; +} + +sub DeclStruct($) +{ + my ($e,$t) = @_; + return ($t ne "pull"?"const ":"") . "struct $e->{NAME} *r"; +} + +sub ArgsStructNdrSize($) +{ + my $d = shift; + return "const struct $d->{NAME} *r, int flags"; +} + +$typefamily{STRUCT} = { + PUSH_FN_BODY => \&ParseStructPush, + DECL => \&DeclStruct, + PULL_FN_BODY => \&ParseStructPull, + PRINT_FN_BODY => \&ParseStructPrint, + SIZE_FN_BODY => \&ParseStructNdrSize, + SIZE_FN_ARGS => \&ArgsStructNdrSize, +}; + +##################################################################### +# calculate size of ndr struct +sub ParseUnionNdrSize($) +{ + my $t = shift; + my $sizevar; + + if (my $flags = has_property($t, "flag")) { + pidl "flags |= $flags;"; + } + + pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});"; +} + +##################################################################### +# parse a union - push side +sub ParseUnionPush($$) +{ + my ($e,$name) = @_; + my $have_default = 0; + + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base}); + pidl "int level;"; + + start_flags($e); + + pidl "level = ndr_push_get_switch_value(ndr, r);"; + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + + if (defined($e->{SWITCH_TYPE})) { + pidl "NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));"; + } + + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + if ($el->{CASE} eq "default") { + $have_default = 1; + } + pidl "$el->{CASE}:"; + + if ($el->{TYPE} ne "EMPTY") { + indent; + if (defined($e->{PROPERTIES}{relative_base})) { + pidl "NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));"; + # set the current offset as base for relative pointers + # and store it based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));"; + } + DeclareArrayVariables($el); + ParseElementPush($el, "ndr", "r->", {}, 1, 0); + deindent; + } + pidl "break;"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + } + deindent; + pidl "}"; + deindent; + pidl "}"; + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + if (defined($e->{PROPERTIES}{relative_base})) { + # retrieve the current offset as base for relative pointers + # based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));"; + } + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + pidl "$el->{CASE}:"; + if ($el->{TYPE} ne "EMPTY") { + indent; + ParseElementPush($el, "ndr", "r->", {}, 0, 1); + deindent; + } + pidl "break;"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + } + deindent; + pidl "}"; + + deindent; + pidl "}"; + end_flags($e); + # restore the old relative_base_offset + pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); +} + +##################################################################### +# print a union +sub ParseUnionPrint($$) +{ + my ($e,$name) = @_; + my $have_default = 0; + + pidl "int level;"; + foreach my $el (@{$e->{ELEMENTS}}) { + DeclareArrayVariables($el); + } + + start_flags($e); + + pidl "level = ndr_print_get_switch_value(ndr, r);"; + + pidl "ndr_print_union(ndr, name, level, \"$name\");"; + + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + if ($el->{CASE} eq "default") { + $have_default = 1; + } + pidl "$el->{CASE}:"; + if ($el->{TYPE} ne "EMPTY") { + indent; + ParseElementPrint($el, "r->$el->{NAME}", {}); + deindent; + } + pidl "break;"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\tndr_print_bad_level(ndr, name, level);"; + } + deindent; + pidl "}"; + + end_flags($e); +} + +##################################################################### +# parse a union - pull side +sub ParseUnionPull($$) +{ + my ($e,$name) = @_; + my $have_default = 0; + my $switch_type = $e->{SWITCH_TYPE}; + + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base}); + pidl "int level;"; + if (defined($switch_type)) { + if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) { + $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)); + } + pidl mapType($switch_type) . " _level;"; + } + + my %double_cases = (); + foreach my $el (@{$e->{ELEMENTS}}) { + next if ($el->{TYPE} eq "EMPTY"); + next if ($double_cases{"$el->{NAME}"}); + DeclareMemCtxVariables($el); + $double_cases{"$el->{NAME}"} = 1; + } + + start_flags($e); + + pidl "level = ndr_pull_get_switch_value(ndr, r);"; + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + + if (defined($switch_type)) { + pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));"; + pidl "if (_level != level) {"; + pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $name\", _level);"; + pidl "}"; + } + + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + if ($el->{CASE} eq "default") { + $have_default = 1; + } + pidl "$el->{CASE}: {"; + + if ($el->{TYPE} ne "EMPTY") { + indent; + DeclarePtrVariables($el); + DeclareArrayVariables($el); + if (defined($e->{PROPERTIES}{relative_base})) { + pidl "NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));"; + # set the current offset as base for relative pointers + # and store it based on the toplevel struct/union + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));"; + } + ParseElementPull($el, "ndr", "r->", {}, 1, 0); + deindent; + } + pidl "break; }"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + } + deindent; + pidl "}"; + deindent; + pidl "}"; + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + if (defined($e->{PROPERTIES}{relative_base})) { + # retrieve the current offset as base for relative pointers + # based on the toplevel struct/union + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));"; + } + pidl "switch (level) {"; + indent; + foreach my $el (@{$e->{ELEMENTS}}) { + pidl "$el->{CASE}:"; + if ($el->{TYPE} ne "EMPTY") { + indent; + ParseElementPull($el, "ndr", "r->", {}, 0, 1); + deindent; + } + pidl "break;"; + pidl ""; + } + if (! $have_default) { + pidl "default:"; + pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + } + deindent; + pidl "}"; + + deindent; + pidl "}"; + + add_deferred(); + + end_flags($e); + # restore the old relative_base_offset + pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); +} + +sub DeclUnion($$) +{ + my ($e,$t) = @_; + return ($t ne "pull"?"const ":"") . "union $e->{NAME} *r"; +} + +sub ArgsUnionNdrSize($) +{ + my $d = shift; + return "const union $d->{NAME} *r, uint32_t level, int flags"; +} + +$typefamily{UNION} = { + PUSH_FN_BODY => \&ParseUnionPush, + DECL => \&DeclUnion, + PULL_FN_BODY => \&ParseUnionPull, + PRINT_FN_BODY => \&ParseUnionPrint, + SIZE_FN_ARGS => \&ArgsUnionNdrSize, + SIZE_FN_BODY => \&ParseUnionNdrSize, +}; + +##################################################################### +# parse a typedef - push side +sub ParseTypedefPush($) +{ + my($e) = shift; + + my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push"); + pidl fn_prefix($e) . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)"; + + pidl "{"; + indent; + $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $e->{NAME}); + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl "";; +} + +##################################################################### +# parse a typedef - pull side +sub ParseTypedefPull($) +{ + my($e) = shift; + + my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull"); + + pidl fn_prefix($e) . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)"; + + pidl "{"; + indent; + $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $e->{NAME}); + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse a typedef - print side +sub ParseTypedefPrint($) +{ + my($e) = shift; + + my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print"); + + pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; + pidl "{"; + indent; + $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME}); + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +## calculate the size of a structure +sub ParseTypedefNdrSize($) +{ + my($t) = shift; + + my $tf = $typefamily{$t->{DATA}->{TYPE}}; + my $args = $tf->{SIZE_FN_ARGS}->($t); + + pidl "size_t ndr_size_$t->{NAME}($args)"; + pidl "{"; + indent; + $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t); + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse a function - print side +sub ParseFunctionPrint($) +{ + my($fn) = shift; + + return if has_property($fn, "noprint"); + + pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; + pidl "{"; + indent; + + foreach my $e (@{$fn->{ELEMENTS}}) { + DeclareArrayVariables($e); + } + + pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");"; + pidl "ndr->depth++;"; + + pidl "if (flags & NDR_SET_VALUES) {"; + pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;"; + pidl "}"; + + pidl "if (flags & NDR_IN) {"; + indent; + pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");"; + pidl "ndr->depth++;"; + + my $env = GenerateFunctionInEnv($fn); + EnvSubstituteValue($env, $fn); + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/in/,@{$e->{DIRECTION}})) { + ParseElementPrint($e, "r->in.$e->{NAME}", $env); + } + } + pidl "ndr->depth--;"; + deindent; + pidl "}"; + + pidl "if (flags & NDR_OUT) {"; + indent; + pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");"; + pidl "ndr->depth++;"; + + $env = GenerateFunctionOutEnv($fn); + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/out/,@{$e->{DIRECTION}})) { + ParseElementPrint($e, "r->out.$e->{NAME}", $env); + } + } + if ($fn->{RETURN_TYPE}) { + pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);"; + } + pidl "ndr->depth--;"; + deindent; + pidl "}"; + + pidl "ndr->depth--;"; + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse a function +sub ParseFunctionPush($) +{ + my($fn) = shift; + + return if has_property($fn, "nopush"); + + pidl fn_prefix($fn) . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)"; + pidl "{"; + indent; + + foreach my $e (@{$fn->{ELEMENTS}}) { + DeclareArrayVariables($e); + } + + pidl "if (flags & NDR_IN) {"; + indent; + + my $env = GenerateFunctionInEnv($fn); + + EnvSubstituteValue($env, $fn); + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/in/,@{$e->{DIRECTION}})) { + ParseElementPush($e, "ndr", "r->in.", $env, 1, 1); + } + } + + deindent; + pidl "}"; + + pidl "if (flags & NDR_OUT) {"; + indent; + + $env = GenerateFunctionOutEnv($fn); + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/out/,@{$e->{DIRECTION}})) { + ParseElementPush($e, "ndr", "r->out.", $env, 1, 1); + } + } + + if ($fn->{RETURN_TYPE}) { + pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));"; + } + + deindent; + pidl "}"; + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl ""; +} + +sub AllocateArrayLevel($$$$$) +{ + my ($e,$l,$ndr,$env,$size) = @_; + + my $var = ParseExpr($e->{NAME}, $env); + + check_null_pointer($size); + my $pl = GetPrevLevel($e, $l); + if (defined($pl) and + $pl->{TYPE} eq "POINTER" and + $pl->{POINTER_TYPE} eq "ref" + and not $l->{IS_ZERO_TERMINATED}) { + pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; + pidl "\tNDR_PULL_ALLOC_N($ndr, $var, $size);"; + pidl "}"; + if (grep(/in/,@{$e->{DIRECTION}}) and + grep(/out/,@{$e->{DIRECTION}})) { + pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));"; + } + return; + } + + pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);"; +} + +##################################################################### +# parse a function +sub ParseFunctionPull($) +{ + my($fn) = shift; + + return if has_property($fn, "nopull"); + + # pull function args + pidl fn_prefix($fn) . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)"; + pidl "{"; + indent; + + # declare any internal pointers we need + foreach my $e (@{$fn->{ELEMENTS}}) { + DeclarePtrVariables($e); + DeclareArrayVariables($e); + } + + my %double_cases = (); + foreach my $e (@{$fn->{ELEMENTS}}) { + next if ($e->{TYPE} eq "EMPTY"); + next if ($double_cases{"$e->{NAME}"}); + DeclareMemCtxVariables($e); + $double_cases{"$e->{NAME}"} = 1; + } + + pidl "if (flags & NDR_IN) {"; + indent; + + # auto-init the out section of a structure. I originally argued that + # this was a bad idea as it hides bugs, but coping correctly + # with initialisation and not wiping ref vars is turning + # out to be too tricky (tridge) + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless grep(/out/, @{$e->{DIRECTION}}); + pidl "ZERO_STRUCT(r->out);"; + pidl ""; + last; + } + + my $env = GenerateFunctionInEnv($fn); + + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/in/, @{$e->{DIRECTION}})); + ParseElementPull($e, "ndr", "r->in.", $env, 1, 1); + } + + # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's + # own flag rather then be in NDR_IN ? + + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/out/, @{$e->{DIRECTION}})); + next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and + $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref"); + next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and + ($e->{LEVELS}[1]->{DATA_TYPE} eq "string")); + next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY") + and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}); + + if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { + my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env); + check_null_pointer($size); + + pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"; + + if (grep(/in/, @{$e->{DIRECTION}})) { + pidl "memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));"; + } else { + pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));"; + } + } else { + pidl "NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});"; + + if (grep(/in/, @{$e->{DIRECTION}})) { + pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};"; + } else { + pidl "ZERO_STRUCTP(r->out.$e->{NAME});"; + } + } + } + + add_deferred(); + deindent; + pidl "}"; + + pidl "if (flags & NDR_OUT) {"; + indent; + + $env = GenerateFunctionOutEnv($fn); + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless grep(/out/, @{$e->{DIRECTION}}); + ParseElementPull($e, "ndr", "r->out.", $env, 1, 1); + } + + if ($fn->{RETURN_TYPE}) { + pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));"; + } + + add_deferred(); + deindent; + pidl "}"; + + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# produce a function call table +sub FunctionTable($) +{ + my($interface) = shift; + my $count = 0; + my $uname = uc $interface->{NAME}; + + $count = $#{$interface->{FUNCTIONS}}+1; + + return if ($count == 0); + + pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {"; + $count = 0; + foreach my $d (@{$interface->{FUNCTIONS}}) { + next if not defined($d->{OPNUM}); + pidl "\t{"; + pidl "\t\t\"$d->{NAME}\","; + pidl "\t\tsizeof(struct $d->{NAME}),"; + pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},"; + pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},"; + pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME},"; + pidl "\t\t".($d->{ASYNC}?"True":"False").","; + pidl "\t},"; + $count++; + } + pidl "\t{ NULL, 0, NULL, NULL, NULL, False }"; + pidl "};"; + pidl ""; + + pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {"; + foreach my $ep (@{$interface->{ENDPOINTS}}) { + pidl "\t$ep, "; + } + my $endpoint_count = $#{$interface->{ENDPOINTS}}+1; + + pidl "};"; + pidl ""; + + pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {"; + pidl "\t.count\t= $endpoint_count,"; + pidl "\t.names\t= $interface->{NAME}\_endpoint_strings"; + pidl "};"; + pidl ""; + + if (! defined $interface->{PROPERTIES}->{authservice}) { + $interface->{PROPERTIES}->{authservice} = "\"host\""; + } + + my @a = split / /, $interface->{PROPERTIES}->{authservice}; + my $authservice_count = $#a + 1; + + pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {"; + foreach my $ap (@a) { + pidl "\t$ap, "; + } + pidl "};"; + pidl ""; + + pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {"; + pidl "\t.count\t= $endpoint_count,"; + pidl "\t.names\t= $interface->{NAME}\_authservice_strings"; + pidl "};"; + pidl ""; + + pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {"; + pidl "\t.name\t\t= \"$interface->{NAME}\","; + pidl "\t.uuid\t\t= DCERPC_$uname\_UUID,"; + pidl "\t.if_version\t= DCERPC_$uname\_VERSION,"; + pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,"; + pidl "\t.num_calls\t= $count,"; + pidl "\t.calls\t\t= $interface->{NAME}\_calls,"; + pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,"; + pidl "\t.authservices\t= &$interface->{NAME}\_authservices"; + pidl "};"; + pidl ""; + + pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)"; + pidl "{"; + pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});"; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse the interface definitions +sub ParseInterface($$) +{ + my($interface,$needed) = @_; + + # Typedefs + foreach my $d (@{$interface->{TYPEDEFS}}) { + ($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d); + ($needed->{"pull_$d->{NAME}"}) && ParseTypedefPull($d); + ($needed->{"print_$d->{NAME}"}) && ParseTypedefPrint($d); + + # Make sure we don't generate a function twice... + $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = + $needed->{"print_$d->{NAME}"} = 0; + + ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypedefNdrSize($d); + } + + # Functions + foreach my $d (@{$interface->{FUNCTIONS}}) { + ($needed->{"push_$d->{NAME}"}) && ParseFunctionPush($d); + ($needed->{"pull_$d->{NAME}"}) && ParseFunctionPull($d); + ($needed->{"print_$d->{NAME}"}) && ParseFunctionPrint($d); + + # Make sure we don't generate a function twice... + $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = + $needed->{"print_$d->{NAME}"} = 0; + } + + FunctionTable($interface); +} + +sub RegistrationFunction($$) +{ + my ($idl,$filename) = @_; + + $filename =~ /.*\/ndr_(.*).c/; + my $basename = $1; + pidl "NTSTATUS dcerpc_$basename\_init(void)"; + pidl "{"; + indent; + pidl "NTSTATUS status = NT_STATUS_OK;"; + foreach my $interface (@{$idl}) { + next if $interface->{TYPE} ne "INTERFACE"; + + my $count = ($#{$interface->{FUNCTIONS}}+1); + + next if ($count == 0); + + pidl "status = dcerpc_ndr_$interface->{NAME}_init();"; + pidl "if (NT_STATUS_IS_ERR(status)) {"; + pidl "\treturn status;"; + pidl "}"; + pidl ""; + } + pidl "return status;"; + deindent; + pidl "}"; + pidl ""; +} + +##################################################################### +# parse a parsed IDL structure back into an IDL file +sub Parse($$) +{ + my($ndr,$filename) = @_; + + $tabs = ""; + my $h_filename = $filename; + $res = ""; + + if ($h_filename =~ /(.*)\.c/) { + $h_filename = "$1.h"; + } + + pidl "/* parser auto-generated by pidl */"; + pidl ""; + pidl "#include \"includes.h\""; + pidl "#include \"librpc/gen_ndr/ndr_misc.h\""; + pidl "#include \"librpc/gen_ndr/ndr_dcerpc.h\""; + pidl "#include \"$h_filename\""; + pidl ""; + + my %needed = (); + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed); + } + + foreach my $x (@{$ndr}) { + ($x->{TYPE} eq "INTERFACE") && ParseInterface($x, \%needed); + } + + RegistrationFunction($ndr, $filename); + + return $res; +} + +sub NeededFunction($$) +{ + my ($fn,$needed) = @_; + $needed->{"pull_$fn->{NAME}"} = 1; + $needed->{"push_$fn->{NAME}"} = 1; + $needed->{"print_$fn->{NAME}"} = 1; + foreach my $e (@{$fn->{ELEMENTS}}) { + $e->{PARENT} = $fn; + unless(defined($needed->{"pull_$e->{TYPE}"})) { + $needed->{"pull_$e->{TYPE}"} = 1; + } + unless(defined($needed->{"push_$e->{TYPE}"})) { + $needed->{"push_$e->{TYPE}"} = 1; + } + unless(defined($needed->{"print_$e->{TYPE}"})) { + $needed->{"print_$e->{TYPE}"} = 1; + } + } +} + +sub NeededTypedef($$) +{ + my ($t,$needed) = @_; + if (has_property($t, "public")) { + $needed->{"pull_$t->{NAME}"} = not has_property($t, "nopull"); + $needed->{"push_$t->{NAME}"} = not has_property($t, "nopush"); + $needed->{"print_$t->{NAME}"} = not has_property($t, "noprint"); + } + + if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") { + if (has_property($t, "gensize")) { + $needed->{"ndr_size_$t->{NAME}"} = 1; + } + + for my $e (@{$t->{DATA}->{ELEMENTS}}) { + $e->{PARENT} = $t->{DATA}; + if ($needed->{"pull_$t->{NAME}"} and + not defined($needed->{"pull_$e->{TYPE}"})) { + $needed->{"pull_$e->{TYPE}"} = 1; + } + if ($needed->{"push_$t->{NAME}"} and + not defined($needed->{"push_$e->{TYPE}"})) { + $needed->{"push_$e->{TYPE}"} = 1; + } + if ($needed->{"print_$t->{NAME}"} and + not defined($needed->{"print_$e->{TYPE}"})) { + $needed->{"print_$e->{TYPE}"} = 1; + } + } + } +} + +##################################################################### +# work out what parse functions are needed +sub NeededInterface($$) +{ + my ($interface,$needed) = @_; + foreach my $d (@{$interface->{FUNCTIONS}}) { + NeededFunction($d, $needed); + } + foreach my $d (reverse @{$interface->{TYPEDEFS}}) { + NeededTypedef($d, $needed); + } +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm new file mode 100644 index 0000000000..585209b733 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -0,0 +1,325 @@ +################################################### +# server boilerplate generator +# Copyright tridge@samba.org 2003 +# Copyright metze@samba.org 2004 +# released under the GNU GPL + +package Parse::Pidl::Samba4::NDR::Server; + +use strict; + +use vars qw($VERSION); +$VERSION = '0.01'; + +my($res); + +sub pidl($) +{ + $res .= shift; +} + + +##################################################### +# generate the switch statement for function dispatch +sub gen_dispatch_switch($) +{ + my $interface = shift; + + foreach my $fn (@{$interface->{FUNCTIONS}}) { + next if not defined($fn->{OPNUM}); + + pidl "\tcase $fn->{OPNUM}: {\n"; + pidl "\t\tstruct $fn->{NAME} *r2 = r;\n"; + pidl "\t\tif (DEBUGLEVEL >= 10) {\n"; + pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_IN, r2);\n"; + pidl "\t\t}\n"; + if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") { + pidl "\t\tr2->out.result = $fn->{NAME}(dce_call, mem_ctx, r2);\n"; + } else { + pidl "\t\t$fn->{NAME}(dce_call, mem_ctx, r2);\n"; + } + pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; + pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} will reply async\\n\"));\n"; + pidl "\t\t}\n"; + pidl "\t\tbreak;\n\t}\n"; + } +} + +##################################################### +# generate the switch statement for function reply +sub gen_reply_switch($) +{ + my $interface = shift; + + foreach my $fn (@{$interface->{FUNCTIONS}}) { + next if not defined($fn->{OPNUM}); + + pidl "\tcase $fn->{OPNUM}: {\n"; + pidl "\t\tstruct $fn->{NAME} *r2 = r;\n"; + pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; + pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} replied async\\n\"));\n"; + pidl "\t\t}\n"; + pidl "\t\tif (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {\n"; + pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n"; + pidl "\t\t}\n"; + pidl "\t\tif (dce_call->fault_code != 0) {\n"; + pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $fn->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n"; + pidl "\t\t}\n"; + pidl "\t\tbreak;\n\t}\n"; + } +} + +##################################################################### +# produce boilerplate code for a interface +sub Boilerplate_Iface($) +{ + my($interface) = shift; + my $name = $interface->{NAME}; + my $uname = uc $name; + my $uuid = Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})); + my $if_version = $interface->{PROPERTIES}->{version}; + + pidl " +static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface) +{ +#ifdef DCESRV_INTERFACE_$uname\_BIND + return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface); +#else + return NT_STATUS_OK; +#endif +} + +static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface) +{ +#ifdef DCESRV_INTERFACE_$uname\_UNBIND + DCESRV_INTERFACE_$uname\_UNBIND(context, iface); +#else + return; +#endif +} + +static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r) +{ + NTSTATUS status; + uint16_t opnum = dce_call->pkt.u.request.opnum; + + dce_call->fault_code = 0; + + if (opnum >= dcerpc_table_$name.num_calls) { + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + return NT_STATUS_NET_WRITE_FAULT; + } + + *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size); + NT_STATUS_HAVE_NO_MEMORY(*r); + + /* unravel the NDR for the packet */ + status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); + if (!NT_STATUS_IS_OK(status)) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + dce_call->fault_code = DCERPC_FAULT_NDR; + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) +{ + uint16_t opnum = dce_call->pkt.u.request.opnum; + + switch (opnum) { +"; + gen_dispatch_switch($interface); + +pidl " + default: + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + break; + } + + if (dce_call->fault_code != 0) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) +{ + uint16_t opnum = dce_call->pkt.u.request.opnum; + + switch (opnum) { +"; + gen_reply_switch($interface); + +pidl " + default: + dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; + break; + } + + if (dce_call->fault_code != 0) { + dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + &dce_call->pkt.u.request.stub_and_verifier); + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r) +{ + NTSTATUS status; + uint16_t opnum = dce_call->pkt.u.request.opnum; + + status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); + if (!NT_STATUS_IS_OK(status)) { + dce_call->fault_code = DCERPC_FAULT_NDR; + return NT_STATUS_NET_WRITE_FAULT; + } + + return NT_STATUS_OK; +} + +static const struct dcesrv_interface $name\_interface = { + .name = \"$name\", + .uuid = $uuid, + .if_version = $if_version, + .bind = $name\__op_bind, + .unbind = $name\__op_unbind, + .ndr_pull = $name\__op_ndr_pull, + .dispatch = $name\__op_dispatch, + .reply = $name\__op_reply, + .ndr_push = $name\__op_ndr_push +}; + +"; +} + +##################################################################### +# produce boilerplate code for an endpoint server +sub Boilerplate_Ep_Server($) +{ + my($interface) = shift; + my $name = $interface->{NAME}; + my $uname = uc $name; + + pidl " +static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server) +{ + int i; + + for (i=0;icount;i++) { + NTSTATUS ret; + const char *name = dcerpc_table_$name.endpoints->names[i]; + + ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL); + if (!NT_STATUS_IS_OK(ret)) { + DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name)); + return ret; + } + } + + return NT_STATUS_OK; +} + +static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version) +{ + if ($name\_interface.if_version == if_version && + strcmp($name\_interface.uuid, uuid)==0) { + memcpy(iface,&$name\_interface, sizeof(*iface)); + return True; + } + + return False; +} + +static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) +{ + if (strcmp($name\_interface.name, name)==0) { + memcpy(iface,&$name\_interface, sizeof(*iface)); + return True; + } + + return False; +} + +NTSTATUS dcerpc_server_$name\_init(void) +{ + NTSTATUS ret; + struct dcesrv_endpoint_server ep_server; + + /* fill in our name */ + ep_server.name = \"$name\"; + + /* fill in all the operations */ + ep_server.init_server = $name\__op_init_server; + + ep_server.interface_by_uuid = $name\__op_interface_by_uuid; + ep_server.interface_by_name = $name\__op_interface_by_name; + + /* register ourselves with the DCERPC subsystem. */ + ret = dcerpc_register_ep_server(&ep_server); + + if (!NT_STATUS_IS_OK(ret)) { + DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\")); + return ret; + } + + return ret; +} + +"; +} + +##################################################################### +# dcerpc server boilerplate from a parsed IDL structure +sub ParseInterface($) +{ + my($interface) = shift; + my $count = 0; + + if (!defined $interface->{PROPERTIES}->{uuid}) { + return $res; + } + + if (!defined $interface->{PROPERTIES}->{version}) { + $interface->{PROPERTIES}->{version} = "0.0"; + } + + foreach my $fn (@{$interface->{FUNCTIONS}}) { + if (defined($fn->{OPNUM})) { $count++; } + } + + if ($count == 0) { + return $res; + } + + $res .= "/* $interface->{NAME} - dcerpc server boilerplate generated by pidl */\n\n"; + Boilerplate_Iface($interface); + Boilerplate_Ep_Server($interface); + + return $res; +} + +sub Parse($$) +{ + my($ndr) = shift; + my($filename) = shift; + + $res = ""; + $res .= "/* server functions auto-generated by pidl */\n"; + $res .= "\n"; + + foreach my $x (@{$ndr}) { + ParseInterface($x) if ($x->{TYPE} eq "INTERFACE" and not defined($x->{PROPERTIES}{object})); + } + + return $res; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm new file mode 100644 index 0000000000..b6c268edeb --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -0,0 +1,79 @@ +################################################### +# Samba4 parser generator for swig wrappers +# Copyright tpot@samba.org 2004,2005 +# released under the GNU GPL + +package Parse::Pidl::Samba4::SWIG; + +use vars qw($VERSION); +$VERSION = '0.01'; + +use strict; + +sub pidl($) +{ + print OUT shift; +} + +##################################################################### +# rewrite autogenerated header file +sub RewriteHeader($$$) +{ + my($idl) = shift; + my($input) = shift; + my($output) = shift; + + open(IN, "<$input") || die "can't open $input for reading"; + open(OUT, ">$output") || die "can't open $output for writing"; + + pidl "%{\n"; + pidl "#define data_in in\n"; + pidl "#define data_out out\n"; + pidl "%}\n\n"; + + while() { + + # Rename dom_sid2 to dom_sid as we don't care about the difference + # for the swig wrappers. + + s/dom_sid2/dom_sid/g; + + # Copy structure and union definitions + + if (/^(struct|union) .*? {$/ .. /^\};$/) { + s/\} (in|out);/\} data_$1;/; # "in" is a Python keyword + pidl $_; + next; + } + + # Copy dcerpc functions + + pidl $_ if /^NTSTATUS dcerpc_.*?\(struct dcerpc_pipe/; + + # Copy interface definitions + + pidl $_ + if /^\#define DCERPC_.*?_UUID/ or /^\#define DCERPC_.*?_VERSION/; + } + + close(OUT); +} + +##################################################################### +# rewrite autogenerated header file +sub RewriteC($$$) +{ + my($idl) = shift; + my($input) = shift; + my($output) = shift; + + open(IN, "<$input") || die "can't open $input for reading"; + open(OUT, ">>$output") || die "can't open $output for writing"; + + while() { + } + + close(OUT); +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm new file mode 100644 index 0000000000..524ed08bfa --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -0,0 +1,280 @@ +################################################### +# Trivial Parser Generator +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +package Parse::Pidl::Samba4::TDR; +use Parse::Pidl::Util qw(has_property ParseExpr is_constant); + +use vars qw($VERSION); +$VERSION = '0.01'; + +use strict; + +my $ret = ""; +my $tabs = ""; + +sub indent() { $tabs.="\t"; } +sub deindent() { $tabs = substr($tabs, 1); } +sub pidl($) { $ret .= $tabs.(shift)."\n"; } +sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } +sub static($) { my $p = shift; return("static ") unless ($p); return ""; } +sub typearg($) { + my $t = shift; + return(", const char *name") if ($t eq "print"); + return(", TALLOC_CTX *mem_ctx") if ($t eq "pull"); + return(""); +} + +sub ContainsArray($) +{ + my $e = shift; + foreach (@{$e->{ELEMENTS}}) { + next if (has_property($_, "charset") and + scalar(@{$_->{ARRAY_LEN}}) == 1); + return 1 if (defined($_->{ARRAY_LEN}) and + scalar(@{$_->{ARRAY_LEN}}) > 0); + } + return 0; +} + +sub ParserElement($$$) +{ + my ($e,$t,$env) = @_; + my $switch = ""; + my $array = ""; + my $name = ""; + my $mem_ctx = "mem_ctx"; + + fatal($e,"Pointers not supported in TDR") if ($e->{POINTERS} > 0); + fatal($e,"size_is() not supported in TDR") if (has_property($e, "size_is")); + fatal($e,"length_is() not supported in TDR") if (has_property($e, "length_is")); + + if ($t eq "print") { + $name = ", \"$e->{NAME}\"$array"; + } + + if (has_property($e, "flag")) { + pidl "{"; + indent; + pidl "uint32_t saved_flags = tdr->flags;"; + pidl "tdr->flags |= $e->{PROPERTIES}->{flag};"; + } + + if (has_property($e, "charset")) { + fatal($e,"charset() on non-array element") unless (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0); + + my $len = ParseExpr(@{$e->{ARRAY_LEN}}[0], $env); + if ($len eq "*") { $len = "-1"; } + $name = ", mem_ctx" if ($t eq "pull"); + pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));"; + return; + } + + if (has_property($e, "switch_is")) { + $switch = ", " . ParseExpr($e->{PROPERTIES}->{switch_is}, $env); + } + + if (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0) { + my $len = ParseExpr($e->{ARRAY_LEN}[0], $env); + + if ($t eq "pull" and not is_constant($len)) { + pidl "TDR_ALLOC(mem_ctx, v->$e->{NAME}, $len);"; + $mem_ctx = "v->$e->{NAME}"; + } + + pidl "for (i = 0; i < $len; i++) {"; + indent; + $array = "[i]"; + } + + if ($t eq "pull") { + $name = ", $mem_ctx"; + } + + if (has_property($e, "value") && $t eq "push") { + pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env).";"; + } + + pidl "TDR_CHECK(tdr_$t\_$e->{TYPE}(tdr$name$switch, &v->$e->{NAME}$array));"; + + if ($array) { deindent; pidl "}"; } + + if (has_property($e, "flag")) { + pidl "tdr->flags = saved_flags;"; + deindent; + pidl "}"; + } +} + +sub ParserStruct($$$$) +{ + my ($e,$n,$t,$p) = @_; + + pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", struct $n *v)"; + pidl "{"; indent; + pidl "int i;" if (ContainsArray($e)); + + if ($t eq "print") { + pidl "tdr->print(tdr, \"\%-25s: struct $n\", name);"; + pidl "tdr->level++;"; + } + + my %env = map { $_->{NAME} => "v->$_->{NAME}" } @{$e->{ELEMENTS}}; + $env{"this"} = "v"; + ParserElement($_, $t, \%env) foreach (@{$e->{ELEMENTS}}); + + if ($t eq "print") { + pidl "tdr->level--;"; + } + + pidl "return NT_STATUS_OK;"; + + deindent; pidl "}"; +} + +sub ParserUnion($$$$) +{ + my ($e,$n,$t,$p) = @_; + + pidl static($p)."NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".typearg($t).", int level, union $n *v)"; + pidl "{"; indent; + pidl "int i;" if (ContainsArray($e)); + + if ($t eq "print") { + pidl "tdr->print(tdr, \"\%-25s: union $n\", name);"; + pidl "tdr->level++;"; + } + + pidl "switch (level) {"; indent; + foreach (@{$e->{ELEMENTS}}) { + if (has_property($_, "case")) { + pidl "case " . $_->{PROPERTIES}->{case} . ":"; + } elsif (has_property($_, "default")) { + pidl "default:"; + } + indent; ParserElement($_, $t, {}); deindent; + pidl "break;"; + } + deindent; pidl "}"; + + if ($t eq "print") { + pidl "tdr->level--;"; + } + + pidl "return NT_STATUS_OK;\n"; + deindent; pidl "}"; +} + +sub ParserBitmap($$$$) +{ + my ($e,$n,$t,$p) = @_; + return if ($p); + pidl "#define tdr_$t\_$n tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e); +} + +sub ParserEnum($$$$) +{ + my ($e,$n,$t,$p) = @_; + my $bt = ($e->{PROPERTIES}->{base_type} or "uint8"); + + pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", enum $n *v)"; + pidl "{"; + if ($t eq "pull") { + pidl "\t$bt\_t r;"; + pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, mem_ctx, \&r));"; + pidl "\t*v = r;"; + } elsif ($t eq "push") { + pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));"; + } elsif ($t eq "print") { + pidl "\t/* FIXME */"; + } + pidl "\treturn NT_STATUS_OK;"; + pidl "}"; +} + +sub ParserTypedef($$) +{ + my ($e,$t) = @_; + + return if (has_property($e, "no$t")); + + $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES}; + + { STRUCT => \&ParserStruct, UNION => \&ParserUnion, + ENUM => \&ParserEnum, BITMAP => \&ParserBitmap + }->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $t, has_property($e, "public")); + + pidl ""; +} + +sub ParserInterface($) +{ + my $x = shift; + + foreach (@{$x->{DATA}}) { + next if ($_->{TYPE} ne "TYPEDEF"); + ParserTypedef($_, "pull"); + ParserTypedef($_, "push"); + ParserTypedef($_, "print"); + } +} + +sub Parser($$) +{ + my ($idl,$hdrname) = @_; + $ret = ""; + pidl "/* autogenerated by pidl */"; + pidl "#include \"includes.h\""; + pidl "#include \"$hdrname\""; + pidl ""; + foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } + return $ret; +} + +sub HeaderInterface($$) +{ + my ($x,$outputdir) = @_; + + pidl "#ifndef __TDR_$x->{NAME}_HEADER__"; + pidl "#define __TDR_$x->{NAME}_HEADER__"; + + foreach my $e (@{$x->{DATA}}) { + next unless ($e->{TYPE} eq "TYPEDEF"); + next unless has_property($e, "public"); + + my $switch = ""; + + $switch = ", int level" if ($e->{DATA}->{TYPE} eq "UNION"); + + if ($e->{DATA}->{TYPE} eq "BITMAP") { + # FIXME + } else { + my ($n, $d) = ($e->{NAME}, lc($e->{DATA}->{TYPE})); + pidl "NTSTATUS tdr_pull\_$n(struct tdr_pull *tdr, TALLOC_CTX *ctx$switch, $d $n *v);"; + pidl "NTSTATUS tdr_print\_$n(struct tdr_print *tdr, const char *name$switch, $d $n *v);"; + pidl "NTSTATUS tdr_push\_$n(struct tdr_push *tdr$switch, $d $n *v);"; + } + + pidl ""; + } + + pidl "#endif /* __TDR_$x->{NAME}_HEADER__ */"; +} + +sub Header($$$) +{ + my ($idl,$outputdir,$basename) = @_; + $ret = ""; + pidl "/* Generated by pidl */"; + + pidl "#include \"$outputdir/$basename.h\""; + pidl ""; + + foreach (@$idl) { + HeaderInterface($_, $outputdir) if ($_->{TYPE} eq "INTERFACE"); + } + return $ret; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm new file mode 100644 index 0000000000..111ae28123 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm @@ -0,0 +1,99 @@ +################################################### +# server template function generator +# Copyright tridge@samba.org 2003 +# released under the GNU GPL + +package Parse::Pidl::Samba4::Template; + +use vars qw($VERSION); +$VERSION = '0.01'; + +use strict; + +my($res); + +##################################################################### +# produce boilerplate code for a interface +sub Template($) +{ + my($interface) = shift; + my($data) = $interface->{DATA}; + my $name = $interface->{NAME}; + + $res .= +"/* + Unix SMB/CIFS implementation. + + endpoint server for the $name pipe + + Copyright (C) YOUR NAME HERE YEAR + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include \"includes.h\" +#include \"rpc_server/dcerpc_server.h\" +#include \"librpc/gen_ndr/ndr_$name.h\" +#include \"rpc_server/common/common.h\" + +"; + + foreach my $d (@{$data}) { + if ($d->{TYPE} eq "FUNCTION") { + my $fname = $d->{NAME}; + $res .= +" +/* + $fname +*/ +static $d->{RETURN_TYPE} $fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, + struct $fname *r) +{ +"; + + if ($d->{RETURN_TYPE} eq "void") { + $res .= "\tDCESRV_FAULT_VOID(DCERPC_FAULT_OP_RNG_ERROR);\n"; + } else { + $res .= "\tDCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);\n"; + } + + $res .= "} + +"; + } + } + + $res .= +" +/* include the generated boilerplate */ +#include \"librpc/gen_ndr/ndr_$name\_s.c\" +" +} + + +##################################################################### +# parse a parsed IDL structure back into an IDL file +sub Parse($) +{ + my($idl) = shift; + $res = ""; + foreach my $x (@{$idl}) { + ($x->{TYPE} eq "INTERFACE") && + Template($x); + } + return $res; +} + +1; -- cgit From 68ef82aac72c351f6e166b92bbb4573e8bcdbc86 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 Dec 2005 23:32:50 +0000 Subject: r12464: Add simple IDL parsing tests for pidl using the standard perl testing framework (Test::Simple, distributed with perl itself). Run these tests from 'make test' (This used to be commit 975d8816db6697dab828941b69a740e3a0a2c272) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 8 +- source4/pidl/lib/Parse/Pidl/NDR.pm | 24 ++-- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm | 14 +- source4/pidl/lib/Parse/Pidl/Test.pm | 171 ----------------------- 4 files changed, 21 insertions(+), 196 deletions(-) delete mode 100644 source4/pidl/lib/Parse/Pidl/Test.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index c948f1af33..4988ae572a 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -2690,6 +2690,7 @@ sub CleanData($) { sub CleanData($); my($v) = shift; + return undef if (not defined($v)); if (ref($v) eq "ARRAY") { foreach my $i (0 .. $#{$v}) { CleanData($v->[$i]); @@ -2776,12 +2777,13 @@ again: } } -sub parse_string($) +sub parse_string { - my ($data) = @_; + my ($data,$filename) = @_; my $self = new Parse::Pidl::IDL; + $self->YYData->{INPUT_FILENAME} = $filename; $self->YYData->{INPUT} = $data; $self->YYData->{LINE} = 0; $self->YYData->{LAST_TOKEN} = "NONE"; @@ -2804,7 +2806,7 @@ sub parse_file($) my $data = `$cpp -D__PIDL__ -xc $filename`; $/ = $saved_delim; - return parse_string($data); + return parse_string($data, $filename); } 1; diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 9ff69f8757..4b7a753fa5 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -13,15 +13,18 @@ Parse::Pidl::NDR - NDR parsing information generator =head1 DESCRIPTION -##################################################################### -# return a table describing the order in which the parts of an element -# should be parsed -# Possible level types: -# - POINTER -# - ARRAY -# - SUBCONTEXT -# - SWITCH -# - DATA +Return a table describing the order in which the parts of an element +should be parsed +Possible level types: + - POINTER + - ARRAY + - SUBCONTEXT + - SWITCH + - DATA + +=head1 AUTHOR + +Jelmer Vernooij =cut @@ -629,6 +632,9 @@ sub ParseInterface($) sub Parse($) { my $idl = shift; + + return undef unless (defined($idl)); + my @ndr = (); push(@ndr, ParseInterface($_)) foreach (@{$idl}); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm index d55a7a12af..1480b42971 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm @@ -16,19 +16,8 @@ use vars qw($VERSION); $VERSION = '0.01'; my($res); -my($tab_depth); -sub pidl ($) -{ - $res .= shift; -} - -sub tabs() -{ - my $res = ""; - $res .="\t" foreach (1..$tab_depth); - return $res; -} +sub pidl ($) { $res .= shift; } ##################################################################### # prototype a typedef @@ -154,7 +143,6 @@ sub HeaderInterface($) sub Parse($$) { my($idl,$basename) = @_; - $tab_depth = 0; $res = ""; pidl "/* header auto-generated by pidl */\n"; diff --git a/source4/pidl/lib/Parse/Pidl/Test.pm b/source4/pidl/lib/Parse/Pidl/Test.pm deleted file mode 100644 index 66f5c73595..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Test.pm +++ /dev/null @@ -1,171 +0,0 @@ -# Simple system for running tests against pidl -# (C) 2005 Jelmer Vernooij -# Published under the GNU General Public License - -package Parse::Pidl::Test; - -use strict; -use Parse::Pidl::Util; -use Getopt::Long; - -use vars qw($VERSION); -$VERSION = '0.01'; -my $cc = $ENV{CC}; -my @cflags = split / /, $ENV{CFLAGS}; -my @ldflags = split / /, $ENV{LDFLAGS}; - -$cc = "cc" if ($cc eq ""); - -sub generate_cfile($$$) -{ - my ($filename, $fragment, $incfiles) = @_; - - unless (open (OUT, ">$filename")) { - print STDERR "Unable to open $filename\n"; - return -1; - } - print OUT ' -/* This file was autogenerated. All changes made will be lost! */ -#include "include/includes.h" -'; - - foreach (@$incfiles) { - print OUT "#include \"$_\"\n"; - } - - print OUT ' -int main(int argc, char **argv) -{ - TALLOC_CTX *mem_ctx = talloc_init(NULL); - '; - print OUT $fragment; - print OUT "\treturn 0;\n}\n"; - close OUT; - - return 0; -} - -sub generate_idlfile($$) -{ - my ($filename,$fragment) = @_; - - unless (open(OUT, ">$filename")) { - print STDERR "Unable to open $filename\n"; - return -1; - } - - print OUT ' -[uuid("1-2-3-4-5")] interface test_if -{ -'; - print OUT $fragment; - print OUT "\n}\n"; - close OUT; - - return 0; -} - -sub compile_idl($$$) -{ - my ($filename,$idl_path, $idlargs) = @_; - - my @args = @$idlargs; - push (@args, $filename); - - unless (system($idl_path, @args) == 0) { - print STDERR "Error compiling IDL file $filename: $!\n"; - return -1; - } -} - -sub compile_cfile($) -{ - my ($filename) = @_; - - return system($cc, @cflags, '-I.', '-Iinclude', '-c', $filename); -} - -sub link_files($$) -{ - my ($exe_name,$objs) = @_; - - return system($cc, @ldflags, '-Lbin', '-lrpc', '-o', $exe_name, @$objs); -} - -sub test_idl($$$$) -{ - my ($name,$settings,$idl,$c) = @_; - - $| = 1; - - print "Running $name... "; - - my $outputdir = $settings->{OutputDir}; - - my $c_filename = $outputdir."/".$name."_test.c"; - my $idl_filename = $outputdir."/".$name."_idl.idl"; - my $exe_filename = $outputdir."/".$name."_exe"; - - return -1 if (generate_cfile($c_filename, $c, $settings->{IncludeFiles}) == -1); - - return -1 if (generate_idlfile($idl_filename, $idl) == -1); - - return -1 if (compile_idl($idl_filename, $settings->{'IDL-Compiler'}, $settings->{'IDL-Arguments'}) == -1); - - my @srcs = ($c_filename); - push (@srcs, @{$settings->{'ExtraFiles'}}); - - foreach (@srcs) { - next unless /\.c$/; - return -1 if (compile_cfile($_) == -1); - } - - my @objs; - foreach (@srcs) { - if (/\.c$/) { s/\.c$/\.o/g; } - push(@objs, $_); - } - - return -1 if (link_files($exe_filename, \@objs) == -1); - - my $ret = system("./$exe_filename"); - if ($ret != 0) { - $ret = $? >> 8; - print "failed with return value $ret\n"; - return $ret; - } - - unless ($settings->{Keep}) { - unlink(@srcs, @objs, $exe_filename, $idl_filename); - } - - print "Ok\n"; - - return $ret; -} - -sub GetSettings($) -{ - my $settings = { - OutputDir => ".", - 'IDL-Compiler' => "./pidl" - }; - - my %opts = (); - GetOptions('idl-compiler=s' => \$settings->{'IDL-Compiler'}, - 'outputdir=s' => \$settings->{OutputDir}, - 'keep' => \$settings->{Keep}, - 'help' => sub { ShowHelp(); exit 1; } ); - - return %$settings; -} - -sub ShowHelp() -{ - print " --idl-compiler=PATH-TO-PIDL Override path to IDL compiler\n"; - print " --outputdir=OUTPUTDIR Write temporary files to OUTPUTDIR rather then .\n"; - print " --keep Keep intermediate files after running test"; - print " --help Show this help message\n"; -} - -1; -- cgit From 620d375320e143abcf6775a392f9bde3146f2baa Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 Dec 2005 01:33:35 +0000 Subject: r12465: Merge Parse::Pidl::Samba4::NDR::Header into Parse::Pidl::Samba4::NDR::Parser. Small optimization to avoid including NDR headers multiple times (This used to be commit 6967b9884970b6f1d7617196ab024d401628a13c) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm | 157 ----------------------- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 146 +++++++++++++++------ 2 files changed, 110 insertions(+), 193 deletions(-) delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm deleted file mode 100644 index 1480b42971..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Header.pm +++ /dev/null @@ -1,157 +0,0 @@ -################################################### -# create C header files for an IDL structure -# Copyright tridge@samba.org 2000 -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba4::NDR::Header; - -use strict; -use Parse::Pidl::Typelist qw(mapType); -use Parse::Pidl::Util qw(has_property is_constant); -use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); -use Parse::Pidl::Samba4::NDR::Parser; - -use vars qw($VERSION); -$VERSION = '0.01'; - -my($res); - -sub pidl ($) { $res .= shift; } - -##################################################################### -# prototype a typedef -sub HeaderTypedefProto($) -{ - my($d) = shift; - - my $tf = Parse::Pidl::Samba4::NDR::Parser::get_typefamily($d->{DATA}{TYPE}); - - if (has_property($d, "gensize")) { - my $size_args = $tf->{SIZE_FN_ARGS}->($d); - pidl "size_t ndr_size_$d->{NAME}($size_args);\n"; - } - - return unless has_property($d, "public"); - - unless (has_property($d, "nopush")) { - pidl "NTSTATUS ndr_push_$d->{NAME}(struct ndr_push *ndr, int ndr_flags, " . $tf->{DECL}->($d, "push") . ");\n"; - } - unless (has_property($d, "nopull")) { - pidl "NTSTATUS ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, " . $tf->{DECL}->($d, "pull") . ");\n"; - } - unless (has_property($d, "noprint")) { - pidl "void ndr_print_$d->{NAME}(struct ndr_print *ndr, const char *name, " . $tf->{DECL}->($d, "print") . ");\n"; - } -} - -##################################################################### -# output prototypes for a IDL function -sub HeaderFnProto($$) -{ - my ($interface,$fn) = @_; - my $name = $fn->{NAME}; - - pidl "void ndr_print_$name(struct ndr_print *ndr, const char *name, int flags, const struct $name *r);\n"; - - unless (has_property($fn, "noopnum")) { - pidl "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n"; - pidl "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n"; - } - - return unless has_property($fn, "public"); - - pidl "NTSTATUS ndr_push_$name(struct ndr_push *ndr, int flags, const struct $name *r);\n"; - pidl "NTSTATUS ndr_pull_$name(struct ndr_pull *ndr, int flags, struct $name *r);\n"; - - pidl "\n"; -} - -##################################################################### -# parse the interface definitions -sub HeaderInterface($) -{ - my($interface) = shift; - - if (defined $interface->{PROPERTIES}->{depends}) { - my @d = split / /, $interface->{PROPERTIES}->{depends}; - foreach my $i (@d) { - pidl "#include \"librpc/gen_ndr/ndr_$i\.h\"\n"; - } - } - - my $count = 0; - - pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n"; - pidl "#define _HEADER_NDR_$interface->{NAME}\n\n"; - - if (defined $interface->{PROPERTIES}->{uuid}) { - my $name = uc $interface->{NAME}; - pidl "#define DCERPC_$name\_UUID " . - Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})) . "\n"; - - if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; } - pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n"; - - pidl "#define DCERPC_$name\_NAME \"$interface->{NAME}\"\n"; - - if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; } - pidl "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}\n"; - - pidl "\nextern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n"; - pidl "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);\n\n"; - } - - foreach my $d (@{$interface->{DATA}}) { - next if $d->{TYPE} ne "FUNCTION"; - next if has_property($d, "noopnum"); - next if grep(/$d->{NAME}/,@{$interface->{INHERITED_FUNCTIONS}}); - my $u_name = uc $d->{NAME}; - pidl "#define DCERPC_$u_name ("; - - if (defined($interface->{BASE})) { - pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + "; - } - - pidl sprintf("0x%02x", $count) . ")\n"; - $count++; - } - - pidl "\n#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ("; - - if (defined($interface->{BASE})) { - pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + "; - } - - pidl "$count)\n\n"; - - foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "TYPEDEF"); - HeaderTypedefProto($d); - } - - foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "FUNCTION"); - HeaderFnProto($interface, $d); - } - - pidl "#endif /* _HEADER_NDR_$interface->{NAME} */\n"; -} - -##################################################################### -# parse a parsed IDL into a C header -sub Parse($$) -{ - my($idl,$basename) = @_; - - $res = ""; - pidl "/* header auto-generated by pidl */\n"; - pidl "#include \"librpc/gen_ndr/$basename\.h\"\n\n"; - - foreach my $x (@{$idl}) { - ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); - } - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index a7ea60b2e4..2242323747 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -101,7 +101,7 @@ sub get_value_of($) } } -my $res = ""; +my $res; my $deferred = ""; my $tabs = ""; @@ -117,6 +117,10 @@ sub pidl($) $res .="\n"; } +my $res_hdr; + +sub pidl_hdr ($) { my $d = shift; $res_hdr .= "$d\n"; } + #################################### # defer() is like pidl(), but adds to # a deferred buffer which is then added to the @@ -188,13 +192,17 @@ sub check_null_pointer_void($) } ##################################################################### -# work out is a parse function should be declared static or not -sub fn_prefix($) +# declare a function public or static, depending on its attributes +sub fn_declare($$) { - my $fn = shift; + my ($fn,$decl) = @_; - return "" if (has_property($fn, "public")); - return "static "; + if (has_property($fn, "public")) { + pidl_hdr "$decl;"; + pidl "$decl"; + } else { + pidl "static $decl"; + } } ################################################################### @@ -1821,7 +1829,7 @@ sub ParseTypedefPush($) my($e) = shift; my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push"); - pidl fn_prefix($e) . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)"; + fn_declare($e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)"); pidl "{"; indent; @@ -1840,7 +1848,7 @@ sub ParseTypedefPull($) my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull"); - pidl fn_prefix($e) . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)"; + fn_declare($e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)"); pidl "{"; indent; @@ -1860,6 +1868,7 @@ sub ParseTypedefPrint($) my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print"); pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; + pidl_hdr "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args);"; pidl "{"; indent; $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME}); @@ -1877,7 +1886,8 @@ sub ParseTypedefNdrSize($) my $tf = $typefamily{$t->{DATA}->{TYPE}}; my $args = $tf->{SIZE_FN_ARGS}->($t); - pidl "size_t ndr_size_$t->{NAME}($args)"; + fn_declare($t, "size_t ndr_size_$t->{NAME}($args)"); + pidl "{"; indent; $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t); @@ -1895,6 +1905,7 @@ sub ParseFunctionPrint($) return if has_property($fn, "noprint"); pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; + pidl_hdr "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r);"; pidl "{"; indent; @@ -1958,7 +1969,8 @@ sub ParseFunctionPush($) return if has_property($fn, "nopush"); - pidl fn_prefix($fn) . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)"; + fn_declare($fn, "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)"); + pidl "{"; indent; @@ -2038,7 +2050,7 @@ sub ParseFunctionPull($) return if has_property($fn, "nopull"); # pull function args - pidl fn_prefix($fn) . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)"; + fn_declare($fn, "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)"); pidl "{"; indent; @@ -2149,6 +2161,7 @@ sub FunctionTable($) $count = $#{$interface->{FUNCTIONS}}+1; return if ($count == 0); + return unless defined ($interface->{PROPERTIES}->{uuid}); pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {"; $count = 0; @@ -2222,12 +2235,83 @@ sub FunctionTable($) pidl ""; } +##################################################################### +# generate prototypes and defines for the interface definitions +# FIXME: these prototypes are for the DCE/RPC client functions, not the +# NDR parser and so do not belong here, technically speaking +sub HeaderInterface($) +{ + my($interface) = shift; + + my $count = 0; + + pidl_hdr "#ifndef _HEADER_RPC_$interface->{NAME}"; + pidl_hdr "#define _HEADER_RPC_$interface->{NAME}"; + + pidl_hdr ""; + + if (defined $interface->{PROPERTIES}->{depends}) { + my @d = split / /, $interface->{PROPERTIES}->{depends}; + foreach my $i (@d) { + pidl_hdr "#include \"librpc/gen_ndr/ndr_$i\.h\""; + } + } + + if (defined $interface->{PROPERTIES}->{uuid}) { + my $name = uc $interface->{NAME}; + pidl_hdr "#define DCERPC_$name\_UUID " . + Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})); + + if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; } + pidl_hdr "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}"; + + pidl_hdr "#define DCERPC_$name\_NAME \"$interface->{NAME}\""; + + if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; } + pidl_hdr "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}"; + + pidl_hdr "extern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};"; + pidl_hdr "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);"; + } + + foreach (@{$interface->{FUNCTIONS}}) { + next if has_property($_, "noopnum"); + next if grep(/$_->{NAME}/,@{$interface->{INHERITED_FUNCTIONS}}); + my $u_name = uc $_->{NAME}; + + my $val = sprintf("0x%02x", $count); + if (defined($interface->{BASE})) { + $val .= " + DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT"; + } + + pidl_hdr "#define DCERPC_$u_name ($val)"; + + pidl_hdr "NTSTATUS dcerpc_$_->{NAME}(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $_->{NAME} *r);"; + pidl_hdr "struct rpc_request *dcerpc_$_->{NAME}\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $_->{NAME} *r);"; + + pidl_hdr ""; + $count++; + } + + my $val = $count; + + if (defined($interface->{BASE})) { + $val .= " + DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT"; + } + + pidl_hdr "#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ($val)"; + + pidl_hdr "#endif /* _HEADER_RPC_$interface->{NAME} */"; +} + ##################################################################### # parse the interface definitions sub ParseInterface($$) { my($interface,$needed) = @_; + HeaderInterface($interface); + # Typedefs foreach my $d (@{$interface->{TYPEDEFS}}) { ($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d); @@ -2257,10 +2341,8 @@ sub ParseInterface($$) sub RegistrationFunction($$) { - my ($idl,$filename) = @_; + my ($idl,$basename) = @_; - $filename =~ /.*\/ndr_(.*).c/; - my $basename = $1; pidl "NTSTATUS dcerpc_$basename\_init(void)"; pidl "{"; indent; @@ -2271,6 +2353,7 @@ sub RegistrationFunction($$) my $count = ($#{$interface->{FUNCTIONS}}+1); next if ($count == 0); + next unless defined ($interface->{PROPERTIES}->{uuid}); pidl "status = dcerpc_ndr_$interface->{NAME}_init();"; pidl "if (NT_STATUS_IS_ERR(status)) {"; @@ -2288,37 +2371,31 @@ sub RegistrationFunction($$) # parse a parsed IDL structure back into an IDL file sub Parse($$) { - my($ndr,$filename) = @_; + my($ndr,$basename) = @_; $tabs = ""; - my $h_filename = $filename; $res = ""; - if ($h_filename =~ /(.*)\.c/) { - $h_filename = "$1.h"; - } + $res_hdr = ""; + pidl_hdr "/* header auto-generated by pidl */"; + pidl_hdr ""; pidl "/* parser auto-generated by pidl */"; pidl ""; - pidl "#include \"includes.h\""; - pidl "#include \"librpc/gen_ndr/ndr_misc.h\""; - pidl "#include \"librpc/gen_ndr/ndr_dcerpc.h\""; - pidl "#include \"$h_filename\""; - pidl ""; my %needed = (); - foreach my $x (@{$ndr}) { - ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed); + foreach (@{$ndr}) { + ($_->{TYPE} eq "INTERFACE") && NeededInterface($_, \%needed); } - foreach my $x (@{$ndr}) { - ($x->{TYPE} eq "INTERFACE") && ParseInterface($x, \%needed); + foreach (@{$ndr}) { + ($_->{TYPE} eq "INTERFACE") && ParseInterface($_, \%needed); } - RegistrationFunction($ndr, $filename); + RegistrationFunction($ndr, $basename); - return $res; + return ($res_hdr, $res); } sub NeededFunction($$) @@ -2378,12 +2455,9 @@ sub NeededTypedef($$) sub NeededInterface($$) { my ($interface,$needed) = @_; - foreach my $d (@{$interface->{FUNCTIONS}}) { - NeededFunction($d, $needed); - } - foreach my $d (reverse @{$interface->{TYPEDEFS}}) { - NeededTypedef($d, $needed); - } + NeededFunction($_, $needed) foreach (@{$interface->{FUNCTIONS}}); + NeededTypedef($_, $needed) foreach (reverse @{$interface->{TYPEDEFS}}); } 1; + -- cgit From 7717f180ca2f908e1b3258355520719991215050 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 Dec 2005 03:04:13 +0000 Subject: r12470: Add helper module for pidl tests Convert other pidl tests to use Test::More and run them from 'make test' (This used to be commit 3a57d29a62112ab654e290ccc985fba7f67664c5) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 2 ++ source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 15 ++++++--------- 2 files changed, 8 insertions(+), 9 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 4b7a753fa5..e7b790d1e5 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -634,6 +634,8 @@ sub Parse($) my $idl = shift; return undef unless (defined($idl)); + + Parse::Pidl::NDR::Validate($idl); my @ndr = (); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index a1c568cdc7..46caba731a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -17,10 +17,7 @@ $VERSION = '0.01'; my($res); my($tab_depth); -sub pidl ($) -{ - $res .= shift; -} +sub pidl($) { $res .= shift; } sub tabs() { @@ -261,7 +258,7 @@ sub HeaderFunctionInOut_needed($$) return undef; } -my %headerstructs = (); +my %headerstructs; ##################################################################### # parse a function @@ -313,8 +310,6 @@ sub HeaderInterface($) { my($interface) = shift; - my $count = 0; - pidl "#ifndef _HEADER_$interface->{NAME}\n"; pidl "#define _HEADER_$interface->{NAME}\n\n"; @@ -337,6 +332,7 @@ sub HeaderInterface($) foreach my $d (@{$interface->{DATA}}) { next if ($d->{TYPE} ne "FUNCTION"); + HeaderFunction($d); } @@ -351,9 +347,10 @@ sub Parse($) $tab_depth = 0; $res = ""; + %headerstructs = (); pidl "/* header auto-generated by pidl */\n\n"; - foreach my $x (@{$idl}) { - ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); + foreach (@{$idl}) { + ($_->{TYPE} eq "INTERFACE") && HeaderInterface($_); } return $res; } -- cgit From a4fe56c06a95bf5278a4a0efdd976febc2b9866b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 Dec 2005 14:59:21 +0000 Subject: r12481: Move parser-specific utility functions to idl.yp, remove some unused functions Allow the use of non-typedef structs and unions when declaring variables. Allow the use of the 'signed' and 'unsigned' qualifiers for integer types (This used to be commit bc6b45e242c8d7b2ef1a6e6d3eb172c27afd952d) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 1032 ++++++++++++++++++++--------------- source4/pidl/lib/Parse/Pidl/Util.pm | 42 -- 2 files changed, 597 insertions(+), 477 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 4988ae572a..60439b8601 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -509,7 +509,7 @@ sub new { ACTIONS => { '' => 2 }, - DEFAULT => -63, + DEFAULT => -80, GOTOS => { 'interface' => 3, 'coclass' => 4, @@ -559,7 +559,7 @@ sub new { } }, {#State 9 - DEFAULT => -92 + DEFAULT => -109 }, {#State 10 ACTIONS => { @@ -570,10 +570,10 @@ sub new { ACTIONS => { "(" => 16 }, - DEFAULT => -67 + DEFAULT => -84 }, {#State 12 - DEFAULT => -65 + DEFAULT => -82 }, {#State 13 ACTIONS => { @@ -602,7 +602,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'listtext' => 26, @@ -621,7 +621,7 @@ sub new { } }, {#State 18 - DEFAULT => -64 + DEFAULT => -81 }, {#State 19 ACTIONS => { @@ -643,13 +643,13 @@ sub new { } }, {#State 22 - DEFAULT => -96 + DEFAULT => -113 }, {#State 23 - DEFAULT => -74 + DEFAULT => -91 }, {#State 24 - DEFAULT => -76 + DEFAULT => -93 }, {#State 25 ACTIONS => { @@ -669,7 +669,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -69 + DEFAULT => -86 }, {#State 26 ACTIONS => { @@ -678,13 +678,13 @@ sub new { } }, {#State 27 - DEFAULT => -75 + DEFAULT => -92 }, {#State 28 - DEFAULT => -95 + DEFAULT => -112 }, {#State 29 - DEFAULT => -66 + DEFAULT => -83 }, {#State 30 DEFAULT => -9 @@ -699,7 +699,7 @@ sub new { "const" => 60, "struct" => 63 }, - DEFAULT => -63, + DEFAULT => -80, GOTOS => { 'typedecl' => 64, 'function' => 53, @@ -720,7 +720,7 @@ sub new { ACTIONS => { ";" => 71 }, - DEFAULT => -97, + DEFAULT => -114, GOTOS => { 'optional_semicolon' => 72 } @@ -739,7 +739,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 74, @@ -753,7 +753,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 75, @@ -767,7 +767,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 76, @@ -781,7 +781,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 77, @@ -795,7 +795,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 78, @@ -809,7 +809,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 79, @@ -823,7 +823,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 80, @@ -838,7 +838,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 82, @@ -852,7 +852,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 83, @@ -866,7 +866,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 84, @@ -880,7 +880,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 80, @@ -895,7 +895,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 86, @@ -909,7 +909,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 87, @@ -923,7 +923,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 88, @@ -937,7 +937,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 89, @@ -951,7 +951,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, 'anytext' => 90, @@ -960,10 +960,10 @@ sub new { } }, {#State 50 - DEFAULT => -68 + DEFAULT => -85 }, {#State 51 - DEFAULT => -63, + DEFAULT => -80, GOTOS => { 'property_list' => 91 } @@ -972,7 +972,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -94, + DEFAULT => -111, GOTOS => { 'optional_identifier' => 93 } @@ -991,7 +991,7 @@ sub new { "const" => 60, "struct" => 63 }, - DEFAULT => -63, + DEFAULT => -80, GOTOS => { 'typedecl' => 64, 'function' => 53, @@ -1015,30 +1015,34 @@ sub new { {#State 56 ACTIONS => { 'IDENTIFIER' => 9, + "signed" => 102, "union" => 52, "enum" => 65, "bitmap" => 66, - "[" => 7, 'void' => 97, + "unsigned" => 103, + "[" => 7, "struct" => 63 }, GOTOS => { + 'existingtype' => 101, + 'bitmap' => 67, + 'usertype' => 98, 'identifier' => 99, 'struct' => 59, 'enum' => 61, - 'type' => 100, + 'type' => 104, 'union' => 70, - 'bitmap' => 67, - 'usertype' => 98 + 'sign' => 100 } }, {#State 57 DEFAULT => -10 }, {#State 58 - DEFAULT => -63, + DEFAULT => -80, GOTOS => { - 'property_list' => 101 + 'property_list' => 105 } }, {#State 59 @@ -1049,7 +1053,7 @@ sub new { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 102 + 'identifier' => 106 } }, {#State 61 @@ -1062,9 +1066,9 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -94, + DEFAULT => -111, GOTOS => { - 'optional_identifier' => 103 + 'optional_identifier' => 107 } }, {#State 64 @@ -1074,18 +1078,18 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -94, + DEFAULT => -111, GOTOS => { - 'optional_identifier' => 104 + 'optional_identifier' => 108 } }, {#State 66 ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -94, + DEFAULT => -111, GOTOS => { - 'optional_identifier' => 105 + 'optional_identifier' => 109 } }, {#State 67 @@ -1101,14 +1105,14 @@ sub new { DEFAULT => -27 }, {#State 71 - DEFAULT => -98 + DEFAULT => -115 }, {#State 72 DEFAULT => -4 }, {#State 73 ACTIONS => { - ";" => 106 + ";" => 110 } }, {#State 74 @@ -1129,7 +1133,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -86 + DEFAULT => -103 }, {#State 75 ACTIONS => { @@ -1140,7 +1144,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -77 + DEFAULT => -94 }, {#State 76 ACTIONS => { @@ -1160,7 +1164,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -85 + DEFAULT => -102 }, {#State 77 ACTIONS => { @@ -1180,7 +1184,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -81 + DEFAULT => -98 }, {#State 78 ACTIONS => { @@ -1200,7 +1204,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -89 + DEFAULT => -106 }, {#State 79 ACTIONS => { @@ -1211,7 +1215,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -88 + DEFAULT => -105 }, {#State 80 ACTIONS => { @@ -1231,12 +1235,12 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -71 + DEFAULT => -88 }, {#State 81 ACTIONS => { - "}" => 107, - "," => 108 + "}" => 111, + "," => 112 } }, {#State 82 @@ -1248,7 +1252,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -83 + DEFAULT => -100 }, {#State 83 ACTIONS => { @@ -1259,7 +1263,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -84 + DEFAULT => -101 }, {#State 84 ACTIONS => { @@ -1279,12 +1283,12 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -87 + DEFAULT => -104 }, {#State 85 ACTIONS => { - "," => 108, - ")" => 109 + "," => 112, + ")" => 113 } }, {#State 86 @@ -1296,7 +1300,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -82 + DEFAULT => -99 }, {#State 87 ACTIONS => { @@ -1307,7 +1311,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -79 + DEFAULT => -96 }, {#State 88 ACTIONS => { @@ -1318,7 +1322,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -78 + DEFAULT => -95 }, {#State 89 ACTIONS => { @@ -1329,7 +1333,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -80 + DEFAULT => -97 }, {#State 90 ACTIONS => { @@ -1349,43 +1353,52 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -70 + DEFAULT => -87 }, {#State 91 ACTIONS => { 'IDENTIFIER' => 9, + "signed" => 102, "union" => 52, "enum" => 65, "bitmap" => 66, - "[" => 7, 'void' => 97, + "unsigned" => 103, + "[" => 7, "struct" => 63 }, GOTOS => { + 'existingtype' => 101, + 'bitmap' => 67, + 'usertype' => 98, 'identifier' => 99, 'struct' => 59, 'enum' => 61, - 'type' => 110, + 'type' => 114, 'union' => 70, - 'bitmap' => 67, - 'usertype' => 98 + 'sign' => 100 } }, {#State 92 - DEFAULT => -93 + DEFAULT => -110 }, {#State 93 ACTIONS => { - "{" => 111 + "{" => 116 + }, + DEFAULT => -65, + GOTOS => { + 'union_body' => 117, + 'opt_union_body' => 115 } }, {#State 94 ACTIONS => { ";" => 71 }, - DEFAULT => -97, + DEFAULT => -114, GOTOS => { - 'optional_semicolon' => 112 + 'optional_semicolon' => 118 } }, {#State 95 @@ -1395,178 +1408,237 @@ sub new { DEFAULT => -30 }, {#State 97 - DEFAULT => -33 + DEFAULT => -38 }, {#State 98 - DEFAULT => -31 + DEFAULT => -36 }, {#State 99 - DEFAULT => -32 + DEFAULT => -35 }, {#State 100 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 113 + 'identifier' => 119 } }, {#State 101 + DEFAULT => -37 + }, + {#State 102 + DEFAULT => -31 + }, + {#State 103 + DEFAULT => -32 + }, + {#State 104 ACTIONS => { - "enum" => 117, - "bitmap" => 118, + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 120 + } + }, + {#State 105 + ACTIONS => { + "enum" => 124, + "bitmap" => 125, "[" => 7 }, GOTOS => { - 'decl_enum' => 114, - 'decl_bitmap' => 115, - 'decl_type' => 116 + 'decl_enum' => 121, + 'decl_bitmap' => 122, + 'decl_type' => 123 } }, - {#State 102 - DEFAULT => -52, + {#State 106 + DEFAULT => -69, GOTOS => { - 'pointers' => 119 + 'pointers' => 126 } }, - {#State 103 + {#State 107 ACTIONS => { - "{" => 120 + "{" => 128 + }, + DEFAULT => -55, + GOTOS => { + 'struct_body' => 127, + 'opt_struct_body' => 129 } }, - {#State 104 + {#State 108 ACTIONS => { - "{" => 121 + "{" => 130 + }, + DEFAULT => -40, + GOTOS => { + 'opt_enum_body' => 132, + 'enum_body' => 131 } }, - {#State 105 + {#State 109 ACTIONS => { - "{" => 122 + "{" => 134 + }, + DEFAULT => -48, + GOTOS => { + 'bitmap_body' => 135, + 'opt_bitmap_body' => 133 } }, - {#State 106 + {#State 110 DEFAULT => -6 }, - {#State 107 + {#State 111 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, - 'anytext' => 123, + 'anytext' => 136, 'text' => 24, 'constant' => 27 } }, - {#State 108 + {#State 112 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, - 'anytext' => 124, + 'anytext' => 137, 'text' => 24, 'constant' => 27 } }, - {#State 109 + {#State 113 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, - 'anytext' => 125, + 'anytext' => 138, 'text' => 24, 'constant' => 27 } }, - {#State 110 + {#State 114 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 126 + 'identifier' => 139 } }, - {#State 111 - DEFAULT => -48, + {#State 115 + DEFAULT => -67 + }, + {#State 116 + DEFAULT => -62, GOTOS => { - 'union_elements' => 127 + 'union_elements' => 140 } }, - {#State 112 + {#State 117 + DEFAULT => -66 + }, + {#State 118 DEFAULT => -7 }, - {#State 113 + {#State 119 + DEFAULT => -34 + }, + {#State 120 ACTIONS => { - "(" => 128 + "(" => 141 } }, - {#State 114 + {#State 121 DEFAULT => -21 }, - {#State 115 + {#State 122 DEFAULT => -22 }, - {#State 116 + {#State 123 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 129 + 'identifier' => 142 } }, - {#State 117 + {#State 124 DEFAULT => -23 }, - {#State 118 + {#State 125 DEFAULT => -24 }, - {#State 119 + {#State 126 ACTIONS => { 'IDENTIFIER' => 9, - "*" => 131 + "*" => 144 }, GOTOS => { - 'identifier' => 130 + 'identifier' => 143 } }, - {#State 120 - DEFAULT => -54, + {#State 127 + DEFAULT => -56 + }, + {#State 128 + DEFAULT => -71, GOTOS => { - 'element_list1' => 132 + 'element_list1' => 145 } }, - {#State 121 + {#State 129 + DEFAULT => -57 + }, + {#State 130 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 133, - 'enum_element' => 134, - 'enum_elements' => 135 + 'identifier' => 146, + 'enum_element' => 147, + 'enum_elements' => 148 } }, - {#State 122 + {#State 131 + DEFAULT => -41 + }, + {#State 132 + DEFAULT => -42 + }, + {#State 133 + DEFAULT => -50 + }, + {#State 134 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 138, - 'bitmap_elements' => 137, - 'bitmap_element' => 136 + 'identifier' => 151, + 'bitmap_elements' => 150, + 'bitmap_element' => 149 } }, - {#State 123 + {#State 135 + DEFAULT => -49 + }, + {#State 136 ACTIONS => { "-" => 35, ":" => 34, @@ -1584,9 +1656,9 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -91 + DEFAULT => -108 }, - {#State 124 + {#State 137 ACTIONS => { "-" => 35, ":" => 34, @@ -1604,9 +1676,9 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -72 + DEFAULT => -89 }, - {#State 125 + {#State 138 ACTIONS => { ":" => 34, "<" => 37, @@ -1615,258 +1687,263 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -90 + DEFAULT => -107 }, - {#State 126 + {#State 139 ACTIONS => { - "[" => 139 + "[" => 152 }, - DEFAULT => -60, + DEFAULT => -77, GOTOS => { - 'array_len' => 140 + 'array_len' => 153 } }, - {#State 127 + {#State 140 ACTIONS => { - "}" => 141 + "}" => 154 }, - DEFAULT => -63, + DEFAULT => -80, GOTOS => { - 'optional_base_element' => 143, - 'property_list' => 142 + 'optional_base_element' => 156, + 'property_list' => 155 } }, - {#State 128 + {#State 141 ACTIONS => { - "," => -56, - "void" => 147, - ")" => -56 + "," => -73, + "void" => 160, + ")" => -73 }, - DEFAULT => -63, + DEFAULT => -80, GOTOS => { - 'base_element' => 144, - 'element_list2' => 146, - 'property_list' => 145 + 'base_element' => 157, + 'element_list2' => 159, + 'property_list' => 158 } }, - {#State 129 + {#State 142 ACTIONS => { - ";" => 148 + ";" => 161 } }, - {#State 130 + {#State 143 ACTIONS => { - "[" => 139, - "=" => 150 + "[" => 152, + "=" => 163 }, GOTOS => { - 'array_len' => 149 + 'array_len' => 162 } }, - {#State 131 - DEFAULT => -53 + {#State 144 + DEFAULT => -70 }, - {#State 132 + {#State 145 ACTIONS => { - "}" => 151 + "}" => 164 }, - DEFAULT => -63, + DEFAULT => -80, GOTOS => { - 'base_element' => 152, - 'property_list' => 145 + 'base_element' => 165, + 'property_list' => 158 } }, - {#State 133 + {#State 146 ACTIONS => { - "=" => 153 + "=" => 166 }, - DEFAULT => -37 + DEFAULT => -45 }, - {#State 134 - DEFAULT => -35 + {#State 147 + DEFAULT => -43 }, - {#State 135 + {#State 148 ACTIONS => { - "}" => 154, - "," => 155 + "}" => 167, + "," => 168 } }, - {#State 136 - DEFAULT => -40 + {#State 149 + DEFAULT => -51 }, - {#State 137 + {#State 150 ACTIONS => { - "}" => 156, - "," => 157 + "}" => 169, + "," => 170 } }, - {#State 138 + {#State 151 ACTIONS => { - "=" => 158 + "=" => 171 } }, - {#State 139 + {#State 152 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, - "]" => 159, + "]" => 172, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, - 'anytext' => 160, + 'anytext' => 173, 'text' => 24, 'constant' => 27 } }, - {#State 140 + {#State 153 ACTIONS => { - ";" => 161 + ";" => 174 } }, - {#State 141 - DEFAULT => -50 + {#State 154 + DEFAULT => -64 }, - {#State 142 + {#State 155 ACTIONS => { "[" => 7 }, - DEFAULT => -63, + DEFAULT => -80, GOTOS => { - 'base_or_empty' => 162, - 'base_element' => 163, - 'empty_element' => 164, - 'property_list' => 165 + 'base_or_empty' => 175, + 'base_element' => 176, + 'empty_element' => 177, + 'property_list' => 178 } }, - {#State 143 - DEFAULT => -49 + {#State 156 + DEFAULT => -63 }, - {#State 144 - DEFAULT => -58 + {#State 157 + DEFAULT => -75 }, - {#State 145 + {#State 158 ACTIONS => { 'IDENTIFIER' => 9, + "signed" => 102, "union" => 52, "enum" => 65, "bitmap" => 66, - "[" => 7, 'void' => 97, + "unsigned" => 103, + "[" => 7, "struct" => 63 }, + DEFAULT => -33, GOTOS => { + 'existingtype' => 101, + 'bitmap' => 67, + 'usertype' => 98, 'identifier' => 99, 'struct' => 59, 'enum' => 61, - 'type' => 166, + 'type' => 179, 'union' => 70, - 'bitmap' => 67, - 'usertype' => 98 + 'sign' => 100 } }, - {#State 146 + {#State 159 ACTIONS => { - "," => 167, - ")" => 168 + "," => 180, + ")" => 181 } }, - {#State 147 - DEFAULT => -57 + {#State 160 + DEFAULT => -74 }, - {#State 148 + {#State 161 DEFAULT => -20 }, - {#State 149 + {#State 162 ACTIONS => { - "=" => 169 + "=" => 182 } }, - {#State 150 + {#State 163 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, - 'anytext' => 170, + 'anytext' => 183, 'text' => 24, 'constant' => 27 } }, - {#State 151 - DEFAULT => -43 + {#State 164 + DEFAULT => -54 }, - {#State 152 + {#State 165 ACTIONS => { - ";" => 171 + ";" => 184 } }, - {#State 153 + {#State 166 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, - 'anytext' => 172, + 'anytext' => 185, 'text' => 24, 'constant' => 27 } }, - {#State 154 - DEFAULT => -34 + {#State 167 + DEFAULT => -39 }, - {#State 155 + {#State 168 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 133, - 'enum_element' => 173 + 'identifier' => 146, + 'enum_element' => 186 } }, - {#State 156 - DEFAULT => -39 + {#State 169 + DEFAULT => -47 }, - {#State 157 + {#State 170 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 138, - 'bitmap_element' => 174 + 'identifier' => 151, + 'bitmap_element' => 187 } }, - {#State 158 + {#State 171 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, - 'anytext' => 175, + 'anytext' => 188, 'text' => 24, 'constant' => 27 } }, - {#State 159 + {#State 172 ACTIONS => { - "[" => 139 + "[" => 152 }, - DEFAULT => -60, + DEFAULT => -77, GOTOS => { - 'array_len' => 176 + 'array_len' => 189 } }, - {#State 160 + {#State 173 ACTIONS => { "-" => 35, ":" => 34, @@ -1882,84 +1959,89 @@ sub new { "(" => 44, "*" => 46, "." => 47, - "]" => 177, + "]" => 190, ">" => 48 } }, - {#State 161 + {#State 174 DEFAULT => -25 }, - {#State 162 - DEFAULT => -47 + {#State 175 + DEFAULT => -61 }, - {#State 163 + {#State 176 ACTIONS => { - ";" => 178 + ";" => 191 } }, - {#State 164 - DEFAULT => -46 + {#State 177 + DEFAULT => -60 }, - {#State 165 + {#State 178 ACTIONS => { 'IDENTIFIER' => 9, + "signed" => 102, "union" => 52, - ";" => 179, + ";" => 192, "enum" => 65, "bitmap" => 66, 'void' => 97, + "unsigned" => 103, "[" => 7, "struct" => 63 }, + DEFAULT => -33, GOTOS => { + 'existingtype' => 101, + 'bitmap' => 67, + 'usertype' => 98, 'identifier' => 99, 'struct' => 59, 'enum' => 61, - 'type' => 166, + 'type' => 179, 'union' => 70, - 'bitmap' => 67, - 'usertype' => 98 + 'sign' => 100 } }, - {#State 166 - DEFAULT => -52, + {#State 179 + DEFAULT => -69, GOTOS => { - 'pointers' => 180 + 'pointers' => 193 } }, - {#State 167 - DEFAULT => -63, + {#State 180 + DEFAULT => -80, GOTOS => { - 'base_element' => 181, - 'property_list' => 145 + 'base_element' => 194, + 'property_list' => 158 } }, - {#State 168 + {#State 181 ACTIONS => { - ";" => 182 + ";" => 195 } }, - {#State 169 + {#State 182 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -73, + DEFAULT => -90, GOTOS => { 'identifier' => 23, - 'anytext' => 183, + 'anytext' => 196, 'text' => 24, 'constant' => 27 } }, - {#State 170 + {#State 183 ACTIONS => { "-" => 35, ":" => 34, "?" => 36, "<" => 37, - ";" => 184, + ";" => 197, "+" => 39, "~" => 38, "&" => 41, @@ -1973,10 +2055,10 @@ sub new { ">" => 48 } }, - {#State 171 - DEFAULT => -55 + {#State 184 + DEFAULT => -72 }, - {#State 172 + {#State 185 ACTIONS => { "-" => 35, ":" => 34, @@ -1994,15 +2076,15 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -38 + DEFAULT => -46 }, - {#State 173 - DEFAULT => -36 + {#State 186 + DEFAULT => -44 }, - {#State 174 - DEFAULT => -41 + {#State 187 + DEFAULT => -52 }, - {#State 175 + {#State 188 ACTIONS => { "-" => 35, ":" => 34, @@ -2020,48 +2102,48 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -42 + DEFAULT => -53 }, - {#State 176 - DEFAULT => -61 + {#State 189 + DEFAULT => -78 }, - {#State 177 + {#State 190 ACTIONS => { - "[" => 139 + "[" => 152 }, - DEFAULT => -60, + DEFAULT => -77, GOTOS => { - 'array_len' => 185 + 'array_len' => 198 } }, - {#State 178 - DEFAULT => -45 + {#State 191 + DEFAULT => -59 }, - {#State 179 - DEFAULT => -44 + {#State 192 + DEFAULT => -58 }, - {#State 180 + {#State 193 ACTIONS => { 'IDENTIFIER' => 9, - "*" => 131 + "*" => 144 }, GOTOS => { - 'identifier' => 186 + 'identifier' => 199 } }, - {#State 181 - DEFAULT => -59 + {#State 194 + DEFAULT => -76 }, - {#State 182 + {#State 195 DEFAULT => -19 }, - {#State 183 + {#State 196 ACTIONS => { "-" => 35, ":" => 34, "?" => 36, "<" => 37, - ";" => 187, + ";" => 200, "+" => 39, "~" => 38, "&" => 41, @@ -2075,26 +2157,26 @@ sub new { ">" => 48 } }, - {#State 184 + {#State 197 DEFAULT => -17 }, - {#State 185 - DEFAULT => -62 + {#State 198 + DEFAULT => -79 }, - {#State 186 + {#State 199 ACTIONS => { - "[" => 139 + "[" => 152 }, - DEFAULT => -60, + DEFAULT => -77, GOTOS => { - 'array_len' => 188 + 'array_len' => 201 } }, - {#State 187 + {#State 200 DEFAULT => -18 }, - {#State 188 - DEFAULT => -51 + {#State 201 + DEFAULT => -68 } ], yyrules => @@ -2300,90 +2382,144 @@ sub { $_[1] } ], [#Rule 31 - 'type', 1, undef + 'sign', 1, undef ], [#Rule 32 - 'type', 1, undef + 'sign', 1, undef ], [#Rule 33 + 'existingtype', 0, undef + ], + [#Rule 34 + 'existingtype', 2, +sub +#line 146 "idl.yp" +{ "$_[1] $_[2]" } + ], + [#Rule 35 + 'existingtype', 1, undef + ], + [#Rule 36 + 'type', 1, undef + ], + [#Rule 37 + 'type', 1, undef + ], + [#Rule 38 'type', 1, sub -#line 144 "idl.yp" +#line 150 "idl.yp" { "void" } ], - [#Rule 34 - 'enum', 5, + [#Rule 39 + 'enum_body', 3, +sub +#line 152 "idl.yp" +{ $_[2] } + ], + [#Rule 40 + 'opt_enum_body', 0, undef + ], + [#Rule 41 + 'opt_enum_body', 1, undef + ], + [#Rule 42 + 'enum', 3, sub -#line 148 "idl.yp" +#line 155 "idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], - "ELEMENTS" => $_[4] + "ELEMENTS" => $_[3] }} ], - [#Rule 35 + [#Rule 43 'enum_elements', 1, sub -#line 156 "idl.yp" +#line 163 "idl.yp" { [ $_[1] ] } ], - [#Rule 36 + [#Rule 44 'enum_elements', 3, sub -#line 157 "idl.yp" +#line 164 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 37 + [#Rule 45 'enum_element', 1, undef ], - [#Rule 38 + [#Rule 46 'enum_element', 3, sub -#line 161 "idl.yp" +#line 168 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 39 - 'bitmap', 5, + [#Rule 47 + 'bitmap_body', 3, +sub +#line 171 "idl.yp" +{ $_[2] } + ], + [#Rule 48 + 'opt_bitmap_body', 0, undef + ], + [#Rule 49 + 'opt_bitmap_body', 1, undef + ], + [#Rule 50 + 'bitmap', 3, sub -#line 165 "idl.yp" +#line 174 "idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], - "ELEMENTS" => $_[4] + "ELEMENTS" => $_[3] }} ], - [#Rule 40 + [#Rule 51 'bitmap_elements', 1, sub -#line 173 "idl.yp" +#line 182 "idl.yp" { [ $_[1] ] } ], - [#Rule 41 + [#Rule 52 'bitmap_elements', 3, sub -#line 174 "idl.yp" +#line 183 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 42 + [#Rule 53 'bitmap_element', 3, sub -#line 177 "idl.yp" +#line 186 "idl.yp" { "$_[1] ( $_[3] )" } ], - [#Rule 43 - 'struct', 5, + [#Rule 54 + 'struct_body', 3, sub -#line 181 "idl.yp" +#line 189 "idl.yp" +{ $_[2] } + ], + [#Rule 55 + 'opt_struct_body', 0, undef + ], + [#Rule 56 + 'opt_struct_body', 1, undef + ], + [#Rule 57 + 'struct', 3, +sub +#line 193 "idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], - "ELEMENTS" => $_[4] + "ELEMENTS" => $_[3] }} ], - [#Rule 44 + [#Rule 58 'empty_element', 2, sub -#line 189 "idl.yp" +#line 201 "idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2394,41 +2530,53 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 45 + [#Rule 59 'base_or_empty', 2, undef ], - [#Rule 46 + [#Rule 60 'base_or_empty', 1, undef ], - [#Rule 47 + [#Rule 61 'optional_base_element', 2, sub -#line 203 "idl.yp" -{ $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } +#line 215 "idl.yp" +{ $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], - [#Rule 48 + [#Rule 62 'union_elements', 0, undef ], - [#Rule 49 + [#Rule 63 'union_elements', 2, sub -#line 208 "idl.yp" +#line 220 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 50 - 'union', 5, + [#Rule 64 + 'union_body', 3, +sub +#line 223 "idl.yp" +{ $_[2] } + ], + [#Rule 65 + 'opt_union_body', 0, undef + ], + [#Rule 66 + 'opt_union_body', 1, undef + ], + [#Rule 67 + 'union', 3, sub -#line 212 "idl.yp" +#line 227 "idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], - "ELEMENTS" => $_[4] + "ELEMENTS" => $_[3] }} ], - [#Rule 51 + [#Rule 68 'base_element', 5, sub -#line 220 "idl.yp" +#line 235 "idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2439,238 +2587,238 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 52 + [#Rule 69 'pointers', 0, sub -#line 234 "idl.yp" +#line 249 "idl.yp" { 0 } ], - [#Rule 53 + [#Rule 70 'pointers', 2, sub -#line 235 "idl.yp" +#line 250 "idl.yp" { $_[1]+1 } ], - [#Rule 54 + [#Rule 71 'element_list1', 0, undef ], - [#Rule 55 + [#Rule 72 'element_list1', 3, sub -#line 240 "idl.yp" +#line 255 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 56 + [#Rule 73 'element_list2', 0, undef ], - [#Rule 57 + [#Rule 74 'element_list2', 1, undef ], - [#Rule 58 + [#Rule 75 'element_list2', 1, sub -#line 246 "idl.yp" +#line 261 "idl.yp" { [ $_[1] ] } ], - [#Rule 59 + [#Rule 76 'element_list2', 3, sub -#line 247 "idl.yp" +#line 262 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 60 + [#Rule 77 'array_len', 0, undef ], - [#Rule 61 + [#Rule 78 'array_len', 3, sub -#line 252 "idl.yp" +#line 267 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], - [#Rule 62 + [#Rule 79 'array_len', 4, sub -#line 253 "idl.yp" +#line 268 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], - [#Rule 63 + [#Rule 80 'property_list', 0, undef ], - [#Rule 64 + [#Rule 81 'property_list', 4, sub -#line 259 "idl.yp" -{ Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); } +#line 274 "idl.yp" +{ FlattenHash([$_[1],$_[3]]); } ], - [#Rule 65 + [#Rule 82 'properties', 1, sub -#line 262 "idl.yp" +#line 277 "idl.yp" { $_[1] } ], - [#Rule 66 + [#Rule 83 'properties', 3, sub -#line 263 "idl.yp" -{ Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); } +#line 278 "idl.yp" +{ FlattenHash([$_[1], $_[3]]); } ], - [#Rule 67 + [#Rule 84 'property', 1, sub -#line 266 "idl.yp" +#line 281 "idl.yp" {{ "$_[1]" => "1" }} ], - [#Rule 68 + [#Rule 85 'property', 4, sub -#line 267 "idl.yp" +#line 282 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], - [#Rule 69 + [#Rule 86 'listtext', 1, undef ], - [#Rule 70 + [#Rule 87 'listtext', 3, sub -#line 272 "idl.yp" +#line 287 "idl.yp" { "$_[1] $_[3]" } ], - [#Rule 71 + [#Rule 88 'commalisttext', 1, undef ], - [#Rule 72 + [#Rule 89 'commalisttext', 3, sub -#line 277 "idl.yp" +#line 292 "idl.yp" { "$_[1],$_[3]" } ], - [#Rule 73 + [#Rule 90 'anytext', 0, sub -#line 281 "idl.yp" +#line 296 "idl.yp" { "" } ], - [#Rule 74 + [#Rule 91 'anytext', 1, undef ], - [#Rule 75 + [#Rule 92 'anytext', 1, undef ], - [#Rule 76 + [#Rule 93 'anytext', 1, undef ], - [#Rule 77 + [#Rule 94 'anytext', 3, sub -#line 283 "idl.yp" +#line 298 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 78 + [#Rule 95 'anytext', 3, sub -#line 284 "idl.yp" +#line 299 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 79 + [#Rule 96 'anytext', 3, sub -#line 285 "idl.yp" +#line 300 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 80 + [#Rule 97 'anytext', 3, sub -#line 286 "idl.yp" +#line 301 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 81 + [#Rule 98 'anytext', 3, sub -#line 287 "idl.yp" +#line 302 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 82 + [#Rule 99 'anytext', 3, sub -#line 288 "idl.yp" +#line 303 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 83 + [#Rule 100 'anytext', 3, sub -#line 289 "idl.yp" +#line 304 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 84 + [#Rule 101 'anytext', 3, sub -#line 290 "idl.yp" +#line 305 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 85 + [#Rule 102 'anytext', 3, sub -#line 291 "idl.yp" +#line 306 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 86 + [#Rule 103 'anytext', 3, sub -#line 292 "idl.yp" +#line 307 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 87 + [#Rule 104 'anytext', 3, sub -#line 293 "idl.yp" +#line 308 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 88 + [#Rule 105 'anytext', 3, sub -#line 294 "idl.yp" +#line 309 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 89 + [#Rule 106 'anytext', 3, sub -#line 295 "idl.yp" +#line 310 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 90 + [#Rule 107 'anytext', 5, sub -#line 296 "idl.yp" +#line 311 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 91 + [#Rule 108 'anytext', 5, sub -#line 297 "idl.yp" +#line 312 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 92 + [#Rule 109 'identifier', 1, undef ], - [#Rule 93 + [#Rule 110 'optional_identifier', 1, undef ], - [#Rule 94 + [#Rule 111 'optional_identifier', 0, undef ], - [#Rule 95 + [#Rule 112 'constant', 1, undef ], - [#Rule 96 + [#Rule 113 'text', 1, sub -#line 311 "idl.yp" +#line 326 "idl.yp" { "\"$_[1]\"" } ], - [#Rule 97 + [#Rule 114 'optional_semicolon', 0, undef ], - [#Rule 98 + [#Rule 115 'optional_semicolon', 1, undef ] ], @@ -2678,10 +2826,24 @@ sub bless($self,$class); } -#line 322 "idl.yp" +#line 337 "idl.yp" + + +##################################################################### +# flatten an array of hashes into a single hash +sub FlattenHash($) +{ + my $a = shift; + my %b; + for my $d (@{$a}) { + for my $k (keys %{$d}) { + $b{$k} = $d->{$k}; + } + } + return \%b; +} -use Parse::Pidl::Util; ##################################################################### # traverse a perl data structure removing any empty arrays or @@ -2765,7 +2927,7 @@ again: $parser->YYData->{LAST_TOKEN} = $1; if ($1 =~ /^(coclass|interface|const|typedef|declare|union - |struct|enum|bitmap|void)$/x) { + |struct|enum|bitmap|void|unsigned|signed)$/x) { return $1; } return('IDENTIFIER',$1); diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index fec1301a59..ec6a1420ab 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -12,48 +12,6 @@ $VERSION = '0.01'; use strict; -##################################################################### -# flatten an array of arrays into a single array -sub FlattenArray2($) -{ - my $a = shift; - my @b; - for my $d (@{$a}) { - for my $d1 (@{$d}) { - push(@b, $d1); - } - } - return \@b; -} - -##################################################################### -# flatten an array of arrays into a single array -sub FlattenArray($) -{ - my $a = shift; - my @b; - for my $d (@{$a}) { - for my $d1 (@{$d}) { - push(@b, $d1); - } - } - return \@b; -} - -##################################################################### -# flatten an array of hashes into a single hash -sub FlattenHash($) -{ - my $a = shift; - my %b; - for my $d (@{$a}) { - for my $k (keys %{$d}) { - $b{$k} = $d->{$k}; - } - } - return \%b; -} - ##################################################################### # a dumper wrapper to prevent dependence on the Data::Dumper module # unless we actually need it -- cgit From 25d57c0ad8704894ee055f74bab2f33b688a7d72 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 Dec 2005 15:19:55 +0000 Subject: r12483: Remove --tdr-header option (merged into --tdr-parser) (This used to be commit 45013467f57d646f3db099862665d2631272b446) --- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 79 ++++++++++--------------------- 1 file changed, 25 insertions(+), 54 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index 524ed08bfa..789fb7adbe 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -11,14 +11,15 @@ $VERSION = '0.01'; use strict; -my $ret = ""; +my $ret; +my $ret_hdr; my $tabs = ""; sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $ret .= $tabs.(shift)."\n"; } +sub pidl_hdr($) { $ret_hdr .= (shift)."\n"; } sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } -sub static($) { my $p = shift; return("static ") unless ($p); return ""; } sub typearg($) { my $t = shift; return(", const char *name") if ($t eq "print"); @@ -26,6 +27,12 @@ sub typearg($) { return(""); } +sub fn_declare($$) +{ + my ($p, $d) = @_; + if ($p) { pidl $d; pidl_hdr "$d;"; } else { pidl "static $d"; } +} + sub ContainsArray($) { my $e = shift; @@ -111,7 +118,7 @@ sub ParserStruct($$$$) { my ($e,$n,$t,$p) = @_; - pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", struct $n *v)"; + fn_declare($p,,"NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", struct $n *v)"); pidl "{"; indent; pidl "int i;" if (ContainsArray($e)); @@ -137,7 +144,7 @@ sub ParserUnion($$$$) { my ($e,$n,$t,$p) = @_; - pidl static($p)."NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".typearg($t).", int level, union $n *v)"; + fn_declare($p,"NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".typearg($t).", int level, union $n *v)"); pidl "{"; indent; pidl "int i;" if (ContainsArray($e)); @@ -178,7 +185,7 @@ sub ParserEnum($$$$) my ($e,$n,$t,$p) = @_; my $bt = ($e->{PROPERTIES}->{base_type} or "uint8"); - pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", enum $n *v)"; + fn_declare($p, "NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", enum $n *v)"); pidl "{"; if ($t eq "pull") { pidl "\t$bt\_t r;"; @@ -211,6 +218,9 @@ sub ParserTypedef($$) sub ParserInterface($) { my $x = shift; + + pidl_hdr "#ifndef __TDR_$x->{NAME}_HEADER__"; + pidl_hdr "#define __TDR_$x->{NAME}_HEADER__"; foreach (@{$x->{DATA}}) { next if ($_->{TYPE} ne "TYPEDEF"); @@ -218,63 +228,24 @@ sub ParserInterface($) ParserTypedef($_, "push"); ParserTypedef($_, "print"); } + + pidl_hdr "#endif /* __TDR_$x->{NAME}_HEADER__ */"; } -sub Parser($$) +sub Parser($$$) { - my ($idl,$hdrname) = @_; - $ret = ""; + my ($idl,$hdrname,$baseheader) = @_; + $ret = ""; $ret_hdr = ""; pidl "/* autogenerated by pidl */"; pidl "#include \"includes.h\""; pidl "#include \"$hdrname\""; pidl ""; - foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } - return $ret; -} - -sub HeaderInterface($$) -{ - my ($x,$outputdir) = @_; - - pidl "#ifndef __TDR_$x->{NAME}_HEADER__"; - pidl "#define __TDR_$x->{NAME}_HEADER__"; - - foreach my $e (@{$x->{DATA}}) { - next unless ($e->{TYPE} eq "TYPEDEF"); - next unless has_property($e, "public"); - - my $switch = ""; + pidl_hdr "/* autogenerated by pidl */"; + pidl_hdr "#include \"$baseheader\""; + pidl_hdr ""; - $switch = ", int level" if ($e->{DATA}->{TYPE} eq "UNION"); - - if ($e->{DATA}->{TYPE} eq "BITMAP") { - # FIXME - } else { - my ($n, $d) = ($e->{NAME}, lc($e->{DATA}->{TYPE})); - pidl "NTSTATUS tdr_pull\_$n(struct tdr_pull *tdr, TALLOC_CTX *ctx$switch, $d $n *v);"; - pidl "NTSTATUS tdr_print\_$n(struct tdr_print *tdr, const char *name$switch, $d $n *v);"; - pidl "NTSTATUS tdr_push\_$n(struct tdr_push *tdr$switch, $d $n *v);"; - } - - pidl ""; - } - - pidl "#endif /* __TDR_$x->{NAME}_HEADER__ */"; -} - -sub Header($$$) -{ - my ($idl,$outputdir,$basename) = @_; - $ret = ""; - pidl "/* Generated by pidl */"; - - pidl "#include \"$outputdir/$basename.h\""; - pidl ""; - - foreach (@$idl) { - HeaderInterface($_, $outputdir) if ($_->{TYPE} eq "INTERFACE"); - } - return $ret; + foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } + return ($ret_hdr, $ret); } 1; -- cgit From 94793b80d7fbd6121bb30e36b25e63abe078feee Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 Dec 2005 17:12:52 +0000 Subject: r12484: Initial work on supporting non-typedeffed types (This used to be commit e7ac6c708dde7afb4c92a8cc4dea7a95b7054e3e) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/NDR.pm | 69 ++++++++++++------------ source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 4 +- source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm | 4 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 +- 8 files changed, 45 insertions(+), 44 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index b400d1ade0..0b81536795 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -112,7 +112,7 @@ sub Interface($) { my($interface) = @_; Const($_,$interface->{NAME}) foreach (@{$interface->{CONSTS}}); - Typedef($_,$interface->{NAME}) foreach (@{$interface->{TYPEDEFS}}); + Typedef($_,$interface->{NAME}) foreach (@{$interface->{TYPES}}); Function($_,$interface->{NAME}) foreach (@{$interface->{FUNCTIONS}}); } diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index e7b790d1e5..0dd1ab4dd2 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -330,8 +330,9 @@ sub find_largest_alignment($) ##################################################################### # align a type -sub align_type +sub align_type($) { + sub align_type($); my $e = shift; unless (hasType($e)) { @@ -369,9 +370,9 @@ sub ParseElement($) }; } -sub ParseStruct($) +sub ParseStruct($$) { - my $struct = shift; + my ($ndr,$struct) = @_; my @elements = (); my $surrounding = undef; @@ -405,9 +406,9 @@ sub ParseStruct($) }; } -sub ParseUnion($) +sub ParseUnion($$) { - my $e = shift; + my ($ndr,$e) = @_; my @elements = (); my $switch_type = has_property($e, "switch_type"); unless (defined($switch_type)) { $switch_type = "uint32"; } @@ -444,9 +445,9 @@ sub ParseUnion($) }; } -sub ParseEnum($) +sub ParseEnum($$) { - my $e = shift; + my ($ndr,$e) = @_; return { TYPE => "ENUM", @@ -457,9 +458,9 @@ sub ParseEnum($) }; } -sub ParseBitmap($) +sub ParseBitmap($$) { - my $e = shift; + my ($ndr,$e) = @_; return { TYPE => "BITMAP", @@ -470,26 +471,34 @@ sub ParseBitmap($) }; } -sub ParseTypedef($$) +sub ParseType($$) { - my ($ndr,$d) = @_; - my $data; + my ($ndr, $d) = @_; - if ($d->{DATA}->{TYPE} eq "STRUCT" or $d->{DATA}->{TYPE} eq "UNION") { - CheckPointerTypes($d->{DATA}, $ndr->{PROPERTIES}->{pointer_default}); + if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "UNION") { + CheckPointerTypes($d, $ndr->{PROPERTIES}->{pointer_default}); } - if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) { - $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES}; - } - - $data = { + my $data = { STRUCT => \&ParseStruct, UNION => \&ParseUnion, ENUM => \&ParseEnum, - BITMAP => \&ParseBitmap - }->{$d->{DATA}->{TYPE}}->($d->{DATA}); + BITMAP => \&ParseBitmap, + TYPEDEF => \&ParseTypedef, + }->{$d->{TYPE}}->($ndr, $d); + + return $data; +} + +sub ParseTypedef($$) +{ + my ($ndr,$d) = @_; + if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) { + $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES}; + } + + my $data = ParseType($ndr, $d->{DATA}); $data->{ALIGN} = align_type($d->{NAME}); return { @@ -563,7 +572,7 @@ sub CheckPointerTypes($$) sub ParseInterface($) { my $idl = shift; - my @typedefs = (); + my @types = (); my @consts = (); my @functions = (); my @endpoints; @@ -582,20 +591,14 @@ sub ParseInterface($) } foreach my $d (@{$idl->{DATA}}) { - if ($d->{TYPE} eq "TYPEDEF") { - push (@typedefs, ParseTypedef($idl, $d)); - } - if ($d->{TYPE} eq "DECLARE") { push (@declares, $d); - } - - if ($d->{TYPE} eq "FUNCTION") { + } elsif ($d->{TYPE} eq "FUNCTION") { push (@functions, ParseFunction($idl, $d, \$opnum)); - } - - if ($d->{TYPE} eq "CONST") { + } elsif ($d->{TYPE} eq "CONST") { push (@consts, ParseConst($idl, $d)); + } else { + push (@types, ParseType($idl, $d)); } } @@ -620,7 +623,7 @@ sub ParseInterface($) PROPERTIES => $idl->{PROPERTIES}, FUNCTIONS => \@functions, CONSTS => \@consts, - TYPEDEFS => \@typedefs, + TYPES => \@types, DECLARES => \@declares, ENDPOINTS => \@endpoints }; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index b49e64c337..fb02120a42 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -183,7 +183,7 @@ sub ParseInterface($) pidl ""; - foreach (@{$if->{TYPEDEFS}}) { + foreach (@{$if->{TYPES}}) { ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "STRUCT"); ParseEnum($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "ENUM"); ParseBitmap($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "BITMAP"); diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index 9ef8f09dc4..c12f7554e9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -566,7 +566,7 @@ sub ParseInterface($) # Structures first pidl "/* $if->{NAME} structures */"; - foreach (@{$if->{TYPEDEFS}}) { + foreach (@{$if->{TYPES}}) { ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "STRUCT"); ParseUnion($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "UNION"); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index 3f7e8ae134..d1f1032714 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -350,7 +350,7 @@ sub LoadTypes($) foreach my $if (@{$ndr}) { next unless ($if->{TYPE} eq "INTERFACE"); - foreach my $td (@{$if->{TYPEDEFS}}) { + foreach my $td (@{$if->{TYPES}}) { my $decl = uc("$if->{NAME}_$td->{NAME}"); my $init = sub { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index f5aea73d12..8c576c44f9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -706,7 +706,7 @@ sub EjsInterface($$) %constants = (); - foreach my $d (@{$interface->{TYPEDEFS}}) { + foreach my $d (@{$interface->{TYPES}}) { ($needed->{"push_$d->{NAME}"}) && EjsTypedefPush($d); ($needed->{"pull_$d->{NAME}"}) && EjsTypedefPull($d); } @@ -831,7 +831,7 @@ sub NeededInterface($$) foreach my $d (@{$interface->{FUNCTIONS}}) { NeededFunction($d, $needed); } - foreach my $d (reverse @{$interface->{TYPEDEFS}}) { + foreach my $d (reverse @{$interface->{TYPES}}) { NeededTypedef($d, $needed); } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm index a204ee7a56..eae7ddce5f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm @@ -54,9 +54,7 @@ sub HeaderInterface($) pidl "\n"; - foreach my $d (@{$interface->{TYPEDEFS}}) { - HeaderTypedefProto($d); - } + HeaderTypedefProto($_) foreach (@{$interface->{TYPES}}); pidl "\n"; pidl "#endif /* _HEADER_EJS_$interface->{NAME} */\n"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 2242323747..bb9d32487a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2313,7 +2313,7 @@ sub ParseInterface($$) HeaderInterface($interface); # Typedefs - foreach my $d (@{$interface->{TYPEDEFS}}) { + foreach my $d (@{$interface->{TYPES}}) { ($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d); ($needed->{"pull_$d->{NAME}"}) && ParseTypedefPull($d); ($needed->{"print_$d->{NAME}"}) && ParseTypedefPrint($d); @@ -2456,7 +2456,7 @@ sub NeededInterface($$) { my ($interface,$needed) = @_; NeededFunction($_, $needed) foreach (@{$interface->{FUNCTIONS}}); - NeededTypedef($_, $needed) foreach (reverse @{$interface->{TYPEDEFS}}); + NeededTypedef($_, $needed) foreach (reverse @{$interface->{TYPES}}); } 1; -- cgit From ee10fb1a12391a76fe81e6e7a92d282ef885bc30 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 26 Dec 2005 02:14:18 +0000 Subject: r12490: Fix --warn-compat (This used to be commit ba6a767f1b3a14e076ebd049b4fdcffd64173523) --- source4/pidl/lib/Parse/Pidl/Compat.pm | 52 +++++++----------------- source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm | 17 ++++---- 2 files changed, 22 insertions(+), 47 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Compat.pm b/source4/pidl/lib/Parse/Pidl/Compat.pm index 2e7d686249..f0b8cc7b0b 100644 --- a/source4/pidl/lib/Parse/Pidl/Compat.pm +++ b/source4/pidl/lib/Parse/Pidl/Compat.pm @@ -74,29 +74,19 @@ my %supported_properties = ( "length_is" => ["ELEMENT"], ); - -my($res); - sub warning($$) -{ - my $l = shift; - my $m = shift; - - print "$l->{FILE}:$l->{LINE}:Warning:$m\n"; -} - -sub error($$) { my ($l,$m) = @_; - print "$l->{FILE}:$l->{LINE}:$m\n"; + + print STDERR "$l->{FILE}:$l->{LINE}:warning:$m\n"; } sub CheckTypedef($) { - my $td = shift; + my ($td) = @_; if (has_property($td, "nodiscriminant")) { - error($td, "nodiscriminant property not supported"); + warning($td, "nodiscriminant property not supported"); } if ($td->{TYPE} eq "BITMAP") { @@ -121,7 +111,7 @@ sub CheckElement($) my $e = shift; if (has_property($e, "noheader")) { - error($e, "noheader property not supported"); + warning($e, "noheader property not supported"); return; } @@ -131,30 +121,28 @@ sub CheckElement($) } if (has_property($e, "compression")) { - error($e, "compression() property not supported"); + warning($e, "compression() property not supported"); } if (has_property($e, "obfuscation")) { - error($e, "obfuscation() property not supported"); + warning($e, "obfuscation() property not supported"); } if (has_property($e, "sptr")) { - error($e, "sptr() pointer property not supported"); + warning($e, "sptr() pointer property not supported"); } if (has_property($e, "relative")) { - error($e, "relative() pointer property not supported"); + warning($e, "relative() pointer property not supported"); } - if (has_property($td, "flag")) { + if (has_property($e, "flag")) { warning($e, "ignoring flag() property"); } - if (has_property($td, "value")) { + if (has_property($e, "value")) { warning($e, "ignoring value() property"); } - - StripProperties($e); } sub CheckFunction($) @@ -162,12 +150,8 @@ sub CheckFunction($) my $fn = shift; if (has_property($fn, "noopnum")) { - error($fn, "noopnum not converted. Opcodes will be out of sync."); + warning($fn, "noopnum not converted. Opcodes will be out of sync."); } - - StripProperties($fn); - - } sub CheckInterface($) @@ -176,11 +160,9 @@ sub CheckInterface($) if (has_property($if, "pointer_default_top") and $if->{PROPERTIES}->{pointer_default_top} ne "ref") { - error($if, "pointer_default_top() is pidl-specific"); + warning($if, "pointer_default_top() is pidl-specific"); } - StripProperties($if); - foreach my $x (@{$if->{DATA}}) { if ($x->{TYPE} eq "DECLARE") { warning($if, "the declare keyword is pidl-specific"); @@ -193,14 +175,10 @@ sub Check($) { my $pidl = shift; my $nidl = []; - my $res = ""; - foreach my $x (@{$pidl}) { - push (@$nidl, CheckInterface($x)) - if ($x->{TYPE} eq "INTERFACE"); + foreach (@{$pidl}) { + push (@$nidl, CheckInterface($_)) if ($_->{TYPE} eq "INTERFACE"); } - - return $res; } 1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm index b9044078ea..83df9afe88 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm @@ -3,8 +3,8 @@ package Parse::Pidl::Samba4::COM::Header; -use Parse::Pidl::Typelist; -use Parse::Pidl::Util qw(has_property); +use Parse::Pidl::Typelist qw(mapType); +use Parse::Pidl::Util qw(has_property is_constant); use vars qw($VERSION); $VERSION = '0.01'; @@ -18,7 +18,7 @@ sub GetArgumentProtoList($) foreach my $a (@{$f->{ELEMENTS}}) { - $res .= ", " . Parse::Pidl::Typelist::mapType($a->{TYPE}) . " "; + $res .= ", " . mapType($a->{TYPE}) . " "; my $l = $a->{POINTERS}; $l-- if (Parse::Pidl::Typelist::scalar_is_reference($a->{TYPE})); @@ -26,13 +26,12 @@ sub GetArgumentProtoList($) $res .= "*"; } - if (defined $a->{ARRAY_LEN}[0] && - !Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0]) && + if (defined $a->{ARRAY_LEN}[0] && !is_constant($a->{ARRAY_LEN}[0]) && !$a->{POINTERS}) { $res .= "*"; } $res .= $a->{NAME}; - if (defined $a->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0])) { + if (defined $a->{ARRAY_LEN}[0] && is_constant($a->{ARRAY_LEN}[0])) { $res .= "[$a->{ARRAY_LEN}[0]]"; } } @@ -45,9 +44,7 @@ sub GetArgumentList($) my $f = shift; my $res = ""; - foreach my $a (@{$f->{ELEMENTS}}) { - $res .= ", $a->{NAME}"; - } + foreach (@{$f->{ELEMENTS}}) { $res .= ", $_->{NAME}"; } return $res; } @@ -65,7 +62,7 @@ sub HeaderVTable($) my $data = $interface->{DATA}; foreach my $d (@{$data}) { - $res .= "\t" . Parse::Pidl::Typelist::mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION"); + $res .= "\t" . mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION"); } $res .= "\n"; $res .= "struct $interface->{NAME}_vtable {\n"; -- cgit From c1c01df22f7145ca86b97fce670131017b3df3b9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 26 Dec 2005 22:47:40 +0000 Subject: r12501: Merge EJSHeader.pm into EJS.pm and simplify smbcalls_rpc.c a bit, now that it is guaranteed that the smbcalls modules are always initialized after the EJS subsystem itself. (This used to be commit 1e8670874bb7415c3e00a42516680fdb4ee2fca1) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 78 +++++++++++++++++-------- source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm | 77 ------------------------ 2 files changed, 55 insertions(+), 100 deletions(-) delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 8c576c44f9..d5e1405c30 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -13,10 +13,18 @@ use Parse::Pidl::Util qw(has_property); use vars qw($VERSION); $VERSION = '0.01'; -my($res); +my $res; +my $res_hdr; + my %constants; my $tabs = ""; + +sub pidl_hdr ($) +{ + $res_hdr .= shift; +} + sub pidl($) { my $d = shift; @@ -110,12 +118,16 @@ sub get_value_of($) ##################################################################### # work out is a parse function should be declared static or not -sub fn_prefix($) +sub fn_declare($$) { - my $fn = shift; + my ($fn,$decl) = @_; - return "" if (has_property($fn, "public")); - return "static "; + if (has_property($fn, "public")) { + pidl_hdr "$decl;\n"; + pidl "$decl"; + } else { + pidl "static $decl"; + } } ########################### @@ -251,8 +263,8 @@ sub EjsStructPull($$) my $name = shift; my $d = shift; my $env = GenerateStructEnv($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)\n{"; + fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)"); + pidl "{"; indent; pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; foreach my $e (@{$d->{ELEMENTS}}) { @@ -271,8 +283,8 @@ sub EjsUnionPull($$) my $d = shift; my $have_default = 0; my $env = GenerateStructEnv($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)\n{"; + fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)"); + pidl "{"; indent; pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; pidl "switch (ejs->switch_var) {"; @@ -327,8 +339,8 @@ sub EjsEnumPull($$) my $name = shift; my $d = shift; EjsEnumConstant($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)\n{"; + fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)"); + pidl "{"; indent; pidl "unsigned e;"; pidl "NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));"; @@ -346,8 +358,8 @@ sub EjsBitmapPull($$) my $d = shift; my $type_fn = $d->{BASE_TYPE}; my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE}); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)\n{"; + fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)"); + pidl "{"; indent; pidl "return ejs_pull_$type_fn(ejs, v, name, r);"; deindent; @@ -529,8 +541,8 @@ sub EjsStructPush($$) my $name = shift; my $d = shift; my $env = GenerateStructEnv($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)\n{"; + fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)"); + pidl "{"; indent; pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; foreach my $e (@{$d->{ELEMENTS}}) { @@ -549,8 +561,8 @@ sub EjsUnionPush($$) my $d = shift; my $have_default = 0; my $env = GenerateStructEnv($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)\n{"; + fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)"); + pidl "{"; indent; pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; pidl "switch (ejs->switch_var) {"; @@ -587,8 +599,8 @@ sub EjsEnumPush($$) my $name = shift; my $d = shift; EjsEnumConstant($d); - pidl fn_prefix($d); - pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)\n{"; + fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)"); + pidl "{"; indent; pidl "unsigned e = *r;"; pidl "NDR_CHECK(ejs_push_enum(ejs, v, name, &e));"; @@ -613,8 +625,8 @@ sub EjsBitmapPush($$) $constants{$bname} = $v; } } - pidl fn_prefix($d); - pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)\n{"; + fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)"); + pidl "{"; indent; pidl "return ejs_push_$type_fn(ejs, v, name, r);"; deindent; @@ -628,6 +640,7 @@ sub EjsTypedefPush($) { my $d = shift; return if (has_property($d, "noejs")); + if ($d->{DATA}->{TYPE} eq 'STRUCT') { EjsStructPush($d->{NAME}, $d->{DATA}); } elsif ($d->{DATA}->{TYPE} eq 'UNION') { @@ -706,6 +719,17 @@ sub EjsInterface($$) %constants = (); + pidl_hdr "#ifndef _HEADER_EJS_$interface->{NAME}\n"; + pidl_hdr "#define _HEADER_EJS_$interface->{NAME}\n\n"; + + if (has_property($interface, "depends")) { + foreach (split / /, $interface->{PROPERTIES}->{depends}) { + pidl_hdr "#include \"librpc/gen_ndr/ndr_$_\_ejs\.h\"\n"; + } + } + + pidl_hdr "\n"; + foreach my $d (@{$interface->{TYPES}}) { ($needed->{"push_$d->{NAME}"}) && EjsTypedefPush($d); ($needed->{"pull_$d->{NAME}"}) && EjsTypedefPull($d); @@ -748,9 +772,13 @@ sub EjsInterface($$) pidl "NTSTATUS ejs_init_$name(void)"; pidl "{"; indent; - pidl "return smbcalls_register_ejs(\"$name\_init\", ejs_$name\_init);"; + pidl "ejsDefineCFunction(-1, \"$name\_init\", ejs_$name\_init, NULL, MPR_VAR_SCRIPT_HANDLE);"; + pidl "return NT_STATUS_OK;"; deindent; pidl "}"; + + pidl_hdr "\n"; + pidl_hdr "#endif /* _HEADER_EJS_$interface->{NAME} */\n"; } ##################################################################### @@ -762,6 +790,10 @@ sub Parse($$) my $ejs_hdr = $hdr; $ejs_hdr =~ s/.h$/_ejs.h/; $res = ""; + $res_hdr = ""; + + pidl_hdr "/* header auto-generated by pidl */\n\n"; + pidl " /* EJS wrapper functions auto-generated by pidl */ #include \"includes.h\" @@ -784,7 +816,7 @@ sub Parse($$) ($x->{TYPE} eq "INTERFACE") && EjsInterface($x, \%needed); } - return $res; + return ($res_hdr, $res); } sub NeededFunction($$) diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm deleted file mode 100644 index eae7ddce5f..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJSHeader.pm +++ /dev/null @@ -1,77 +0,0 @@ -################################################### -# create C header files for an EJS mapping functions -# Copyright tridge@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba4::EJSHeader; - -use strict; -use Parse::Pidl::Typelist; -use Parse::Pidl::Util qw(has_property); - -use vars qw($VERSION); -$VERSION = '0.01'; - -my($res); - -sub pidl ($) -{ - $res .= shift; -} - -##################################################################### -# prototype a typedef -sub HeaderTypedefProto($) -{ - my $d = shift; - my $name = $d->{NAME}; - - return unless has_property($d, "public"); - - my $type_decl = Parse::Pidl::Typelist::mapType($name); - - pidl "NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, const $type_decl *);\n"; - pidl "NTSTATUS ejs_pull_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, $type_decl *);\n"; -} - -##################################################################### -# parse the interface definitions -sub HeaderInterface($) -{ - my($interface) = shift; - - my $count = 0; - - pidl "#ifndef _HEADER_EJS_$interface->{NAME}\n"; - pidl "#define _HEADER_EJS_$interface->{NAME}\n\n"; - - if (defined $interface->{PROPERTIES}->{depends}) { - my @d = split / /, $interface->{PROPERTIES}->{depends}; - foreach my $i (@d) { - pidl "#include \"librpc/gen_ndr/ndr_$i\_ejs\.h\"\n"; - } - } - - pidl "\n"; - - HeaderTypedefProto($_) foreach (@{$interface->{TYPES}}); - - pidl "\n"; - pidl "#endif /* _HEADER_EJS_$interface->{NAME} */\n"; -} - -##################################################################### -# parse a parsed IDL into a C header -sub Parse($) -{ - my($idl) = shift; - - $res = ""; - pidl "/* header auto-generated by pidl */\n\n"; - foreach my $x (@{$idl}) { - ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x); - } - return $res; -} - -1; -- cgit From d658de65d32e6746ac51aeb4da7aa74b3da40c2b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Dec 2005 16:22:35 +0000 Subject: r12512: Use GUID structs in API functions everywhere rather then converting back and forth between GUID structs and strings in several places. (This used to be commit 3564e2f967ef72d6301b4f7e9a311cebcded4d75) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 9 +++++---- source4/pidl/lib/Parse/Pidl/Util.pm | 16 +++++++++++++++- 3 files changed, 22 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index bb9d32487a..2247fcbf81 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -9,7 +9,7 @@ package Parse::Pidl::Samba4::NDR::Parser; use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); -use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::Util qw(has_property ParseExpr print_uuid); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use vars qw($VERSION); @@ -2218,7 +2218,7 @@ sub FunctionTable($) pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {"; pidl "\t.name\t\t= \"$interface->{NAME}\","; - pidl "\t.uuid\t\t= DCERPC_$uname\_UUID,"; + pidl "\t.uuid\t\t= ". print_uuid($interface->{UUID}) .","; pidl "\t.if_version\t= DCERPC_$uname\_VERSION,"; pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,"; pidl "\t.num_calls\t= $count,"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index 585209b733..8710f08cc7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -7,6 +7,7 @@ package Parse::Pidl::Samba4::NDR::Server; use strict; +use Parse::Pidl::Util; use vars qw($VERSION); $VERSION = '0.01'; @@ -76,7 +77,7 @@ sub Boilerplate_Iface($) my($interface) = shift; my $name = $interface->{NAME}; my $uname = uc $name; - my $uuid = Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})); + my $uuid = lc($interface->{PROPERTIES}->{uuid}); my $if_version = $interface->{PROPERTIES}->{version}; pidl " @@ -187,7 +188,7 @@ static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_C static const struct dcesrv_interface $name\_interface = { .name = \"$name\", - .uuid = $uuid, + .uuid = ".print_uuid($uuid).", .if_version = $if_version, .bind = $name\__op_bind, .unbind = $name\__op_unbind, @@ -227,10 +228,10 @@ static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const str return NT_STATUS_OK; } -static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version) +static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version) { if ($name\_interface.if_version == if_version && - strcmp($name\_interface.uuid, uuid)==0) { + GUID_equal(\&$name\_interface.uuid, uuid)) { memcpy(iface,&$name\_interface, sizeof(*iface)); return True; } diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index ec6a1420ab..ff615a21ba 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -6,7 +6,7 @@ package Parse::Pidl::Util; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(has_property property_matches ParseExpr is_constant make_str); +@EXPORT = qw(has_property property_matches ParseExpr is_constant make_str print_uuid); use vars qw($VERSION); $VERSION = '0.01'; @@ -75,6 +75,20 @@ sub make_str($) return "\"" . $str . "\""; } +sub print_uuid($) +{ + my ($uuid) = @_; + $uuid =~ s/"//g; + my ($time_low,$time_mid,$time_hi,$clock_seq,$node) = split /-/, $uuid; + + my @clock_seq = $clock_seq =~ /(..)/g; + my @node = $node =~ /(..)/g; + + return "{0x$time_low,0x$time_mid,0x$time_hi," . + "{".join(',', map {"0x$_"} @clock_seq)."}," . + "{".join(',', map {"0x$_"} @node)."}}"; +} + # a hack to build on platforms that don't like negative enum values my $useUintEnums = 0; sub setUseUintEnums($) -- cgit From 05b141c5c93eecdc07b17d19804a0cf7b77f3ebd Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Dec 2005 17:50:53 +0000 Subject: r12515: Use UUID directly rather then string containing UUID (This used to be commit 465b9738709e7415eab58ea773bd138e8f0f20d6) --- source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm index 26a1225590..c0d460fe09 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm @@ -54,7 +54,7 @@ sub ParseRegFunc($) $res.= " const void *base_vtable; - GUID_from_string(DCERPC_" . (uc $interface->{BASE}) . "_UUID, &base_iid); + base_iid = dcerpc_table_$interface->{BASE}.uuid; base_vtable = dcom_proxy_vtable_by_iid(&base_iid); if (base_vtable == NULL) { @@ -73,7 +73,7 @@ sub ParseRegFunc($) } $res.= " - GUID_from_string(DCERPC_" . (uc $interface->{NAME}) . "_UUID, &proxy_vtable.iid); + proxy_vtable.iid = dcerpc_table_$interface->{NAME}.uuid; return dcom_register_proxy(&proxy_vtable); }\n\n"; -- cgit From d49f11df218699014af32d19eef8dcc0a70ff38f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Dec 2005 19:13:18 +0000 Subject: r12517: Don't generate empty init functions (This used to be commit 832a1092c9c11c293b5748e2e78da872fcba2a42) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 35 +++++++++++------------- 1 file changed, 16 insertions(+), 19 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 2247fcbf81..f294fa1b9b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2158,13 +2158,10 @@ sub FunctionTable($) my $count = 0; my $uname = uc $interface->{NAME}; - $count = $#{$interface->{FUNCTIONS}}+1; - - return if ($count == 0); + return if ($#{$interface->{FUNCTIONS}}+1 == 0); return unless defined ($interface->{PROPERTIES}->{uuid}); pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {"; - $count = 0; foreach my $d (@{$interface->{FUNCTIONS}}) { next if not defined($d->{OPNUM}); pidl "\t{"; @@ -2343,26 +2340,26 @@ sub RegistrationFunction($$) { my ($idl,$basename) = @_; - pidl "NTSTATUS dcerpc_$basename\_init(void)"; - pidl "{"; - indent; - pidl "NTSTATUS status = NT_STATUS_OK;"; + my $body = ""; + foreach my $interface (@{$idl}) { next if $interface->{TYPE} ne "INTERFACE"; - - my $count = ($#{$interface->{FUNCTIONS}}+1); - - next if ($count == 0); + next if ($#{$interface->{FUNCTIONS}}+1 == 0); next unless defined ($interface->{PROPERTIES}->{uuid}); - pidl "status = dcerpc_ndr_$interface->{NAME}_init();"; - pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\treturn status;"; - pidl "}"; - pidl ""; + $body .= "\tstatus = dcerpc_ndr_$interface->{NAME}_init();\n"; + $body .= "\tif (NT_STATUS_IS_ERR(status)) {\n"; + $body .= "\t\treturn status;\n"; + $body .= "\t}\n"; + $body .= "\n"; } - pidl "return status;"; - deindent; + + return unless $body; + + pidl "NTSTATUS dcerpc_$basename\_init(void)"; + pidl "{"; + pidl "\tNTSTATUS status = NT_STATUS_OK;"; + pidl "$body\treturn status;"; pidl "}"; pidl ""; } -- cgit From 0a3c167f6bcf08b2204ca49831ca49eef73dcbf4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Dec 2005 22:51:30 +0000 Subject: r12528: Add seperate proto headers for ntvfs, tdr, smb_server and nbt_server. (This used to be commit 87f665a1d5ba74289974bf9d8f9441c162e6f1b1) --- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index 789fb7adbe..3bdb701526 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -242,6 +242,7 @@ sub Parser($$$) pidl ""; pidl_hdr "/* autogenerated by pidl */"; pidl_hdr "#include \"$baseheader\""; + pidl_hdr "#include \"tdr/tdr.h\""; pidl_hdr ""; foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } -- cgit From 1cfda1af18db8aee6d4d3031f2056d80f4afe75b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 29 Dec 2005 16:03:03 +0000 Subject: r12572: No longer parse coclasses as interfaces (This used to be commit f75f757b621a46ea531c27ac682623829a4fdea7) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 0dd1ab4dd2..179d2ecb12 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -642,7 +642,9 @@ sub Parse($) my @ndr = (); - push(@ndr, ParseInterface($_)) foreach (@{$idl}); + foreach (@{$idl}) { + ($_->{TYPE} eq "INTERFACE") && push(@ndr, ParseInterface($_)); + } return \@ndr; } -- cgit From 87fd7b5484b10ccdece6152f2a2a9adb4ea5fc78 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 29 Dec 2005 16:04:34 +0000 Subject: r12574: Bring tables.pl back to life and move registration of interfaces now completely to a new subsystem. (This used to be commit bbacfaaea5819e0ecadf81e8fbb424916284c809) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 35 ------------------------ 1 file changed, 35 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index f294fa1b9b..5d01531eb7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2225,11 +2225,6 @@ sub FunctionTable($) pidl "};"; pidl ""; - pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)"; - pidl "{"; - pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});"; - pidl "}"; - pidl ""; } ##################################################################### @@ -2336,34 +2331,6 @@ sub ParseInterface($$) FunctionTable($interface); } -sub RegistrationFunction($$) -{ - my ($idl,$basename) = @_; - - my $body = ""; - - foreach my $interface (@{$idl}) { - next if $interface->{TYPE} ne "INTERFACE"; - next if ($#{$interface->{FUNCTIONS}}+1 == 0); - next unless defined ($interface->{PROPERTIES}->{uuid}); - - $body .= "\tstatus = dcerpc_ndr_$interface->{NAME}_init();\n"; - $body .= "\tif (NT_STATUS_IS_ERR(status)) {\n"; - $body .= "\t\treturn status;\n"; - $body .= "\t}\n"; - $body .= "\n"; - } - - return unless $body; - - pidl "NTSTATUS dcerpc_$basename\_init(void)"; - pidl "{"; - pidl "\tNTSTATUS status = NT_STATUS_OK;"; - pidl "$body\treturn status;"; - pidl "}"; - pidl ""; -} - ##################################################################### # parse a parsed IDL structure back into an IDL file sub Parse($$) @@ -2390,8 +2357,6 @@ sub Parse($$) ($_->{TYPE} eq "INTERFACE") && ParseInterface($_, \%needed); } - RegistrationFunction($ndr, $basename); - return ($res_hdr, $res); } -- cgit From e3e048630be2fbf20d580850e5673ad372bd34f0 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Tue, 28 Feb 2006 03:42:19 +0000 Subject: r13738: added support for a "pointer" type in pidl. This will be used in the opendb work that will be committed shortly. The pointer type assumes that pointers fit in 64 bits, which is probably OK on all our supported architectures. (This used to be commit d2a2057ea5af140ca88a9c305a38fc5dca9eaafd) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 1 + source4/pidl/lib/Parse/Pidl/Typelist.pm | 5 +++++ 2 files changed, 6 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 179d2ecb12..48d3ebf170 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -51,6 +51,7 @@ my $scalar_alignment = { 'int32' => 4, 'uint32' => 4, 'hyper' => 8, + 'pointer' => 8, 'dlong' => 4, 'udlong' => 4, 'udlongr' => 4, diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 67e348c5fe..b54badaeb6 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -73,6 +73,11 @@ my $scalars = { C_TYPE => "uint64_t", IS_REFERENCE => 0, }, + # assume its a 8 byte type, but cope with either + "pointer" => { + C_TYPE => "void*", + IS_REFERENCE => 0, + }, # DATA_BLOB types "DATA_BLOB" => { -- cgit From c71c86c52458eefae8a34774ec186c2837f473af Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 5 Mar 2006 17:44:16 +0000 Subject: r13842: Make some more functions public. (This used to be commit aac1b99b362993352d80692afa55c38fc851c016) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 5d01531eb7..efcb0f6ea4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -199,7 +199,7 @@ sub fn_declare($$) if (has_property($fn, "public")) { pidl_hdr "$decl;"; - pidl "$decl"; + pidl "_PUBLIC_ $decl"; } else { pidl "static $decl"; } @@ -1867,7 +1867,7 @@ sub ParseTypedefPrint($) my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print"); - pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; + pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; pidl_hdr "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args);"; pidl "{"; indent; @@ -1904,7 +1904,7 @@ sub ParseFunctionPrint($) return if has_property($fn, "noprint"); - pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; + pidl "_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; pidl_hdr "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r);"; pidl "{"; indent; -- cgit From f07143c35cc4514e6714d34e43ea065c38fc2321 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 9 Mar 2006 21:59:37 +0000 Subject: r14105: fix whitespaces metze (This used to be commit 1b4c9f7fc203908d9cdd331f26b983fb445f05e2) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index 83f9034c7c..1da765303c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -40,7 +40,7 @@ NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name * status = dcerpc_ndr_request_recv(req); - if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { + if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { NDR_PRINT_OUT_DEBUG($name, r); } "; -- cgit From 39f1f55610594c4b82c4b0f1ec7c9611b2f3f8a4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 11 Mar 2006 23:00:14 +0000 Subject: r14215: Improve warning/error messages. (This used to be commit 80b9865b373ee542da2d56d6688b4c8fd4c6275c) --- source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 12 +++++++++--- 4 files changed, 14 insertions(+), 8 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm index ceeb81c3d7..59f0341d02 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm @@ -19,8 +19,8 @@ my $tabs = ""; sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $res .= $tabs.(shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } -sub warning($$) { my ($e,$s) = @_; warn("$e->{FILE}:$e->{LINE}: $s\n"); } +sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } +sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } sub CopyLevel($$$$) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index fb02120a42..480a6c8e44 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -19,8 +19,8 @@ my $tabs = ""; sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $res .= $tabs.(shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } -sub warning($$) { my ($e,$s) = @_; warn("$e->{FILE}:$e->{LINE}: $s\n"); } +sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } +sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } sub ParseElement($) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index c12f7554e9..a6b4b38cdf 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -22,7 +22,7 @@ my $tabs = ""; sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $res .= $tabs.(shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } +sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } #TODO: # - Add some security checks (array sizes, memory alloc == NULL, etc) diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index d1f1032714..c31f406a38 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -18,7 +18,7 @@ $VERSION = '0.01'; # TODO: Find external types somehow? -sub warning($$) { my ($e,$s) = @_; print STDERR "$e->{FILE}:$e->{LINE}: $s\n"; } +sub warning($$) { my ($e,$s) = @_; print STDERR "$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"; } sub init_scalar($$$$) { @@ -144,6 +144,12 @@ my $known_types = INIT => \&init_scalar, DISSECT_P => \&dissect_scalar, }, + int32 => + { + DECL => "int32", + INIT => \&init_scalar, + DISSECT_P => \&dissect_scalar, + }, string => { DECL => \&decl_string, @@ -228,7 +234,7 @@ sub DeclShort($) my $t = $known_types->{$e->{TYPE}}; if (not $t) { - warning($e, "Can't declare unknown type $e->{TYPE}"); + warning($e, "Can't declare unknown type `$e->{TYPE}'"); return undef; } @@ -262,7 +268,7 @@ sub DeclLong($) my $t = $known_types->{$e->{TYPE}}; if (not $t) { - warning($e, "Can't declare unknown type $e->{TYPE}"); + warning($e, "Can't declare unknown type `$e->{TYPE}'"); return undef; } -- cgit From 9edbad7a36a2a7e61439eba9cd043adf81f70468 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 11 Mar 2006 23:20:37 +0000 Subject: r14223: Couple of small fixes: - properly support --samba3-header argument used alone - support `security_descriptor' data type - only print pidl warnings, not perl warnings on erratic input - insert copyright header in templates (This used to be commit db1d7358b2ba9b104c1a96762af89b500b79172f) --- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 3 ++- source4/pidl/lib/Parse/Pidl/Samba3/Template.pm | 36 +++++++++++++++++++------- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 9 +++++++ 3 files changed, 37 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm index 480a6c8e44..c479b14afa 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm @@ -32,7 +32,8 @@ sub ParseElement($) pidl "\tuint32 ptr$l->{POINTER_INDEX}_$e->{NAME};"; } elsif ($l->{TYPE} eq "SWITCH") { } elsif ($l->{TYPE} eq "DATA") { - pidl "\t" . DeclShort($e) . ";"; + my $n = DeclShort($e); + pidl "\t$n;" if ($n); } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED}) { my ($t,$f) = StringType($e,$l); pidl "\t" . uc($t) . " $e->{NAME};"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm index 072aa07850..47d565dce6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm @@ -45,16 +45,32 @@ sub Parse($$) $res = ""; - pidl "/*"; - pidl " * Unix SMB/CIFS implementation."; - pidl " * template auto-generated by pidl. Modify to your needs"; - pidl " */"; - pidl ""; - pidl "#include \"includes.h\""; - pidl ""; - pidl "#undef DBGC_CLASS"; - pidl "#define DBGC_CLASS DBGC_MSRPC"; - pidl ""; + pidl "/* + * Unix SMB/CIFS implementation. + **** template auto-generated by pidl. Modify to your needs **** + * RPC Pipe client / server routines + * Copyright (C) YOUR NAME YEAR. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include \"includes.h\" + +#undef DBGC_CLASS +#define DBGC_CLASS DBGC_MSRPC +"; foreach (@$ndr) { ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm index c31f406a38..666d23e669 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm @@ -205,6 +205,15 @@ my $known_types = return "smb_io_pol_hnd(\"$e->{NAME}\", &n, ps, depth)"; } }, + security_descriptor => + { + DECL => "SEC_DESC", + INIT => "", + DISSECT_P => sub { + my ($e,$l,$n,$w,$a) = @_; + return "sec_io_desc(\"$e->{NAME}\", &n, ps, depth)"; + } + }, hyper => { DECL => "uint64", -- cgit From 35447f0a486a00dc11355613ea7aaa7928c69961 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 13 Mar 2006 22:32:41 +0000 Subject: r14348: Fix location of #endif (This used to be commit eb8687cdd4240c5636384e992a0f1a77251fddcc) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index efcb0f6ea4..e89ce3268a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2237,11 +2237,6 @@ sub HeaderInterface($) my $count = 0; - pidl_hdr "#ifndef _HEADER_RPC_$interface->{NAME}"; - pidl_hdr "#define _HEADER_RPC_$interface->{NAME}"; - - pidl_hdr ""; - if (defined $interface->{PROPERTIES}->{depends}) { my @d = split / /, $interface->{PROPERTIES}->{depends}; foreach my $i (@d) { @@ -2293,7 +2288,6 @@ sub HeaderInterface($) pidl_hdr "#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ($val)"; - pidl_hdr "#endif /* _HEADER_RPC_$interface->{NAME} */"; } ##################################################################### @@ -2302,6 +2296,11 @@ sub ParseInterface($$) { my($interface,$needed) = @_; + pidl_hdr "#ifndef _HEADER_RPC_$interface->{NAME}"; + pidl_hdr "#define _HEADER_RPC_$interface->{NAME}"; + + pidl_hdr ""; + HeaderInterface($interface); # Typedefs @@ -2329,6 +2328,8 @@ sub ParseInterface($$) } FunctionTable($interface); + + pidl_hdr "#endif /* _HEADER_RPC_$interface->{NAME} */"; } ##################################################################### @@ -2422,4 +2423,3 @@ sub NeededInterface($$) } 1; - -- cgit From 9865048bf41acff37d021a0773347d36bcac3798 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 14 Mar 2006 00:12:58 +0000 Subject: r14361: Support 'helper' attribute in pidl and use it. Remove some headers from include/includes.h (they're now only included in the file they are used) (This used to be commit 7213b7498eacac2c2cd03cf6aace376ce153cc7c) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 1 + source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 6 ++++++ 2 files changed, 7 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 48d3ebf170..b1aec5cc5d 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -750,6 +750,7 @@ my %property_list = ( "pointer_default" => ["INTERFACE"], "pointer_default_top" => ["INTERFACE"], "depends" => ["INTERFACE"], + "helper" => ["INTERFACE"], "authservice" => ["INTERFACE"], # dcom diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index e89ce3268a..0b2cef54b8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2244,6 +2244,12 @@ sub HeaderInterface($) } } + if (defined $interface->{PROPERTIES}->{helper}) { + foreach (split / /, $interface->{PROPERTIES}->{helper}) { + pidl_hdr "#include $_"; + } + } + if (defined $interface->{PROPERTIES}->{uuid}) { my $name = uc $interface->{NAME}; pidl_hdr "#define DCERPC_$name\_UUID " . -- cgit From 227a789351acd600d4cde15df9e6b3d106e862c1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 14 Mar 2006 00:37:05 +0000 Subject: r14362: Only include ndr_compression.h when necessary. (This used to be commit 4fced6dbbdc06233e5cf69f90c099fafee9baa34) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 0b2cef54b8..4a1f8a9c14 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2307,6 +2307,10 @@ sub ParseInterface($$) pidl_hdr ""; + if ($needed->{"compression"}) { + pidl "#include \"librpc/ndr/ndr_compression.h\""; + } + HeaderInterface($interface); # Typedefs @@ -2403,6 +2407,9 @@ sub NeededTypedef($$) for my $e (@{$t->{DATA}->{ELEMENTS}}) { $e->{PARENT} = $t->{DATA}; + if (has_property($e, "compression")) { + $needed->{"compression"} = 1; + } if ($needed->{"pull_$t->{NAME}"} and not defined($needed->{"pull_$e->{TYPE}"})) { $needed->{"pull_$e->{TYPE}"} = 1; -- cgit From 1060f6b3f621cb70b075a879f129e57f10fdbf8a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 14 Mar 2006 23:35:30 +0000 Subject: r14402: Generate seperate headers for RPC client functions. (This used to be commit 7054ebf0249930843a2baf4d023ae8f62cedb109) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 25 +++++++++++++----------- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 5 ++--- 2 files changed, 16 insertions(+), 14 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index 1da765303c..60faa78df3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -10,7 +10,7 @@ $VERSION = '0.01'; use strict; -my($res); +my($res,$res_hdr); ##################################################################### # parse a function @@ -20,6 +20,10 @@ sub ParseFunction($$) my $name = $fn->{NAME}; my $uname = uc $name; + $res_hdr .= "\nstruct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r); +NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r); +"; + $res .= " struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) { @@ -74,29 +78,28 @@ sub ParseInterface($) return $res; } -sub Parse($$) +sub Parse($$$$) { - my($ndr) = shift; - my($filename) = shift; + my($ndr,$header,$ndr_header,$client_header) = @_; - my $h_filename = $filename; $res = ""; - - if ($h_filename =~ /(.*)\.c/) { - $h_filename = "$1.h"; - } + $res_hdr = ""; $res .= "/* client functions auto-generated by pidl */\n"; $res .= "\n"; $res .= "#include \"includes.h\"\n"; - $res .= "#include \"$h_filename\"\n"; + $res .= "#include \"$ndr_header\"\n"; + $res .= "#include \"$client_header\"\n"; $res .= "\n"; + $res_hdr .= "#include \"librpc/rpc/dcerpc.h\"\n"; + $res_hdr .= "#include \"$header\"\n"; + foreach my $x (@{$ndr}) { ($x->{TYPE} eq "INTERFACE") && ParseInterface($x); } - return $res; + return ($res,$res_hdr); } 1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 4a1f8a9c14..249a1ae194 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2237,6 +2237,8 @@ sub HeaderInterface($) my $count = 0; + pidl_hdr "#include \"librpc/ndr/libndr.h\""; + if (defined $interface->{PROPERTIES}->{depends}) { my @d = split / /, $interface->{PROPERTIES}->{depends}; foreach my $i (@d) { @@ -2279,9 +2281,6 @@ sub HeaderInterface($) pidl_hdr "#define DCERPC_$u_name ($val)"; - pidl_hdr "NTSTATUS dcerpc_$_->{NAME}(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $_->{NAME} *r);"; - pidl_hdr "struct rpc_request *dcerpc_$_->{NAME}\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $_->{NAME} *r);"; - pidl_hdr ""; $count++; } -- cgit From 84aea6eca58b20f32fad0de0f43d9a5c7de247c9 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 15 Mar 2006 17:26:53 +0000 Subject: r14455: also add the: #ifndef FOO #define FOO ... #endif to the client headers metze (This used to be commit c0dd773537bda9980e77eb6eda848161b7df82e5) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 6 ++++++ source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 8 ++++---- 2 files changed, 10 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index 60faa78df3..0f3a86e81e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -66,6 +66,10 @@ my %done; sub ParseInterface($) { my($interface) = shift; + + $res_hdr .= "#ifndef _HEADER_RPC_$interface->{NAME}\n"; + $res_hdr .= "#define _HEADER_RPC_$interface->{NAME}\n\n"; + $res .= "/* $interface->{NAME} - client functions generated by pidl */\n\n"; foreach my $fn (@{$interface->{FUNCTIONS}}) { @@ -75,6 +79,8 @@ sub ParseInterface($) $done{$fn->{NAME}} = 1; } + $res_hdr .= "#endif /* _HEADER_RPC_$interface->{NAME} */\n"; + return $res; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 249a1ae194..42375674f5 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2301,8 +2301,8 @@ sub ParseInterface($$) { my($interface,$needed) = @_; - pidl_hdr "#ifndef _HEADER_RPC_$interface->{NAME}"; - pidl_hdr "#define _HEADER_RPC_$interface->{NAME}"; + pidl_hdr "#ifndef _HEADER_NDR_$interface->{NAME}"; + pidl_hdr "#define _HEADER_NDR_$interface->{NAME}"; pidl_hdr ""; @@ -2338,7 +2338,7 @@ sub ParseInterface($$) FunctionTable($interface); - pidl_hdr "#endif /* _HEADER_RPC_$interface->{NAME} */"; + pidl_hdr "#endif /* _HEADER_NDR_$interface->{NAME} */"; } ##################################################################### @@ -2351,7 +2351,7 @@ sub Parse($$) $res = ""; $res_hdr = ""; - pidl_hdr "/* header auto-generated by pidl */"; + pidl_hdr "/* header auto-generated by pidl */"; pidl_hdr ""; pidl "/* parser auto-generated by pidl */"; -- cgit From 8528016978b084213ef53d66e1b6e831b1a01acc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 16 Mar 2006 00:23:11 +0000 Subject: r14464: Don't include ndr_BASENAME.h files unless strictly required, instead try to include just the BASENAME.h files (containing only structs) (This used to be commit 3dd477ca5147f28a962b8437e2611a8222d706bd) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 6 +++++- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 4 ++-- 2 files changed, 7 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 42375674f5..972368195b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2239,10 +2239,14 @@ sub HeaderInterface($) pidl_hdr "#include \"librpc/ndr/libndr.h\""; + if (has_property($interface, "object")) { + pidl "#include \"librpc/gen_ndr/ndr_orpc.h\""; + } + if (defined $interface->{PROPERTIES}->{depends}) { my @d = split / /, $interface->{PROPERTIES}->{depends}; foreach my $i (@d) { - pidl_hdr "#include \"librpc/gen_ndr/ndr_$i\.h\""; + pidl "#include \"librpc/gen_ndr/ndr_$i\.h\""; } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index 8710f08cc7..fd6d303330 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -309,11 +309,11 @@ sub ParseInterface($) sub Parse($$) { - my($ndr) = shift; - my($filename) = shift; + my($ndr,$header) = @_; $res = ""; $res .= "/* server functions auto-generated by pidl */\n"; + $res .= "#include \"$header\"\n"; $res .= "\n"; foreach my $x (@{$ndr}) { -- cgit From 4f1c8daa36a7a0372c5fd9eab51f3c16ee81c49d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 16 Mar 2006 12:43:28 +0000 Subject: r14470: Remove some unnecessary headers. (This used to be commit f7312dab3b9aba2b2b82e8a6e0c483a32a03a63a) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index 0f3a86e81e..d52dc12ec3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -70,6 +70,10 @@ sub ParseInterface($) $res_hdr .= "#ifndef _HEADER_RPC_$interface->{NAME}\n"; $res_hdr .= "#define _HEADER_RPC_$interface->{NAME}\n\n"; + if (defined $interface->{PROPERTIES}->{uuid}) { + $res_hdr .= "extern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n"; + } + $res .= "/* $interface->{NAME} - client functions generated by pidl */\n\n"; foreach my $fn (@{$interface->{FUNCTIONS}}) { -- cgit From ecf0dd6bafaa95692c3ece94b6f71446cd54ebdc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 16 Mar 2006 20:02:31 +0000 Subject: r14488: Install more headers. Generate different #include lines in pidl depending on whether we're building inside or outside of the Samba tree (useful for 3rd-party projects). (This used to be commit 0c188833154c1fe565cb1735909e408a4a1a6049) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 32 ++++++++++++++++++++++++ source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm | 17 +++++++------ source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm | 18 +++++++------ source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 5 ++++ source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 31 ++++++++++++++++++----- 5 files changed, 83 insertions(+), 20 deletions(-) create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm new file mode 100644 index 0000000000..0a284aa85b --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -0,0 +1,32 @@ +################################################### +# Common Samba4 functions +# Copyright jelmer@samba.org 2006 +# released under the GNU GPL + +package Parse::Pidl::Samba4; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(is_intree choose_header); + +use Parse::Pidl::Util qw(has_property); +use strict; + +use vars qw($VERSION); +$VERSION = '0.01'; + +sub is_intree() +{ + return -f "include/smb.h"; +} + +# Return an #include line depending on whether this build is an in-tree +# build or not. +sub choose_header($$) +{ + my ($in,$out) = @_; + return "#include \"$in\"" if (is_intree()); + return "#include <$out>"; +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm index 83df9afe88..85dab37246 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm @@ -117,19 +117,22 @@ sub ParseCoClass($) return $res; } -sub Parse($) +sub Parse($$) { - my $idl = shift; + my ($idl,$ndr_header) = @_; my $res = ""; - foreach my $x (@{$idl}) + $res .= "#include \"librpc/gen_ndr/orpc.h\"\n" . + "#include \"$ndr_header\"\n\n"; + + foreach (@{$idl}) { - if ($x->{TYPE} eq "INTERFACE" && has_property($x, "object")) { - $res.=ParseInterface($x); + if ($_->{TYPE} eq "INTERFACE" && has_property($_, "object")) { + $res.=ParseInterface($_); } - if ($x->{TYPE} eq "COCLASS") { - $res.=ParseCoClass($x); + if ($_->{TYPE} eq "COCLASS") { + $res.=ParseCoClass($_); } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm index c0d460fe09..e6366f0f3d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm @@ -196,17 +196,21 @@ sub RegistrationFunction($$) return $res; } -sub Parse($) +sub Parse($$) { - my $pidl = shift; + my ($pidl,$comh_filename) = @_; my $res = ""; - foreach my $x (@{$pidl}) { - next if ($x->{TYPE} ne "INTERFACE"); - next if has_property($x, "local"); - next unless has_property($x, "object"); + $res .= "#include \"includes.h\"\n" . + "#include \"lib/com/dcom/dcom.h\"\n" . + "#include \"$comh_filename\"\n"; - $res .= ParseInterface($x); + foreach (@{$pidl}) { + next if ($_->{TYPE} ne "INTERFACE"); + next if has_property($_, "local"); + next unless has_property($_, "object"); + + $res .= ParseInterface($_); } return $res; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 46caba731a..54e410f716 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -10,6 +10,7 @@ use strict; use Parse::Pidl::Typelist qw(mapType); use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); +use Parse::Pidl::Samba4 qw(is_intree); use vars qw($VERSION); $VERSION = '0.01'; @@ -349,6 +350,10 @@ sub Parse($) $res = ""; %headerstructs = (); pidl "/* header auto-generated by pidl */\n\n"; + if (!is_intree()) { + pidl "#include "; + } + foreach (@{$idl}) { ($_->{TYPE} eq "INTERFACE") && HeaderInterface($_); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 972368195b..f4672e93e9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -11,6 +11,7 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); use Parse::Pidl::Util qw(has_property ParseExpr print_uuid); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::Samba4 qw(is_intree choose_header); use vars qw($VERSION); $VERSION = '0.01'; @@ -2237,16 +2238,16 @@ sub HeaderInterface($) my $count = 0; - pidl_hdr "#include \"librpc/ndr/libndr.h\""; + pidl_hdr choose_header("librpc/ndr/libndr.h", "ndr.h"); if (has_property($interface, "object")) { - pidl "#include \"librpc/gen_ndr/ndr_orpc.h\""; + pidl choose_header("librpc/gen_ndr/ndr_orpc.h", "ndr/orpc.h"); } if (defined $interface->{PROPERTIES}->{depends}) { my @d = split / /, $interface->{PROPERTIES}->{depends}; foreach my $i (@d) { - pidl "#include \"librpc/gen_ndr/ndr_$i\.h\""; + pidl choose_header("librpc/gen_ndr/ndr_$i\.h", "gen_ndr/ndr_$i.h"); } } @@ -2311,7 +2312,7 @@ sub ParseInterface($$) pidl_hdr ""; if ($needed->{"compression"}) { - pidl "#include \"librpc/ndr/ndr_compression.h\""; + pidl choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h"); } HeaderInterface($interface); @@ -2347,9 +2348,9 @@ sub ParseInterface($$) ##################################################################### # parse a parsed IDL structure back into an IDL file -sub Parse($$) +sub Parse($$$) { - my($ndr,$basename) = @_; + my($ndr,$gen_header,$ndr_header) = @_; $tabs = ""; $res = ""; @@ -2357,9 +2358,27 @@ sub Parse($$) $res_hdr = ""; pidl_hdr "/* header auto-generated by pidl */"; pidl_hdr ""; + pidl_hdr "#include \"$gen_header\""; + pidl_hdr ""; pidl "/* parser auto-generated by pidl */"; pidl ""; + if (is_intree()) { + pidl "#include \"includes.h\""; + } else { + pidl "#define _GNU_SOURCE"; + pidl "#include "; + pidl "#include "; + pidl "#include "; + pidl "#include "; + pidl "#include "; + } + pidl choose_header("libcli/util/nterr.h", "core/nterr.h"); + pidl choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h"); + pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h"); + pidl "#include \"$ndr_header\""; + pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here! + pidl ""; my %needed = (); -- cgit From 4469fa31e3e3b2d62da7686fd6426bb44be09830 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 16 Mar 2006 21:35:31 +0000 Subject: r14491: Allow building more output outside of the Samba source tree (This used to be commit 272ca8e636cc5043279ff247fc8d5693a9181992) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 15 +++++++++++++-- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 14 ++++++++++++-- 3 files changed, 26 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 54e410f716..e082a74fc4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -351,7 +351,7 @@ sub Parse($) %headerstructs = (); pidl "/* header auto-generated by pidl */\n\n"; if (!is_intree()) { - pidl "#include "; + pidl "#include \n\n"; } foreach (@{$idl}) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index d52dc12ec3..f19f4df319 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -5,6 +5,8 @@ package Parse::Pidl::Samba4::NDR::Client; +use Parse::Pidl::Samba4 qw(choose_header is_intree); + use vars qw($VERSION); $VERSION = '0.01'; @@ -97,12 +99,21 @@ sub Parse($$$$) $res .= "/* client functions auto-generated by pidl */\n"; $res .= "\n"; - $res .= "#include \"includes.h\"\n"; + if (is_intree()) { + $res .= "#include \"includes.h\"\n"; + } else { + $res .= "#define _GNU_SOURCE\n"; + $res .= "#include \n"; + $res .= "#include \n"; + $res .= "#include \n"; + $res .= "#include \n"; + $res .= "#include \n"; + } $res .= "#include \"$ndr_header\"\n"; $res .= "#include \"$client_header\"\n"; $res .= "\n"; - $res_hdr .= "#include \"librpc/rpc/dcerpc.h\"\n"; + $res_hdr .= choose_header("librpc/rpc/dcerpc.h", "dcerpc.h")."\n"; $res_hdr .= "#include \"$header\"\n"; foreach my $x (@{$ndr}) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index 3bdb701526..7e597dfb34 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -5,6 +5,7 @@ package Parse::Pidl::Samba4::TDR; use Parse::Pidl::Util qw(has_property ParseExpr is_constant); +use Parse::Pidl::Samba4 qw(is_intree choose_header); use vars qw($VERSION); $VERSION = '0.01'; @@ -237,12 +238,21 @@ sub Parser($$$) my ($idl,$hdrname,$baseheader) = @_; $ret = ""; $ret_hdr = ""; pidl "/* autogenerated by pidl */"; - pidl "#include \"includes.h\""; + if (is_intree()) { + pidl "#include \"includes.h\""; + } else { + pidl "#include "; + pidl "#include "; + pidl "#include "; + pidl "#include "; + pidl "#include "; + pidl "#include "; + } pidl "#include \"$hdrname\""; pidl ""; pidl_hdr "/* autogenerated by pidl */"; pidl_hdr "#include \"$baseheader\""; - pidl_hdr "#include \"tdr/tdr.h\""; + pidl_hdr choose_header("tdr/tdr.h", "tdr.h"); pidl_hdr ""; foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } -- cgit From 35349a58df5b69446607fbd742a05f57f3515319 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 18 Mar 2006 15:42:57 +0000 Subject: r14542: Remove librpc, libndr and libnbt from includes.h (This used to be commit 51b4270513752d2eafbe77f9de598de16ef84a1f) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index d5e1405c30..e24fb54b96 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -797,6 +797,7 @@ sub Parse($$) pidl " /* EJS wrapper functions auto-generated by pidl */ #include \"includes.h\" +#include \"librpc/rpc/dcerpc.h\" #include \"lib/appweb/ejs/ejs.h\" #include \"scripting/ejs/ejsrpc.h\" #include \"scripting/ejs/smbcalls.h\" -- cgit From fb67b0d99a2744272767d88f48416154d7150443 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 18 Mar 2006 22:16:24 +0000 Subject: r14550: Fix tests (This used to be commit 765fd852e789371f6b6361acd7603f8056ac14a9) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index f4672e93e9..e7f8c85a90 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2358,7 +2358,7 @@ sub Parse($$$) $res_hdr = ""; pidl_hdr "/* header auto-generated by pidl */"; pidl_hdr ""; - pidl_hdr "#include \"$gen_header\""; + pidl_hdr "#include \"$gen_header\"" if ($gen_header); pidl_hdr ""; pidl "/* parser auto-generated by pidl */"; @@ -2376,7 +2376,7 @@ sub Parse($$$) pidl choose_header("libcli/util/nterr.h", "core/nterr.h"); pidl choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h"); pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h"); - pidl "#include \"$ndr_header\""; + pidl "#include \"$ndr_header\"" if ($ndr_header); pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here! pidl ""; -- cgit From 508f2f5506a14814888718bf00f52b7788d0e9ea Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 20 Mar 2006 23:35:08 +0000 Subject: r14594: Fix some dependencies (required for shared library build) (This used to be commit 06f7a8c692a645830eb3dd9abad8556c66bba747) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index e24fb54b96..41ea1e8eaa 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -124,7 +124,7 @@ sub fn_declare($$) if (has_property($fn, "public")) { pidl_hdr "$decl;\n"; - pidl "$decl"; + pidl "_PUBLIC_ $decl"; } else { pidl "static $decl"; } -- cgit From 3c7df1118c5bc42a323bb28ac893706dd64043d0 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 22 Mar 2006 20:01:15 +0000 Subject: r14658: Include ndr_obfuscate.h when necessary (This used to be commit 3647bd31244c9a44a4fae8a20a3176b85f4a0b3d) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index e7f8c85a90..bc7e4ce545 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2314,6 +2314,10 @@ sub ParseInterface($$) if ($needed->{"compression"}) { pidl choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h"); } + + if ($needed->{"obfuscate"}) { + pidl "#include \"ndr_obfuscate.h\""; + } HeaderInterface($interface); @@ -2432,6 +2436,9 @@ sub NeededTypedef($$) if (has_property($e, "compression")) { $needed->{"compression"} = 1; } + if (has_property($e, "obfuscation")) { + $needed->{"obfuscate"} = 1; + } if ($needed->{"pull_$t->{NAME}"} and not defined($needed->{"pull_$e->{TYPE}"})) { $needed->{"pull_$e->{TYPE}"} = 1; -- cgit From 311d6f47c85282925932b3a7326e66679be9451f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 23 Mar 2006 21:47:16 +0000 Subject: r14686: Fix pidl testsuite to run whenever there is a shared libary built Samba present. Ignore tests that are known to fail for now. (This used to be commit a7279f13f0431a5036c931c5339542f98139c461) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index b1aec5cc5d..a709abba10 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -317,8 +317,10 @@ sub find_largest_alignment($) if ($e->{POINTERS}) { $a = 4; - } elsif (has_property($e, "subcontext")){ + } elsif (has_property($e, "subcontext")) { $a = 1; + } elsif (has_property($e, "represent_as")) { + $a = align_type($e->{PROPERTIES}->{represent_as}); } else { $a = align_type($e->{TYPE}); } @@ -793,6 +795,8 @@ my %property_list = ( "case" => ["ELEMENT"], "default" => ["ELEMENT"], + "represent_as" => ["ELEMENT"], + # subcontext "subcontext" => ["ELEMENT"], "subcontext_size" => ["ELEMENT"], -- cgit From b6cae24de839756db87a62213795856c0051b8b9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 24 Mar 2006 01:03:02 +0000 Subject: r14687: Start working on support for represent_as() and transmit_as() as an alternative to subcontext() (This used to be commit 744402160d5f994f5440553bb726e95a13033a83) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 23 ++++++++++++++++++++--- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 1 + source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 15 ++++++++++++++- 3 files changed, 35 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index a709abba10..1d5059bfb5 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -2,7 +2,7 @@ # Samba4 NDR info tree generator # Copyright tridge@samba.org 2000-2003 # Copyright tpot@samba.org 2001 -# Copyright jelmer@samba.org 2004-2005 +# Copyright jelmer@samba.org 2004-2006 # released under the GNU GPL =pod @@ -258,6 +258,8 @@ sub GetElementLevelTable($) push (@$order, { TYPE => "DATA", + CONVERT_TO => has_property($e, ""), + CONVERT_FROM => has_property($e, ""), DATA_TYPE => $e->{TYPE}, IS_DEFERRED => $is_deferred, CONTAINS_DEFERRED => can_contain_deferred($e), @@ -319,8 +321,8 @@ sub find_largest_alignment($) $a = 4; } elsif (has_property($e, "subcontext")) { $a = 1; - } elsif (has_property($e, "represent_as")) { - $a = align_type($e->{PROPERTIES}->{represent_as}); + } elsif (has_property($e, "transmit_as")) { + $a = align_type($e->{PROPERTIES}->{transmit_as}); } else { $a = align_type($e->{TYPE}); } @@ -368,6 +370,7 @@ sub ParseElement($) TYPE => $e->{TYPE}, PROPERTIES => $e->{PROPERTIES}, LEVELS => GetElementLevelTable($e), + REPRESENTATION_TYPE => $e->{PROPERTIES}->{represent_as}, ALIGN => align_type($e->{TYPE}), ORIGINAL => $e }; @@ -796,6 +799,7 @@ my %property_list = ( "default" => ["ELEMENT"], "represent_as" => ["ELEMENT"], + "transmit_as" => ["ELEMENT"], # subcontext "subcontext" => ["ELEMENT"], @@ -900,6 +904,19 @@ sub ValidElement($) } } + + if (has_property($e, "subcontext") and has_property($e, "represent_as")) { + fatal($e, el_name($e) . " : subcontext() and represent_as() can not be used on the same element"); + } + + if (has_property($e, "subcontext") and has_property($e, "transmit_as")) { + fatal($e, el_name($e) . " : subcontext() and transmit_as() can not be used on the same element"); + } + + if (has_property($e, "represent_as") and has_property($e, "transmit_as")) { + fatal($e, el_name($e) . " : represent_as() and transmit_as() can not be used on the same element"); + } + if (defined (has_property($e, "subcontext_size")) and not defined(has_property($e, "subcontext"))) { fatal($e, el_name($e) . " : subcontext_size() on non-subcontext element"); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index f19f4df319..ace1e79672 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -1,6 +1,7 @@ ################################################### # client calls generator # Copyright tridge@samba.org 2003 +# Copyright jelmer@samba.org 2005-2006 # released under the GNU GPL package Parse::Pidl::Samba4::NDR::Client; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index bc7e4ce545..81e30e1053 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2,7 +2,7 @@ # Samba4 NDR parser generator for IDL structures # Copyright tridge@samba.org 2000-2003 # Copyright tpot@samba.org 2001 -# Copyright jelmer@samba.org 2004-2005 +# Copyright jelmer@samba.org 2004-2006 # released under the GNU GPL package Parse::Pidl::Samba4::NDR::Parser; @@ -674,6 +674,12 @@ sub ParseElementPush($$$$$$) return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); + # Representation type is different from transmit_as + if ($e->{REPRESENTATION_TYPE}) { + pidl "/* FIXME: Convert from $e->{REPRESENTATION_TYPE} to $e->{TYPE} */"; + pidl "NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}(FIXME, FIXME));"; + } + start_flags($e); if (my $value = has_property($e, "value")) { @@ -683,6 +689,7 @@ sub ParseElementPush($$$$$$) ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred); end_flags($e); + } ##################################################################### @@ -1067,6 +1074,12 @@ sub ParseElementPull($$$$$$) ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred); end_flags($e); + + # Representation type is different from transmit_as + if ($e->{REPRESENTATION_TYPE}) { + pidl "/* FIXME: Convert from $e->{TYPE} to $e->{REPRESENTATION_TYPE} */"; + pidl "NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}(FIXME, FIXME));"; + } } ##################################################################### -- cgit From 85e91438b119f91cc0eb7da0992fadd5d2e47332 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 24 Mar 2006 11:42:03 +0000 Subject: r14688: More work on represent_as(): output the right function calls, fix test. (This used to be commit 7bc72277b37f9d89f6a078e85c14d560fd33a3bb) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 30 +++++++++++++++++++----- 1 file changed, 24 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 81e30e1053..feab825a3f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -676,8 +676,12 @@ sub ParseElementPush($$$$$$) # Representation type is different from transmit_as if ($e->{REPRESENTATION_TYPE}) { - pidl "/* FIXME: Convert from $e->{REPRESENTATION_TYPE} to $e->{TYPE} */"; - pidl "NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}(FIXME, FIXME));"; + pidl "{"; + indent; + my $transmit_name = "_transmit_$e->{NAME}"; + pidl mapType($e->{TYPE}) ." $transmit_name;"; + pidl "NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}($var_name, $transmit_name));"; + $var_name = $transmit_name; } start_flags($e); @@ -690,6 +694,10 @@ sub ParseElementPush($$$$$$) end_flags($e); + if ($e->{REPRESENTATION_TYPE}) { + deindent; + pidl "}"; + } } ##################################################################### @@ -1064,11 +1072,20 @@ sub ParseElementPull($$$$$$) my($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_; my $var_name = $var_prefix.$e->{NAME}; - - $var_name = append_prefix($e, $var_name); + my $represent_name; return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); + if ($e->{REPRESENTATION_TYPE}) { + pidl "{"; + indent; + $represent_name = $var_name; + $var_name = "_transmit_$e->{NAME}"; + pidl mapType($e->{TYPE})." $var_name;"; + } + + $var_name = append_prefix($e, $var_name); + start_flags($e); ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred); @@ -1077,8 +1094,9 @@ sub ParseElementPull($$$$$$) # Representation type is different from transmit_as if ($e->{REPRESENTATION_TYPE}) { - pidl "/* FIXME: Convert from $e->{TYPE} to $e->{REPRESENTATION_TYPE} */"; - pidl "NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}(FIXME, FIXME));"; + pidl "NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}($var_name, $represent_name));"; + deindent; + pidl "}"; } } -- cgit From 5d9ea9170d2e0fd816285bd460de05f800ce26e8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 24 Mar 2006 12:40:07 +0000 Subject: r14690: Support represent_as in headers, enable represent_as() test (which works now) (This used to be commit 31e847a0844a6871befc6091e813ae017cd6e4b4) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 38 +++++++++++++----------- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 12 ++++---- 2 files changed, 27 insertions(+), 23 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index e082a74fc4..6fb3ee2eec 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -55,19 +55,23 @@ sub HeaderElement($) my($element) = shift; pidl tabs(); - HeaderType($element, $element->{TYPE}, ""); - pidl " "; - my $numstar = $element->{POINTERS}; - if ($numstar >= 1) { - $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); - } - foreach (@{$element->{ARRAY_LEN}}) - { - next if is_constant($_) and - not has_property($element, "charset"); - $numstar++; + if (has_property($element, "represent_as")) { + pidl mapType($element->{PROPERTIES}->{represent_as})." "; + } else { + HeaderType($element, $element->{TYPE}, ""); + pidl " "; + my $numstar = $element->{POINTERS}; + if ($numstar >= 1) { + $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); + } + foreach (@{$element->{ARRAY_LEN}}) + { + next if is_constant($_) and + not has_property($element, "charset"); + $numstar++; + } + pidl "*" foreach (1..$numstar); } - pidl "*" foreach (1..$numstar); pidl $element->{NAME}; foreach (@{$element->{ARRAY_LEN}}) { next unless (is_constant($_) and @@ -91,8 +95,8 @@ sub HeaderStruct($$) $tab_depth++; my $el_count=0; if (defined $struct->{ELEMENTS}) { - foreach my $e (@{$struct->{ELEMENTS}}) { - HeaderElement($e); + foreach (@{$struct->{ELEMENTS}}) { + HeaderElement($_); $el_count++; } } @@ -237,10 +241,8 @@ sub HeaderFunctionInOut($$) { my($fn,$prop) = @_; - foreach my $e (@{$fn->{ELEMENTS}}) { - if (has_property($e, $prop)) { - HeaderElement($e); - } + foreach (@{$fn->{ELEMENTS}}) { + HeaderElement($_) if (has_property($_, $prop)); } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index feab825a3f..d9666a20fe 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -670,8 +670,6 @@ sub ParseElementPush($$$$$$) my $var_name = $var_prefix.$e->{NAME}; - $var_name = append_prefix($e, $var_name); - return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); # Representation type is different from transmit_as @@ -680,10 +678,12 @@ sub ParseElementPush($$$$$$) indent; my $transmit_name = "_transmit_$e->{NAME}"; pidl mapType($e->{TYPE}) ." $transmit_name;"; - pidl "NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}($var_name, $transmit_name));"; + pidl "NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}($var_name, " . get_pointer_to($transmit_name) . "));"; $var_name = $transmit_name; } + $var_name = append_prefix($e, $var_name); + start_flags($e); if (my $value = has_property($e, "value")) { @@ -1073,6 +1073,7 @@ sub ParseElementPull($$$$$$) my $var_name = $var_prefix.$e->{NAME}; my $represent_name; + my $transmit_name; return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); @@ -1080,7 +1081,8 @@ sub ParseElementPull($$$$$$) pidl "{"; indent; $represent_name = $var_name; - $var_name = "_transmit_$e->{NAME}"; + $transmit_name = "_transmit_$e->{NAME}"; + $var_name = $transmit_name; pidl mapType($e->{TYPE})." $var_name;"; } @@ -1094,7 +1096,7 @@ sub ParseElementPull($$$$$$) # Representation type is different from transmit_as if ($e->{REPRESENTATION_TYPE}) { - pidl "NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}($var_name, $represent_name));"; + pidl "NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}($transmit_name, ".get_pointer_to($represent_name)."));"; deindent; pidl "}"; } -- cgit From 8973ac8a393f9df64ea37de79397161815e1ce2c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 24 Mar 2006 14:13:02 +0000 Subject: r14691: Fix printing elements with represent_as set (This used to be commit f4428db2f922e921c54cdb0849eaad5018cb5a01) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 4 ++++ source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 17 ++++++++++------- 2 files changed, 14 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 1d5059bfb5..c8a9717889 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -917,6 +917,10 @@ sub ValidElement($) fatal($e, el_name($e) . " : represent_as() and transmit_as() can not be used on the same element"); } + if (has_property($e, "represent_as") and has_property($e, "value")) { + fatal($e, el_name($e) . " : represent_as() and value() can not be used on the same element"); + } + if (defined (has_property($e, "subcontext_size")) and not defined(has_property($e, "subcontext"))) { fatal($e, el_name($e) . " : subcontext_size() on non-subcontext element"); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index d9666a20fe..e3058665f2 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -729,9 +729,15 @@ sub ParseElementPrint($$$) { my($e,$var_name,$env) = @_; - $var_name = append_prefix($e, $var_name); return if (has_property($e, "noprint")); + if ($e->{REPRESENTATION_TYPE}) { + pidl "ndr_print_$e->{REPRESENTATION_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; + return; + } + + $var_name = append_prefix($e, $var_name); + if (my $value = has_property($e, "value")) { $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env) . ":$var_name"; } @@ -1411,18 +1417,15 @@ sub ParseStructPrint($$) EnvSubstituteValue($env, $struct); - foreach my $e (@{$struct->{ELEMENTS}}) { - DeclareArrayVariables($e); - } + DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}}); pidl "ndr_print_struct(ndr, name, \"$name\");"; start_flags($struct); pidl "ndr->depth++;"; - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPrint($e, "r->$e->{NAME}", $env); - } + + ParseElementPrint($_, "r->$_->{NAME}", $env) foreach (@{$struct->{ELEMENTS}}); pidl "ndr->depth--;"; end_flags($struct); -- cgit From 76ab42061529f026f3cade4ab2b2779dd676a61a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 24 Mar 2006 14:22:33 +0000 Subject: r14692: Get rid of the obfuscation() attribute (This used to be commit 122d1d0249800d51e45ce0d092c97f1f9bf2c7d5) --- source4/pidl/lib/Parse/Pidl/Compat.pm | 4 -- source4/pidl/lib/Parse/Pidl/NDR.pm | 6 --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 59 ------------------------ 3 files changed, 69 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Compat.pm b/source4/pidl/lib/Parse/Pidl/Compat.pm index f0b8cc7b0b..944193ac1b 100644 --- a/source4/pidl/lib/Parse/Pidl/Compat.pm +++ b/source4/pidl/lib/Parse/Pidl/Compat.pm @@ -124,10 +124,6 @@ sub CheckElement($) warning($e, "compression() property not supported"); } - if (has_property($e, "obfuscation")) { - warning($e, "obfuscation() property not supported"); - } - if (has_property($e, "sptr")) { warning($e, "sptr() pointer property not supported"); } diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index c8a9717889..1efd0694e5 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -232,7 +232,6 @@ sub GetElementLevelTable($) SUBCONTEXT_SIZE => $subsize, IS_DEFERRED => $is_deferred, COMPRESSION => has_property($e, "compression"), - OBFUSCATION => has_property($e, "obfuscation") }); } @@ -805,7 +804,6 @@ my %property_list = ( "subcontext" => ["ELEMENT"], "subcontext_size" => ["ELEMENT"], "compression" => ["ELEMENT"], - "obfuscation" => ["ELEMENT"], # enum "enum8bit" => ["TYPEDEF"], @@ -929,10 +927,6 @@ sub ValidElement($) fatal($e, el_name($e) . " : compression() on non-subcontext element"); } - if (defined (has_property($e, "obfuscation")) and not defined(has_property($e, "subcontext"))) { - fatal($e, el_name($e) . " : obfuscation() on non-subcontext element"); - } - if (!$e->{POINTERS} && ( has_property($e, "ptr") or has_property($e, "sptr") or diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index e3058665f2..f29518d21f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -464,42 +464,6 @@ sub ParseCompressionPullEnd($$$$) pidl "}"; } -sub ParseObfuscationPushStart($$) -{ - my ($e,$ndr) = @_; - my $obfuscation = has_property($e, "obfuscation"); - - pidl "NDR_CHECK(ndr_push_obfuscation_start($ndr, $obfuscation));"; - - return $ndr; -} - -sub ParseObfuscationPushEnd($$) -{ - my ($e,$ndr) = @_; - my $obfuscation = has_property($e, "obfuscation"); - - pidl "NDR_CHECK(ndr_push_obfuscation_end($ndr, $obfuscation));"; -} - -sub ParseObfuscationPullStart($$) -{ - my ($e,$ndr) = @_; - my $obfuscation = has_property($e, "obfuscation"); - - pidl "NDR_CHECK(ndr_pull_obfuscation_start($ndr, $obfuscation));"; - - return $ndr; -} - -sub ParseObfuscationPullEnd($$) -{ - my ($e,$ndr) = @_; - my $obfuscation = has_property($e, "obfuscation"); - - pidl "NDR_CHECK(ndr_pull_obfuscation_end($ndr, $obfuscation));"; -} - sub ParseSubcontextPushStart($$$$) { my ($e,$l,$ndr,$env) = @_; @@ -515,10 +479,6 @@ sub ParseSubcontextPushStart($$$$) $subndr = ParseCompressionPushStart($e, $l, $subndr, $env); } - if (defined $l->{OBFUSCATION}) { - $subndr = ParseObfuscationPushStart($e, $subndr); - } - return $subndr; } @@ -532,10 +492,6 @@ sub ParseSubcontextPushEnd($$$$) ParseCompressionPushEnd($e, $l, $subndr, $env); } - if (defined $l->{OBFUSCATION}) { - ParseObfuscationPushEnd($e, $subndr); - } - pidl "NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; deindent; pidl "}"; @@ -556,10 +512,6 @@ sub ParseSubcontextPullStart($$$$) $subndr = ParseCompressionPullStart($e, $l, $subndr, $env); } - if (defined $l->{OBFUSCATION}) { - $subndr = ParseObfuscationPullStart($e, $subndr); - } - return $subndr; } @@ -573,10 +525,6 @@ sub ParseSubcontextPullEnd($$$$) ParseCompressionPullEnd($e, $l, $subndr, $env); } - if (defined $l->{OBFUSCATION}) { - ParseObfuscationPullEnd($e, $subndr); - } - pidl "NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; deindent; pidl "}"; @@ -2351,10 +2299,6 @@ sub ParseInterface($$) pidl choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h"); } - if ($needed->{"obfuscate"}) { - pidl "#include \"ndr_obfuscate.h\""; - } - HeaderInterface($interface); # Typedefs @@ -2472,9 +2416,6 @@ sub NeededTypedef($$) if (has_property($e, "compression")) { $needed->{"compression"} = 1; } - if (has_property($e, "obfuscation")) { - $needed->{"obfuscate"} = 1; - } if ($needed->{"pull_$t->{NAME}"} and not defined($needed->{"pull_$e->{TYPE}"})) { $needed->{"pull_$e->{TYPE}"} = 1; -- cgit From 42da534d66c14c60844568246a2862da7b49f1d5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 26 Mar 2006 00:59:17 +0000 Subject: r14735: Use dcerpc_syntax_id rather then seperate GUID + if_version everywhere (This used to be commit a316b33057f3ec8532677980e093cd327d33f257) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 6 ++++-- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 7 +++---- 2 files changed, 7 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index f29518d21f..07128568bd 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2200,8 +2200,10 @@ sub FunctionTable($) pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {"; pidl "\t.name\t\t= \"$interface->{NAME}\","; - pidl "\t.uuid\t\t= ". print_uuid($interface->{UUID}) .","; - pidl "\t.if_version\t= DCERPC_$uname\_VERSION,"; + pidl "\t.syntax_id\t= {"; + pidl "\t\t" . print_uuid($interface->{UUID}) .","; + pidl "\t\tDCERPC_$uname\_VERSION"; + pidl "\t},"; pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,"; pidl "\t.num_calls\t= $count,"; pidl "\t.calls\t\t= $interface->{NAME}\_calls,"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index fd6d303330..c35310785a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -188,8 +188,7 @@ static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_C static const struct dcesrv_interface $name\_interface = { .name = \"$name\", - .uuid = ".print_uuid($uuid).", - .if_version = $if_version, + .syntax_id = {".print_uuid($uuid).",$if_version}, .bind = $name\__op_bind, .unbind = $name\__op_unbind, .ndr_pull = $name\__op_ndr_pull, @@ -230,8 +229,8 @@ static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const str static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version) { - if ($name\_interface.if_version == if_version && - GUID_equal(\&$name\_interface.uuid, uuid)) { + if ($name\_interface.syntax_id.if_version == if_version && + GUID_equal(\&$name\_interface.syntax_id.uuid, uuid)) { memcpy(iface,&$name\_interface, sizeof(*iface)); return True; } -- cgit From 1b22141c874ff704ad4fe048d4464168495c36b6 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 2 Apr 2006 16:26:02 +0000 Subject: r14867: Include in external compiles (This used to be commit 03224dab111b931effd548586e630480fa1423b1) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 1 + source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 1 + source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 1 + 3 files changed, 3 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index ace1e79672..3b12c8f173 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -105,6 +105,7 @@ sub Parse($$$$) } else { $res .= "#define _GNU_SOURCE\n"; $res .= "#include \n"; + $res .= "#include \n"; $res .= "#include \n"; $res .= "#include \n"; $res .= "#include \n"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 07128568bd..38e3268356 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2356,6 +2356,7 @@ sub Parse($$$) pidl "#include "; pidl "#include "; pidl "#include "; + pidl "#include "; pidl "#include "; pidl "#include "; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index 7e597dfb34..592961dee2 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -242,6 +242,7 @@ sub Parser($$$) pidl "#include \"includes.h\""; } else { pidl "#include "; + pidl "#include "; pidl "#include "; pidl "#include "; pidl "#include "; -- cgit From a0f8ff3cbdbfe475496d210e3d25ecb5bc35fdf3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 24 Apr 2006 14:41:13 +0000 Subject: r15202: Don't derefence NULL pointers - found by the IBM Checker (This used to be commit f6a3e8b69d2a303e7e4f8924e6735c4e168a363a) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 41ea1e8eaa..91938c038e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -450,7 +450,11 @@ sub EjsPushPointer($$$$$) my ($e, $l, $var, $name, $env) = @_; pidl "if (NULL == $var) {"; indent; - pidl "NDR_CHECK(ejs_push_null(ejs, v, $name));"; + if ($l->{POINTER_TYPE} eq "ref") { + pidl "return NT_STATUS_INVALID_PARAMETER_MIX;"; + } else { + pidl "NDR_CHECK(ejs_push_null(ejs, v, $name));"; + } deindent; pidl "} else {"; indent; -- cgit From ddbd7bed65fbe404c171c58aef6f2f28c05f186d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 24 Apr 2006 18:18:20 +0000 Subject: r15220: Another attempt to fix the bug found by the IBM Checker (This used to be commit 9f79bfc05d456c106cca44ee459eb542273c3a0c) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 91938c038e..550499a5f3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -154,7 +154,11 @@ sub EjsPullPointer($$$$$) my ($e, $l, $var, $name, $env) = @_; pidl "if (ejs_pull_null(ejs, v, $name)) {"; indent; - pidl "$var = NULL;"; + if ($l->{POINTER_TYPE} eq "ref") { + pidl "return NT_STATUS_INVALID_PARAMETER_MIX;"; + } else { + pidl "$var = NULL;"; + } deindent; pidl "} else {"; indent; -- cgit From 0263ec1c894c46a479b472d65dc5f3ce48c57673 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 26 Apr 2006 00:08:39 +0000 Subject: r15260: Don't dereference NULL pointers to obtain array lengths - found by the IBM checker (This used to be commit a492cd4bd49b6922d91d4ce5f1247bad0d0d6a7e) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 14 ++++++++++++++ 1 file changed, 14 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 550499a5f3..b9d8a1251c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -116,6 +116,18 @@ sub get_value_of($) } } +##################################################################### +# check that a variable we get from ParseExpr isn't a null pointer +sub check_null_pointer($) +{ + my $size = shift; + if ($size =~ /^\*/) { + my $size2 = substr($size, 1); + pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; + } +} + + ##################################################################### # work out is a parse function should be declared static or not sub fn_declare($$) @@ -196,6 +208,7 @@ sub EjsPullArray($$$$$) if (!$l->{IS_FIXED}) { pidl "EJS_ALLOC_N(ejs, $var, $size);"; } + check_null_pointer($length); pidl "ejs_pull_array_uint8(ejs, v, $name, $var, $length);"; return; } @@ -492,6 +505,7 @@ sub EjsPushArray($$$$$) } # uint8 arrays are treated as data blobs if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { + check_null_pointer($length); pidl "ejs_push_array_uint8(ejs, v, $name, $var, $length);"; return; } -- cgit From fc487fb552f38ae41c6a406f0b1cad0c84aa0c2d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 29 Apr 2006 14:51:26 +0000 Subject: r15324: Generate prototype even if the function itself is written manually. (This used to be commit 56eceeb3221b768b754f6eca10d020148264e869) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 38e3268356..4d40699435 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -194,13 +194,13 @@ sub check_null_pointer_void($) ##################################################################### # declare a function public or static, depending on its attributes -sub fn_declare($$) +sub fn_declare($$$) { - my ($fn,$decl) = @_; + my ($type,$fn,$decl) = @_; - if (has_property($fn, "public")) { + if (has_property($fn, "no$type") or has_property($fn, "public")) { pidl_hdr "$decl;"; - pidl "_PUBLIC_ $decl"; + pidl "_PUBLIC_ $decl" unless (has_property($fn, "no$type")); } else { pidl "static $decl"; } @@ -1814,7 +1814,7 @@ sub ParseTypedefPush($) my($e) = shift; my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push"); - fn_declare($e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)"); + fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)"); pidl "{"; indent; @@ -1833,7 +1833,7 @@ sub ParseTypedefPull($) my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull"); - fn_declare($e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)"); + fn_declare("pull", $e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)"); pidl "{"; indent; @@ -1871,7 +1871,7 @@ sub ParseTypedefNdrSize($) my $tf = $typefamily{$t->{DATA}->{TYPE}}; my $args = $tf->{SIZE_FN_ARGS}->($t); - fn_declare($t, "size_t ndr_size_$t->{NAME}($args)"); + fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)"); pidl "{"; indent; @@ -1952,9 +1952,9 @@ sub ParseFunctionPush($) { my($fn) = shift; - return if has_property($fn, "nopush"); + fn_declare("push", $fn, "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)"); - fn_declare($fn, "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)"); + return if has_property($fn, "nopush"); pidl "{"; indent; @@ -2032,10 +2032,11 @@ sub ParseFunctionPull($) { my($fn) = shift; + # pull function args + fn_declare("pull", $fn, "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)"); + return if has_property($fn, "nopull"); - # pull function args - fn_declare($fn, "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)"); pidl "{"; indent; -- cgit From 1a4effad3d4c9d69a8aec4a7bb509c4dff309edb Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 29 Apr 2006 17:33:32 +0000 Subject: r15327: Support 'nosize'. Also write prototypes for print and size functions that are manually written. (This used to be commit f10b38b824d0ddfdccea498b7522efcc03a020d0) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 1 + source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 37 +++++++++++++++--------- 2 files changed, 24 insertions(+), 14 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 1efd0694e5..a4008a1545 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -787,6 +787,7 @@ my %property_list = ( "public" => ["FUNCTION", "TYPEDEF"], "nopush" => ["FUNCTION", "TYPEDEF"], "nopull" => ["FUNCTION", "TYPEDEF"], + "nosize" => ["FUNCTION", "TYPEDEF"], "noprint" => ["FUNCTION", "TYPEDEF"], "noejs" => ["FUNCTION", "TYPEDEF"], diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 4d40699435..b7ae526e68 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -198,12 +198,19 @@ sub fn_declare($$$) { my ($type,$fn,$decl) = @_; - if (has_property($fn, "no$type") or has_property($fn, "public")) { + if (has_property($fn, "no$type")) { pidl_hdr "$decl;"; - pidl "_PUBLIC_ $decl" unless (has_property($fn, "no$type")); + return 0; + } + + if (has_property($fn, "public")) { + pidl_hdr "$decl;"; + pidl "_PUBLIC_ $decl"; } else { pidl "static $decl"; } + + return 1; } ################################################################### @@ -1814,7 +1821,7 @@ sub ParseTypedefPush($) my($e) = shift; my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push"); - fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)"); + fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)") or return; pidl "{"; indent; @@ -1833,7 +1840,7 @@ sub ParseTypedefPull($) my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull"); - fn_declare("pull", $e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)"); + fn_declare("pull", $e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)") or return; pidl "{"; indent; @@ -1852,8 +1859,11 @@ sub ParseTypedefPrint($) my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print"); - pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; pidl_hdr "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args);"; + + return if (has_property($e, "noprint")); + + pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; pidl "{"; indent; $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME}); @@ -1871,7 +1881,7 @@ sub ParseTypedefNdrSize($) my $tf = $typefamily{$t->{DATA}->{TYPE}}; my $args = $tf->{SIZE_FN_ARGS}->($t); - fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)"); + fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)") or return; pidl "{"; indent; @@ -1887,10 +1897,11 @@ sub ParseFunctionPrint($) { my($fn) = shift; + pidl_hdr "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r);"; + return if has_property($fn, "noprint"); pidl "_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; - pidl_hdr "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r);"; pidl "{"; indent; @@ -1952,7 +1963,7 @@ sub ParseFunctionPush($) { my($fn) = shift; - fn_declare("push", $fn, "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)"); + fn_declare("push", $fn, "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)") or return; return if has_property($fn, "nopush"); @@ -2033,9 +2044,7 @@ sub ParseFunctionPull($) my($fn) = shift; # pull function args - fn_declare("pull", $fn, "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)"); - - return if has_property($fn, "nopull"); + fn_declare("pull", $fn, "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)") or return; pidl "{"; indent; @@ -2405,9 +2414,9 @@ sub NeededTypedef($$) { my ($t,$needed) = @_; if (has_property($t, "public")) { - $needed->{"pull_$t->{NAME}"} = not has_property($t, "nopull"); - $needed->{"push_$t->{NAME}"} = not has_property($t, "nopush"); - $needed->{"print_$t->{NAME}"} = not has_property($t, "noprint"); + $needed->{"pull_$t->{NAME}"} = 1; + $needed->{"push_$t->{NAME}"} = 1; + $needed->{"print_$t->{NAME}"} = 1; } if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") { -- cgit From 09ea8a9fd6d6640b72f3d673a5bebf4ef1a9ddfb Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 30 Apr 2006 02:41:50 +0000 Subject: r15353: Don't dereference NULL pointer. Found by the IBM checker. (This used to be commit 67d62fc55621871c576298b5a8da2f5e9ea03d69) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index b9d8a1251c..e1a8feb1cd 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -206,6 +206,7 @@ sub EjsPullArray($$$$$) # uint8 arrays are treated as data blobs if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { if (!$l->{IS_FIXED}) { + check_null_pointer($size); pidl "EJS_ALLOC_N(ejs, $var, $size);"; } check_null_pointer($length); -- cgit From 2a13a7f09fdf273a913b649b2e47962be0fc8138 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 30 Apr 2006 23:11:59 +0000 Subject: r15367: Fix unused function warnings in generated EJS code. (This used to be commit 946a80298ad58e7b8ba9608a840154ee4a790da7) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 56 +++++++++++++++---------------- 1 file changed, 28 insertions(+), 28 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index e1a8feb1cd..218b882323 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -422,15 +422,13 @@ sub EjsPullFunction($) # on the non-array elements foreach my $e (@{$d->{ELEMENTS}}) { next unless (grep(/in/, @{$e->{DIRECTION}})); - next if (has_property($e, "length_is") || - has_property($e, "size_is")); + next if (has_property($e, "length_is") || has_property($e, "size_is")); EjsPullElementTop($e, $env); } foreach my $e (@{$d->{ELEMENTS}}) { next unless (grep(/in/, @{$e->{DIRECTION}})); - next unless (has_property($e, "length_is") || - has_property($e, "size_is")); + next unless (has_property($e, "length_is") || has_property($e, "size_is")); EjsPullElementTop($e, $env); } @@ -760,7 +758,7 @@ sub EjsInterface($$) foreach my $d (@{$interface->{FUNCTIONS}}) { next if not defined($d->{OPNUM}); - next if Parse::Pidl::Util::has_property($d, "noejs"); + next if has_property($d, "noejs"); EjsPullFunction($d); EjsPushFunction($d); @@ -846,14 +844,17 @@ sub Parse($$) sub NeededFunction($$) { my ($fn,$needed) = @_; + $needed->{"pull_$fn->{NAME}"} = 1; $needed->{"push_$fn->{NAME}"} = 1; - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/in/, @{$e->{DIRECTION}})) { - $needed->{"pull_$e->{TYPE}"} = 1; + + foreach (@{$fn->{ELEMENTS}}) { + next if (has_property($_, "subcontext")); #FIXME: Support subcontexts + if (grep(/in/, @{$_->{DIRECTION}})) { + $needed->{"pull_$_->{TYPE}"} = 1; } - if (grep (/out/, @{$e->{DIRECTION}})) { - $needed->{"push_$e->{TYPE}"} = 1; + if (grep(/out/, @{$_->{DIRECTION}})) { + $needed->{"push_$_->{TYPE}"} = 1; } } } @@ -861,20 +862,22 @@ sub NeededFunction($$) sub NeededTypedef($$) { my ($t,$needed) = @_; - if (Parse::Pidl::Util::has_property($t, "public")) { - $needed->{"pull_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs"); - $needed->{"push_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs"); - } - if ($t->{DATA}->{TYPE} ne "STRUCT" && - $t->{DATA}->{TYPE} ne "UNION") { - return; + + if (has_property($t, "public")) { + $needed->{"pull_$t->{NAME}"} = not has_property($t, "noejs"); + $needed->{"push_$t->{NAME}"} = not has_property($t, "noejs"); } - for my $e (@{$t->{DATA}->{ELEMENTS}}) { - if ($needed->{"pull_$t->{NAME}"}) { - $needed->{"pull_$e->{TYPE}"} = 1; + + return if (($t->{DATA}->{TYPE} ne "STRUCT") and + ($t->{DATA}->{TYPE} ne "UNION")); + + foreach (@{$t->{DATA}->{ELEMENTS}}) { + next if (has_property($_, "subcontext")); #FIXME: Support subcontexts + unless (defined($needed->{"pull_$_->{TYPE}"})) { + $needed->{"pull_$_->{TYPE}"} = $needed->{"pull_$t->{NAME}"}; } - if ($needed->{"push_$t->{NAME}"}) { - $needed->{"push_$e->{TYPE}"} = 1; + unless (defined($needed->{"push_$_->{TYPE}"})) { + $needed->{"push_$_->{TYPE}"} = $needed->{"push_$t->{NAME}"}; } } } @@ -884,12 +887,9 @@ sub NeededTypedef($$) sub NeededInterface($$) { my ($interface,$needed) = @_; - foreach my $d (@{$interface->{FUNCTIONS}}) { - NeededFunction($d, $needed); - } - foreach my $d (reverse @{$interface->{TYPES}}) { - NeededTypedef($d, $needed); - } + + NeededFunction($_, $needed) foreach (@{$interface->{FUNCTIONS}}); + NeededTypedef($_, $needed) foreach (reverse @{$interface->{TYPES}}); } 1; -- cgit From e81fd2e11918a775175a91744bced45689343914 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 4 May 2006 16:04:08 +0000 Subject: r15437: Add generator that creates Samba3 client code which uses Samba4's NDR routines. (This used to be commit 538be4a6319b6f8235ed450740784104671ab0b5) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 136 ++++++++++++++++++++++++ 1 file changed, 136 insertions(+) create mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm new file mode 100644 index 0000000000..ec3287ffb0 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -0,0 +1,136 @@ +################################################### +# Samba3 client generator for IDL structures +# on top of Samba4 style NDR functions +# Copyright jelmer@samba.org 2005-2006 +# released under the GNU GPL + +package Parse::Pidl::Samba3::ClientNDR; + +use strict; +use Parse::Pidl::Typelist qw(hasType getType mapType); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::Samba3::Types qw(DeclLong); + +use vars qw($VERSION); +$VERSION = '0.01'; + +my $res = ""; +my $tabs = ""; +sub indent() { $tabs.="\t"; } +sub deindent() { $tabs = substr($tabs, 1); } +sub pidl($) { $res .= $tabs.(shift)."\n"; } +sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } +sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } + +sub CopyLevel($$$$) +{ + sub CopyLevel($$$$); + my ($e,$l,$argument,$member) = @_; + + if ($l->{TYPE} eq "DATA") { + pidl "*$argument = *$member;"; + } elsif ($l->{TYPE} eq "POINTER") { + pidl "if (r.ptr$l->{POINTER_INDEX}_$e->{NAME}) {"; + indent; + pidl "*$argument = talloc_size(mem_ctx, sizeof(void *));"; + CopyLevel($e,GetNextLevel($e,$l),"*$argument", $member); + deindent; + pidl "}"; + } elsif ($l->{TYPE} eq "SWITCH") { + CopyLevel($e,GetNextLevel($e,$l),$argument,$member); + } elsif ($l->{TYPE} eq "ARRAY") { + pidl "*$argument = $member;"; + } +} + +sub ParseFunction($$) +{ + my ($if,$fn) = @_; + + my $inargs = ""; + my $defargs = ""; + my $uif = uc($if->{NAME}); + my $ufn = uc($fn->{NAME}); + + foreach (@{$fn->{ELEMENTS}}) { + $defargs .= ", " . DeclLong($_); + } + pidl "NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"; + pidl "{"; + indent; + pidl "struct $fn->{NAME} r;"; + pidl "NTSTATUS status;"; + pidl ""; + pidl "/* In parameters */"; + + foreach (@{$fn->{ELEMENTS}}) { + if (grep(/in/, @{$_->{DIRECTION}})) { + pidl "r.in.$_->{NAME} = $_->{NAME};"; + } + } + + pidl "status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, $ufn, &r, ndr_pull_$fn->{NAME}, ndr_push_$fn->{NAME});"; + pidl "if (NT_STATUS_IS_ERR(status)) {"; + pidl "\treturn status;"; + pidl "}"; + pidl ""; + pidl "/* Return variables */"; + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/out/, @{$e->{DIRECTION}})); + + if ($e->{LEVELS}[0]->{TYPE} ne "POINTER") { + warning($e, "First element not a pointer for [out] argument"); + next; + } + + CopyLevel($e, $e->{LEVELS}[1], $e->{NAME}, "r.out.$e->{NAME}"); + } + + pidl""; + pidl "/* Return result */"; + if (not $fn->{RETURN_TYPE}) { + pidl "return NT_STATUS_OK;"; + } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { + pidl "return r.status;"; + } elsif ($fn->{RETURN_TYPE} eq "WERROR") { + pidl "return werror_to_ntstatus(r.status);"; + } else { + pidl "/* Sorry, don't know how to convert $fn->{RETURN_TYPE} to NTSTATUS */"; + pidl "return NT_STATUS_OK;"; + } + + deindent; + pidl "}"; + pidl ""; +} + +sub ParseInterface($) +{ + my $if = shift; + + ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); +} + +sub Parse($$) +{ + my($ndr,$filename) = @_; + + $res = ""; + + pidl "/*"; + pidl " * Unix SMB/CIFS implementation."; + pidl " * client auto-generated by pidl. DO NOT MODIFY!"; + pidl " */"; + pidl ""; + pidl "#include \"includes.h\""; + pidl ""; + + foreach (@$ndr) { + ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + } + + return $res; +} + +1; -- cgit From a3f2ed12b9cde474a8d5ec96eb0bd0b6211c45a9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 6 May 2006 11:44:00 +0000 Subject: r15470: Write header file with prototypes for Samba3-Client-With-Samba4-NDR code. (This used to be commit a2bb0b6012b14787825a9cd5f33e2c0e989b65a7) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index ec3287ffb0..92bb440e7c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -15,13 +15,16 @@ use Parse::Pidl::Samba3::Types qw(DeclLong); use vars qw($VERSION); $VERSION = '0.01'; -my $res = ""; +my $res; +my $res_hdr; my $tabs = ""; sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $res .= $tabs.(shift)."\n"; } +sub pidl_hdr($) { $res_hdr .= (shift)."\n"; } sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } +sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } sub CopyLevel($$$$) { @@ -51,12 +54,12 @@ sub ParseFunction($$) my $inargs = ""; my $defargs = ""; my $uif = uc($if->{NAME}); - my $ufn = uc($fn->{NAME}); + my $ufn = "DCERPC_".uc($fn->{NAME}); foreach (@{$fn->{ELEMENTS}}) { $defargs .= ", " . DeclLong($_); } - pidl "NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"; + fn_declare "NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"; pidl "{"; indent; pidl "struct $fn->{NAME} r;"; @@ -79,10 +82,7 @@ sub ParseFunction($$) foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); - if ($e->{LEVELS}[0]->{TYPE} ne "POINTER") { - warning($e, "First element not a pointer for [out] argument"); - next; - } + fatal($e, "[out] argument is not a pointer") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER"); CopyLevel($e, $e->{LEVELS}[1], $e->{NAME}, "r.out.$e->{NAME}"); } @@ -109,7 +109,12 @@ sub ParseInterface($) { my $if = shift; + my $uif = uc($if->{NAME}); + + pidl_hdr "#ifndef __CLI_$uif\__"; + pidl_hdr "#define __CLI_$uif\__"; ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); + pidl_hdr "#endif /* __CLI_$uif\__ */"; } sub Parse($$) @@ -117,6 +122,7 @@ sub Parse($$) my($ndr,$filename) = @_; $res = ""; + $res_hdr = ""; pidl "/*"; pidl " * Unix SMB/CIFS implementation."; @@ -130,7 +136,7 @@ sub Parse($$) ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); } - return $res; + return ($res, $res_hdr); } 1; -- cgit From 55969efea3185a9aaf2ffa86969be9554c84863b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 6 May 2006 16:19:29 +0000 Subject: r15474: Generate proper type declarations, fix headers (This used to be commit 1405f59d5501319c7d08861e19165e012c4bc3a9) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 53 +++++++++++++++++++++---- source4/pidl/lib/Parse/Pidl/Typelist.pm | 2 +- 2 files changed, 46 insertions(+), 9 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 92bb440e7c..eda2ab99d7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -7,10 +7,9 @@ package Parse::Pidl::Samba3::ClientNDR; use strict; -use Parse::Pidl::Typelist qw(hasType getType mapType); -use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); +use Parse::Pidl::Util qw(has_property ParseExpr is_constant); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba3::Types qw(DeclLong); use vars qw($VERSION); $VERSION = '0.01'; @@ -47,6 +46,42 @@ sub CopyLevel($$$$) } } +sub DeclLong($) +{ + my($element) = shift; + my $ret = ""; + + if (has_property($element, "represent_as")) { + $ret.=mapType($element->{PROPERTIES}->{represent_as})." "; + } else { + if (has_property($element, "charset")) { + $ret.="const char"; + } else { + $ret.=mapType($element->{TYPE}); + } + + $ret.=" "; + my $numstar = $element->{ORIGINAL}->{POINTERS}; + if ($numstar >= 1) { + $numstar-- if scalar_is_reference($element->{TYPE}); + } + foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) + { + next if is_constant($_) and + not has_property($element, "charset"); + $numstar++; + } + $ret.="*" foreach (1..$numstar); + } + $ret.=$element->{NAME}; + foreach (@{$element->{ARRAY_LEN}}) { + next unless (is_constant($_) and not has_property($element, "charset")); + $ret.="[$_]"; + } + + return $ret; +} + sub ParseFunction($$) { my ($if,$fn) = @_; @@ -73,7 +108,7 @@ sub ParseFunction($$) } } - pidl "status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, $ufn, &r, ndr_pull_$fn->{NAME}, ndr_push_$fn->{NAME});"; + pidl "status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, $ufn, &r, (ndr_pull_flags_fn_t)ndr_pull_$fn->{NAME}, (ndr_push_flags_fn_t)ndr_push_$fn->{NAME});"; pidl "if (NT_STATUS_IS_ERR(status)) {"; pidl "\treturn status;"; pidl "}"; @@ -92,9 +127,9 @@ sub ParseFunction($$) if (not $fn->{RETURN_TYPE}) { pidl "return NT_STATUS_OK;"; } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { - pidl "return r.status;"; + pidl "return r.out.result;"; } elsif ($fn->{RETURN_TYPE} eq "WERROR") { - pidl "return werror_to_ntstatus(r.status);"; + pidl "return werror_to_ntstatus(r.out.result);"; } else { pidl "/* Sorry, don't know how to convert $fn->{RETURN_TYPE} to NTSTATUS */"; pidl "return NT_STATUS_OK;"; @@ -117,9 +152,9 @@ sub ParseInterface($) pidl_hdr "#endif /* __CLI_$uif\__ */"; } -sub Parse($$) +sub Parse($$$) { - my($ndr,$filename) = @_; + my($ndr,$header,$ndr_header) = @_; $res = ""; $res_hdr = ""; @@ -130,6 +165,8 @@ sub Parse($$) pidl " */"; pidl ""; pidl "#include \"includes.h\""; + pidl "#include \"$header\""; + pidl_hdr "#include \"$ndr_header\""; pidl ""; foreach (@$ndr) { diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index b54badaeb6..016e5f538f 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Typelist; require Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(hasType getType mapType); +@EXPORT_OK = qw(hasType getType mapType scalar_is_reference); use vars qw($VERSION); $VERSION = '0.01'; -- cgit From 664459a41f285c99150b4ea0d79f59334ee94a6c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 13 May 2006 19:15:31 +0000 Subject: r15574: Keep information about which scalar types are references in a separate data structure (This used to be commit 0cb1906046c8e4ad105ad4a47740f94f30f5d6db) --- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 8 +++---- source4/pidl/lib/Parse/Pidl/Typelist.pm | 35 ++++++----------------------- 2 files changed, 11 insertions(+), 32 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 0b81536795..371c35b374 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -180,7 +180,7 @@ sub Bitmap($$$) pidl_code ""; - pidl_code "if(parent_tree) {"; + pidl_code "if (parent_tree) {"; indent; pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);"; pidl_code "tree = proto_item_add_subtree(item,ett_$ifname\_$name);"; @@ -224,7 +224,7 @@ sub Bitmap($$$) pidl_code ""; } - pidl_code "if(flags){"; + pidl_code "if (flags) {"; pidl_code "\tproto_item_append_text(item, \"Unknown bitmap value 0x%x\", flags);"; pidl_code "}\n"; pidl_code "return offset;"; @@ -489,7 +489,7 @@ sub Struct($$$) pidl_code "old_offset = offset;"; pidl_code ""; - pidl_code "if(parent_tree){"; + pidl_code "if (parent_tree) {"; indent; pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);"; pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; @@ -553,7 +553,7 @@ sub Union($$$) pidl_code ""; pidl_code "old_offset = offset;"; - pidl_code "if(parent_tree){"; + pidl_code "if (parent_tree) {"; indent; pidl_code "item = proto_tree_add_text(parent_tree, tvb, offset, -1, \"$name\");"; pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 016e5f538f..cdf0302ced 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -16,130 +16,109 @@ use strict; my %typedefs = (); +my @reference_scalars = ( + "string", "string_array", "nbt_string", + "wrepl_nbt_name", "ipv4address" +); + # a list of known scalar types my $scalars = { # 0 byte types "void" => { C_TYPE => "void", - IS_REFERENCE => 0, }, # 1 byte types "char" => { C_TYPE => "char", - IS_REFERENCE => 0, }, "int8" => { C_TYPE => "int8_t", - IS_REFERENCE => 0, }, "uint8" => { C_TYPE => "uint8_t", - IS_REFERENCE => 0, }, # 2 byte types "int16" => { C_TYPE => "int16_t", - IS_REFERENCE => 0, }, "uint16" => { C_TYPE => "uint16_t", - IS_REFERENCE => 0, }, # 4 byte types "int32" => { C_TYPE => "int32_t", - IS_REFERENCE => 0, }, "uint32" => { C_TYPE => "uint32_t", - IS_REFERENCE => 0, }, # 8 byte types "hyper" => { C_TYPE => "uint64_t", - IS_REFERENCE => 0, }, "dlong" => { C_TYPE => "int64_t", - IS_REFERENCE => 0, }, "udlong" => { C_TYPE => "uint64_t", - IS_REFERENCE => 0, }, "udlongr" => { C_TYPE => "uint64_t", - IS_REFERENCE => 0, }, # assume its a 8 byte type, but cope with either "pointer" => { C_TYPE => "void*", - IS_REFERENCE => 0, }, # DATA_BLOB types "DATA_BLOB" => { C_TYPE => "DATA_BLOB", - IS_REFERENCE => 0, }, # string types "string" => { C_TYPE => "const char *", - IS_REFERENCE => 1, }, "string_array" => { C_TYPE => "const char **", - IS_REFERENCE => 1, }, # time types "time_t" => { C_TYPE => "time_t", - IS_REFERENCE => 0, }, "NTTIME" => { C_TYPE => "NTTIME", - IS_REFERENCE => 0, }, "NTTIME_1sec" => { C_TYPE => "NTTIME", - IS_REFERENCE => 0, }, "NTTIME_hyper" => { C_TYPE => "NTTIME", - IS_REFERENCE => 0, }, # error code types "WERROR" => { C_TYPE => "WERROR", - IS_REFERENCE => 0, }, "NTSTATUS" => { C_TYPE => "NTSTATUS", - IS_REFERENCE => 0, }, "COMRESULT" => { C_TYPE => "COMRESULT", - IS_REFERENCE => 0, }, # special types "nbt_string" => { C_TYPE => "const char *", - IS_REFERENCE => 1, }, "wrepl_nbt_name"=> { C_TYPE => "struct nbt_name *", - IS_REFERENCE => 1, }, "ipv4address" => { C_TYPE => "const char *", - IS_REFERENCE => 1, } }; @@ -200,8 +179,8 @@ sub is_scalar($) sub scalar_is_reference($) { my $name = shift; - - return $scalars->{$name}{IS_REFERENCE} if defined($scalars->{$name}) and defined($scalars->{$name}{IS_REFERENCE}); + + return 1 if (grep(/^$name$/, @reference_scalars)); return 0; } -- cgit From c65d2f9b1bb9a772656ccb2840bd2a5c5dc533e4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 13 May 2006 19:56:06 +0000 Subject: r15576: Separate out Samba4 bits a bit more (This used to be commit 77a2eb406e2b108089d3621194f9b86328a3e774) --- source4/pidl/lib/Parse/Pidl/Typelist.pm | 137 ++++++++++---------------------- 1 file changed, 44 insertions(+), 93 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index cdf0302ced..cf68345517 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -22,105 +22,55 @@ my @reference_scalars = ( ); # a list of known scalar types -my $scalars = { +my %scalars = ( # 0 byte types - "void" => { - C_TYPE => "void", - }, + "void" => "void", # 1 byte types - "char" => { - C_TYPE => "char", - }, - "int8" => { - C_TYPE => "int8_t", - }, - "uint8" => { - C_TYPE => "uint8_t", - }, + "char" => "char", + "int8" => "int8_t", + "uint8" => "uint8_t", # 2 byte types - "int16" => { - C_TYPE => "int16_t", - }, - "uint16" => { C_TYPE => "uint16_t", - }, + "int16" => "int16_t", + "uint16" => "uint16_t", # 4 byte types - "int32" => { - C_TYPE => "int32_t", - }, - "uint32" => { C_TYPE => "uint32_t", - }, + "int32" => "int32_t", + "uint32" => "uint32_t", # 8 byte types - "hyper" => { - C_TYPE => "uint64_t", - }, - "dlong" => { - C_TYPE => "int64_t", - }, - "udlong" => { - C_TYPE => "uint64_t", - }, - "udlongr" => { - C_TYPE => "uint64_t", - }, + "hyper" => "uint64_t", + "dlong" => "int64_t", + "udlong" => "uint64_t", + "udlongr" => "uint64_t", + # assume its a 8 byte type, but cope with either - "pointer" => { - C_TYPE => "void*", - }, + "pointer" => "void*", # DATA_BLOB types - "DATA_BLOB" => { - C_TYPE => "DATA_BLOB", - }, + "DATA_BLOB" => "DATA_BLOB", # string types - "string" => { - C_TYPE => "const char *", - }, - "string_array" => { - C_TYPE => "const char **", - }, + "string" => "const char *", + "string_array" => "const char **", # time types - "time_t" => { - C_TYPE => "time_t", - }, - "NTTIME" => { - C_TYPE => "NTTIME", - }, - "NTTIME_1sec" => { - C_TYPE => "NTTIME", - }, - "NTTIME_hyper" => { - C_TYPE => "NTTIME", - }, - + "time_t" => "time_t", + "NTTIME" => "NTTIME", + "NTTIME_1sec" => "NTTIME", + "NTTIME_hyper" => "NTTIME", # error code types - "WERROR" => { - C_TYPE => "WERROR", - }, - "NTSTATUS" => { - C_TYPE => "NTSTATUS", - }, - "COMRESULT" => { - C_TYPE => "COMRESULT", - }, + "WERROR" => "WERROR", + "NTSTATUS" => "NTSTATUS", + "COMRESULT" => "COMRESULT", # special types - "nbt_string" => { - C_TYPE => "const char *", - }, - "wrepl_nbt_name"=> { - C_TYPE => "struct nbt_name *", - }, - "ipv4address" => { - C_TYPE => "const char *", - } -}; + "nbt_string" => "const char *", + "wrepl_nbt_name"=> "struct nbt_name *", + "ipv4address" => "const char *", +); # map from a IDL type to a C header type sub mapScalarType($) @@ -129,7 +79,7 @@ sub mapScalarType($) # it's a bug when a type is not in the list # of known scalars or has no mapping - return $typedefs{$name}->{DATA}->{C_TYPE} if defined($typedefs{$name}) and defined($typedefs{$name}->{DATA}->{C_TYPE}); + return $scalars{$name} if defined($scalars{$name}); die("Unknown scalar type $name"); } @@ -149,8 +99,7 @@ sub getType($) sub typeIs($$) { - my $t = shift; - my $tt = shift; + my ($t,$tt) = @_; return 1 if (hasType($t) and getType($t)->{DATA}->{TYPE} eq $tt); return 0; @@ -186,18 +135,20 @@ sub scalar_is_reference($) sub RegisterScalars() { - foreach my $k (keys %{$scalars}) { - $typedefs{$k} = { - NAME => $k, + foreach (keys %scalars) { + addType({ + NAME => $_, TYPE => "TYPEDEF", - DATA => $scalars->{$k} - }; - $typedefs{$k}->{DATA}->{TYPE} = "SCALAR"; - $typedefs{$k}->{DATA}->{NAME} = $k; + DATA => { + TYPE => "SCALAR", + NAME => $_ + } + } + ); } } -my $aliases = { +my %aliases = ( "DWORD" => "uint32", "int" => "int32", "WORD" => "uint16", @@ -206,12 +157,12 @@ my $aliases = { "short" => "int16", "HYPER_T" => "hyper", "HRESULT" => "COMRESULT", -}; +); sub RegisterAliases() { - foreach my $k (keys %{$aliases}) { - $typedefs{$k} = $typedefs{$aliases->{$k}}; + foreach (keys %aliases) { + $typedefs{$_} = $typedefs{$aliases{$_}}; } } -- cgit From f9dd0263553c4f04fbc0d067e5384a9e46cd98bc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 13 May 2006 21:36:15 +0000 Subject: r15585: Revive pidl's SWIG file generator. It now generates simple object oriented wrappers for the interfaces (still need to fix the actual function calls) (This used to be commit bf5da20869eae29aea92386cbb13413b507fc55f) --- source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 129 ++++++++++++++++++----------- 1 file changed, 80 insertions(+), 49 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm index b6c268edeb..d42960be28 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -1,6 +1,7 @@ ################################################### # Samba4 parser generator for swig wrappers # Copyright tpot@samba.org 2004,2005 +# Copyright jelmer@samba.org 2006 # released under the GNU GPL package Parse::Pidl::Samba4::SWIG; @@ -10,70 +11,100 @@ $VERSION = '0.01'; use strict; +my $ret = ""; +my $tabs = ""; + sub pidl($) { - print OUT shift; + my $p = shift; + $ret .= $tabs. $p . "\n"; } -##################################################################### -# rewrite autogenerated header file -sub RewriteHeader($$$) -{ - my($idl) = shift; - my($input) = shift; - my($output) = shift; - - open(IN, "<$input") || die "can't open $input for reading"; - open(OUT, ">$output") || die "can't open $output for writing"; - - pidl "%{\n"; - pidl "#define data_in in\n"; - pidl "#define data_out out\n"; - pidl "%}\n\n"; - - while() { +sub indent() { $tabs.="\t"; } +sub deindent() { $tabs = substr($tabs,0,-1); } - # Rename dom_sid2 to dom_sid as we don't care about the difference - # for the swig wrappers. - - s/dom_sid2/dom_sid/g; +sub ParseInterface($) +{ + my $if = shift; + + pidl "\%{"; + pidl "struct $if->{NAME} {"; + indent; + pidl "struct dcerpc_pipe *pipe;"; + deindent; + pidl "};"; + pidl "%}"; + pidl ""; + + # FIXME: Generate ignores for all manual functions + + pidl "\%extend $if->{NAME} {"; + indent(); + pidl "struct $if->{NAME} *$if->{NAME} (const char *binding, struct cli_credentials *cred = NULL, TALLOC_CTX *mem_ctx = NULL, struct event_context *event = NULL)"; + pidl "{"; + indent; + pidl "struct $if->{NAME} *ret = talloc(mem_ctx, struct $if->{NAME});"; + pidl "NTSTATUS status;"; + pidl ""; + pidl "status = dcerpc_pipe_connect(mem_ctx, &ret->pipe, &dcerpc_table_$if->{NAME}, cred, event);"; + pidl "if (NT_STATUS_IS_ERR(status)) {"; + pidl "\tsamba_nt_status_exception(status);"; + pidl "\treturn NULL;"; + pidl "}"; + pidl ""; + pidl "return ret;"; + deindent; + pidl "}"; + pidl ""; + pidl "~$if->{NAME}() {"; + pidl "\ttalloc_free(self);"; + pidl "}"; + pidl ""; + + foreach (@{$if->{FUNCTIONS}}) { + pidl "/* $_->{NAME} */"; + } - # Copy structure and union definitions + deindent(); + pidl "}"; + pidl ""; - if (/^(struct|union) .*? {$/ .. /^\};$/) { - s/\} (in|out);/\} data_$1;/; # "in" is a Python keyword - pidl $_; - next; + foreach (@{$if->{TYPES}}) { + pidl "/* $_->{NAME} */"; } + + pidl ""; +} - # Copy dcerpc functions - - pidl $_ if /^NTSTATUS dcerpc_.*?\(struct dcerpc_pipe/; +sub Parse($$$$) +{ + my($ndr,$basename,$header,$gen_header) = @_; - # Copy interface definitions + $ret = ""; - pidl $_ - if /^\#define DCERPC_.*?_UUID/ or /^\#define DCERPC_.*?_VERSION/; - } + pidl "/* This file is autogenerated by pidl. DO NOT EDIT */"; - close(OUT); -} + pidl "\%module $basename"; + + pidl ""; -##################################################################### -# rewrite autogenerated header file -sub RewriteC($$$) -{ - my($idl) = shift; - my($input) = shift; - my($output) = shift; + pidl "\%{"; + pidl "#include \"includes.h\""; + pidl "#include \"$header\""; + pidl "%}"; + pidl "\%include \"samba.i\""; + pidl "\%include \"$gen_header\""; - open(IN, "<$input") || die "can't open $input for reading"; - open(OUT, ">>$output") || die "can't open $output for writing"; - - while() { - } + pidl ""; - close(OUT); + foreach (@$ndr) { + ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + } + #FIXME: Foreach ref pointer, set NONNULL + #FIXME: Foreach unique/full pointer, set MAYBENULL + #FIXME: Foreach [out] parameter, set OUTPARAM + # + return $ret; } 1; -- cgit From 8d6249814f45e95a9941dfc7d6d3d2a93811efb0 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 13 May 2006 22:03:44 +0000 Subject: r15587: Generate stubs for the SWIG functions (This used to be commit 746d0a7fa7a43685e6ebb4877bb5459101e51ed1) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 37 +------------------ source4/pidl/lib/Parse/Pidl/Samba4.pm | 41 +++++++++++++++++++-- source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 48 ++++++++++++++++++++----- source4/pidl/lib/Parse/Pidl/Typelist.pm | 2 +- 4 files changed, 80 insertions(+), 48 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index eda2ab99d7..3b8c92ebe4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -10,6 +10,7 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); use Parse::Pidl::Util qw(has_property ParseExpr is_constant); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::Samba4 qw(DeclLong); use vars qw($VERSION); $VERSION = '0.01'; @@ -46,42 +47,6 @@ sub CopyLevel($$$$) } } -sub DeclLong($) -{ - my($element) = shift; - my $ret = ""; - - if (has_property($element, "represent_as")) { - $ret.=mapType($element->{PROPERTIES}->{represent_as})." "; - } else { - if (has_property($element, "charset")) { - $ret.="const char"; - } else { - $ret.=mapType($element->{TYPE}); - } - - $ret.=" "; - my $numstar = $element->{ORIGINAL}->{POINTERS}; - if ($numstar >= 1) { - $numstar-- if scalar_is_reference($element->{TYPE}); - } - foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) - { - next if is_constant($_) and - not has_property($element, "charset"); - $numstar++; - } - $ret.="*" foreach (1..$numstar); - } - $ret.=$element->{NAME}; - foreach (@{$element->{ARRAY_LEN}}) { - next unless (is_constant($_) and not has_property($element, "charset")); - $ret.="[$_]"; - } - - return $ret; -} - sub ParseFunction($$) { my ($if,$fn) = @_; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index 0a284aa85b..2d710f3eb6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -7,9 +7,10 @@ package Parse::Pidl::Samba4; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(is_intree choose_header); +@EXPORT = qw(is_intree choose_header DeclLong); -use Parse::Pidl::Util qw(has_property); +use Parse::Pidl::Util qw(has_property is_constant); +use Parse::Pidl::Typelist qw(mapType scalar_is_reference); use strict; use vars qw($VERSION); @@ -29,4 +30,40 @@ sub choose_header($$) return "#include <$out>"; } +sub DeclLong($) +{ + my($element) = shift; + my $ret = ""; + + if (has_property($element, "represent_as")) { + $ret.=mapType($element->{PROPERTIES}->{represent_as})." "; + } else { + if (has_property($element, "charset")) { + $ret.="const char"; + } else { + $ret.=mapType($element->{TYPE}); + } + + $ret.=" "; + my $numstar = $element->{ORIGINAL}->{POINTERS}; + if ($numstar >= 1) { + $numstar-- if scalar_is_reference($element->{TYPE}); + } + foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) + { + next if is_constant($_) and + not has_property($element, "charset"); + $numstar++; + } + $ret.="*" foreach (1..$numstar); + } + $ret.=$element->{NAME}; + foreach (@{$element->{ARRAY_LEN}}) { + next unless (is_constant($_) and not has_property($element, "charset")); + $ret.="[$_]"; + } + + return $ret; +} + 1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm index d42960be28..22061f46af 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -7,6 +7,8 @@ package Parse::Pidl::Samba4::SWIG; use vars qw($VERSION); +use Parse::Pidl::Samba4 qw(DeclLong); +use Parse::Pidl::Typelist qw(mapType); $VERSION = '0.01'; use strict; @@ -23,9 +25,9 @@ sub pidl($) sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs,0,-1); } -sub ParseInterface($) +sub ParseInterface($$) { - my $if = shift; + my ($basename,$if) = @_; pidl "\%{"; pidl "struct $if->{NAME} {"; @@ -36,8 +38,6 @@ sub ParseInterface($) pidl "%}"; pidl ""; - # FIXME: Generate ignores for all manual functions - pidl "\%extend $if->{NAME} {"; indent(); pidl "struct $if->{NAME} *$if->{NAME} (const char *binding, struct cli_credentials *cred = NULL, TALLOC_CTX *mem_ctx = NULL, struct event_context *event = NULL)"; @@ -61,8 +61,39 @@ sub ParseInterface($) pidl "}"; pidl ""; - foreach (@{$if->{FUNCTIONS}}) { - pidl "/* $_->{NAME} */"; + foreach my $fn (@{$if->{FUNCTIONS}}) { + pidl "/* $fn->{NAME} */"; + my $args = ""; + foreach (@{$fn->{ELEMENTS}}) { + $args .= DeclLong($_) . ", "; + } + my $name = $fn->{NAME}; + $name =~ s/^$if->{NAME}_//g; + $name =~ s/^$basename\_//g; + $args .= "TALLOC_CTX *mem_ctx = NULL"; + pidl mapType($fn->{RETURN_TYPE}) . " $name($args)"; + pidl "{"; + indent; + pidl "struct $fn->{NAME} r;"; + my $assign = ""; + if (defined($fn->{RETURN_TYPE})) { + pidl mapType($fn->{RETURN_TYPE}) . " ret;"; + $assign = "ret = "; + } + pidl ""; + pidl "/* Fill r structure */"; + pidl "/* FIXME */"; + pidl ""; + pidl $assign."dcerpc_$fn->{NAME}(self->pipe, mem_ctx, &r);"; + pidl ""; + pidl "/* Set out arguments */"; + pidl "/* FIXME */"; + if (defined($fn->{RETURN_TYPE})) { + pidl "return ret;"; + } + deindent; + pidl "}"; + pidl ""; } deindent(); @@ -70,7 +101,7 @@ sub ParseInterface($) pidl ""; foreach (@{$if->{TYPES}}) { - pidl "/* $_->{NAME} */"; + pidl "/* $_->{NAME} */"; } pidl ""; @@ -98,12 +129,11 @@ sub Parse($$$$) pidl ""; foreach (@$ndr) { - ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + ParseInterface($basename, $_) if ($_->{TYPE} eq "INTERFACE"); } #FIXME: Foreach ref pointer, set NONNULL #FIXME: Foreach unique/full pointer, set MAYBENULL #FIXME: Foreach [out] parameter, set OUTPARAM - # return $ret; } diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index cf68345517..ff8f18ee48 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -194,7 +194,7 @@ sub bitmap_type_fn($) sub mapType($) { my $t = shift; - die("Undef passed to mapType") unless defined($t); + return "void" unless defined($t); my $dt; unless ($dt or ($dt = getType($t))) { -- cgit From fde2d769eb7c63a92704135e5ce49712dd30a1ca Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 13 May 2006 23:58:16 +0000 Subject: r15591: Generate function calls correctly as well. (This used to be commit b0439779b8eba68680cfd49ea2364affc739300e) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 23 +------ source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 82 ++++++++++++++++++------- 2 files changed, 60 insertions(+), 45 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 3b8c92ebe4..fa629e6101 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -26,27 +26,6 @@ sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LI sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } -sub CopyLevel($$$$) -{ - sub CopyLevel($$$$); - my ($e,$l,$argument,$member) = @_; - - if ($l->{TYPE} eq "DATA") { - pidl "*$argument = *$member;"; - } elsif ($l->{TYPE} eq "POINTER") { - pidl "if (r.ptr$l->{POINTER_INDEX}_$e->{NAME}) {"; - indent; - pidl "*$argument = talloc_size(mem_ctx, sizeof(void *));"; - CopyLevel($e,GetNextLevel($e,$l),"*$argument", $member); - deindent; - pidl "}"; - } elsif ($l->{TYPE} eq "SWITCH") { - CopyLevel($e,GetNextLevel($e,$l),$argument,$member); - } elsif ($l->{TYPE} eq "ARRAY") { - pidl "*$argument = $member;"; - } -} - sub ParseFunction($$) { my ($if,$fn) = @_; @@ -84,7 +63,7 @@ sub ParseFunction($$) fatal($e, "[out] argument is not a pointer") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER"); - CopyLevel($e, $e->{LEVELS}[1], $e->{NAME}, "r.out.$e->{NAME}"); + pidl "*$e->{NAME} = *r.out.$e->{NAME};"; } pidl""; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm index 22061f46af..57ff007d1b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -9,6 +9,7 @@ package Parse::Pidl::Samba4::SWIG; use vars qw($VERSION); use Parse::Pidl::Samba4 qw(DeclLong); use Parse::Pidl::Typelist qw(mapType); +use Parse::Pidl::Util qw(has_property); $VERSION = '0.01'; use strict; @@ -25,30 +26,35 @@ sub pidl($) sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs,0,-1); } +sub IgnoreInterface($$) +{ + my ($basename,$if) = @_; + + foreach (@{$if->{TYPES}}) { + next unless (has_property($_, "public")); + pidl "\%types($_->{NAME});"; + } +} + sub ParseInterface($$) { my ($basename,$if) = @_; - pidl "\%{"; - pidl "struct $if->{NAME} {"; - indent; - pidl "struct dcerpc_pipe *pipe;"; - deindent; - pidl "};"; - pidl "%}"; + pidl "\%inline {"; + pidl "struct $if->{NAME} { struct dcerpc_pipe *pipe; };"; + pidl "}"; pidl ""; - pidl "\%extend $if->{NAME} {"; indent(); - pidl "struct $if->{NAME} *$if->{NAME} (const char *binding, struct cli_credentials *cred = NULL, TALLOC_CTX *mem_ctx = NULL, struct event_context *event = NULL)"; + pidl "$if->{NAME} (const char *binding, struct cli_credentials *cred = NULL, TALLOC_CTX *mem_ctx = NULL, struct event_context *event = NULL)"; pidl "{"; indent; pidl "struct $if->{NAME} *ret = talloc(mem_ctx, struct $if->{NAME});"; pidl "NTSTATUS status;"; pidl ""; - pidl "status = dcerpc_pipe_connect(mem_ctx, &ret->pipe, &dcerpc_table_$if->{NAME}, cred, event);"; + pidl "status = dcerpc_pipe_connect(mem_ctx, &ret->pipe, binding, &dcerpc_table_$if->{NAME}, cred, event);"; pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\tsamba_nt_status_exception(status);"; + pidl "\tntstatus_exception(status);"; pidl "\treturn NULL;"; pidl "}"; pidl ""; @@ -75,21 +81,38 @@ sub ParseInterface($$) pidl "{"; indent; pidl "struct $fn->{NAME} r;"; - my $assign = ""; - if (defined($fn->{RETURN_TYPE})) { - pidl mapType($fn->{RETURN_TYPE}) . " ret;"; - $assign = "ret = "; - } + pidl "NTSTATUS status;"; pidl ""; pidl "/* Fill r structure */"; - pidl "/* FIXME */"; + + foreach (@{$fn->{ELEMENTS}}) { + if (grep(/in/, @{$_->{DIRECTION}})) { + pidl "r.in.$_->{NAME} = $_->{NAME};"; + } + } + pidl ""; - pidl $assign."dcerpc_$fn->{NAME}(self->pipe, mem_ctx, &r);"; + pidl "status = dcerpc_$fn->{NAME}(self->pipe, mem_ctx, &r);"; + pidl "if (NT_STATUS_IS_ERR(status)) {"; + pidl "\tntstatus_exception(status);"; + if (defined($fn->{RETURN_TYPE})) { + pidl "\treturn r.out.result;"; + } else { + pidl "\treturn;"; + } + pidl "}"; pidl ""; pidl "/* Set out arguments */"; - pidl "/* FIXME */"; + foreach (@{$fn->{ELEMENTS}}) { + next unless (grep(/out/, @{$_->{DIRECTION}})); + + pidl ("/* FIXME: $_->{NAME} [out] argument is not a pointer */") if ($_->{LEVELS}[0]->{TYPE} ne "POINTER"); + + pidl "*$_->{NAME} = *r.out.$_->{NAME};"; + } + if (defined($fn->{RETURN_TYPE})) { - pidl "return ret;"; + pidl "return r.out.result;"; } deindent; pidl "}"; @@ -97,7 +120,7 @@ sub ParseInterface($$) } deindent(); - pidl "}"; + pidl "};"; pidl ""; foreach (@{$if->{TYPES}}) { @@ -121,10 +144,23 @@ sub Parse($$$$) pidl "\%{"; pidl "#include \"includes.h\""; + pidl "#include \"auth/credentials/credentials.h\""; pidl "#include \"$header\""; + pidl "#include \"$gen_header\""; pidl "%}"; - pidl "\%include \"samba.i\""; - pidl "\%include \"$gen_header\""; + pidl "\%import \"samba.i\""; + pidl ""; + pidl "\%inline {"; + pidl "void ntstatus_exception(NTSTATUS status)"; + pidl "{"; + pidl "\t/* FIXME */"; + pidl "}"; + pidl "}"; + pidl ""; + foreach (@$ndr) { + IgnoreInterface($basename, $_) if ($_->{TYPE} eq "INTERFACE"); + } + pidl ""; pidl ""; -- cgit From 2a9407fad39a472a356adbcdac3c0fa0a4d69a5f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 14 May 2006 00:22:24 +0000 Subject: r15593: Warn about [out] arguments that are not pointers. These can all be fixed by adding [ref] pointers. This will cause a lot of warnings to be outputted by pidl for now. I will fix these gradually over the next few days. We need to avoid [out] arguments that are not pointers because they are not understood by other IDL compilers and don't work with some of our output modules (Samba3, Samba3NDR and ethereal) (This used to be commit c4ab021ee8d93aa74f15deebf64a366b33b7bb9f) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 5 +++++ source4/pidl/lib/Parse/Pidl/ODL.pm | 15 +++++++++------ source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 5 ----- 3 files changed, 14 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index a4008a1545..3cbf416488 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -540,6 +540,11 @@ sub ParseFunction($$$) my $e = ParseElement($x); push (@{$e->{DIRECTION}}, "in") if (has_property($x, "in")); push (@{$e->{DIRECTION}}, "out") if (has_property($x, "out")); + + nonfatal($x, "`$e->{NAME}' is [out] argument but not a pointer") + if ($e->{LEVELS}[0]->{TYPE} ne "POINTER") and + grep(/out/, @{$e->{DIRECTION}}); + push (@elements, $e); } diff --git a/source4/pidl/lib/Parse/Pidl/ODL.pm b/source4/pidl/lib/Parse/Pidl/ODL.pm index 082deaea1d..b5d65b6239 100644 --- a/source4/pidl/lib/Parse/Pidl/ODL.pm +++ b/source4/pidl/lib/Parse/Pidl/ODL.pm @@ -15,11 +15,10 @@ $VERSION = '0.01'; # find an interface in an array of interfaces sub get_interface($$) { - my($if) = shift; - my($n) = shift; + my($if,$n) = @_; - foreach(@{$if}) { - if($_->{NAME} eq $n) { return $_; } + foreach(@$if) { + return $_ if($_->{NAME} eq $n); } return 0; @@ -33,13 +32,17 @@ sub FunctionAddObjArgs($) 'NAME' => 'ORPCthis', 'POINTERS' => 0, 'PROPERTIES' => { 'in' => '1' }, - 'TYPE' => 'ORPCTHIS' + 'TYPE' => 'ORPCTHIS', + 'FILE' => $e->{FILE}, + 'LINE' => $e->{LINE} }); unshift(@{$e->{ELEMENTS}}, { 'NAME' => 'ORPCthat', 'POINTERS' => 0, 'PROPERTIES' => { 'out' => '1' }, - 'TYPE' => 'ORPCTHAT' + 'TYPE' => 'ORPCTHAT', + 'FILE' => $e->{FILE}, + 'LINE' => $e->{LINE} }); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm index 59f0341d02..9e26e9a21e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm @@ -85,11 +85,6 @@ sub ParseFunction($$) foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); - if ($e->{LEVELS}[0]->{TYPE} ne "POINTER") { - warning($e->{ORIGINAL}, "First element not a pointer for [out] argument"); - next; - } - CopyLevel($e, $e->{LEVELS}[1], $e->{NAME}, "r.$e->{NAME}"); } -- cgit From 392e4b383c35ba9befd396a99f6f27608efb9862 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 16 May 2006 22:21:44 +0000 Subject: r15650: Fix perl warning when generating IDL for elements with no properties (This used to be commit 038bbbcda50d8284c56dbdc3a70214ba6202595e) --- source4/pidl/lib/Parse/Pidl/Dump.pm | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Dump.pm b/source4/pidl/lib/Parse/Pidl/Dump.pm index 3a1cec1b59..88f18de322 100644 --- a/source4/pidl/lib/Parse/Pidl/Dump.pm +++ b/source4/pidl/lib/Parse/Pidl/Dump.pm @@ -36,7 +36,7 @@ my($res); sub DumpProperties($) { my($props) = shift; - my($res); + my $res = ""; foreach my $d ($props) { foreach my $k (keys %{$d}) { @@ -63,7 +63,7 @@ sub DumpProperties($) sub DumpElement($) { my($element) = shift; - my($res); + my $res = ""; (defined $element->{PROPERTIES}) && ($res .= DumpProperties($element->{PROPERTIES})); @@ -89,10 +89,9 @@ sub DumpStruct($) $res .= "struct {\n"; if (defined $struct->{ELEMENTS}) { - foreach my $e (@{$struct->{ELEMENTS}}) { - $res .= "\t" . DumpElement($e); - $res .= ";\n"; - } + foreach (@{$struct->{ELEMENTS}}) { + $res .= "\t" . DumpElement($_) . ";\n"; + } } $res .= "}"; -- cgit From 76aa75abc6dde74d1d8d382fe8d1fa07750a90da Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 16 May 2006 22:25:13 +0000 Subject: r15651: Add 'MANUAL' command in Ethereal conformance files. This allows overriding individual functions for specific element levels without losing the other functions for an element or the hf/ett fields allocated. Fixes #3738. (This used to be commit a3dbab619bf8fdef002b8e31956e99226bc20e94) --- .../pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 19 ++++++++++-- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 35 +++++++++++++++++++++- 2 files changed, 50 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index e3296c1629..02319a0aa9 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -74,6 +74,13 @@ Code to insert when generating the specified dissector. @HF@ and Override the text shown when a bitmap boolean value is enabled or disabled. +=item I fn_name + +Force pidl to not generate a particular function but allow the user +to write a function manually. This can be used to remove the function +for only one level for a particular element rather then all the functions and +ett/hf variables for a particular element as the NOEMIT command does. + =back =head1 EXAMPLE @@ -232,9 +239,7 @@ sub handle_strip_prefix($$$) sub handle_noemit($$$) { - my $pos = shift; - my $data = shift; - my $type = shift; + my ($pos,$data,$type) = @_; if (defined($type)) { $data->{noemit}->{$type} = 1; @@ -243,6 +248,13 @@ sub handle_noemit($$$) } } +sub handle_manual($$$) +{ + my ($pos,$data,$fn) = @_; + + $data->{manual}->{$fn} = 1; +} + sub handle_protocol($$$$$$) { my ($pos, $data, $name, $longname, $shortname, $filtername) = @_; @@ -287,6 +299,7 @@ sub handle_import my %field_handlers = ( TYPE => \&handle_type, NOEMIT => \&handle_noemit, + MANUAL => \&handle_manual, PARAM_VALUE => \&handle_param_value, HF_FIELD => \&handle_hf_field, HF_RENAME => \&handle_hf_rename, diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm index 371c35b374..685cb5a12a 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm @@ -72,9 +72,24 @@ sub field2name($) my %res = (); my $tabs = ""; +my $cur_fn = undef; +sub pidl_fn_start($) +{ + my $fn = shift; + $cur_fn = $fn; +} +sub pidl_fn_end($) +{ + my $fn = shift; + die("Inconsistent state: $fn != $cur_fn") if ($fn ne $cur_fn); + $cur_fn = undef; +} + sub pidl_code($) { my $d = shift; + return if (defined($cur_fn) and defined($conformance->{manual}->{$cur_fn})); + if ($d) { $res{code} .= $tabs; $res{code} .= $d; @@ -124,7 +139,7 @@ sub Enum($$$) return if (defined($conformance->{noemit}->{StripPrefixes($name)})); - foreach (@{$e->{ELEMENTS}}) { + foreach (@{$e->{ELEMENTS}}) { if (/([^=]*)=(.*)/) { pidl_hdr "#define $1 ($2)"; } @@ -142,6 +157,7 @@ sub Enum($$$) pidl_def "{ 0, NULL }"; pidl_def "};"; + pidl_fn_start $dissectorname; pidl_code "int"; pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)"; pidl_code "{"; @@ -150,6 +166,7 @@ sub Enum($$$) pidl_code "return offset;"; deindent; pidl_code "}\n"; + pidl_fn_end $dissectorname; my $enum_size = $e->{BASE_TYPE}; $enum_size =~ s/uint//g; @@ -165,6 +182,7 @@ sub Bitmap($$$) pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; + pidl_fn_start $dissectorname; pidl_code "int"; pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; pidl_code "{"; @@ -230,6 +248,7 @@ sub Bitmap($$$) pidl_code "return offset;"; deindent; pidl_code "}\n"; + pidl_fn_end $dissectorname; my $size = $e->{BASE_TYPE}; $size =~ s/uint//g; @@ -376,6 +395,7 @@ sub Element($$$) foreach (@{$e->{LEVELS}}) { next if ($_->{TYPE} eq "SWITCH"); pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);"; + pidl_fn_start "$dissectorname$add"; pidl_code "static int"; pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)"; pidl_code "{"; @@ -387,6 +407,7 @@ sub Element($$$) pidl_code "return offset;"; deindent; pidl_code "}\n"; + pidl_fn_end "$dissectorname$add"; $add.="_"; last if ($_->{TYPE} eq "ARRAY" and $_->{IS_ZERO_TERMINATED}); } @@ -408,6 +429,7 @@ sub Function($$$) $fn_name =~ s/^${ifname}_//; PrintIdl DumpFunction($fn->{ORIGINAL}); + pidl_fn_start "$ifname\_dissect\_$fn_name\_response"; pidl_code "static int"; pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; pidl_code "{"; @@ -441,7 +463,9 @@ sub Function($$$) pidl_code "return offset;"; deindent; pidl_code "}\n"; + pidl_fn_end "$ifname\_dissect\_$fn_name\_response"; + pidl_fn_start "$ifname\_dissect\_$fn_name\_request"; pidl_code "static int"; pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; pidl_code "{"; @@ -457,6 +481,7 @@ sub Function($$$) pidl_code "return offset;"; deindent; pidl_code "}\n"; + pidl_fn_end "$ifname\_dissect\_$fn_name\_request"; } sub Struct($$$) @@ -473,6 +498,7 @@ sub Struct($$$) pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_);"; + pidl_fn_start $dissectorname; pidl_code "int"; pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; pidl_code "{"; @@ -502,6 +528,7 @@ sub Struct($$$) pidl_code "return offset;"; deindent; pidl_code "}\n"; + pidl_fn_end $dissectorname; register_type($name, "offset = $dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); } @@ -536,6 +563,7 @@ sub Union($$$) $switch_dissect = "dissect_ndr_$e->{SWITCH_TYPE}"; } + pidl_fn_start $dissectorname; pidl_code "static int"; pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; pidl_code "{"; @@ -569,6 +597,7 @@ sub Union($$$) pidl_code "return offset;"; deindent; pidl_code "}"; + pidl_fn_end $dissectorname; register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); } @@ -602,6 +631,7 @@ sub RegisterInterface($) { my ($x) = @_; + pidl_fn_start "proto_register_dcerpc_$x->{NAME}"; pidl_code "void proto_register_dcerpc_$x->{NAME}(void)"; pidl_code "{"; indent; @@ -639,6 +669,7 @@ sub RegisterInterface($) deindent; pidl_code "}\n"; + pidl_fn_end "proto_register_dcerpc_$x->{NAME}"; } sub RegisterInterfaceHandoff($) @@ -646,6 +677,7 @@ sub RegisterInterfaceHandoff($) my $x = shift; if (defined($x->{UUID})) { + pidl_fn_start "proto_reg_handoff_dcerpc_$x->{NAME}"; pidl_code "void proto_reg_handoff_dcerpc_$x->{NAME}(void)"; pidl_code "{"; indent; @@ -654,6 +686,7 @@ sub RegisterInterfaceHandoff($) pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);"; deindent; pidl_code "}"; + pidl_fn_end "proto_reg_handoff_dcerpc_$x->{NAME}"; $hf_used{"hf_$x->{NAME}_opnum"} = 1; } -- cgit From fda645af50ea82c74d51ef76b37a6b38a826c56c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 16 May 2006 23:49:31 +0000 Subject: r15652: Fix aliases mechanism (fixes #3710) (This used to be commit 3e89ef0875c5c8ccaafa9694d27a8043930127e6) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 6 +++-- source4/pidl/lib/Parse/Pidl/Typelist.pm | 45 ++++++++++++++++++--------------- 2 files changed, 29 insertions(+), 22 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 3cbf416488..5839b042d3 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -37,7 +37,7 @@ $VERSION = '0.01'; @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); use strict; -use Parse::Pidl::Typelist qw(hasType getType); +use Parse::Pidl::Typelist qw(hasType getType expandAlias); use Parse::Pidl::Util qw(has_property property_matches); # Alignment of the built-in scalar types @@ -364,6 +364,8 @@ sub ParseElement($) { my $e = shift; + $e->{TYPE} = expandAlias($e->{TYPE}); + return { NAME => $e->{NAME}, TYPE => $e->{TYPE}, @@ -549,7 +551,7 @@ sub ParseFunction($$$) } if ($d->{RETURN_TYPE} ne "void") { - $rettype = $d->{RETURN_TYPE}; + $rettype = expandAlias($d->{RETURN_TYPE}); } my $async = 0; diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index ff8f18ee48..10a1e8136f 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Typelist; require Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(hasType getType mapType scalar_is_reference); +@EXPORT_OK = qw(hasType getType mapType scalar_is_reference expandAlias); use vars qw($VERSION); $VERSION = '0.01'; @@ -72,6 +72,29 @@ my %scalars = ( "ipv4address" => "const char *", ); +my %aliases = ( + "error_status_t" => "uint32", + "boolean8" => "uint8", + "boolean32" => "uint32", + "DWORD" => "uint32", + "int" => "int32", + "WORD" => "uint16", + "char" => "uint8", + "long" => "int32", + "short" => "int16", + "HYPER_T" => "hyper", + "HRESULT" => "COMRESULT", +); + +sub expandAlias($) +{ + my $name = shift; + + return $aliases{$name} if defined($aliases{$name}); + + return $name; +} + # map from a IDL type to a C header type sub mapScalarType($) { @@ -148,24 +171,6 @@ sub RegisterScalars() } } -my %aliases = ( - "DWORD" => "uint32", - "int" => "int32", - "WORD" => "uint16", - "char" => "uint8", - "long" => "int32", - "short" => "int16", - "HYPER_T" => "hyper", - "HRESULT" => "COMRESULT", -); - -sub RegisterAliases() -{ - foreach (keys %aliases) { - $typedefs{$_} = $typedefs{$aliases{$_}}; - } -} - sub enum_type_fn($) { my $enum = shift; @@ -196,6 +201,7 @@ sub mapType($) my $t = shift; return "void" unless defined($t); my $dt; + $t = expandAlias($t); unless ($dt or ($dt = getType($t))) { # Best guess @@ -237,6 +243,5 @@ sub LoadIdl($) } RegisterScalars(); -RegisterAliases(); 1; -- cgit From 9727b061f330ba8f500a29bf4b94992e2bceffbc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 21 May 2006 12:58:39 +0000 Subject: r15776: Don't generate ref pointers in Samba4-generated code. There is no point in having pointers for outgoing data when you can already modify the top-level element. This can be overridden (temporarily) by specifying the new "keepref" attribute. Once we've removed keepref from all IDL files, I'll remove this attribute as well. (This used to be commit bdc6dd37503ced8322a671d225122ccffbb8bfec) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 26 ++++++++++++++++++-- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 6 ++++- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 30 ++++++++++++++---------- source4/pidl/lib/Parse/Pidl/Typelist.pm | 21 ----------------- 4 files changed, 47 insertions(+), 36 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 5839b042d3..21875a1297 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -571,8 +571,7 @@ sub ParseFunction($$$) sub CheckPointerTypes($$) { - my $s = shift; - my $default = shift; + my ($s,$default) = @_; foreach my $e (@{$s->{ELEMENTS}}) { if ($e->{POINTERS} and not defined(pointer_type($e))) { @@ -581,6 +580,23 @@ sub CheckPointerTypes($$) } } +#FIXME: Remove when ref handling in Samba4 is fixed +sub AddKeepRef($) +{ + my $d = shift; + + if ($d->{TYPE} eq "FUNCTION") { + foreach (@{$d->{ELEMENTS}}) { + $_->{PROPERTIES}->{keepref} = 1; + } + } elsif ($d->{TYPE} eq "TYPEDEF" and ($d->{DATA}->{TYPE} eq "STRUCT" + or $d->{DATA}->{TYPE} eq "UNION")) { + foreach (@{$d->{DATA}->{ELEMENTS}}) { + $_->{PROPERTIES}->{keepref} = 1; + } + } +} + sub ParseInterface($) { my $idl = shift; @@ -606,10 +622,12 @@ sub ParseInterface($) if ($d->{TYPE} eq "DECLARE") { push (@declares, $d); } elsif ($d->{TYPE} eq "FUNCTION") { + AddKeepRef($d) if (has_property($idl, "keepref")); push (@functions, ParseFunction($idl, $d, \$opnum)); } elsif ($d->{TYPE} eq "CONST") { push (@consts, ParseConst($idl, $d)); } else { + AddKeepRef($d) if (has_property($idl, "keepref")); push (@types, ParseType($idl, $d)); } } @@ -831,6 +849,10 @@ my %property_list = ( "noheader" => ["ELEMENT"], "charset" => ["ELEMENT"], "length_is" => ["ELEMENT"], + + # temporary (should be removed once we've migrated away from + # relying on ref pointers being there in Samba4's code) + "keepref" => ["ELEMENT","INTERFACE"], ); ##################################################################### diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 6fb3ee2eec..c9487115f5 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -60,7 +60,11 @@ sub HeaderElement($) } else { HeaderType($element, $element->{TYPE}, ""); pidl " "; - my $numstar = $element->{POINTERS}; + my $numstar = 0; + if (!has_property($element, "ref") or + has_property($element, "keepref")) { + $numstar += $element->{POINTERS}; + } if ($numstar >= 1) { $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index b7ae526e68..5a8ef53e14 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -582,7 +582,9 @@ sub ParseElementPushLevel pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));"; } } - $var_name = get_value_of($var_name); + if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) { + $var_name = get_value_of($var_name); + } ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1); if ($l->{POINTER_TYPE} ne "ref") { @@ -662,11 +664,12 @@ sub ParsePtrPush($$$) my ($e,$l,$var_name) = @_; if ($l->{POINTER_TYPE} eq "ref") { - if ($l->{LEVEL} eq "EMBEDDED") { - pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_name));"; - } else { + if (has_property($e, "keepref")) { check_null_pointer(get_value_of($var_name)); } + if ($l->{LEVEL} eq "EMBEDDED") { + pidl "NDR_CHECK(ndr_push_ref_ptr(ndr));"; + } } elsif ($l->{POINTER_TYPE} eq "relative") { pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));"; } elsif ($l->{POINTER_TYPE} eq "unique") { @@ -872,7 +875,7 @@ sub ParseMemCtxPullStart($$$) my $next_is_array = ($nl->{TYPE} eq "ARRAY"); my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); - if ($next_is_array or $next_is_string) { + if ($next_is_array or $next_is_string or not has_property($e, "keepref")) { return; } else { $mem_c_flags = "LIBNDR_FLAG_REF_ALLOC"; @@ -898,7 +901,7 @@ sub ParseMemCtxPullEnd($$) my $next_is_array = ($nl->{TYPE} eq "ARRAY"); my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); - if ($next_is_array or $next_is_string) { + if ($next_is_array or $next_is_string or not has_property($e, "keepref")) { return; } else { $mem_r_flags = "LIBNDR_FLAG_REF_ALLOC"; @@ -975,7 +978,9 @@ sub ParseElementPullLevel ParseMemCtxPullStart($e,$l, $var_name); - $var_name = get_value_of($var_name); + if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) { + $var_name = get_value_of($var_name); + } ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); ParseMemCtxPullEnd($e,$l); @@ -1075,11 +1080,12 @@ sub ParsePtrPull($$$$) ($nl->{DATA_TYPE} eq "string")); if ($l->{POINTER_TYPE} eq "ref") { - unless ($l->{LEVEL} eq "TOP") { + if ($l->{LEVEL} eq "EMBEDDED") { pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"; } - unless ($next_is_array or $next_is_string) { + if (!$next_is_array and !$next_is_string and + has_property($e, "keepref")) { pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; pidl "\tNDR_PULL_ALLOC($ndr, $var_name);"; pidl "}"; @@ -1413,8 +1419,7 @@ sub DeclareArrayVariables($) sub need_decl_mem_ctx($$) { - my $e = shift; - my $l = shift; + my ($e,$l) = @_; return 0 if has_fast_array($e,$l); return 0 if is_charset_array($e,$l); @@ -1425,7 +1430,7 @@ sub need_decl_mem_ctx($$) my $next_is_array = ($nl->{TYPE} eq "ARRAY"); my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); - return 0 if ($next_is_array or $next_is_string); + return 0 if ($next_is_array or $next_is_string or not has_property($e, "keepref")); } return 1 if ($l->{TYPE} eq "POINTER"); @@ -2091,6 +2096,7 @@ sub ParseFunctionPull($) next unless (grep(/out/, @{$e->{DIRECTION}})); next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref"); + next unless has_property($e, "keepref"); next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and ($e->{LEVELS}[1]->{DATA_TYPE} eq "string")); next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY") diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 10a1e8136f..66d5e59e7c 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -23,50 +23,29 @@ my @reference_scalars = ( # a list of known scalar types my %scalars = ( - # 0 byte types "void" => "void", - - # 1 byte types "char" => "char", "int8" => "int8_t", "uint8" => "uint8_t", - - # 2 byte types "int16" => "int16_t", "uint16" => "uint16_t", - - # 4 byte types "int32" => "int32_t", "uint32" => "uint32_t", - - # 8 byte types "hyper" => "uint64_t", "dlong" => "int64_t", "udlong" => "uint64_t", "udlongr" => "uint64_t", - - # assume its a 8 byte type, but cope with either "pointer" => "void*", - - # DATA_BLOB types "DATA_BLOB" => "DATA_BLOB", - - # string types "string" => "const char *", "string_array" => "const char **", - - # time types "time_t" => "time_t", "NTTIME" => "NTTIME", "NTTIME_1sec" => "NTTIME", "NTTIME_hyper" => "NTTIME", - - # error code types "WERROR" => "WERROR", "NTSTATUS" => "NTSTATUS", "COMRESULT" => "COMRESULT", - - # special types "nbt_string" => "const char *", "wrepl_nbt_name"=> "struct nbt_name *", "ipv4address" => "const char *", -- cgit From 8fef2c8122a8d8ca522356353d30ed25dfd4c8fe Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 21 May 2006 15:01:47 +0000 Subject: r15778: Fix bug printing ref pointers. (This used to be commit 030272e79b621c2c54354f4c89cc25c202d2dbbc) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 5a8ef53e14..2797c6c490 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -702,13 +702,15 @@ sub ParseElementPrint($$$) foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { + if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) { pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);"; pidl "ndr->depth++;"; - if ($l->{POINTER_TYPE} ne "ref") { - pidl "if ($var_name) {"; - indent; + if ($l->{POINTER_TYPE} ne "ref") { + pidl "if ($var_name) {"; + indent; + } + $var_name = get_value_of($var_name); } - $var_name = get_value_of($var_name); } elsif ($l->{TYPE} eq "ARRAY") { my $length; @@ -757,11 +759,13 @@ sub ParseElementPrint($$$) foreach my $l (reverse @{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { - if ($l->{POINTER_TYPE} ne "ref") { - deindent; - pidl "}"; + if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) { + if ($l->{POINTER_TYPE} ne "ref") { + deindent; + pidl "}"; + } + pidl "ndr->depth--;"; } - pidl "ndr->depth--;"; } elsif (($l->{TYPE} eq "ARRAY") and not is_charset_array($e,$l) and not has_fast_array($e,$l)) { -- cgit From 03f520fd1232ef14eeb75af439685c6978db04e3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 21 May 2006 15:35:33 +0000 Subject: r15780: Fix indentation of deferred code (fixed #3739) (This used to be commit a7c9ec69b229db1b9c93b97133601231a2995c1b) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 2797c6c490..77482685b7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -103,7 +103,7 @@ sub get_value_of($) } my $res; -my $deferred = ""; +my $deferred = []; my $tabs = ""; #################################### @@ -128,14 +128,16 @@ sub pidl_hdr ($) { my $d = shift; $res_hdr .= "$d\n"; } # output buffer at the end of the structure/union/function # This is needed to cope with code that must be pushed back # to the end of a block of elements +my $defer_tabs = ""; +sub defer_indent() { $defer_tabs.="\t"; } +sub defer_deindent() { $defer_tabs=substr($defer_tabs, 0, -1); } + sub defer($) { my $d = shift; if ($d) { - $deferred .= $tabs; - $deferred .= $d; + push(@$deferred, $defer_tabs.$d); } - $deferred .="\n"; } ######################################## @@ -143,8 +145,9 @@ sub defer($) # output sub add_deferred() { - $res .= $deferred; - $deferred = ""; + pidl $_ foreach (@$deferred); + $deferred = []; + $defer_tabs = ""; } sub indent() @@ -370,16 +373,20 @@ sub ParseArrayPullHeader($$$$$) if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { my $size = ParseExpr($l->{SIZE_IS}, $env); defer "if ($var_name) {"; + defer_indent; check_null_pointer_deferred($size); defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"; + defer_deindent; defer "}"; } if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { my $length = ParseExpr($l->{LENGTH_IS}, $env); defer "if ($var_name) {"; + defer_indent; check_null_pointer_deferred($length); defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"; + defer_deindent; defer "}" } -- cgit From e3a6c6be79326578a1e9c7cb8547234eab62235f Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Thu, 8 Jun 2006 15:20:05 +0000 Subject: r16100: Patch from Michael Wood : s/then/than/ for correct grammar (This used to be commit 26a2fa97e4c819e630bc9b50e11c8d5328c7b8c8) --- source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm index 02319a0aa9..e7f2922c7f 100644 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm @@ -49,7 +49,7 @@ Generate a custom header field with specified properties. Force the use of new_hf_name when the parser generator was going to use old_hf_name. -This can be used in conjunction with HF_FIELD in order to make more then +This can be used in conjunction with HF_FIELD in order to make more than one element use the same filter name. =item I prefix @@ -78,7 +78,7 @@ Override the text shown when a bitmap boolean value is enabled or disabled. Force pidl to not generate a particular function but allow the user to write a function manually. This can be used to remove the function -for only one level for a particular element rather then all the functions and +for only one level for a particular element rather than all the functions and ett/hf variables for a particular element as the NOEMIT command does. =back diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm index a6b4b38cdf..57fa3867f7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm @@ -35,7 +35,7 @@ sub Align($$) { my ($a,$b) = @_; - # Only align if previous element was smaller then current one + # Only align if previous element was smaller than current one if ($$a < $b) { pidl "if (!prs_align_custom(ps, $b))"; pidl "\treturn False;"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 77482685b7..912c4b74f9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -836,7 +836,7 @@ sub ParseDataPush($$$$$) { my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; - # strings are passed by value rather then reference + # strings are passed by value rather than reference if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); } @@ -2101,7 +2101,7 @@ sub ParseFunctionPull($) } # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's - # own flag rather then be in NDR_IN ? + # own flag rather than be in NDR_IN ? foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); -- cgit From 927cbf74ae1c08876a717f739449177d03740f2e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 5 Jul 2006 20:49:50 +0000 Subject: r16824: Rename Ethereal -> Wireshark (patch from Joerg Mayer) (This used to be commit a789aa468b2b2b631289dd65888b352de46ad900) --- .../pidl/lib/Parse/Pidl/Ethereal/Conformance.pm | 360 ------- source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm | 1054 -------------------- .../pidl/lib/Parse/Pidl/Wireshark/Conformance.pm | 360 +++++++ source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 1054 ++++++++++++++++++++ 4 files changed, 1414 insertions(+), 1414 deletions(-) delete mode 100644 source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm deleted file mode 100644 index e7f2922c7f..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/Conformance.pm +++ /dev/null @@ -1,360 +0,0 @@ -################################################### -# parse an ethereal conformance file -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -=pod - -=head1 NAME - -Parse::Pidl::Ethereal::Conformance - Conformance file parser for Ethereal - -=head1 DESCRIPTION - -This module supports parsing Ethereal conformance files (*.cnf). - -=head1 FILE FORMAT - -Pidl needs additional data for ethereal output. This data is read from -so-called conformance files. This section describes the format of these -files. - -Conformance files are simple text files with a single command on each line. -Empty lines and lines starting with a '#' character are ignored. -Arguments to commands are seperated by spaces. - -The following commands are currently supported: - -=over 4 - -=item I name dissector ft_type base_type mask valsstring alignment - -Register new data type with specified name, what dissector function to call -and what properties to give header fields for elements of this type. - -=item I type - -Suppress emitting a dissect_type function for the specified type - -=item I type param - -Set parameter to specify to dissector function for given type. - -=item I hf title filter ft_type base_type valsstring mask description - -Generate a custom header field with specified properties. - -=item I old_hf_name new_hf_name - -Force the use of new_hf_name when the parser generator was going to -use old_hf_name. - -This can be used in conjunction with HF_FIELD in order to make more than -one element use the same filter name. - -=item I prefix - -Remove the specified prefix from all function names (if present). - -=item I longname shortname filtername - -Change the short-, long- and filter-name for the current interface in -Ethereal. - -=item I field desc - -Change description for the specified header field. `field' is the hf name of the field. - -=item I dissector code... - -Code to insert when generating the specified dissector. @HF@ and -@PARAM@ will be substituted. - -=item I hf_name "true string" "false string" - -Override the text shown when a bitmap boolean value is enabled or disabled. - -=item I fn_name - -Force pidl to not generate a particular function but allow the user -to write a function manually. This can be used to remove the function -for only one level for a particular element rather than all the functions and -ett/hf variables for a particular element as the NOEMIT command does. - -=back - -=head1 EXAMPLE - - INFO_KEY OpenKey.Ke - -=cut - -package Parse::Pidl::Ethereal::Conformance; - -require Exporter; -use vars qw($VERSION); -$VERSION = '0.01'; - -@ISA = qw(Exporter); -@EXPORT_OK = qw(ReadConformance); - -use strict; - -use Parse::Pidl::Util qw(has_property); - -sub handle_type($$$$$$$$$$) -{ - my ($pos,$data,$name,$dissectorname,$ft_type,$base_type,$mask,$valsstring,$alignment) = @_; - - unless(defined($alignment)) { - print "$pos: error incomplete TYPE command\n"; - return; - } - - unless ($dissectorname =~ /.*dissect_.*/) { - print "$pos: warning: dissector name does not contain `dissect'\n"; - } - - unless(valid_ft_type($ft_type)) { - print "$pos: warning: invalid FT_TYPE `$ft_type'\n"; - } - - unless (valid_base_type($base_type)) { - print "$pos: warning: invalid BASE_TYPE `$base_type'\n"; - } - - $data->{types}->{$name} = { - NAME => $name, - POS => $pos, - USED => 0, - DISSECTOR_NAME => $dissectorname, - FT_TYPE => $ft_type, - BASE_TYPE => $base_type, - MASK => $mask, - VALSSTRING => $valsstring, - ALIGNMENT => $alignment - }; -} - -sub handle_tfs($$$$$) -{ - my ($pos,$data,$hf,$trues,$falses) = @_; - - unless(defined($falses)) { - print "$pos: error: incomplete TFS command\n"; - return; - } - - $data->{tfs}->{$hf} = { - TRUE_STRING => $trues, - FALSE_STRING => $falses - }; -} - -sub handle_hf_rename($$$$) -{ - my ($pos,$data,$old,$new) = @_; - - unless(defined($new)) { - print "$pos: error: incomplete HF_RENAME command\n"; - return; - } - - $data->{hf_renames}->{$old} = { - OLDNAME => $old, - NEWNAME => $new, - POS => $pos, - USED => 0 - }; -} - -sub handle_param_value($$$$) -{ - my ($pos,$data,$dissector_name,$value) = @_; - - unless(defined($value)) { - print "$pos: error: incomplete PARAM_VALUE command\n"; - return; - } - - $data->{dissectorparams}->{$dissector_name} = { - DISSECTOR => $dissector_name, - PARAM => $value, - POS => $pos, - USED => 0 - }; -} - -sub valid_base_type($) -{ - my $t = shift; - return 0 unless($t =~ /^BASE_.*/); - return 1; -} - -sub valid_ft_type($) -{ - my $t = shift; - return 0 unless($t =~ /^FT_.*/); - return 1; -} - -sub handle_hf_field($$$$$$$$$$) -{ - my ($pos,$data,$index,$name,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; - - unless(defined($blurb)) { - print "$pos: error: incomplete HF_FIELD command\n"; - return; - } - - unless(valid_ft_type($ft_type)) { - print "$pos: warning: invalid FT_TYPE `$ft_type'\n"; - } - - unless(valid_base_type($base_type)) { - print "$pos: warning: invalid BASE_TYPE `$base_type'\n"; - } - - $data->{header_fields}->{$index} = { - INDEX => $index, - POS => $pos, - USED => 0, - NAME => $name, - FILTER => $filter, - FT_TYPE => $ft_type, - BASE_TYPE => $base_type, - VALSSTRING => $valsstring, - MASK => $mask, - BLURB => $blurb - }; -} - -sub handle_strip_prefix($$$) -{ - my ($pos,$data,$x) = @_; - - push (@{$data->{strip_prefixes}}, $x); -} - -sub handle_noemit($$$) -{ - my ($pos,$data,$type) = @_; - - if (defined($type)) { - $data->{noemit}->{$type} = 1; - } else { - $data->{noemit_dissector} = 1; - } -} - -sub handle_manual($$$) -{ - my ($pos,$data,$fn) = @_; - - $data->{manual}->{$fn} = 1; -} - -sub handle_protocol($$$$$$) -{ - my ($pos, $data, $name, $longname, $shortname, $filtername) = @_; - - $data->{protocols}->{$name} = { - LONGNAME => $longname, - SHORTNAME => $shortname, - FILTERNAME => $filtername - }; -} - -sub handle_fielddescription($$$$) -{ - my ($pos,$data,$field,$desc) = @_; - - $data->{fielddescription}->{$field} = { - DESCRIPTION => $desc, - POS => $pos, - USED => 0 - }; -} - -sub handle_import -{ - my $pos = shift @_; - my $data = shift @_; - my $dissectorname = shift @_; - - unless(defined($dissectorname)) { - print "$pos: error: no dissectorname specified\n"; - return; - } - - $data->{imports}->{$dissectorname} = { - NAME => $dissectorname, - DATA => join(' ', @_), - USED => 0, - POS => $pos - }; -} - -my %field_handlers = ( - TYPE => \&handle_type, - NOEMIT => \&handle_noemit, - MANUAL => \&handle_manual, - PARAM_VALUE => \&handle_param_value, - HF_FIELD => \&handle_hf_field, - HF_RENAME => \&handle_hf_rename, - TFS => \&handle_tfs, - STRIP_PREFIX => \&handle_strip_prefix, - PROTOCOL => \&handle_protocol, - FIELD_DESCRIPTION => \&handle_fielddescription, - IMPORT => \&handle_import -); - -sub ReadConformance($$) -{ - my ($f,$data) = @_; - - $data->{override} = ""; - - my $incodeblock = 0; - - open(IN,"<$f") or return undef; - - my $ln = 0; - - foreach () { - $ln++; - next if (/^#.*$/); - next if (/^$/); - - s/[\r\n]//g; - - if ($_ eq "CODE START") { - $incodeblock = 1; - next; - } elsif ($incodeblock and $_ eq "CODE END") { - $incodeblock = 0; - next; - } elsif ($incodeblock) { - $data->{override}.="$_\n"; - next; - } - - my @fields = /([^ "]+|"[^"]+")/g; - - my $cmd = $fields[0]; - - shift @fields; - - if (not defined($field_handlers{$cmd})) { - print "$f:$ln: Warning: Unknown command `$cmd'\n"; - next; - } - - $field_handlers{$cmd}("$f:$ln", $data, @fields); - } - - close(IN); -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm deleted file mode 100644 index 685cb5a12a..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Ethereal/NDR.pm +++ /dev/null @@ -1,1054 +0,0 @@ -################################################## -# Samba4 NDR parser generator for IDL structures -# Copyright tridge@samba.org 2000-2003 -# Copyright tpot@samba.org 2001,2005 -# Copyright jelmer@samba.org 2004-2005 -# Portions based on idl2eth.c by Ronnie Sahlberg -# released under the GNU GPL - -=pod - -=head1 NAME - -Parse::Pidl::Ethereal::NDR - Parser generator for Ethereal - -=cut - -package Parse::Pidl::Ethereal::NDR; - -use strict; -use Parse::Pidl::Typelist qw(getType); -use Parse::Pidl::Util qw(has_property ParseExpr property_matches make_str); -use Parse::Pidl::NDR qw(ContainsString GetNextLevel); -use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); -use Parse::Pidl::Ethereal::Conformance qw(ReadConformance); -use File::Basename; - -use vars qw($VERSION); -$VERSION = '0.01'; - -sub error($$) -{ - my ($e,$t) = @_; - print "$e->{FILE}:$e->{LINE}: $t\n"; -} - -my @ett; - -my %hf_used = (); -my %dissector_used = (); - -my $conformance = undef; - -my %ptrtype_mappings = ( - "unique" => "NDR_POINTER_UNIQUE", - "ref" => "NDR_POINTER_REF", - "ptr" => "NDR_POINTER_PTR" -); - -sub StripPrefixes($) -{ - my ($s) = @_; - - foreach (@{$conformance->{strip_prefixes}}) { - $s =~ s/^$_\_//g; - } - - return $s; -} - -# Convert a IDL structure field name (e.g access_mask) to a prettier -# string like 'Access Mask'. - -sub field2name($) -{ - my($field) = shift; - - $field =~ s/_/ /g; # Replace underscores with spaces - $field =~ s/(\w+)/\u\L$1/g; # Capitalise each word - - return $field; -} - -my %res = (); -my $tabs = ""; -my $cur_fn = undef; -sub pidl_fn_start($) -{ - my $fn = shift; - $cur_fn = $fn; -} -sub pidl_fn_end($) -{ - my $fn = shift; - die("Inconsistent state: $fn != $cur_fn") if ($fn ne $cur_fn); - $cur_fn = undef; -} - -sub pidl_code($) -{ - my $d = shift; - return if (defined($cur_fn) and defined($conformance->{manual}->{$cur_fn})); - - if ($d) { - $res{code} .= $tabs; - $res{code} .= $d; - } - $res{code} .="\n"; -} - -sub pidl_hdr($) { my $x = shift; $res{hdr} .= "$x\n"; } -sub pidl_def($) { my $x = shift; $res{def} .= "$x\n"; } - -sub indent() -{ - $tabs .= "\t"; -} - -sub deindent() -{ - $tabs = substr($tabs, 0, -1); -} - -sub PrintIdl($) -{ - my $idl = shift; - - foreach (split /\n/, $idl) { - pidl_code "/* IDL: $_ */"; - } - - pidl_code ""; -} - -##################################################################### -# parse the interface definitions -sub Interface($) -{ - my($interface) = @_; - Const($_,$interface->{NAME}) foreach (@{$interface->{CONSTS}}); - Typedef($_,$interface->{NAME}) foreach (@{$interface->{TYPES}}); - Function($_,$interface->{NAME}) foreach (@{$interface->{FUNCTIONS}}); -} - -sub Enum($$$) -{ - my ($e,$name,$ifname) = @_; - my $valsstring = "$ifname\_$name\_vals"; - my $dissectorname = "$ifname\_dissect\_enum\_".StripPrefixes($name); - - return if (defined($conformance->{noemit}->{StripPrefixes($name)})); - - foreach (@{$e->{ELEMENTS}}) { - if (/([^=]*)=(.*)/) { - pidl_hdr "#define $1 ($2)"; - } - } - - pidl_hdr "extern const value_string $valsstring\[];"; - pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; - - pidl_def "const value_string ".$valsstring."[] = {"; - foreach (@{$e->{ELEMENTS}}) { - next unless (/([^=]*)=(.*)/); - pidl_def "\t{ $1, \"$1\" },"; - } - - pidl_def "{ 0, NULL }"; - pidl_def "};"; - - pidl_fn_start $dissectorname; - pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)"; - pidl_code "{"; - indent; - pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, NULL);"; - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end $dissectorname; - - my $enum_size = $e->{BASE_TYPE}; - $enum_size =~ s/uint//g; - register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$enum_size", "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8); -} - -sub Bitmap($$$) -{ - my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_bitmap\_".StripPrefixes($name); - - register_ett("ett_$ifname\_$name"); - - pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; - - pidl_fn_start $dissectorname; - pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; - pidl_code "{"; - indent; - pidl_code "proto_item *item = NULL;"; - pidl_code "proto_tree *tree = NULL;"; - pidl_code ""; - - pidl_code "g$e->{BASE_TYPE} flags;"; - if ($e->{ALIGN} > 1) { - pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; - } - - pidl_code ""; - - pidl_code "if (parent_tree) {"; - indent; - pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);"; - pidl_code "tree = proto_item_add_subtree(item,ett_$ifname\_$name);"; - deindent; - pidl_code "}\n"; - - pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);"; - - pidl_code "proto_item_append_text(item, \": \");\n"; - pidl_code "if (!flags)"; - pidl_code "\tproto_item_append_text(item, \"(No values set)\");\n"; - - foreach (@{$e->{ELEMENTS}}) { - next unless (/([^ ]*) (.*)/); - my ($en,$ev) = ($1,$2); - my $hf_bitname = "hf_$ifname\_$name\_$en"; - my $filtername = "$ifname\.$name\.$en"; - - $hf_used{$hf_bitname} = 1; - - register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, ""); - - pidl_def "static const true_false_string $name\_$en\_tfs = {"; - if (defined($conformance->{tfs}->{$hf_bitname})) { - pidl_def " $conformance->{tfs}->{$hf_bitname}->{TRUE_STRING},"; - pidl_def " $conformance->{tfs}->{$hf_bitname}->{FALSE_STRING},"; - $conformance->{tfs}->{$hf_bitname}->{USED} = 1; - } else { - pidl_def " \"$en is SET\","; - pidl_def " \"$en is NOT SET\","; - } - pidl_def "};"; - - pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);"; - pidl_code "if (flags&$ev){"; - pidl_code "\tproto_item_append_text(item, \"$en\");"; - pidl_code "\tif (flags & (~$ev))"; - pidl_code "\t\tproto_item_append_text(item, \", \");"; - pidl_code "}"; - pidl_code "flags&=(~$ev);"; - pidl_code ""; - } - - pidl_code "if (flags) {"; - pidl_code "\tproto_item_append_text(item, \"Unknown bitmap value 0x%x\", flags);"; - pidl_code "}\n"; - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end $dissectorname; - - my $size = $e->{BASE_TYPE}; - $size =~ s/uint//g; - register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$size", "BASE_HEX", "0", "NULL", $size/8); -} - -sub ElementLevel($$$$$) -{ - my ($e,$l,$hf,$myname,$pn) = @_; - - my $param = 0; - - if (defined($conformance->{dissectorparams}->{$myname})) { - $conformance->{dissectorparams}->{$myname}->{PARAM} = 1; - $param = $conformance->{dissectorparams}->{$myname}->{PARAM}; - } - - if ($l->{TYPE} eq "POINTER") { - my $type; - if ($l->{LEVEL} eq "TOP") { - $type = "toplevel"; - } elsif ($l->{LEVEL} eq "EMBEDDED") { - $type = "embedded"; - } - pidl_code "offset = dissect_ndr_$type\_pointer(tvb, offset, pinfo, tree, drep, $myname\_, $ptrtype_mappings{$l->{POINTER_TYPE}}, \"Pointer to ".field2name(StripPrefixes($e->{NAME})) . " ($e->{TYPE})\",$hf);"; - } elsif ($l->{TYPE} eq "ARRAY") { - if ($l->{IS_INLINE}) { - error($e->{ORIGINAL}, "Inline arrays not supported"); - } elsif ($l->{IS_FIXED}) { - pidl_code "int i;"; - pidl_code "for (i = 0; i < $l->{SIZE_IS}; i++)"; - pidl_code "\toffset = $myname\_(tvb, offset, pinfo, tree, drep);"; - } else { - my $type = ""; - $type .= "c" if ($l->{IS_CONFORMANT}); - $type .= "v" if ($l->{IS_VARYING}); - - unless ($l->{IS_ZERO_TERMINATED}) { - pidl_code "offset = dissect_ndr_u" . $type . "array(tvb, offset, pinfo, tree, drep, $myname\_);"; - } else { - my $nl = GetNextLevel($e,$l); - pidl_code "char *data;"; - pidl_code ""; - pidl_code "offset = dissect_ndr_$type" . "string(tvb, offset, pinfo, tree, drep, sizeof(g$nl->{DATA_TYPE}), $hf, FALSE, &data);"; - pidl_code "proto_item_append_text(tree, \": %s\", data);"; - } - } - } elsif ($l->{TYPE} eq "DATA") { - if ($l->{DATA_TYPE} eq "string") { - my $bs = 2; # Byte size defaults to that of UCS2 - - - ($bs = 1) if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_ASCII.*")); - - if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) { - pidl_code "char *data;\n"; - pidl_code "offset = dissect_ndr_cvstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, &data);"; - pidl_code "proto_item_append_text(tree, \": %s\", data);"; - } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*")) { - pidl_code "offset = dissect_ndr_vstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, NULL);"; - } else { - warn("Unable to handle string with flags $e->{PROPERTIES}->{flag}"); - } - } else { - my $call; - - if ($conformance->{imports}->{$l->{DATA_TYPE}}) { - $call = $conformance->{imports}->{$l->{DATA_TYPE}}->{DATA}; - $conformance->{imports}->{$l->{DATA_TYPE}}->{USED} = 1; - } elsif (defined($conformance->{imports}->{"$pn.$e->{NAME}"})) { - $call = $conformance->{imports}->{"$pn.$e->{NAME}"}->{DATA}; - $conformance->{imports}->{"$pn.$e->{NAME}"}->{USED} = 1; - - } elsif (defined($conformance->{types}->{$l->{DATA_TYPE}})) { - $call= $conformance->{types}->{$l->{DATA_TYPE}}->{DISSECTOR_NAME}; - $conformance->{types}->{$l->{DATA_TYPE}}->{USED} = 1; - } else { - if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/) - { - pidl_code "offset = $1_dissect_struct_$2(tvb,offset,pinfo,tree,drep,$hf,$param);"; - } - - return; - } - - $call =~ s/\@HF\@/$hf/g; - $call =~ s/\@PARAM\@/$param/g; - pidl_code "$call"; - } - } elsif ($_->{TYPE} eq "SUBCONTEXT") { - my $num_bits = ($l->{HEADER_SIZE}*8); - pidl_code "guint$num_bits size;"; - pidl_code "int start_offset = offset;"; - pidl_code "tvbuff_t *subtvb;"; - pidl_code "offset = dissect_ndr_uint$num_bits(tvb, offset, pinfo, tree, drep, $hf, &size);"; - pidl_code "proto_tree_add_text(tree, tvb, start_offset, offset - start_offset + size, \"Subcontext size\");"; - - pidl_code "subtvb = tvb_new_subset(tvb, offset, size, -1);"; - pidl_code "$myname\_(subtvb, 0, pinfo, tree, drep);"; - } else { - die("Unknown type `$_->{TYPE}'"); - } -} - -sub Element($$$) -{ - my ($e,$pn,$ifname) = @_; - - my $dissectorname = "$ifname\_dissect\_element\_".StripPrefixes($pn)."\_".StripPrefixes($e->{NAME}); - - my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; - - my $type = find_type($e->{TYPE}); - - if (not defined($type)) { - # default settings - $type = { - MASK => 0, - VALSSTRING => "NULL", - FT_TYPE => "FT_NONE", - BASE_TYPE => "BASE_HEX" - }; - } - - if (ContainsString($e)) { - $type = { - MASK => 0, - VALSSTRING => "NULL", - FT_TYPE => "FT_STRING", - BASE_TYPE => "BASE_DEC" - }; - } - - my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", $type->{FT_TYPE}, $type->{BASE_TYPE}, $type->{VALSSTRING}, $type->{MASK}, ""); - $hf_used{$hf} = 1; - - my $eltname = StripPrefixes($pn) . ".$e->{NAME}"; - if (defined($conformance->{noemit}->{$eltname})) { - return $call_code; - } - - my $add = ""; - - foreach (@{$e->{LEVELS}}) { - next if ($_->{TYPE} eq "SWITCH"); - pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);"; - pidl_fn_start "$dissectorname$add"; - pidl_code "static int"; - pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)"; - pidl_code "{"; - indent; - - ElementLevel($e,$_,$hf,$dissectorname.$add,$pn); - - pidl_code ""; - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end "$dissectorname$add"; - $add.="_"; - last if ($_->{TYPE} eq "ARRAY" and $_->{IS_ZERO_TERMINATED}); - } - - return $call_code; -} - -sub Function($$$) -{ - my ($fn,$ifname) = @_; - - my %dissectornames; - - foreach (@{$fn->{ELEMENTS}}) { - $dissectornames{$_->{NAME}} = Element($_, $fn->{NAME}, $ifname) if not defined($dissectornames{$_->{NAME}}); - } - - my $fn_name = $_->{NAME}; - $fn_name =~ s/^${ifname}_//; - - PrintIdl DumpFunction($fn->{ORIGINAL}); - pidl_fn_start "$ifname\_dissect\_$fn_name\_response"; - pidl_code "static int"; - pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; - pidl_code "{"; - indent; - pidl_code "guint32 status;\n"; - foreach (@{$fn->{ELEMENTS}}) { - if (grep(/out/,@{$_->{DIRECTION}})) { - pidl_code "$dissectornames{$_->{NAME}}"; - pidl_code "offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"; - pidl_code ""; - } - } - - if (not defined($fn->{RETURN_TYPE})) { - } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { - pidl_code "offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, &status);\n"; - pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; - pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, NT_errors, \"Unknown NT status 0x%08x\"));\n"; - $hf_used{"hf\_$ifname\_status"} = 1; - } elsif ($fn->{RETURN_TYPE} eq "WERROR") { - pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, &status);\n"; - pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; - pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, DOS_errors, \"Unknown DOS error 0x%08x\"));\n"; - - $hf_used{"hf\_$ifname\_werror"} = 1; - } else { - print "$fn->{FILE}:$fn->{LINE}: error: return type `$fn->{RETURN_TYPE}' not yet supported\n"; - } - - - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end "$ifname\_dissect\_$fn_name\_response"; - - pidl_fn_start "$ifname\_dissect\_$fn_name\_request"; - pidl_code "static int"; - pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; - pidl_code "{"; - indent; - foreach (@{$fn->{ELEMENTS}}) { - if (grep(/in/,@{$_->{DIRECTION}})) { - pidl_code "$dissectornames{$_->{NAME}}"; - pidl_code "offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"; - } - - } - - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end "$ifname\_dissect\_$fn_name\_request"; -} - -sub Struct($$$) -{ - my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_struct\_".StripPrefixes($name); - - return if (defined($conformance->{noemit}->{StripPrefixes($name)})); - - register_ett("ett_$ifname\_$name"); - - my $res = ""; - ($res.="\t".Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}}); - - pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_);"; - - pidl_fn_start $dissectorname; - pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; - pidl_code "{"; - indent; - pidl_code "proto_item *item = NULL;"; - pidl_code "proto_tree *tree = NULL;"; - pidl_code "int old_offset;"; - pidl_code ""; - - if ($e->{ALIGN} > 1) { - pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; - } - pidl_code ""; - - pidl_code "old_offset = offset;"; - pidl_code ""; - pidl_code "if (parent_tree) {"; - indent; - pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);"; - pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; - deindent; - pidl_code "}"; - - pidl_code "\n$res"; - - pidl_code "proto_item_set_len(item, offset-old_offset);\n"; - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end $dissectorname; - - register_type($name, "offset = $dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); -} - -sub Union($$$) -{ - my ($e,$name,$ifname) = @_; - - my $dissectorname = "$ifname\_dissect_".StripPrefixes($name); - - return if (defined($conformance->{noemit}->{StripPrefixes($name)})); - - register_ett("ett_$ifname\_$name"); - - my $res = ""; - foreach (@{$e->{ELEMENTS}}) { - $res.="\n\t\t$_->{CASE}:\n"; - if ($_->{TYPE} ne "EMPTY") { - $res.="\t\t\t".Element($_, $name, $ifname)."\n"; - } - $res.="\t\tbreak;\n"; - } - - my $switch_type; - my $switch_dissect; - my $switch_dt = getType($e->{SWITCH_TYPE}); - if ($switch_dt->{DATA}->{TYPE} eq "ENUM") { - $switch_type = "g".Parse::Pidl::Typelist::enum_type_fn($switch_dt); - $switch_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($switch_dt); - } elsif ($switch_dt->{DATA}->{TYPE} eq "SCALAR") { - $switch_type = "g$e->{SWITCH_TYPE}"; - $switch_dissect = "dissect_ndr_$e->{SWITCH_TYPE}"; - } - - pidl_fn_start $dissectorname; - pidl_code "static int"; - pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; - pidl_code "{"; - indent; - pidl_code "proto_item *item = NULL;"; - pidl_code "proto_tree *tree = NULL;"; - pidl_code "int old_offset;"; - pidl_code "$switch_type level;"; - pidl_code ""; - - if ($e->{ALIGN} > 1) { - pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; - } - - pidl_code ""; - - pidl_code "old_offset = offset;"; - pidl_code "if (parent_tree) {"; - indent; - pidl_code "item = proto_tree_add_text(parent_tree, tvb, offset, -1, \"$name\");"; - pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; - deindent; - pidl_code "}"; - - pidl_code ""; - - pidl_code "offset = $switch_dissect(tvb, offset, pinfo, tree, drep, hf_index, &level);"; - - pidl_code "switch(level) {$res\t}"; - pidl_code "proto_item_set_len(item, offset-old_offset);\n"; - pidl_code "return offset;"; - deindent; - pidl_code "}"; - pidl_fn_end $dissectorname; - - register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); -} - -sub Const($$) -{ - my ($const,$ifname) = @_; - - if (!defined($const->{ARRAY_LEN}[0])) { - pidl_hdr "#define $const->{NAME}\t( $const->{VALUE} )\n"; - } else { - pidl_hdr "#define $const->{NAME}\t $const->{VALUE}\n"; - } -} - -sub Typedef($$) -{ - my ($e,$ifname) = @_; - - PrintIdl DumpTypedef($e->{ORIGINAL}); - - { - ENUM => \&Enum, - STRUCT => \&Struct, - UNION => \&Union, - BITMAP => \&Bitmap - }->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $ifname); -} - -sub RegisterInterface($) -{ - my ($x) = @_; - - pidl_fn_start "proto_register_dcerpc_$x->{NAME}"; - pidl_code "void proto_register_dcerpc_$x->{NAME}(void)"; - pidl_code "{"; - indent; - - $res{code}.=DumpHfList()."\n"; - $res{code}.="\n".DumpEttList()."\n"; - - if (defined($x->{UUID})) { - # These can be changed to non-pidl_code names if the old dissectors - # in epan/dissctors are deleted. - - my $name = uc($x->{NAME}) . " (pidl)"; - my $short_name = uc($x->{NAME}); - my $filter_name = $x->{NAME}; - - if (has_property($x, "helpstring")) { - $name = $x->{PROPERTIES}->{helpstring}; - } - - if (defined($conformance->{protocols}->{$x->{NAME}})) { - $short_name = $conformance->{protocols}->{$x->{NAME}}->{SHORTNAME}; - $name = $conformance->{protocols}->{$x->{NAME}}->{LONGNAME}; - $filter_name = $conformance->{protocols}->{$x->{NAME}}->{FILTERNAME}; - } - - pidl_code "proto_dcerpc_$x->{NAME} = proto_register_protocol(".make_str($name).", ".make_str($short_name).", ".make_str($filter_name).");"; - - pidl_code "proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));"; - pidl_code "proto_register_subtree_array(ett, array_length(ett));"; - } else { - pidl_code "proto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");"; - pidl_code "proto_register_field_array(proto_dcerpc, hf, array_length(hf));"; - pidl_code "proto_register_subtree_array(ett, array_length(ett));"; - } - - deindent; - pidl_code "}\n"; - pidl_fn_end "proto_register_dcerpc_$x->{NAME}"; -} - -sub RegisterInterfaceHandoff($) -{ - my $x = shift; - - if (defined($x->{UUID})) { - pidl_fn_start "proto_reg_handoff_dcerpc_$x->{NAME}"; - pidl_code "void proto_reg_handoff_dcerpc_$x->{NAME}(void)"; - pidl_code "{"; - indent; - pidl_code "dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},"; - pidl_code "\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},"; - pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);"; - deindent; - pidl_code "}"; - pidl_fn_end "proto_reg_handoff_dcerpc_$x->{NAME}"; - - $hf_used{"hf_$x->{NAME}_opnum"} = 1; - } -} - -sub ProcessInterface($) -{ - my ($x) = @_; - - push(@{$conformance->{strip_prefixes}}, $x->{NAME}); - - my $define = "__PACKET_DCERPC_" . uc($_->{NAME}) . "_H"; - pidl_hdr "#ifndef $define"; - pidl_hdr "#define $define"; - pidl_hdr ""; - - if (defined $x->{PROPERTIES}->{depends}) { - foreach (split / /, $x->{PROPERTIES}->{depends}) { - next if($_ eq "security"); - pidl_hdr "#include \"packet-dcerpc-$_\.h\"\n"; - } - } - - pidl_def "static gint proto_dcerpc_$x->{NAME} = -1;"; - register_ett("ett_dcerpc_$x->{NAME}"); - register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, ""); - - if (defined($x->{UUID})) { - my $if_uuid = $x->{UUID}; - - pidl_def "/* Version information */\n\n"; - - pidl_def "static e_uuid_t uuid_dcerpc_$x->{NAME} = {"; - pidl_def "\t0x" . substr($if_uuid, 1, 8) - . ", 0x" . substr($if_uuid, 10, 4) - . ", 0x" . substr($if_uuid, 15, 4) . ","; - pidl_def "\t{ 0x" . substr($if_uuid, 20, 2) - . ", 0x" . substr($if_uuid, 22, 2) - . ", 0x" . substr($if_uuid, 25, 2) - . ", 0x" . substr($if_uuid, 27, 2) - . ", 0x" . substr($if_uuid, 29, 2) - . ", 0x" . substr($if_uuid, 31, 2) - . ", 0x" . substr($if_uuid, 33, 2) - . ", 0x" . substr($if_uuid, 35, 2) . " }"; - pidl_def "};"; - - my $maj = $x->{VERSION}; - $maj =~ s/\.(.*)$//g; - pidl_def "static guint16 ver_dcerpc_$x->{NAME} = $maj;"; - pidl_def ""; - } - - Interface($x); - - pidl_code "\n".DumpFunctionTable($x); - - # Only register these two return types if they were actually used - if (defined($hf_used{"hf_$x->{NAME}_status"})) { - register_hf_field("hf_$x->{NAME}_status", "Status", "$x->{NAME}.status", "FT_UINT32", "BASE_HEX", "VALS(NT_errors)", 0, ""); - } - - if (defined($hf_used{"hf_$x->{NAME}_werror"})) { - register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "VALS(DOS_errors)", 0, ""); - } - - RegisterInterface($x); - RegisterInterfaceHandoff($x); - - pidl_hdr "#endif /* $define */"; -} - -sub find_type($) -{ - my $n = shift; - - return $conformance->{types}->{$n}; -} - -sub register_type($$$$$$$) -{ - my ($type,$call,$ft,$base,$mask,$vals,$length) = @_; - - $conformance->{types}->{$type} = { - NAME => $type, - DISSECTOR_NAME => $call, - FT_TYPE => $ft, - BASE_TYPE => $base, - MASK => $mask, - VALSSTRING => $vals, - ALIGNMENT => $length - }; -} - -# Loads the default types -sub Initialize($) -{ - my $cnf_file = shift; - - $conformance = { - imports => {}, - header_fields=> {} - }; - - ReadConformance($cnf_file, $conformance) or print "Warning: No conformance file `$cnf_file'\n"; - - foreach my $bytes (qw(1 2 4 8)) { - my $bits = $bytes * 8; - register_type("uint$bits", "offset = dissect_ndr_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@,NULL);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes); - register_type("int$bits", "offset = dissect_ndr_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes); - } - - register_type("udlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4); - register_type("bool8", "offset = dissect_ndr_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); - register_type("char", "offset = dissect_ndr_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); - register_type("long", "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4); - register_type("dlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8); - register_type("GUID", "offset = dissect_ndr_uuid_t(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4); - register_type("policy_handle", "offset = dissect_nt_policy_hnd(tvb, offset, pinfo, tree, drep, \@HF\@, NULL, NULL, \@PARAM\@&0x01, \@PARAM\@&0x02);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); - register_type("NTTIME", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); - register_type("NTTIME_hyper", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); - register_type("time_t", "offset = dissect_ndr_time_t(tvb, offset, pinfo,tree, drep, \@HF\@, NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4); - register_type("NTTIME_1sec", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); - register_type("SID", " - dcerpc_info *di = (dcerpc_info *)pinfo->private_data; - - di->hf_index = \@HF\@; - - offset = dissect_ndr_nt_SID_with_options(tvb, offset, pinfo, tree, drep, param); - ","FT_STRING", "BASE_DEC", 0, "NULL", 4); - register_type("WERROR", - "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4); - -} - -##################################################################### -# Generate ethereal parser and header code -sub Parse($$$$) -{ - my($ndr,$idl_file,$h_filename,$cnf_file) = @_; - Initialize($cnf_file); - - return (undef, undef) if defined($conformance->{noemit_dissector}); - - $tabs = ""; - - %res = (code=>"",def=>"",hdr=>""); - @ett = (); - - my $notice = -"/* DO NOT EDIT - This filter was automatically generated - from $idl_file and $cnf_file. - - Pidl is a perl based IDL compiler for DCE/RPC idl files. - It is maintained by the Samba team, not the Ethereal team. - Instructions on how to download and install Pidl can be - found at http://wiki.ethereal.com/Pidl -*/ - -"; - - pidl_hdr $notice; - - $res{headers} = "\n"; - $res{headers} .= "#ifdef HAVE_CONFIG_H\n"; - $res{headers} .= "#include \"config.h\"\n"; - $res{headers} .= "#endif\n\n"; - $res{headers} .= "#include \n"; - $res{headers} .= "#include \n"; - $res{headers} .= "#include \n\n"; - - $res{headers} .= "#include \"packet-dcerpc.h\"\n"; - $res{headers} .= "#include \"packet-dcerpc-nt.h\"\n"; - $res{headers} .= "#include \"packet-windows-common.h\"\n"; - - my $h_basename = basename($h_filename); - - $res{headers} .= "#include \"$h_basename\"\n"; - pidl_code ""; - - # Ethereal protocol registration - - ProcessInterface($_) foreach (@$ndr); - - $res{ett} = DumpEttDeclaration(); - $res{hf} = DumpHfDeclaration(); - - my $parser = $notice; - $parser.= $res{headers}; - $parser.=$res{ett}; - $parser.=$res{hf}; - $parser.=$res{def}; - $parser.=$conformance->{override}; - $parser.=$res{code}; - - my $header = "/* autogenerated by pidl */\n\n"; - $header.=$res{hdr}; - - CheckUsed($conformance); - - return ($parser,$header); -} - -############################################################################### -# ETT -############################################################################### - -sub register_ett($) -{ - my $name = shift; - - push (@ett, $name); -} - -sub DumpEttList() -{ - my $res = "\tstatic gint *ett[] = {\n"; - foreach (@ett) { - $res .= "\t\t&$_,\n"; - } - - return "$res\t};\n"; -} - -sub DumpEttDeclaration() -{ - my $res = "\n/* Ett declarations */\n"; - foreach (@ett) { - $res .= "static gint $_ = -1;\n"; - } - - return "$res\n"; -} - -############################################################################### -# HF -############################################################################### - -sub register_hf_field($$$$$$$$) -{ - my ($index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; - - if (defined ($conformance->{hf_renames}->{$index})) { - $conformance->{hf_renames}->{$index}->{USED} = 1; - return $conformance->{hf_renames}->{$index}->{NEWNAME}; - } - - $conformance->{header_fields}->{$index} = { - INDEX => $index, - NAME => $name, - FILTER => $filter_name, - FT_TYPE => $ft_type, - BASE_TYPE => $base_type, - VALSSTRING => $valsstring, - MASK => $mask, - BLURB => $blurb - }; - - if ((not defined($blurb) or $blurb eq "") and - defined($conformance->{fielddescription}->{$index})) { - $conformance->{header_fields}->{$index}->{BLURB} = - $conformance->{fielddescription}->{$index}->{DESCRIPTION}; - $conformance->{fielddescription}->{$index}->{USED} = 1; - } - - return $index; -} - -sub DumpHfDeclaration() -{ - my $res = ""; - - $res = "\n/* Header field declarations */\n"; - - foreach (keys %{$conformance->{header_fields}}) - { - $res .= "static gint $_ = -1;\n"; - } - - return "$res\n"; -} - -sub DumpHfList() -{ - my $res = "\tstatic hf_register_info hf[] = {\n"; - - foreach (values %{$conformance->{header_fields}}) - { - $res .= "\t{ &$_->{INDEX}, - { ".make_str($_->{NAME}).", ".make_str($_->{FILTER}).", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALSSTRING}, $_->{MASK}, ".make_str($_->{BLURB}).", HFILL }}, -"; - } - - return $res."\t};\n"; -} - - -############################################################################### -# Function table -############################################################################### - -sub DumpFunctionTable($) -{ - my $if = shift; - - my $res = "static dcerpc_sub_dissector $if->{NAME}\_dissectors[] = {\n"; - foreach (@{$if->{FUNCTIONS}}) { - my $fn_name = $_->{NAME}; - $fn_name =~ s/^$if->{NAME}_//; - $res.= "\t{ $_->{OPNUM}, \"$fn_name\",\n"; - $res.= "\t $if->{NAME}_dissect_${fn_name}_request, $if->{NAME}_dissect_${fn_name}_response},\n"; - } - - $res .= "\t{ 0, NULL, NULL, NULL }\n"; - - return "$res};\n"; -} - -sub CheckUsed($) -{ - my $conformance = shift; - foreach (values %{$conformance->{header_fields}}) { - if (not defined($hf_used{$_->{INDEX}})) { - print "$_->{POS}: warning: hf field `$_->{INDEX}' not used\n"; - } - } - - foreach (values %{$conformance->{hf_renames}}) { - if (not $_->{USED}) { - print "$_->{POS}: warning: hf field `$_->{OLDNAME}' not used\n"; - } - } - - foreach (values %{$conformance->{dissectorparams}}) { - if (not $_->{USED}) { - print "$_->{POS}: warning: dissector param never used\n"; - } - } - - foreach (values %{$conformance->{imports}}) { - if (not $_->{USED}) { - print "$_->{POS}: warning: import never used\n"; - } - } - - foreach (values %{$conformance->{types}}) { - if (not $_->{USED} and defined($_->{POS})) { - print "$_->{POS}: warning: type never used\n"; - } - } - - foreach (values %{$conformance->{fielddescription}}) { - if (not $_->{USED}) { - print "$_->{POS}: warning: description never used\n"; - } - } - - foreach (values %{$conformance->{tfs}}) { - if (not $_->{USED}) { - print "$_->{POS}: warning: True/False description never used\n"; - } - } -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm new file mode 100644 index 0000000000..93927f8f54 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm @@ -0,0 +1,360 @@ +################################################### +# parse an Wireshark conformance file +# Copyright jelmer@samba.org 2005 +# released under the GNU GPL + +=pod + +=head1 NAME + +Parse::Pidl::Wireshark::Conformance - Conformance file parser for Wireshark + +=head1 DESCRIPTION + +This module supports parsing Wireshark conformance files (*.cnf). + +=head1 FILE FORMAT + +Pidl needs additional data for Wireshark output. This data is read from +so-called conformance files. This section describes the format of these +files. + +Conformance files are simple text files with a single command on each line. +Empty lines and lines starting with a '#' character are ignored. +Arguments to commands are seperated by spaces. + +The following commands are currently supported: + +=over 4 + +=item I name dissector ft_type base_type mask valsstring alignment + +Register new data type with specified name, what dissector function to call +and what properties to give header fields for elements of this type. + +=item I type + +Suppress emitting a dissect_type function for the specified type + +=item I type param + +Set parameter to specify to dissector function for given type. + +=item I hf title filter ft_type base_type valsstring mask description + +Generate a custom header field with specified properties. + +=item I old_hf_name new_hf_name + +Force the use of new_hf_name when the parser generator was going to +use old_hf_name. + +This can be used in conjunction with HF_FIELD in order to make more than +one element use the same filter name. + +=item I prefix + +Remove the specified prefix from all function names (if present). + +=item I longname shortname filtername + +Change the short-, long- and filter-name for the current interface in +Wireshark. + +=item I field desc + +Change description for the specified header field. `field' is the hf name of the field. + +=item I dissector code... + +Code to insert when generating the specified dissector. @HF@ and +@PARAM@ will be substituted. + +=item I hf_name "true string" "false string" + +Override the text shown when a bitmap boolean value is enabled or disabled. + +=item I fn_name + +Force pidl to not generate a particular function but allow the user +to write a function manually. This can be used to remove the function +for only one level for a particular element rather than all the functions and +ett/hf variables for a particular element as the NOEMIT command does. + +=back + +=head1 EXAMPLE + + INFO_KEY OpenKey.Ke + +=cut + +package Parse::Pidl::Wireshark::Conformance; + +require Exporter; +use vars qw($VERSION); +$VERSION = '0.01'; + +@ISA = qw(Exporter); +@EXPORT_OK = qw(ReadConformance); + +use strict; + +use Parse::Pidl::Util qw(has_property); + +sub handle_type($$$$$$$$$$) +{ + my ($pos,$data,$name,$dissectorname,$ft_type,$base_type,$mask,$valsstring,$alignment) = @_; + + unless(defined($alignment)) { + print "$pos: error incomplete TYPE command\n"; + return; + } + + unless ($dissectorname =~ /.*dissect_.*/) { + print "$pos: warning: dissector name does not contain `dissect'\n"; + } + + unless(valid_ft_type($ft_type)) { + print "$pos: warning: invalid FT_TYPE `$ft_type'\n"; + } + + unless (valid_base_type($base_type)) { + print "$pos: warning: invalid BASE_TYPE `$base_type'\n"; + } + + $data->{types}->{$name} = { + NAME => $name, + POS => $pos, + USED => 0, + DISSECTOR_NAME => $dissectorname, + FT_TYPE => $ft_type, + BASE_TYPE => $base_type, + MASK => $mask, + VALSSTRING => $valsstring, + ALIGNMENT => $alignment + }; +} + +sub handle_tfs($$$$$) +{ + my ($pos,$data,$hf,$trues,$falses) = @_; + + unless(defined($falses)) { + print "$pos: error: incomplete TFS command\n"; + return; + } + + $data->{tfs}->{$hf} = { + TRUE_STRING => $trues, + FALSE_STRING => $falses + }; +} + +sub handle_hf_rename($$$$) +{ + my ($pos,$data,$old,$new) = @_; + + unless(defined($new)) { + print "$pos: error: incomplete HF_RENAME command\n"; + return; + } + + $data->{hf_renames}->{$old} = { + OLDNAME => $old, + NEWNAME => $new, + POS => $pos, + USED => 0 + }; +} + +sub handle_param_value($$$$) +{ + my ($pos,$data,$dissector_name,$value) = @_; + + unless(defined($value)) { + print "$pos: error: incomplete PARAM_VALUE command\n"; + return; + } + + $data->{dissectorparams}->{$dissector_name} = { + DISSECTOR => $dissector_name, + PARAM => $value, + POS => $pos, + USED => 0 + }; +} + +sub valid_base_type($) +{ + my $t = shift; + return 0 unless($t =~ /^BASE_.*/); + return 1; +} + +sub valid_ft_type($) +{ + my $t = shift; + return 0 unless($t =~ /^FT_.*/); + return 1; +} + +sub handle_hf_field($$$$$$$$$$) +{ + my ($pos,$data,$index,$name,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; + + unless(defined($blurb)) { + print "$pos: error: incomplete HF_FIELD command\n"; + return; + } + + unless(valid_ft_type($ft_type)) { + print "$pos: warning: invalid FT_TYPE `$ft_type'\n"; + } + + unless(valid_base_type($base_type)) { + print "$pos: warning: invalid BASE_TYPE `$base_type'\n"; + } + + $data->{header_fields}->{$index} = { + INDEX => $index, + POS => $pos, + USED => 0, + NAME => $name, + FILTER => $filter, + FT_TYPE => $ft_type, + BASE_TYPE => $base_type, + VALSSTRING => $valsstring, + MASK => $mask, + BLURB => $blurb + }; +} + +sub handle_strip_prefix($$$) +{ + my ($pos,$data,$x) = @_; + + push (@{$data->{strip_prefixes}}, $x); +} + +sub handle_noemit($$$) +{ + my ($pos,$data,$type) = @_; + + if (defined($type)) { + $data->{noemit}->{$type} = 1; + } else { + $data->{noemit_dissector} = 1; + } +} + +sub handle_manual($$$) +{ + my ($pos,$data,$fn) = @_; + + $data->{manual}->{$fn} = 1; +} + +sub handle_protocol($$$$$$) +{ + my ($pos, $data, $name, $longname, $shortname, $filtername) = @_; + + $data->{protocols}->{$name} = { + LONGNAME => $longname, + SHORTNAME => $shortname, + FILTERNAME => $filtername + }; +} + +sub handle_fielddescription($$$$) +{ + my ($pos,$data,$field,$desc) = @_; + + $data->{fielddescription}->{$field} = { + DESCRIPTION => $desc, + POS => $pos, + USED => 0 + }; +} + +sub handle_import +{ + my $pos = shift @_; + my $data = shift @_; + my $dissectorname = shift @_; + + unless(defined($dissectorname)) { + print "$pos: error: no dissectorname specified\n"; + return; + } + + $data->{imports}->{$dissectorname} = { + NAME => $dissectorname, + DATA => join(' ', @_), + USED => 0, + POS => $pos + }; +} + +my %field_handlers = ( + TYPE => \&handle_type, + NOEMIT => \&handle_noemit, + MANUAL => \&handle_manual, + PARAM_VALUE => \&handle_param_value, + HF_FIELD => \&handle_hf_field, + HF_RENAME => \&handle_hf_rename, + TFS => \&handle_tfs, + STRIP_PREFIX => \&handle_strip_prefix, + PROTOCOL => \&handle_protocol, + FIELD_DESCRIPTION => \&handle_fielddescription, + IMPORT => \&handle_import +); + +sub ReadConformance($$) +{ + my ($f,$data) = @_; + + $data->{override} = ""; + + my $incodeblock = 0; + + open(IN,"<$f") or return undef; + + my $ln = 0; + + foreach () { + $ln++; + next if (/^#.*$/); + next if (/^$/); + + s/[\r\n]//g; + + if ($_ eq "CODE START") { + $incodeblock = 1; + next; + } elsif ($incodeblock and $_ eq "CODE END") { + $incodeblock = 0; + next; + } elsif ($incodeblock) { + $data->{override}.="$_\n"; + next; + } + + my @fields = /([^ "]+|"[^"]+")/g; + + my $cmd = $fields[0]; + + shift @fields; + + if (not defined($field_handlers{$cmd})) { + print "$f:$ln: Warning: Unknown command `$cmd'\n"; + next; + } + + $field_handlers{$cmd}("$f:$ln", $data, @fields); + } + + close(IN); +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm new file mode 100644 index 0000000000..872a149274 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -0,0 +1,1054 @@ +################################################## +# Samba4 NDR parser generator for IDL structures +# Copyright tridge@samba.org 2000-2003 +# Copyright tpot@samba.org 2001,2005 +# Copyright jelmer@samba.org 2004-2005 +# Portions based on idl2eth.c by Ronnie Sahlberg +# released under the GNU GPL + +=pod + +=head1 NAME + +Parse::Pidl::Wireshark::NDR - Parser generator for Wireshark + +=cut + +package Parse::Pidl::Wireshark::NDR; + +use strict; +use Parse::Pidl::Typelist qw(getType); +use Parse::Pidl::Util qw(has_property ParseExpr property_matches make_str); +use Parse::Pidl::NDR qw(ContainsString GetNextLevel); +use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); +use Parse::Pidl::Wireshark::Conformance qw(ReadConformance); +use File::Basename; + +use vars qw($VERSION); +$VERSION = '0.01'; + +sub error($$) +{ + my ($e,$t) = @_; + print "$e->{FILE}:$e->{LINE}: $t\n"; +} + +my @ett; + +my %hf_used = (); +my %dissector_used = (); + +my $conformance = undef; + +my %ptrtype_mappings = ( + "unique" => "NDR_POINTER_UNIQUE", + "ref" => "NDR_POINTER_REF", + "ptr" => "NDR_POINTER_PTR" +); + +sub StripPrefixes($) +{ + my ($s) = @_; + + foreach (@{$conformance->{strip_prefixes}}) { + $s =~ s/^$_\_//g; + } + + return $s; +} + +# Convert a IDL structure field name (e.g access_mask) to a prettier +# string like 'Access Mask'. + +sub field2name($) +{ + my($field) = shift; + + $field =~ s/_/ /g; # Replace underscores with spaces + $field =~ s/(\w+)/\u\L$1/g; # Capitalise each word + + return $field; +} + +my %res = (); +my $tabs = ""; +my $cur_fn = undef; +sub pidl_fn_start($) +{ + my $fn = shift; + $cur_fn = $fn; +} +sub pidl_fn_end($) +{ + my $fn = shift; + die("Inconsistent state: $fn != $cur_fn") if ($fn ne $cur_fn); + $cur_fn = undef; +} + +sub pidl_code($) +{ + my $d = shift; + return if (defined($cur_fn) and defined($conformance->{manual}->{$cur_fn})); + + if ($d) { + $res{code} .= $tabs; + $res{code} .= $d; + } + $res{code} .="\n"; +} + +sub pidl_hdr($) { my $x = shift; $res{hdr} .= "$x\n"; } +sub pidl_def($) { my $x = shift; $res{def} .= "$x\n"; } + +sub indent() +{ + $tabs .= "\t"; +} + +sub deindent() +{ + $tabs = substr($tabs, 0, -1); +} + +sub PrintIdl($) +{ + my $idl = shift; + + foreach (split /\n/, $idl) { + pidl_code "/* IDL: $_ */"; + } + + pidl_code ""; +} + +##################################################################### +# parse the interface definitions +sub Interface($) +{ + my($interface) = @_; + Const($_,$interface->{NAME}) foreach (@{$interface->{CONSTS}}); + Typedef($_,$interface->{NAME}) foreach (@{$interface->{TYPES}}); + Function($_,$interface->{NAME}) foreach (@{$interface->{FUNCTIONS}}); +} + +sub Enum($$$) +{ + my ($e,$name,$ifname) = @_; + my $valsstring = "$ifname\_$name\_vals"; + my $dissectorname = "$ifname\_dissect\_enum\_".StripPrefixes($name); + + return if (defined($conformance->{noemit}->{StripPrefixes($name)})); + + foreach (@{$e->{ELEMENTS}}) { + if (/([^=]*)=(.*)/) { + pidl_hdr "#define $1 ($2)"; + } + } + + pidl_hdr "extern const value_string $valsstring\[];"; + pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; + + pidl_def "const value_string ".$valsstring."[] = {"; + foreach (@{$e->{ELEMENTS}}) { + next unless (/([^=]*)=(.*)/); + pidl_def "\t{ $1, \"$1\" },"; + } + + pidl_def "{ 0, NULL }"; + pidl_def "};"; + + pidl_fn_start $dissectorname; + pidl_code "int"; + pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "{"; + indent; + pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, NULL);"; + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + pidl_fn_end $dissectorname; + + my $enum_size = $e->{BASE_TYPE}; + $enum_size =~ s/uint//g; + register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$enum_size", "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8); +} + +sub Bitmap($$$) +{ + my ($e,$name,$ifname) = @_; + my $dissectorname = "$ifname\_dissect\_bitmap\_".StripPrefixes($name); + + register_ett("ett_$ifname\_$name"); + + pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; + + pidl_fn_start $dissectorname; + pidl_code "int"; + pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "{"; + indent; + pidl_code "proto_item *item = NULL;"; + pidl_code "proto_tree *tree = NULL;"; + pidl_code ""; + + pidl_code "g$e->{BASE_TYPE} flags;"; + if ($e->{ALIGN} > 1) { + pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; + } + + pidl_code ""; + + pidl_code "if (parent_tree) {"; + indent; + pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);"; + pidl_code "tree = proto_item_add_subtree(item,ett_$ifname\_$name);"; + deindent; + pidl_code "}\n"; + + pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);"; + + pidl_code "proto_item_append_text(item, \": \");\n"; + pidl_code "if (!flags)"; + pidl_code "\tproto_item_append_text(item, \"(No values set)\");\n"; + + foreach (@{$e->{ELEMENTS}}) { + next unless (/([^ ]*) (.*)/); + my ($en,$ev) = ($1,$2); + my $hf_bitname = "hf_$ifname\_$name\_$en"; + my $filtername = "$ifname\.$name\.$en"; + + $hf_used{$hf_bitname} = 1; + + register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, ""); + + pidl_def "static const true_false_string $name\_$en\_tfs = {"; + if (defined($conformance->{tfs}->{$hf_bitname})) { + pidl_def " $conformance->{tfs}->{$hf_bitname}->{TRUE_STRING},"; + pidl_def " $conformance->{tfs}->{$hf_bitname}->{FALSE_STRING},"; + $conformance->{tfs}->{$hf_bitname}->{USED} = 1; + } else { + pidl_def " \"$en is SET\","; + pidl_def " \"$en is NOT SET\","; + } + pidl_def "};"; + + pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);"; + pidl_code "if (flags&$ev){"; + pidl_code "\tproto_item_append_text(item, \"$en\");"; + pidl_code "\tif (flags & (~$ev))"; + pidl_code "\t\tproto_item_append_text(item, \", \");"; + pidl_code "}"; + pidl_code "flags&=(~$ev);"; + pidl_code ""; + } + + pidl_code "if (flags) {"; + pidl_code "\tproto_item_append_text(item, \"Unknown bitmap value 0x%x\", flags);"; + pidl_code "}\n"; + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + pidl_fn_end $dissectorname; + + my $size = $e->{BASE_TYPE}; + $size =~ s/uint//g; + register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$size", "BASE_HEX", "0", "NULL", $size/8); +} + +sub ElementLevel($$$$$) +{ + my ($e,$l,$hf,$myname,$pn) = @_; + + my $param = 0; + + if (defined($conformance->{dissectorparams}->{$myname})) { + $conformance->{dissectorparams}->{$myname}->{PARAM} = 1; + $param = $conformance->{dissectorparams}->{$myname}->{PARAM}; + } + + if ($l->{TYPE} eq "POINTER") { + my $type; + if ($l->{LEVEL} eq "TOP") { + $type = "toplevel"; + } elsif ($l->{LEVEL} eq "EMBEDDED") { + $type = "embedded"; + } + pidl_code "offset = dissect_ndr_$type\_pointer(tvb, offset, pinfo, tree, drep, $myname\_, $ptrtype_mappings{$l->{POINTER_TYPE}}, \"Pointer to ".field2name(StripPrefixes($e->{NAME})) . " ($e->{TYPE})\",$hf);"; + } elsif ($l->{TYPE} eq "ARRAY") { + if ($l->{IS_INLINE}) { + error($e->{ORIGINAL}, "Inline arrays not supported"); + } elsif ($l->{IS_FIXED}) { + pidl_code "int i;"; + pidl_code "for (i = 0; i < $l->{SIZE_IS}; i++)"; + pidl_code "\toffset = $myname\_(tvb, offset, pinfo, tree, drep);"; + } else { + my $type = ""; + $type .= "c" if ($l->{IS_CONFORMANT}); + $type .= "v" if ($l->{IS_VARYING}); + + unless ($l->{IS_ZERO_TERMINATED}) { + pidl_code "offset = dissect_ndr_u" . $type . "array(tvb, offset, pinfo, tree, drep, $myname\_);"; + } else { + my $nl = GetNextLevel($e,$l); + pidl_code "char *data;"; + pidl_code ""; + pidl_code "offset = dissect_ndr_$type" . "string(tvb, offset, pinfo, tree, drep, sizeof(g$nl->{DATA_TYPE}), $hf, FALSE, &data);"; + pidl_code "proto_item_append_text(tree, \": %s\", data);"; + } + } + } elsif ($l->{TYPE} eq "DATA") { + if ($l->{DATA_TYPE} eq "string") { + my $bs = 2; # Byte size defaults to that of UCS2 + + + ($bs = 1) if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_ASCII.*")); + + if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) { + pidl_code "char *data;\n"; + pidl_code "offset = dissect_ndr_cvstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, &data);"; + pidl_code "proto_item_append_text(tree, \": %s\", data);"; + } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*")) { + pidl_code "offset = dissect_ndr_vstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, NULL);"; + } else { + warn("Unable to handle string with flags $e->{PROPERTIES}->{flag}"); + } + } else { + my $call; + + if ($conformance->{imports}->{$l->{DATA_TYPE}}) { + $call = $conformance->{imports}->{$l->{DATA_TYPE}}->{DATA}; + $conformance->{imports}->{$l->{DATA_TYPE}}->{USED} = 1; + } elsif (defined($conformance->{imports}->{"$pn.$e->{NAME}"})) { + $call = $conformance->{imports}->{"$pn.$e->{NAME}"}->{DATA}; + $conformance->{imports}->{"$pn.$e->{NAME}"}->{USED} = 1; + + } elsif (defined($conformance->{types}->{$l->{DATA_TYPE}})) { + $call= $conformance->{types}->{$l->{DATA_TYPE}}->{DISSECTOR_NAME}; + $conformance->{types}->{$l->{DATA_TYPE}}->{USED} = 1; + } else { + if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/) + { + pidl_code "offset = $1_dissect_struct_$2(tvb,offset,pinfo,tree,drep,$hf,$param);"; + } + + return; + } + + $call =~ s/\@HF\@/$hf/g; + $call =~ s/\@PARAM\@/$param/g; + pidl_code "$call"; + } + } elsif ($_->{TYPE} eq "SUBCONTEXT") { + my $num_bits = ($l->{HEADER_SIZE}*8); + pidl_code "guint$num_bits size;"; + pidl_code "int start_offset = offset;"; + pidl_code "tvbuff_t *subtvb;"; + pidl_code "offset = dissect_ndr_uint$num_bits(tvb, offset, pinfo, tree, drep, $hf, &size);"; + pidl_code "proto_tree_add_text(tree, tvb, start_offset, offset - start_offset + size, \"Subcontext size\");"; + + pidl_code "subtvb = tvb_new_subset(tvb, offset, size, -1);"; + pidl_code "$myname\_(subtvb, 0, pinfo, tree, drep);"; + } else { + die("Unknown type `$_->{TYPE}'"); + } +} + +sub Element($$$) +{ + my ($e,$pn,$ifname) = @_; + + my $dissectorname = "$ifname\_dissect\_element\_".StripPrefixes($pn)."\_".StripPrefixes($e->{NAME}); + + my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; + + my $type = find_type($e->{TYPE}); + + if (not defined($type)) { + # default settings + $type = { + MASK => 0, + VALSSTRING => "NULL", + FT_TYPE => "FT_NONE", + BASE_TYPE => "BASE_HEX" + }; + } + + if (ContainsString($e)) { + $type = { + MASK => 0, + VALSSTRING => "NULL", + FT_TYPE => "FT_STRING", + BASE_TYPE => "BASE_DEC" + }; + } + + my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", $type->{FT_TYPE}, $type->{BASE_TYPE}, $type->{VALSSTRING}, $type->{MASK}, ""); + $hf_used{$hf} = 1; + + my $eltname = StripPrefixes($pn) . ".$e->{NAME}"; + if (defined($conformance->{noemit}->{$eltname})) { + return $call_code; + } + + my $add = ""; + + foreach (@{$e->{LEVELS}}) { + next if ($_->{TYPE} eq "SWITCH"); + pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);"; + pidl_fn_start "$dissectorname$add"; + pidl_code "static int"; + pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)"; + pidl_code "{"; + indent; + + ElementLevel($e,$_,$hf,$dissectorname.$add,$pn); + + pidl_code ""; + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + pidl_fn_end "$dissectorname$add"; + $add.="_"; + last if ($_->{TYPE} eq "ARRAY" and $_->{IS_ZERO_TERMINATED}); + } + + return $call_code; +} + +sub Function($$$) +{ + my ($fn,$ifname) = @_; + + my %dissectornames; + + foreach (@{$fn->{ELEMENTS}}) { + $dissectornames{$_->{NAME}} = Element($_, $fn->{NAME}, $ifname) if not defined($dissectornames{$_->{NAME}}); + } + + my $fn_name = $_->{NAME}; + $fn_name =~ s/^${ifname}_//; + + PrintIdl DumpFunction($fn->{ORIGINAL}); + pidl_fn_start "$ifname\_dissect\_$fn_name\_response"; + pidl_code "static int"; + pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; + pidl_code "{"; + indent; + pidl_code "guint32 status;\n"; + foreach (@{$fn->{ELEMENTS}}) { + if (grep(/out/,@{$_->{DIRECTION}})) { + pidl_code "$dissectornames{$_->{NAME}}"; + pidl_code "offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"; + pidl_code ""; + } + } + + if (not defined($fn->{RETURN_TYPE})) { + } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { + pidl_code "offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, &status);\n"; + pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; + pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, NT_errors, \"Unknown NT status 0x%08x\"));\n"; + $hf_used{"hf\_$ifname\_status"} = 1; + } elsif ($fn->{RETURN_TYPE} eq "WERROR") { + pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, &status);\n"; + pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; + pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, DOS_errors, \"Unknown DOS error 0x%08x\"));\n"; + + $hf_used{"hf\_$ifname\_werror"} = 1; + } else { + print "$fn->{FILE}:$fn->{LINE}: error: return type `$fn->{RETURN_TYPE}' not yet supported\n"; + } + + + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + pidl_fn_end "$ifname\_dissect\_$fn_name\_response"; + + pidl_fn_start "$ifname\_dissect\_$fn_name\_request"; + pidl_code "static int"; + pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; + pidl_code "{"; + indent; + foreach (@{$fn->{ELEMENTS}}) { + if (grep(/in/,@{$_->{DIRECTION}})) { + pidl_code "$dissectornames{$_->{NAME}}"; + pidl_code "offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"; + } + + } + + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + pidl_fn_end "$ifname\_dissect\_$fn_name\_request"; +} + +sub Struct($$$) +{ + my ($e,$name,$ifname) = @_; + my $dissectorname = "$ifname\_dissect\_struct\_".StripPrefixes($name); + + return if (defined($conformance->{noemit}->{StripPrefixes($name)})); + + register_ett("ett_$ifname\_$name"); + + my $res = ""; + ($res.="\t".Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}}); + + pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_);"; + + pidl_fn_start $dissectorname; + pidl_code "int"; + pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "{"; + indent; + pidl_code "proto_item *item = NULL;"; + pidl_code "proto_tree *tree = NULL;"; + pidl_code "int old_offset;"; + pidl_code ""; + + if ($e->{ALIGN} > 1) { + pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; + } + pidl_code ""; + + pidl_code "old_offset = offset;"; + pidl_code ""; + pidl_code "if (parent_tree) {"; + indent; + pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);"; + pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; + deindent; + pidl_code "}"; + + pidl_code "\n$res"; + + pidl_code "proto_item_set_len(item, offset-old_offset);\n"; + pidl_code "return offset;"; + deindent; + pidl_code "}\n"; + pidl_fn_end $dissectorname; + + register_type($name, "offset = $dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); +} + +sub Union($$$) +{ + my ($e,$name,$ifname) = @_; + + my $dissectorname = "$ifname\_dissect_".StripPrefixes($name); + + return if (defined($conformance->{noemit}->{StripPrefixes($name)})); + + register_ett("ett_$ifname\_$name"); + + my $res = ""; + foreach (@{$e->{ELEMENTS}}) { + $res.="\n\t\t$_->{CASE}:\n"; + if ($_->{TYPE} ne "EMPTY") { + $res.="\t\t\t".Element($_, $name, $ifname)."\n"; + } + $res.="\t\tbreak;\n"; + } + + my $switch_type; + my $switch_dissect; + my $switch_dt = getType($e->{SWITCH_TYPE}); + if ($switch_dt->{DATA}->{TYPE} eq "ENUM") { + $switch_type = "g".Parse::Pidl::Typelist::enum_type_fn($switch_dt); + $switch_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($switch_dt); + } elsif ($switch_dt->{DATA}->{TYPE} eq "SCALAR") { + $switch_type = "g$e->{SWITCH_TYPE}"; + $switch_dissect = "dissect_ndr_$e->{SWITCH_TYPE}"; + } + + pidl_fn_start $dissectorname; + pidl_code "static int"; + pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "{"; + indent; + pidl_code "proto_item *item = NULL;"; + pidl_code "proto_tree *tree = NULL;"; + pidl_code "int old_offset;"; + pidl_code "$switch_type level;"; + pidl_code ""; + + if ($e->{ALIGN} > 1) { + pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; + } + + pidl_code ""; + + pidl_code "old_offset = offset;"; + pidl_code "if (parent_tree) {"; + indent; + pidl_code "item = proto_tree_add_text(parent_tree, tvb, offset, -1, \"$name\");"; + pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; + deindent; + pidl_code "}"; + + pidl_code ""; + + pidl_code "offset = $switch_dissect(tvb, offset, pinfo, tree, drep, hf_index, &level);"; + + pidl_code "switch(level) {$res\t}"; + pidl_code "proto_item_set_len(item, offset-old_offset);\n"; + pidl_code "return offset;"; + deindent; + pidl_code "}"; + pidl_fn_end $dissectorname; + + register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); +} + +sub Const($$) +{ + my ($const,$ifname) = @_; + + if (!defined($const->{ARRAY_LEN}[0])) { + pidl_hdr "#define $const->{NAME}\t( $const->{VALUE} )\n"; + } else { + pidl_hdr "#define $const->{NAME}\t $const->{VALUE}\n"; + } +} + +sub Typedef($$) +{ + my ($e,$ifname) = @_; + + PrintIdl DumpTypedef($e->{ORIGINAL}); + + { + ENUM => \&Enum, + STRUCT => \&Struct, + UNION => \&Union, + BITMAP => \&Bitmap + }->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $ifname); +} + +sub RegisterInterface($) +{ + my ($x) = @_; + + pidl_fn_start "proto_register_dcerpc_$x->{NAME}"; + pidl_code "void proto_register_dcerpc_$x->{NAME}(void)"; + pidl_code "{"; + indent; + + $res{code}.=DumpHfList()."\n"; + $res{code}.="\n".DumpEttList()."\n"; + + if (defined($x->{UUID})) { + # These can be changed to non-pidl_code names if the old dissectors + # in epan/dissctors are deleted. + + my $name = uc($x->{NAME}) . " (pidl)"; + my $short_name = uc($x->{NAME}); + my $filter_name = $x->{NAME}; + + if (has_property($x, "helpstring")) { + $name = $x->{PROPERTIES}->{helpstring}; + } + + if (defined($conformance->{protocols}->{$x->{NAME}})) { + $short_name = $conformance->{protocols}->{$x->{NAME}}->{SHORTNAME}; + $name = $conformance->{protocols}->{$x->{NAME}}->{LONGNAME}; + $filter_name = $conformance->{protocols}->{$x->{NAME}}->{FILTERNAME}; + } + + pidl_code "proto_dcerpc_$x->{NAME} = proto_register_protocol(".make_str($name).", ".make_str($short_name).", ".make_str($filter_name).");"; + + pidl_code "proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));"; + pidl_code "proto_register_subtree_array(ett, array_length(ett));"; + } else { + pidl_code "proto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");"; + pidl_code "proto_register_field_array(proto_dcerpc, hf, array_length(hf));"; + pidl_code "proto_register_subtree_array(ett, array_length(ett));"; + } + + deindent; + pidl_code "}\n"; + pidl_fn_end "proto_register_dcerpc_$x->{NAME}"; +} + +sub RegisterInterfaceHandoff($) +{ + my $x = shift; + + if (defined($x->{UUID})) { + pidl_fn_start "proto_reg_handoff_dcerpc_$x->{NAME}"; + pidl_code "void proto_reg_handoff_dcerpc_$x->{NAME}(void)"; + pidl_code "{"; + indent; + pidl_code "dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},"; + pidl_code "\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},"; + pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);"; + deindent; + pidl_code "}"; + pidl_fn_end "proto_reg_handoff_dcerpc_$x->{NAME}"; + + $hf_used{"hf_$x->{NAME}_opnum"} = 1; + } +} + +sub ProcessInterface($) +{ + my ($x) = @_; + + push(@{$conformance->{strip_prefixes}}, $x->{NAME}); + + my $define = "__PACKET_DCERPC_" . uc($_->{NAME}) . "_H"; + pidl_hdr "#ifndef $define"; + pidl_hdr "#define $define"; + pidl_hdr ""; + + if (defined $x->{PROPERTIES}->{depends}) { + foreach (split / /, $x->{PROPERTIES}->{depends}) { + next if($_ eq "security"); + pidl_hdr "#include \"packet-dcerpc-$_\.h\"\n"; + } + } + + pidl_def "static gint proto_dcerpc_$x->{NAME} = -1;"; + register_ett("ett_dcerpc_$x->{NAME}"); + register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, ""); + + if (defined($x->{UUID})) { + my $if_uuid = $x->{UUID}; + + pidl_def "/* Version information */\n\n"; + + pidl_def "static e_uuid_t uuid_dcerpc_$x->{NAME} = {"; + pidl_def "\t0x" . substr($if_uuid, 1, 8) + . ", 0x" . substr($if_uuid, 10, 4) + . ", 0x" . substr($if_uuid, 15, 4) . ","; + pidl_def "\t{ 0x" . substr($if_uuid, 20, 2) + . ", 0x" . substr($if_uuid, 22, 2) + . ", 0x" . substr($if_uuid, 25, 2) + . ", 0x" . substr($if_uuid, 27, 2) + . ", 0x" . substr($if_uuid, 29, 2) + . ", 0x" . substr($if_uuid, 31, 2) + . ", 0x" . substr($if_uuid, 33, 2) + . ", 0x" . substr($if_uuid, 35, 2) . " }"; + pidl_def "};"; + + my $maj = $x->{VERSION}; + $maj =~ s/\.(.*)$//g; + pidl_def "static guint16 ver_dcerpc_$x->{NAME} = $maj;"; + pidl_def ""; + } + + Interface($x); + + pidl_code "\n".DumpFunctionTable($x); + + # Only register these two return types if they were actually used + if (defined($hf_used{"hf_$x->{NAME}_status"})) { + register_hf_field("hf_$x->{NAME}_status", "Status", "$x->{NAME}.status", "FT_UINT32", "BASE_HEX", "VALS(NT_errors)", 0, ""); + } + + if (defined($hf_used{"hf_$x->{NAME}_werror"})) { + register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "VALS(DOS_errors)", 0, ""); + } + + RegisterInterface($x); + RegisterInterfaceHandoff($x); + + pidl_hdr "#endif /* $define */"; +} + +sub find_type($) +{ + my $n = shift; + + return $conformance->{types}->{$n}; +} + +sub register_type($$$$$$$) +{ + my ($type,$call,$ft,$base,$mask,$vals,$length) = @_; + + $conformance->{types}->{$type} = { + NAME => $type, + DISSECTOR_NAME => $call, + FT_TYPE => $ft, + BASE_TYPE => $base, + MASK => $mask, + VALSSTRING => $vals, + ALIGNMENT => $length + }; +} + +# Loads the default types +sub Initialize($) +{ + my $cnf_file = shift; + + $conformance = { + imports => {}, + header_fields=> {} + }; + + ReadConformance($cnf_file, $conformance) or print "Warning: No conformance file `$cnf_file'\n"; + + foreach my $bytes (qw(1 2 4 8)) { + my $bits = $bytes * 8; + register_type("uint$bits", "offset = dissect_ndr_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@,NULL);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes); + register_type("int$bits", "offset = dissect_ndr_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes); + } + + register_type("udlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4); + register_type("bool8", "offset = dissect_ndr_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + register_type("char", "offset = dissect_ndr_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + register_type("long", "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4); + register_type("dlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8); + register_type("GUID", "offset = dissect_ndr_uuid_t(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4); + register_type("policy_handle", "offset = dissect_nt_policy_hnd(tvb, offset, pinfo, tree, drep, \@HF\@, NULL, NULL, \@PARAM\@&0x01, \@PARAM\@&0x02);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); + register_type("NTTIME", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + register_type("NTTIME_hyper", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + register_type("time_t", "offset = dissect_ndr_time_t(tvb, offset, pinfo,tree, drep, \@HF\@, NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4); + register_type("NTTIME_1sec", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + register_type("SID", " + dcerpc_info *di = (dcerpc_info *)pinfo->private_data; + + di->hf_index = \@HF\@; + + offset = dissect_ndr_nt_SID_with_options(tvb, offset, pinfo, tree, drep, param); + ","FT_STRING", "BASE_DEC", 0, "NULL", 4); + register_type("WERROR", + "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4); + +} + +##################################################################### +# Generate Wireshark parser and header code +sub Parse($$$$) +{ + my($ndr,$idl_file,$h_filename,$cnf_file) = @_; + Initialize($cnf_file); + + return (undef, undef) if defined($conformance->{noemit_dissector}); + + $tabs = ""; + + %res = (code=>"",def=>"",hdr=>""); + @ett = (); + + my $notice = +"/* DO NOT EDIT + This filter was automatically generated + from $idl_file and $cnf_file. + + Pidl is a perl based IDL compiler for DCE/RPC idl files. + It is maintained by the Samba team, not the Wireshark team. + Instructions on how to download and install Pidl can be + found at http://wiki.wireshark.org/Pidl +*/ + +"; + + pidl_hdr $notice; + + $res{headers} = "\n"; + $res{headers} .= "#ifdef HAVE_CONFIG_H\n"; + $res{headers} .= "#include \"config.h\"\n"; + $res{headers} .= "#endif\n\n"; + $res{headers} .= "#include \n"; + $res{headers} .= "#include \n"; + $res{headers} .= "#include \n\n"; + + $res{headers} .= "#include \"packet-dcerpc.h\"\n"; + $res{headers} .= "#include \"packet-dcerpc-nt.h\"\n"; + $res{headers} .= "#include \"packet-windows-common.h\"\n"; + + my $h_basename = basename($h_filename); + + $res{headers} .= "#include \"$h_basename\"\n"; + pidl_code ""; + + # Wireshark protocol registration + + ProcessInterface($_) foreach (@$ndr); + + $res{ett} = DumpEttDeclaration(); + $res{hf} = DumpHfDeclaration(); + + my $parser = $notice; + $parser.= $res{headers}; + $parser.=$res{ett}; + $parser.=$res{hf}; + $parser.=$res{def}; + $parser.=$conformance->{override}; + $parser.=$res{code}; + + my $header = "/* autogenerated by pidl */\n\n"; + $header.=$res{hdr}; + + CheckUsed($conformance); + + return ($parser,$header); +} + +############################################################################### +# ETT +############################################################################### + +sub register_ett($) +{ + my $name = shift; + + push (@ett, $name); +} + +sub DumpEttList() +{ + my $res = "\tstatic gint *ett[] = {\n"; + foreach (@ett) { + $res .= "\t\t&$_,\n"; + } + + return "$res\t};\n"; +} + +sub DumpEttDeclaration() +{ + my $res = "\n/* Ett declarations */\n"; + foreach (@ett) { + $res .= "static gint $_ = -1;\n"; + } + + return "$res\n"; +} + +############################################################################### +# HF +############################################################################### + +sub register_hf_field($$$$$$$$) +{ + my ($index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; + + if (defined ($conformance->{hf_renames}->{$index})) { + $conformance->{hf_renames}->{$index}->{USED} = 1; + return $conformance->{hf_renames}->{$index}->{NEWNAME}; + } + + $conformance->{header_fields}->{$index} = { + INDEX => $index, + NAME => $name, + FILTER => $filter_name, + FT_TYPE => $ft_type, + BASE_TYPE => $base_type, + VALSSTRING => $valsstring, + MASK => $mask, + BLURB => $blurb + }; + + if ((not defined($blurb) or $blurb eq "") and + defined($conformance->{fielddescription}->{$index})) { + $conformance->{header_fields}->{$index}->{BLURB} = + $conformance->{fielddescription}->{$index}->{DESCRIPTION}; + $conformance->{fielddescription}->{$index}->{USED} = 1; + } + + return $index; +} + +sub DumpHfDeclaration() +{ + my $res = ""; + + $res = "\n/* Header field declarations */\n"; + + foreach (keys %{$conformance->{header_fields}}) + { + $res .= "static gint $_ = -1;\n"; + } + + return "$res\n"; +} + +sub DumpHfList() +{ + my $res = "\tstatic hf_register_info hf[] = {\n"; + + foreach (values %{$conformance->{header_fields}}) + { + $res .= "\t{ &$_->{INDEX}, + { ".make_str($_->{NAME}).", ".make_str($_->{FILTER}).", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALSSTRING}, $_->{MASK}, ".make_str($_->{BLURB}).", HFILL }}, +"; + } + + return $res."\t};\n"; +} + + +############################################################################### +# Function table +############################################################################### + +sub DumpFunctionTable($) +{ + my $if = shift; + + my $res = "static dcerpc_sub_dissector $if->{NAME}\_dissectors[] = {\n"; + foreach (@{$if->{FUNCTIONS}}) { + my $fn_name = $_->{NAME}; + $fn_name =~ s/^$if->{NAME}_//; + $res.= "\t{ $_->{OPNUM}, \"$fn_name\",\n"; + $res.= "\t $if->{NAME}_dissect_${fn_name}_request, $if->{NAME}_dissect_${fn_name}_response},\n"; + } + + $res .= "\t{ 0, NULL, NULL, NULL }\n"; + + return "$res};\n"; +} + +sub CheckUsed($) +{ + my $conformance = shift; + foreach (values %{$conformance->{header_fields}}) { + if (not defined($hf_used{$_->{INDEX}})) { + print "$_->{POS}: warning: hf field `$_->{INDEX}' not used\n"; + } + } + + foreach (values %{$conformance->{hf_renames}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: hf field `$_->{OLDNAME}' not used\n"; + } + } + + foreach (values %{$conformance->{dissectorparams}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: dissector param never used\n"; + } + } + + foreach (values %{$conformance->{imports}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: import never used\n"; + } + } + + foreach (values %{$conformance->{types}}) { + if (not $_->{USED} and defined($_->{POS})) { + print "$_->{POS}: warning: type never used\n"; + } + } + + foreach (values %{$conformance->{fielddescription}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: description never used\n"; + } + } + + foreach (values %{$conformance->{tfs}}) { + if (not $_->{USED}) { + print "$_->{POS}: warning: True/False description never used\n"; + } + } +} + +1; -- cgit From 3d3bd93403c0a371f16cd8e13f7f563c4601122a Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sat, 29 Jul 2006 06:00:58 +0000 Subject: r17305: allow 'declare [...] union foo;' metze (This used to be commit 15d37004b70d097a1431fb4d41fef363ed654ac7) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 939 +++++++++++++++++++------------------ 1 file changed, 479 insertions(+), 460 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 60439b8601..dddbb26e76 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -509,7 +509,7 @@ sub new { ACTIONS => { '' => 2 }, - DEFAULT => -80, + DEFAULT => -82, GOTOS => { 'interface' => 3, 'coclass' => 4, @@ -559,7 +559,7 @@ sub new { } }, {#State 9 - DEFAULT => -109 + DEFAULT => -111 }, {#State 10 ACTIONS => { @@ -570,10 +570,10 @@ sub new { ACTIONS => { "(" => 16 }, - DEFAULT => -84 + DEFAULT => -86 }, {#State 12 - DEFAULT => -82 + DEFAULT => -84 }, {#State 13 ACTIONS => { @@ -602,7 +602,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'listtext' => 26, @@ -621,7 +621,7 @@ sub new { } }, {#State 18 - DEFAULT => -81 + DEFAULT => -83 }, {#State 19 ACTIONS => { @@ -643,13 +643,13 @@ sub new { } }, {#State 22 - DEFAULT => -113 + DEFAULT => -115 }, {#State 23 - DEFAULT => -91 + DEFAULT => -93 }, {#State 24 - DEFAULT => -93 + DEFAULT => -95 }, {#State 25 ACTIONS => { @@ -669,7 +669,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -86 + DEFAULT => -88 }, {#State 26 ACTIONS => { @@ -678,13 +678,13 @@ sub new { } }, {#State 27 - DEFAULT => -92 + DEFAULT => -94 }, {#State 28 - DEFAULT => -112 + DEFAULT => -114 }, {#State 29 - DEFAULT => -83 + DEFAULT => -85 }, {#State 30 DEFAULT => -9 @@ -699,7 +699,7 @@ sub new { "const" => 60, "struct" => 63 }, - DEFAULT => -80, + DEFAULT => -82, GOTOS => { 'typedecl' => 64, 'function' => 53, @@ -720,7 +720,7 @@ sub new { ACTIONS => { ";" => 71 }, - DEFAULT => -114, + DEFAULT => -116, GOTOS => { 'optional_semicolon' => 72 } @@ -739,7 +739,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 74, @@ -753,7 +753,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 75, @@ -767,7 +767,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 76, @@ -781,7 +781,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 77, @@ -795,7 +795,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 78, @@ -809,7 +809,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 79, @@ -823,7 +823,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 80, @@ -838,7 +838,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 82, @@ -852,7 +852,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 83, @@ -866,7 +866,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 84, @@ -880,7 +880,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 80, @@ -895,7 +895,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 86, @@ -909,7 +909,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 87, @@ -923,7 +923,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 88, @@ -937,7 +937,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 89, @@ -951,7 +951,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, 'anytext' => 90, @@ -960,10 +960,10 @@ sub new { } }, {#State 50 - DEFAULT => -85 + DEFAULT => -87 }, {#State 51 - DEFAULT => -80, + DEFAULT => -82, GOTOS => { 'property_list' => 91 } @@ -972,7 +972,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -111, + DEFAULT => -113, GOTOS => { 'optional_identifier' => 93 } @@ -991,7 +991,7 @@ sub new { "const" => 60, "struct" => 63 }, - DEFAULT => -80, + DEFAULT => -82, GOTOS => { 'typedecl' => 64, 'function' => 53, @@ -1040,13 +1040,13 @@ sub new { DEFAULT => -10 }, {#State 58 - DEFAULT => -80, + DEFAULT => -82, GOTOS => { 'property_list' => 105 } }, {#State 59 - DEFAULT => -26 + DEFAULT => -28 }, {#State 60 ACTIONS => { @@ -1057,7 +1057,7 @@ sub new { } }, {#State 61 - DEFAULT => -28 + DEFAULT => -30 }, {#State 62 DEFAULT => -14 @@ -1066,7 +1066,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -111, + DEFAULT => -113, GOTOS => { 'optional_identifier' => 107 } @@ -1078,7 +1078,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -111, + DEFAULT => -113, GOTOS => { 'optional_identifier' => 108 } @@ -1087,13 +1087,13 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -111, + DEFAULT => -113, GOTOS => { 'optional_identifier' => 109 } }, {#State 67 - DEFAULT => -29 + DEFAULT => -31 }, {#State 68 DEFAULT => -13 @@ -1102,10 +1102,10 @@ sub new { DEFAULT => -15 }, {#State 70 - DEFAULT => -27 + DEFAULT => -29 }, {#State 71 - DEFAULT => -115 + DEFAULT => -117 }, {#State 72 DEFAULT => -4 @@ -1133,7 +1133,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -103 + DEFAULT => -105 }, {#State 75 ACTIONS => { @@ -1144,7 +1144,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -94 + DEFAULT => -96 }, {#State 76 ACTIONS => { @@ -1164,7 +1164,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -102 + DEFAULT => -104 }, {#State 77 ACTIONS => { @@ -1184,7 +1184,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -98 + DEFAULT => -100 }, {#State 78 ACTIONS => { @@ -1204,7 +1204,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -106 + DEFAULT => -108 }, {#State 79 ACTIONS => { @@ -1215,7 +1215,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -105 + DEFAULT => -107 }, {#State 80 ACTIONS => { @@ -1235,7 +1235,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -88 + DEFAULT => -90 }, {#State 81 ACTIONS => { @@ -1252,7 +1252,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -100 + DEFAULT => -102 }, {#State 83 ACTIONS => { @@ -1263,7 +1263,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -101 + DEFAULT => -103 }, {#State 84 ACTIONS => { @@ -1283,7 +1283,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -104 + DEFAULT => -106 }, {#State 85 ACTIONS => { @@ -1300,7 +1300,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -99 + DEFAULT => -101 }, {#State 87 ACTIONS => { @@ -1311,7 +1311,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -96 + DEFAULT => -98 }, {#State 88 ACTIONS => { @@ -1322,7 +1322,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -95 + DEFAULT => -97 }, {#State 89 ACTIONS => { @@ -1333,7 +1333,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -97 + DEFAULT => -99 }, {#State 90 ACTIONS => { @@ -1353,7 +1353,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -87 + DEFAULT => -89 }, {#State 91 ACTIONS => { @@ -1380,13 +1380,13 @@ sub new { } }, {#State 92 - DEFAULT => -110 + DEFAULT => -112 }, {#State 93 ACTIONS => { "{" => 116 }, - DEFAULT => -65, + DEFAULT => -67, GOTOS => { 'union_body' => 117, 'opt_union_body' => 115 @@ -1396,7 +1396,7 @@ sub new { ACTIONS => { ";" => 71 }, - DEFAULT => -114, + DEFAULT => -116, GOTOS => { 'optional_semicolon' => 118 } @@ -1405,16 +1405,16 @@ sub new { DEFAULT => -11 }, {#State 96 - DEFAULT => -30 + DEFAULT => -32 }, {#State 97 - DEFAULT => -38 + DEFAULT => -40 }, {#State 98 - DEFAULT => -36 + DEFAULT => -38 }, {#State 99 - DEFAULT => -35 + DEFAULT => -37 }, {#State 100 ACTIONS => { @@ -1425,13 +1425,13 @@ sub new { } }, {#State 101 - DEFAULT => -37 + DEFAULT => -39 }, {#State 102 - DEFAULT => -31 + DEFAULT => -33 }, {#State 103 - DEFAULT => -32 + DEFAULT => -34 }, {#State 104 ACTIONS => { @@ -1443,50 +1443,52 @@ sub new { }, {#State 105 ACTIONS => { - "enum" => 124, - "bitmap" => 125, + "union" => 121, + "enum" => 126, + "bitmap" => 127, "[" => 7 }, GOTOS => { - 'decl_enum' => 121, - 'decl_bitmap' => 122, - 'decl_type' => 123 + 'decl_enum' => 122, + 'decl_bitmap' => 123, + 'decl_type' => 125, + 'decl_union' => 124 } }, {#State 106 - DEFAULT => -69, + DEFAULT => -71, GOTOS => { - 'pointers' => 126 + 'pointers' => 128 } }, {#State 107 ACTIONS => { - "{" => 128 + "{" => 130 }, - DEFAULT => -55, + DEFAULT => -57, GOTOS => { - 'struct_body' => 127, - 'opt_struct_body' => 129 + 'struct_body' => 129, + 'opt_struct_body' => 131 } }, {#State 108 ACTIONS => { - "{" => 130 + "{" => 132 }, - DEFAULT => -40, + DEFAULT => -42, GOTOS => { - 'opt_enum_body' => 132, - 'enum_body' => 131 + 'opt_enum_body' => 134, + 'enum_body' => 133 } }, {#State 109 ACTIONS => { - "{" => 134 + "{" => 136 }, - DEFAULT => -48, + DEFAULT => -50, GOTOS => { - 'bitmap_body' => 135, - 'opt_bitmap_body' => 133 + 'bitmap_body' => 137, + 'opt_bitmap_body' => 135 } }, {#State 110 @@ -1498,10 +1500,10 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, - 'anytext' => 136, + 'anytext' => 138, 'text' => 24, 'constant' => 27 } @@ -1512,10 +1514,10 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, - 'anytext' => 137, + 'anytext' => 139, 'text' => 24, 'constant' => 27 } @@ -1526,10 +1528,10 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, - 'anytext' => 138, + 'anytext' => 140, 'text' => 24, 'constant' => 27 } @@ -1539,106 +1541,112 @@ sub new { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 139 + 'identifier' => 141 } }, {#State 115 - DEFAULT => -67 + DEFAULT => -69 }, {#State 116 - DEFAULT => -62, + DEFAULT => -64, GOTOS => { - 'union_elements' => 140 + 'union_elements' => 142 } }, {#State 117 - DEFAULT => -66 + DEFAULT => -68 }, {#State 118 DEFAULT => -7 }, {#State 119 - DEFAULT => -34 + DEFAULT => -36 }, {#State 120 ACTIONS => { - "(" => 141 + "(" => 143 } }, {#State 121 - DEFAULT => -21 + DEFAULT => -26 }, {#State 122 - DEFAULT => -22 + DEFAULT => -21 }, {#State 123 - ACTIONS => { - 'IDENTIFIER' => 9 - }, - GOTOS => { - 'identifier' => 142 - } + DEFAULT => -22 }, {#State 124 DEFAULT => -23 }, {#State 125 - DEFAULT => -24 - }, - {#State 126 ACTIONS => { - 'IDENTIFIER' => 9, - "*" => 144 + 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 143 + 'identifier' => 144 } }, + {#State 126 + DEFAULT => -24 + }, {#State 127 - DEFAULT => -56 + DEFAULT => -25 }, {#State 128 - DEFAULT => -71, + ACTIONS => { + 'IDENTIFIER' => 9, + "*" => 146 + }, GOTOS => { - 'element_list1' => 145 + 'identifier' => 145 } }, {#State 129 - DEFAULT => -57 + DEFAULT => -58 }, {#State 130 - ACTIONS => { - 'IDENTIFIER' => 9 - }, + DEFAULT => -73, GOTOS => { - 'identifier' => 146, - 'enum_element' => 147, - 'enum_elements' => 148 + 'element_list1' => 147 } }, {#State 131 - DEFAULT => -41 + DEFAULT => -59 }, {#State 132 - DEFAULT => -42 + ACTIONS => { + 'IDENTIFIER' => 9 + }, + GOTOS => { + 'identifier' => 148, + 'enum_element' => 149, + 'enum_elements' => 150 + } }, {#State 133 - DEFAULT => -50 + DEFAULT => -43 }, {#State 134 + DEFAULT => -44 + }, + {#State 135 + DEFAULT => -52 + }, + {#State 136 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 151, - 'bitmap_elements' => 150, - 'bitmap_element' => 149 + 'identifier' => 153, + 'bitmap_elements' => 152, + 'bitmap_element' => 151 } }, - {#State 135 - DEFAULT => -49 + {#State 137 + DEFAULT => -51 }, - {#State 136 + {#State 138 ACTIONS => { "-" => 35, ":" => 34, @@ -1656,9 +1664,9 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -108 + DEFAULT => -110 }, - {#State 137 + {#State 139 ACTIONS => { "-" => 35, ":" => 34, @@ -1676,9 +1684,9 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -89 + DEFAULT => -91 }, - {#State 138 + {#State 140 ACTIONS => { ":" => 34, "<" => 37, @@ -1687,84 +1695,75 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -107 + DEFAULT => -109 }, - {#State 139 + {#State 141 ACTIONS => { - "[" => 152 + "[" => 154 }, - DEFAULT => -77, + DEFAULT => -79, GOTOS => { - 'array_len' => 153 + 'array_len' => 155 } }, - {#State 140 + {#State 142 ACTIONS => { - "}" => 154 + "}" => 156 }, - DEFAULT => -80, + DEFAULT => -82, GOTOS => { - 'optional_base_element' => 156, - 'property_list' => 155 + 'optional_base_element' => 158, + 'property_list' => 157 } }, - {#State 141 + {#State 143 ACTIONS => { - "," => -73, - "void" => 160, - ")" => -73 + "," => -75, + "void" => 162, + ")" => -75 }, - DEFAULT => -80, + DEFAULT => -82, GOTOS => { - 'base_element' => 157, - 'element_list2' => 159, - 'property_list' => 158 + 'base_element' => 159, + 'element_list2' => 161, + 'property_list' => 160 } }, - {#State 142 + {#State 144 ACTIONS => { - ";" => 161 + ";" => 163 } }, - {#State 143 + {#State 145 ACTIONS => { - "[" => 152, - "=" => 163 + "[" => 154, + "=" => 165 }, GOTOS => { - 'array_len' => 162 + 'array_len' => 164 } }, - {#State 144 - DEFAULT => -70 + {#State 146 + DEFAULT => -72 }, - {#State 145 + {#State 147 ACTIONS => { - "}" => 164 + "}" => 166 }, - DEFAULT => -80, + DEFAULT => -82, GOTOS => { - 'base_element' => 165, - 'property_list' => 158 + 'base_element' => 167, + 'property_list' => 160 } }, - {#State 146 - ACTIONS => { - "=" => 166 - }, - DEFAULT => -45 - }, - {#State 147 - DEFAULT => -43 - }, {#State 148 ACTIONS => { - "}" => 167, - "," => 168 - } + "=" => 168 + }, + DEFAULT => -47 }, {#State 149 - DEFAULT => -51 + DEFAULT => -45 }, {#State 150 ACTIONS => { @@ -1773,52 +1772,61 @@ sub new { } }, {#State 151 + DEFAULT => -53 + }, + {#State 152 ACTIONS => { - "=" => 171 + "}" => 171, + "," => 172 } }, - {#State 152 + {#State 153 + ACTIONS => { + "=" => 173 + } + }, + {#State 154 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, - "]" => 172, + "]" => 174, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, - 'anytext' => 173, + 'anytext' => 175, 'text' => 24, 'constant' => 27 } }, - {#State 153 + {#State 155 ACTIONS => { - ";" => 174 + ";" => 176 } }, - {#State 154 - DEFAULT => -64 + {#State 156 + DEFAULT => -66 }, - {#State 155 + {#State 157 ACTIONS => { "[" => 7 }, - DEFAULT => -80, + DEFAULT => -82, GOTOS => { - 'base_or_empty' => 175, - 'base_element' => 176, - 'empty_element' => 177, - 'property_list' => 178 + 'base_or_empty' => 177, + 'base_element' => 178, + 'empty_element' => 179, + 'property_list' => 180 } }, - {#State 156 - DEFAULT => -63 + {#State 158 + DEFAULT => -65 }, - {#State 157 - DEFAULT => -75 + {#State 159 + DEFAULT => -77 }, - {#State 158 + {#State 160 ACTIONS => { 'IDENTIFIER' => 9, "signed" => 102, @@ -1830,7 +1838,7 @@ sub new { "[" => 7, "struct" => 63 }, - DEFAULT => -33, + DEFAULT => -35, GOTOS => { 'existingtype' => 101, 'bitmap' => 67, @@ -1838,112 +1846,112 @@ sub new { 'identifier' => 99, 'struct' => 59, 'enum' => 61, - 'type' => 179, + 'type' => 181, 'union' => 70, 'sign' => 100 } }, - {#State 159 + {#State 161 ACTIONS => { - "," => 180, - ")" => 181 + "," => 182, + ")" => 183 } }, - {#State 160 - DEFAULT => -74 + {#State 162 + DEFAULT => -76 }, - {#State 161 + {#State 163 DEFAULT => -20 }, - {#State 162 + {#State 164 ACTIONS => { - "=" => 182 + "=" => 184 } }, - {#State 163 + {#State 165 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, - 'anytext' => 183, + 'anytext' => 185, 'text' => 24, 'constant' => 27 } }, - {#State 164 - DEFAULT => -54 + {#State 166 + DEFAULT => -56 }, - {#State 165 + {#State 167 ACTIONS => { - ";" => 184 + ";" => 186 } }, - {#State 166 + {#State 168 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, - 'anytext' => 185, + 'anytext' => 187, 'text' => 24, 'constant' => 27 } }, - {#State 167 - DEFAULT => -39 + {#State 169 + DEFAULT => -41 }, - {#State 168 + {#State 170 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 146, - 'enum_element' => 186 + 'identifier' => 148, + 'enum_element' => 188 } }, - {#State 169 - DEFAULT => -47 + {#State 171 + DEFAULT => -49 }, - {#State 170 + {#State 172 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { - 'identifier' => 151, - 'bitmap_element' => 187 + 'identifier' => 153, + 'bitmap_element' => 189 } }, - {#State 171 + {#State 173 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, - 'anytext' => 188, + 'anytext' => 190, 'text' => 24, 'constant' => 27 } }, - {#State 172 + {#State 174 ACTIONS => { - "[" => 152 + "[" => 154 }, - DEFAULT => -77, + DEFAULT => -79, GOTOS => { - 'array_len' => 189 + 'array_len' => 191 } }, - {#State 173 + {#State 175 ACTIONS => { "-" => 35, ":" => 34, @@ -1959,30 +1967,30 @@ sub new { "(" => 44, "*" => 46, "." => 47, - "]" => 190, + "]" => 192, ">" => 48 } }, - {#State 174 - DEFAULT => -25 + {#State 176 + DEFAULT => -27 }, - {#State 175 - DEFAULT => -61 + {#State 177 + DEFAULT => -63 }, - {#State 176 + {#State 178 ACTIONS => { - ";" => 191 + ";" => 193 } }, - {#State 177 - DEFAULT => -60 + {#State 179 + DEFAULT => -62 }, - {#State 178 + {#State 180 ACTIONS => { 'IDENTIFIER' => 9, "signed" => 102, "union" => 52, - ";" => 192, + ";" => 194, "enum" => 65, "bitmap" => 66, 'void' => 97, @@ -1990,7 +1998,7 @@ sub new { "[" => 7, "struct" => 63 }, - DEFAULT => -33, + DEFAULT => -35, GOTOS => { 'existingtype' => 101, 'bitmap' => 67, @@ -1998,50 +2006,50 @@ sub new { 'identifier' => 99, 'struct' => 59, 'enum' => 61, - 'type' => 179, + 'type' => 181, 'union' => 70, 'sign' => 100 } }, - {#State 179 - DEFAULT => -69, + {#State 181 + DEFAULT => -71, GOTOS => { - 'pointers' => 193 + 'pointers' => 195 } }, - {#State 180 - DEFAULT => -80, + {#State 182 + DEFAULT => -82, GOTOS => { - 'base_element' => 194, - 'property_list' => 158 + 'base_element' => 196, + 'property_list' => 160 } }, - {#State 181 + {#State 183 ACTIONS => { - ";" => 195 + ";" => 197 } }, - {#State 182 + {#State 184 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'identifier' => 23, - 'anytext' => 196, + 'anytext' => 198, 'text' => 24, 'constant' => 27 } }, - {#State 183 + {#State 185 ACTIONS => { "-" => 35, ":" => 34, "?" => 36, "<" => 37, - ";" => 197, + ";" => 199, "+" => 39, "~" => 38, "&" => 41, @@ -2055,10 +2063,10 @@ sub new { ">" => 48 } }, - {#State 184 - DEFAULT => -72 + {#State 186 + DEFAULT => -74 }, - {#State 185 + {#State 187 ACTIONS => { "-" => 35, ":" => 34, @@ -2076,15 +2084,15 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -46 + DEFAULT => -48 }, - {#State 186 - DEFAULT => -44 + {#State 188 + DEFAULT => -46 }, - {#State 187 - DEFAULT => -52 + {#State 189 + DEFAULT => -54 }, - {#State 188 + {#State 190 ACTIONS => { "-" => 35, ":" => 34, @@ -2102,48 +2110,48 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -53 + DEFAULT => -55 }, - {#State 189 - DEFAULT => -78 + {#State 191 + DEFAULT => -80 }, - {#State 190 + {#State 192 ACTIONS => { - "[" => 152 + "[" => 154 }, - DEFAULT => -77, + DEFAULT => -79, GOTOS => { - 'array_len' => 198 + 'array_len' => 200 } }, - {#State 191 - DEFAULT => -59 + {#State 193 + DEFAULT => -61 }, - {#State 192 - DEFAULT => -58 + {#State 194 + DEFAULT => -60 }, - {#State 193 + {#State 195 ACTIONS => { 'IDENTIFIER' => 9, - "*" => 144 + "*" => 146 }, GOTOS => { - 'identifier' => 199 + 'identifier' => 201 } }, - {#State 194 - DEFAULT => -76 + {#State 196 + DEFAULT => -78 }, - {#State 195 + {#State 197 DEFAULT => -19 }, - {#State 196 + {#State 198 ACTIONS => { "-" => 35, ":" => 34, "?" => 36, "<" => 37, - ";" => 200, + ";" => 202, "+" => 39, "~" => 38, "&" => 41, @@ -2157,26 +2165,26 @@ sub new { ">" => 48 } }, - {#State 197 + {#State 199 DEFAULT => -17 }, - {#State 198 - DEFAULT => -79 + {#State 200 + DEFAULT => -81 }, - {#State 199 + {#State 201 ACTIONS => { - "[" => 152 + "[" => 154 }, - DEFAULT => -77, + DEFAULT => -79, GOTOS => { - 'array_len' => 201 + 'array_len' => 203 } }, - {#State 200 + {#State 202 DEFAULT => -18 }, - {#State 201 - DEFAULT => -68 + {#State 203 + DEFAULT => -70 } ], yyrules => @@ -2190,19 +2198,19 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "idl.yp" +#line 19 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "idl.yp" +#line 20 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'coclass', 7, sub -#line 24 "idl.yp" +#line 24 "pidl/idl.yp" {$_[3] => { "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -2218,13 +2226,13 @@ sub [#Rule 6 'interface_names', 4, sub -#line 36 "idl.yp" +#line 36 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'interface', 8, sub -#line 40 "idl.yp" +#line 40 "pidl/idl.yp" {$_[3] => { "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -2241,19 +2249,19 @@ sub [#Rule 9 'base_interface', 2, sub -#line 53 "idl.yp" +#line 53 "pidl/idl.yp" { $_[2] } ], [#Rule 10 'definitions', 1, sub -#line 57 "idl.yp" +#line 57 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 11 'definitions', 2, sub -#line 58 "idl.yp" +#line 58 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 12 @@ -2274,7 +2282,7 @@ sub [#Rule 17 'const', 7, sub -#line 66 "idl.yp" +#line 66 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2288,7 +2296,7 @@ sub [#Rule 18 'const', 8, sub -#line 76 "idl.yp" +#line 76 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2303,7 +2311,7 @@ sub [#Rule 19 'function', 7, sub -#line 90 "idl.yp" +#line 90 "pidl/idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2317,7 +2325,7 @@ sub [#Rule 20 'declare', 5, sub -#line 102 "idl.yp" +#line 102 "pidl/idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2334,25 +2342,36 @@ sub 'decl_type', 1, undef ], [#Rule 23 + 'decl_type', 1, undef + ], + [#Rule 24 'decl_enum', 1, sub -#line 116 "idl.yp" +#line 116 "pidl/idl.yp" {{ "TYPE" => "ENUM" }} ], - [#Rule 24 + [#Rule 25 'decl_bitmap', 1, sub -#line 122 "idl.yp" +#line 122 "pidl/idl.yp" {{ "TYPE" => "BITMAP" }} ], - [#Rule 25 + [#Rule 26 + 'decl_union', 1, +sub +#line 128 "pidl/idl.yp" +{{ + "TYPE" => "UNION" + }} + ], + [#Rule 27 'typedef', 6, sub -#line 128 "idl.yp" +#line 134 "pidl/idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], @@ -2363,163 +2382,163 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 26 + [#Rule 28 'usertype', 1, undef ], - [#Rule 27 + [#Rule 29 'usertype', 1, undef ], - [#Rule 28 + [#Rule 30 'usertype', 1, undef ], - [#Rule 29 + [#Rule 31 'usertype', 1, undef ], - [#Rule 30 + [#Rule 32 'typedecl', 2, sub -#line 141 "idl.yp" +#line 147 "pidl/idl.yp" { $_[1] } ], - [#Rule 31 + [#Rule 33 'sign', 1, undef ], - [#Rule 32 + [#Rule 34 'sign', 1, undef ], - [#Rule 33 + [#Rule 35 'existingtype', 0, undef ], - [#Rule 34 + [#Rule 36 'existingtype', 2, sub -#line 146 "idl.yp" +#line 152 "pidl/idl.yp" { "$_[1] $_[2]" } ], - [#Rule 35 + [#Rule 37 'existingtype', 1, undef ], - [#Rule 36 + [#Rule 38 'type', 1, undef ], - [#Rule 37 + [#Rule 39 'type', 1, undef ], - [#Rule 38 + [#Rule 40 'type', 1, sub -#line 150 "idl.yp" +#line 156 "pidl/idl.yp" { "void" } ], - [#Rule 39 + [#Rule 41 'enum_body', 3, sub -#line 152 "idl.yp" +#line 158 "pidl/idl.yp" { $_[2] } ], - [#Rule 40 + [#Rule 42 'opt_enum_body', 0, undef ], - [#Rule 41 + [#Rule 43 'opt_enum_body', 1, undef ], - [#Rule 42 + [#Rule 44 'enum', 3, sub -#line 155 "idl.yp" +#line 161 "pidl/idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 43 + [#Rule 45 'enum_elements', 1, sub -#line 163 "idl.yp" +#line 169 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 44 + [#Rule 46 'enum_elements', 3, sub -#line 164 "idl.yp" +#line 170 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 45 + [#Rule 47 'enum_element', 1, undef ], - [#Rule 46 + [#Rule 48 'enum_element', 3, sub -#line 168 "idl.yp" +#line 174 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 47 + [#Rule 49 'bitmap_body', 3, sub -#line 171 "idl.yp" +#line 177 "pidl/idl.yp" { $_[2] } ], - [#Rule 48 + [#Rule 50 'opt_bitmap_body', 0, undef ], - [#Rule 49 + [#Rule 51 'opt_bitmap_body', 1, undef ], - [#Rule 50 + [#Rule 52 'bitmap', 3, sub -#line 174 "idl.yp" +#line 180 "pidl/idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 51 + [#Rule 53 'bitmap_elements', 1, sub -#line 182 "idl.yp" +#line 188 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 52 + [#Rule 54 'bitmap_elements', 3, sub -#line 183 "idl.yp" +#line 189 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 53 + [#Rule 55 'bitmap_element', 3, sub -#line 186 "idl.yp" +#line 192 "pidl/idl.yp" { "$_[1] ( $_[3] )" } ], - [#Rule 54 + [#Rule 56 'struct_body', 3, sub -#line 189 "idl.yp" +#line 195 "pidl/idl.yp" { $_[2] } ], - [#Rule 55 + [#Rule 57 'opt_struct_body', 0, undef ], - [#Rule 56 + [#Rule 58 'opt_struct_body', 1, undef ], - [#Rule 57 + [#Rule 59 'struct', 3, sub -#line 193 "idl.yp" +#line 199 "pidl/idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 58 + [#Rule 60 'empty_element', 2, sub -#line 201 "idl.yp" +#line 207 "pidl/idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2530,53 +2549,53 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 59 + [#Rule 61 'base_or_empty', 2, undef ], - [#Rule 60 + [#Rule 62 'base_or_empty', 1, undef ], - [#Rule 61 + [#Rule 63 'optional_base_element', 2, sub -#line 215 "idl.yp" +#line 221 "pidl/idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], - [#Rule 62 + [#Rule 64 'union_elements', 0, undef ], - [#Rule 63 + [#Rule 65 'union_elements', 2, sub -#line 220 "idl.yp" +#line 226 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 64 + [#Rule 66 'union_body', 3, sub -#line 223 "idl.yp" +#line 229 "pidl/idl.yp" { $_[2] } ], - [#Rule 65 + [#Rule 67 'opt_union_body', 0, undef ], - [#Rule 66 + [#Rule 68 'opt_union_body', 1, undef ], - [#Rule 67 + [#Rule 69 'union', 3, sub -#line 227 "idl.yp" +#line 233 "pidl/idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 68 + [#Rule 70 'base_element', 5, sub -#line 235 "idl.yp" +#line 241 "pidl/idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2587,238 +2606,238 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 69 + [#Rule 71 'pointers', 0, sub -#line 249 "idl.yp" +#line 255 "pidl/idl.yp" { 0 } ], - [#Rule 70 + [#Rule 72 'pointers', 2, sub -#line 250 "idl.yp" +#line 256 "pidl/idl.yp" { $_[1]+1 } ], - [#Rule 71 + [#Rule 73 'element_list1', 0, undef ], - [#Rule 72 + [#Rule 74 'element_list1', 3, sub -#line 255 "idl.yp" +#line 261 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 73 + [#Rule 75 'element_list2', 0, undef ], - [#Rule 74 + [#Rule 76 'element_list2', 1, undef ], - [#Rule 75 + [#Rule 77 'element_list2', 1, sub -#line 261 "idl.yp" +#line 267 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 76 + [#Rule 78 'element_list2', 3, sub -#line 262 "idl.yp" +#line 268 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 77 + [#Rule 79 'array_len', 0, undef ], - [#Rule 78 + [#Rule 80 'array_len', 3, sub -#line 267 "idl.yp" +#line 273 "pidl/idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], - [#Rule 79 + [#Rule 81 'array_len', 4, sub -#line 268 "idl.yp" +#line 274 "pidl/idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], - [#Rule 80 + [#Rule 82 'property_list', 0, undef ], - [#Rule 81 + [#Rule 83 'property_list', 4, sub -#line 274 "idl.yp" +#line 280 "pidl/idl.yp" { FlattenHash([$_[1],$_[3]]); } ], - [#Rule 82 + [#Rule 84 'properties', 1, sub -#line 277 "idl.yp" +#line 283 "pidl/idl.yp" { $_[1] } ], - [#Rule 83 + [#Rule 85 'properties', 3, sub -#line 278 "idl.yp" +#line 284 "pidl/idl.yp" { FlattenHash([$_[1], $_[3]]); } ], - [#Rule 84 + [#Rule 86 'property', 1, sub -#line 281 "idl.yp" +#line 287 "pidl/idl.yp" {{ "$_[1]" => "1" }} ], - [#Rule 85 + [#Rule 87 'property', 4, sub -#line 282 "idl.yp" +#line 288 "pidl/idl.yp" {{ "$_[1]" => "$_[3]" }} ], - [#Rule 86 + [#Rule 88 'listtext', 1, undef ], - [#Rule 87 + [#Rule 89 'listtext', 3, sub -#line 287 "idl.yp" +#line 293 "pidl/idl.yp" { "$_[1] $_[3]" } ], - [#Rule 88 + [#Rule 90 'commalisttext', 1, undef ], - [#Rule 89 + [#Rule 91 'commalisttext', 3, sub -#line 292 "idl.yp" +#line 298 "pidl/idl.yp" { "$_[1],$_[3]" } ], - [#Rule 90 + [#Rule 92 'anytext', 0, sub -#line 296 "idl.yp" +#line 302 "pidl/idl.yp" { "" } ], - [#Rule 91 - 'anytext', 1, undef - ], - [#Rule 92 - 'anytext', 1, undef - ], [#Rule 93 'anytext', 1, undef ], [#Rule 94 - 'anytext', 3, -sub -#line 298 "idl.yp" -{ "$_[1]$_[2]$_[3]" } + 'anytext', 1, undef ], [#Rule 95 - 'anytext', 3, -sub -#line 299 "idl.yp" -{ "$_[1]$_[2]$_[3]" } + 'anytext', 1, undef ], [#Rule 96 'anytext', 3, sub -#line 300 "idl.yp" +#line 304 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 97 'anytext', 3, sub -#line 301 "idl.yp" +#line 305 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 98 'anytext', 3, sub -#line 302 "idl.yp" +#line 306 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 99 'anytext', 3, sub -#line 303 "idl.yp" +#line 307 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 100 'anytext', 3, sub -#line 304 "idl.yp" +#line 308 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 101 'anytext', 3, sub -#line 305 "idl.yp" +#line 309 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 102 'anytext', 3, sub -#line 306 "idl.yp" +#line 310 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 103 'anytext', 3, sub -#line 307 "idl.yp" +#line 311 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 104 'anytext', 3, sub -#line 308 "idl.yp" +#line 312 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 105 'anytext', 3, sub -#line 309 "idl.yp" +#line 313 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 106 'anytext', 3, sub -#line 310 "idl.yp" +#line 314 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 + 'anytext', 3, +sub +#line 315 "pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 108 + 'anytext', 3, +sub +#line 316 "pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 109 'anytext', 5, sub -#line 311 "idl.yp" +#line 317 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 108 + [#Rule 110 'anytext', 5, sub -#line 312 "idl.yp" +#line 318 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 109 + [#Rule 111 'identifier', 1, undef ], - [#Rule 110 + [#Rule 112 'optional_identifier', 1, undef ], - [#Rule 111 + [#Rule 113 'optional_identifier', 0, undef ], - [#Rule 112 + [#Rule 114 'constant', 1, undef ], - [#Rule 113 + [#Rule 115 'text', 1, sub -#line 326 "idl.yp" +#line 332 "pidl/idl.yp" { "\"$_[1]\"" } ], - [#Rule 114 + [#Rule 116 'optional_semicolon', 0, undef ], - [#Rule 115 + [#Rule 117 'optional_semicolon', 1, undef ] ], @@ -2826,7 +2845,7 @@ sub bless($self,$class); } -#line 337 "idl.yp" +#line 343 "pidl/idl.yp" ##################################################################### -- cgit From 66314777f6667995154b9418aba7dfb26a2b3c88 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 28 Aug 2006 17:12:12 +0000 Subject: r17887: fix c++ warnings metze (This used to be commit ccef1f729089939b9250f1b177d5241f8baaa5eb) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index c35310785a..abc3b786b9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -30,7 +30,7 @@ sub gen_dispatch_switch($) next if not defined($fn->{OPNUM}); pidl "\tcase $fn->{OPNUM}: {\n"; - pidl "\t\tstruct $fn->{NAME} *r2 = r;\n"; + pidl "\t\tstruct $fn->{NAME} *r2 = (struct $fn->{NAME} *)r;\n"; pidl "\t\tif (DEBUGLEVEL >= 10) {\n"; pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_IN, r2);\n"; pidl "\t\t}\n"; @@ -56,7 +56,7 @@ sub gen_reply_switch($) next if not defined($fn->{OPNUM}); pidl "\tcase $fn->{OPNUM}: {\n"; - pidl "\t\tstruct $fn->{NAME} *r2 = r;\n"; + pidl "\t\tstruct $fn->{NAME} *r2 = (struct $fn->{NAME} *)r;\n"; pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} replied async\\n\"));\n"; pidl "\t\t}\n"; -- cgit From 1e0cb682635b4a8865cbac139b025b715ee24f8f Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 28 Aug 2006 17:18:41 +0000 Subject: r17889: allocate a valid element where the pointer can point to, fix c++ warnings metze (This used to be commit b15e4c7cfa4df3dc429945e4d330a8a9766eb1a6) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 912c4b74f9..bf5e8fe441 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1122,7 +1122,7 @@ sub ParsePtrPull($$$$) # We allocate an array twice # - once just to indicate that it's there, # - then the real allocation... - pidl "NDR_PULL_ALLOC_SIZE($ndr, $var_name, 1);"; + pidl "NDR_PULL_ALLOC($ndr, $var_name);"; } #pidl "memset($var_name, 0, sizeof($var_name));"; -- cgit From 0329d755a7611ba3897fc1ee9bdce410cc33d7f8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 30 Aug 2006 11:29:34 +0000 Subject: r17930: Merge noinclude branch: * Move dlinklist.h, smb.h to subsystem-specific directories * Clean up ads.h and move what is left of it to dsdb/ (only place where it's used) (This used to be commit f7afa1cb77f3cfa7020b57de12e6003db7cfcc42) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index 2d710f3eb6..35456b1cfb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -18,7 +18,7 @@ $VERSION = '0.01'; sub is_intree() { - return -f "include/smb.h"; + return -f "kdc/kdc.c"; } # Return an #include line depending on whether this build is an in-tree -- cgit From c92781b333de6d9f7e5a9330ad4b1681c402cf91 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 6 Sep 2006 22:25:54 +0000 Subject: r18194: Allow empty bitmap {} declarations. (This used to be commit 084b5002b9a8c9790ce81480fe26d57e52789dbb) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 689 +++++++++++++++++++------------------ 1 file changed, 351 insertions(+), 338 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index dddbb26e76..b9c39f186e 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -509,7 +509,7 @@ sub new { ACTIONS => { '' => 2 }, - DEFAULT => -82, + DEFAULT => -84, GOTOS => { 'interface' => 3, 'coclass' => 4, @@ -559,7 +559,7 @@ sub new { } }, {#State 9 - DEFAULT => -111 + DEFAULT => -113 }, {#State 10 ACTIONS => { @@ -570,10 +570,10 @@ sub new { ACTIONS => { "(" => 16 }, - DEFAULT => -86 + DEFAULT => -88 }, {#State 12 - DEFAULT => -84 + DEFAULT => -86 }, {#State 13 ACTIONS => { @@ -602,7 +602,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'listtext' => 26, @@ -621,7 +621,7 @@ sub new { } }, {#State 18 - DEFAULT => -83 + DEFAULT => -85 }, {#State 19 ACTIONS => { @@ -643,13 +643,13 @@ sub new { } }, {#State 22 - DEFAULT => -115 + DEFAULT => -117 }, {#State 23 - DEFAULT => -93 + DEFAULT => -95 }, {#State 24 - DEFAULT => -95 + DEFAULT => -97 }, {#State 25 ACTIONS => { @@ -669,7 +669,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -88 + DEFAULT => -90 }, {#State 26 ACTIONS => { @@ -678,13 +678,13 @@ sub new { } }, {#State 27 - DEFAULT => -94 + DEFAULT => -96 }, {#State 28 - DEFAULT => -114 + DEFAULT => -116 }, {#State 29 - DEFAULT => -85 + DEFAULT => -87 }, {#State 30 DEFAULT => -9 @@ -699,7 +699,7 @@ sub new { "const" => 60, "struct" => 63 }, - DEFAULT => -82, + DEFAULT => -84, GOTOS => { 'typedecl' => 64, 'function' => 53, @@ -720,7 +720,7 @@ sub new { ACTIONS => { ";" => 71 }, - DEFAULT => -116, + DEFAULT => -118, GOTOS => { 'optional_semicolon' => 72 } @@ -739,7 +739,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 74, @@ -753,7 +753,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 75, @@ -767,7 +767,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 76, @@ -781,7 +781,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 77, @@ -795,7 +795,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 78, @@ -809,7 +809,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 79, @@ -823,7 +823,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 80, @@ -838,7 +838,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 82, @@ -852,7 +852,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 83, @@ -866,7 +866,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 84, @@ -880,7 +880,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 80, @@ -895,7 +895,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 86, @@ -909,7 +909,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 87, @@ -923,7 +923,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 88, @@ -937,7 +937,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 89, @@ -951,7 +951,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 90, @@ -960,10 +960,10 @@ sub new { } }, {#State 50 - DEFAULT => -87 + DEFAULT => -89 }, {#State 51 - DEFAULT => -82, + DEFAULT => -84, GOTOS => { 'property_list' => 91 } @@ -972,7 +972,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -113, + DEFAULT => -115, GOTOS => { 'optional_identifier' => 93 } @@ -991,7 +991,7 @@ sub new { "const" => 60, "struct" => 63 }, - DEFAULT => -82, + DEFAULT => -84, GOTOS => { 'typedecl' => 64, 'function' => 53, @@ -1040,7 +1040,7 @@ sub new { DEFAULT => -10 }, {#State 58 - DEFAULT => -82, + DEFAULT => -84, GOTOS => { 'property_list' => 105 } @@ -1066,7 +1066,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -113, + DEFAULT => -115, GOTOS => { 'optional_identifier' => 107 } @@ -1078,7 +1078,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -113, + DEFAULT => -115, GOTOS => { 'optional_identifier' => 108 } @@ -1087,7 +1087,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 92 }, - DEFAULT => -113, + DEFAULT => -115, GOTOS => { 'optional_identifier' => 109 } @@ -1105,7 +1105,7 @@ sub new { DEFAULT => -29 }, {#State 71 - DEFAULT => -117 + DEFAULT => -119 }, {#State 72 DEFAULT => -4 @@ -1133,7 +1133,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -105 + DEFAULT => -107 }, {#State 75 ACTIONS => { @@ -1144,7 +1144,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -96 + DEFAULT => -98 }, {#State 76 ACTIONS => { @@ -1164,7 +1164,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -104 + DEFAULT => -106 }, {#State 77 ACTIONS => { @@ -1184,7 +1184,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -100 + DEFAULT => -102 }, {#State 78 ACTIONS => { @@ -1204,7 +1204,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -108 + DEFAULT => -110 }, {#State 79 ACTIONS => { @@ -1215,7 +1215,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -107 + DEFAULT => -109 }, {#State 80 ACTIONS => { @@ -1235,7 +1235,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -90 + DEFAULT => -92 }, {#State 81 ACTIONS => { @@ -1252,7 +1252,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -102 + DEFAULT => -104 }, {#State 83 ACTIONS => { @@ -1263,7 +1263,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -103 + DEFAULT => -105 }, {#State 84 ACTIONS => { @@ -1283,7 +1283,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -106 + DEFAULT => -108 }, {#State 85 ACTIONS => { @@ -1300,7 +1300,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -101 + DEFAULT => -103 }, {#State 87 ACTIONS => { @@ -1311,7 +1311,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -98 + DEFAULT => -100 }, {#State 88 ACTIONS => { @@ -1322,7 +1322,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -97 + DEFAULT => -99 }, {#State 89 ACTIONS => { @@ -1333,7 +1333,7 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -99 + DEFAULT => -101 }, {#State 90 ACTIONS => { @@ -1353,7 +1353,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -89 + DEFAULT => -91 }, {#State 91 ACTIONS => { @@ -1380,13 +1380,13 @@ sub new { } }, {#State 92 - DEFAULT => -112 + DEFAULT => -114 }, {#State 93 ACTIONS => { "{" => 116 }, - DEFAULT => -67, + DEFAULT => -69, GOTOS => { 'union_body' => 117, 'opt_union_body' => 115 @@ -1396,7 +1396,7 @@ sub new { ACTIONS => { ";" => 71 }, - DEFAULT => -116, + DEFAULT => -118, GOTOS => { 'optional_semicolon' => 118 } @@ -1456,7 +1456,7 @@ sub new { } }, {#State 106 - DEFAULT => -71, + DEFAULT => -73, GOTOS => { 'pointers' => 128 } @@ -1465,7 +1465,7 @@ sub new { ACTIONS => { "{" => 130 }, - DEFAULT => -57, + DEFAULT => -59, GOTOS => { 'struct_body' => 129, 'opt_struct_body' => 131 @@ -1500,7 +1500,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 138, @@ -1514,7 +1514,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 139, @@ -1528,7 +1528,7 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, 'anytext' => 140, @@ -1545,16 +1545,16 @@ sub new { } }, {#State 115 - DEFAULT => -69 + DEFAULT => -71 }, {#State 116 - DEFAULT => -64, + DEFAULT => -66, GOTOS => { 'union_elements' => 142 } }, {#State 117 - DEFAULT => -68 + DEFAULT => -70 }, {#State 118 DEFAULT => -7 @@ -1603,16 +1603,16 @@ sub new { } }, {#State 129 - DEFAULT => -58 + DEFAULT => -60 }, {#State 130 - DEFAULT => -73, + DEFAULT => -75, GOTOS => { 'element_list1' => 147 } }, {#State 131 - DEFAULT => -59 + DEFAULT => -61 }, {#State 132 ACTIONS => { @@ -1637,10 +1637,12 @@ sub new { ACTIONS => { 'IDENTIFIER' => 9 }, + DEFAULT => -55, GOTOS => { 'identifier' => 153, - 'bitmap_elements' => 152, - 'bitmap_element' => 151 + 'bitmap_element' => 152, + 'bitmap_elements' => 151, + 'opt_bitmap_elements' => 154 } }, {#State 137 @@ -1664,7 +1666,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -110 + DEFAULT => -112 }, {#State 139 ACTIONS => { @@ -1684,7 +1686,7 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -91 + DEFAULT => -93 }, {#State 140 ACTIONS => { @@ -1695,70 +1697,70 @@ sub new { "{" => 40, "=" => 43 }, - DEFAULT => -109 + DEFAULT => -111 }, {#State 141 ACTIONS => { - "[" => 154 + "[" => 155 }, - DEFAULT => -79, + DEFAULT => -81, GOTOS => { - 'array_len' => 155 + 'array_len' => 156 } }, {#State 142 ACTIONS => { - "}" => 156 + "}" => 157 }, - DEFAULT => -82, + DEFAULT => -84, GOTOS => { - 'optional_base_element' => 158, - 'property_list' => 157 + 'optional_base_element' => 159, + 'property_list' => 158 } }, {#State 143 ACTIONS => { - "," => -75, - "void" => 162, - ")" => -75 + "," => -77, + "void" => 163, + ")" => -77 }, - DEFAULT => -82, + DEFAULT => -84, GOTOS => { - 'base_element' => 159, - 'element_list2' => 161, - 'property_list' => 160 + 'base_element' => 160, + 'element_list2' => 162, + 'property_list' => 161 } }, {#State 144 ACTIONS => { - ";" => 163 + ";" => 164 } }, {#State 145 ACTIONS => { - "[" => 154, - "=" => 165 + "[" => 155, + "=" => 166 }, GOTOS => { - 'array_len' => 164 + 'array_len' => 165 } }, {#State 146 - DEFAULT => -72 + DEFAULT => -74 }, {#State 147 ACTIONS => { - "}" => 166 + "}" => 167 }, - DEFAULT => -82, + DEFAULT => -84, GOTOS => { - 'base_element' => 167, - 'property_list' => 160 + 'base_element' => 168, + 'property_list' => 161 } }, {#State 148 ACTIONS => { - "=" => 168 + "=" => 169 }, DEFAULT => -47 }, @@ -1767,18 +1769,18 @@ sub new { }, {#State 150 ACTIONS => { - "}" => 169, - "," => 170 + "}" => 170, + "," => 171 } }, {#State 151 - DEFAULT => -53 - }, - {#State 152 ACTIONS => { - "}" => 171, "," => 172 - } + }, + DEFAULT => -56 + }, + {#State 152 + DEFAULT => -53 }, {#State 153 ACTIONS => { @@ -1786,47 +1788,52 @@ sub new { } }, {#State 154 + ACTIONS => { + "}" => 174 + } + }, + {#State 155 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, - "]" => 174, + "]" => 175, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, - 'anytext' => 175, + 'anytext' => 176, 'text' => 24, 'constant' => 27 } }, - {#State 155 + {#State 156 ACTIONS => { - ";" => 176 + ";" => 177 } }, - {#State 156 - DEFAULT => -66 - }, {#State 157 + DEFAULT => -68 + }, + {#State 158 ACTIONS => { "[" => 7 }, - DEFAULT => -82, + DEFAULT => -84, GOTOS => { - 'base_or_empty' => 177, - 'base_element' => 178, - 'empty_element' => 179, - 'property_list' => 180 + 'base_or_empty' => 178, + 'base_element' => 179, + 'empty_element' => 180, + 'property_list' => 181 } }, - {#State 158 - DEFAULT => -65 - }, {#State 159 - DEFAULT => -77 + DEFAULT => -67 }, {#State 160 + DEFAULT => -79 + }, + {#State 161 ACTIONS => { 'IDENTIFIER' => 9, "signed" => 102, @@ -1846,86 +1853,83 @@ sub new { 'identifier' => 99, 'struct' => 59, 'enum' => 61, - 'type' => 181, + 'type' => 182, 'union' => 70, 'sign' => 100 } }, - {#State 161 + {#State 162 ACTIONS => { - "," => 182, - ")" => 183 + "," => 183, + ")" => 184 } }, - {#State 162 - DEFAULT => -76 - }, {#State 163 - DEFAULT => -20 + DEFAULT => -78 }, {#State 164 + DEFAULT => -20 + }, + {#State 165 ACTIONS => { - "=" => 184 + "=" => 185 } }, - {#State 165 + {#State 166 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, - 'anytext' => 185, + 'anytext' => 186, 'text' => 24, 'constant' => 27 } }, - {#State 166 - DEFAULT => -56 - }, {#State 167 + DEFAULT => -58 + }, + {#State 168 ACTIONS => { - ";" => 186 + ";" => 187 } }, - {#State 168 + {#State 169 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, - 'anytext' => 187, + 'anytext' => 188, 'text' => 24, 'constant' => 27 } }, - {#State 169 + {#State 170 DEFAULT => -41 }, - {#State 170 + {#State 171 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { 'identifier' => 148, - 'enum_element' => 188 + 'enum_element' => 189 } }, - {#State 171 - DEFAULT => -49 - }, {#State 172 ACTIONS => { 'IDENTIFIER' => 9 }, GOTOS => { 'identifier' => 153, - 'bitmap_element' => 189 + 'bitmap_element' => 190 } }, {#State 173 @@ -1934,24 +1938,27 @@ sub new { 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, - 'anytext' => 190, + 'anytext' => 191, 'text' => 24, 'constant' => 27 } }, {#State 174 + DEFAULT => -49 + }, + {#State 175 ACTIONS => { - "[" => 154 + "[" => 155 }, - DEFAULT => -79, + DEFAULT => -81, GOTOS => { - 'array_len' => 191 + 'array_len' => 192 } }, - {#State 175 + {#State 176 ACTIONS => { "-" => 35, ":" => 34, @@ -1967,30 +1974,30 @@ sub new { "(" => 44, "*" => 46, "." => 47, - "]" => 192, + "]" => 193, ">" => 48 } }, - {#State 176 - DEFAULT => -27 - }, {#State 177 - DEFAULT => -63 + DEFAULT => -27 }, {#State 178 - ACTIONS => { - ";" => 193 - } + DEFAULT => -65 }, {#State 179 - DEFAULT => -62 + ACTIONS => { + ";" => 194 + } }, {#State 180 + DEFAULT => -64 + }, + {#State 181 ACTIONS => { 'IDENTIFIER' => 9, "signed" => 102, "union" => 52, - ";" => 194, + ";" => 195, "enum" => 65, "bitmap" => 66, 'void' => 97, @@ -2006,50 +2013,50 @@ sub new { 'identifier' => 99, 'struct' => 59, 'enum' => 61, - 'type' => 181, + 'type' => 182, 'union' => 70, 'sign' => 100 } }, - {#State 181 - DEFAULT => -71, + {#State 182 + DEFAULT => -73, GOTOS => { - 'pointers' => 195 + 'pointers' => 196 } }, - {#State 182 - DEFAULT => -82, + {#State 183 + DEFAULT => -84, GOTOS => { - 'base_element' => 196, - 'property_list' => 160 + 'base_element' => 197, + 'property_list' => 161 } }, - {#State 183 + {#State 184 ACTIONS => { - ";" => 197 + ";" => 198 } }, - {#State 184 + {#State 185 ACTIONS => { 'CONSTANT' => 28, 'TEXT' => 22, 'IDENTIFIER' => 9 }, - DEFAULT => -92, + DEFAULT => -94, GOTOS => { 'identifier' => 23, - 'anytext' => 198, + 'anytext' => 199, 'text' => 24, 'constant' => 27 } }, - {#State 185 + {#State 186 ACTIONS => { "-" => 35, ":" => 34, "?" => 36, "<" => 37, - ";" => 199, + ";" => 200, "+" => 39, "~" => 38, "&" => 41, @@ -2063,10 +2070,10 @@ sub new { ">" => 48 } }, - {#State 186 - DEFAULT => -74 - }, {#State 187 + DEFAULT => -76 + }, + {#State 188 ACTIONS => { "-" => 35, ":" => 34, @@ -2086,13 +2093,13 @@ sub new { }, DEFAULT => -48 }, - {#State 188 + {#State 189 DEFAULT => -46 }, - {#State 189 + {#State 190 DEFAULT => -54 }, - {#State 190 + {#State 191 ACTIONS => { "-" => 35, ":" => 34, @@ -2110,48 +2117,48 @@ sub new { "." => 47, ">" => 48 }, - DEFAULT => -55 - }, - {#State 191 - DEFAULT => -80 + DEFAULT => -57 }, {#State 192 + DEFAULT => -82 + }, + {#State 193 ACTIONS => { - "[" => 154 + "[" => 155 }, - DEFAULT => -79, + DEFAULT => -81, GOTOS => { - 'array_len' => 200 + 'array_len' => 201 } }, - {#State 193 - DEFAULT => -61 - }, {#State 194 - DEFAULT => -60 + DEFAULT => -63 }, {#State 195 + DEFAULT => -62 + }, + {#State 196 ACTIONS => { 'IDENTIFIER' => 9, "*" => 146 }, GOTOS => { - 'identifier' => 201 + 'identifier' => 202 } }, - {#State 196 - DEFAULT => -78 - }, {#State 197 - DEFAULT => -19 + DEFAULT => -80 }, {#State 198 + DEFAULT => -19 + }, + {#State 199 ACTIONS => { "-" => 35, ":" => 34, "?" => 36, "<" => 37, - ";" => 202, + ";" => 203, "+" => 39, "~" => 38, "&" => 41, @@ -2165,26 +2172,26 @@ sub new { ">" => 48 } }, - {#State 199 - DEFAULT => -17 - }, {#State 200 - DEFAULT => -81 + DEFAULT => -17 }, {#State 201 + DEFAULT => -83 + }, + {#State 202 ACTIONS => { - "[" => 154 + "[" => 155 }, - DEFAULT => -79, + DEFAULT => -81, GOTOS => { - 'array_len' => 203 + 'array_len' => 204 } }, - {#State 202 + {#State 203 DEFAULT => -18 }, - {#State 203 - DEFAULT => -70 + {#State 204 + DEFAULT => -72 } ], yyrules => @@ -2198,19 +2205,19 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "pidl/idl.yp" +#line 19 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "pidl/idl.yp" +#line 20 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'coclass', 7, sub -#line 24 "pidl/idl.yp" +#line 24 "idl.yp" {$_[3] => { "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -2226,13 +2233,13 @@ sub [#Rule 6 'interface_names', 4, sub -#line 36 "pidl/idl.yp" +#line 36 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'interface', 8, sub -#line 40 "pidl/idl.yp" +#line 40 "idl.yp" {$_[3] => { "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -2249,19 +2256,19 @@ sub [#Rule 9 'base_interface', 2, sub -#line 53 "pidl/idl.yp" +#line 53 "idl.yp" { $_[2] } ], [#Rule 10 'definitions', 1, sub -#line 57 "pidl/idl.yp" +#line 57 "idl.yp" { [ $_[1] ] } ], [#Rule 11 'definitions', 2, sub -#line 58 "pidl/idl.yp" +#line 58 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 12 @@ -2282,7 +2289,7 @@ sub [#Rule 17 'const', 7, sub -#line 66 "pidl/idl.yp" +#line 66 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2296,7 +2303,7 @@ sub [#Rule 18 'const', 8, sub -#line 76 "pidl/idl.yp" +#line 76 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2311,7 +2318,7 @@ sub [#Rule 19 'function', 7, sub -#line 90 "pidl/idl.yp" +#line 90 "idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2325,7 +2332,7 @@ sub [#Rule 20 'declare', 5, sub -#line 102 "pidl/idl.yp" +#line 102 "idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2347,7 +2354,7 @@ sub [#Rule 24 'decl_enum', 1, sub -#line 116 "pidl/idl.yp" +#line 116 "idl.yp" {{ "TYPE" => "ENUM" }} @@ -2355,7 +2362,7 @@ sub [#Rule 25 'decl_bitmap', 1, sub -#line 122 "pidl/idl.yp" +#line 122 "idl.yp" {{ "TYPE" => "BITMAP" }} @@ -2363,7 +2370,7 @@ sub [#Rule 26 'decl_union', 1, sub -#line 128 "pidl/idl.yp" +#line 128 "idl.yp" {{ "TYPE" => "UNION" }} @@ -2371,7 +2378,7 @@ sub [#Rule 27 'typedef', 6, sub -#line 134 "pidl/idl.yp" +#line 134 "idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], @@ -2397,7 +2404,7 @@ sub [#Rule 32 'typedecl', 2, sub -#line 147 "pidl/idl.yp" +#line 147 "idl.yp" { $_[1] } ], [#Rule 33 @@ -2412,7 +2419,7 @@ sub [#Rule 36 'existingtype', 2, sub -#line 152 "pidl/idl.yp" +#line 152 "idl.yp" { "$_[1] $_[2]" } ], [#Rule 37 @@ -2427,13 +2434,13 @@ sub [#Rule 40 'type', 1, sub -#line 156 "pidl/idl.yp" +#line 156 "idl.yp" { "void" } ], [#Rule 41 'enum_body', 3, sub -#line 158 "pidl/idl.yp" +#line 158 "idl.yp" { $_[2] } ], [#Rule 42 @@ -2445,7 +2452,7 @@ sub [#Rule 44 'enum', 3, sub -#line 161 "pidl/idl.yp" +#line 161 "idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], @@ -2455,13 +2462,13 @@ sub [#Rule 45 'enum_elements', 1, sub -#line 169 "pidl/idl.yp" +#line 169 "idl.yp" { [ $_[1] ] } ], [#Rule 46 'enum_elements', 3, sub -#line 170 "pidl/idl.yp" +#line 170 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 47 @@ -2470,13 +2477,13 @@ sub [#Rule 48 'enum_element', 3, sub -#line 174 "pidl/idl.yp" +#line 174 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 49 'bitmap_body', 3, sub -#line 177 "pidl/idl.yp" +#line 177 "idl.yp" { $_[2] } ], [#Rule 50 @@ -2488,7 +2495,7 @@ sub [#Rule 52 'bitmap', 3, sub -#line 180 "pidl/idl.yp" +#line 180 "idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], @@ -2498,47 +2505,53 @@ sub [#Rule 53 'bitmap_elements', 1, sub -#line 188 "pidl/idl.yp" +#line 188 "idl.yp" { [ $_[1] ] } ], [#Rule 54 'bitmap_elements', 3, sub -#line 189 "pidl/idl.yp" +#line 189 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 55 + 'opt_bitmap_elements', 0, undef + ], + [#Rule 56 + 'opt_bitmap_elements', 1, undef + ], + [#Rule 57 'bitmap_element', 3, sub -#line 192 "pidl/idl.yp" +#line 194 "idl.yp" { "$_[1] ( $_[3] )" } ], - [#Rule 56 + [#Rule 58 'struct_body', 3, sub -#line 195 "pidl/idl.yp" +#line 197 "idl.yp" { $_[2] } ], - [#Rule 57 + [#Rule 59 'opt_struct_body', 0, undef ], - [#Rule 58 + [#Rule 60 'opt_struct_body', 1, undef ], - [#Rule 59 + [#Rule 61 'struct', 3, sub -#line 199 "pidl/idl.yp" +#line 201 "idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 60 + [#Rule 62 'empty_element', 2, sub -#line 207 "pidl/idl.yp" +#line 209 "idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2549,53 +2562,53 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 61 + [#Rule 63 'base_or_empty', 2, undef ], - [#Rule 62 + [#Rule 64 'base_or_empty', 1, undef ], - [#Rule 63 + [#Rule 65 'optional_base_element', 2, sub -#line 221 "pidl/idl.yp" +#line 223 "idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], - [#Rule 64 + [#Rule 66 'union_elements', 0, undef ], - [#Rule 65 + [#Rule 67 'union_elements', 2, sub -#line 226 "pidl/idl.yp" +#line 228 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 66 + [#Rule 68 'union_body', 3, sub -#line 229 "pidl/idl.yp" +#line 231 "idl.yp" { $_[2] } ], - [#Rule 67 + [#Rule 69 'opt_union_body', 0, undef ], - [#Rule 68 + [#Rule 70 'opt_union_body', 1, undef ], - [#Rule 69 + [#Rule 71 'union', 3, sub -#line 233 "pidl/idl.yp" +#line 235 "idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 70 + [#Rule 72 'base_element', 5, sub -#line 241 "pidl/idl.yp" +#line 243 "idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2606,238 +2619,238 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 71 + [#Rule 73 'pointers', 0, sub -#line 255 "pidl/idl.yp" +#line 257 "idl.yp" { 0 } ], - [#Rule 72 + [#Rule 74 'pointers', 2, sub -#line 256 "pidl/idl.yp" +#line 258 "idl.yp" { $_[1]+1 } ], - [#Rule 73 + [#Rule 75 'element_list1', 0, undef ], - [#Rule 74 + [#Rule 76 'element_list1', 3, sub -#line 261 "pidl/idl.yp" +#line 263 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 75 + [#Rule 77 'element_list2', 0, undef ], - [#Rule 76 + [#Rule 78 'element_list2', 1, undef ], - [#Rule 77 + [#Rule 79 'element_list2', 1, sub -#line 267 "pidl/idl.yp" +#line 269 "idl.yp" { [ $_[1] ] } ], - [#Rule 78 + [#Rule 80 'element_list2', 3, sub -#line 268 "pidl/idl.yp" +#line 270 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 79 + [#Rule 81 'array_len', 0, undef ], - [#Rule 80 + [#Rule 82 'array_len', 3, sub -#line 273 "pidl/idl.yp" +#line 275 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], - [#Rule 81 + [#Rule 83 'array_len', 4, sub -#line 274 "pidl/idl.yp" +#line 276 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], - [#Rule 82 + [#Rule 84 'property_list', 0, undef ], - [#Rule 83 + [#Rule 85 'property_list', 4, sub -#line 280 "pidl/idl.yp" +#line 282 "idl.yp" { FlattenHash([$_[1],$_[3]]); } ], - [#Rule 84 + [#Rule 86 'properties', 1, sub -#line 283 "pidl/idl.yp" +#line 285 "idl.yp" { $_[1] } ], - [#Rule 85 + [#Rule 87 'properties', 3, sub -#line 284 "pidl/idl.yp" +#line 286 "idl.yp" { FlattenHash([$_[1], $_[3]]); } ], - [#Rule 86 + [#Rule 88 'property', 1, sub -#line 287 "pidl/idl.yp" +#line 289 "idl.yp" {{ "$_[1]" => "1" }} ], - [#Rule 87 + [#Rule 89 'property', 4, sub -#line 288 "pidl/idl.yp" +#line 290 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], - [#Rule 88 + [#Rule 90 'listtext', 1, undef ], - [#Rule 89 + [#Rule 91 'listtext', 3, sub -#line 293 "pidl/idl.yp" +#line 295 "idl.yp" { "$_[1] $_[3]" } ], - [#Rule 90 + [#Rule 92 'commalisttext', 1, undef ], - [#Rule 91 + [#Rule 93 'commalisttext', 3, sub -#line 298 "pidl/idl.yp" +#line 300 "idl.yp" { "$_[1],$_[3]" } ], - [#Rule 92 + [#Rule 94 'anytext', 0, sub -#line 302 "pidl/idl.yp" +#line 304 "idl.yp" { "" } ], - [#Rule 93 - 'anytext', 1, undef - ], - [#Rule 94 - 'anytext', 1, undef - ], [#Rule 95 'anytext', 1, undef ], [#Rule 96 - 'anytext', 3, -sub -#line 304 "pidl/idl.yp" -{ "$_[1]$_[2]$_[3]" } + 'anytext', 1, undef ], [#Rule 97 - 'anytext', 3, -sub -#line 305 "pidl/idl.yp" -{ "$_[1]$_[2]$_[3]" } + 'anytext', 1, undef ], [#Rule 98 'anytext', 3, sub -#line 306 "pidl/idl.yp" +#line 306 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 99 'anytext', 3, sub -#line 307 "pidl/idl.yp" +#line 307 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 100 'anytext', 3, sub -#line 308 "pidl/idl.yp" +#line 308 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 101 'anytext', 3, sub -#line 309 "pidl/idl.yp" +#line 309 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 102 'anytext', 3, sub -#line 310 "pidl/idl.yp" +#line 310 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 103 'anytext', 3, sub -#line 311 "pidl/idl.yp" +#line 311 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 104 'anytext', 3, sub -#line 312 "pidl/idl.yp" +#line 312 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 105 'anytext', 3, sub -#line 313 "pidl/idl.yp" +#line 313 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 106 'anytext', 3, sub -#line 314 "pidl/idl.yp" +#line 314 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 315 "pidl/idl.yp" +#line 315 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 'anytext', 3, sub -#line 316 "pidl/idl.yp" +#line 316 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 109 + 'anytext', 3, +sub +#line 317 "idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 110 + 'anytext', 3, +sub +#line 318 "idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 111 'anytext', 5, sub -#line 317 "pidl/idl.yp" +#line 319 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 110 + [#Rule 112 'anytext', 5, sub -#line 318 "pidl/idl.yp" +#line 320 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 111 + [#Rule 113 'identifier', 1, undef ], - [#Rule 112 + [#Rule 114 'optional_identifier', 1, undef ], - [#Rule 113 + [#Rule 115 'optional_identifier', 0, undef ], - [#Rule 114 + [#Rule 116 'constant', 1, undef ], - [#Rule 115 + [#Rule 117 'text', 1, sub -#line 332 "pidl/idl.yp" +#line 334 "idl.yp" { "\"$_[1]\"" } ], - [#Rule 116 + [#Rule 118 'optional_semicolon', 0, undef ], - [#Rule 117 + [#Rule 119 'optional_semicolon', 1, undef ] ], @@ -2845,7 +2858,7 @@ sub bless($self,$class); } -#line 343 "pidl/idl.yp" +#line 345 "idl.yp" ##################################################################### -- cgit From 4dff1f05f00560adc1deeb09b5e27dacad787783 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 7 Sep 2006 19:46:23 +0000 Subject: r18227: Recognize Samba3 in-tree builds. (This used to be commit 5055430ddfca02a962827bbedf7fbd9987992953) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index 35456b1cfb..eac5104da2 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -18,7 +18,7 @@ $VERSION = '0.01'; sub is_intree() { - return -f "kdc/kdc.c"; + return (-f "kdc/kdc.c" or -f "include/smb.h"); } # Return an #include line depending on whether this build is an in-tree -- cgit From 433ec0ba664c9eb53b26550e25973e2fc538646b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 7 Sep 2006 20:01:17 +0000 Subject: r18228: Don't include Samba4-specific headers when building inside a Samba3 tree. (This used to be commit d0f0d4600acad71ea4993f4e356735433d9bc5f0) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 4 ++- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 39 +++++++++++++++--------- 2 files changed, 27 insertions(+), 16 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index eac5104da2..4ef2daa591 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -18,7 +18,9 @@ $VERSION = '0.01'; sub is_intree() { - return (-f "kdc/kdc.c" or -f "include/smb.h"); + return 4 if (-f "kdc/kdc.c"); + return 3 if (-f "include/smb.h"); + return 0; } # Return an #include line depending on whether this build is an in-tree diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index bf5e8fe441..9e4388e28d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2359,6 +2359,29 @@ sub ParseInterface($$) pidl_hdr "#endif /* _HEADER_NDR_$interface->{NAME} */"; } +sub GenerateIncludes() +{ + if (is_intree()) { + pidl "#include \"includes.h\""; + } else { + pidl "#define _GNU_SOURCE"; + pidl "#include "; + pidl "#include "; + pidl "#include "; + pidl "#include "; + pidl "#include "; + pidl "#include "; + } + + # Samba3 has everything in include/includes.h + if (is_intree() != 3) { + pidl choose_header("libcli/util/nterr.h", "core/nterr.h"); + pidl choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h"); + pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h"); + pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here! + } +} + ##################################################################### # parse a parsed IDL structure back into an IDL file sub Parse($$$) @@ -2376,22 +2399,8 @@ sub Parse($$$) pidl "/* parser auto-generated by pidl */"; pidl ""; - if (is_intree()) { - pidl "#include \"includes.h\""; - } else { - pidl "#define _GNU_SOURCE"; - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; - } - pidl choose_header("libcli/util/nterr.h", "core/nterr.h"); - pidl choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h"); - pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h"); + GenerateIncludes(); pidl "#include \"$ndr_header\"" if ($ndr_header); - pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here! pidl ""; my %needed = (); -- cgit From 25819cfabcb72bfa397cd7bb49700ec80433670e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 7 Sep 2006 20:24:59 +0000 Subject: r18231: Don't use _PUBLIC_ but use __attribute__ directly instead. (This used to be commit 77043ebe25dcca2a6b1a37d3b6095e9c434652d9) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 9e4388e28d..d409450a80 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -208,7 +208,8 @@ sub fn_declare($$$) if (has_property($fn, "public")) { pidl_hdr "$decl;"; - pidl "_PUBLIC_ $decl"; + pidl "__attribute__((visibility(\"default\")))"; + pidl "$decl"; } else { pidl "static $decl"; } @@ -1879,7 +1880,8 @@ sub ParseTypedefPrint($) return if (has_property($e, "noprint")); - pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; + pidl "__attribute__((visibility(\"default\")))"; + pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; pidl "{"; indent; $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME}); @@ -1917,7 +1919,8 @@ sub ParseFunctionPrint($) return if has_property($fn, "noprint"); - pidl "_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; + pidl "__attribute__((visibility(\"default\")))"; + pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; pidl "{"; indent; @@ -2380,6 +2383,11 @@ sub GenerateIncludes() pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h"); pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here! } + + pidl "/* define dummy __attribute__ for systems that don't have it */"; + pidl "#if !(defined(__GNUC__) || defined(__GNUG__) || defined(__attribute__))"; + pidl "#define __attribute__(p) /* nothing */"; + pidl "#endif"; } ##################################################################### -- cgit From 5622eb1deec3f2ac4d0aa72e99e0ed300b9e9d05 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Fri, 8 Sep 2006 05:43:08 +0000 Subject: r18254: reverted r18231 Jelmer, older versions of gcc don't support visibility("default"). See for example the CentOS build here: http://build.samba.org/?function=View+Build;host=lithium;tree=samba4;compiler=gcc;revision=18253 Is there some other way you can think of to do this? (This used to be commit 76496c2f5e37b735e0b303ae20824c92bfa30974) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index d409450a80..9e4388e28d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -208,8 +208,7 @@ sub fn_declare($$$) if (has_property($fn, "public")) { pidl_hdr "$decl;"; - pidl "__attribute__((visibility(\"default\")))"; - pidl "$decl"; + pidl "_PUBLIC_ $decl"; } else { pidl "static $decl"; } @@ -1880,8 +1879,7 @@ sub ParseTypedefPrint($) return if (has_property($e, "noprint")); - pidl "__attribute__((visibility(\"default\")))"; - pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; + pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; pidl "{"; indent; $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME}); @@ -1919,8 +1917,7 @@ sub ParseFunctionPrint($) return if has_property($fn, "noprint"); - pidl "__attribute__((visibility(\"default\")))"; - pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; + pidl "_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; pidl "{"; indent; @@ -2383,11 +2380,6 @@ sub GenerateIncludes() pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h"); pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here! } - - pidl "/* define dummy __attribute__ for systems that don't have it */"; - pidl "#if !(defined(__GNUC__) || defined(__GNUG__) || defined(__attribute__))"; - pidl "#define __attribute__(p) /* nothing */"; - pidl "#endif"; } ##################################################################### -- cgit From 28bd2665c12199596e1ff44d557d418092d0136c Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 8 Sep 2006 14:06:39 +0000 Subject: r18268: for samba3 define _PUBLIC_ empty metze (This used to be commit b2018249b7da4155dde963bf118d4636864b0343) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 9e4388e28d..944a3f3453 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2380,6 +2380,11 @@ sub GenerateIncludes() pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h"); pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here! } + + # Samba3 doesn't have _PUBLIC + if (is_intree() == 3) { + pidl "#define _PUBLIC_"; + } } ##################################################################### -- cgit From 7caf7839f5243546437e75f0f7eec52bcea98d6b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 8 Sep 2006 14:25:52 +0000 Subject: r18270: Samba3 has _PUBLIC_ now. (This used to be commit 9dd6520240fbe3ea8126845a1fa2bdea35c7c4ac) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 5 ----- 1 file changed, 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 944a3f3453..9e4388e28d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2380,11 +2380,6 @@ sub GenerateIncludes() pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h"); pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here! } - - # Samba3 doesn't have _PUBLIC - if (is_intree() == 3) { - pidl "#define _PUBLIC_"; - } } ##################################################################### -- cgit From e26ed8b3e2e6b30de424dea27ed7ca55f2b50c05 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 13 Sep 2006 13:45:36 +0000 Subject: r18470: Remove obsolete client generator code for Samba3 (we're now using the new code that uses libndr) (This used to be commit ea0ef1542f78e3a58d86b5693ec17c145050526b) --- source4/pidl/lib/Parse/Pidl/Samba3/Client.pm | 137 --------------------------- 1 file changed, 137 deletions(-) delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Client.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm deleted file mode 100644 index 9e26e9a21e..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Client.pm +++ /dev/null @@ -1,137 +0,0 @@ -################################################### -# Samba3 NDR client generator for IDL structures -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba3::Client; - -use strict; -use Parse::Pidl::Typelist qw(hasType getType mapType); -use Parse::Pidl::Util qw(has_property ParseExpr); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba3::Types qw(DeclLong); - -use vars qw($VERSION); -$VERSION = '0.01'; - -my $res = ""; -my $tabs = ""; -sub indent() { $tabs.="\t"; } -sub deindent() { $tabs = substr($tabs, 1); } -sub pidl($) { $res .= $tabs.(shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } -sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } - -sub CopyLevel($$$$) -{ - sub CopyLevel($$$$); - my ($e,$l,$argument,$member) = @_; - - if ($l->{TYPE} eq "DATA") { - pidl "*$argument = $member;"; - } elsif ($l->{TYPE} eq "POINTER") { - pidl "if (r.ptr$l->{POINTER_INDEX}_$e->{NAME}) {"; - indent; - pidl "*$argument = talloc_size(mem_ctx, sizeof(void *));"; - CopyLevel($e,GetNextLevel($e,$l),"*$argument", $member); - deindent; - pidl "}"; - } elsif ($l->{TYPE} eq "SWITCH") { - CopyLevel($e,GetNextLevel($e,$l),$argument,$member); - } elsif ($l->{TYPE} eq "ARRAY") { - pidl "*$argument = $member;"; - } -} - -sub ParseFunction($$) -{ - my ($if,$fn) = @_; - - my $inargs = ""; - my $defargs = ""; - foreach (@{$fn->{ELEMENTS}}) { - $defargs .= ", " . DeclLong($_); - if (grep(/in/, @{$_->{DIRECTION}})) { - $inargs .= ", $_->{NAME}"; - } - } - - my $uif = uc($if->{NAME}); - my $ufn = uc($fn->{NAME}); - - pidl "NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"; - pidl "{"; - indent; - pidl "prs_struct qbuf, rbuf;"; - pidl "$uif\_Q_$ufn q;"; - pidl "$uif\_R_$ufn r;"; - pidl ""; - pidl "ZERO_STRUCT(q);"; - pidl "ZERO_STRUCT(r);"; - pidl ""; - pidl "/* Marshall data and send request */"; - pidl ""; - pidl "if (!init_$if->{NAME}_q_$fn->{NAME}(&q$inargs))"; - pidl "\treturn NT_STATUS_INVALID_PARAMETER;"; - pidl ""; - pidl "CLI_DO_RPC(cli, mem_ctx, PI_$uif, $ufn,"; - pidl "\tq, r,"; - pidl "\tqbuf, rbuf, "; - pidl "\t$if->{NAME}_io_q_$fn->{NAME},"; - pidl "\t$if->{NAME}_io_r_$fn->{NAME},"; - pidl "\tNT_STATUS_UNSUCCESSFUL);"; - pidl ""; - pidl "/* Return variables */"; - foreach my $e (@{$fn->{ELEMENTS}}) { - next unless (grep(/out/, @{$e->{DIRECTION}})); - - CopyLevel($e, $e->{LEVELS}[1], $e->{NAME}, "r.$e->{NAME}"); - } - - pidl""; - pidl "/* Return result */"; - if (not $fn->{RETURN_TYPE}) { - pidl "return NT_STATUS_OK;"; - } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { - pidl "return r.status;"; - } elsif ($fn->{RETURN_TYPE} eq "WERROR") { - pidl "return werror_to_ntstatus(r.status);"; - } else { - pidl "/* Sorry, don't know how to convert $fn->{RETURN_TYPE} to NTSTATUS */"; - pidl "return NT_STATUS_OK;"; - } - - deindent; - pidl "}"; - pidl ""; -} - -sub ParseInterface($) -{ - my $if = shift; - - ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); -} - -sub Parse($$) -{ - my($ndr,$filename) = @_; - - $res = ""; - - pidl "/*"; - pidl " * Unix SMB/CIFS implementation."; - pidl " * client auto-generated by pidl. DO NOT MODIFY!"; - pidl " */"; - pidl ""; - pidl "#include \"includes.h\""; - pidl ""; - - foreach (@$ndr) { - ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); - } - - return $res; -} - -1; -- cgit From 0eb9794e9f254445ba8a264c06b8ab21b82619c1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 13 Sep 2006 13:49:17 +0000 Subject: r18471: Remove other Samba3 parser generator support as well - it's no longer necessary as we can use libndr now. (This used to be commit 22142a9f3d5e759742c79a591413e5e8af04b22f) --- source4/pidl/lib/Parse/Pidl/Samba3/Header.pm | 223 --------- source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm | 603 ------------------------- source4/pidl/lib/Parse/Pidl/Samba3/Template.pm | 82 ---- source4/pidl/lib/Parse/Pidl/Samba3/Types.pm | 403 ----------------- 4 files changed, 1311 deletions(-) delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Header.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Template.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Types.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm deleted file mode 100644 index c479b14afa..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Header.pm +++ /dev/null @@ -1,223 +0,0 @@ -################################################### -# Samba3 NDR header generator for IDL structures -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba3::Header; - -use strict; -use Parse::Pidl::Typelist qw(hasType getType); -use Parse::Pidl::Util qw(has_property ParseExpr); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba3::Types qw(DeclShort StringType); - -use vars qw($VERSION); -$VERSION = '0.01'; - -my $res = ""; -my $tabs = ""; -sub indent() { $tabs.="\t"; } -sub deindent() { $tabs = substr($tabs, 1); } -sub pidl($) { $res .= $tabs.(shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } -sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } - -sub ParseElement($) -{ - my $e = shift; - - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "POINTER") { - next if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP"); - pidl "\tuint32 ptr$l->{POINTER_INDEX}_$e->{NAME};"; - } elsif ($l->{TYPE} eq "SWITCH") { - } elsif ($l->{TYPE} eq "DATA") { - my $n = DeclShort($e); - pidl "\t$n;" if ($n); - } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED}) { - my ($t,$f) = StringType($e,$l); - pidl "\t" . uc($t) . " $e->{NAME};"; - return; - } elsif ($l->{TYPE} eq "ARRAY") { - if ($l->{IS_CONFORMANT}) { - pidl "\tuint32 size_$e->{NAME};"; - } - if ($l->{IS_VARYING}) { - pidl "\tuint32 length_$e->{NAME};"; - pidl "\tuint32 offset_$e->{NAME};"; - } - } - } -} - -sub CreateStruct($$$$) -{ - my ($if,$fn,$n,$t) = @_; - - pidl "typedef struct $n {"; - ParseElement($_) foreach (@$t); - - if (not @$t) { - # Some compilers don't like empty structs - pidl "\tuint32 dummy;"; - } - - pidl "} " . uc($n) . ";"; - pidl ""; -} - -sub ParseFunction($$) -{ - my ($if,$fn) = @_; - - my @in = (); - my @out = (); - - foreach (@{$fn->{ELEMENTS}}) { - push (@in, $_) if (grep(/in/, @{$_->{DIRECTION}})); - push (@out, $_) if (grep(/out/, @{$_->{DIRECTION}})); - } - - if (defined($fn->{RETURN_TYPE})) { - push (@out, { - NAME => "status", - TYPE => $fn->{RETURN_TYPE}, - LEVELS => [ - { - TYPE => "DATA", - DATA_TYPE => $fn->{RETURN_TYPE} - } - ] - } ); - } - - # define Q + R structures for functions - - CreateStruct($if, $fn, "$if->{NAME}_q_$fn->{NAME}", \@in); - CreateStruct($if, $fn, "$if->{NAME}_r_$fn->{NAME}", \@out); -} - -sub ParseStruct($$$) -{ - my ($if,$s,$n) = @_; - - CreateStruct($if, $s, "$if->{NAME}_$n", $s->{ELEMENTS}); -} - -sub ParseUnion($$$) -{ - my ($if,$u,$n) = @_; - - my $extra = { - switch_value => $u->{SWITCH_TYPE} - }; - - if (not defined($extra->{switch_value})) { - $extra->{switch_value} = "uint32"; - } - - foreach my $e (@{$u->{ELEMENTS}}) { - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "ARRAY") { - if ($l->{IS_CONFORMANT}) { - $extra->{"size"} = "uint32"; - } - if ($l->{IS_VARYING}) { - $extra->{"length"} = $extra->{"offset"} = "uint32"; - } - } elsif ($l->{TYPE} eq "POINTER") { - $extra->{"ptr$l->{POINTER_INDEX}"} = "uint32"; - } elsif ($l->{TYPE} eq "SWITCH") { - $extra->{"level"} = "uint32"; - } - } - } - - pidl "typedef struct $if->{NAME}_$n\_ctr {"; - indent; - pidl "$extra->{$_} $_;" foreach (keys %$extra); - pidl "union $if->{NAME}_$n {"; - indent; - foreach (@{$u->{ELEMENTS}}) { - next if ($_->{TYPE} eq "EMPTY"); - pidl "\t" . DeclShort($_) . ";"; - } - deindent; - pidl "} u;"; - deindent; - pidl "} ".uc("$if->{NAME}_$n\_ctr") .";"; - pidl ""; -} - -sub ParseEnum($$$) -{ - my ($if,$s,$n) = @_; - - pidl "typedef enum {"; - pidl "$_," foreach (@{$s->{ELEMENTS}}); - pidl "} $n;"; -} - -sub ParseBitmap($$$) -{ - my ($if,$s,$n) = @_; - - pidl "#define $_" foreach (@{$s->{ELEMENTS}}); -} - -sub ParseInterface($) -{ - my $if = shift; - - my $def = "_RPC_" . uc($if->{NAME}) . "_H"; - - pidl ""; - - pidl "\#ifndef $def"; - pidl "\#define $def"; - - pidl ""; - - foreach (@{$if->{FUNCTIONS}}) { - pidl "\#define " . uc($_->{NAME}) . " $_->{OPNUM}" ; - } - - pidl ""; - - foreach (@{$if->{TYPES}}) { - ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "STRUCT"); - ParseEnum($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "ENUM"); - ParseBitmap($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "BITMAP"); - ParseUnion($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "UNION"); - } - - ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); - - foreach (@{$if->{CONSTS}}) { - pidl "$_->{NAME} ($_->{VALUE})"; - } - - pidl "\#endif /* $def */"; -} - -sub Parse($$) -{ - my($ndr,$filename) = @_; - - $res = ""; - $tabs = ""; - - pidl "/*"; - pidl " * Unix SMB/CIFS implementation."; - pidl " * header auto-generated by pidl. DO NOT MODIFY!"; - pidl " */"; - pidl ""; - - # Loop over interfaces - foreach (@{$ndr}) { - ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); - } - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm deleted file mode 100644 index 57fa3867f7..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Parser.pm +++ /dev/null @@ -1,603 +0,0 @@ -################################################### -# Samba3 NDR parser generator for IDL structures -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba3::Parser; - -use strict; -use Parse::Pidl::Typelist qw(hasType getType mapType); -use Parse::Pidl::Util qw(has_property ParseExpr); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba3::Types qw(DeclShort DeclLong InitType DissectType StringType); - -use vars qw($VERSION); -$VERSION = '0.01'; - -use constant PRIMITIVES => 1; -use constant DEFERRED => 2; - -my $res = ""; -my $tabs = ""; -sub indent() { $tabs.="\t"; } -sub deindent() { $tabs = substr($tabs, 1); } -sub pidl($) { $res .= $tabs.(shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } - -#TODO: -# - Add some security checks (array sizes, memory alloc == NULL, etc) -# - Don't add seperate _p and _d functions if there is no deferred data -# - [string] with non-varying arrays and "surrounding" strings -# - subcontext() -# - DATA_BLOB - -sub Align($$) -{ - my ($a,$b) = @_; - - # Only align if previous element was smaller than current one - if ($$a < $b) { - pidl "if (!prs_align_custom(ps, $b))"; - pidl "\treturn False;"; - pidl ""; - } - - $$a = $b; -} - -sub DeclareArrayVariables -{ - my $es = shift; - my $what = shift; - - my $output = 0; - - foreach my $e (@$es) { - foreach my $l (@{$e->{LEVELS}}) { - if ($what) { - next if ($l->{IS_DEFERRED} and $what == PRIMITIVES); - next if (not $l->{IS_DEFERRED} and $what == DEFERRED); - } - if ($l->{TYPE} eq "ARRAY" and not $l->{IS_ZERO_TERMINATED}) { - pidl "uint32 i_$e->{NAME}_$l->{LEVEL_INDEX};"; - $output = 1; - } - } - } - pidl "" if $output; -} - -sub ParseElementLevelData($$$$$$$) -{ - my ($e,$l,$nl,$env,$varname,$what,$align) = @_; - - my $c = DissectType($e,$l,$varname,$what,$align); - return if not $c; - - if (defined($e->{ALIGN})) { - Align($align, $e->{ALIGN}); - } else { - # Default to 4 - Align($align, 4); - } - - pidl "if (!$c)"; - pidl "\treturn False;"; -} - -sub ParseElementLevelArray($$$$$$$) -{ - my ($e,$l,$nl,$env,$varname,$what,$align) = @_; - - if ($l->{IS_ZERO_TERMINATED}) { - return if ($what == DEFERRED); - - my ($t,$f) = StringType($e,$l); - - Align($align, 4); - pidl "if (!smb_io_$t(\"$e->{NAME}\", &$varname, 1, ps, depth))"; - pidl "\treturn False;"; - - $$align = 0; - return; - } - - my $len = ParseExpr($l->{LENGTH_IS}, $env); - my $size = ParseExpr($l->{SIZE_IS}, $env); - - if ($what == PRIMITIVES) { - # Fetch headers - if ($l->{IS_CONFORMANT} and not $l->{IS_SURROUNDING}) { - Align($align, 4); - pidl "if (!prs_uint32(\"size_$e->{NAME}\", ps, depth, &" . ParseExpr("size_$e->{NAME}", $env) . "))"; - pidl "\treturn False;"; - pidl ""; - } - - if ($l->{IS_VARYING}) { - Align($align, 4); - pidl "if (!prs_uint32(\"offset_$e->{NAME}\", ps, depth, &" . ParseExpr("offset_$e->{NAME}", $env) . "))"; - pidl "\treturn False;"; - pidl ""; - - pidl "if (!prs_uint32(\"length_$e->{NAME}\", ps, depth, &" . ParseExpr("length_$e->{NAME}", $env) . "))"; - pidl "\treturn False;"; - pidl ""; - } - } - - # Everything but fixed arrays have to be allocated - if (!$l->{IS_FIXED} and $what == PRIMITIVES) { - pidl "if (UNMARSHALLING(ps)) {"; - indent; - pidl "$varname = (void *)PRS_ALLOC_MEM_VOID(ps,sizeof(*$varname)*$size);"; - deindent; - pidl "}"; - } - - return if ($what == DEFERRED and not ContainsDeferred($e,$l)); - - my $i = "i_$e->{NAME}_$l->{LEVEL_INDEX}"; - pidl "for ($i=0; $i<$len;$i++) {"; - indent; - ParseElementLevel($e,$nl,$env,$varname."[$i]",$what,$align); - deindent; - pidl "}"; -} - -sub ParseElementLevelSwitch($$$$$$$) -{ - my ($e,$l,$nl,$env,$varname,$what,$align) = @_; - - ParseElementLevel($e,$nl,$env,$varname,$what,$align); -} - -sub ParseElementLevelPtr($$$$$$$) -{ - my ($e,$l,$nl,$env,$varname,$what,$align) = @_; - - if ($what == PRIMITIVES) { - if (($l->{POINTER_TYPE} eq "ref") and ($l->{LEVEL} eq "EMBEDDED")) { - # Ref pointers always have to be non-NULL - pidl "if (MARSHALLING(ps) && !" . ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . ")"; - pidl "\treturn False;"; - pidl ""; - } - - unless ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP") { - Align($align, 4); - pidl "if (!prs_uint32(\"ptr$l->{POINTER_INDEX}_$e->{NAME}\", ps, depth, &" . ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . "))"; - pidl "\treturn False;"; - pidl ""; - } - } - - if ($l->{POINTER_TYPE} eq "relative") { - fatal($e, "relative pointers not supported for Samba 3"); - #FIXME - } - - if ($what == DEFERRED) { - if ($l->{POINTER_TYPE} ne "ref") { - pidl "if (" . ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . ") {"; - indent; - } - ParseElementLevel($e,$nl,$env,$varname,PRIMITIVES,$align); - ParseElementLevel($e,$nl,$env,$varname,DEFERRED,$align); - if ($l->{POINTER_TYPE} ne "ref") { - deindent; - pidl "}"; - } - $$align = 0; - } -} - -sub ParseElementLevelSubcontext($$$$$$$) -{ - my ($e,$l,$nl,$env,$varname,$what,$align) = @_; - - fatal($e, "subcontext() not supported for Samba 3"); - #FIXME -} - -sub ParseElementLevel($$$$$$) -{ - my ($e,$l,$env,$varname,$what,$align) = @_; - - { - DATA => \&ParseElementLevelData, - SUBCONTEXT => \&ParseElementLevelSubcontext, - POINTER => \&ParseElementLevelPtr, - SWITCH => \&ParseElementLevelSwitch, - ARRAY => \&ParseElementLevelArray - }->{$l->{TYPE}}->($e,$l,GetNextLevel($e,$l),$env,$varname,$what,$align); -} - -sub ParseElement($$$$) -{ - my ($e,$env,$what,$align) = @_; - - ParseElementLevel($e, $e->{LEVELS}[0], $env, ParseExpr($e->{NAME}, $env), $what, $align); -} - -sub InitLevel($$$$) -{ - sub InitLevel($$$$); - my ($e,$l,$varname,$env) = @_; - - if ($l->{TYPE} eq "POINTER") { - if ($l->{POINTER_TYPE} eq "ref") { - pidl "if (!$varname)"; - pidl "\treturn False;"; - pidl ""; - } else { - pidl "if ($varname) {"; - indent; - } - - unless ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP") { - pidl ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . " = 1;"; - } - InitLevel($e, GetNextLevel($e,$l), "*$varname", $env); - - if ($l->{POINTER_TYPE} ne "ref") { - deindent; - pidl "} else {"; - pidl "\t" . ParseExpr("ptr$l->{POINTER_INDEX}_$e->{NAME}", $env) . " = 0;"; - pidl "}"; - } - } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED}) { - my ($t,$f) = StringType($e,$l); - pidl "init_$t(&" . ParseExpr($e->{NAME}, $env) . ", ".substr($varname, 1) . ", $f);"; - } elsif ($l->{TYPE} eq "ARRAY") { - pidl ParseExpr($e->{NAME}, $env) . " = $varname;"; - } elsif ($l->{TYPE} eq "DATA") { - pidl InitType($e, $l, ParseExpr($e->{NAME}, $env), $varname); - } elsif ($l->{TYPE} eq "SWITCH") { - InitLevel($e, GetNextLevel($e,$l), $varname, $env); - pidl ParseExpr($e->{NAME}, $env) . ".switch_value = " . ParseExpr($l->{SWITCH_IS}, $env) . ";"; - } -} - -sub GenerateEnvElement($$) -{ - my ($e,$env) = @_; - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "DATA") { - $env->{$e->{NAME}} = "v->$e->{NAME}"; - } elsif ($l->{TYPE} eq "POINTER") { - $env->{"ptr$l->{POINTER_INDEX}_$e->{NAME}"} = "v->ptr$l->{POINTER_INDEX}_$e->{NAME}"; - } elsif ($l->{TYPE} eq "SWITCH") { - } elsif ($l->{TYPE} eq "ARRAY" and not $l->{IS_ZERO_TERMINATED}) { - $env->{"length_$e->{NAME}"} = "v->length_$e->{NAME}"; - $env->{"size_$e->{NAME}"} = "v->size_$e->{NAME}"; - $env->{"offset_$e->{NAME}"} = "v->offset_$e->{NAME}"; - } - } -} - -sub ParseStruct($$$) -{ - my ($if,$s,$n) = @_; - - my $fn = "$if->{NAME}_io_$n"; - my $sn = uc("$if->{NAME}_$n"); - my $ifn = "init_$if->{NAME}_$n"; - - my $args = ""; - foreach (@{$s->{ELEMENTS}}) { - $args .= ", " . DeclLong($_); - } - - my $env = { "this" => "v" }; - GenerateEnvElement($_, $env) foreach (@{$s->{ELEMENTS}}); - - pidl "BOOL $ifn($sn *v$args)"; - pidl "{"; - indent; - pidl "DEBUG(5,(\"$ifn\\n\"));"; - pidl ""; - # Call init for all arguments - foreach (@{$s->{ELEMENTS}}) { - InitLevel($_, $_->{LEVELS}[0], $_->{NAME}, $env); - pidl ""; - } - pidl "return True;"; - deindent; - pidl "}"; - pidl ""; - - my $pfn = "$fn\_p"; - my $dfn = "$fn\_d"; - - pidl "BOOL $pfn(const char *desc, $sn *v, prs_struct *ps, int depth)"; - pidl "{"; - indent; - DeclareArrayVariables($s->{ELEMENTS}, PRIMITIVES); - pidl "if (v == NULL)"; - pidl "\treturn False;"; - pidl ""; - pidl "prs_debug(ps, depth, desc, \"$pfn\");"; - pidl "depth++;"; - - my $align = 8; - if ($s->{SURROUNDING_ELEMENT}) { - pidl "if (!prs_uint32(\"size_$s->{SURROUNDING_ELEMENT}->{NAME}\", ps, depth, &" . ParseExpr("size_$s->{SURROUNDING_ELEMENT}->{NAME}", $env) . "))"; - pidl "\treturn False;"; - pidl ""; - $align = 4; - - } - - foreach (@{$s->{ELEMENTS}}) { - ParseElement($_, $env, PRIMITIVES, \$align); - pidl ""; - } - - pidl "return True;"; - deindent; - pidl "}"; - pidl ""; - - pidl "BOOL $dfn(const char *desc, $sn *v, prs_struct *ps, int depth)"; - pidl "{"; - indent; - DeclareArrayVariables($s->{ELEMENTS}, DEFERRED); - pidl "if (v == NULL)"; - pidl "\treturn False;"; - pidl ""; - pidl "prs_debug(ps, depth, desc, \"$dfn\");"; - pidl "depth++;"; - - $align = 0; - foreach (@{$s->{ELEMENTS}}) { - ParseElement($_, $env, DEFERRED, \$align); - pidl ""; - } - - pidl "return True;"; - deindent; - pidl "}"; - pidl ""; -} - -sub UnionGenerateEnvElement($) -{ - my $e = shift; - my $env = {}; - - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "DATA") { - $env->{$e->{NAME}} = "v->u.$e->{NAME}"; - } elsif ($l->{TYPE} eq "POINTER") { - $env->{"ptr$l->{POINTER_INDEX}_$e->{NAME}"} = "v->ptr$l->{POINTER_INDEX}"; - } elsif ($l->{TYPE} eq "SWITCH") { - } elsif ($l->{TYPE} eq "ARRAY" and not $l->{IS_ZERO_TERMINATED}) { - $env->{"length_$e->{NAME}"} = "v->length"; - $env->{"size_$e->{NAME}"} = "v->size"; - $env->{"offset_$e->{NAME}"} = "v->offset"; - } - } - - return $env; -} - -sub ParseUnion($$$) -{ - my ($if,$u,$n) = @_; - - my $fn = "$if->{NAME}_io_$n"; - my $sn = uc("$if->{NAME}_$n\_ctr"); - - my $pfn = "$fn\_p"; - my $dfn = "$fn\_d"; - - pidl "BOOL $pfn(const char *desc, $sn* v, prs_struct *ps, int depth)"; - pidl "{"; - indent; - DeclareArrayVariables($u->{ELEMENTS}); - - if (defined ($u->{SWITCH_TYPE})) { - pidl "if (!prs_$u->{SWITCH_TYPE}(\"switch_value\", ps, depth, &v->switch_value))"; - pidl "\treturn False;"; - pidl ""; - } - - # Maybe check here that level and v->switch_value are equal? - - pidl "switch (v->switch_value) {"; - indent; - - foreach (@{$u->{ELEMENTS}}) { - pidl "$_->{CASE}:"; - indent; - if ($_->{TYPE} ne "EMPTY") { - pidl "depth++;"; - my $env = UnionGenerateEnvElement($_); - my $align = 8; - ParseElement($_, $env, PRIMITIVES, \$align); - pidl "depth--;"; - } - pidl "break;"; - deindent; - pidl ""; - } - - unless ($u->{HAS_DEFAULT}) { - pidl "default:"; - pidl "\treturn False;"; - pidl ""; - } - - deindent; - pidl "}"; - pidl ""; - pidl "return True;"; - deindent; - pidl "}"; - pidl ""; - - pidl "BOOL $dfn(const char *desc, $sn* v, prs_struct *ps, int depth)"; - pidl "{"; - indent; - DeclareArrayVariables($u->{ELEMENTS}); - - if (defined($u->{SWITCH_TYPE})) { - pidl "switch (v->switch_value) {"; - } else { - pidl "switch (level) {"; - } - indent; - - foreach (@{$u->{ELEMENTS}}) { - pidl "$_->{CASE}:"; - indent; - if ($_->{TYPE} ne "EMPTY") { - pidl "depth++;"; - my $env = UnionGenerateEnvElement($_); - my $align = 0; - ParseElement($_, $env, DEFERRED, \$align); - pidl "depth--;"; - } - pidl "break;"; - deindent; - pidl ""; - } - - deindent; - pidl "}"; - pidl ""; - pidl "return True;"; - deindent; - pidl "}"; - -} - -sub CreateFnDirection($$$$$) -{ - my ($fn,$ifn,$s,$all,$es) = @_; - - my $args = ""; - foreach (@$all) { $args .= ", " . DeclLong($_); } - - my $env = { }; - GenerateEnvElement($_, $env) foreach (@$es); - - pidl "BOOL $ifn($s *v$args)"; - pidl "{"; - indent; - pidl "DEBUG(5,(\"$ifn\\n\"));"; - pidl ""; - # Call init for all arguments - foreach (@$es) { - InitLevel($_, $_->{LEVELS}[0], $_->{NAME}, $env); - pidl ""; - } - pidl "return True;"; - deindent; - pidl "}"; - pidl ""; - - pidl "BOOL $fn(const char *desc, $s *v, prs_struct *ps, int depth)"; - pidl "{"; - indent; - DeclareArrayVariables($es); - pidl "if (v == NULL)"; - pidl "\treturn False;"; - pidl ""; - pidl "prs_debug(ps, depth, desc, \"$fn\");"; - pidl "depth++;"; - - my $align = 8; - foreach (@$es) { - ParseElement($_, $env, PRIMITIVES, \$align); - ParseElement($_, $env, DEFERRED, \$align); - pidl ""; - } - - pidl "return True;"; - deindent; - pidl "}"; - pidl ""; -} - -sub ParseFunction($$) -{ - my ($if,$fn) = @_; - - my @in = (); - my @out = (); - my @all = @{$fn->{ELEMENTS}}; - - foreach (@{$fn->{ELEMENTS}}) { - push (@in, $_) if (grep(/in/, @{$_->{DIRECTION}})); - push (@out, $_) if (grep(/out/, @{$_->{DIRECTION}})); - } - - if (defined($fn->{RETURN_TYPE})) { - my $status = { - NAME => "status", - TYPE => $fn->{RETURN_TYPE}, - LEVELS => [ - { - TYPE => "DATA", - DATA_TYPE => $fn->{RETURN_TYPE} - } - ] - }; - - push (@out, $status); - push (@all, $status); - } - - CreateFnDirection("$if->{NAME}_io_q_$fn->{NAME}", - "init_$if->{NAME}_q_$fn->{NAME}", - uc("$if->{NAME}_q_$fn->{NAME}"), - \@in, \@in); - CreateFnDirection("$if->{NAME}_io_r_$fn->{NAME}", - "init_$if->{NAME}_r_$fn->{NAME}", - uc("$if->{NAME}_r_$fn->{NAME}"), - \@all, \@out); -} - -sub ParseInterface($) -{ - my $if = shift; - - # Structures first - pidl "/* $if->{NAME} structures */"; - foreach (@{$if->{TYPES}}) { - ParseStruct($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "STRUCT"); - ParseUnion($if, $_->{DATA}, $_->{NAME}) if ($_->{DATA}->{TYPE} eq "UNION"); - } - - pidl "/* $if->{NAME} functions */"; - ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); -} - -sub Parse($$) -{ - my($ndr,$filename) = @_; - - $tabs = ""; - $res = ""; - - pidl "/*"; - pidl " * Unix SMB/CIFS implementation."; - pidl " * parser auto-generated by pidl. DO NOT MODIFY!"; - pidl " */"; - pidl ""; - pidl "#include \"includes.h\""; - pidl ""; - pidl "#undef DBGC_CLASS"; - pidl "#define DBGC_CLASS DBGC_RPC_PARSE"; - pidl ""; - - foreach (@$ndr) { - ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); - } - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm deleted file mode 100644 index 47d565dce6..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Template.pm +++ /dev/null @@ -1,82 +0,0 @@ -################################################### -# Samba3 NDR client generator for IDL structures -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba3::Template; - -use strict; -use Parse::Pidl::Typelist qw(hasType getType mapType); -use Parse::Pidl::Util qw(has_property ParseExpr); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); - -use vars qw($VERSION); -$VERSION = '0.01'; - -my $res; -sub pidl($) { my $x = shift; $res.="$x\n"; } - -sub ParseInterface($) -{ - my $if = shift; - - foreach (@{$if->{FUNCTIONS}}) { - my $ret = $_->{RETURN_TYPE}; - if (not $ret) { $ret = "void"; } - pidl "$ret _$_->{NAME}(pipes_struct *p, " . uc($if->{NAME}) . "_Q_" . uc($_->{NAME}) . " *q_u, " . uc($if->{NAME}) . "_R_" . uc($_->{NAME}) . " *r_u)"; - pidl "{"; - pidl "\t/* FIXME: Implement your code here */"; - if (not defined($_->{RETURN_TYPE})) { - } elsif ($_->{RETURN_TYPE} eq "WERROR") { - pidl "\treturn WERR_NOT_SUPPORTED;"; - } elsif ($_->{RETURN_TYPE} eq "NTSTATUS") { - pidl "\treturn NT_STATUS_NOT_IMPLEMENTED;"; - } elsif ($_->{RETURN_TYPE} eq "uint32") { - pidl "\treturn 0;"; - } - pidl "}"; - pidl ""; - } -} - -sub Parse($$) -{ - my($ndr,$filename) = @_; - - $res = ""; - - pidl "/* - * Unix SMB/CIFS implementation. - **** template auto-generated by pidl. Modify to your needs **** - * RPC Pipe client / server routines - * Copyright (C) YOUR NAME YEAR. - * - * 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. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include \"includes.h\" - -#undef DBGC_CLASS -#define DBGC_CLASS DBGC_MSRPC -"; - - foreach (@$ndr) { - ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); - } - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm deleted file mode 100644 index 666d23e669..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Types.pm +++ /dev/null @@ -1,403 +0,0 @@ -################################################### -# Samba3 type-specific declarations / initialization / marshalling -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba3::Types; - -require Exporter; -@ISA = qw(Exporter); -@EXPORT_OK = qw(DeclShort DeclLong InitType DissectType AddType StringType); - -use strict; -use Parse::Pidl::Util qw(has_property ParseExpr property_matches); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); - -use vars qw($VERSION); -$VERSION = '0.01'; - -# TODO: Find external types somehow? - -sub warning($$) { my ($e,$s) = @_; print STDERR "$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"; } - -sub init_scalar($$$$) -{ - my ($e,$l,$n,$v) = @_; - - return "$n = $v;"; -} - -sub dissect_scalar($$$$$) -{ - my ($e,$l,$n,$w,$a) = @_; - - my $t = lc($e->{TYPE}); - - return "prs_$t(\"$e->{NAME}\", ps, depth, &$n)"; -} - -sub decl_string($) -{ - my $e = shift; - - my $is_conformant = property_matches($e, "flag", ".*STR_SIZE4.*"); - my $is_varying = property_matches($e, "flag", ".*STR_LEN4.*"); - my $is_ascii = property_matches($e, "flag", ".*STR_ASCII.*"); - - return "STRING2" if ($is_conformant and $is_varying and $is_ascii); - - return "UNISTR2" if ($is_conformant and $is_varying); - return "UNISTR3" if ($is_varying); - # We don't do UNISTR4, as we have lsa_String for that in Samba4's IDL - - die("Don't know what string type to use"); -} - -sub contains_pointer($) -{ - my $e = shift; - - foreach my $l (@{$e->{LEVELS}}) { - return 1 if ($l->{TYPE} eq "POINTER"); - } - - return 0; -} - -sub ext_decl_string($) -{ - my $e = shift; - - # One pointer is sufficient.. - return "const char" if (contains_pointer($e)); - return "const char *"; -} - -sub init_string($$$$) -{ - my ($e,$l,$n,$v) = @_; - - my $t = lc(decl_string($e)); - - my $flags; - if (property_matches($e, "flag", ".*STR_NULLTERM.*")) { - $flags = "UNI_STR_TERMINATE"; - } elsif (property_matches($e, "flag", ".*STR_NOTERM.*")) { - $flags = "UNI_STR_NOTERM"; - } else { - $flags = "UNI_FLAGS_NONE"; - } - - # One pointer is sufficient - if (substr($v, 0, 1) eq "*") { $v = substr($v, 1); } - - return "init_$t(&$n, $v, $flags);"; -} - -sub dissect_string($$$$$) -{ - my ($e,$l,$n,$w,$a) = @_; - - my $t = lc(decl_string($e)); - - $$a = 1; - return "smb_io_$t(\"$e->{NAME}\", &$n, 1, ps, depth)"; -} - -sub StringType($$) -{ - my ($e,$l) = @_; - my $nl = GetNextLevel($e,$l); - - if ($l->{IS_VARYING} and $l->{IS_CONFORMANT} and $nl->{DATA_TYPE} eq "uint16") { - return ("unistr2", "UNI_FLAGS_NONE"); - } elsif ($l->{IS_CONFORMANT} and $l->{IS_VARYING} and $nl->{DATA_TYPE} eq "uint8") { - return ("string2", 0); - } else { - fatal($e, "[string] non-varying string not supported for Samba3 yet"); - } -} - -my $known_types = -{ - uint8 => - { - DECL => "uint8", - INIT => \&init_scalar, - DISSECT_P => \&dissect_scalar, - }, - uint16 => - { - DECL => "uint16", - INIT => \&init_scalar, - DISSECT_P => \&dissect_scalar, - }, - uint32 => - { - DECL => "uint32", - INIT => \&init_scalar, - DISSECT_P => \&dissect_scalar, - }, - uint64 => - { - DECL => "uint64", - INIT => \&init_scalar, - DISSECT_P => \&dissect_scalar, - }, - int32 => - { - DECL => "int32", - INIT => \&init_scalar, - DISSECT_P => \&dissect_scalar, - }, - string => - { - DECL => \&decl_string, - EXT_DECL => \&ext_decl_string, - INIT => \&init_string, - DISSECT_P => \&dissect_string, - }, - NTSTATUS => - { - DECL => "NTSTATUS", - INIT => \&init_scalar, - DISSECT_P => \&dissect_scalar, - }, - WERROR => - { - DECL => "WERROR", - INIT => \&init_scalar, - DISSECT_P => \&dissect_scalar, - }, - GUID => - { - DECL => "struct uuid", - INIT => "", - DISSECT_P => sub { - my ($e,$l,$n) = @_; - return "smb_io_uuid(\"$e->{NAME}\", &$n, ps, depth)"; - } - }, - NTTIME => - { - DECL => "NTTIME", - INIT => "", - DISSECT_P => sub { - my ($e,$l,$n,$w,$a) = @_; - return "smb_io_nttime(\"$e->{NAME}\", &n, ps, depth)"; - } - }, - dom_sid => - { - DECL => "DOM_SID", - INIT => "", - DISSECT_P => sub { - my ($e,$l,$n,$w,$a) = @_; - return "smb_io_dom_sid(\"$e->{NAME}\", &n, ps, depth)"; - } - }, - policy_handle => - { - DECL => "POLICY_HND", - INIT => "", - DISSECT_P => sub { - my ($e,$l,$n,$w,$a) = @_; - return "smb_io_pol_hnd(\"$e->{NAME}\", &n, ps, depth)"; - } - }, - security_descriptor => - { - DECL => "SEC_DESC", - INIT => "", - DISSECT_P => sub { - my ($e,$l,$n,$w,$a) = @_; - return "sec_io_desc(\"$e->{NAME}\", &n, ps, depth)"; - } - }, - hyper => - { - DECL => "uint64", - INIT => "", - DISSECT_P => sub { - my ($e,$l,$n,$w,$a) = @_; - return "prs_uint64(\"$e->{NAME}\", ps, depth, &$n)"; - } - }, -}; - -sub AddType($$) -{ - my ($t,$d) = @_; - - warn("Reregistering type $t") if (defined($known_types->{$t})); - - $known_types->{$t} = $d; -} - -# Return type without special stuff, as used in -# declarations for internal structs -sub DeclShort($) -{ - my $e = shift; - - my $t = $known_types->{$e->{TYPE}}; - - if (not $t) { - warning($e, "Can't declare unknown type `$e->{TYPE}'"); - return undef; - } - - my $p; - - # DECL can be a function - if (ref($t->{DECL}) eq "CODE") { - $p = $t->{DECL}->($e); - } else { - $p = $t->{DECL}; - } - - my $prefixes = ""; - my $suffixes = ""; - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "ARRAY" and not $l->{IS_FIXED}) { - $prefixes = "*$prefixes"; - } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}) { - $suffixes.="[$l->{SIZE_IS}]"; - } - } - - return "$p $prefixes$e->{NAME}$suffixes"; -} - -# Return type including special stuff (pointers, etc). -sub DeclLong($) -{ - my $e = shift; - - my $t = $known_types->{$e->{TYPE}}; - - if (not $t) { - warning($e, "Can't declare unknown type `$e->{TYPE}'"); - return undef; - } - - my $p; - - if (defined($t->{EXT_DECL})) { - $p = $t->{EXT_DECL} - } else { - $p = $t->{DECL}; - } - - if (ref($p) eq "CODE") { - $p = $p->($e); - } - - my $prefixes = ""; - my $suffixes = ""; - - foreach my $l (@{$e->{LEVELS}}) { - if ($l->{TYPE} eq "ARRAY" and $l->{IS_ZERO_TERMINATED}) { - $p = "const char"; - last; - } elsif ($l->{TYPE} eq "ARRAY" and not $l->{IS_FIXED}) { - $prefixes = "*$prefixes"; - } elsif ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}) { - $suffixes.="[$l->{SIZE_IS}]"; - } elsif ($l->{TYPE} eq "POINTER") { - $prefixes = "*$prefixes"; - } - } - - return "$p $prefixes$e->{NAME}$suffixes"; -} - -sub InitType($$$$) -{ - my ($e, $l, $varname, $value) = @_; - - my $t = $known_types->{$l->{DATA_TYPE}}; - - if (not $t) { - warning($e, "Don't know how to initialize type $l->{DATA_TYPE}"); - return undef; - } - - # INIT can be a function - if (ref($t->{INIT}) eq "CODE") { - return $t->{INIT}->($e, $l, $varname, $value); - } else { - return $t->{INIT}; - } -} - -sub DissectType($$$$$) -{ - my ($e,$l,$varname,$what,$align) = @_; - - my $t = $known_types->{$l->{DATA_TYPE}}; - - if (not $t) { - warning($e, "Don't know how to dissect type $l->{DATA_TYPE}"); - return undef; - } - - my $dissect; - if ($what == 1) { #primitives - $dissect = $t->{DISSECT_P}; - } elsif ($what == 2) { - $dissect = $t->{DISSECT_D}; - } - - return "" if not defined($dissect); - - # DISSECT can be a function - if (ref($dissect) eq "CODE") { - return $dissect->($e,$l,$varname,$what,$align); - } else { - return $dissect; - } -} - -sub LoadTypes($) -{ - my $ndr = shift; - foreach my $if (@{$ndr}) { - next unless ($if->{TYPE} eq "INTERFACE"); - - foreach my $td (@{$if->{TYPES}}) { - my $decl = uc("$if->{NAME}_$td->{NAME}"); - - my $init = sub { - my ($e,$l,$n,$v) = @_; - return "$n = $v;"; - }; - - my $dissect_d; - my $dissect_p; - if ($td->{DATA}->{TYPE} eq "UNION") { - $decl.="_CTR"; - } - - $dissect_p = sub { - my ($e,$l,$n,$w,$a) = @_; - - return "$if->{NAME}_io_$td->{NAME}_p(\"$e->{NAME}\", &$n, ps, depth)"; - }; - $dissect_d = sub { - my ($e,$l,$n,$w,$a) = @_; - - return "$if->{NAME}_io_$td->{NAME}_d(\"$e->{NAME}\", &$n, ps, depth)"; - }; - - AddType($td->{NAME}, { - DECL => $decl, - INIT => $init, - DISSECT_D => $dissect_d, - DISSECT_P => $dissect_p - }); - } - } -} - -1; -- cgit From 2fb4ecebc11152d770d07370b996b878338bcf46 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 13 Sep 2006 14:13:48 +0000 Subject: r18475: Start working on server code generator that uses libndr. (This used to be commit aa1c550d371c5874668baf06be7168c85dc5d48b) --- source4/pidl/lib/Parse/Pidl/Samba3/Server.pm | 122 ------------------------ source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 110 +++++++++++++++++++++ 2 files changed, 110 insertions(+), 122 deletions(-) delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/Server.pm create mode 100644 source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm deleted file mode 100644 index 179ace7dbb..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba3/Server.pm +++ /dev/null @@ -1,122 +0,0 @@ -################################################### -# Samba3 NDR server generator for IDL structures -# Copyright jelmer@samba.org 2005 -# released under the GNU GPL - -package Parse::Pidl::Samba3::Server; - -use strict; -use Parse::Pidl::Typelist qw(hasType getType mapType); -use Parse::Pidl::Util qw(has_property ParseExpr); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); - -my $res = ""; -my $tabs = ""; - -sub indent() { $tabs.="\t"; } -sub deindent() { $tabs = substr($tabs, 1); } -sub pidl($) { $res .= $tabs.(shift)."\n"; } - -use vars qw($VERSION); -$VERSION = '0.01'; - -sub ParseFunction($$) -{ - my ($if,$fn) = @_; - - pidl "/******************************************************************"; - pidl " api_$fn->{NAME}"; - pidl " *****************************************************************/"; - pidl ""; - pidl "static BOOL api_$fn->{NAME}(pipes_struct *p)"; - pidl "{"; - indent; - pidl uc("$if->{NAME}_q_$fn->{NAME}") . " q_u;"; - pidl uc("$if->{NAME}_r_$fn->{NAME}") . " r_u;"; - pidl "prs_struct *data = &p->in_data.data;"; - pidl "prs_struct *rdata = &p->out_data.rdata;"; - pidl ""; - pidl "ZERO_STRUCT(q_u);"; - pidl "ZERO_STRUCT(r_u);"; - pidl ""; - pidl "if (!$if->{NAME}_io_q_$fn->{NAME}(\"\", &q_u, data, 0))"; - pidl "\treturn False;"; - pidl ""; - if ($fn->{RETURN_TYPE}) { - pidl "r_u.status = _$fn->{NAME}(p, &q_u, &r_u);"; - } else { - pidl "_$fn->{NAME}(p, &q_u, &r_u);"; - } - pidl ""; - pidl "if (!$if->{NAME}_io_r_$fn->{NAME}(\"\", &r_u, rdata, 0))"; - pidl "\treturn False;"; - pidl ""; - pidl "return True;"; - deindent; - pidl "}"; -} - -sub ParseInterface($) -{ - my $if = shift; - - ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); - - pidl ""; - pidl "/* Tables */"; - pidl "static struct api_struct api_$if->{NAME}_cmds[] = "; - pidl "{"; - indent; - foreach (@{$if->{FUNCTIONS}}) { - pidl "{\"" . uc($_->{NAME}) . "\", " . uc($_->{NAME}) . ", api_$_->{NAME}},"; - } - deindent; - pidl "};"; - - pidl ""; - - pidl "void $if->{NAME}_get_pipe_fns(struct api_struct **fns, int *n_fns)"; - pidl "{"; - indent; - pidl "*fns = api_$if->{NAME}_cmds;"; - pidl "*n_fns = sizeof(api_$if->{NAME}_cmds) / sizeof(struct api_struct);"; - deindent; - pidl "}"; - - pidl ""; - - pidl "NTSTATUS rpc_$if->{NAME}_init(void)"; - pidl "{"; - indent; - pidl "return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, \"$if->{NAME}\", \"$if->{NAME}\", api_$if->{NAME}_cmds, sizeof(api_$if->{NAME}_cmds) / sizeof(struct api_struct));"; - deindent; - pidl "}"; -} - -sub Parse($$) -{ - my($ndr,$filename) = @_; - - $tabs = ""; - $res = ""; - - pidl "/*"; - pidl " * Unix SMB/CIFS implementation."; - pidl " * server auto-generated by pidl. DO NOT MODIFY!"; - pidl " */"; - pidl ""; - pidl "#include \"includes.h\""; - pidl "#include \"nterr.h\""; - pidl ""; - pidl "#undef DBGC_CLASS"; - pidl "#define DBGC_CLASS DBGC_RPC"; - pidl ""; - - foreach (@$ndr) { - ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); - } - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm new file mode 100644 index 0000000000..327aea2f0e --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -0,0 +1,110 @@ +################################################### +# Samba3 server generator for IDL structures +# on top of Samba4 style NDR functions +# Copyright jelmer@samba.org 2005-2006 +# released under the GNU GPL + +package Parse::Pidl::Samba3::ServerNDR; + +use strict; +use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); +use Parse::Pidl::Util qw(has_property ParseExpr is_constant); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::Samba4 qw(DeclLong); + +use vars qw($VERSION); +$VERSION = '0.01'; + +my $res; +my $res_hdr; +my $tabs = ""; +sub indent() { $tabs.="\t"; } +sub deindent() { $tabs = substr($tabs, 1); } +sub pidl($) { $res .= $tabs.(shift)."\n"; } +sub pidl_hdr($) { $res_hdr .= (shift)."\n"; } +sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } +sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } +sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } + +sub ParseFunction($$) +{ + my ($if,$fn) = @_; + + pidl "static BOOL api_$fn->{NAME}(pipes_struct *p)"; + pidl "{"; + indent; + + deindent; + pidl "}"; + pidl ""; +} + +sub ParseInterface($) +{ + my $if = shift; + + my $uif = uc($if->{NAME}); + + pidl_hdr "#ifndef __SRV_$uif\__"; + pidl_hdr "#define __SRV_$uif\__"; + ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); + + pidl ""; + pidl "/* Tables */"; + pidl "static struct api_struct api_$if->{NAME}_cmds[] = "; + pidl "{"; + indent; + + foreach (@{$if->{FUNCTIONS}}) { + pidl "{\"" . uc($_->{NAME}) . "\", DCERPC_" . uc($_->{NAME}) . ", api_$_->{NAME}},"; + } + + deindent; + pidl "};"; + + pidl ""; + + pidl_hdr "void $if->{NAME}_get_pipe_fns(struct api_struct **fns, int *n_fns);"; + pidl "void $if->{NAME}_get_pipe_fns(struct api_struct **fns, int *n_fns)"; + pidl "{"; + indent; + pidl "*fns = api_$if->{NAME}_cmds;"; + pidl "*n_fns = sizeof(api_$if->{NAME}_cmds) / sizeof(struct api_struct);"; + deindent; + pidl "}"; + pidl ""; + + pidl_hdr "NTSTATUS rpc_netdfs_init(void);"; + pidl "NTSTATUS rpc_netdfs_init(void)"; + pidl "{"; + pidl "\treturn rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, \"$if->{NAME}\", \"$if->{NAME}\", api_$if->{NAME}_cmds, sizeof(api_$if->{NAME}_cmds) / sizeof(struct api_struct));"; + pidl "}"; + + pidl_hdr "#endif /* __SRV_$uif\__ */"; +} + +sub Parse($$$) +{ + my($ndr,$header,$ndr_header) = @_; + + $res = ""; + $res_hdr = ""; + + pidl "/*"; + pidl " * Unix SMB/CIFS implementation."; + pidl " * server auto-generated by pidl. DO NOT MODIFY!"; + pidl " */"; + pidl ""; + pidl "#include \"includes.h\""; + pidl "#include \"$header\""; + pidl_hdr "#include \"$ndr_header\""; + pidl ""; + + foreach (@$ndr) { + ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + } + + return ($res, $res_hdr); +} + +1; -- cgit From 6a2b54149723d283878e3295bfe3a48d67e2d495 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 13 Sep 2006 15:45:20 +0000 Subject: r18477: Finish server code generator for Samba 3. (This used to be commit 4e2f20042448721ba1df5bbbb77710e155f23953) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 68 +++++++++++++++++++++++++ 1 file changed, 68 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 327aea2f0e..7fba856617 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -33,7 +33,75 @@ sub ParseFunction($$) pidl "static BOOL api_$fn->{NAME}(pipes_struct *p)"; pidl "{"; indent; + pidl "struct ndr_pull *pull;"; + pidl "struct ndr_push *push;"; + pidl "DATA_BLOB blob;"; + pidl "struct $fn->{NAME} r;"; + pidl "TALLOC_CTX *mem_ctx = talloc_init(\"api_$fn->{NAME}\");"; + pidl ""; + pidl "if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {"; + pidl "\ttalloc_free(mem_ctx);"; + pidl "\treturn False;"; + pidl "}"; + pidl ""; + pidl "pull = ndr_pull_init_blob(&blob, mem_ctx);"; + pidl "if (pull == NULL)"; + pidl "\treturn False;"; + pidl ""; + pidl "pull->flags |= LIBNDR_FLAG_REF_ALLOC;"; + pidl "status = ndr_pull_$fn->{NAME}(pull, NDR_IN, &r);"; + pidl "if (NT_STATUS_IS_ERR(status)) {"; + pidl "\ttalloc_free(mem_ctx);"; + pidl "\treturn False;"; + pidl "}"; + pidl ""; + my $proto = "_$fn->{NAME}(pipes_struct *p"; + my $ret = "_$fn->{NAME}(p"; + foreach (@{$fn->{ELEMENTS}}) { + my @dir = @{$_->{DIRECTION}}; + if (grep(@dir, /in/) and grep(@dir, /out/)) { + pidl "r.out.$_->{NAME} = r.in.$_->{NAME};"; + } + if (grep(@dir, /in/)) { $ret .= ", r.in.$_->{NAME}"; } + else { $ret .= ", r.out.$_->{NAME}"; } + + $proto .= ", " . DeclLong($_); + } + $ret .= ")"; + $proto .= ");"; + + if ($fn->{RETURN_TYPE}) { + $ret = "r.out.result = $ret"; + $proto = "$fn->{RETURN_TYPE} $proto"; + } else { + $proto = "void $proto"; + } + + pidl_hdr "$proto"; + pidl "$ret;"; + pidl ""; + pidl "push = ndr_push_init_ctx(mem_ctx);"; + pidl "if (push == NULL) {"; + pidl "\ttalloc_free(mem_ctx);"; + pidl "\treturn False;"; + pidl "}"; + pidl ""; + pidl "status = ndr_push_$fn->{NAME}(push, NDR_OUT, &r);"; + pidl "if (NT_STATUS_IS_ERR(status)) {"; + pidl "\ttalloc_free(mem_ctx);"; + pidl "\treturn False;"; + pidl "}"; + pidl ""; + pidl "blob = ndr_push_blob(push);"; + pidl "if (!prs_init_data_blob(&p->in_data.rdata, &blob, p->mem_ctx)) {"; + pidl "\ttalloc_free(mem_ctx);"; + pidl "\treturn False;"; + pidl "}"; + pidl ""; + pidl "talloc_free(mem_ctx);"; + pidl ""; + pidl "return True;"; deindent; pidl "}"; pidl ""; -- cgit From ea50e4f30aad94320c7d8bbc3e33dd6b10777bbe Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 13 Sep 2006 15:54:08 +0000 Subject: r18478: Add missing declaration for status. (This used to be commit 64909a0d69a938e96f7a04b4288ca851fb8fe18a) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 7fba856617..47e18fee69 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -35,6 +35,7 @@ sub ParseFunction($$) indent; pidl "struct ndr_pull *pull;"; pidl "struct ndr_push *push;"; + pidl "NTSTATUS status;"; pidl "DATA_BLOB blob;"; pidl "struct $fn->{NAME} r;"; pidl "TALLOC_CTX *mem_ctx = talloc_init(\"api_$fn->{NAME}\");"; -- cgit From 965633a5b4c93e34723f753a807ef0cc77f916fa Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 13 Sep 2006 16:29:14 +0000 Subject: r18482: Fix a couple of small issues in the generated server code. (This used to be commit ddfe3c54439eb76327608e04df9381621ab875b8) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 47e18fee69..9ecd7d1e83 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -60,10 +60,10 @@ sub ParseFunction($$) my $ret = "_$fn->{NAME}(p"; foreach (@{$fn->{ELEMENTS}}) { my @dir = @{$_->{DIRECTION}}; - if (grep(@dir, /in/) and grep(@dir, /out/)) { + if (grep(/in/, @dir) and grep(/out/, @dir)) { pidl "r.out.$_->{NAME} = r.in.$_->{NAME};"; } - if (grep(@dir, /in/)) { $ret .= ", r.in.$_->{NAME}"; } + if (grep(/in/, @dir)) { $ret .= ", r.in.$_->{NAME}"; } else { $ret .= ", r.out.$_->{NAME}"; } $proto .= ", " . DeclLong($_); @@ -95,7 +95,7 @@ sub ParseFunction($$) pidl "}"; pidl ""; pidl "blob = ndr_push_blob(push);"; - pidl "if (!prs_init_data_blob(&p->in_data.rdata, &blob, p->mem_ctx)) {"; + pidl "if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {"; pidl "\ttalloc_free(mem_ctx);"; pidl "\treturn False;"; pidl "}"; -- cgit From 5f68b76c4a02b2681e4533d010628a0dd6338768 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 14 Sep 2006 12:23:02 +0000 Subject: r18522: It's probably not a good idea to use rpc_netdfs_init() as initialization function name for _all_ RPC servers... (This used to be commit 234272e39d7dc79f5e7e0399aebf5681a92981b2) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 9ecd7d1e83..dea3a32607 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -143,8 +143,8 @@ sub ParseInterface($) pidl "}"; pidl ""; - pidl_hdr "NTSTATUS rpc_netdfs_init(void);"; - pidl "NTSTATUS rpc_netdfs_init(void)"; + pidl_hdr "NTSTATUS rpc_$if->{NAME}_init(void);"; + pidl "NTSTATUS rpc_$if->{NAME}_init(void)"; pidl "{"; pidl "\treturn rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, \"$if->{NAME}\", \"$if->{NAME}\", api_$if->{NAME}_cmds, sizeof(api_$if->{NAME}_cmds) / sizeof(struct api_struct));"; pidl "}"; -- cgit From df08af841881d331285a56f76a826ebd19b426b8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 14 Sep 2006 12:25:41 +0000 Subject: r18523: Allow [out] on arrays as well as pointers, use in unixinfo. (This used to be commit f67b4d58acd2c3746e5ffeffa804e888ca3c49a5) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 7 ++++--- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 21875a1297..f274836fe7 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -543,9 +543,10 @@ sub ParseFunction($$$) push (@{$e->{DIRECTION}}, "in") if (has_property($x, "in")); push (@{$e->{DIRECTION}}, "out") if (has_property($x, "out")); - nonfatal($x, "`$e->{NAME}' is [out] argument but not a pointer") - if ($e->{LEVELS}[0]->{TYPE} ne "POINTER") and - grep(/out/, @{$e->{DIRECTION}}); + nonfatal($x, "`$e->{NAME}' is [out] argument but not a pointer or array") + if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and + $e->{LEVELS}[0]->{TYPE} ne "ARRAY" and + grep(/out/, @{$e->{DIRECTION}})); push (@elements, $e); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index fa629e6101..31ea73f7aa 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -61,7 +61,7 @@ sub ParseFunction($$) foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); - fatal($e, "[out] argument is not a pointer") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER"); + fatal($e, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); pidl "*$e->{NAME} = *r.out.$e->{NAME};"; } -- cgit From f78ff444e68aa45674310e5c679b8caef69e35c9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 14 Sep 2006 13:37:17 +0000 Subject: r18524: Pre-allocate out arguments. (This used to be commit 0ee42669d3a5ec062ec14ecda94342b0df519964) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 33 +++++++++++++++++++++++++ 1 file changed, 33 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index dea3a32607..4d3dba2e0e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -26,6 +26,30 @@ sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LI sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } +sub AllocOutVar($$$$) +{ + my ($e, $mem_ctx, $name, $env) = @_; + + my $l = $e->{LEVELS}[0]; + + if ($l->{TYPE} eq "POINTER") { + $l = GetNextLevel($e, $l); + } + + if ($l->{TYPE} eq "ARRAY") { + my $size = ParseExpr($l->{SIZE_IS}, $env); + pidl "$name = talloc_array_size($mem_ctx, sizeof(*$name), $size);"; + } else { + pidl "$name = talloc_size($mem_ctx, sizeof(*$name));"; + } + + pidl "if ($name == NULL) {"; + pidl "\ttalloc_free(mem_ctx);"; + pidl "\treturn False;"; + pidl "}"; + pidl ""; +} + sub ParseFunction($$) { my ($if,$fn) = @_; @@ -56,12 +80,21 @@ sub ParseFunction($$) pidl "\treturn False;"; pidl "}"; pidl ""; + + my %env = (); + foreach (@{$fn->{ELEMENTS}}) { + next unless (grep (/in/, @{$_->{DIRECTION}})); + $env{$_->{NAME}} = "r.in.$_->{NAME}"; + } + my $proto = "_$fn->{NAME}(pipes_struct *p"; my $ret = "_$fn->{NAME}(p"; foreach (@{$fn->{ELEMENTS}}) { my @dir = @{$_->{DIRECTION}}; if (grep(/in/, @dir) and grep(/out/, @dir)) { pidl "r.out.$_->{NAME} = r.in.$_->{NAME};"; + } elsif (grep(/out/, @dir)) { + AllocOutVar($_, "mem_ctx", "r.out.$_->{NAME}", \%env); } if (grep(/in/, @dir)) { $ret .= ", r.in.$_->{NAME}"; } else { $ret .= ", r.out.$_->{NAME}"; } -- cgit From 3e7cff6c0002d09489cbb186dcab57b72a0c1ed2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 15 Sep 2006 14:32:30 +0000 Subject: r18554: Fix warnings about [out] arguments. (This used to be commit caac6cf817b09c864554e992f89437f6205b948b) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index f274836fe7..114de797b8 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -109,6 +109,15 @@ sub GetElementLevelTable($) @bracket_array = @{$e->{ARRAY_LEN}}; } + if (has_property($e, "out")) { + my $needptrs = 1; + + if (has_property($e, "string")) { $needptrs++; } + if ($#bracket_array >= 0) { $needptrs = 0; } + + nonfatal($e, "[out] argument `$e->{NAME}' not a pointer") if ($needptrs > $e->{POINTERS}); + } + # Parse the [][][][] style array stuff for my $i (0 .. $#bracket_array) { my $d = $bracket_array[$#bracket_array - $i]; @@ -543,11 +552,6 @@ sub ParseFunction($$$) push (@{$e->{DIRECTION}}, "in") if (has_property($x, "in")); push (@{$e->{DIRECTION}}, "out") if (has_property($x, "out")); - nonfatal($x, "`$e->{NAME}' is [out] argument but not a pointer or array") - if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and - $e->{LEVELS}[0]->{TYPE} ne "ARRAY" and - grep(/out/, @{$e->{DIRECTION}})); - push (@elements, $e); } -- cgit From 291c5ed53c9957d1da981fa39477b046b94fe192 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 15 Sep 2006 17:34:46 +0000 Subject: r18559: [string] always applies to the last pointer (This used to be commit 86b4624226d6e72645221cadb8669b0f1aba0903) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 114de797b8..f602bd2d68 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -204,7 +204,8 @@ sub GetElementLevelTable($) } } - if (scalar(@size_is) == 0 and has_property($e, "string")) { + if (scalar(@size_is) == 0 and has_property($e, "string") and + $i == $e->{POINTERS}) { $is_string = 1; $is_varying = $is_conformant = has_property($e, "noheader")?0:1; delete($e->{PROPERTIES}->{string}); -- cgit From d9b4bdd5bb32806162514f7e010a97d24fb94549 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 15 Sep 2006 20:07:55 +0000 Subject: r18565: Fix echo.idl to be Samba3-, MIDL and midlc compatible (This used to be commit ab0a798c57564901f0adcd8aedc1ef0928e79edd) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 9e4388e28d..bbcc9f884e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -7,6 +7,10 @@ package Parse::Pidl::Samba4::NDR::Parser; +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(is_charset_array); + use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); use Parse::Pidl::Util qw(has_property ParseExpr print_uuid); -- cgit From cd9057a0bb90bef6d31051f176849b6a3543a376 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 18 Sep 2006 21:52:00 +0000 Subject: r18639: Get rid of the keepref support (This used to be commit d1364ef0cd8f1a64f44476476323ab390ac4de48) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 23 ------------- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 6 +--- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 42 +++++++++--------------- 3 files changed, 16 insertions(+), 55 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index f602bd2d68..cd8aa214ff 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -586,23 +586,6 @@ sub CheckPointerTypes($$) } } -#FIXME: Remove when ref handling in Samba4 is fixed -sub AddKeepRef($) -{ - my $d = shift; - - if ($d->{TYPE} eq "FUNCTION") { - foreach (@{$d->{ELEMENTS}}) { - $_->{PROPERTIES}->{keepref} = 1; - } - } elsif ($d->{TYPE} eq "TYPEDEF" and ($d->{DATA}->{TYPE} eq "STRUCT" - or $d->{DATA}->{TYPE} eq "UNION")) { - foreach (@{$d->{DATA}->{ELEMENTS}}) { - $_->{PROPERTIES}->{keepref} = 1; - } - } -} - sub ParseInterface($) { my $idl = shift; @@ -628,12 +611,10 @@ sub ParseInterface($) if ($d->{TYPE} eq "DECLARE") { push (@declares, $d); } elsif ($d->{TYPE} eq "FUNCTION") { - AddKeepRef($d) if (has_property($idl, "keepref")); push (@functions, ParseFunction($idl, $d, \$opnum)); } elsif ($d->{TYPE} eq "CONST") { push (@consts, ParseConst($idl, $d)); } else { - AddKeepRef($d) if (has_property($idl, "keepref")); push (@types, ParseType($idl, $d)); } } @@ -855,10 +836,6 @@ my %property_list = ( "noheader" => ["ELEMENT"], "charset" => ["ELEMENT"], "length_is" => ["ELEMENT"], - - # temporary (should be removed once we've migrated away from - # relying on ref pointers being there in Samba4's code) - "keepref" => ["ELEMENT","INTERFACE"], ); ##################################################################### diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index c9487115f5..6fb3ee2eec 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -60,11 +60,7 @@ sub HeaderElement($) } else { HeaderType($element, $element->{TYPE}, ""); pidl " "; - my $numstar = 0; - if (!has_property($element, "ref") or - has_property($element, "keepref")) { - $numstar += $element->{POINTERS}; - } + my $numstar = $element->{POINTERS}; if ($numstar >= 1) { $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index bbcc9f884e..6124935e67 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -593,9 +593,7 @@ sub ParseElementPushLevel pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));"; } } - if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) { - $var_name = get_value_of($var_name); - } + $var_name = get_value_of($var_name); ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1); if ($l->{POINTER_TYPE} ne "ref") { @@ -675,9 +673,7 @@ sub ParsePtrPush($$$) my ($e,$l,$var_name) = @_; if ($l->{POINTER_TYPE} eq "ref") { - if (has_property($e, "keepref")) { - check_null_pointer(get_value_of($var_name)); - } + check_null_pointer(get_value_of($var_name)); if ($l->{LEVEL} eq "EMBEDDED") { pidl "NDR_CHECK(ndr_push_ref_ptr(ndr));"; } @@ -713,15 +709,13 @@ sub ParseElementPrint($$$) foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { - if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) { pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);"; pidl "ndr->depth++;"; - if ($l->{POINTER_TYPE} ne "ref") { - pidl "if ($var_name) {"; - indent; - } - $var_name = get_value_of($var_name); + if ($l->{POINTER_TYPE} ne "ref") { + pidl "if ($var_name) {"; + indent; } + $var_name = get_value_of($var_name); } elsif ($l->{TYPE} eq "ARRAY") { my $length; @@ -770,13 +764,11 @@ sub ParseElementPrint($$$) foreach my $l (reverse @{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { - if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) { - if ($l->{POINTER_TYPE} ne "ref") { - deindent; - pidl "}"; - } - pidl "ndr->depth--;"; + if ($l->{POINTER_TYPE} ne "ref") { + deindent; + pidl "}"; } + pidl "ndr->depth--;"; } elsif (($l->{TYPE} eq "ARRAY") and not is_charset_array($e,$l) and not has_fast_array($e,$l)) { @@ -890,7 +882,7 @@ sub ParseMemCtxPullStart($$$) my $next_is_array = ($nl->{TYPE} eq "ARRAY"); my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); - if ($next_is_array or $next_is_string or not has_property($e, "keepref")) { + if ($next_is_array or $next_is_string) { return; } else { $mem_c_flags = "LIBNDR_FLAG_REF_ALLOC"; @@ -916,7 +908,7 @@ sub ParseMemCtxPullEnd($$) my $next_is_array = ($nl->{TYPE} eq "ARRAY"); my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); - if ($next_is_array or $next_is_string or not has_property($e, "keepref")) { + if ($next_is_array or $next_is_string) { return; } else { $mem_r_flags = "LIBNDR_FLAG_REF_ALLOC"; @@ -993,9 +985,7 @@ sub ParseElementPullLevel ParseMemCtxPullStart($e,$l, $var_name); - if ($l->{POINTER_TYPE} ne "ref" or has_property($e, "keepref")) { - $var_name = get_value_of($var_name); - } + $var_name = get_value_of($var_name); ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); ParseMemCtxPullEnd($e,$l); @@ -1099,8 +1089,7 @@ sub ParsePtrPull($$$$) pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"; } - if (!$next_is_array and !$next_is_string and - has_property($e, "keepref")) { + if (!$next_is_array and !$next_is_string) { pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; pidl "\tNDR_PULL_ALLOC($ndr, $var_name);"; pidl "}"; @@ -1445,7 +1434,7 @@ sub need_decl_mem_ctx($$) my $next_is_array = ($nl->{TYPE} eq "ARRAY"); my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); - return 0 if ($next_is_array or $next_is_string or not has_property($e, "keepref")); + return 0 if ($next_is_array or $next_is_string); } return 1 if ($l->{TYPE} eq "POINTER"); @@ -2111,7 +2100,6 @@ sub ParseFunctionPull($) next unless (grep(/out/, @{$e->{DIRECTION}})); next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref"); - next unless has_property($e, "keepref"); next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and ($e->{LEVELS}[1]->{DATA_TYPE} eq "string")); next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY") -- cgit From 1463ca1d2bafd5eff003cb4dbb5671e5e8afe80a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 19 Sep 2006 22:18:16 +0000 Subject: r18689: Initialize r.out in the server side code, in case the handler function doesn't touch them. (This used to be commit 2ac2c7ca60c70d70a07162c63bfb492c74816c7c) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 4d3dba2e0e..8ef4529402 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -82,11 +82,15 @@ sub ParseFunction($$) pidl ""; my %env = (); + my $hasout = 0; foreach (@{$fn->{ELEMENTS}}) { + if (grep(/out/, @{$_->{DIRECTION}})) { $hasout = 1; } next unless (grep (/in/, @{$_->{DIRECTION}})); $env{$_->{NAME}} = "r.in.$_->{NAME}"; } + pidl "ZERO_STRUCT(r.out);" if ($hasout); + my $proto = "_$fn->{NAME}(pipes_struct *p"; my $ret = "_$fn->{NAME}(p"; foreach (@{$fn->{ELEMENTS}}) { -- cgit From b9785235b40ed0506fd920214967f6b0bd9fc659 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 19 Sep 2006 22:39:49 +0000 Subject: r18693: Print debug info when DEBUGLEVEL >= 10 in the Samba3 code. (This used to be commit d28ae3f70ad4f6b09780e600ecb98c39cc62fd24) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 8 ++++++++ source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 6 ++++++ 2 files changed, 14 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 31ea73f7aa..3b75bf33a6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -52,7 +52,15 @@ sub ParseFunction($$) } } + pidl ""; + pidl "if (DEBUGLEVEL >= 10)"; + pidl "\tNDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"; + pidl ""; pidl "status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, $ufn, &r, (ndr_pull_flags_fn_t)ndr_pull_$fn->{NAME}, (ndr_push_flags_fn_t)ndr_push_$fn->{NAME});"; + pidl ""; + pidl "if (DEBUGLEVEL >= 10)"; + pidl "\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);"; + pidl ""; pidl "if (NT_STATUS_IS_ERR(status)) {"; pidl "\treturn status;"; pidl "}"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 8ef4529402..070ccde8ee 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -80,6 +80,9 @@ sub ParseFunction($$) pidl "\treturn False;"; pidl "}"; pidl ""; + pidl "if (DEBUGLEVEL >= 10)"; + pidl "\tNDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"; + pidl ""; my %env = (); my $hasout = 0; @@ -118,6 +121,9 @@ sub ParseFunction($$) pidl_hdr "$proto"; pidl "$ret;"; + pidl ""; + pidl "if (DEBUGLEVEL >= 10)"; + pidl "\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);"; pidl ""; pidl "push = ndr_push_init_ctx(mem_ctx);"; pidl "if (push == NULL) {"; -- cgit From d094a421d3e85d4c27119f6cd4fd3e8e164f2f4c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 19 Sep 2006 22:48:08 +0000 Subject: r18696: Zero initialize ref ptrs. (This used to be commit 8de48f62e7840431fe5bfbb1c61daaafcf421ff1) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 070ccde8ee..928a88ba5e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -38,9 +38,9 @@ sub AllocOutVar($$$$) if ($l->{TYPE} eq "ARRAY") { my $size = ParseExpr($l->{SIZE_IS}, $env); - pidl "$name = talloc_array_size($mem_ctx, sizeof(*$name), $size);"; + pidl "$name = talloc_zero_size($mem_ctx, sizeof(*$name) * $size);"; } else { - pidl "$name = talloc_size($mem_ctx, sizeof(*$name));"; + pidl "$name = talloc_zero_size($mem_ctx, sizeof(*$name));"; } pidl "if ($name == NULL) {"; -- cgit From d6e65c2318c54bacdbcf49336bb235eea126af71 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 21 Sep 2006 04:26:31 +0000 Subject: r18767: Fix [ref] pointer in object oriented interfaces. Removes a bunch of warnings when compiling dcom.idl. (This used to be commit 6f6dd761460e063eda3c1d0706358cb336c181fd) --- source4/pidl/lib/Parse/Pidl/ODL.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/ODL.pm b/source4/pidl/lib/Parse/Pidl/ODL.pm index b5d65b6239..c8d1de3d43 100644 --- a/source4/pidl/lib/Parse/Pidl/ODL.pm +++ b/source4/pidl/lib/Parse/Pidl/ODL.pm @@ -38,8 +38,8 @@ sub FunctionAddObjArgs($) }); unshift(@{$e->{ELEMENTS}}, { 'NAME' => 'ORPCthat', - 'POINTERS' => 0, - 'PROPERTIES' => { 'out' => '1' }, + 'POINTERS' => 1, + 'PROPERTIES' => { 'out' => '1', 'ref' => '1' }, 'TYPE' => 'ORPCTHAT', 'FILE' => $e->{FILE}, 'LINE' => $e->{LINE} -- cgit From 4d3434ff6e83799a1690b3ad3475beb3ef6f12ba Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 24 Sep 2006 16:39:28 +0000 Subject: r18873: Use WERR_errors table rather than DOS_errors table for wireshark. (This used to be commit 5a2e103ea0b31e80e4b2c2237b5fd9940820cec6) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 872a149274..b91ba10e98 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -452,7 +452,7 @@ sub Function($$$) } elsif ($fn->{RETURN_TYPE} eq "WERROR") { pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, &status);\n"; pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; - pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, DOS_errors, \"Unknown DOS error 0x%08x\"));\n"; + pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, WERR_errors, \"Unknown DOS error 0x%08x\"));\n"; $hf_used{"hf\_$ifname\_werror"} = 1; } else { @@ -749,7 +749,7 @@ sub ProcessInterface($) } if (defined($hf_used{"hf_$x->{NAME}_werror"})) { - register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "VALS(DOS_errors)", 0, ""); + register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "VALS(WERR_errors)", 0, ""); } RegisterInterface($x); -- cgit From a22d785d7cdfbb662a0755552acfbf995d865d0c Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Mon, 2 Oct 2006 16:19:05 +0000 Subject: r19049: Samba 3 client fixes * Make sure to check for NULL pointers when dealing with [out,unique] before assigning valoues * Detect RPC faults and return immediately (This used to be commit c96dae478c2fee2fede9c853a71c8079bbb8ba47) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 3b75bf33a6..c939feb1b9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -57,6 +57,14 @@ sub ParseFunction($$) pidl "\tNDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"; pidl ""; pidl "status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, $ufn, &r, (ndr_pull_flags_fn_t)ndr_pull_$fn->{NAME}, (ndr_push_flags_fn_t)ndr_push_$fn->{NAME});"; + pidl ""; + + pidl "if ( !NT_STATUS_IS_OK(status) ) {"; + indent; + pidl "return status;"; + deindent; + pidl "}"; + pidl ""; pidl "if (DEBUGLEVEL >= 10)"; pidl "\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);"; @@ -71,7 +79,16 @@ sub ParseFunction($$) fatal($e, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); - pidl "*$e->{NAME} = *r.out.$e->{NAME};"; + if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") && ($e->{LEVELS}[0]->{POINTER_TYPE} eq "unique") ) { + pidl "if ( $e->{NAME} ) {"; + indent; + pidl "*$e->{NAME} = *r.out.$e->{NAME};"; + deindent; + pidl "}"; + } else { + pidl "*$e->{NAME} = *r.out.$e->{NAME};"; + } + } pidl""; -- cgit From e461cfee2ed62ad001d5e5a57fa32b83a3905733 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Mon, 9 Oct 2006 19:40:48 +0000 Subject: r19208: Fix Samba3 pidl generation to remove memory leaks. Jermey. (This used to be commit 4b878578c27d499e38b208c87b4fd4b399474092) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 928a88ba5e..02fd1884a2 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -138,7 +138,7 @@ sub ParseFunction($$) pidl "}"; pidl ""; pidl "blob = ndr_push_blob(push);"; - pidl "if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {"; + pidl "if (!prs_copy_data_in(&p->out_data.rdata, blob.data, (uint32)blob.length)) {"; pidl "\ttalloc_free(mem_ctx);"; pidl "\treturn False;"; pidl "}"; -- cgit From af5e5175215145fb36bb28357894c41abd3bca84 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Tue, 10 Oct 2006 07:52:31 +0000 Subject: r19219: Fix a memleak in the generated srv_code. Fix a warning. Implement the rng_fault_state return check. After this (and Jeremy's fix) all Samba3-developers should do a 'make idl' and do a complete rebuild. Volker (This used to be commit 0c0a861c8b5b4c44d290f8db0d4c5e95260140ca) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 02fd1884a2..a7c81e4e2b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -70,8 +70,10 @@ sub ParseFunction($$) pidl "}"; pidl ""; pidl "pull = ndr_pull_init_blob(&blob, mem_ctx);"; - pidl "if (pull == NULL)"; + pidl "if (pull == NULL) {"; + pidl "\ttalloc_free(mem_ctx);"; pidl "\treturn False;"; + pidl "}"; pidl ""; pidl "pull->flags |= LIBNDR_FLAG_REF_ALLOC;"; pidl "status = ndr_pull_$fn->{NAME}(pull, NDR_IN, &r);"; @@ -121,6 +123,12 @@ sub ParseFunction($$) pidl_hdr "$proto"; pidl "$ret;"; + pidl ""; + pidl "if (p->rng_fault_state) {"; + pidl "\ttalloc_free(mem_ctx);"; + pidl "\t/* Return True here, srv_pipe_hnd.c will take care */"; + pidl "\treturn True;"; + pidl "}"; pidl ""; pidl "if (DEBUGLEVEL >= 10)"; pidl "\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);"; @@ -138,7 +146,7 @@ sub ParseFunction($$) pidl "}"; pidl ""; pidl "blob = ndr_push_blob(push);"; - pidl "if (!prs_copy_data_in(&p->out_data.rdata, blob.data, (uint32)blob.length)) {"; + pidl "if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {"; pidl "\ttalloc_free(mem_ctx);"; pidl "\treturn False;"; pidl "}"; -- cgit From 70b8d2c8eb42cbde5dbf5642afd2ccc9b3c76808 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 3 Nov 2006 19:55:17 +0000 Subject: r19541: Explicitly segfault when the API is being used incorrectly. Previously this would've caused a silent premature return. (This used to be commit 91ae5a803334f77c2328ea12542158aab4da2da8) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 13 ------------- 1 file changed, 13 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 6124935e67..75f30f7370 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -187,18 +187,6 @@ sub check_null_pointer_deferred($) } } -##################################################################### -# check that a variable we get from ParseExpr isn't a null pointer -# void return varient -sub check_null_pointer_void($) -{ - my $size = shift; - if ($size =~ /^\*/) { - my $size2 = substr($size, 1); - pidl "if ($size2 == NULL) return;"; - } -} - ##################################################################### # declare a function public or static, depending on its attributes sub fn_declare($$$) @@ -757,7 +745,6 @@ sub ParseElementPrint($$$) pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; } elsif ($l->{TYPE} eq "SWITCH") { my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); - check_null_pointer_void($switch_var); pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"; } } -- cgit From 4be0aa0d31db0ec4665fd476775d3ada016499f1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 3 Nov 2006 23:08:33 +0000 Subject: r19544: Fix case of 'warning'. (This used to be commit 4f1f541837db31322d875b6d2452c3f3a0d37fcd) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index cd8aa214ff..6a3698a920 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -75,7 +75,7 @@ my $scalar_alignment = { sub nonfatal($$) { my ($e,$s) = @_; - warn ("$e->{FILE}:$e->{LINE}: Warning: $s\n"); + warn ("$e->{FILE}:$e->{LINE}: warning: $s\n"); } ##################################################################### diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm index 93927f8f54..163b3053f4 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm @@ -347,7 +347,7 @@ sub ReadConformance($$) shift @fields; if (not defined($field_handlers{$cmd})) { - print "$f:$ln: Warning: Unknown command `$cmd'\n"; + print "$f:$ln: warning: Unknown command `$cmd'\n"; next; } -- cgit From 36b971bb3c77894bca4f83901f8c673f14480b0b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 4 Nov 2006 01:53:29 +0000 Subject: r19545: Allow enums as return types in code generated for wireshark. Originally based on a patch by Julien Kerihuel. (This used to be commit 705cd03c53f097086ef4f5aee9311a45bd19afa2) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 52 ++++++++++++++++++++-------- 1 file changed, 37 insertions(+), 15 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index b91ba10e98..2a636139de 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -36,6 +36,7 @@ sub error($$) my @ett; my %hf_used = (); +my %return_types = (); my %dissector_used = (); my $conformance = undef; @@ -146,7 +147,7 @@ sub Enum($$$) } pidl_hdr "extern const value_string $valsstring\[];"; - pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; + pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 *param);"; pidl_def "const value_string ".$valsstring."[] = {"; foreach (@{$e->{ELEMENTS}}) { @@ -159,10 +160,10 @@ sub Enum($$$) pidl_fn_start $dissectorname; pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 *param)"; pidl_code "{"; indent; - pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, NULL);"; + pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, param);"; pidl_code "return offset;"; deindent; pidl_code "}\n"; @@ -434,7 +435,20 @@ sub Function($$$) pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; pidl_code "{"; indent; - pidl_code "guint32 status;\n"; + if ( not defined($fn->{RETURN_TYPE})) { + } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS" or $fn->{RETURN_TYPE} eq "WERROR") + { + pidl_code "guint32 status;\n"; + } elsif (my $type = getType($fn->{RETURN_TYPE})) { + if ($type->{DATA}->{TYPE} eq "ENUM") { + pidl_code "g".Parse::Pidl::Typelist::enum_type_fn($type) . " status;\n"; + } else { + print "$fn->{FILE}:$fn->{LINE}: error: return type `$fn->{RETURN_TYPE}' not yet supported\n"; + } + } else { + print "$fn->{FILE}:$fn->{LINE}: error: unknown return type `$fn->{RETURN_TYPE}'\n"; + } + foreach (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$_->{DIRECTION}})) { pidl_code "$dissectornames{$_->{NAME}}"; @@ -448,15 +462,23 @@ sub Function($$$) pidl_code "offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, &status);\n"; pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, NT_errors, \"Unknown NT status 0x%08x\"));\n"; - $hf_used{"hf\_$ifname\_status"} = 1; + $return_types{$ifname}->{"status"} = ["NTSTATUS", "Windows Error"]; } elsif ($fn->{RETURN_TYPE} eq "WERROR") { pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, &status);\n"; pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, WERR_errors, \"Unknown DOS error 0x%08x\"));\n"; - $hf_used{"hf\_$ifname\_werror"} = 1; - } else { - print "$fn->{FILE}:$fn->{LINE}: error: return type `$fn->{RETURN_TYPE}' not yet supported\n"; + $return_types{$ifname}->{"werror"} = ["WERROR", "Windows Error"]; + } elsif (my $type = getType($fn->{RETURN_TYPE})) { + if ($type->{DATA}->{TYPE} eq "ENUM") { + my $return_type = "g".Parse::Pidl::Typelist::enum_type_fn($type); + my $return_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($type); + + pidl_code "offset = $return_dissect(tvb, offset, pinfo, tree, drep, hf\_$ifname\_$fn->{RETURN_TYPE}_status, &status);"; + pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; + pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Status: %s\", val_to_str(status, $ifname\_$fn->{RETURN_TYPE}\_vals, \"Unknown " . $fn->{RETURN_TYPE} . " error 0x%08x\"));\n"; + $return_types{$ifname}->{$fn->{RETURN_TYPE}."_status"} = [$fn->{RETURN_TYPE}, $fn->{RETURN_TYPE}]; + } } @@ -739,17 +761,17 @@ sub ProcessInterface($) pidl_def ""; } + $return_types{$x->{NAME}} = {}; + Interface($x); pidl_code "\n".DumpFunctionTable($x); - # Only register these two return types if they were actually used - if (defined($hf_used{"hf_$x->{NAME}_status"})) { - register_hf_field("hf_$x->{NAME}_status", "Status", "$x->{NAME}.status", "FT_UINT32", "BASE_HEX", "VALS(NT_errors)", 0, ""); - } - - if (defined($hf_used{"hf_$x->{NAME}_werror"})) { - register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "VALS(WERR_errors)", 0, ""); + foreach (keys %{$return_types{$x->{NAME}}}) { + my ($type, $desc) = @{$return_types{$x->{NAME}}->{$_}}; + my $dt = find_type($type); + register_hf_field("hf_$x->{NAME}_$_", $desc, "$x->{NAME}.$_", $dt->{FT_TYPE}, "BASE_HEX", $dt->{VALSSTRING}, 0, ""); + $hf_used{"hf_$x->{NAME}_$_"} = 1; } RegisterInterface($x); -- cgit From d9862f2bc48e4da63aaa4cc0255d08fd36bd0a66 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 4 Nov 2006 02:51:03 +0000 Subject: r19546: fix number of bytes pushed when using switch_type() set to enum types. die() on invalid used of enum_type_fn() (This used to be commit de6198c893737e63a5ff70684c1df212da054988) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 2 +- source4/pidl/lib/Parse/Pidl/Typelist.pm | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 75f30f7370..1bb277fd0e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1694,7 +1694,7 @@ sub ParseUnionPull($$) pidl "int level;"; if (defined($switch_type)) { if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) { - $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)); + $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)->{DATA}); } pidl mapType($switch_type) . " _level;"; } diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 66d5e59e7c..4109e8032e 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -153,6 +153,7 @@ sub RegisterScalars() sub enum_type_fn($) { my $enum = shift; + $enum->{TYPE} eq "ENUM" or die("not an enum"); if (has_property($enum->{PARENT}, "enum8bit")) { return "uint8"; } elsif (has_property($enum->{PARENT}, "v1_enum")) { -- cgit From 77d1be3e8da0c4796a518e15e16d4083445613c7 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 4 Nov 2006 02:54:24 +0000 Subject: r19547: Fix use of v1_enum on enums used in return types. (This used to be commit dbae9b4e4ea38806062ba34dcf05a67c2e7af043) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 2a636139de..8793dd5774 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -441,7 +441,7 @@ sub Function($$$) pidl_code "guint32 status;\n"; } elsif (my $type = getType($fn->{RETURN_TYPE})) { if ($type->{DATA}->{TYPE} eq "ENUM") { - pidl_code "g".Parse::Pidl::Typelist::enum_type_fn($type) . " status;\n"; + pidl_code "g".Parse::Pidl::Typelist::enum_type_fn($type->{DATA}) . " status;\n"; } else { print "$fn->{FILE}:$fn->{LINE}: error: return type `$fn->{RETURN_TYPE}' not yet supported\n"; } @@ -471,8 +471,8 @@ sub Function($$$) $return_types{$ifname}->{"werror"} = ["WERROR", "Windows Error"]; } elsif (my $type = getType($fn->{RETURN_TYPE})) { if ($type->{DATA}->{TYPE} eq "ENUM") { - my $return_type = "g".Parse::Pidl::Typelist::enum_type_fn($type); - my $return_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($type); + my $return_type = "g".Parse::Pidl::Typelist::enum_type_fn($type->{DATA}); + my $return_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($type->{DATA}); pidl_code "offset = $return_dissect(tvb, offset, pinfo, tree, drep, hf\_$ifname\_$fn->{RETURN_TYPE}_status, &status);"; pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; @@ -578,8 +578,8 @@ sub Union($$$) my $switch_dissect; my $switch_dt = getType($e->{SWITCH_TYPE}); if ($switch_dt->{DATA}->{TYPE} eq "ENUM") { - $switch_type = "g".Parse::Pidl::Typelist::enum_type_fn($switch_dt); - $switch_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($switch_dt); + $switch_type = "g".Parse::Pidl::Typelist::enum_type_fn($switch_dt->{DATA}); + $switch_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($switch_dt->{DATA}); } elsif ($switch_dt->{DATA}->{TYPE} eq "SCALAR") { $switch_type = "g$e->{SWITCH_TYPE}"; $switch_dissect = "dissect_ndr_$e->{SWITCH_TYPE}"; -- cgit From 0f738f13f9a0105a0eb6506537f538a093446904 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 4 Nov 2006 15:40:05 +0000 Subject: r19553: Add check for correct API usage. (This used to be commit 9e2206ae99ed6dc64788b71f1301bd188ab0026d) --- source4/pidl/lib/Parse/Pidl/Typelist.pm | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 4109e8032e..88f896632d 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -166,6 +166,8 @@ sub bitmap_type_fn($) { my $bitmap = shift; + $bitmap->{TYPE} eq "BITMAP" or die("not an enum"); + if (has_property($bitmap, "bitmap8bit")) { return "uint8"; } elsif (has_property($bitmap, "bitmap16bit")) { -- cgit From 6031841dd8c605af09889ee3c3128224ef833c32 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 4 Nov 2006 20:24:35 +0000 Subject: r19557: Fix lookup table for WERROR. Fix perl warnings when using NTSTATUS as return type. (This used to be commit 577cd1625d97efae7bb397570de81a6a5ac0b1b0) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 8793dd5774..e211a896ad 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -462,7 +462,7 @@ sub Function($$$) pidl_code "offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, &status);\n"; pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, NT_errors, \"Unknown NT status 0x%08x\"));\n"; - $return_types{$ifname}->{"status"} = ["NTSTATUS", "Windows Error"]; + $return_types{$ifname}->{"status"} = ["NTSTATUS", "NT Error"]; } elsif ($fn->{RETURN_TYPE} eq "WERROR") { pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, &status);\n"; pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; @@ -770,6 +770,7 @@ sub ProcessInterface($) foreach (keys %{$return_types{$x->{NAME}}}) { my ($type, $desc) = @{$return_types{$x->{NAME}}->{$_}}; my $dt = find_type($type); + $dt or die("Unable to find information about return type `$type'"); register_hf_field("hf_$x->{NAME}_$_", $desc, "$x->{NAME}.$_", $dt->{FT_TYPE}, "BASE_HEX", $dt->{VALSSTRING}, 0, ""); $hf_used{"hf_$x->{NAME}_$_"} = 1; } @@ -839,6 +840,8 @@ sub Initialize($) offset = dissect_ndr_nt_SID_with_options(tvb, offset, pinfo, tree, drep, param); ","FT_STRING", "BASE_DEC", 0, "NULL", 4); register_type("WERROR", + "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(WERR_errors)", 4); + register_type("NTSTATUS", "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4); } -- cgit From 5b9f1b01ba6880ead4662bb66988bcdf5bf2aa82 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 4 Nov 2006 21:53:00 +0000 Subject: r19559: Fix handling of types where the name isn't prefixed by the interface name. Based on patch by Julien Kerihuel. (This used to be commit 466e9c12a5f9bd2f7bf00c710bd9a537b48e7864) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index e211a896ad..5af7c02032 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -256,9 +256,9 @@ sub Bitmap($$$) register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$size", "BASE_HEX", "0", "NULL", $size/8); } -sub ElementLevel($$$$$) +sub ElementLevel($$$$$$) { - my ($e,$l,$hf,$myname,$pn) = @_; + my ($e,$l,$hf,$myname,$pn,$ifname) = @_; my $param = 0; @@ -327,10 +327,7 @@ sub ElementLevel($$$$$) $call= $conformance->{types}->{$l->{DATA_TYPE}}->{DISSECTOR_NAME}; $conformance->{types}->{$l->{DATA_TYPE}}->{USED} = 1; } else { - if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/) - { - pidl_code "offset = $1_dissect_struct_$2(tvb,offset,pinfo,tree,drep,$hf,$param);"; - } + pidl_code "offset = $ifname\_dissect_struct_" . $l->{DATA_TYPE} . "(tvb,offset,pinfo,tree,drep,$hf,$param);"; return; } @@ -402,7 +399,7 @@ sub Element($$$) pidl_code "{"; indent; - ElementLevel($e,$_,$hf,$dissectorname.$add,$pn); + ElementLevel($e,$_,$hf,$dissectorname.$add,$pn,$ifname); pidl_code ""; pidl_code "return offset;"; -- cgit From ae0219cd8148bd01179f1686e8e12cf3ccdbf1a9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 5 Nov 2006 00:03:44 +0000 Subject: r19560: Fix handling of PARAM_VALUE. (This used to be commit dde3d5342cd8b67ec4a0929f3e5577d6b1e7d16b) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 5af7c02032..f72efc7534 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -263,7 +263,7 @@ sub ElementLevel($$$$$$) my $param = 0; if (defined($conformance->{dissectorparams}->{$myname})) { - $conformance->{dissectorparams}->{$myname}->{PARAM} = 1; +# $conformance->{dissectorparams}->{$myname}->{PARAM} = 1; $param = $conformance->{dissectorparams}->{$myname}->{PARAM}; } @@ -426,6 +426,8 @@ sub Function($$$) my $fn_name = $_->{NAME}; $fn_name =~ s/^${ifname}_//; + print "$fn_name\n"; + PrintIdl DumpFunction($fn->{ORIGINAL}); pidl_fn_start "$ifname\_dissect\_$fn_name\_response"; pidl_code "static int"; -- cgit From bdf1f0b0db569f65c1501df67788c4f9b7a66966 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 5 Nov 2006 00:08:39 +0000 Subject: r19561: Remove debug statement. (This used to be commit 910b56e72924661f30e43ca0e832b743e8d78d19) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 3 --- 1 file changed, 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index f72efc7534..c5a39a4c42 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -263,7 +263,6 @@ sub ElementLevel($$$$$$) my $param = 0; if (defined($conformance->{dissectorparams}->{$myname})) { -# $conformance->{dissectorparams}->{$myname}->{PARAM} = 1; $param = $conformance->{dissectorparams}->{$myname}->{PARAM}; } @@ -426,8 +425,6 @@ sub Function($$$) my $fn_name = $_->{NAME}; $fn_name =~ s/^${ifname}_//; - print "$fn_name\n"; - PrintIdl DumpFunction($fn->{ORIGINAL}); pidl_fn_start "$ifname\_dissect\_$fn_name\_response"; pidl_code "static int"; -- cgit From a7b18e70dd315efc15045d32c0c2bfdb76cf4805 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 5 Nov 2006 00:26:44 +0000 Subject: r19562: Support returning simple scalars. (This used to be commit 8bd12d3fdb23a532bf6b46bc88a21837303a0374) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index c5a39a4c42..8c75d590e0 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -438,6 +438,8 @@ sub Function($$$) } elsif (my $type = getType($fn->{RETURN_TYPE})) { if ($type->{DATA}->{TYPE} eq "ENUM") { pidl_code "g".Parse::Pidl::Typelist::enum_type_fn($type->{DATA}) . " status;\n"; + } elsif ($type->{DATA}->{TYPE} eq "SCALAR") { + pidl_code "g$fn->{RETURN_TYPE} status;\n"; } else { print "$fn->{FILE}:$fn->{LINE}: error: return type `$fn->{RETURN_TYPE}' not yet supported\n"; } @@ -474,6 +476,11 @@ sub Function($$$) pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Status: %s\", val_to_str(status, $ifname\_$fn->{RETURN_TYPE}\_vals, \"Unknown " . $fn->{RETURN_TYPE} . " error 0x%08x\"));\n"; $return_types{$ifname}->{$fn->{RETURN_TYPE}."_status"} = [$fn->{RETURN_TYPE}, $fn->{RETURN_TYPE}]; + } elsif ($type->{DATA}->{TYPE} eq "SCALAR") { + pidl_code "offset = dissect_ndr_$fn->{RETURN_TYPE}(tvb, offset, pinfo, tree, drep, hf\_$ifname\_$fn->{RETURN_TYPE}_status, &status);"; + pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; + pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Status: %d\", status);\n"; + $return_types{$ifname}->{$fn->{RETURN_TYPE}."_status"} = [$fn->{RETURN_TYPE}, $fn->{RETURN_TYPE}]; } } -- cgit From e08bf809af3a839f29df4d369e976a2f09a5853a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 6 Nov 2006 14:07:20 +0000 Subject: r19572: Fix typo. (This used to be commit 1836411390e7ad19dc0e28bf656a0c240edbf063) --- source4/pidl/lib/Parse/Pidl/Typelist.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 88f896632d..7be7e5a5c3 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -166,7 +166,7 @@ sub bitmap_type_fn($) { my $bitmap = shift; - $bitmap->{TYPE} eq "BITMAP" or die("not an enum"); + $bitmap->{TYPE} eq "BITMAP" or die("not a bitmap"); if (has_property($bitmap, "bitmap8bit")) { return "uint8"; -- cgit From 5c3fd8e4717ec7167a67f9e9ee1e2d86f7d515a8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 6 Nov 2006 20:01:22 +0000 Subject: r19580: Add --includedir option. (This used to be commit b076bfa39fefafcf30ac5be5056abfd629338fa5) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index b9c39f186e..87b4ccb5e5 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -2987,9 +2987,9 @@ sub parse_string return CleanData($idl); } -sub parse_file($) +sub parse_file($$) { - my ($filename) = @_; + my ($filename,$incdirs) = @_; my $saved_delim = $/; undef $/; @@ -2997,7 +2997,8 @@ sub parse_file($) if (! defined $cpp) { $cpp = "cpp"; } - my $data = `$cpp -D__PIDL__ -xc $filename`; + my $includes = map { " -I$_" } @$incdirs; + my $data = `$cpp -D__PIDL__$includes -xc $filename`; $/ = $saved_delim; return parse_string($data, $filename); -- cgit From d8ecabe452f36302105c6412ae5ab93cabfe5cf2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 6 Nov 2006 21:54:19 +0000 Subject: r19585: Add support for some more standard IDL instructions: - `include' (replaces helper()) - `import' (replaces depends()) Add support for parsing importlib() - importlib() is now ignored (with a warning), but no longer causes syntax errors. helper() and depends() are now marked deprecated and will cause warnings. (This used to be commit 1ccab71cb8a9e3db9448b6679d01ad00e1c1e9a3) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 2668 +++++++++++----------- source4/pidl/lib/Parse/Pidl/NDR.pm | 11 + source4/pidl/lib/Parse/Pidl/ODL.pm | 22 +- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 17 +- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 25 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 33 +- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 33 +- 7 files changed, 1501 insertions(+), 1308 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 87b4ccb5e5..e400862795 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -507,12 +507,17 @@ sub new { }, {#State 1 ACTIONS => { - '' => 2 + '' => 2, + "importlib" => 3, + "import" => 6 }, - DEFAULT => -84, + DEFAULT => -90, GOTOS => { - 'interface' => 3, - 'coclass' => 4, + 'importlib' => 9, + 'interface' => 8, + 'include' => 4, + 'coclass' => 10, + 'import' => 7, 'property_list' => 5 } }, @@ -520,1678 +525,1735 @@ sub new { DEFAULT => 0 }, {#State 3 - DEFAULT => -2 + ACTIONS => { + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 12, + 'constant' => 13, + 'commalisttext' => 15 + } }, {#State 4 - DEFAULT => -3 + DEFAULT => -5 }, {#State 5 ACTIONS => { - "coclass" => 6, - "interface" => 8, - "[" => 7 + "coclass" => 19, + "[" => 21, + "interface" => 20 } }, {#State 6 ACTIONS => { - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, + DEFAULT => -100, GOTOS => { - 'identifier' => 10 + 'identifier' => 17, + 'text' => 18, + 'anytext' => 12, + 'constant' => 13, + 'commalisttext' => 22 } }, {#State 7 - ACTIONS => { - 'IDENTIFIER' => 9 - }, - GOTOS => { - 'identifier' => 11, - 'properties' => 13, - 'property' => 12 - } + DEFAULT => -4 }, {#State 8 - ACTIONS => { - 'IDENTIFIER' => 9 - }, - GOTOS => { - 'identifier' => 14 - } + DEFAULT => -2 }, {#State 9 - DEFAULT => -113 + DEFAULT => -6 }, {#State 10 - ACTIONS => { - "{" => 15 - } + DEFAULT => -3 }, {#State 11 - ACTIONS => { - "(" => 16 - }, - DEFAULT => -88 + DEFAULT => -119 }, {#State 12 - DEFAULT => -86 + ACTIONS => { + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 + }, + DEFAULT => -98 }, {#State 13 - ACTIONS => { - "," => 17, - "]" => 18 - } + DEFAULT => -102 }, {#State 14 - ACTIONS => { - ":" => 19 - }, - DEFAULT => -8, - GOTOS => { - 'base_interface' => 20 - } + DEFAULT => -122 }, {#State 15 - DEFAULT => -5, - GOTOS => { - 'interface_names' => 21 + ACTIONS => { + ";" => 38, + "," => 39 } }, {#State 16 - ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'listtext' => 26, - 'anytext' => 25, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -123 }, {#State 17 - ACTIONS => { - 'IDENTIFIER' => 9 - }, - GOTOS => { - 'identifier' => 11, - 'property' => 29 - } + DEFAULT => -101 }, {#State 18 - DEFAULT => -85 + DEFAULT => -103 }, {#State 19 ACTIONS => { - 'IDENTIFIER' => 9 + 'IDENTIFIER' => 11 }, GOTOS => { - 'identifier' => 30 + 'identifier' => 40 } }, {#State 20 ACTIONS => { - "{" => 31 + 'IDENTIFIER' => 11 + }, + GOTOS => { + 'identifier' => 41 } }, {#State 21 ACTIONS => { - "}" => 32, - "interface" => 33 + 'IDENTIFIER' => 11 + }, + GOTOS => { + 'identifier' => 43, + 'property' => 44, + 'properties' => 42 } }, {#State 22 - DEFAULT => -117 + ACTIONS => { + ";" => 45, + "," => 39 + } }, {#State 23 - DEFAULT => -95 + ACTIONS => { + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 46, + 'constant' => 13 + } }, {#State 24 - DEFAULT => -97 + ACTIONS => { + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 47, + 'constant' => 13 + } }, {#State 25 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 - }, - DEFAULT => -90 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 48, + 'constant' => 13 + } }, {#State 26 ACTIONS => { - "," => 49, - ")" => 50 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 49, + 'constant' => 13 } }, {#State 27 - DEFAULT => -96 + ACTIONS => { + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 50, + 'constant' => 13 + } }, {#State 28 - DEFAULT => -116 + ACTIONS => { + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 51, + 'constant' => 13 + } }, {#State 29 - DEFAULT => -87 + ACTIONS => { + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 12, + 'constant' => 13, + 'commalisttext' => 52 + } }, {#State 30 - DEFAULT => -9 + ACTIONS => { + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 53, + 'constant' => 13 + } }, {#State 31 ACTIONS => { - "typedef" => 51, - "union" => 52, - "enum" => 65, - "bitmap" => 66, - "declare" => 58, - "const" => 60, - "struct" => 63 - }, - DEFAULT => -84, - GOTOS => { - 'typedecl' => 64, - 'function' => 53, - 'bitmap' => 67, - 'definitions' => 54, - 'definition' => 57, - 'property_list' => 56, - 'usertype' => 55, - 'declare' => 69, - 'const' => 68, - 'struct' => 59, - 'enum' => 61, - 'typedef' => 62, - 'union' => 70 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 54, + 'constant' => 13 } }, {#State 32 ACTIONS => { - ";" => 71 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -118, + DEFAULT => -100, GOTOS => { - 'optional_semicolon' => 72 + 'identifier' => 17, + 'text' => 18, + 'anytext' => 55, + 'constant' => 13 } }, {#State 33 ACTIONS => { - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, + DEFAULT => -100, GOTOS => { - 'identifier' => 73 + 'identifier' => 17, + 'text' => 18, + 'anytext' => 12, + 'constant' => 13, + 'commalisttext' => 56 } }, {#State 34 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 74, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'text' => 18, + 'anytext' => 57, + 'constant' => 13 } }, {#State 35 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 75, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'text' => 18, + 'anytext' => 58, + 'constant' => 13 } }, {#State 36 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 76, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'text' => 18, + 'anytext' => 59, + 'constant' => 13 } }, {#State 37 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 77, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'text' => 18, + 'anytext' => 60, + 'constant' => 13 } }, {#State 38 - ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 78, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -9 }, {#State 39 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 79, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'text' => 18, + 'anytext' => 61, + 'constant' => 13 } }, {#State 40 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 80, - 'text' => 24, - 'constant' => 27, - 'commalisttext' => 81 + "{" => 62 } }, {#State 41 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + ":" => 63 }, - DEFAULT => -94, + DEFAULT => -14, GOTOS => { - 'identifier' => 23, - 'anytext' => 82, - 'text' => 24, - 'constant' => 27 + 'base_interface' => 64 } }, {#State 42 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 83, - 'text' => 24, - 'constant' => 27 + "," => 65, + "]" => 66 } }, {#State 43 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + "(" => 67 }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 84, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -94 }, {#State 44 - ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 80, - 'text' => 24, - 'constant' => 27, - 'commalisttext' => 85 - } + DEFAULT => -92 }, {#State 45 - ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 86, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -7 }, {#State 46 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 87, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -113 }, {#State 47 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + ":" => 23, + "<" => 26, + "~" => 27, + "?" => 25, + "{" => 29, + "=" => 32 }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 88, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -104 }, {#State 48 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 89, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -112 }, {#State 49 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 90, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -108 }, {#State 50 - DEFAULT => -89 + ACTIONS => { + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 + }, + DEFAULT => -116 }, {#State 51 - DEFAULT => -84, - GOTOS => { - 'property_list' => 91 - } + ACTIONS => { + ":" => 23, + "<" => 26, + "~" => 27, + "?" => 25, + "{" => 29, + "=" => 32 + }, + DEFAULT => -115 }, {#State 52 ACTIONS => { - 'IDENTIFIER' => 92 - }, - DEFAULT => -115, - GOTOS => { - 'optional_identifier' => 93 + "}" => 68, + "," => 39 } }, {#State 53 - DEFAULT => -12 + ACTIONS => { + ":" => 23, + "<" => 26, + "~" => 27, + "?" => 25, + "{" => 29, + "=" => 32 + }, + DEFAULT => -110 }, {#State 54 ACTIONS => { - "}" => 94, - "typedef" => 51, - "union" => 52, - "enum" => 65, - "bitmap" => 66, - "declare" => 58, - "const" => 60, - "struct" => 63 - }, - DEFAULT => -84, - GOTOS => { - 'typedecl' => 64, - 'function' => 53, - 'bitmap' => 67, - 'definition' => 95, - 'property_list' => 56, - 'usertype' => 55, - 'const' => 68, - 'struct' => 59, - 'declare' => 69, - 'enum' => 61, - 'typedef' => 62, - 'union' => 70 - } + ":" => 23, + "<" => 26, + "~" => 27, + "?" => 25, + "{" => 29, + "=" => 32 + }, + DEFAULT => -111 }, {#State 55 ACTIONS => { - ";" => 96 - } + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 + }, + DEFAULT => -114 }, {#State 56 ACTIONS => { - 'IDENTIFIER' => 9, - "signed" => 102, - "union" => 52, - "enum" => 65, - "bitmap" => 66, - 'void' => 97, - "unsigned" => 103, - "[" => 7, - "struct" => 63 - }, - GOTOS => { - 'existingtype' => 101, - 'bitmap' => 67, - 'usertype' => 98, - 'identifier' => 99, - 'struct' => 59, - 'enum' => 61, - 'type' => 104, - 'union' => 70, - 'sign' => 100 + "," => 39, + ")" => 69 } }, {#State 57 - DEFAULT => -10 + ACTIONS => { + ":" => 23, + "<" => 26, + "~" => 27, + "?" => 25, + "{" => 29, + "=" => 32 + }, + DEFAULT => -109 }, {#State 58 - DEFAULT => -84, - GOTOS => { - 'property_list' => 105 - } + ACTIONS => { + ":" => 23, + "<" => 26, + "~" => 27, + "?" => 25, + "{" => 29, + "=" => 32 + }, + DEFAULT => -106 }, {#State 59 - DEFAULT => -28 + ACTIONS => { + ":" => 23, + "<" => 26, + "~" => 27, + "?" => 25, + "{" => 29, + "=" => 32 + }, + DEFAULT => -105 }, {#State 60 ACTIONS => { - 'IDENTIFIER' => 9 + ":" => 23, + "<" => 26, + "~" => 27, + "?" => 25, + "{" => 29, + "=" => 32 }, - GOTOS => { - 'identifier' => 106 - } + DEFAULT => -107 }, {#State 61 - DEFAULT => -30 + ACTIONS => { + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 + }, + DEFAULT => -99 }, {#State 62 - DEFAULT => -14 + DEFAULT => -11, + GOTOS => { + 'interface_names' => 70 + } }, {#State 63 ACTIONS => { - 'IDENTIFIER' => 92 + 'IDENTIFIER' => 11 }, - DEFAULT => -115, GOTOS => { - 'optional_identifier' => 107 + 'identifier' => 71 } }, {#State 64 - DEFAULT => -16 + ACTIONS => { + "{" => 72 + } }, {#State 65 ACTIONS => { - 'IDENTIFIER' => 92 + 'IDENTIFIER' => 11 }, - DEFAULT => -115, GOTOS => { - 'optional_identifier' => 108 + 'identifier' => 43, + 'property' => 73 } }, {#State 66 + DEFAULT => -91 + }, + {#State 67 ACTIONS => { - 'IDENTIFIER' => 92 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -115, + DEFAULT => -100, GOTOS => { - 'optional_identifier' => 109 + 'identifier' => 17, + 'text' => 18, + 'listtext' => 75, + 'anytext' => 74, + 'constant' => 13 } }, - {#State 67 - DEFAULT => -31 - }, {#State 68 - DEFAULT => -13 + ACTIONS => { + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 76, + 'constant' => 13 + } }, {#State 69 - DEFAULT => -15 + ACTIONS => { + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 + }, + DEFAULT => -100, + GOTOS => { + 'identifier' => 17, + 'text' => 18, + 'anytext' => 77, + 'constant' => 13 + } }, {#State 70 - DEFAULT => -29 + ACTIONS => { + "}" => 78, + "interface" => 79 + } }, {#State 71 - DEFAULT => -119 + DEFAULT => -15 }, {#State 72 - DEFAULT => -4 - }, - {#State 73 ACTIONS => { - ";" => 110 + "typedef" => 80, + "union" => 81, + "enum" => 94, + "bitmap" => 95, + "declare" => 87, + "const" => 89, + "struct" => 92 + }, + DEFAULT => -90, + GOTOS => { + 'typedecl' => 93, + 'function' => 82, + 'bitmap' => 96, + 'definitions' => 83, + 'definition' => 86, + 'property_list' => 85, + 'usertype' => 84, + 'declare' => 98, + 'const' => 97, + 'struct' => 88, + 'enum' => 90, + 'typedef' => 91, + 'union' => 99 } }, + {#State 73 + DEFAULT => -93 + }, {#State 74 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 }, - DEFAULT => -107 + DEFAULT => -96 }, {#State 75 ACTIONS => { - ":" => 34, - "<" => 37, - "~" => 38, - "?" => 36, - "{" => 40, - "=" => 43 - }, - DEFAULT => -98 + "," => 100, + ")" => 101 + } }, {#State 76 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 - }, - DEFAULT => -106 + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 + }, + DEFAULT => -118 }, {#State 77 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 + ":" => 23, + "<" => 26, + "~" => 27, + "?" => 25, + "{" => 29, + "=" => 32 }, - DEFAULT => -102 + DEFAULT => -117 }, {#State 78 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 + ";" => 102 }, - DEFAULT => -110 + DEFAULT => -124, + GOTOS => { + 'optional_semicolon' => 103 + } }, {#State 79 ACTIONS => { - ":" => 34, - "<" => 37, - "~" => 38, - "?" => 36, - "{" => 40, - "=" => 43 + 'IDENTIFIER' => 11 }, - DEFAULT => -109 + GOTOS => { + 'identifier' => 104 + } }, {#State 80 - ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 - }, - DEFAULT => -92 + DEFAULT => -90, + GOTOS => { + 'property_list' => 105 + } }, {#State 81 ACTIONS => { - "}" => 111, - "," => 112 + 'IDENTIFIER' => 106 + }, + DEFAULT => -121, + GOTOS => { + 'optional_identifier' => 107 } }, {#State 82 - ACTIONS => { - ":" => 34, - "<" => 37, - "~" => 38, - "?" => 36, - "{" => 40, - "=" => 43 - }, - DEFAULT => -104 + DEFAULT => -18 }, {#State 83 ACTIONS => { - ":" => 34, - "<" => 37, - "~" => 38, - "?" => 36, - "{" => 40, - "=" => 43 - }, - DEFAULT => -105 + "}" => 108, + "typedef" => 80, + "union" => 81, + "enum" => 94, + "bitmap" => 95, + "declare" => 87, + "const" => 89, + "struct" => 92 + }, + DEFAULT => -90, + GOTOS => { + 'typedecl' => 93, + 'function' => 82, + 'bitmap' => 96, + 'definition' => 109, + 'property_list' => 85, + 'usertype' => 84, + 'const' => 97, + 'struct' => 88, + 'declare' => 98, + 'enum' => 90, + 'typedef' => 91, + 'union' => 99 + } }, {#State 84 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 - }, - DEFAULT => -108 + ";" => 110 + } }, {#State 85 ACTIONS => { - "," => 112, - ")" => 113 + 'IDENTIFIER' => 11, + "signed" => 116, + "union" => 81, + "enum" => 94, + "bitmap" => 95, + 'void' => 111, + "unsigned" => 117, + "[" => 21, + "struct" => 92 + }, + GOTOS => { + 'existingtype' => 115, + 'bitmap' => 96, + 'usertype' => 112, + 'identifier' => 113, + 'struct' => 88, + 'enum' => 90, + 'type' => 118, + 'union' => 99, + 'sign' => 114 } }, {#State 86 - ACTIONS => { - ":" => 34, - "<" => 37, - "~" => 38, - "?" => 36, - "{" => 40, - "=" => 43 - }, - DEFAULT => -103 + DEFAULT => -16 }, {#State 87 - ACTIONS => { - ":" => 34, - "<" => 37, - "~" => 38, - "?" => 36, - "{" => 40, - "=" => 43 - }, - DEFAULT => -100 + DEFAULT => -90, + GOTOS => { + 'property_list' => 119 + } }, {#State 88 + DEFAULT => -34 + }, + {#State 89 ACTIONS => { - ":" => 34, - "<" => 37, - "~" => 38, - "?" => 36, - "{" => 40, - "=" => 43 + 'IDENTIFIER' => 11 }, - DEFAULT => -99 - }, - {#State 89 - ACTIONS => { - ":" => 34, - "<" => 37, - "~" => 38, - "?" => 36, - "{" => 40, - "=" => 43 - }, - DEFAULT => -101 + GOTOS => { + 'identifier' => 120 + } }, {#State 90 - ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 - }, - DEFAULT => -91 + DEFAULT => -36 }, {#State 91 + DEFAULT => -20 + }, + {#State 92 ACTIONS => { - 'IDENTIFIER' => 9, - "signed" => 102, - "union" => 52, - "enum" => 65, - "bitmap" => 66, - 'void' => 97, - "unsigned" => 103, - "[" => 7, - "struct" => 63 + 'IDENTIFIER' => 106 }, + DEFAULT => -121, GOTOS => { - 'existingtype' => 101, - 'bitmap' => 67, - 'usertype' => 98, - 'identifier' => 99, - 'struct' => 59, - 'enum' => 61, - 'type' => 114, - 'union' => 70, - 'sign' => 100 + 'optional_identifier' => 121 } }, - {#State 92 - DEFAULT => -114 - }, {#State 93 + DEFAULT => -22 + }, + {#State 94 ACTIONS => { - "{" => 116 + 'IDENTIFIER' => 106 }, - DEFAULT => -69, + DEFAULT => -121, GOTOS => { - 'union_body' => 117, - 'opt_union_body' => 115 + 'optional_identifier' => 122 } }, - {#State 94 + {#State 95 ACTIONS => { - ";" => 71 + 'IDENTIFIER' => 106 }, - DEFAULT => -118, + DEFAULT => -121, GOTOS => { - 'optional_semicolon' => 118 + 'optional_identifier' => 123 } }, - {#State 95 - DEFAULT => -11 - }, {#State 96 - DEFAULT => -32 + DEFAULT => -37 }, {#State 97 - DEFAULT => -40 + DEFAULT => -19 }, {#State 98 - DEFAULT => -38 + DEFAULT => -21 }, {#State 99 - DEFAULT => -37 + DEFAULT => -35 }, {#State 100 ACTIONS => { - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, + DEFAULT => -100, GOTOS => { - 'identifier' => 119 + 'identifier' => 17, + 'anytext' => 124, + 'text' => 18, + 'constant' => 13 } }, {#State 101 - DEFAULT => -39 + DEFAULT => -95 }, {#State 102 - DEFAULT => -33 + DEFAULT => -125 }, {#State 103 - DEFAULT => -34 + DEFAULT => -10 }, {#State 104 ACTIONS => { - 'IDENTIFIER' => 9 - }, - GOTOS => { - 'identifier' => 120 + ";" => 125 } }, {#State 105 ACTIONS => { - "union" => 121, - "enum" => 126, - "bitmap" => 127, - "[" => 7 + 'IDENTIFIER' => 11, + "signed" => 116, + "union" => 81, + "enum" => 94, + "bitmap" => 95, + 'void' => 111, + "unsigned" => 117, + "[" => 21, + "struct" => 92 }, GOTOS => { - 'decl_enum' => 122, - 'decl_bitmap' => 123, - 'decl_type' => 125, - 'decl_union' => 124 + 'existingtype' => 115, + 'bitmap' => 96, + 'usertype' => 112, + 'identifier' => 113, + 'struct' => 88, + 'enum' => 90, + 'type' => 126, + 'union' => 99, + 'sign' => 114 } }, {#State 106 - DEFAULT => -73, - GOTOS => { - 'pointers' => 128 - } + DEFAULT => -120 }, {#State 107 ACTIONS => { - "{" => 130 + "{" => 128 }, - DEFAULT => -59, + DEFAULT => -75, GOTOS => { - 'struct_body' => 129, - 'opt_struct_body' => 131 + 'union_body' => 129, + 'opt_union_body' => 127 } }, {#State 108 ACTIONS => { - "{" => 132 + ";" => 102 }, - DEFAULT => -42, + DEFAULT => -124, GOTOS => { - 'opt_enum_body' => 134, - 'enum_body' => 133 + 'optional_semicolon' => 130 } }, {#State 109 - ACTIONS => { - "{" => 136 - }, - DEFAULT => -50, - GOTOS => { - 'bitmap_body' => 137, - 'opt_bitmap_body' => 135 - } + DEFAULT => -17 }, {#State 110 - DEFAULT => -6 + DEFAULT => -38 }, {#State 111 - ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 138, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -46 }, {#State 112 - ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 139, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -44 }, {#State 113 - ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 - }, - DEFAULT => -94, - GOTOS => { - 'identifier' => 23, - 'anytext' => 140, - 'text' => 24, - 'constant' => 27 - } + DEFAULT => -43 }, {#State 114 ACTIONS => { - 'IDENTIFIER' => 9 + 'IDENTIFIER' => 11 }, GOTOS => { - 'identifier' => 141 + 'identifier' => 131 } }, {#State 115 - DEFAULT => -71 + DEFAULT => -45 }, {#State 116 - DEFAULT => -66, - GOTOS => { - 'union_elements' => 142 - } + DEFAULT => -39 }, {#State 117 - DEFAULT => -70 + DEFAULT => -40 }, {#State 118 - DEFAULT => -7 + ACTIONS => { + 'IDENTIFIER' => 11 + }, + GOTOS => { + 'identifier' => 132 + } }, {#State 119 - DEFAULT => -36 + ACTIONS => { + "union" => 133, + "enum" => 138, + "bitmap" => 139, + "[" => 21 + }, + GOTOS => { + 'decl_enum' => 134, + 'decl_bitmap' => 135, + 'decl_type' => 137, + 'decl_union' => 136 + } }, {#State 120 - ACTIONS => { - "(" => 143 + DEFAULT => -79, + GOTOS => { + 'pointers' => 140 } }, {#State 121 - DEFAULT => -26 + ACTIONS => { + "{" => 142 + }, + DEFAULT => -65, + GOTOS => { + 'struct_body' => 141, + 'opt_struct_body' => 143 + } }, {#State 122 - DEFAULT => -21 + ACTIONS => { + "{" => 144 + }, + DEFAULT => -48, + GOTOS => { + 'opt_enum_body' => 146, + 'enum_body' => 145 + } }, {#State 123 - DEFAULT => -22 + ACTIONS => { + "{" => 148 + }, + DEFAULT => -56, + GOTOS => { + 'bitmap_body' => 149, + 'opt_bitmap_body' => 147 + } }, {#State 124 - DEFAULT => -23 + ACTIONS => { + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 + }, + DEFAULT => -97 }, {#State 125 + DEFAULT => -12 + }, + {#State 126 ACTIONS => { - 'IDENTIFIER' => 9 + 'IDENTIFIER' => 11 }, GOTOS => { - 'identifier' => 144 + 'identifier' => 150 } }, - {#State 126 - DEFAULT => -24 - }, {#State 127 - DEFAULT => -25 + DEFAULT => -77 }, {#State 128 - ACTIONS => { - 'IDENTIFIER' => 9, - "*" => 146 - }, + DEFAULT => -72, GOTOS => { - 'identifier' => 145 + 'union_elements' => 151 } }, {#State 129 - DEFAULT => -60 + DEFAULT => -76 }, {#State 130 - DEFAULT => -75, - GOTOS => { - 'element_list1' => 147 - } + DEFAULT => -13 }, {#State 131 - DEFAULT => -61 + DEFAULT => -42 }, {#State 132 ACTIONS => { - 'IDENTIFIER' => 9 - }, - GOTOS => { - 'identifier' => 148, - 'enum_element' => 149, - 'enum_elements' => 150 + "(" => 152 } }, {#State 133 - DEFAULT => -43 + DEFAULT => -32 }, {#State 134 - DEFAULT => -44 + DEFAULT => -27 }, {#State 135 - DEFAULT => -52 + DEFAULT => -28 }, {#State 136 + DEFAULT => -29 + }, + {#State 137 ACTIONS => { - 'IDENTIFIER' => 9 + 'IDENTIFIER' => 11 }, - DEFAULT => -55, GOTOS => { - 'identifier' => 153, - 'bitmap_element' => 152, - 'bitmap_elements' => 151, - 'opt_bitmap_elements' => 154 + 'identifier' => 153 } }, - {#State 137 - DEFAULT => -51 - }, {#State 138 + DEFAULT => -30 + }, + {#State 139 + DEFAULT => -31 + }, + {#State 140 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 + 'IDENTIFIER' => 11, + "*" => 155 }, - DEFAULT => -112 + GOTOS => { + 'identifier' => 154 + } }, - {#State 139 + {#State 141 + DEFAULT => -66 + }, + {#State 142 + DEFAULT => -81, + GOTOS => { + 'element_list1' => 156 + } + }, + {#State 143 + DEFAULT => -67 + }, + {#State 144 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 + 'IDENTIFIER' => 11 }, - DEFAULT => -93 + GOTOS => { + 'identifier' => 157, + 'enum_element' => 158, + 'enum_elements' => 159 + } }, - {#State 140 + {#State 145 + DEFAULT => -49 + }, + {#State 146 + DEFAULT => -50 + }, + {#State 147 + DEFAULT => -58 + }, + {#State 148 ACTIONS => { - ":" => 34, - "<" => 37, - "~" => 38, - "?" => 36, - "{" => 40, - "=" => 43 + 'IDENTIFIER' => 11 }, - DEFAULT => -111 + DEFAULT => -61, + GOTOS => { + 'identifier' => 162, + 'bitmap_element' => 161, + 'bitmap_elements' => 160, + 'opt_bitmap_elements' => 163 + } }, - {#State 141 + {#State 149 + DEFAULT => -57 + }, + {#State 150 ACTIONS => { - "[" => 155 + "[" => 164 }, - DEFAULT => -81, + DEFAULT => -87, GOTOS => { - 'array_len' => 156 + 'array_len' => 165 } }, - {#State 142 + {#State 151 ACTIONS => { - "}" => 157 + "}" => 166 }, - DEFAULT => -84, + DEFAULT => -90, GOTOS => { - 'optional_base_element' => 159, - 'property_list' => 158 + 'optional_base_element' => 168, + 'property_list' => 167 } }, - {#State 143 + {#State 152 ACTIONS => { - "," => -77, - "void" => 163, - ")" => -77 + "," => -83, + "void" => 172, + ")" => -83 }, - DEFAULT => -84, + DEFAULT => -90, GOTOS => { - 'base_element' => 160, - 'element_list2' => 162, - 'property_list' => 161 + 'base_element' => 169, + 'element_list2' => 171, + 'property_list' => 170 } }, - {#State 144 + {#State 153 ACTIONS => { - ";" => 164 + ";" => 173 } }, - {#State 145 + {#State 154 ACTIONS => { - "[" => 155, - "=" => 166 + "[" => 164, + "=" => 175 }, GOTOS => { - 'array_len' => 165 + 'array_len' => 174 } }, - {#State 146 - DEFAULT => -74 + {#State 155 + DEFAULT => -80 }, - {#State 147 + {#State 156 ACTIONS => { - "}" => 167 + "}" => 176 }, - DEFAULT => -84, + DEFAULT => -90, GOTOS => { - 'base_element' => 168, - 'property_list' => 161 + 'base_element' => 177, + 'property_list' => 170 } }, - {#State 148 + {#State 157 ACTIONS => { - "=" => 169 + "=" => 178 }, - DEFAULT => -47 + DEFAULT => -53 }, - {#State 149 - DEFAULT => -45 + {#State 158 + DEFAULT => -51 }, - {#State 150 + {#State 159 ACTIONS => { - "}" => 170, - "," => 171 + "}" => 179, + "," => 180 } }, - {#State 151 + {#State 160 ACTIONS => { - "," => 172 + "," => 181 }, - DEFAULT => -56 + DEFAULT => -62 }, - {#State 152 - DEFAULT => -53 + {#State 161 + DEFAULT => -59 }, - {#State 153 + {#State 162 ACTIONS => { - "=" => 173 + "=" => 182 } }, - {#State 154 + {#State 163 ACTIONS => { - "}" => 174 + "}" => 183 } }, - {#State 155 + {#State 164 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - "]" => 175, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + "]" => 184, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 176, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'anytext' => 185, + 'text' => 18, + 'constant' => 13 } }, - {#State 156 + {#State 165 ACTIONS => { - ";" => 177 + ";" => 186 } }, - {#State 157 - DEFAULT => -68 + {#State 166 + DEFAULT => -74 }, - {#State 158 + {#State 167 ACTIONS => { - "[" => 7 + "[" => 21 }, - DEFAULT => -84, + DEFAULT => -90, GOTOS => { - 'base_or_empty' => 178, - 'base_element' => 179, - 'empty_element' => 180, - 'property_list' => 181 + 'base_or_empty' => 187, + 'base_element' => 188, + 'empty_element' => 189, + 'property_list' => 190 } }, - {#State 159 - DEFAULT => -67 + {#State 168 + DEFAULT => -73 }, - {#State 160 - DEFAULT => -79 + {#State 169 + DEFAULT => -85 }, - {#State 161 + {#State 170 ACTIONS => { - 'IDENTIFIER' => 9, - "signed" => 102, - "union" => 52, - "enum" => 65, - "bitmap" => 66, - 'void' => 97, - "unsigned" => 103, - "[" => 7, - "struct" => 63 - }, - DEFAULT => -35, - GOTOS => { - 'existingtype' => 101, - 'bitmap' => 67, - 'usertype' => 98, - 'identifier' => 99, - 'struct' => 59, - 'enum' => 61, - 'type' => 182, - 'union' => 70, - 'sign' => 100 + 'IDENTIFIER' => 11, + "signed" => 116, + "union" => 81, + "enum" => 94, + "bitmap" => 95, + 'void' => 111, + "unsigned" => 117, + "[" => 21, + "struct" => 92 + }, + DEFAULT => -41, + GOTOS => { + 'existingtype' => 115, + 'bitmap' => 96, + 'usertype' => 112, + 'identifier' => 113, + 'struct' => 88, + 'enum' => 90, + 'type' => 191, + 'union' => 99, + 'sign' => 114 } }, - {#State 162 + {#State 171 ACTIONS => { - "," => 183, - ")" => 184 + "," => 192, + ")" => 193 } }, - {#State 163 - DEFAULT => -78 + {#State 172 + DEFAULT => -84 }, - {#State 164 - DEFAULT => -20 + {#State 173 + DEFAULT => -26 }, - {#State 165 + {#State 174 ACTIONS => { - "=" => 185 + "=" => 194 } }, - {#State 166 + {#State 175 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 186, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'anytext' => 195, + 'text' => 18, + 'constant' => 13 } }, - {#State 167 - DEFAULT => -58 + {#State 176 + DEFAULT => -64 }, - {#State 168 + {#State 177 ACTIONS => { - ";" => 187 + ";" => 196 } }, - {#State 169 + {#State 178 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 188, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'anytext' => 197, + 'text' => 18, + 'constant' => 13 } }, - {#State 170 - DEFAULT => -41 + {#State 179 + DEFAULT => -47 }, - {#State 171 + {#State 180 ACTIONS => { - 'IDENTIFIER' => 9 + 'IDENTIFIER' => 11 }, GOTOS => { - 'identifier' => 148, - 'enum_element' => 189 + 'identifier' => 157, + 'enum_element' => 198 } }, - {#State 172 + {#State 181 ACTIONS => { - 'IDENTIFIER' => 9 + 'IDENTIFIER' => 11 }, GOTOS => { - 'identifier' => 153, - 'bitmap_element' => 190 + 'identifier' => 162, + 'bitmap_element' => 199 } }, - {#State 173 + {#State 182 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 191, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'anytext' => 200, + 'text' => 18, + 'constant' => 13 } }, - {#State 174 - DEFAULT => -49 + {#State 183 + DEFAULT => -55 }, - {#State 175 + {#State 184 ACTIONS => { - "[" => 155 + "[" => 164 }, - DEFAULT => -81, + DEFAULT => -87, GOTOS => { - 'array_len' => 192 + 'array_len' => 201 } }, - {#State 176 + {#State 185 ACTIONS => { - "-" => 35, - ":" => 34, - "?" => 36, - "<" => 37, - "+" => 39, - "~" => 38, - "&" => 41, - "{" => 40, - "/" => 42, - "=" => 43, - "|" => 45, - "(" => 44, - "*" => 46, - "." => 47, - "]" => 193, - ">" => 48 + "-" => 24, + ":" => 23, + "?" => 25, + "<" => 26, + "+" => 28, + "~" => 27, + "&" => 30, + "{" => 29, + "/" => 31, + "=" => 32, + "|" => 34, + "(" => 33, + "*" => 35, + "." => 36, + "]" => 202, + ">" => 37 } }, - {#State 177 - DEFAULT => -27 + {#State 186 + DEFAULT => -33 }, - {#State 178 - DEFAULT => -65 + {#State 187 + DEFAULT => -71 }, - {#State 179 + {#State 188 ACTIONS => { - ";" => 194 + ";" => 203 } }, - {#State 180 - DEFAULT => -64 + {#State 189 + DEFAULT => -70 }, - {#State 181 + {#State 190 ACTIONS => { - 'IDENTIFIER' => 9, - "signed" => 102, - "union" => 52, - ";" => 195, - "enum" => 65, - "bitmap" => 66, - 'void' => 97, - "unsigned" => 103, - "[" => 7, - "struct" => 63 - }, - DEFAULT => -35, - GOTOS => { - 'existingtype' => 101, - 'bitmap' => 67, - 'usertype' => 98, - 'identifier' => 99, - 'struct' => 59, - 'enum' => 61, - 'type' => 182, - 'union' => 70, - 'sign' => 100 + 'IDENTIFIER' => 11, + "signed" => 116, + "union" => 81, + ";" => 204, + "enum" => 94, + "bitmap" => 95, + 'void' => 111, + "unsigned" => 117, + "[" => 21, + "struct" => 92 + }, + DEFAULT => -41, + GOTOS => { + 'existingtype' => 115, + 'bitmap' => 96, + 'usertype' => 112, + 'identifier' => 113, + 'struct' => 88, + 'enum' => 90, + 'type' => 191, + 'union' => 99, + 'sign' => 114 } }, - {#State 182 - DEFAULT => -73, + {#State 191 + DEFAULT => -79, GOTOS => { - 'pointers' => 196 + 'pointers' => 205 } }, - {#State 183 - DEFAULT => -84, + {#State 192 + DEFAULT => -90, GOTOS => { - 'base_element' => 197, - 'property_list' => 161 + 'base_element' => 206, + 'property_list' => 170 } }, - {#State 184 + {#State 193 ACTIONS => { - ";" => 198 + ";" => 207 } }, - {#State 185 + {#State 194 ACTIONS => { - 'CONSTANT' => 28, - 'TEXT' => 22, - 'IDENTIFIER' => 9 + 'CONSTANT' => 14, + 'TEXT' => 16, + 'IDENTIFIER' => 11 }, - DEFAULT => -94, + DEFAULT => -100, GOTOS => { - 'identifier' => 23, - 'anytext' => 199, - 'text' => 24, - 'constant' => 27 + 'identifier' => 17, + 'anytext' => 208, + 'text' => 18, + 'constant' => 13 } }, - {#State 186 + {#State 195 ACTIONS => { - "-" => 35, - ":" => 34, - "?" => 36, - "<" => 37, - ";" => 200, - "+" => 39, - "~" => 38, - "&" => 41, - "{" => 40, - "/" => 42, - "=" => 43, - "|" => 45, - "(" => 44, - "*" => 46, - "." => 47, - ">" => 48 + "-" => 24, + ":" => 23, + "?" => 25, + "<" => 26, + ";" => 209, + "+" => 28, + "~" => 27, + "&" => 30, + "{" => 29, + "/" => 31, + "=" => 32, + "|" => 34, + "(" => 33, + "*" => 35, + "." => 36, + ">" => 37 } }, - {#State 187 - DEFAULT => -76 + {#State 196 + DEFAULT => -82 }, - {#State 188 + {#State 197 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 - }, - DEFAULT => -48 + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 + }, + DEFAULT => -54 }, - {#State 189 - DEFAULT => -46 + {#State 198 + DEFAULT => -52 }, - {#State 190 - DEFAULT => -54 + {#State 199 + DEFAULT => -60 }, - {#State 191 + {#State 200 ACTIONS => { - "-" => 35, - ":" => 34, - "<" => 37, - "+" => 39, - "~" => 38, - "*" => 46, - "?" => 36, - "{" => 40, - "&" => 41, - "/" => 42, - "=" => 43, - "(" => 44, - "|" => 45, - "." => 47, - ">" => 48 + "-" => 24, + ":" => 23, + "<" => 26, + "+" => 28, + "~" => 27, + "*" => 35, + "?" => 25, + "{" => 29, + "&" => 30, + "/" => 31, + "=" => 32, + "(" => 33, + "|" => 34, + "." => 36, + ">" => 37 }, - DEFAULT => -57 + DEFAULT => -63 }, - {#State 192 - DEFAULT => -82 + {#State 201 + DEFAULT => -88 }, - {#State 193 + {#State 202 ACTIONS => { - "[" => 155 + "[" => 164 }, - DEFAULT => -81, + DEFAULT => -87, GOTOS => { - 'array_len' => 201 + 'array_len' => 210 } }, - {#State 194 - DEFAULT => -63 + {#State 203 + DEFAULT => -69 }, - {#State 195 - DEFAULT => -62 + {#State 204 + DEFAULT => -68 }, - {#State 196 + {#State 205 ACTIONS => { - 'IDENTIFIER' => 9, - "*" => 146 + 'IDENTIFIER' => 11, + "*" => 155 }, GOTOS => { - 'identifier' => 202 + 'identifier' => 211 } }, - {#State 197 - DEFAULT => -80 - }, - {#State 198 - DEFAULT => -19 + {#State 206 + DEFAULT => -86 }, - {#State 199 - ACTIONS => { - "-" => 35, - ":" => 34, - "?" => 36, - "<" => 37, - ";" => 203, - "+" => 39, - "~" => 38, - "&" => 41, - "{" => 40, - "/" => 42, - "=" => 43, - "|" => 45, - "(" => 44, - "*" => 46, - "." => 47, - ">" => 48 - } + {#State 207 + DEFAULT => -25 }, - {#State 200 - DEFAULT => -17 + {#State 208 + ACTIONS => { + "-" => 24, + ":" => 23, + "?" => 25, + "<" => 26, + ";" => 212, + "+" => 28, + "~" => 27, + "&" => 30, + "{" => 29, + "/" => 31, + "=" => 32, + "|" => 34, + "(" => 33, + "*" => 35, + "." => 36, + ">" => 37 + } + }, + {#State 209 + DEFAULT => -23 }, - {#State 201 - DEFAULT => -83 + {#State 210 + DEFAULT => -89 }, - {#State 202 + {#State 211 ACTIONS => { - "[" => 155 + "[" => 164 }, - DEFAULT => -81, + DEFAULT => -87, GOTOS => { - 'array_len' => 204 + 'array_len' => 213 } }, - {#State 203 - DEFAULT => -18 + {#State 212 + DEFAULT => -24 }, - {#State 204 - DEFAULT => -72 + {#State 213 + DEFAULT => -78 } ], yyrules => @@ -2205,20 +2267,71 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "idl.yp" +#line 19 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "idl.yp" +#line 20 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 + 'idl', 2, +sub +#line 21 "pidl/idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 5 + 'idl', 2, +sub +#line 22 "pidl/idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 6 + 'idl', 2, +sub +#line 23 "pidl/idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 7 + 'import', 3, +sub +#line 26 "pidl/idl.yp" +{{ + "TYPE" => "IMPORT", + "PATHS" => [ $_[2] ], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE} + }} + ], + [#Rule 8 + 'include', 3, +sub +#line 33 "pidl/idl.yp" +{{ + "TYPE" => "INCLUDE", + "PATHS" => [ $_[2] ], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE} + }} + ], + [#Rule 9 + 'importlib', 3, +sub +#line 40 "pidl/idl.yp" +{{ + "TYPE" => "IMPORTLIB", + "PATHS" => [ $_[2] ], + "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "LINE" => $_[0]->YYData->{LINE} + }} + ], + [#Rule 10 'coclass', 7, sub -#line 24 "idl.yp" -{$_[3] => { +#line 49 "pidl/idl.yp" +{{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], "NAME" => $_[3], @@ -2227,20 +2340,20 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 5 + [#Rule 11 'interface_names', 0, undef ], - [#Rule 6 + [#Rule 12 'interface_names', 4, sub -#line 36 "idl.yp" +#line 61 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 7 + [#Rule 13 'interface', 8, sub -#line 40 "idl.yp" -{$_[3] => { +#line 65 "pidl/idl.yp" +{{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], "NAME" => $_[3], @@ -2250,46 +2363,46 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 8 + [#Rule 14 'base_interface', 0, undef ], - [#Rule 9 + [#Rule 15 'base_interface', 2, sub -#line 53 "idl.yp" +#line 78 "pidl/idl.yp" { $_[2] } ], - [#Rule 10 + [#Rule 16 'definitions', 1, sub -#line 57 "idl.yp" +#line 82 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 11 + [#Rule 17 'definitions', 2, sub -#line 58 "idl.yp" +#line 83 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 12 + [#Rule 18 'definition', 1, undef ], - [#Rule 13 + [#Rule 19 'definition', 1, undef ], - [#Rule 14 + [#Rule 20 'definition', 1, undef ], - [#Rule 15 + [#Rule 21 'definition', 1, undef ], - [#Rule 16 + [#Rule 22 'definition', 1, undef ], - [#Rule 17 + [#Rule 23 'const', 7, sub -#line 66 "idl.yp" +#line 91 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2300,10 +2413,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 18 + [#Rule 24 'const', 8, sub -#line 76 "idl.yp" +#line 101 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2315,10 +2428,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 19 + [#Rule 25 'function', 7, sub -#line 90 "idl.yp" +#line 115 "pidl/idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2329,10 +2442,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 20 + [#Rule 26 'declare', 5, sub -#line 102 "idl.yp" +#line 127 "pidl/idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2342,43 +2455,43 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 21 + [#Rule 27 'decl_type', 1, undef ], - [#Rule 22 + [#Rule 28 'decl_type', 1, undef ], - [#Rule 23 + [#Rule 29 'decl_type', 1, undef ], - [#Rule 24 + [#Rule 30 'decl_enum', 1, sub -#line 116 "idl.yp" +#line 141 "pidl/idl.yp" {{ "TYPE" => "ENUM" }} ], - [#Rule 25 + [#Rule 31 'decl_bitmap', 1, sub -#line 122 "idl.yp" +#line 147 "pidl/idl.yp" {{ "TYPE" => "BITMAP" }} ], - [#Rule 26 + [#Rule 32 'decl_union', 1, sub -#line 128 "idl.yp" +#line 153 "pidl/idl.yp" {{ "TYPE" => "UNION" }} ], - [#Rule 27 + [#Rule 33 'typedef', 6, sub -#line 134 "idl.yp" +#line 159 "pidl/idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], @@ -2389,169 +2502,169 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 28 + [#Rule 34 'usertype', 1, undef ], - [#Rule 29 + [#Rule 35 'usertype', 1, undef ], - [#Rule 30 + [#Rule 36 'usertype', 1, undef ], - [#Rule 31 + [#Rule 37 'usertype', 1, undef ], - [#Rule 32 + [#Rule 38 'typedecl', 2, sub -#line 147 "idl.yp" +#line 172 "pidl/idl.yp" { $_[1] } ], - [#Rule 33 + [#Rule 39 'sign', 1, undef ], - [#Rule 34 + [#Rule 40 'sign', 1, undef ], - [#Rule 35 + [#Rule 41 'existingtype', 0, undef ], - [#Rule 36 + [#Rule 42 'existingtype', 2, sub -#line 152 "idl.yp" +#line 177 "pidl/idl.yp" { "$_[1] $_[2]" } ], - [#Rule 37 + [#Rule 43 'existingtype', 1, undef ], - [#Rule 38 + [#Rule 44 'type', 1, undef ], - [#Rule 39 + [#Rule 45 'type', 1, undef ], - [#Rule 40 + [#Rule 46 'type', 1, sub -#line 156 "idl.yp" +#line 181 "pidl/idl.yp" { "void" } ], - [#Rule 41 + [#Rule 47 'enum_body', 3, sub -#line 158 "idl.yp" +#line 183 "pidl/idl.yp" { $_[2] } ], - [#Rule 42 + [#Rule 48 'opt_enum_body', 0, undef ], - [#Rule 43 + [#Rule 49 'opt_enum_body', 1, undef ], - [#Rule 44 + [#Rule 50 'enum', 3, sub -#line 161 "idl.yp" +#line 186 "pidl/idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 45 + [#Rule 51 'enum_elements', 1, sub -#line 169 "idl.yp" +#line 194 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 46 + [#Rule 52 'enum_elements', 3, sub -#line 170 "idl.yp" +#line 195 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 47 + [#Rule 53 'enum_element', 1, undef ], - [#Rule 48 + [#Rule 54 'enum_element', 3, sub -#line 174 "idl.yp" +#line 199 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 49 + [#Rule 55 'bitmap_body', 3, sub -#line 177 "idl.yp" +#line 202 "pidl/idl.yp" { $_[2] } ], - [#Rule 50 + [#Rule 56 'opt_bitmap_body', 0, undef ], - [#Rule 51 + [#Rule 57 'opt_bitmap_body', 1, undef ], - [#Rule 52 + [#Rule 58 'bitmap', 3, sub -#line 180 "idl.yp" +#line 205 "pidl/idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 53 + [#Rule 59 'bitmap_elements', 1, sub -#line 188 "idl.yp" +#line 213 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 54 + [#Rule 60 'bitmap_elements', 3, sub -#line 189 "idl.yp" +#line 214 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 55 + [#Rule 61 'opt_bitmap_elements', 0, undef ], - [#Rule 56 + [#Rule 62 'opt_bitmap_elements', 1, undef ], - [#Rule 57 + [#Rule 63 'bitmap_element', 3, sub -#line 194 "idl.yp" +#line 219 "pidl/idl.yp" { "$_[1] ( $_[3] )" } ], - [#Rule 58 + [#Rule 64 'struct_body', 3, sub -#line 197 "idl.yp" +#line 222 "pidl/idl.yp" { $_[2] } ], - [#Rule 59 + [#Rule 65 'opt_struct_body', 0, undef ], - [#Rule 60 + [#Rule 66 'opt_struct_body', 1, undef ], - [#Rule 61 + [#Rule 67 'struct', 3, sub -#line 201 "idl.yp" +#line 226 "pidl/idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 62 + [#Rule 68 'empty_element', 2, sub -#line 209 "idl.yp" +#line 234 "pidl/idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2562,53 +2675,53 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 63 + [#Rule 69 'base_or_empty', 2, undef ], - [#Rule 64 + [#Rule 70 'base_or_empty', 1, undef ], - [#Rule 65 + [#Rule 71 'optional_base_element', 2, sub -#line 223 "idl.yp" +#line 248 "pidl/idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], - [#Rule 66 + [#Rule 72 'union_elements', 0, undef ], - [#Rule 67 + [#Rule 73 'union_elements', 2, sub -#line 228 "idl.yp" +#line 253 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 68 + [#Rule 74 'union_body', 3, sub -#line 231 "idl.yp" +#line 256 "pidl/idl.yp" { $_[2] } ], - [#Rule 69 + [#Rule 75 'opt_union_body', 0, undef ], - [#Rule 70 + [#Rule 76 'opt_union_body', 1, undef ], - [#Rule 71 + [#Rule 77 'union', 3, sub -#line 235 "idl.yp" +#line 260 "pidl/idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 72 + [#Rule 78 'base_element', 5, sub -#line 243 "idl.yp" +#line 268 "pidl/idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2619,238 +2732,238 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 73 + [#Rule 79 'pointers', 0, sub -#line 257 "idl.yp" +#line 282 "pidl/idl.yp" { 0 } ], - [#Rule 74 + [#Rule 80 'pointers', 2, sub -#line 258 "idl.yp" +#line 283 "pidl/idl.yp" { $_[1]+1 } ], - [#Rule 75 + [#Rule 81 'element_list1', 0, undef ], - [#Rule 76 + [#Rule 82 'element_list1', 3, sub -#line 263 "idl.yp" +#line 288 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 77 + [#Rule 83 'element_list2', 0, undef ], - [#Rule 78 + [#Rule 84 'element_list2', 1, undef ], - [#Rule 79 + [#Rule 85 'element_list2', 1, sub -#line 269 "idl.yp" +#line 294 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 80 + [#Rule 86 'element_list2', 3, sub -#line 270 "idl.yp" +#line 295 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 81 + [#Rule 87 'array_len', 0, undef ], - [#Rule 82 + [#Rule 88 'array_len', 3, sub -#line 275 "idl.yp" +#line 300 "pidl/idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], - [#Rule 83 + [#Rule 89 'array_len', 4, sub -#line 276 "idl.yp" +#line 301 "pidl/idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], - [#Rule 84 + [#Rule 90 'property_list', 0, undef ], - [#Rule 85 + [#Rule 91 'property_list', 4, sub -#line 282 "idl.yp" +#line 307 "pidl/idl.yp" { FlattenHash([$_[1],$_[3]]); } ], - [#Rule 86 + [#Rule 92 'properties', 1, sub -#line 285 "idl.yp" +#line 310 "pidl/idl.yp" { $_[1] } ], - [#Rule 87 + [#Rule 93 'properties', 3, sub -#line 286 "idl.yp" +#line 311 "pidl/idl.yp" { FlattenHash([$_[1], $_[3]]); } ], - [#Rule 88 + [#Rule 94 'property', 1, sub -#line 289 "idl.yp" +#line 314 "pidl/idl.yp" {{ "$_[1]" => "1" }} ], - [#Rule 89 + [#Rule 95 'property', 4, sub -#line 290 "idl.yp" +#line 315 "pidl/idl.yp" {{ "$_[1]" => "$_[3]" }} ], - [#Rule 90 + [#Rule 96 'listtext', 1, undef ], - [#Rule 91 + [#Rule 97 'listtext', 3, sub -#line 295 "idl.yp" +#line 320 "pidl/idl.yp" { "$_[1] $_[3]" } ], - [#Rule 92 + [#Rule 98 'commalisttext', 1, undef ], - [#Rule 93 + [#Rule 99 'commalisttext', 3, sub -#line 300 "idl.yp" +#line 325 "pidl/idl.yp" { "$_[1],$_[3]" } ], - [#Rule 94 + [#Rule 100 'anytext', 0, sub -#line 304 "idl.yp" +#line 329 "pidl/idl.yp" { "" } ], - [#Rule 95 + [#Rule 101 'anytext', 1, undef ], - [#Rule 96 + [#Rule 102 'anytext', 1, undef ], - [#Rule 97 + [#Rule 103 'anytext', 1, undef ], - [#Rule 98 + [#Rule 104 'anytext', 3, sub -#line 306 "idl.yp" +#line 331 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 99 + [#Rule 105 'anytext', 3, sub -#line 307 "idl.yp" +#line 332 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 100 + [#Rule 106 'anytext', 3, sub -#line 308 "idl.yp" +#line 333 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 101 + [#Rule 107 'anytext', 3, sub -#line 309 "idl.yp" +#line 334 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 102 + [#Rule 108 'anytext', 3, sub -#line 310 "idl.yp" +#line 335 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 103 + [#Rule 109 'anytext', 3, sub -#line 311 "idl.yp" +#line 336 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 104 + [#Rule 110 'anytext', 3, sub -#line 312 "idl.yp" +#line 337 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 105 + [#Rule 111 'anytext', 3, sub -#line 313 "idl.yp" +#line 338 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 106 + [#Rule 112 'anytext', 3, sub -#line 314 "idl.yp" +#line 339 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 107 + [#Rule 113 'anytext', 3, sub -#line 315 "idl.yp" +#line 340 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 108 + [#Rule 114 'anytext', 3, sub -#line 316 "idl.yp" +#line 341 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 109 + [#Rule 115 'anytext', 3, sub -#line 317 "idl.yp" +#line 342 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 110 + [#Rule 116 'anytext', 3, sub -#line 318 "idl.yp" +#line 343 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 111 + [#Rule 117 'anytext', 5, sub -#line 319 "idl.yp" +#line 344 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 112 + [#Rule 118 'anytext', 5, sub -#line 320 "idl.yp" +#line 345 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 113 + [#Rule 119 'identifier', 1, undef ], - [#Rule 114 + [#Rule 120 'optional_identifier', 1, undef ], - [#Rule 115 + [#Rule 121 'optional_identifier', 0, undef ], - [#Rule 116 + [#Rule 122 'constant', 1, undef ], - [#Rule 117 + [#Rule 123 'text', 1, sub -#line 334 "idl.yp" +#line 359 "pidl/idl.yp" { "\"$_[1]\"" } ], - [#Rule 118 + [#Rule 124 'optional_semicolon', 0, undef ], - [#Rule 119 + [#Rule 125 'optional_semicolon', 1, undef ] ], @@ -2858,7 +2971,7 @@ sub bless($self,$class); } -#line 345 "idl.yp" +#line 370 "pidl/idl.yp" ##################################################################### @@ -2959,7 +3072,8 @@ again: $parser->YYData->{LAST_TOKEN} = $1; if ($1 =~ /^(coclass|interface|const|typedef|declare|union - |struct|enum|bitmap|void|unsigned|signed)$/x) { + |struct|enum|bitmap|void|unsigned|signed|import|include + |importlib)$/x) { return $1; } return('IDENTIFIER',$1); diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 6a3698a920..86bd62044b 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -661,6 +661,7 @@ sub Parse($) foreach (@{$idl}) { ($_->{TYPE} eq "INTERFACE") && push(@ndr, ParseInterface($_)); + ($_->{TYPE} eq "IMPORT") && push(@ndr, $_); } return \@ndr; @@ -1044,6 +1045,14 @@ sub ValidInterface($) my($interface) = shift; my($data) = $interface->{DATA}; + if (has_property($interface, "depends")) { + nonfatal $interface, "depends() is pidl-specific and deprecated. Use `import' instead"; + } + + if (has_property($interface, "helper")) { + nonfatal $interface, "helper() is pidl-specific and deprecated. Use `include' instead"; + } + ValidProperties($interface,"INTERFACE"); if (has_property($interface, "pointer_default") && @@ -1081,6 +1090,8 @@ sub Validate($) foreach my $x (@{$idl}) { ($x->{TYPE} eq "INTERFACE") && ValidInterface($x); + ($x->{TYPE} eq "IMPORTLIB") && + nonfatal($x, "importlib() not supported"); } } diff --git a/source4/pidl/lib/Parse/Pidl/ODL.pm b/source4/pidl/lib/Parse/Pidl/ODL.pm index c8d1de3d43..ee8d030a37 100644 --- a/source4/pidl/lib/Parse/Pidl/ODL.pm +++ b/source4/pidl/lib/Parse/Pidl/ODL.pm @@ -18,6 +18,7 @@ sub get_interface($$) my($if,$n) = @_; foreach(@$if) { + next if ($_->{TYPE} ne "INTERFACE"); return $_ if($_->{NAME} eq $n); } @@ -62,8 +63,10 @@ sub ReplaceInterfacePointers($) sub ODL2IDL($) { my $odl = shift; - - foreach my $x (@{$odl}) { + my $addedorpc = 0; + + foreach my $x (@$odl) { + next if ($x->{TYPE} ne "INTERFACE"); # Add [in] ORPCTHIS *this, [out] ORPCTHAT *that # and replace interfacepointers with MInterfacePointer # for 'object' interfaces @@ -72,13 +75,7 @@ sub ODL2IDL($) ($e->{TYPE} eq "FUNCTION") && FunctionAddObjArgs($e); ReplaceInterfacePointers($e); } - # Object interfaces use ORPC - my @depends = (); - if(has_property($x, "depends")) { - @depends = split /,/, $x->{PROPERTIES}->{depends}; - } - push @depends, "orpc"; - $x->{PROPERTIES}->{depends} = join(',',@depends); + $addedorpc = 1; } if ($x->{BASE}) { @@ -92,6 +89,13 @@ sub ODL2IDL($) } } + unshift (@$odl, { + TYPE => "IMPORT", + PATHS => [ "\"orpc.idl\"" ], + FILE => undef, + LINE => undef + }) if ($addedorpc); + return $odl; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 218b882323..bb3b36dca4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -730,6 +730,16 @@ sub EjsConst($) $constants{$const->{NAME}} = $const->{VALUE}; } +sub EjsImport +{ + my @imports = @_; + foreach (@imports) { + s/\.idl\"$//; + s/^\"//; + pidl_hdr "#include \"librpc/gen_ndr/ndr_$_\_ejs\.h\"\n"; + } +} + ##################################################################### # parse the interface definitions sub EjsInterface($$) @@ -744,9 +754,7 @@ sub EjsInterface($$) pidl_hdr "#define _HEADER_EJS_$interface->{NAME}\n\n"; if (has_property($interface, "depends")) { - foreach (split / /, $interface->{PROPERTIES}->{depends}) { - pidl_hdr "#include \"librpc/gen_ndr/ndr_$_\_ejs\.h\"\n"; - } + EjsImport(split / /, $interface->{PROPERTIES}->{depends}); } pidl_hdr "\n"; @@ -834,8 +842,9 @@ sub Parse($$) ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed); } - foreach my $x (@{$ndr}) { + foreach my $x (@$ndr) { ($x->{TYPE} eq "INTERFACE") && EjsInterface($x, \%needed); + ($x->{TYPE} eq "IMPORT") && EjsImport(@{$x->{PATHS}}); } return ($res_hdr, $res); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 6fb3ee2eec..94346efe4b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -307,6 +307,24 @@ sub HeaderFunction($) pidl "};\n\n"; } +sub HeaderImport +{ + my @imports = @_; + foreach (@imports) { + s/\.idl\"$//; + s/^\"//; + pidl "#include \"librpc/gen_ndr/$_\.h\"\n"; + } +} + +sub HeaderInclude +{ + my @includes = @_; + foreach (@includes) { + pidl "#include \"$_\"\n"; + } +} + ##################################################################### # parse the interface definitions sub HeaderInterface($) @@ -317,10 +335,7 @@ sub HeaderInterface($) pidl "#define _HEADER_$interface->{NAME}\n\n"; if (defined $interface->{PROPERTIES}->{depends}) { - my @d = split / /, $interface->{PROPERTIES}->{depends}; - foreach my $i (@d) { - pidl "#include \"librpc/gen_ndr/$i\.h\"\n"; - } + HeaderImport(split / /, $interface->{PROPERTIES}->{depends}); } foreach my $d (@{$interface->{DATA}}) { @@ -358,6 +373,8 @@ sub Parse($) foreach (@{$idl}) { ($_->{TYPE} eq "INTERFACE") && HeaderInterface($_); + ($_->{TYPE} eq "IMPORT") && HeaderImport(@{$_->{PATHS}}); + ($_->{TYPE} eq "INCLUDE") && HeaderInclude(@{$_->{PATHS}}); } return $res; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 1bb277fd0e..80d02cb533 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2220,6 +2220,28 @@ sub FunctionTable($) } +##################################################################### +# generate include statements for imported idl files +sub HeaderImport +{ + my @imports = @_; + foreach (@imports) { + s/\.idl\"$//; + s/^\"//; + pidl choose_header("librpc/gen_ndr/ndr_$_\.h", "gen_ndr/ndr_$_.h"); + } +} + +##################################################################### +# generate include statements for included header files +sub HeaderInclude +{ + my @includes = @_; + foreach (@includes) { + pidl_hdr "#include $_"; + } +} + ##################################################################### # generate prototypes and defines for the interface definitions # FIXME: these prototypes are for the DCE/RPC client functions, not the @@ -2237,16 +2259,11 @@ sub HeaderInterface($) } if (defined $interface->{PROPERTIES}->{depends}) { - my @d = split / /, $interface->{PROPERTIES}->{depends}; - foreach my $i (@d) { - pidl choose_header("librpc/gen_ndr/ndr_$i\.h", "gen_ndr/ndr_$i.h"); - } + HeaderImport(split / /, $interface->{PROPERTIES}->{depends}); } if (defined $interface->{PROPERTIES}->{helper}) { - foreach (split / /, $interface->{PROPERTIES}->{helper}) { - pidl_hdr "#include $_"; - } + HeaderInclude(split / /, $interface->{PROPERTIES}->{helper}); } if (defined $interface->{PROPERTIES}->{uuid}) { @@ -2390,6 +2407,8 @@ sub Parse($$$) foreach (@{$ndr}) { ($_->{TYPE} eq "INTERFACE") && ParseInterface($_, \%needed); + ($_->{TYPE} eq "IMPORT") && HeaderImport(@{$_->{PATHS}}); + ($_->{TYPE} eq "INCLUDE") && HeaderInclude(@{$_->{PATHS}}); } return ($res_hdr, $res); diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 8c75d590e0..7b8691e044 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -717,6 +717,25 @@ sub RegisterInterfaceHandoff($) } } +sub ProcessInclude +{ + my @includes = @_; + foreach (@includes) { + pidl_hdr "#include \"$_\"\n"; + } +} + +sub ProcessImport +{ + my @imports = @_; + foreach (@imports) { + next if($_ eq "security"); + s/\.idl\"$//; + s/^\"//; + pidl_hdr "#include \"packet-dcerpc-$_\.h\"\n"; + } +} + sub ProcessInterface($) { my ($x) = @_; @@ -728,12 +747,8 @@ sub ProcessInterface($) pidl_hdr "#define $define"; pidl_hdr ""; - if (defined $x->{PROPERTIES}->{depends}) { - foreach (split / /, $x->{PROPERTIES}->{depends}) { - next if($_ eq "security"); - pidl_hdr "#include \"packet-dcerpc-$_\.h\"\n"; - } - } + ProcessImport(split / /, $x->{PROPERTIES}->{depends}) if + (defined $x->{PROPERTIES}->{depends}); pidl_def "static gint proto_dcerpc_$x->{NAME} = -1;"; register_ett("ett_dcerpc_$x->{NAME}"); @@ -897,7 +912,11 @@ sub Parse($$$$) # Wireshark protocol registration - ProcessInterface($_) foreach (@$ndr); + foreach (@$ndr) { + ProcessInterface($_) if ($_->{TYPE} eq "INTERFACE"); + ProcessImport(@{$_->{PATHS}}) if ($_->{TYPE} eq "IMPORT"); + ProcessInclude(@{$_->{PATHS}}) if ($_->{TYPE} eq "INCLUDE"); + } $res{ett} = DumpEttDeclaration(); $res{hf} = DumpHfDeclaration(); -- cgit From 863dcbfa06cfcd4eecba7559c03080321b9a8a91 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 6 Nov 2006 22:54:49 +0000 Subject: r19588: Use include and import statements rather than depends() and helper(). (This used to be commit 347ae9628202ca4de4318ef8156999239aad9192) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 2549 +++++++++++++------------- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 2 +- 2 files changed, 1292 insertions(+), 1259 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index e400862795..d237db7137 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -509,9 +509,10 @@ sub new { ACTIONS => { '' => 2, "importlib" => 3, - "import" => 6 + "import" => 6, + "include" => 11 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { 'importlib' => 9, 'interface' => 8, @@ -526,17 +527,11 @@ sub new { }, {#State 3 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + 'TEXT' => 13 }, - DEFAULT => -100, GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 12, - 'constant' => 13, - 'commalisttext' => 15 + 'commalist' => 12, + 'text' => 14 } }, {#State 4 @@ -544,24 +539,18 @@ sub new { }, {#State 5 ACTIONS => { - "coclass" => 19, - "[" => 21, - "interface" => 20 + "coclass" => 15, + "[" => 17, + "interface" => 16 } }, {#State 6 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + 'TEXT' => 13 }, - DEFAULT => -100, GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 12, - 'constant' => 13, - 'commalisttext' => 22 + 'commalist' => 18, + 'text' => 14 } }, {#State 7 @@ -577,1683 +566,1715 @@ sub new { DEFAULT => -3 }, {#State 11 - DEFAULT => -119 + ACTIONS => { + 'TEXT' => 13 + }, + GOTOS => { + 'commalist' => 19, + 'text' => 14 + } }, {#State 12 ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 - }, - DEFAULT => -98 + ";" => 20, + "," => 21 + } }, {#State 13 - DEFAULT => -102 + DEFAULT => -125 }, {#State 14 - DEFAULT => -122 + DEFAULT => -10 }, {#State 15 ACTIONS => { - ";" => 38, - "," => 39 + 'IDENTIFIER' => 22 + }, + GOTOS => { + 'identifier' => 23 } }, {#State 16 - DEFAULT => -123 + ACTIONS => { + 'IDENTIFIER' => 22 + }, + GOTOS => { + 'identifier' => 24 + } }, {#State 17 - DEFAULT => -101 + ACTIONS => { + 'IDENTIFIER' => 22 + }, + GOTOS => { + 'identifier' => 26, + 'property' => 27, + 'properties' => 25 + } }, {#State 18 - DEFAULT => -103 + ACTIONS => { + ";" => 28, + "," => 21 + } }, {#State 19 ACTIONS => { - 'IDENTIFIER' => 11 - }, - GOTOS => { - 'identifier' => 40 + ";" => 29, + "," => 21 } }, {#State 20 - ACTIONS => { - 'IDENTIFIER' => 11 - }, - GOTOS => { - 'identifier' => 41 - } + DEFAULT => -9 }, {#State 21 ACTIONS => { - 'IDENTIFIER' => 11 + 'TEXT' => 13 }, GOTOS => { - 'identifier' => 43, - 'property' => 44, - 'properties' => 42 + 'text' => 30 } }, {#State 22 - ACTIONS => { - ";" => 45, - "," => 39 - } + DEFAULT => -121 }, {#State 23 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 46, - 'constant' => 13 + "{" => 31 } }, {#State 24 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + ":" => 32 }, - DEFAULT => -100, + DEFAULT => -16, GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 47, - 'constant' => 13 + 'base_interface' => 33 } }, {#State 25 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 48, - 'constant' => 13 + "," => 34, + "]" => 35 } }, {#State 26 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + "(" => 36 }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 49, - 'constant' => 13 - } + DEFAULT => -96 }, {#State 27 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 50, - 'constant' => 13 - } + DEFAULT => -94 }, {#State 28 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 51, - 'constant' => 13 - } + DEFAULT => -7 }, {#State 29 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 12, - 'constant' => 13, - 'commalisttext' => 52 - } + DEFAULT => -8 }, {#State 30 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 53, - 'constant' => 13 - } + DEFAULT => -11 }, {#State 31 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, + DEFAULT => -13, GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 54, - 'constant' => 13 + 'interface_names' => 37 } }, {#State 32 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + 'IDENTIFIER' => 22 }, - DEFAULT => -100, GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 55, - 'constant' => 13 + 'identifier' => 38 } }, {#State 33 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 12, - 'constant' => 13, - 'commalisttext' => 56 + "{" => 39 } }, {#State 34 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + 'IDENTIFIER' => 22 }, - DEFAULT => -100, GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 57, - 'constant' => 13 + 'identifier' => 26, + 'property' => 40 } }, {#State 35 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 58, - 'constant' => 13 - } + DEFAULT => -93 }, {#State 36 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -100, + DEFAULT => -102, GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 59, - 'constant' => 13 + 'identifier' => 45, + 'text' => 46, + 'listtext' => 42, + 'anytext' => 41, + 'constant' => 43 } }, {#State 37 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 60, - 'constant' => 13 + "}" => 47, + "interface" => 48 } }, {#State 38 - DEFAULT => -9 + DEFAULT => -17 }, {#State 39 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 61, - 'constant' => 13 + "typedef" => 49, + "union" => 50, + "enum" => 63, + "bitmap" => 64, + "declare" => 56, + "const" => 58, + "struct" => 61 + }, + DEFAULT => -92, + GOTOS => { + 'typedecl' => 62, + 'function' => 51, + 'bitmap' => 65, + 'definitions' => 52, + 'definition' => 55, + 'property_list' => 54, + 'usertype' => 53, + 'declare' => 67, + 'const' => 66, + 'struct' => 57, + 'enum' => 59, + 'typedef' => 60, + 'union' => 68 } }, {#State 40 - ACTIONS => { - "{" => 62 - } + DEFAULT => -95 }, {#State 41 ACTIONS => { - ":" => 63 + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 }, - DEFAULT => -14, - GOTOS => { - 'base_interface' => 64 - } + DEFAULT => -98 }, {#State 42 ACTIONS => { - "," => 65, - "]" => 66 + "," => 84, + ")" => 85 } }, {#State 43 - ACTIONS => { - "(" => 67 - }, - DEFAULT => -94 + DEFAULT => -104 }, {#State 44 - DEFAULT => -92 + DEFAULT => -124 }, {#State 45 - DEFAULT => -7 + DEFAULT => -103 }, {#State 46 - ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 - }, - DEFAULT => -113 + DEFAULT => -105 }, {#State 47 ACTIONS => { - ":" => 23, - "<" => 26, - "~" => 27, - "?" => 25, - "{" => 29, - "=" => 32 + ";" => 86 }, - DEFAULT => -104 + DEFAULT => -126, + GOTOS => { + 'optional_semicolon' => 87 + } }, {#State 48 ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 + 'IDENTIFIER' => 22 }, - DEFAULT => -112 + GOTOS => { + 'identifier' => 88 + } }, {#State 49 - ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 - }, - DEFAULT => -108 + DEFAULT => -92, + GOTOS => { + 'property_list' => 89 + } }, {#State 50 ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 + 'IDENTIFIER' => 90 }, - DEFAULT => -116 + DEFAULT => -123, + GOTOS => { + 'optional_identifier' => 91 + } }, {#State 51 - ACTIONS => { - ":" => 23, - "<" => 26, - "~" => 27, - "?" => 25, - "{" => 29, - "=" => 32 - }, - DEFAULT => -115 + DEFAULT => -20 }, {#State 52 ACTIONS => { - "}" => 68, - "," => 39 + "}" => 92, + "typedef" => 49, + "union" => 50, + "enum" => 63, + "bitmap" => 64, + "declare" => 56, + "const" => 58, + "struct" => 61 + }, + DEFAULT => -92, + GOTOS => { + 'typedecl' => 62, + 'function' => 51, + 'bitmap' => 65, + 'definition' => 93, + 'property_list' => 54, + 'usertype' => 53, + 'const' => 66, + 'struct' => 57, + 'declare' => 67, + 'enum' => 59, + 'typedef' => 60, + 'union' => 68 } }, {#State 53 ACTIONS => { - ":" => 23, - "<" => 26, - "~" => 27, - "?" => 25, - "{" => 29, - "=" => 32 - }, - DEFAULT => -110 + ";" => 94 + } }, {#State 54 ACTIONS => { - ":" => 23, - "<" => 26, - "~" => 27, - "?" => 25, - "{" => 29, - "=" => 32 + 'IDENTIFIER' => 22, + "signed" => 100, + "union" => 50, + "enum" => 63, + "bitmap" => 64, + 'void' => 95, + "unsigned" => 101, + "[" => 17, + "struct" => 61 }, - DEFAULT => -111 + GOTOS => { + 'existingtype' => 99, + 'bitmap' => 65, + 'usertype' => 96, + 'identifier' => 97, + 'struct' => 57, + 'enum' => 59, + 'type' => 102, + 'union' => 68, + 'sign' => 98 + } }, {#State 55 - ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 - }, - DEFAULT => -114 + DEFAULT => -18 }, {#State 56 - ACTIONS => { - "," => 39, - ")" => 69 + DEFAULT => -92, + GOTOS => { + 'property_list' => 103 } }, {#State 57 - ACTIONS => { - ":" => 23, - "<" => 26, - "~" => 27, - "?" => 25, - "{" => 29, - "=" => 32 - }, - DEFAULT => -109 + DEFAULT => -36 }, {#State 58 ACTIONS => { - ":" => 23, - "<" => 26, - "~" => 27, - "?" => 25, - "{" => 29, - "=" => 32 + 'IDENTIFIER' => 22 }, - DEFAULT => -106 + GOTOS => { + 'identifier' => 104 + } }, {#State 59 - ACTIONS => { - ":" => 23, - "<" => 26, - "~" => 27, - "?" => 25, - "{" => 29, - "=" => 32 - }, - DEFAULT => -105 + DEFAULT => -38 }, {#State 60 - ACTIONS => { - ":" => 23, - "<" => 26, - "~" => 27, - "?" => 25, - "{" => 29, - "=" => 32 - }, - DEFAULT => -107 + DEFAULT => -22 }, {#State 61 ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 + 'IDENTIFIER' => 90 }, - DEFAULT => -99 - }, - {#State 62 - DEFAULT => -11, + DEFAULT => -123, GOTOS => { - 'interface_names' => 70 + 'optional_identifier' => 105 } }, + {#State 62 + DEFAULT => -24 + }, {#State 63 ACTIONS => { - 'IDENTIFIER' => 11 + 'IDENTIFIER' => 90 }, + DEFAULT => -123, GOTOS => { - 'identifier' => 71 + 'optional_identifier' => 106 } }, {#State 64 ACTIONS => { - "{" => 72 - } - }, - {#State 65 - ACTIONS => { - 'IDENTIFIER' => 11 + 'IDENTIFIER' => 90 }, + DEFAULT => -123, GOTOS => { - 'identifier' => 43, - 'property' => 73 + 'optional_identifier' => 107 } }, + {#State 65 + DEFAULT => -39 + }, {#State 66 - DEFAULT => -91 + DEFAULT => -21 }, {#State 67 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'listtext' => 75, - 'anytext' => 74, - 'constant' => 13 - } + DEFAULT => -23 }, {#State 68 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 76, - 'constant' => 13 - } + DEFAULT => -37 }, {#State 69 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -100, + DEFAULT => -102, GOTOS => { - 'identifier' => 17, - 'text' => 18, - 'anytext' => 77, - 'constant' => 13 + 'identifier' => 45, + 'anytext' => 108, + 'text' => 46, + 'constant' => 43 } }, {#State 70 ACTIONS => { - "}" => 78, - "interface" => 79 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 109, + 'text' => 46, + 'constant' => 43 } }, {#State 71 - DEFAULT => -15 + ACTIONS => { + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 110, + 'text' => 46, + 'constant' => 43 + } }, {#State 72 ACTIONS => { - "typedef" => 80, - "union" => 81, - "enum" => 94, - "bitmap" => 95, - "declare" => 87, - "const" => 89, - "struct" => 92 - }, - DEFAULT => -90, - GOTOS => { - 'typedecl' => 93, - 'function' => 82, - 'bitmap' => 96, - 'definitions' => 83, - 'definition' => 86, - 'property_list' => 85, - 'usertype' => 84, - 'declare' => 98, - 'const' => 97, - 'struct' => 88, - 'enum' => 90, - 'typedef' => 91, - 'union' => 99 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 111, + 'text' => 46, + 'constant' => 43 } }, {#State 73 - DEFAULT => -93 + ACTIONS => { + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 112, + 'text' => 46, + 'constant' => 43 + } }, {#State 74 ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -96 + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 113, + 'text' => 46, + 'constant' => 43 + } }, {#State 75 ACTIONS => { - "," => 100, - ")" => 101 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 114, + 'text' => 46, + 'constant' => 43 } }, {#State 76 ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -118 + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 115, + 'text' => 46, + 'constant' => 43, + 'commalisttext' => 116 + } }, {#State 77 ACTIONS => { - ":" => 23, - "<" => 26, - "~" => 27, - "?" => 25, - "{" => 29, - "=" => 32 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -117 + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 117, + 'text' => 46, + 'constant' => 43 + } }, {#State 78 ACTIONS => { - ";" => 102 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -124, + DEFAULT => -102, GOTOS => { - 'optional_semicolon' => 103 + 'identifier' => 45, + 'anytext' => 118, + 'text' => 46, + 'constant' => 43 } }, {#State 79 ACTIONS => { - 'IDENTIFIER' => 11 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, + DEFAULT => -102, GOTOS => { - 'identifier' => 104 + 'identifier' => 45, + 'anytext' => 119, + 'text' => 46, + 'constant' => 43 } }, {#State 80 - DEFAULT => -90, + ACTIONS => { + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, GOTOS => { - 'property_list' => 105 + 'identifier' => 45, + 'anytext' => 115, + 'text' => 46, + 'constant' => 43, + 'commalisttext' => 120 } }, {#State 81 ACTIONS => { - 'IDENTIFIER' => 106 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -121, + DEFAULT => -102, GOTOS => { - 'optional_identifier' => 107 + 'identifier' => 45, + 'anytext' => 121, + 'text' => 46, + 'constant' => 43 } }, {#State 82 - DEFAULT => -18 - }, - {#State 83 ACTIONS => { - "}" => 108, - "typedef" => 80, - "union" => 81, - "enum" => 94, - "bitmap" => 95, - "declare" => 87, - "const" => 89, - "struct" => 92 - }, - DEFAULT => -90, - GOTOS => { - 'typedecl' => 93, - 'function' => 82, - 'bitmap' => 96, - 'definition' => 109, - 'property_list' => 85, - 'usertype' => 84, - 'const' => 97, - 'struct' => 88, - 'declare' => 98, - 'enum' => 90, - 'typedef' => 91, - 'union' => 99 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 122, + 'text' => 46, + 'constant' => 43 } }, - {#State 84 + {#State 83 ACTIONS => { - ";" => 110 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 123, + 'text' => 46, + 'constant' => 43 } }, - {#State 85 + {#State 84 ACTIONS => { - 'IDENTIFIER' => 11, - "signed" => 116, - "union" => 81, - "enum" => 94, - "bitmap" => 95, - 'void' => 111, - "unsigned" => 117, - "[" => 21, - "struct" => 92 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, + DEFAULT => -102, GOTOS => { - 'existingtype' => 115, - 'bitmap' => 96, - 'usertype' => 112, - 'identifier' => 113, - 'struct' => 88, - 'enum' => 90, - 'type' => 118, - 'union' => 99, - 'sign' => 114 + 'identifier' => 45, + 'anytext' => 124, + 'text' => 46, + 'constant' => 43 } }, + {#State 85 + DEFAULT => -97 + }, {#State 86 - DEFAULT => -16 + DEFAULT => -127 }, {#State 87 - DEFAULT => -90, - GOTOS => { - 'property_list' => 119 - } + DEFAULT => -12 }, {#State 88 - DEFAULT => -34 + ACTIONS => { + ";" => 125 + } }, {#State 89 ACTIONS => { - 'IDENTIFIER' => 11 - }, - GOTOS => { - 'identifier' => 120 + 'IDENTIFIER' => 22, + "signed" => 100, + "union" => 50, + "enum" => 63, + "bitmap" => 64, + 'void' => 95, + "unsigned" => 101, + "[" => 17, + "struct" => 61 + }, + GOTOS => { + 'existingtype' => 99, + 'bitmap' => 65, + 'usertype' => 96, + 'identifier' => 97, + 'struct' => 57, + 'enum' => 59, + 'type' => 126, + 'union' => 68, + 'sign' => 98 } }, {#State 90 - DEFAULT => -36 + DEFAULT => -122 }, {#State 91 - DEFAULT => -20 + ACTIONS => { + "{" => 128 + }, + DEFAULT => -77, + GOTOS => { + 'union_body' => 129, + 'opt_union_body' => 127 + } }, {#State 92 ACTIONS => { - 'IDENTIFIER' => 106 + ";" => 86 }, - DEFAULT => -121, + DEFAULT => -126, GOTOS => { - 'optional_identifier' => 121 + 'optional_semicolon' => 130 } }, {#State 93 - DEFAULT => -22 + DEFAULT => -19 }, {#State 94 - ACTIONS => { - 'IDENTIFIER' => 106 - }, - DEFAULT => -121, - GOTOS => { - 'optional_identifier' => 122 - } + DEFAULT => -40 }, {#State 95 - ACTIONS => { - 'IDENTIFIER' => 106 - }, - DEFAULT => -121, - GOTOS => { - 'optional_identifier' => 123 - } + DEFAULT => -48 }, {#State 96 - DEFAULT => -37 + DEFAULT => -46 }, {#State 97 - DEFAULT => -19 + DEFAULT => -45 }, {#State 98 - DEFAULT => -21 - }, - {#State 99 - DEFAULT => -35 - }, - {#State 100 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + 'IDENTIFIER' => 22 }, - DEFAULT => -100, GOTOS => { - 'identifier' => 17, - 'anytext' => 124, - 'text' => 18, - 'constant' => 13 + 'identifier' => 131 } }, + {#State 99 + DEFAULT => -47 + }, + {#State 100 + DEFAULT => -41 + }, {#State 101 - DEFAULT => -95 + DEFAULT => -42 }, {#State 102 - DEFAULT => -125 + ACTIONS => { + 'IDENTIFIER' => 22 + }, + GOTOS => { + 'identifier' => 132 + } }, {#State 103 - DEFAULT => -10 + ACTIONS => { + "union" => 133, + "enum" => 138, + "bitmap" => 139, + "[" => 17 + }, + GOTOS => { + 'decl_enum' => 134, + 'decl_bitmap' => 135, + 'decl_type' => 137, + 'decl_union' => 136 + } }, {#State 104 - ACTIONS => { - ";" => 125 + DEFAULT => -81, + GOTOS => { + 'pointers' => 140 } }, {#State 105 ACTIONS => { - 'IDENTIFIER' => 11, - "signed" => 116, - "union" => 81, - "enum" => 94, - "bitmap" => 95, - 'void' => 111, - "unsigned" => 117, - "[" => 21, - "struct" => 92 - }, - GOTOS => { - 'existingtype' => 115, - 'bitmap' => 96, - 'usertype' => 112, - 'identifier' => 113, - 'struct' => 88, - 'enum' => 90, - 'type' => 126, - 'union' => 99, - 'sign' => 114 + "{" => 142 + }, + DEFAULT => -67, + GOTOS => { + 'struct_body' => 141, + 'opt_struct_body' => 143 } }, {#State 106 - DEFAULT => -120 + ACTIONS => { + "{" => 144 + }, + DEFAULT => -50, + GOTOS => { + 'opt_enum_body' => 146, + 'enum_body' => 145 + } }, {#State 107 ACTIONS => { - "{" => 128 + "{" => 148 }, - DEFAULT => -75, + DEFAULT => -58, GOTOS => { - 'union_body' => 129, - 'opt_union_body' => 127 + 'bitmap_body' => 149, + 'opt_bitmap_body' => 147 } }, {#State 108 ACTIONS => { - ";" => 102 + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 }, - DEFAULT => -124, - GOTOS => { - 'optional_semicolon' => 130 - } + DEFAULT => -115 }, {#State 109 - DEFAULT => -17 + ACTIONS => { + ":" => 69, + "<" => 71, + "~" => 72, + "?" => 75, + "{" => 76, + "=" => 79 + }, + DEFAULT => -106 }, {#State 110 - DEFAULT => -38 + ACTIONS => { + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 + }, + DEFAULT => -110 }, {#State 111 - DEFAULT => -46 + ACTIONS => { + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 + }, + DEFAULT => -118 }, {#State 112 - DEFAULT => -44 + ACTIONS => { + ":" => 69, + "<" => 71, + "~" => 72, + "?" => 75, + "{" => 76, + "=" => 79 + }, + DEFAULT => -117 }, {#State 113 - DEFAULT => -43 + ACTIONS => { + ":" => 69, + "<" => 71, + "~" => 72, + "?" => 75, + "{" => 76, + "=" => 79 + }, + DEFAULT => -108 }, {#State 114 ACTIONS => { - 'IDENTIFIER' => 11 + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 }, - GOTOS => { - 'identifier' => 131 - } + DEFAULT => -114 }, {#State 115 - DEFAULT => -45 + ACTIONS => { + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 + }, + DEFAULT => -100 }, {#State 116 - DEFAULT => -39 + ACTIONS => { + "}" => 150, + "," => 151 + } }, {#State 117 - DEFAULT => -40 + ACTIONS => { + ":" => 69, + "<" => 71, + "~" => 72, + "?" => 75, + "{" => 76, + "=" => 79 + }, + DEFAULT => -112 }, {#State 118 ACTIONS => { - 'IDENTIFIER' => 11 + ":" => 69, + "<" => 71, + "~" => 72, + "?" => 75, + "{" => 76, + "=" => 79 }, - GOTOS => { - 'identifier' => 132 - } + DEFAULT => -113 }, {#State 119 ACTIONS => { - "union" => 133, - "enum" => 138, - "bitmap" => 139, - "[" => 21 + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 }, - GOTOS => { - 'decl_enum' => 134, - 'decl_bitmap' => 135, - 'decl_type' => 137, - 'decl_union' => 136 - } + DEFAULT => -116 }, {#State 120 - DEFAULT => -79, - GOTOS => { - 'pointers' => 140 + ACTIONS => { + "," => 151, + ")" => 152 } }, {#State 121 ACTIONS => { - "{" => 142 + ":" => 69, + "<" => 71, + "~" => 72, + "?" => 75, + "{" => 76, + "=" => 79 }, - DEFAULT => -65, - GOTOS => { - 'struct_body' => 141, - 'opt_struct_body' => 143 - } + DEFAULT => -111 }, {#State 122 ACTIONS => { - "{" => 144 + ":" => 69, + "<" => 71, + "~" => 72, + "?" => 75, + "{" => 76, + "=" => 79 }, - DEFAULT => -48, - GOTOS => { - 'opt_enum_body' => 146, - 'enum_body' => 145 - } + DEFAULT => -107 }, {#State 123 ACTIONS => { - "{" => 148 + ":" => 69, + "<" => 71, + "~" => 72, + "?" => 75, + "{" => 76, + "=" => 79 }, - DEFAULT => -56, - GOTOS => { - 'bitmap_body' => 149, - 'opt_bitmap_body' => 147 - } + DEFAULT => -109 }, {#State 124 ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 }, - DEFAULT => -97 + DEFAULT => -99 }, {#State 125 - DEFAULT => -12 + DEFAULT => -14 }, {#State 126 ACTIONS => { - 'IDENTIFIER' => 11 + 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 150 + 'identifier' => 153 } }, {#State 127 - DEFAULT => -77 + DEFAULT => -79 }, {#State 128 - DEFAULT => -72, + DEFAULT => -74, GOTOS => { - 'union_elements' => 151 + 'union_elements' => 154 } }, {#State 129 - DEFAULT => -76 + DEFAULT => -78 }, {#State 130 - DEFAULT => -13 + DEFAULT => -15 }, {#State 131 - DEFAULT => -42 + DEFAULT => -44 }, {#State 132 ACTIONS => { - "(" => 152 + "(" => 155 } }, {#State 133 - DEFAULT => -32 + DEFAULT => -34 }, {#State 134 - DEFAULT => -27 + DEFAULT => -29 }, {#State 135 - DEFAULT => -28 + DEFAULT => -30 }, {#State 136 - DEFAULT => -29 + DEFAULT => -31 }, {#State 137 ACTIONS => { - 'IDENTIFIER' => 11 + 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 153 + 'identifier' => 156 } }, {#State 138 - DEFAULT => -30 + DEFAULT => -32 }, {#State 139 - DEFAULT => -31 + DEFAULT => -33 }, {#State 140 ACTIONS => { - 'IDENTIFIER' => 11, - "*" => 155 + 'IDENTIFIER' => 22, + "*" => 158 }, GOTOS => { - 'identifier' => 154 + 'identifier' => 157 } }, {#State 141 - DEFAULT => -66 + DEFAULT => -68 }, {#State 142 - DEFAULT => -81, + DEFAULT => -83, GOTOS => { - 'element_list1' => 156 + 'element_list1' => 159 } }, {#State 143 - DEFAULT => -67 + DEFAULT => -69 }, {#State 144 ACTIONS => { - 'IDENTIFIER' => 11 + 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 157, - 'enum_element' => 158, - 'enum_elements' => 159 + 'identifier' => 160, + 'enum_element' => 161, + 'enum_elements' => 162 } }, {#State 145 - DEFAULT => -49 + DEFAULT => -51 }, {#State 146 - DEFAULT => -50 + DEFAULT => -52 }, {#State 147 - DEFAULT => -58 + DEFAULT => -60 }, {#State 148 ACTIONS => { - 'IDENTIFIER' => 11 + 'IDENTIFIER' => 22 }, - DEFAULT => -61, + DEFAULT => -63, GOTOS => { - 'identifier' => 162, - 'bitmap_element' => 161, - 'bitmap_elements' => 160, - 'opt_bitmap_elements' => 163 + 'identifier' => 165, + 'bitmap_element' => 164, + 'bitmap_elements' => 163, + 'opt_bitmap_elements' => 166 } }, {#State 149 - DEFAULT => -57 + DEFAULT => -59 }, {#State 150 ACTIONS => { - "[" => 164 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -87, + DEFAULT => -102, GOTOS => { - 'array_len' => 165 + 'identifier' => 45, + 'anytext' => 167, + 'text' => 46, + 'constant' => 43 } }, {#State 151 ACTIONS => { - "}" => 166 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -90, + DEFAULT => -102, GOTOS => { - 'optional_base_element' => 168, - 'property_list' => 167 + 'identifier' => 45, + 'anytext' => 168, + 'text' => 46, + 'constant' => 43 } }, {#State 152 ACTIONS => { - "," => -83, - "void" => 172, - ")" => -83 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -90, + DEFAULT => -102, GOTOS => { - 'base_element' => 169, - 'element_list2' => 171, - 'property_list' => 170 + 'identifier' => 45, + 'anytext' => 169, + 'text' => 46, + 'constant' => 43 } }, {#State 153 ACTIONS => { - ";" => 173 + "[" => 170 + }, + DEFAULT => -89, + GOTOS => { + 'array_len' => 171 } }, {#State 154 ACTIONS => { - "[" => 164, - "=" => 175 + "}" => 172 }, + DEFAULT => -92, GOTOS => { - 'array_len' => 174 + 'optional_base_element' => 174, + 'property_list' => 173 } }, {#State 155 - DEFAULT => -80 - }, - {#State 156 ACTIONS => { - "}" => 176 + "," => -85, + "void" => 178, + ")" => -85 }, - DEFAULT => -90, + DEFAULT => -92, GOTOS => { - 'base_element' => 177, - 'property_list' => 170 + 'base_element' => 175, + 'element_list2' => 177, + 'property_list' => 176 + } + }, + {#State 156 + ACTIONS => { + ";" => 179 } }, {#State 157 ACTIONS => { - "=" => 178 + "[" => 170, + "=" => 181 }, - DEFAULT => -53 + GOTOS => { + 'array_len' => 180 + } }, {#State 158 - DEFAULT => -51 + DEFAULT => -82 }, {#State 159 ACTIONS => { - "}" => 179, - "," => 180 + "}" => 182 + }, + DEFAULT => -92, + GOTOS => { + 'base_element' => 183, + 'property_list' => 176 } }, {#State 160 ACTIONS => { - "," => 181 + "=" => 184 }, - DEFAULT => -62 + DEFAULT => -55 }, {#State 161 - DEFAULT => -59 + DEFAULT => -53 }, {#State 162 ACTIONS => { - "=" => 182 + "}" => 185, + "," => 186 } }, {#State 163 ACTIONS => { - "}" => 183 - } + "," => 187 + }, + DEFAULT => -64 }, {#State 164 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - "]" => 184, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'anytext' => 185, - 'text' => 18, - 'constant' => 13 - } + DEFAULT => -61 }, {#State 165 ACTIONS => { - ";" => 186 + "=" => 188 } }, {#State 166 - DEFAULT => -74 + ACTIONS => { + "}" => 189 + } }, {#State 167 ACTIONS => { - "[" => 21 + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 }, - DEFAULT => -90, - GOTOS => { - 'base_or_empty' => 187, - 'base_element' => 188, - 'empty_element' => 189, - 'property_list' => 190 - } + DEFAULT => -120 }, {#State 168 - DEFAULT => -73 + ACTIONS => { + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 + }, + DEFAULT => -101 }, {#State 169 - DEFAULT => -85 + ACTIONS => { + ":" => 69, + "<" => 71, + "~" => 72, + "?" => 75, + "{" => 76, + "=" => 79 + }, + DEFAULT => -119 }, {#State 170 ACTIONS => { - 'IDENTIFIER' => 11, - "signed" => 116, - "union" => 81, - "enum" => 94, - "bitmap" => 95, - 'void' => 111, - "unsigned" => 117, - "[" => 21, - "struct" => 92 - }, - DEFAULT => -41, - GOTOS => { - 'existingtype' => 115, - 'bitmap' => 96, - 'usertype' => 112, - 'identifier' => 113, - 'struct' => 88, - 'enum' => 90, - 'type' => 191, - 'union' => 99, - 'sign' => 114 + 'CONSTANT' => 44, + 'TEXT' => 13, + "]" => 190, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 191, + 'text' => 46, + 'constant' => 43 } }, {#State 171 ACTIONS => { - "," => 192, - ")" => 193 + ";" => 192 } }, {#State 172 - DEFAULT => -84 + DEFAULT => -76 }, {#State 173 - DEFAULT => -26 - }, - {#State 174 - ACTIONS => { - "=" => 194 - } - }, - {#State 175 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 + "[" => 17 }, - DEFAULT => -100, + DEFAULT => -92, GOTOS => { - 'identifier' => 17, - 'anytext' => 195, - 'text' => 18, - 'constant' => 13 + 'base_or_empty' => 193, + 'base_element' => 194, + 'empty_element' => 195, + 'property_list' => 196 } }, + {#State 174 + DEFAULT => -75 + }, + {#State 175 + DEFAULT => -87 + }, {#State 176 - DEFAULT => -64 + ACTIONS => { + 'IDENTIFIER' => 22, + "signed" => 100, + "union" => 50, + "enum" => 63, + "bitmap" => 64, + 'void' => 95, + "unsigned" => 101, + "[" => 17, + "struct" => 61 + }, + DEFAULT => -43, + GOTOS => { + 'existingtype' => 99, + 'bitmap' => 65, + 'usertype' => 96, + 'identifier' => 97, + 'struct' => 57, + 'enum' => 59, + 'type' => 197, + 'union' => 68, + 'sign' => 98 + } }, {#State 177 ACTIONS => { - ";" => 196 + "," => 198, + ")" => 199 } }, {#State 178 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'anytext' => 197, - 'text' => 18, - 'constant' => 13 - } + DEFAULT => -86 }, {#State 179 - DEFAULT => -47 + DEFAULT => -28 }, {#State 180 ACTIONS => { - 'IDENTIFIER' => 11 - }, - GOTOS => { - 'identifier' => 157, - 'enum_element' => 198 + "=" => 200 } }, {#State 181 ACTIONS => { - 'IDENTIFIER' => 11 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, + DEFAULT => -102, GOTOS => { - 'identifier' => 162, - 'bitmap_element' => 199 + 'identifier' => 45, + 'anytext' => 201, + 'text' => 46, + 'constant' => 43 } }, {#State 182 - ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'anytext' => 200, - 'text' => 18, - 'constant' => 13 - } + DEFAULT => -66 }, {#State 183 - DEFAULT => -55 + ACTIONS => { + ";" => 202 + } }, {#State 184 ACTIONS => { - "[" => 164 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -87, + DEFAULT => -102, GOTOS => { - 'array_len' => 201 + 'identifier' => 45, + 'anytext' => 203, + 'text' => 46, + 'constant' => 43 } }, {#State 185 - ACTIONS => { - "-" => 24, - ":" => 23, - "?" => 25, - "<" => 26, - "+" => 28, - "~" => 27, - "&" => 30, - "{" => 29, - "/" => 31, - "=" => 32, - "|" => 34, - "(" => 33, - "*" => 35, - "." => 36, - "]" => 202, - ">" => 37 - } + DEFAULT => -49 }, {#State 186 - DEFAULT => -33 + ACTIONS => { + 'IDENTIFIER' => 22 + }, + GOTOS => { + 'identifier' => 160, + 'enum_element' => 204 + } }, {#State 187 - DEFAULT => -71 + ACTIONS => { + 'IDENTIFIER' => 22 + }, + GOTOS => { + 'identifier' => 165, + 'bitmap_element' => 205 + } }, {#State 188 ACTIONS => { - ";" => 203 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 206, + 'text' => 46, + 'constant' => 43 } }, {#State 189 - DEFAULT => -70 + DEFAULT => -57 }, {#State 190 ACTIONS => { - 'IDENTIFIER' => 11, - "signed" => 116, - "union" => 81, - ";" => 204, - "enum" => 94, - "bitmap" => 95, - 'void' => 111, - "unsigned" => 117, - "[" => 21, - "struct" => 92 - }, - DEFAULT => -41, - GOTOS => { - 'existingtype' => 115, - 'bitmap' => 96, - 'usertype' => 112, - 'identifier' => 113, - 'struct' => 88, - 'enum' => 90, - 'type' => 191, - 'union' => 99, - 'sign' => 114 + "[" => 170 + }, + DEFAULT => -89, + GOTOS => { + 'array_len' => 207 } }, {#State 191 - DEFAULT => -79, - GOTOS => { - 'pointers' => 205 + ACTIONS => { + "-" => 70, + ":" => 69, + "?" => 75, + "<" => 71, + "+" => 73, + "~" => 72, + "&" => 77, + "{" => 76, + "/" => 78, + "=" => 79, + "|" => 81, + "(" => 80, + "*" => 74, + "." => 82, + "]" => 208, + ">" => 83 } }, {#State 192 - DEFAULT => -90, - GOTOS => { - 'base_element' => 206, - 'property_list' => 170 - } + DEFAULT => -35 }, {#State 193 - ACTIONS => { - ";" => 207 - } + DEFAULT => -73 }, {#State 194 ACTIONS => { - 'CONSTANT' => 14, - 'TEXT' => 16, - 'IDENTIFIER' => 11 - }, - DEFAULT => -100, - GOTOS => { - 'identifier' => 17, - 'anytext' => 208, - 'text' => 18, - 'constant' => 13 + ";" => 209 } }, {#State 195 - ACTIONS => { - "-" => 24, - ":" => 23, - "?" => 25, - "<" => 26, - ";" => 209, - "+" => 28, - "~" => 27, - "&" => 30, - "{" => 29, - "/" => 31, - "=" => 32, - "|" => 34, - "(" => 33, - "*" => 35, - "." => 36, - ">" => 37 - } + DEFAULT => -72 }, {#State 196 - DEFAULT => -82 + ACTIONS => { + 'IDENTIFIER' => 22, + "signed" => 100, + "union" => 50, + ";" => 210, + "enum" => 63, + "bitmap" => 64, + 'void' => 95, + "unsigned" => 101, + "[" => 17, + "struct" => 61 + }, + DEFAULT => -43, + GOTOS => { + 'existingtype' => 99, + 'bitmap' => 65, + 'usertype' => 96, + 'identifier' => 97, + 'struct' => 57, + 'enum' => 59, + 'type' => 197, + 'union' => 68, + 'sign' => 98 + } }, {#State 197 - ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 - }, - DEFAULT => -54 + DEFAULT => -81, + GOTOS => { + 'pointers' => 211 + } }, {#State 198 - DEFAULT => -52 + DEFAULT => -92, + GOTOS => { + 'base_element' => 212, + 'property_list' => 176 + } }, {#State 199 - DEFAULT => -60 + ACTIONS => { + ";" => 213 + } }, {#State 200 ACTIONS => { - "-" => 24, - ":" => 23, - "<" => 26, - "+" => 28, - "~" => 27, - "*" => 35, - "?" => 25, - "{" => 29, - "&" => 30, - "/" => 31, - "=" => 32, - "(" => 33, - "|" => 34, - "." => 36, - ">" => 37 - }, - DEFAULT => -63 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -102, + GOTOS => { + 'identifier' => 45, + 'anytext' => 214, + 'text' => 46, + 'constant' => 43 + } }, {#State 201 - DEFAULT => -88 - }, - {#State 202 ACTIONS => { - "[" => 164 - }, - DEFAULT => -87, - GOTOS => { - 'array_len' => 210 + "-" => 70, + ":" => 69, + "?" => 75, + "<" => 71, + ";" => 215, + "+" => 73, + "~" => 72, + "&" => 77, + "{" => 76, + "/" => 78, + "=" => 79, + "|" => 81, + "(" => 80, + "*" => 74, + "." => 82, + ">" => 83 } }, + {#State 202 + DEFAULT => -84 + }, {#State 203 - DEFAULT => -69 + ACTIONS => { + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 + }, + DEFAULT => -56 }, {#State 204 - DEFAULT => -68 + DEFAULT => -54 }, {#State 205 - ACTIONS => { - 'IDENTIFIER' => 11, - "*" => 155 - }, - GOTOS => { - 'identifier' => 211 - } + DEFAULT => -62 }, {#State 206 - DEFAULT => -86 + ACTIONS => { + "-" => 70, + ":" => 69, + "<" => 71, + "+" => 73, + "~" => 72, + "*" => 74, + "?" => 75, + "{" => 76, + "&" => 77, + "/" => 78, + "=" => 79, + "(" => 80, + "|" => 81, + "." => 82, + ">" => 83 + }, + DEFAULT => -65 }, {#State 207 - DEFAULT => -25 + DEFAULT => -90 }, {#State 208 ACTIONS => { - "-" => 24, - ":" => 23, - "?" => 25, - "<" => 26, - ";" => 212, - "+" => 28, - "~" => 27, - "&" => 30, - "{" => 29, - "/" => 31, - "=" => 32, - "|" => 34, - "(" => 33, - "*" => 35, - "." => 36, - ">" => 37 + "[" => 170 + }, + DEFAULT => -89, + GOTOS => { + 'array_len' => 216 } }, {#State 209 - DEFAULT => -23 + DEFAULT => -71 }, {#State 210 - DEFAULT => -89 + DEFAULT => -70 }, {#State 211 ACTIONS => { - "[" => 164 + 'IDENTIFIER' => 22, + "*" => 158 }, - DEFAULT => -87, GOTOS => { - 'array_len' => 213 + 'identifier' => 217 } }, {#State 212 - DEFAULT => -24 + DEFAULT => -88 }, {#State 213 - DEFAULT => -78 + DEFAULT => -27 + }, + {#State 214 + ACTIONS => { + "-" => 70, + ":" => 69, + "?" => 75, + "<" => 71, + ";" => 218, + "+" => 73, + "~" => 72, + "&" => 77, + "{" => 76, + "/" => 78, + "=" => 79, + "|" => 81, + "(" => 80, + "*" => 74, + "." => 82, + ">" => 83 + } + }, + {#State 215 + DEFAULT => -25 + }, + {#State 216 + DEFAULT => -91 + }, + {#State 217 + ACTIONS => { + "[" => 170 + }, + DEFAULT => -89, + GOTOS => { + 'array_len' => 219 + } + }, + {#State 218 + DEFAULT => -26 + }, + {#State 219 + DEFAULT => -80 } ], yyrules => @@ -2300,7 +2321,7 @@ sub #line 26 "pidl/idl.yp" {{ "TYPE" => "IMPORT", - "PATHS" => [ $_[2] ], + "PATHS" => $_[2], "FILE" => $_[0]->YYData->{INPUT_FILENAME}, "LINE" => $_[0]->YYData->{LINE} }} @@ -2311,7 +2332,7 @@ sub #line 33 "pidl/idl.yp" {{ "TYPE" => "INCLUDE", - "PATHS" => [ $_[2] ], + "PATHS" => $_[2], "FILE" => $_[0]->YYData->{INPUT_FILENAME}, "LINE" => $_[0]->YYData->{LINE} }} @@ -2322,15 +2343,27 @@ sub #line 40 "pidl/idl.yp" {{ "TYPE" => "IMPORTLIB", - "PATHS" => [ $_[2] ], + "PATHS" => $_[2], "FILE" => $_[0]->YYData->{INPUT_FILENAME}, "LINE" => $_[0]->YYData->{LINE} }} ], [#Rule 10 - 'coclass', 7, + 'commalist', 1, sub #line 49 "pidl/idl.yp" +{ [ $_[1] ] } + ], + [#Rule 11 + 'commalist', 3, +sub +#line 50 "pidl/idl.yp" +{ push(@{$_[1]}, $_[3]); $_[1] } + ], + [#Rule 12 + 'coclass', 7, +sub +#line 54 "pidl/idl.yp" {{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -2340,19 +2373,19 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 11 + [#Rule 13 'interface_names', 0, undef ], - [#Rule 12 + [#Rule 14 'interface_names', 4, sub -#line 61 "pidl/idl.yp" +#line 66 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 13 + [#Rule 15 'interface', 8, sub -#line 65 "pidl/idl.yp" +#line 70 "pidl/idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -2363,33 +2396,27 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 14 + [#Rule 16 'base_interface', 0, undef ], - [#Rule 15 + [#Rule 17 'base_interface', 2, sub -#line 78 "pidl/idl.yp" +#line 83 "pidl/idl.yp" { $_[2] } ], - [#Rule 16 + [#Rule 18 'definitions', 1, sub -#line 82 "pidl/idl.yp" +#line 87 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 17 + [#Rule 19 'definitions', 2, sub -#line 83 "pidl/idl.yp" +#line 88 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 18 - 'definition', 1, undef - ], - [#Rule 19 - 'definition', 1, undef - ], [#Rule 20 'definition', 1, undef ], @@ -2400,9 +2427,15 @@ sub 'definition', 1, undef ], [#Rule 23 + 'definition', 1, undef + ], + [#Rule 24 + 'definition', 1, undef + ], + [#Rule 25 'const', 7, sub -#line 91 "pidl/idl.yp" +#line 96 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2413,10 +2446,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 24 + [#Rule 26 'const', 8, sub -#line 101 "pidl/idl.yp" +#line 106 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2428,10 +2461,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 25 + [#Rule 27 'function', 7, sub -#line 115 "pidl/idl.yp" +#line 120 "pidl/idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2442,10 +2475,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 26 + [#Rule 28 'declare', 5, sub -#line 127 "pidl/idl.yp" +#line 132 "pidl/idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2455,43 +2488,43 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 27 + [#Rule 29 'decl_type', 1, undef ], - [#Rule 28 + [#Rule 30 'decl_type', 1, undef ], - [#Rule 29 + [#Rule 31 'decl_type', 1, undef ], - [#Rule 30 + [#Rule 32 'decl_enum', 1, sub -#line 141 "pidl/idl.yp" +#line 146 "pidl/idl.yp" {{ "TYPE" => "ENUM" }} ], - [#Rule 31 + [#Rule 33 'decl_bitmap', 1, sub -#line 147 "pidl/idl.yp" +#line 152 "pidl/idl.yp" {{ "TYPE" => "BITMAP" }} ], - [#Rule 32 + [#Rule 34 'decl_union', 1, sub -#line 153 "pidl/idl.yp" +#line 158 "pidl/idl.yp" {{ "TYPE" => "UNION" }} ], - [#Rule 33 + [#Rule 35 'typedef', 6, sub -#line 159 "pidl/idl.yp" +#line 164 "pidl/idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], @@ -2502,169 +2535,169 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 34 + [#Rule 36 'usertype', 1, undef ], - [#Rule 35 + [#Rule 37 'usertype', 1, undef ], - [#Rule 36 + [#Rule 38 'usertype', 1, undef ], - [#Rule 37 + [#Rule 39 'usertype', 1, undef ], - [#Rule 38 + [#Rule 40 'typedecl', 2, sub -#line 172 "pidl/idl.yp" +#line 177 "pidl/idl.yp" { $_[1] } ], - [#Rule 39 + [#Rule 41 'sign', 1, undef ], - [#Rule 40 + [#Rule 42 'sign', 1, undef ], - [#Rule 41 + [#Rule 43 'existingtype', 0, undef ], - [#Rule 42 + [#Rule 44 'existingtype', 2, sub -#line 177 "pidl/idl.yp" +#line 182 "pidl/idl.yp" { "$_[1] $_[2]" } ], - [#Rule 43 + [#Rule 45 'existingtype', 1, undef ], - [#Rule 44 + [#Rule 46 'type', 1, undef ], - [#Rule 45 + [#Rule 47 'type', 1, undef ], - [#Rule 46 + [#Rule 48 'type', 1, sub -#line 181 "pidl/idl.yp" +#line 186 "pidl/idl.yp" { "void" } ], - [#Rule 47 + [#Rule 49 'enum_body', 3, sub -#line 183 "pidl/idl.yp" +#line 188 "pidl/idl.yp" { $_[2] } ], - [#Rule 48 + [#Rule 50 'opt_enum_body', 0, undef ], - [#Rule 49 + [#Rule 51 'opt_enum_body', 1, undef ], - [#Rule 50 + [#Rule 52 'enum', 3, sub -#line 186 "pidl/idl.yp" +#line 191 "pidl/idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 51 + [#Rule 53 'enum_elements', 1, sub -#line 194 "pidl/idl.yp" +#line 199 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 52 + [#Rule 54 'enum_elements', 3, sub -#line 195 "pidl/idl.yp" +#line 200 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 53 + [#Rule 55 'enum_element', 1, undef ], - [#Rule 54 + [#Rule 56 'enum_element', 3, sub -#line 199 "pidl/idl.yp" +#line 204 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 55 + [#Rule 57 'bitmap_body', 3, sub -#line 202 "pidl/idl.yp" +#line 207 "pidl/idl.yp" { $_[2] } ], - [#Rule 56 + [#Rule 58 'opt_bitmap_body', 0, undef ], - [#Rule 57 + [#Rule 59 'opt_bitmap_body', 1, undef ], - [#Rule 58 + [#Rule 60 'bitmap', 3, sub -#line 205 "pidl/idl.yp" +#line 210 "pidl/idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 59 + [#Rule 61 'bitmap_elements', 1, sub -#line 213 "pidl/idl.yp" +#line 218 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 60 + [#Rule 62 'bitmap_elements', 3, sub -#line 214 "pidl/idl.yp" +#line 219 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 61 + [#Rule 63 'opt_bitmap_elements', 0, undef ], - [#Rule 62 + [#Rule 64 'opt_bitmap_elements', 1, undef ], - [#Rule 63 + [#Rule 65 'bitmap_element', 3, sub -#line 219 "pidl/idl.yp" +#line 224 "pidl/idl.yp" { "$_[1] ( $_[3] )" } ], - [#Rule 64 + [#Rule 66 'struct_body', 3, sub -#line 222 "pidl/idl.yp" +#line 227 "pidl/idl.yp" { $_[2] } ], - [#Rule 65 + [#Rule 67 'opt_struct_body', 0, undef ], - [#Rule 66 + [#Rule 68 'opt_struct_body', 1, undef ], - [#Rule 67 + [#Rule 69 'struct', 3, sub -#line 226 "pidl/idl.yp" +#line 231 "pidl/idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 68 + [#Rule 70 'empty_element', 2, sub -#line 234 "pidl/idl.yp" +#line 239 "pidl/idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2675,53 +2708,53 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 69 + [#Rule 71 'base_or_empty', 2, undef ], - [#Rule 70 + [#Rule 72 'base_or_empty', 1, undef ], - [#Rule 71 + [#Rule 73 'optional_base_element', 2, sub -#line 248 "pidl/idl.yp" +#line 253 "pidl/idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], - [#Rule 72 + [#Rule 74 'union_elements', 0, undef ], - [#Rule 73 + [#Rule 75 'union_elements', 2, sub -#line 253 "pidl/idl.yp" +#line 258 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 74 + [#Rule 76 'union_body', 3, sub -#line 256 "pidl/idl.yp" +#line 261 "pidl/idl.yp" { $_[2] } ], - [#Rule 75 + [#Rule 77 'opt_union_body', 0, undef ], - [#Rule 76 + [#Rule 78 'opt_union_body', 1, undef ], - [#Rule 77 + [#Rule 79 'union', 3, sub -#line 260 "pidl/idl.yp" +#line 265 "pidl/idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], "ELEMENTS" => $_[3] }} ], - [#Rule 78 + [#Rule 80 'base_element', 5, sub -#line 268 "pidl/idl.yp" +#line 273 "pidl/idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2732,238 +2765,238 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 79 + [#Rule 81 'pointers', 0, sub -#line 282 "pidl/idl.yp" +#line 287 "pidl/idl.yp" { 0 } ], - [#Rule 80 + [#Rule 82 'pointers', 2, sub -#line 283 "pidl/idl.yp" +#line 288 "pidl/idl.yp" { $_[1]+1 } ], - [#Rule 81 + [#Rule 83 'element_list1', 0, undef ], - [#Rule 82 + [#Rule 84 'element_list1', 3, sub -#line 288 "pidl/idl.yp" +#line 293 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 83 + [#Rule 85 'element_list2', 0, undef ], - [#Rule 84 + [#Rule 86 'element_list2', 1, undef ], - [#Rule 85 + [#Rule 87 'element_list2', 1, sub -#line 294 "pidl/idl.yp" +#line 299 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 86 + [#Rule 88 'element_list2', 3, sub -#line 295 "pidl/idl.yp" +#line 300 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 87 + [#Rule 89 'array_len', 0, undef ], - [#Rule 88 + [#Rule 90 'array_len', 3, sub -#line 300 "pidl/idl.yp" +#line 305 "pidl/idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], - [#Rule 89 + [#Rule 91 'array_len', 4, sub -#line 301 "pidl/idl.yp" +#line 306 "pidl/idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], - [#Rule 90 + [#Rule 92 'property_list', 0, undef ], - [#Rule 91 + [#Rule 93 'property_list', 4, sub -#line 307 "pidl/idl.yp" +#line 312 "pidl/idl.yp" { FlattenHash([$_[1],$_[3]]); } ], - [#Rule 92 + [#Rule 94 'properties', 1, sub -#line 310 "pidl/idl.yp" +#line 315 "pidl/idl.yp" { $_[1] } ], - [#Rule 93 + [#Rule 95 'properties', 3, sub -#line 311 "pidl/idl.yp" +#line 316 "pidl/idl.yp" { FlattenHash([$_[1], $_[3]]); } ], - [#Rule 94 + [#Rule 96 'property', 1, sub -#line 314 "pidl/idl.yp" +#line 319 "pidl/idl.yp" {{ "$_[1]" => "1" }} ], - [#Rule 95 + [#Rule 97 'property', 4, sub -#line 315 "pidl/idl.yp" +#line 320 "pidl/idl.yp" {{ "$_[1]" => "$_[3]" }} ], - [#Rule 96 + [#Rule 98 'listtext', 1, undef ], - [#Rule 97 + [#Rule 99 'listtext', 3, sub -#line 320 "pidl/idl.yp" +#line 325 "pidl/idl.yp" { "$_[1] $_[3]" } ], - [#Rule 98 + [#Rule 100 'commalisttext', 1, undef ], - [#Rule 99 + [#Rule 101 'commalisttext', 3, sub -#line 325 "pidl/idl.yp" +#line 330 "pidl/idl.yp" { "$_[1],$_[3]" } ], - [#Rule 100 + [#Rule 102 'anytext', 0, sub -#line 329 "pidl/idl.yp" +#line 334 "pidl/idl.yp" { "" } ], - [#Rule 101 - 'anytext', 1, undef - ], - [#Rule 102 - 'anytext', 1, undef - ], [#Rule 103 'anytext', 1, undef ], [#Rule 104 - 'anytext', 3, -sub -#line 331 "pidl/idl.yp" -{ "$_[1]$_[2]$_[3]" } + 'anytext', 1, undef ], [#Rule 105 - 'anytext', 3, -sub -#line 332 "pidl/idl.yp" -{ "$_[1]$_[2]$_[3]" } + 'anytext', 1, undef ], [#Rule 106 'anytext', 3, sub -#line 333 "pidl/idl.yp" +#line 336 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 334 "pidl/idl.yp" +#line 337 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 'anytext', 3, sub -#line 335 "pidl/idl.yp" +#line 338 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 109 'anytext', 3, sub -#line 336 "pidl/idl.yp" +#line 339 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 110 'anytext', 3, sub -#line 337 "pidl/idl.yp" +#line 340 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 111 'anytext', 3, sub -#line 338 "pidl/idl.yp" +#line 341 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 112 'anytext', 3, sub -#line 339 "pidl/idl.yp" +#line 342 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 113 'anytext', 3, sub -#line 340 "pidl/idl.yp" +#line 343 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 114 'anytext', 3, sub -#line 341 "pidl/idl.yp" +#line 344 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 115 'anytext', 3, sub -#line 342 "pidl/idl.yp" +#line 345 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 116 'anytext', 3, sub -#line 343 "pidl/idl.yp" +#line 346 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 117 + 'anytext', 3, +sub +#line 347 "pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 118 + 'anytext', 3, +sub +#line 348 "pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 119 'anytext', 5, sub -#line 344 "pidl/idl.yp" +#line 349 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 118 + [#Rule 120 'anytext', 5, sub -#line 345 "pidl/idl.yp" +#line 350 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 119 + [#Rule 121 'identifier', 1, undef ], - [#Rule 120 + [#Rule 122 'optional_identifier', 1, undef ], - [#Rule 121 + [#Rule 123 'optional_identifier', 0, undef ], - [#Rule 122 + [#Rule 124 'constant', 1, undef ], - [#Rule 123 + [#Rule 125 'text', 1, sub -#line 359 "pidl/idl.yp" +#line 364 "pidl/idl.yp" { "\"$_[1]\"" } ], - [#Rule 124 + [#Rule 126 'optional_semicolon', 0, undef ], - [#Rule 125 + [#Rule 127 'optional_semicolon', 1, undef ] ], @@ -2971,7 +3004,7 @@ sub bless($self,$class); } -#line 370 "pidl/idl.yp" +#line 375 "pidl/idl.yp" ##################################################################### diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 94346efe4b..6a999d4147 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -321,7 +321,7 @@ sub HeaderInclude { my @includes = @_; foreach (@includes) { - pidl "#include \"$_\"\n"; + pidl "#include $_\n"; } } -- cgit From 9972dc2549d3a67d8790d3a1dfd02a82584ec1b2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 7 Nov 2006 01:00:27 +0000 Subject: r19599: Fix --includedir. (This used to be commit 0da2bbcf766dc25805ad583fae185045bb390a5f) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index d237db7137..85c5b8b828 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -3144,7 +3144,7 @@ sub parse_file($$) if (! defined $cpp) { $cpp = "cpp"; } - my $includes = map { " -I$_" } @$incdirs; + my $includes = join('',map { " -I$_" } @$incdirs); my $data = `$cpp -D__PIDL__$includes -xc $filename`; $/ = $saved_delim; -- cgit From 5b05f5f5f1bad489091c715867eddda7eff4c8c6 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 16 Nov 2006 22:13:44 +0000 Subject: r19752: Remove support for the `depends' attribute (use "import") instead. (This used to be commit 324395afc725e90f44f286fd776b38a64bdc8e3b) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 5 ----- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 4 ---- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 4 ---- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ---- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 3 --- 5 files changed, 20 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 86bd62044b..a80bb954c1 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -766,7 +766,6 @@ my %property_list = ( "endpoint" => ["INTERFACE"], "pointer_default" => ["INTERFACE"], "pointer_default_top" => ["INTERFACE"], - "depends" => ["INTERFACE"], "helper" => ["INTERFACE"], "authservice" => ["INTERFACE"], @@ -1045,10 +1044,6 @@ sub ValidInterface($) my($interface) = shift; my($data) = $interface->{DATA}; - if (has_property($interface, "depends")) { - nonfatal $interface, "depends() is pidl-specific and deprecated. Use `import' instead"; - } - if (has_property($interface, "helper")) { nonfatal $interface, "helper() is pidl-specific and deprecated. Use `include' instead"; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index bb3b36dca4..960f610cd9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -753,10 +753,6 @@ sub EjsInterface($$) pidl_hdr "#ifndef _HEADER_EJS_$interface->{NAME}\n"; pidl_hdr "#define _HEADER_EJS_$interface->{NAME}\n\n"; - if (has_property($interface, "depends")) { - EjsImport(split / /, $interface->{PROPERTIES}->{depends}); - } - pidl_hdr "\n"; foreach my $d (@{$interface->{TYPES}}) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 6a999d4147..da7d39a238 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -334,10 +334,6 @@ sub HeaderInterface($) pidl "#ifndef _HEADER_$interface->{NAME}\n"; pidl "#define _HEADER_$interface->{NAME}\n\n"; - if (defined $interface->{PROPERTIES}->{depends}) { - HeaderImport(split / /, $interface->{PROPERTIES}->{depends}); - } - foreach my $d (@{$interface->{DATA}}) { next if ($d->{TYPE} ne "CONST"); HeaderConst($d); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 80d02cb533..d871ed38bb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2258,10 +2258,6 @@ sub HeaderInterface($) pidl choose_header("librpc/gen_ndr/ndr_orpc.h", "ndr/orpc.h"); } - if (defined $interface->{PROPERTIES}->{depends}) { - HeaderImport(split / /, $interface->{PROPERTIES}->{depends}); - } - if (defined $interface->{PROPERTIES}->{helper}) { HeaderInclude(split / /, $interface->{PROPERTIES}->{helper}); } diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 7b8691e044..14b922353a 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -747,9 +747,6 @@ sub ProcessInterface($) pidl_hdr "#define $define"; pidl_hdr ""; - ProcessImport(split / /, $x->{PROPERTIES}->{depends}) if - (defined $x->{PROPERTIES}->{depends}); - pidl_def "static gint proto_dcerpc_$x->{NAME} = -1;"; register_ett("ett_dcerpc_$x->{NAME}"); register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, ""); -- cgit From f4c4e0cf7fde6c5b5cffef2e3ad4ec24bb8fb894 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Sun, 19 Nov 2006 17:56:35 +0000 Subject: r19790: Check in the PIDL change and the converted unixinfo and winbind pipes without waiting for comments. This is what version control is for, and it does fix a segfault I ran into ;-) Nevertheless, Jelmer & Jerry, please take a look! Thanks, Volker (This used to be commit 10dcaf89ed07b9d5d1c89da33b50fcaadead32b2) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 17 ++++++++------- source4/pidl/lib/Parse/Pidl/Samba4.pm | 29 ++++++++++++++++++++++--- 2 files changed, 35 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index c939feb1b9..6cfab753e9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -10,7 +10,7 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); use Parse::Pidl::Util qw(has_property ParseExpr is_constant); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba4 qw(DeclLong); +use Parse::Pidl::Samba4 qw(DeclLong_cli IsUniqueOut); use vars qw($VERSION); $VERSION = '0.01'; @@ -36,7 +36,7 @@ sub ParseFunction($$) my $ufn = "DCERPC_".uc($fn->{NAME}); foreach (@{$fn->{ELEMENTS}}) { - $defargs .= ", " . DeclLong($_); + $defargs .= ", " . DeclLong_cli($_); } fn_declare "NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"; pidl "{"; @@ -48,7 +48,12 @@ sub ParseFunction($$) foreach (@{$fn->{ELEMENTS}}) { if (grep(/in/, @{$_->{DIRECTION}})) { + if ( IsUniqueOut($_) ) { + pidl "r.in.$_->{NAME} = *$_->{NAME};"; + } + else { pidl "r.in.$_->{NAME} = $_->{NAME};"; + } } } @@ -79,12 +84,8 @@ sub ParseFunction($$) fatal($e, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); - if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") && ($e->{LEVELS}[0]->{POINTER_TYPE} eq "unique") ) { - pidl "if ( $e->{NAME} ) {"; - indent; - pidl "*$e->{NAME} = *r.out.$e->{NAME};"; - deindent; - pidl "}"; + if ( IsUniqueOut($e) ) { + pidl "*$e->{NAME} = r.out.$e->{NAME};"; } else { pidl "*$e->{NAME} = *r.out.$e->{NAME};"; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index 4ef2daa591..e11bd6a5ff 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Samba4; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(is_intree choose_header DeclLong); +@EXPORT = qw(is_intree choose_header DeclLong DeclLong_cli IsUniqueOut); use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::Typelist qw(mapType scalar_is_reference); @@ -32,9 +32,19 @@ sub choose_header($$) return "#include <$out>"; } -sub DeclLong($) +sub IsUniqueOut($) { - my($element) = shift; + my ($e) = shift; + + return grep(/out/, @{$e->{DIRECTION}}) && + ((($e->{LEVELS}[0]->{TYPE} eq "POINTER") && + ($e->{LEVELS}[0]->{POINTER_TYPE} eq "unique")) || + ($e->{LEVELS}[0]->{TYPE} eq "ARRAY")); +} + +sub DeclLong_int($$) +{ + my($element,$cli) = @_; my $ret = ""; if (has_property($element, "represent_as")) { @@ -57,6 +67,9 @@ sub DeclLong($) not has_property($element, "charset"); $numstar++; } + if ($cli && IsUniqueOut($element)) { + $numstar++; + } $ret.="*" foreach (1..$numstar); } $ret.=$element->{NAME}; @@ -68,4 +81,14 @@ sub DeclLong($) return $ret; } +sub DeclLong($) +{ + return DeclLong_int($_, 0); +} + +sub DeclLong_cli($) +{ + return DeclLong_int($_, 1); +} + 1; -- cgit From ce0c2236b953dc977655dbceef40916825e843ae Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 21 Nov 2006 23:21:08 +0000 Subject: r19830: Warn about non-ref top-level pointers. (This used to be commit 78153200ac45ce7333c91c48ded549b5eed5e077) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index a80bb954c1..d017c455a6 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -70,8 +70,6 @@ my $scalar_alignment = { 'ipv4address' => 4 }; - - sub nonfatal($$) { my ($e,$s) = @_; @@ -135,8 +133,7 @@ sub GetElementLevelTable($) $is_string = 1; delete($e->{PROPERTIES}->{string}); } else { - print "$e->{FILE}:$e->{LINE}: Must specify size_is() for conformant array!\n"; - exit 1; + fatal($e, "Must specify size_is() for conformant array!") } if (($length = shift @length_is) or $is_string) { @@ -184,6 +181,10 @@ sub GetElementLevelTable($) LEVEL => $level }); + nonfatal($e, "top-level pointer `$e->{NAME}' is not a \[ref\] pointer") + if ($i == 1 and pointer_type($e) ne "ref" and + $e->{PARENT}->{TYPE} eq "FUNCTION"); + $pointer_idx++; # everything that follows will be deferred -- cgit From 9d7d39d1809b533787ef18c023c6b01ef10a75eb Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 22 Nov 2006 13:59:14 +0000 Subject: r19834: Prevent some inaccurate warnings. (This used to be commit 21efd2bdb8df8e709259d429fc3ff35eaa332d02) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index d017c455a6..a478c15873 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -181,9 +181,10 @@ sub GetElementLevelTable($) LEVEL => $level }); - nonfatal($e, "top-level pointer `$e->{NAME}' is not a \[ref\] pointer") + nonfatal($e, "top-level \[out\] pointer `$e->{NAME}' is not a \[ref\] pointer") if ($i == 1 and pointer_type($e) ne "ref" and - $e->{PARENT}->{TYPE} eq "FUNCTION"); + $e->{PARENT}->{TYPE} eq "FUNCTION" and + not has_property($e, "in")); $pointer_idx++; -- cgit From 108152dd6aea521b1b50ecaa6a2bfe786708fe96 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 22 Nov 2006 16:53:30 +0000 Subject: r19842: Complain about unknown pointer types. Fallback to "unique" when "ptr" is specified instead of failing. (This used to be commit a1b6308b21f3c38ffd4db4643a5e307fbf32a569) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index a478c15873..f35ea461aa 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -1052,9 +1052,14 @@ sub ValidInterface($) ValidProperties($interface,"INTERFACE"); - if (has_property($interface, "pointer_default") && - $interface->{PROPERTIES}->{pointer_default} eq "ptr") { - fatal $interface, "Full pointers are not supported yet\n"; + if (has_property($interface, "pointer_default")) { + if ($interface->{PROPERTIES}->{pointer_default} eq "ptr") { + nonfatal $interface, "Full pointers are not supported yet, falling back to unique"; + $interface->{PROPERTIES}->{pointer_default} = "unique"; + } elsif (not grep (/$interface->{PROPERTIES}->{pointer_default}/, + ("ref", "unique", "ptr"))) { + fatal $interface, "Unknown default pointer type `$interface->{PROPERTIES}->{pointer_default}'"; + } } if (has_property($interface, "object")) { -- cgit From 55eaaa223800a45ee8ea3f85904f722f91547dd8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 22 Nov 2006 17:13:19 +0000 Subject: r19845: Add warning for pointer_default_top() (This used to be commit 3f0da2388d30959c93483b102fbfab75a8381fef) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index f35ea461aa..ef27c7141f 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -310,7 +310,6 @@ sub pointer_type($) return "ref" if (has_property($e, "ref")); return "ptr" if (has_property($e, "ptr")); - return "sptr" if (has_property($e, "sptr")); return "unique" if (has_property($e, "unique")); return "relative" if (has_property($e, "relative")); return "ignore" if (has_property($e, "ignore")); @@ -607,6 +606,8 @@ sub ParseInterface($) if (not has_property($idl, "pointer_default_top")) { $idl->{PROPERTIES}->{pointer_default_top} = "ref"; + } else { + nonfatal($idl, "pointer_default_top() is a pidl extension and should not be used"); } foreach my $d (@{$idl->{DATA}}) { -- cgit From 203550d0325d6f2176430ecad5c321b1f9d323b6 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 23 Nov 2006 13:11:08 +0000 Subject: r19854: readd support for 'sptr' pointers, to work against windows servers until jelmer commits his 'ptr' support metze (This used to be commit f5aa620b1bc5b0da866cbdb71947ef25a4bae0ad) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index ef27c7141f..9048a25684 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -310,6 +310,7 @@ sub pointer_type($) return "ref" if (has_property($e, "ref")); return "ptr" if (has_property($e, "ptr")); + return "sptr" if (has_property($e, "sptr")); return "unique" if (has_property($e, "unique")); return "relative" if (has_property($e, "relative")); return "ignore" if (has_property($e, "ignore")); @@ -1055,10 +1056,10 @@ sub ValidInterface($) if (has_property($interface, "pointer_default")) { if ($interface->{PROPERTIES}->{pointer_default} eq "ptr") { - nonfatal $interface, "Full pointers are not supported yet, falling back to unique"; - $interface->{PROPERTIES}->{pointer_default} = "unique"; + nonfatal $interface, "Full pointers are not supported yet, falling back to sptr"; + $interface->{PROPERTIES}->{pointer_default} = "sptr"; } elsif (not grep (/$interface->{PROPERTIES}->{pointer_default}/, - ("ref", "unique", "ptr"))) { + ("ref", "unique", "ptr", "sptr"))) { fatal $interface, "Unknown default pointer type `$interface->{PROPERTIES}->{pointer_default}'"; } } -- cgit From 128fe5324b803e0989273c7033ec0b5c8bd3dbae Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 23 Nov 2006 13:48:01 +0000 Subject: r19856: Use sptr as basis for full ptr implementation. Will add checks for duplicates later. (This used to be commit 006ab1d4a449c81680add57e0116a86b8317fbfb) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 15 +++------------ source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 6 +++--- 2 files changed, 6 insertions(+), 15 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 9048a25684..9670e05744 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -309,7 +309,7 @@ sub pointer_type($) return undef unless $e->{POINTERS}; return "ref" if (has_property($e, "ref")); - return "ptr" if (has_property($e, "ptr")); + return "full" if (has_property($e, "ptr")); return "sptr" if (has_property($e, "sptr")); return "unique" if (has_property($e, "unique")); return "relative" if (has_property($e, "relative")); @@ -789,7 +789,6 @@ my %property_list = ( # pointer "ref" => ["ELEMENT"], "ptr" => ["ELEMENT"], - "sptr" => ["ELEMENT"], "unique" => ["ELEMENT"], "ignore" => ["ELEMENT"], "relative" => ["ELEMENT"], @@ -885,10 +884,6 @@ sub ValidElement($) ValidProperties($e,"ELEMENT"); - if (has_property($e, "ptr")) { - fatal($e, el_name($e) . " : pidl does not support full NDR pointers yet\n"); - } - # Check whether switches are used correctly. if (my $switch = has_property($e, "switch_is")) { my $e2 = find_sibling($e, $switch); @@ -946,7 +941,6 @@ sub ValidElement($) if (!$e->{POINTERS} && ( has_property($e, "ptr") or - has_property($e, "sptr") or has_property($e, "unique") or has_property($e, "relative") or has_property($e, "ref"))) { @@ -1055,11 +1049,8 @@ sub ValidInterface($) ValidProperties($interface,"INTERFACE"); if (has_property($interface, "pointer_default")) { - if ($interface->{PROPERTIES}->{pointer_default} eq "ptr") { - nonfatal $interface, "Full pointers are not supported yet, falling back to sptr"; - $interface->{PROPERTIES}->{pointer_default} = "sptr"; - } elsif (not grep (/$interface->{PROPERTIES}->{pointer_default}/, - ("ref", "unique", "ptr", "sptr"))) { + if (not grep (/$interface->{PROPERTIES}->{pointer_default}/, + ("ref", "unique", "ptr"))) { fatal $interface, "Unknown default pointer type `$interface->{PROPERTIES}->{pointer_default}'"; } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index d871ed38bb..f104ffbad8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -669,8 +669,8 @@ sub ParsePtrPush($$$) pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));"; } elsif ($l->{POINTER_TYPE} eq "unique") { pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));"; - } elsif ($l->{POINTER_TYPE} eq "sptr") { - pidl "NDR_CHECK(ndr_push_sptr_ptr(ndr, $var_name));"; + } elsif ($l->{POINTER_TYPE} eq "full") { + pidl "NDR_CHECK(ndr_push_full_ptr(ndr, $var_name));"; } else { die("Unhandled pointer type $l->{POINTER_TYPE}"); } @@ -1085,7 +1085,7 @@ sub ParsePtrPull($$$$) return; } elsif (($l->{POINTER_TYPE} eq "unique") or ($l->{POINTER_TYPE} eq "relative") or - ($l->{POINTER_TYPE} eq "sptr")) { + ($l->{POINTER_TYPE} eq "full")) { pidl "NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));"; pidl "if (_ptr_$e->{NAME}) {"; indent; -- cgit From 3c20e210de357e4f7b6dd54880110a56ae1d7eb0 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 27 Dec 2006 15:36:50 +0000 Subject: r20358: - fix ejs generated code for ipv4address - (not Parse::Pidl::Typelist::scalar_is_reference($e->{TYPE})) is much more generic than ($e->{TYPE} ne "string") and handles ipv4address and other special types... metze (This used to be commit 02d2ce65e614a0c99ef3246bc738eb0f8d91b24a) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 960f610cd9..f820dbbc5a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -153,7 +153,8 @@ sub EjsPullScalar($$$$$) my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); $var = get_pointer_to($var); # have to handle strings specially :( - if ($e->{TYPE} eq "string" && $pl && $pl->{TYPE} eq "POINTER") { + if (Parse::Pidl::Typelist::scalar_is_reference($e->{TYPE}) + and (defined($pl) and $pl->{TYPE} eq "POINTER")) { $var = get_pointer_to($var); } pidl "NDR_CHECK(ejs_pull_$e->{TYPE}(ejs, v, $name, $var));"; @@ -445,7 +446,9 @@ sub EjsPushScalar($$$$$) my ($e, $l, $var, $name, $env) = @_; # have to handle strings specially :( my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); - if ($e->{TYPE} ne "string" || ($pl && $pl->{TYPE} eq "POINTER")) { + + if ((not Parse::Pidl::Typelist::scalar_is_reference($e->{TYPE})) + or (defined($pl) and $pl->{TYPE} eq "POINTER")) { $var = get_pointer_to($var); } pidl "NDR_CHECK(ejs_push_$e->{TYPE}(ejs, v, $name, $var));"; -- cgit From f97f11eab25f0c294ff02b3c4485d7a0a91b5501 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 3 Jan 2007 15:34:01 +0000 Subject: r20511: Combine warnings/errors/fatal functions and move them to Parse::Pidl. (This used to be commit 959adfd0a682a4894c3bdd4ae9c6fc3ebfeeef1f) --- source4/pidl/lib/Parse/Pidl/Compat.pm | 8 +--- source4/pidl/lib/Parse/Pidl/NDR.pm | 49 ++++++++-------------- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 3 +- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 3 +- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 2 +- .../pidl/lib/Parse/Pidl/Wireshark/Conformance.pm | 29 +++++++------ source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 27 +++++------- 7 files changed, 49 insertions(+), 72 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Compat.pm b/source4/pidl/lib/Parse/Pidl/Compat.pm index 944193ac1b..f1241ef341 100644 --- a/source4/pidl/lib/Parse/Pidl/Compat.pm +++ b/source4/pidl/lib/Parse/Pidl/Compat.pm @@ -5,6 +5,7 @@ package Parse::Pidl::Compat; +use Parse::Pidl qw(warning); use Parse::Pidl::Util qw(has_property); use strict; @@ -74,13 +75,6 @@ my %supported_properties = ( "length_is" => ["ELEMENT"], ); -sub warning($$) -{ - my ($l,$m) = @_; - - print STDERR "$l->{FILE}:$l->{LINE}:warning:$m\n"; -} - sub CheckTypedef($) { my ($td) = @_; diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 9670e05744..f8cae5665f 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -37,6 +37,7 @@ $VERSION = '0.01'; @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); use strict; +use Parse::Pidl qw(warning fatal); use Parse::Pidl::Typelist qw(hasType getType expandAlias); use Parse::Pidl::Util qw(has_property property_matches); @@ -70,20 +71,6 @@ my $scalar_alignment = { 'ipv4address' => 4 }; -sub nonfatal($$) -{ - my ($e,$s) = @_; - warn ("$e->{FILE}:$e->{LINE}: warning: $s\n"); -} - -##################################################################### -# signal a fatal validation error -sub fatal($$) -{ - my ($pos,$s) = @_; - die("$pos->{FILE}:$pos->{LINE}:$s\n"); -} - sub GetElementLevelTable($) { my $e = shift; @@ -113,7 +100,7 @@ sub GetElementLevelTable($) if (has_property($e, "string")) { $needptrs++; } if ($#bracket_array >= 0) { $needptrs = 0; } - nonfatal($e, "[out] argument `$e->{NAME}' not a pointer") if ($needptrs > $e->{POINTERS}); + warning($e, "[out] argument `$e->{NAME}' not a pointer") if ($needptrs > $e->{POINTERS}); } # Parse the [][][][] style array stuff @@ -181,7 +168,7 @@ sub GetElementLevelTable($) LEVEL => $level }); - nonfatal($e, "top-level \[out\] pointer `$e->{NAME}' is not a \[ref\] pointer") + warning($e, "top-level \[out\] pointer `$e->{NAME}' is not a \[ref\] pointer") if ($i == 1 and pointer_type($e) ne "ref" and $e->{PARENT}->{TYPE} eq "FUNCTION" and not has_property($e, "in")); @@ -256,15 +243,15 @@ sub GetElementLevelTable($) } if (scalar(@size_is) > 0) { - nonfatal($e, "size_is() on non-array element"); + warning($e, "size_is() on non-array element"); } if (scalar(@length_is) > 0) { - nonfatal($e, "length_is() on non-array element"); + warning($e, "length_is() on non-array element"); } if (has_property($e, "string")) { - nonfatal($e, "string() attribute on non-array element"); + warning($e, "string() attribute on non-array element"); } push (@$order, { @@ -608,7 +595,7 @@ sub ParseInterface($) if (not has_property($idl, "pointer_default_top")) { $idl->{PROPERTIES}->{pointer_default_top} = "ref"; } else { - nonfatal($idl, "pointer_default_top() is a pidl extension and should not be used"); + warning($idl, "pointer_default_top() is a pidl extension and should not be used"); } foreach my $d (@{$idl->{DATA}}) { @@ -850,10 +837,10 @@ sub ValidProperties($$) return unless defined $e->{PROPERTIES}; foreach my $key (keys %{$e->{PROPERTIES}}) { - fatal($e, el_name($e) . ": unknown property '$key'\n") + fatal($e, el_name($e) . ": unknown property '$key'") unless defined($property_list{$key}); - fatal($e, el_name($e) . ": property '$key' not allowed on '$t'\n") + fatal($e, el_name($e) . ": property '$key' not allowed on '$t'") unless grep($t, @{$property_list{$key}}); } } @@ -909,7 +896,7 @@ sub ValidElement($) } if ($t1 ne $t2) { - nonfatal($e, el_name($e) . ": switch_is() is of type $e2->{TYPE} ($t2), while discriminator type for union $type->{NAME} is $discriminator_type ($t1)"); + warning($e, el_name($e) . ": switch_is() is of type $e2->{TYPE} ($t2), while discriminator type for union $type->{NAME} is $discriminator_type ($t1)"); } } } @@ -979,12 +966,12 @@ sub ValidUnion($) if (defined($e->{PROPERTIES}->{default}) and defined($e->{PROPERTIES}->{case})) { - fatal $e, "Union member $e->{NAME} can not have both default and case properties!\n"; + fatal($e, "Union member $e->{NAME} can not have both default and case properties!"); } unless (defined ($e->{PROPERTIES}->{default}) or defined ($e->{PROPERTIES}->{case})) { - fatal $e, "Union member $e->{NAME} must have default or case property\n"; + fatal($e, "Union member $e->{NAME} must have default or case property"); } if (has_property($e, "ref")) { @@ -1029,7 +1016,7 @@ sub ValidFunction($) foreach my $e (@{$fn->{ELEMENTS}}) { $e->{PARENT} = $fn; if (has_property($e, "ref") && !$e->{POINTERS}) { - fatal $e, "[ref] variables must be pointers ($fn->{NAME}/$e->{NAME})\n"; + fatal($e, "[ref] variables must be pointers ($fn->{NAME}/$e->{NAME})"); } ValidElement($e); } @@ -1043,7 +1030,7 @@ sub ValidInterface($) my($data) = $interface->{DATA}; if (has_property($interface, "helper")) { - nonfatal $interface, "helper() is pidl-specific and deprecated. Use `include' instead"; + warning($interface, "helper() is pidl-specific and deprecated. Use `include' instead"); } ValidProperties($interface,"INTERFACE"); @@ -1051,19 +1038,19 @@ sub ValidInterface($) if (has_property($interface, "pointer_default")) { if (not grep (/$interface->{PROPERTIES}->{pointer_default}/, ("ref", "unique", "ptr"))) { - fatal $interface, "Unknown default pointer type `$interface->{PROPERTIES}->{pointer_default}'"; + fatal($interface, "Unknown default pointer type `$interface->{PROPERTIES}->{pointer_default}'"); } } if (has_property($interface, "object")) { if (has_property($interface, "version") && $interface->{PROPERTIES}->{version} != 0) { - fatal $interface, "Object interfaces must have version 0.0 ($interface->{NAME})\n"; + fatal($interface, "Object interfaces must have version 0.0 ($interface->{NAME})"); } if (!defined($interface->{BASE}) && not ($interface->{NAME} eq "IUnknown")) { - fatal $interface, "Object interfaces must all derive from IUnknown ($interface->{NAME})\n"; + fatal($interface, "Object interfaces must all derive from IUnknown ($interface->{NAME})"); } } @@ -1086,7 +1073,7 @@ sub Validate($) ($x->{TYPE} eq "INTERFACE") && ValidInterface($x); ($x->{TYPE} eq "IMPORTLIB") && - nonfatal($x, "importlib() not supported"); + warning($x, "importlib() not supported"); } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 6cfab753e9..5c88e3d22f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -7,6 +7,7 @@ package Parse::Pidl::Samba3::ClientNDR; use strict; +use Parse::Pidl qw(fatal warning); use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); use Parse::Pidl::Util qw(has_property ParseExpr is_constant); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); @@ -22,8 +23,6 @@ sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $res .= $tabs.(shift)."\n"; } sub pidl_hdr($) { $res_hdr .= (shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } -sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } sub ParseFunction($$) diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index a7c81e4e2b..8d42b483ec 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -7,6 +7,7 @@ package Parse::Pidl::Samba3::ServerNDR; use strict; +use Parse::Pidl qw(warning fatal); use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); use Parse::Pidl::Util qw(has_property ParseExpr is_constant); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); @@ -22,8 +23,6 @@ sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $res .= $tabs.(shift)."\n"; } sub pidl_hdr($) { $res_hdr .= (shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } -sub warning($$) { my ($e,$s) = @_; warn("$e->{ORIGINAL}->{FILE}:$e->{ORIGINAL}->{LINE}: $s\n"); } sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } sub AllocOutVar($$$$) diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index 592961dee2..bc8d27a283 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -4,6 +4,7 @@ # released under the GNU GPL package Parse::Pidl::Samba4::TDR; +use Parse::Pidl qw(fatal); use Parse::Pidl::Util qw(has_property ParseExpr is_constant); use Parse::Pidl::Samba4 qw(is_intree choose_header); @@ -20,7 +21,6 @@ sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } sub pidl($) { $ret .= $tabs.(shift)."\n"; } sub pidl_hdr($) { $ret_hdr .= (shift)."\n"; } -sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); } sub typearg($) { my $t = shift; return(", const char *name") if ($t eq "print"); diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm index 163b3053f4..4ad60319a6 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm @@ -100,6 +100,7 @@ $VERSION = '0.01'; use strict; +use Parse::Pidl qw(fatal warning error); use Parse::Pidl::Util qw(has_property); sub handle_type($$$$$$$$$$) @@ -107,20 +108,20 @@ sub handle_type($$$$$$$$$$) my ($pos,$data,$name,$dissectorname,$ft_type,$base_type,$mask,$valsstring,$alignment) = @_; unless(defined($alignment)) { - print "$pos: error incomplete TYPE command\n"; + error($pos, "incomplete TYPE command"); return; } unless ($dissectorname =~ /.*dissect_.*/) { - print "$pos: warning: dissector name does not contain `dissect'\n"; + warning($pos, "dissector name does not contain `dissect'"); } unless(valid_ft_type($ft_type)) { - print "$pos: warning: invalid FT_TYPE `$ft_type'\n"; + warning($pos, "invalid FT_TYPE `$ft_type'"); } unless (valid_base_type($base_type)) { - print "$pos: warning: invalid BASE_TYPE `$base_type'\n"; + warning($pos, "invalid BASE_TYPE `$base_type'"); } $data->{types}->{$name} = { @@ -141,7 +142,7 @@ sub handle_tfs($$$$$) my ($pos,$data,$hf,$trues,$falses) = @_; unless(defined($falses)) { - print "$pos: error: incomplete TFS command\n"; + error($pos, "incomplete TFS command"); return; } @@ -156,7 +157,7 @@ sub handle_hf_rename($$$$) my ($pos,$data,$old,$new) = @_; unless(defined($new)) { - print "$pos: error: incomplete HF_RENAME command\n"; + error($pos, "incomplete HF_RENAME command"); return; } @@ -173,7 +174,7 @@ sub handle_param_value($$$$) my ($pos,$data,$dissector_name,$value) = @_; unless(defined($value)) { - print "$pos: error: incomplete PARAM_VALUE command\n"; + error($pos, "incomplete PARAM_VALUE command"); return; } @@ -204,16 +205,16 @@ sub handle_hf_field($$$$$$$$$$) my ($pos,$data,$index,$name,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; unless(defined($blurb)) { - print "$pos: error: incomplete HF_FIELD command\n"; + error($pos, "incomplete HF_FIELD command"); return; } unless(valid_ft_type($ft_type)) { - print "$pos: warning: invalid FT_TYPE `$ft_type'\n"; + warning($pos, "invalid FT_TYPE `$ft_type'"); } unless(valid_base_type($base_type)) { - print "$pos: warning: invalid BASE_TYPE `$base_type'\n"; + warning($pos, "invalid BASE_TYPE `$base_type'"); } $data->{header_fields}->{$index} = { @@ -284,7 +285,7 @@ sub handle_import my $dissectorname = shift @_; unless(defined($dissectorname)) { - print "$pos: error: no dissectorname specified\n"; + error($pos, "no dissectorname specified"); return; } @@ -346,12 +347,14 @@ sub ReadConformance($$) shift @fields; + my $pos = { FILE => $f, LINE => $ln }; + if (not defined($field_handlers{$cmd})) { - print "$f:$ln: warning: Unknown command `$cmd'\n"; + warning($pos, "Unknown command `$cmd'"); next; } - $field_handlers{$cmd}("$f:$ln", $data, @fields); + $field_handlers{$cmd}($pos, $data, @fields); } close(IN); diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 14b922353a..9526d76a37 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -17,6 +17,7 @@ Parse::Pidl::Wireshark::NDR - Parser generator for Wireshark package Parse::Pidl::Wireshark::NDR; use strict; +use Parse::Pidl qw(error); use Parse::Pidl::Typelist qw(getType); use Parse::Pidl::Util qw(has_property ParseExpr property_matches make_str); use Parse::Pidl::NDR qw(ContainsString GetNextLevel); @@ -27,12 +28,6 @@ use File::Basename; use vars qw($VERSION); $VERSION = '0.01'; -sub error($$) -{ - my ($e,$t) = @_; - print "$e->{FILE}:$e->{LINE}: $t\n"; -} - my @ett; my %hf_used = (); @@ -441,10 +436,10 @@ sub Function($$$) } elsif ($type->{DATA}->{TYPE} eq "SCALAR") { pidl_code "g$fn->{RETURN_TYPE} status;\n"; } else { - print "$fn->{FILE}:$fn->{LINE}: error: return type `$fn->{RETURN_TYPE}' not yet supported\n"; + error($fn, "return type `$fn->{RETURN_TYPE}' not yet supported"); } } else { - print "$fn->{FILE}:$fn->{LINE}: error: unknown return type `$fn->{RETURN_TYPE}'\n"; + error($fn, "unknown return type `$fn->{RETURN_TYPE}'"); } foreach (@{$fn->{ELEMENTS}}) { @@ -828,7 +823,7 @@ sub Initialize($) header_fields=> {} }; - ReadConformance($cnf_file, $conformance) or print "Warning: No conformance file `$cnf_file'\n"; + ReadConformance($cnf_file, $conformance) or print STDERR "warning: No conformance file `$cnf_file'\n"; foreach my $bytes (qw(1 2 4 8)) { my $bits = $bytes * 8; @@ -1054,43 +1049,43 @@ sub CheckUsed($) my $conformance = shift; foreach (values %{$conformance->{header_fields}}) { if (not defined($hf_used{$_->{INDEX}})) { - print "$_->{POS}: warning: hf field `$_->{INDEX}' not used\n"; + warning($_->{POS}, "hf field `$_->{INDEX}' not used"); } } foreach (values %{$conformance->{hf_renames}}) { if (not $_->{USED}) { - print "$_->{POS}: warning: hf field `$_->{OLDNAME}' not used\n"; + warning($_->{POS}, "hf field `$_->{OLDNAME}' not used"); } } foreach (values %{$conformance->{dissectorparams}}) { if (not $_->{USED}) { - print "$_->{POS}: warning: dissector param never used\n"; + warning($_->{POS}, "dissector param never used"); } } foreach (values %{$conformance->{imports}}) { if (not $_->{USED}) { - print "$_->{POS}: warning: import never used\n"; + warning($_->{POS}, "import never used"); } } foreach (values %{$conformance->{types}}) { if (not $_->{USED} and defined($_->{POS})) { - print "$_->{POS}: warning: type never used\n"; + warning($_->{POS}, "type never used"); } } foreach (values %{$conformance->{fielddescription}}) { if (not $_->{USED}) { - print "$_->{POS}: warning: description never used\n"; + warning($_->{POS}, "description never used"); } } foreach (values %{$conformance->{tfs}}) { if (not $_->{USED}) { - print "$_->{POS}: warning: True/False description never used\n"; + warning($_->{POS}, "True/False description never used"); } } } -- cgit From 362d4b14aecb32aac5c7c4f6beb3b9a979bf9d5a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 5 Jan 2007 12:56:15 +0000 Subject: r20543: Merge some pidl bug fixes: * C expressions that just started with a constant were erroneously flagged as being a constant. * 1-length variable names in expressions were broken. (This used to be commit 44775a6ac456247fe7ab4da75498bb550c74c854) --- source4/pidl/lib/Parse/Pidl/Util.pm | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index ff615a21ba..f1a97693a7 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -26,12 +26,9 @@ sub MyDumper($) # see if a pidl property list contains a given property sub has_property($$) { - my($e) = shift; - my($p) = shift; + my($e, $p) = @_; - if (!defined $e->{PROPERTIES}) { - return undef; - } + return undef if (not defined($e->{PROPERTIES})); return $e->{PROPERTIES}->{$p}; } @@ -40,9 +37,7 @@ sub has_property($$) # see if a pidl property matches a value sub property_matches($$$) { - my($e) = shift; - my($p) = shift; - my($v) = shift; + my($e,$p,$v) = @_; if (!defined has_property($e, $p)) { return undef; @@ -59,7 +54,7 @@ sub property_matches($$$) sub is_constant($) { my $s = shift; - if (defined $s && $s =~ /^\d/) { + if (defined $s && $s =~ /^\d$/) { return 1; } return 0; @@ -72,7 +67,7 @@ sub make_str($) if (substr($str, 0, 1) eq "\"") { return $str; } - return "\"" . $str . "\""; + return "\"$str\""; } sub print_uuid($) @@ -80,6 +75,7 @@ sub print_uuid($) my ($uuid) = @_; $uuid =~ s/"//g; my ($time_low,$time_mid,$time_hi,$clock_seq,$node) = split /-/, $uuid; + return undef if not defined($node); my @clock_seq = $clock_seq =~ /(..)/g; my @node = $node =~ /(..)/g; @@ -106,7 +102,7 @@ sub ParseExpr($$) die("Undefined value in ParseExpr") if not defined($expr); - my @tokens = split /((?:[A-Za-z_])(?:(?:(?:[A-Za-z0-9_.])|(?:->))+))/, $expr; + my @tokens = split /((?:[A-Za-z_])(?:(?:(?:[A-Za-z0-9_.])|(?:->))+)?)/, $expr; my $ret = ""; foreach my $t (@tokens) { -- cgit From 306dc32687e68dbf388187ec927444fb4a139158 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 5 Jan 2007 14:25:21 +0000 Subject: r20545: Fix is_constant(). (This used to be commit ae9b0895e8b7fd98335ece82aae3e391b94d2ec9) --- source4/pidl/lib/Parse/Pidl/Util.pm | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index f1a97693a7..064862b7c5 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -54,9 +54,8 @@ sub property_matches($$$) sub is_constant($) { my $s = shift; - if (defined $s && $s =~ /^\d$/) { - return 1; - } + return 1 if (defined $s && $s =~ /^\d+$/); + return 1 if (defined $s && $s =~ /^0x[0-9A-Fa-f]+$/); return 0; } -- cgit From e2b62f7d4168b5900dbaeadf4d4061abf6c1bd7c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 5 Jan 2007 15:20:23 +0000 Subject: r20550: Use standard error mechanism in parser. Make sure errors are reported correctly. (This used to be commit 9f794c55a60b09536d6e0dbadfc172e1e74497ff) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 192 ++++++++++++++++++------------------- 1 file changed, 96 insertions(+), 96 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 85c5b8b828..7c4263fd11 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -2288,88 +2288,88 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "pidl/idl.yp" +#line 19 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "pidl/idl.yp" +#line 20 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'idl', 2, sub -#line 21 "pidl/idl.yp" +#line 21 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 5 'idl', 2, sub -#line 22 "pidl/idl.yp" +#line 22 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 6 'idl', 2, sub -#line 23 "pidl/idl.yp" +#line 23 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'import', 3, sub -#line 26 "pidl/idl.yp" +#line 26 "idl.yp" {{ "TYPE" => "IMPORT", "PATHS" => $_[2], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE} }} ], [#Rule 8 'include', 3, sub -#line 33 "pidl/idl.yp" +#line 33 "idl.yp" {{ "TYPE" => "INCLUDE", "PATHS" => $_[2], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE} }} ], [#Rule 9 'importlib', 3, sub -#line 40 "pidl/idl.yp" +#line 40 "idl.yp" {{ "TYPE" => "IMPORTLIB", "PATHS" => $_[2], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE} }} ], [#Rule 10 'commalist', 1, sub -#line 49 "pidl/idl.yp" +#line 49 "idl.yp" { [ $_[1] ] } ], [#Rule 11 'commalist', 3, sub -#line 50 "pidl/idl.yp" +#line 50 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 12 'coclass', 7, sub -#line 54 "pidl/idl.yp" +#line 54 "idl.yp" {{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], "NAME" => $_[3], "DATA" => $_[5], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} ], @@ -2379,20 +2379,20 @@ sub [#Rule 14 'interface_names', 4, sub -#line 66 "pidl/idl.yp" +#line 66 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 15 'interface', 8, sub -#line 70 "pidl/idl.yp" +#line 70 "idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], "NAME" => $_[3], "BASE" => $_[4], "DATA" => $_[6], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} ], @@ -2402,19 +2402,19 @@ sub [#Rule 17 'base_interface', 2, sub -#line 83 "pidl/idl.yp" +#line 83 "idl.yp" { $_[2] } ], [#Rule 18 'definitions', 1, sub -#line 87 "pidl/idl.yp" +#line 87 "idl.yp" { [ $_[1] ] } ], [#Rule 19 'definitions', 2, sub -#line 88 "pidl/idl.yp" +#line 88 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 20 @@ -2435,21 +2435,21 @@ sub [#Rule 25 'const', 7, sub -#line 96 "pidl/idl.yp" +#line 96 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], "POINTERS" => $_[3], "NAME" => $_[4], "VALUE" => $_[6], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} ], [#Rule 26 'const', 8, sub -#line 106 "pidl/idl.yp" +#line 106 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -2457,34 +2457,34 @@ sub "NAME" => $_[4], "ARRAY_LEN" => $_[5], "VALUE" => $_[7], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} ], [#Rule 27 'function', 7, sub -#line 120 "pidl/idl.yp" +#line 120 "idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], "RETURN_TYPE" => $_[2], "PROPERTIES" => $_[1], "ELEMENTS" => $_[5], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} ], [#Rule 28 'declare', 5, sub -#line 132 "pidl/idl.yp" +#line 132 "idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], "NAME" => $_[4], "DATA" => $_[3], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} ], @@ -2500,7 +2500,7 @@ sub [#Rule 32 'decl_enum', 1, sub -#line 146 "pidl/idl.yp" +#line 146 "idl.yp" {{ "TYPE" => "ENUM" }} @@ -2508,7 +2508,7 @@ sub [#Rule 33 'decl_bitmap', 1, sub -#line 152 "pidl/idl.yp" +#line 152 "idl.yp" {{ "TYPE" => "BITMAP" }} @@ -2516,7 +2516,7 @@ sub [#Rule 34 'decl_union', 1, sub -#line 158 "pidl/idl.yp" +#line 158 "idl.yp" {{ "TYPE" => "UNION" }} @@ -2524,14 +2524,14 @@ sub [#Rule 35 'typedef', 6, sub -#line 164 "pidl/idl.yp" +#line 164 "idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], "NAME" => $_[4], "DATA" => $_[3], "ARRAY_LEN" => $_[5], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} ], @@ -2550,7 +2550,7 @@ sub [#Rule 40 'typedecl', 2, sub -#line 177 "pidl/idl.yp" +#line 177 "idl.yp" { $_[1] } ], [#Rule 41 @@ -2565,7 +2565,7 @@ sub [#Rule 44 'existingtype', 2, sub -#line 182 "pidl/idl.yp" +#line 182 "idl.yp" { "$_[1] $_[2]" } ], [#Rule 45 @@ -2580,13 +2580,13 @@ sub [#Rule 48 'type', 1, sub -#line 186 "pidl/idl.yp" +#line 186 "idl.yp" { "void" } ], [#Rule 49 'enum_body', 3, sub -#line 188 "pidl/idl.yp" +#line 188 "idl.yp" { $_[2] } ], [#Rule 50 @@ -2598,7 +2598,7 @@ sub [#Rule 52 'enum', 3, sub -#line 191 "pidl/idl.yp" +#line 191 "idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], @@ -2608,13 +2608,13 @@ sub [#Rule 53 'enum_elements', 1, sub -#line 199 "pidl/idl.yp" +#line 199 "idl.yp" { [ $_[1] ] } ], [#Rule 54 'enum_elements', 3, sub -#line 200 "pidl/idl.yp" +#line 200 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 55 @@ -2623,13 +2623,13 @@ sub [#Rule 56 'enum_element', 3, sub -#line 204 "pidl/idl.yp" +#line 204 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 57 'bitmap_body', 3, sub -#line 207 "pidl/idl.yp" +#line 207 "idl.yp" { $_[2] } ], [#Rule 58 @@ -2641,7 +2641,7 @@ sub [#Rule 60 'bitmap', 3, sub -#line 210 "pidl/idl.yp" +#line 210 "idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], @@ -2651,13 +2651,13 @@ sub [#Rule 61 'bitmap_elements', 1, sub -#line 218 "pidl/idl.yp" +#line 218 "idl.yp" { [ $_[1] ] } ], [#Rule 62 'bitmap_elements', 3, sub -#line 219 "pidl/idl.yp" +#line 219 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 63 @@ -2669,13 +2669,13 @@ sub [#Rule 65 'bitmap_element', 3, sub -#line 224 "pidl/idl.yp" +#line 224 "idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 66 'struct_body', 3, sub -#line 227 "pidl/idl.yp" +#line 227 "idl.yp" { $_[2] } ], [#Rule 67 @@ -2687,7 +2687,7 @@ sub [#Rule 69 'struct', 3, sub -#line 231 "pidl/idl.yp" +#line 231 "idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], @@ -2697,14 +2697,14 @@ sub [#Rule 70 'empty_element', 2, sub -#line 239 "pidl/idl.yp" +#line 239 "idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", "PROPERTIES" => $_[1], "POINTERS" => 0, "ARRAY_LEN" => [], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} ], @@ -2717,7 +2717,7 @@ sub [#Rule 73 'optional_base_element', 2, sub -#line 253 "pidl/idl.yp" +#line 253 "idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 74 @@ -2726,13 +2726,13 @@ sub [#Rule 75 'union_elements', 2, sub -#line 258 "pidl/idl.yp" +#line 258 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 76 'union_body', 3, sub -#line 261 "pidl/idl.yp" +#line 261 "idl.yp" { $_[2] } ], [#Rule 77 @@ -2744,7 +2744,7 @@ sub [#Rule 79 'union', 3, sub -#line 265 "pidl/idl.yp" +#line 265 "idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], @@ -2754,27 +2754,27 @@ sub [#Rule 80 'base_element', 5, sub -#line 273 "pidl/idl.yp" +#line 273 "idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], "PROPERTIES" => $_[1], "POINTERS" => $_[3], "ARRAY_LEN" => $_[5], - "FILE" => $_[0]->YYData->{INPUT_FILENAME}, + "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} ], [#Rule 81 'pointers', 0, sub -#line 287 "pidl/idl.yp" +#line 287 "idl.yp" { 0 } ], [#Rule 82 'pointers', 2, sub -#line 288 "pidl/idl.yp" +#line 288 "idl.yp" { $_[1]+1 } ], [#Rule 83 @@ -2783,7 +2783,7 @@ sub [#Rule 84 'element_list1', 3, sub -#line 293 "pidl/idl.yp" +#line 293 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 85 @@ -2795,13 +2795,13 @@ sub [#Rule 87 'element_list2', 1, sub -#line 299 "pidl/idl.yp" +#line 299 "idl.yp" { [ $_[1] ] } ], [#Rule 88 'element_list2', 3, sub -#line 300 "pidl/idl.yp" +#line 300 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 89 @@ -2810,13 +2810,13 @@ sub [#Rule 90 'array_len', 3, sub -#line 305 "pidl/idl.yp" +#line 305 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 91 'array_len', 4, sub -#line 306 "pidl/idl.yp" +#line 306 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 92 @@ -2825,31 +2825,31 @@ sub [#Rule 93 'property_list', 4, sub -#line 312 "pidl/idl.yp" +#line 312 "idl.yp" { FlattenHash([$_[1],$_[3]]); } ], [#Rule 94 'properties', 1, sub -#line 315 "pidl/idl.yp" +#line 315 "idl.yp" { $_[1] } ], [#Rule 95 'properties', 3, sub -#line 316 "pidl/idl.yp" +#line 316 "idl.yp" { FlattenHash([$_[1], $_[3]]); } ], [#Rule 96 'property', 1, sub -#line 319 "pidl/idl.yp" +#line 319 "idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 97 'property', 4, sub -#line 320 "pidl/idl.yp" +#line 320 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 98 @@ -2858,7 +2858,7 @@ sub [#Rule 99 'listtext', 3, sub -#line 325 "pidl/idl.yp" +#line 325 "idl.yp" { "$_[1] $_[3]" } ], [#Rule 100 @@ -2867,13 +2867,13 @@ sub [#Rule 101 'commalisttext', 3, sub -#line 330 "pidl/idl.yp" +#line 330 "idl.yp" { "$_[1],$_[3]" } ], [#Rule 102 'anytext', 0, sub -#line 334 "pidl/idl.yp" +#line 334 "idl.yp" { "" } ], [#Rule 103 @@ -2888,91 +2888,91 @@ sub [#Rule 106 'anytext', 3, sub -#line 336 "pidl/idl.yp" +#line 336 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 337 "pidl/idl.yp" +#line 337 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 'anytext', 3, sub -#line 338 "pidl/idl.yp" +#line 338 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 109 'anytext', 3, sub -#line 339 "pidl/idl.yp" +#line 339 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 110 'anytext', 3, sub -#line 340 "pidl/idl.yp" +#line 340 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 111 'anytext', 3, sub -#line 341 "pidl/idl.yp" +#line 341 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 112 'anytext', 3, sub -#line 342 "pidl/idl.yp" +#line 342 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 113 'anytext', 3, sub -#line 343 "pidl/idl.yp" +#line 343 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 114 'anytext', 3, sub -#line 344 "pidl/idl.yp" +#line 344 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 115 'anytext', 3, sub -#line 345 "pidl/idl.yp" +#line 345 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 116 'anytext', 3, sub -#line 346 "pidl/idl.yp" +#line 346 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 117 'anytext', 3, sub -#line 347 "pidl/idl.yp" +#line 347 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 118 'anytext', 3, sub -#line 348 "pidl/idl.yp" +#line 348 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 119 'anytext', 5, sub -#line 349 "pidl/idl.yp" +#line 349 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 120 'anytext', 5, sub -#line 350 "pidl/idl.yp" +#line 350 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 121 @@ -2990,7 +2990,7 @@ sub [#Rule 125 'text', 1, sub -#line 364 "pidl/idl.yp" +#line 364 "idl.yp" { "\"$_[1]\"" } ], [#Rule 126 @@ -3004,9 +3004,11 @@ sub bless($self,$class); } -#line 375 "pidl/idl.yp" +#line 375 "idl.yp" +use Parse::Pidl qw(error); + ##################################################################### # flatten an array of hashes into a single hash sub FlattenHash($) @@ -3053,15 +3055,13 @@ sub CleanData($) sub _Error { if (exists $_[0]->YYData->{ERRMSG}) { - print $_[0]->YYData->{ERRMSG}; + error($_[0]->YYData, $_[0]->YYData->{ERRMSG}); delete $_[0]->YYData->{ERRMSG}; return; }; - my $line = $_[0]->YYData->{LINE}; my $last_token = $_[0]->YYData->{LAST_TOKEN}; - my $file = $_[0]->YYData->{INPUT_FILENAME}; - print "$file:$line: Syntax error near '$last_token'\n"; + error($_[0]->YYData, "Syntax error near '$last_token'"); } sub _Lexer($) @@ -3077,12 +3077,12 @@ again: if (/^\#/) { if (s/^\# (\d+) \"(.*?)\"( \d+|)//) { $parser->YYData->{LINE} = $1-1; - $parser->YYData->{INPUT_FILENAME} = $2; + $parser->YYData->{FILE} = $2; goto again; } if (s/^\#line (\d+) \"(.*?)\"( \d+|)//) { $parser->YYData->{LINE} = $1-1; - $parser->YYData->{INPUT_FILENAME} = $2; + $parser->YYData->{FILE} = $2; goto again; } if (s/^(\#.*)$//m) { @@ -3124,7 +3124,7 @@ sub parse_string my $self = new Parse::Pidl::IDL; - $self->YYData->{INPUT_FILENAME} = $filename; + $self->YYData->{FILE} = $filename; $self->YYData->{INPUT} = $data; $self->YYData->{LINE} = 0; $self->YYData->{LAST_TOKEN} = "NONE"; -- cgit From 3c7a84a2055dde0953a240ce5b03c943f4f2d8f1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 5 Jan 2007 20:12:21 +0000 Subject: r20561: Add parser for subexpressions used in IDL attributes. (This used to be commit 7e7fdb01d3fba449f33b7b67ba0e3a0089dd3902) --- source4/pidl/lib/Parse/Pidl/Expr.pm | 1357 +++++++++++++++++++++++++++++++++++ 1 file changed, 1357 insertions(+) create mode 100644 source4/pidl/lib/Parse/Pidl/Expr.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Expr.pm b/source4/pidl/lib/Parse/Pidl/Expr.pm new file mode 100644 index 0000000000..1d663e1668 --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Expr.pm @@ -0,0 +1,1357 @@ +#################################################################### +# +# This file was generated using Parse::Yapp version 1.05. +# +# Don't edit this file, use source file instead. +# +# ANY CHANGE MADE HERE WILL BE LOST ! +# +#################################################################### +package Parse::Pidl::Expr; +use vars qw ( @ISA ); +use strict; + +@ISA= qw ( Parse::Yapp::Driver ); +use Parse::Yapp::Driver; + + + +sub new { + my($class)=shift; + ref($class) + and $class=ref($class); + + my($self)=$class->SUPER::new( yyversion => '1.05', + yystates => +[ + {#State 0 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'NUM' => 5, + 'TEXT' => 6, + "(" => 7, + "!" => 8, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 2, + 'func' => 11 + } + }, + {#State 1 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "(" => 7, + "!" => 8, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 12, + 'func' => 11 + } + }, + {#State 2 + ACTIONS => { + '' => 14, + "-" => 13, + "<" => 15, + "+" => 16, + "%" => 17, + "==" => 18, + "^" => 19, + "*" => 20, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "/" => 27, + "->" => 28, + "|" => 29, + "<<" => 31, + "=>" => 30, + "<=" => 33, + "." => 32, + ">" => 34 + } + }, + {#State 3 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 35, + 'func' => 11 + } + }, + {#State 4 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 36, + 'func' => 11 + } + }, + {#State 5 + DEFAULT => -1 + }, + {#State 6 + DEFAULT => -2 + }, + {#State 7 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 37, + 'func' => 11 + } + }, + {#State 8 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 38, + 'func' => 11 + } + }, + {#State 9 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 39, + 'func' => 11 + } + }, + {#State 10 + ACTIONS => { + "(" => 40 + }, + DEFAULT => -5 + }, + {#State 11 + DEFAULT => -3 + }, + {#State 12 + ACTIONS => { + "^" => 19, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -29 + }, + {#State 13 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 41, + 'func' => 11 + } + }, + {#State 14 + DEFAULT => 0 + }, + {#State 15 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 42, + 'func' => 11 + } + }, + {#State 16 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 43, + 'func' => 11 + } + }, + {#State 17 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 44, + 'func' => 11 + } + }, + {#State 18 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 45, + 'func' => 11 + } + }, + {#State 19 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 46, + 'func' => 11 + } + }, + {#State 20 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 47, + 'func' => 11 + } + }, + {#State 21 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 48, + 'func' => 11 + } + }, + {#State 22 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 49, + 'func' => 11 + } + }, + {#State 23 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 50, + 'func' => 11 + } + }, + {#State 24 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 51, + 'func' => 11 + } + }, + {#State 25 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 52, + 'func' => 11 + } + }, + {#State 26 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 53, + 'func' => 11 + } + }, + {#State 27 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 54, + 'func' => 11 + } + }, + {#State 28 + ACTIONS => { + 'VAR' => 55 + } + }, + {#State 29 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 56, + 'func' => 11 + } + }, + {#State 30 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 57, + 'func' => 11 + } + }, + {#State 31 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 58, + 'func' => 11 + } + }, + {#State 32 + ACTIONS => { + 'VAR' => 59 + } + }, + {#State 33 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 60, + 'func' => 11 + } + }, + {#State 34 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 61, + 'func' => 11 + } + }, + {#State 35 + ACTIONS => { + "^" => 19, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -7 + }, + {#State 36 + ACTIONS => { + "^" => 19, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -30 + }, + {#State 37 + ACTIONS => { + "-" => 13, + "<" => 15, + "+" => 16, + "%" => 17, + "==" => 18, + "^" => 19, + "*" => 20, + ")" => 62, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "/" => 27, + "->" => 28, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + } + }, + {#State 38 + ACTIONS => { + "-" => 13, + "<" => 15, + "+" => 16, + "%" => 17, + "==" => 18, + "^" => 19, + "*" => 20, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "/" => 27, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -27 + }, + {#State 39 + ACTIONS => { + "^" => 19, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -6 + }, + {#State 40 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + DEFAULT => -34, + GOTOS => { + 'exp' => 64, + 'args' => 63, + 'func' => 11, + 'opt_args' => 65 + } + }, + {#State 41 + ACTIONS => { + "<" => 15, + "==" => 18, + "^" => 19, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -9 + }, + {#State 42 + ACTIONS => { + "==" => 18, + "^" => 19, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -12 + }, + {#State 43 + ACTIONS => { + "<" => 15, + "==" => 18, + "^" => 19, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -8 + }, + {#State 44 + ACTIONS => { + "-" => 13, + "<" => 15, + "+" => 16, + "==" => 18, + "^" => 19, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -11 + }, + {#State 45 + ACTIONS => { + "^" => 19, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -15 + }, + {#State 46 + ACTIONS => { + "-" => 13, + "<" => 15, + "+" => 16, + "%" => 17, + "==" => 18, + "^" => 19, + "*" => 20, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "/" => 27, + "->" => 28, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -31 + }, + {#State 47 + ACTIONS => { + "-" => 13, + "<" => 15, + "+" => 16, + "==" => 18, + "^" => 19, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -10 + }, + {#State 48 + ACTIONS => { + "<" => 15, + "==" => 18, + "^" => 19, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -19 + }, + {#State 49 + ACTIONS => { + "^" => 19, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -20 + }, + {#State 50 + ACTIONS => { + ":" => 66, + "-" => 13, + "<" => 15, + "+" => 16, + "%" => 17, + "==" => 18, + "^" => 19, + "*" => 20, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "/" => 27, + "->" => 28, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + } + }, + {#State 51 + ACTIONS => { + "^" => 19, + "?" => 23, + "||" => 25, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -22 + }, + {#State 52 + ACTIONS => { + "^" => 19, + "?" => 23, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -21 + }, + {#State 53 + ACTIONS => { + "^" => 19, + "?" => 23, + "&&" => 24, + "||" => 25, + "|" => 29, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -23 + }, + {#State 54 + ACTIONS => { + "-" => 13, + "<" => 15, + "+" => 16, + "==" => 18, + "^" => 19, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -28 + }, + {#State 55 + DEFAULT => -24 + }, + {#State 56 + ACTIONS => { + "^" => 19, + "?" => 23, + "&&" => 24, + "||" => 25, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -14 + }, + {#State 57 + ACTIONS => { + "-" => 13, + "<" => 15, + "+" => 16, + "%" => 17, + "==" => 18, + "^" => 19, + "*" => 20, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "/" => 27, + "->" => 28, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -17 + }, + {#State 58 + ACTIONS => { + "<" => 15, + "==" => 18, + "^" => 19, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -18 + }, + {#State 59 + DEFAULT => -4 + }, + {#State 60 + ACTIONS => { + "-" => 13, + "<" => 15, + "+" => 16, + "%" => 17, + "==" => 18, + "^" => 19, + "*" => 20, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "/" => 27, + "->" => 28, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -16 + }, + {#State 61 + ACTIONS => { + "==" => 18, + "^" => 19, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "|" => 29, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -13 + }, + {#State 62 + DEFAULT => -32 + }, + {#State 63 + DEFAULT => -35 + }, + {#State 64 + ACTIONS => { + "-" => 13, + "<" => 15, + "+" => 16, + "%" => 17, + "," => 67, + "==" => 18, + "^" => 19, + "*" => 20, + ">>" => 21, + "!=" => 22, + "?" => 23, + "&&" => 24, + "||" => 25, + "&" => 26, + "->" => 28, + "/" => 27, + "|" => 29, + "=>" => 30, + "<<" => 31, + "." => 32, + "<=" => 33, + ">" => 34 + }, + DEFAULT => -36 + }, + {#State 65 + ACTIONS => { + ")" => 68 + } + }, + {#State 66 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 69, + 'func' => 11 + } + }, + {#State 67 + ACTIONS => { + "-" => 1, + "~" => 3, + "&" => 4, + 'TEXT' => 6, + 'NUM' => 5, + "!" => 8, + "(" => 7, + "*" => 9, + 'VAR' => 10 + }, + GOTOS => { + 'exp' => 64, + 'args' => 70, + 'func' => 11 + } + }, + {#State 68 + DEFAULT => -33 + }, + {#State 69 + ACTIONS => { + "^" => 19, + "=>" => 30, + "." => 32, + "<=" => 33 + }, + DEFAULT => -25 + }, + {#State 70 + DEFAULT => -37 + } +], + yyrules => +[ + [#Rule 0 + '$start', 2, undef + ], + [#Rule 1 + 'exp', 1, undef + ], + [#Rule 2 + 'exp', 1, +sub +#line 22 "expr.yp" +{ "\"$_[1]\"" } + ], + [#Rule 3 + 'exp', 1, undef + ], + [#Rule 4 + 'exp', 3, +sub +#line 24 "expr.yp" +{ "$_[1].$_[3]" } + ], + [#Rule 5 + 'exp', 1, +sub +#line 25 "expr.yp" +{ $_[0]->Lookup($_[1]) } + ], + [#Rule 6 + 'exp', 2, +sub +#line 26 "expr.yp" +{ $_[0]->Dereference($_[2]); "*$_[2]" } + ], + [#Rule 7 + 'exp', 2, +sub +#line 27 "expr.yp" +{ "~$_[2]" } + ], + [#Rule 8 + 'exp', 3, +sub +#line 28 "expr.yp" +{ "$_[1] + $_[3]" } + ], + [#Rule 9 + 'exp', 3, +sub +#line 29 "expr.yp" +{ "$_[1] - $_[3]" } + ], + [#Rule 10 + 'exp', 3, +sub +#line 30 "expr.yp" +{ "$_[1] * $_[3]" } + ], + [#Rule 11 + 'exp', 3, +sub +#line 31 "expr.yp" +{ "$_[1] % $_[3]" } + ], + [#Rule 12 + 'exp', 3, +sub +#line 32 "expr.yp" +{ "$_[1] < $_[3]" } + ], + [#Rule 13 + 'exp', 3, +sub +#line 33 "expr.yp" +{ "$_[1] > $_[3]" } + ], + [#Rule 14 + 'exp', 3, +sub +#line 34 "expr.yp" +{ "$_[1] | $_[3]" } + ], + [#Rule 15 + 'exp', 3, +sub +#line 35 "expr.yp" +{ "$_[1] == $_[3]" } + ], + [#Rule 16 + 'exp', 3, +sub +#line 36 "expr.yp" +{ "$_[1] <= $_[3]" } + ], + [#Rule 17 + 'exp', 3, +sub +#line 37 "expr.yp" +{ "$_[1] => $_[3]" } + ], + [#Rule 18 + 'exp', 3, +sub +#line 38 "expr.yp" +{ "$_[1] << $_[3]" } + ], + [#Rule 19 + 'exp', 3, +sub +#line 39 "expr.yp" +{ "$_[1] >> $_[3]" } + ], + [#Rule 20 + 'exp', 3, +sub +#line 40 "expr.yp" +{ "$_[1] != $_[3]" } + ], + [#Rule 21 + 'exp', 3, +sub +#line 41 "expr.yp" +{ "$_[1] || $_[3]" } + ], + [#Rule 22 + 'exp', 3, +sub +#line 42 "expr.yp" +{ "$_[1] && $_[3]" } + ], + [#Rule 23 + 'exp', 3, +sub +#line 43 "expr.yp" +{ "$_[1] & $_[3]" } + ], + [#Rule 24 + 'exp', 3, +sub +#line 44 "expr.yp" +{ $_[1]."->".$_[3] } + ], + [#Rule 25 + 'exp', 5, +sub +#line 45 "expr.yp" +{ "$_[1]?$_[3]:$_[5]" } + ], + [#Rule 26 + 'exp', 2, +sub +#line 46 "expr.yp" +{ "~$_[1]" } + ], + [#Rule 27 + 'exp', 2, +sub +#line 47 "expr.yp" +{ "not $_[1]" } + ], + [#Rule 28 + 'exp', 3, +sub +#line 48 "expr.yp" +{ "$_[1] / $_[3]" } + ], + [#Rule 29 + 'exp', 2, +sub +#line 49 "expr.yp" +{ "-$_[2]" } + ], + [#Rule 30 + 'exp', 2, +sub +#line 50 "expr.yp" +{ "&$_[2]" } + ], + [#Rule 31 + 'exp', 3, +sub +#line 51 "expr.yp" +{ "$_[1]^$_[3]" } + ], + [#Rule 32 + 'exp', 3, +sub +#line 52 "expr.yp" +{ "($_[2])" } + ], + [#Rule 33 + 'func', 4, +sub +#line 55 "expr.yp" +{ "$_[1]($_[3])" } + ], + [#Rule 34 + 'opt_args', 0, +sub +#line 56 "expr.yp" +{ "" } + ], + [#Rule 35 + 'opt_args', 1, undef + ], + [#Rule 36 + 'args', 1, undef + ], + [#Rule 37 + 'args', 3, +sub +#line 57 "expr.yp" +{ "$_[1], $_[3]" } + ] +], + @_); + bless($self,$class); +} + +#line 59 "expr.yp" + + +package Parse::Pidl::Expr; + +sub _Lexer { + my($parser)=shift; + + $parser->YYData->{INPUT}=~s/^[ \t]//; + + for ($parser->YYData->{INPUT}) { + if (s/^(0x[0-9A-Fa-f]+)//) { + $parser->YYData->{LAST_TOKEN} = $1; + return('NUM',$1); + } + if (s/^([0-9]+(?:\.[0-9]+)?)//) { + $parser->YYData->{LAST_TOKEN} = $1; + return('NUM',$1); + } + if (s/^([A-Za-z_][A-Za-z0-9_]*)//) { + $parser->YYData->{LAST_TOKEN} = $1; + return('VAR',$1); + } + if (s/^\"(.*?)\"//) { + $parser->YYData->{LAST_TOKEN} = $1; + return('TEXT',$1); + } + if (s/^(==|!=|<=|>=|->|\|\||<<|>>|&&)//s) { + $parser->YYData->{LAST_TOKEN} = $1; + return($1,$1); + } + if (s/^(.)//s) { + $parser->YYData->{LAST_TOKEN} = $1; + return($1,$1); + } + } +} + +sub Lookup($$) +{ + my ($self, $x) = @_; + return $self->YYData->{LOOKUP}->($x); +} + +sub Dereference($$) +{ + my ($self, $x) = @_; + if (defined($self->YYData->{DEREFERENCE})) { + $self->YYData->{DEREFERENCE}->($x); + } +} + +sub Run { + my($self, $data, $error, $lookup, $deref) = @_; + $self->YYData->{INPUT} = $data; + $self->YYData->{LOOKUP} = $lookup; + $self->YYData->{DEREFERENCE} = $deref; + return $self->YYParse( yylex => \&_Lexer, yyerror => $error ); +} + +1; -- cgit From 74239c2e944fdbe1ff137e91d80576b87c59d478 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 5 Jan 2007 20:18:33 +0000 Subject: r20563: Start using the new parser in ParseExpr(). It's now trivial to use this to check for NULL pointers when pointers are being dereferenced (#4218). There are exactly 500 tests for pidl now :-) (This used to be commit d3146f3bcd4541f890d6c1b072ff34853e9239d2) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 477 +----------------------------------- source4/pidl/lib/Parse/Pidl/Util.pm | 25 +- 2 files changed, 13 insertions(+), 489 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 7c4263fd11..13a34fae64 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -12,482 +12,7 @@ use vars qw ( @ISA ); use strict; @ISA= qw ( Parse::Yapp::Driver ); -#Included Parse/Yapp/Driver.pm file---------------------------------------- -{ -# -# Module Parse::Yapp::Driver -# -# This module is part of the Parse::Yapp package available on your -# nearest CPAN -# -# Any use of this module in a standalone parser make the included -# text under the same copyright as the Parse::Yapp module itself. -# -# This notice should remain unchanged. -# -# (c) Copyright 1998-2001 Francois Desarmenien, all rights reserved. -# (see the pod text in Parse::Yapp module for use and distribution rights) -# - -package Parse::Yapp::Driver; - -require 5.004; - -use strict; - -use vars qw ( $VERSION $COMPATIBLE $FILENAME ); - -$VERSION = '1.05'; -$COMPATIBLE = '0.07'; -$FILENAME=__FILE__; - -use Carp; - -#Known parameters, all starting with YY (leading YY will be discarded) -my(%params)=(YYLEX => 'CODE', 'YYERROR' => 'CODE', YYVERSION => '', - YYRULES => 'ARRAY', YYSTATES => 'ARRAY', YYDEBUG => ''); -#Mandatory parameters -my(@params)=('LEX','RULES','STATES'); - -sub new { - my($class)=shift; - my($errst,$nberr,$token,$value,$check,$dotpos); - my($self)={ ERROR => \&_Error, - ERRST => \$errst, - NBERR => \$nberr, - TOKEN => \$token, - VALUE => \$value, - DOTPOS => \$dotpos, - STACK => [], - DEBUG => 0, - CHECK => \$check }; - - _CheckParams( [], \%params, \@_, $self ); - - exists($$self{VERSION}) - and $$self{VERSION} < $COMPATIBLE - and croak "Yapp driver version $VERSION ". - "incompatible with version $$self{VERSION}:\n". - "Please recompile parser module."; - - ref($class) - and $class=ref($class); - - bless($self,$class); -} - -sub YYParse { - my($self)=shift; - my($retval); - - _CheckParams( \@params, \%params, \@_, $self ); - - if($$self{DEBUG}) { - _DBLoad(); - $retval = eval '$self->_DBParse()';#Do not create stab entry on compile - $@ and die $@; - } - else { - $retval = $self->_Parse(); - } - $retval -} - -sub YYData { - my($self)=shift; - - exists($$self{USER}) - or $$self{USER}={}; - - $$self{USER}; - -} - -sub YYErrok { - my($self)=shift; - - ${$$self{ERRST}}=0; - undef; -} - -sub YYNberr { - my($self)=shift; - - ${$$self{NBERR}}; -} - -sub YYRecovering { - my($self)=shift; - - ${$$self{ERRST}} != 0; -} - -sub YYAbort { - my($self)=shift; - - ${$$self{CHECK}}='ABORT'; - undef; -} - -sub YYAccept { - my($self)=shift; - - ${$$self{CHECK}}='ACCEPT'; - undef; -} - -sub YYError { - my($self)=shift; - - ${$$self{CHECK}}='ERROR'; - undef; -} - -sub YYSemval { - my($self)=shift; - my($index)= $_[0] - ${$$self{DOTPOS}} - 1; - - $index < 0 - and -$index <= @{$$self{STACK}} - and return $$self{STACK}[$index][1]; - - undef; #Invalid index -} - -sub YYCurtok { - my($self)=shift; - - @_ - and ${$$self{TOKEN}}=$_[0]; - ${$$self{TOKEN}}; -} - -sub YYCurval { - my($self)=shift; - - @_ - and ${$$self{VALUE}}=$_[0]; - ${$$self{VALUE}}; -} - -sub YYExpect { - my($self)=shift; - - keys %{$self->{STATES}[$self->{STACK}[-1][0]]{ACTIONS}} -} - -sub YYLexer { - my($self)=shift; - - $$self{LEX}; -} - - -################# -# Private stuff # -################# - - -sub _CheckParams { - my($mandatory,$checklist,$inarray,$outhash)=@_; - my($prm,$value); - my($prmlst)={}; - - while(($prm,$value)=splice(@$inarray,0,2)) { - $prm=uc($prm); - exists($$checklist{$prm}) - or croak("Unknow parameter '$prm'"); - ref($value) eq $$checklist{$prm} - or croak("Invalid value for parameter '$prm'"); - $prm=unpack('@2A*',$prm); - $$outhash{$prm}=$value; - } - for (@$mandatory) { - exists($$outhash{$_}) - or croak("Missing mandatory parameter '".lc($_)."'"); - } -} - -sub _Error { - print "Parse error.\n"; -} - -sub _DBLoad { - { - no strict 'refs'; - - exists(${__PACKAGE__.'::'}{_DBParse})#Already loaded ? - and return; - } - my($fname)=__FILE__; - my(@drv); - open(DRV,"<$fname") or die "Report this as a BUG: Cannot open $fname"; - while() { - /^\s*sub\s+_Parse\s*{\s*$/ .. /^\s*}\s*#\s*_Parse\s*$/ - and do { - s/^#DBG>//; - push(@drv,$_); - } - } - close(DRV); - - $drv[0]=~s/_P/_DBP/; - eval join('',@drv); -} - -#Note that for loading debugging version of the driver, -#this file will be parsed from 'sub _Parse' up to '}#_Parse' inclusive. -#So, DO NOT remove comment at end of sub !!! -sub _Parse { - my($self)=shift; - - my($rules,$states,$lex,$error) - = @$self{ 'RULES', 'STATES', 'LEX', 'ERROR' }; - my($errstatus,$nberror,$token,$value,$stack,$check,$dotpos) - = @$self{ 'ERRST', 'NBERR', 'TOKEN', 'VALUE', 'STACK', 'CHECK', 'DOTPOS' }; - -#DBG> my($debug)=$$self{DEBUG}; -#DBG> my($dbgerror)=0; - -#DBG> my($ShowCurToken) = sub { -#DBG> my($tok)='>'; -#DBG> for (split('',$$token)) { -#DBG> $tok.= (ord($_) < 32 or ord($_) > 126) -#DBG> ? sprintf('<%02X>',ord($_)) -#DBG> : $_; -#DBG> } -#DBG> $tok.='<'; -#DBG> }; - - $$errstatus=0; - $$nberror=0; - ($$token,$$value)=(undef,undef); - @$stack=( [ 0, undef ] ); - $$check=''; - - while(1) { - my($actions,$act,$stateno); - - $stateno=$$stack[-1][0]; - $actions=$$states[$stateno]; - -#DBG> print STDERR ('-' x 40),"\n"; -#DBG> $debug & 0x2 -#DBG> and print STDERR "In state $stateno:\n"; -#DBG> $debug & 0x08 -#DBG> and print STDERR "Stack:[". -#DBG> join(',',map { $$_[0] } @$stack). -#DBG> "]\n"; - - - if (exists($$actions{ACTIONS})) { - - defined($$token) - or do { - ($$token,$$value)=&$lex($self); -#DBG> $debug & 0x01 -#DBG> and print STDERR "Need token. Got ".&$ShowCurToken."\n"; - }; - - $act= exists($$actions{ACTIONS}{$$token}) - ? $$actions{ACTIONS}{$$token} - : exists($$actions{DEFAULT}) - ? $$actions{DEFAULT} - : undef; - } - else { - $act=$$actions{DEFAULT}; -#DBG> $debug & 0x01 -#DBG> and print STDERR "Don't need token.\n"; - } - - defined($act) - and do { - - $act > 0 - and do { #shift - -#DBG> $debug & 0x04 -#DBG> and print STDERR "Shift and go to state $act.\n"; - - $$errstatus - and do { - --$$errstatus; - -#DBG> $debug & 0x10 -#DBG> and $dbgerror -#DBG> and $$errstatus == 0 -#DBG> and do { -#DBG> print STDERR "**End of Error recovery.\n"; -#DBG> $dbgerror=0; -#DBG> }; - }; - - - push(@$stack,[ $act, $$value ]); - - $$token ne '' #Don't eat the eof - and $$token=$$value=undef; - next; - }; - - #reduce - my($lhs,$len,$code,@sempar,$semval); - ($lhs,$len,$code)=@{$$rules[-$act]}; - -#DBG> $debug & 0x04 -#DBG> and $act -#DBG> and print STDERR "Reduce using rule ".-$act." ($lhs,$len): "; - - $act - or $self->YYAccept(); - - $$dotpos=$len; - - unpack('A1',$lhs) eq '@' #In line rule - and do { - $lhs =~ /^\@[0-9]+\-([0-9]+)$/ - or die "In line rule name '$lhs' ill formed: ". - "report it as a BUG.\n"; - $$dotpos = $1; - }; - - @sempar = $$dotpos - ? map { $$_[1] } @$stack[ -$$dotpos .. -1 ] - : (); - - $semval = $code ? &$code( $self, @sempar ) - : @sempar ? $sempar[0] : undef; - - splice(@$stack,-$len,$len); - - $$check eq 'ACCEPT' - and do { - -#DBG> $debug & 0x04 -#DBG> and print STDERR "Accept.\n"; - - return($semval); - }; - - $$check eq 'ABORT' - and do { - -#DBG> $debug & 0x04 -#DBG> and print STDERR "Abort.\n"; - - return(undef); - - }; - -#DBG> $debug & 0x04 -#DBG> and print STDERR "Back to state $$stack[-1][0], then "; - - $$check eq 'ERROR' - or do { -#DBG> $debug & 0x04 -#DBG> and print STDERR -#DBG> "go to state $$states[$$stack[-1][0]]{GOTOS}{$lhs}.\n"; - -#DBG> $debug & 0x10 -#DBG> and $dbgerror -#DBG> and $$errstatus == 0 -#DBG> and do { -#DBG> print STDERR "**End of Error recovery.\n"; -#DBG> $dbgerror=0; -#DBG> }; - - push(@$stack, - [ $$states[$$stack[-1][0]]{GOTOS}{$lhs}, $semval ]); - $$check=''; - next; - }; - -#DBG> $debug & 0x04 -#DBG> and print STDERR "Forced Error recovery.\n"; - - $$check=''; - - }; - - #Error - $$errstatus - or do { - - $$errstatus = 1; - &$error($self); - $$errstatus # if 0, then YYErrok has been called - or next; # so continue parsing - -#DBG> $debug & 0x10 -#DBG> and do { -#DBG> print STDERR "**Entering Error recovery.\n"; -#DBG> ++$dbgerror; -#DBG> }; - - ++$$nberror; - - }; - - $$errstatus == 3 #The next token is not valid: discard it - and do { - $$token eq '' # End of input: no hope - and do { -#DBG> $debug & 0x10 -#DBG> and print STDERR "**At eof: aborting.\n"; - return(undef); - }; - -#DBG> $debug & 0x10 -#DBG> and print STDERR "**Dicard invalid token ".&$ShowCurToken.".\n"; - - $$token=$$value=undef; - }; - - $$errstatus=3; - - while( @$stack - and ( not exists($$states[$$stack[-1][0]]{ACTIONS}) - or not exists($$states[$$stack[-1][0]]{ACTIONS}{error}) - or $$states[$$stack[-1][0]]{ACTIONS}{error} <= 0)) { - -#DBG> $debug & 0x10 -#DBG> and print STDERR "**Pop state $$stack[-1][0].\n"; - - pop(@$stack); - } - - @$stack - or do { - -#DBG> $debug & 0x10 -#DBG> and print STDERR "**No state left on stack: aborting.\n"; - - return(undef); - }; - - #shift the error token - -#DBG> $debug & 0x10 -#DBG> and print STDERR "**Shift \$error token and go to state ". -#DBG> $$states[$$stack[-1][0]]{ACTIONS}{error}. -#DBG> ".\n"; - - push(@$stack, [ $$states[$$stack[-1][0]]{ACTIONS}{error}, undef ]); - - } - - #never reached - croak("Error in driver logic. Please, report it as a BUG"); - -}#_Parse -#DO NOT remove comment - -1; - -} -#End of include-------------------------------------------------- - +use Parse::Yapp::Driver; diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 064862b7c5..2f3547bbb5 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -12,6 +12,8 @@ $VERSION = '0.01'; use strict; +use Parse::Pidl::Expr; + ##################################################################### # a dumper wrapper to prevent dependence on the Data::Dumper module # unless we actually need it @@ -97,22 +99,19 @@ sub useUintEnums() sub ParseExpr($$) { - my($expr,$varlist) = @_; + my($expr, $varlist) = @_; die("Undefined value in ParseExpr") if not defined($expr); - my @tokens = split /((?:[A-Za-z_])(?:(?:(?:[A-Za-z0-9_.])|(?:->))+)?)/, $expr; - my $ret = ""; - - foreach my $t (@tokens) { - if (defined($varlist->{$t})) { - $ret .= $varlist->{$t}; - } else { - $ret .= $t; - } - } - - return $ret; + my $x = new Parse::Pidl::Expr(); + + return $x->Run($expr, sub { my $x = shift; die(MyDumper($x)); }, + # Lookup fn + sub { my $x = shift; + return($varlist->{$x}) if (defined($varlist->{$x})); + return $x; + }, + undef); } 1; -- cgit From 2ebbad9d76db85dced0d7c784a60b83d28468cca Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 5 Jan 2007 20:23:48 +0000 Subject: r20564: Regenerate. (This used to be commit a4d6e340cdfdab8c6ac49c4fc8a504f8910cefed) --- source4/pidl/lib/Parse/Pidl/Expr.pm | 68 ++++++++++++++++++------------------- 1 file changed, 34 insertions(+), 34 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Expr.pm b/source4/pidl/lib/Parse/Pidl/Expr.pm index 1d663e1668..2f1a98f374 100644 --- a/source4/pidl/lib/Parse/Pidl/Expr.pm +++ b/source4/pidl/lib/Parse/Pidl/Expr.pm @@ -1085,7 +1085,7 @@ sub new { [#Rule 2 'exp', 1, sub -#line 22 "expr.yp" +#line 22 "pidl/expr.yp" { "\"$_[1]\"" } ], [#Rule 3 @@ -1094,187 +1094,187 @@ sub [#Rule 4 'exp', 3, sub -#line 24 "expr.yp" +#line 24 "pidl/expr.yp" { "$_[1].$_[3]" } ], [#Rule 5 'exp', 1, sub -#line 25 "expr.yp" +#line 25 "pidl/expr.yp" { $_[0]->Lookup($_[1]) } ], [#Rule 6 'exp', 2, sub -#line 26 "expr.yp" +#line 26 "pidl/expr.yp" { $_[0]->Dereference($_[2]); "*$_[2]" } ], [#Rule 7 'exp', 2, sub -#line 27 "expr.yp" +#line 27 "pidl/expr.yp" { "~$_[2]" } ], [#Rule 8 'exp', 3, sub -#line 28 "expr.yp" +#line 28 "pidl/expr.yp" { "$_[1] + $_[3]" } ], [#Rule 9 'exp', 3, sub -#line 29 "expr.yp" +#line 29 "pidl/expr.yp" { "$_[1] - $_[3]" } ], [#Rule 10 'exp', 3, sub -#line 30 "expr.yp" +#line 30 "pidl/expr.yp" { "$_[1] * $_[3]" } ], [#Rule 11 'exp', 3, sub -#line 31 "expr.yp" +#line 31 "pidl/expr.yp" { "$_[1] % $_[3]" } ], [#Rule 12 'exp', 3, sub -#line 32 "expr.yp" +#line 32 "pidl/expr.yp" { "$_[1] < $_[3]" } ], [#Rule 13 'exp', 3, sub -#line 33 "expr.yp" +#line 33 "pidl/expr.yp" { "$_[1] > $_[3]" } ], [#Rule 14 'exp', 3, sub -#line 34 "expr.yp" +#line 34 "pidl/expr.yp" { "$_[1] | $_[3]" } ], [#Rule 15 'exp', 3, sub -#line 35 "expr.yp" +#line 35 "pidl/expr.yp" { "$_[1] == $_[3]" } ], [#Rule 16 'exp', 3, sub -#line 36 "expr.yp" +#line 36 "pidl/expr.yp" { "$_[1] <= $_[3]" } ], [#Rule 17 'exp', 3, sub -#line 37 "expr.yp" +#line 37 "pidl/expr.yp" { "$_[1] => $_[3]" } ], [#Rule 18 'exp', 3, sub -#line 38 "expr.yp" +#line 38 "pidl/expr.yp" { "$_[1] << $_[3]" } ], [#Rule 19 'exp', 3, sub -#line 39 "expr.yp" +#line 39 "pidl/expr.yp" { "$_[1] >> $_[3]" } ], [#Rule 20 'exp', 3, sub -#line 40 "expr.yp" +#line 40 "pidl/expr.yp" { "$_[1] != $_[3]" } ], [#Rule 21 'exp', 3, sub -#line 41 "expr.yp" +#line 41 "pidl/expr.yp" { "$_[1] || $_[3]" } ], [#Rule 22 'exp', 3, sub -#line 42 "expr.yp" +#line 42 "pidl/expr.yp" { "$_[1] && $_[3]" } ], [#Rule 23 'exp', 3, sub -#line 43 "expr.yp" +#line 43 "pidl/expr.yp" { "$_[1] & $_[3]" } ], [#Rule 24 'exp', 3, sub -#line 44 "expr.yp" +#line 44 "pidl/expr.yp" { $_[1]."->".$_[3] } ], [#Rule 25 'exp', 5, sub -#line 45 "expr.yp" +#line 45 "pidl/expr.yp" { "$_[1]?$_[3]:$_[5]" } ], [#Rule 26 'exp', 2, sub -#line 46 "expr.yp" +#line 46 "pidl/expr.yp" { "~$_[1]" } ], [#Rule 27 'exp', 2, sub -#line 47 "expr.yp" +#line 47 "pidl/expr.yp" { "not $_[1]" } ], [#Rule 28 'exp', 3, sub -#line 48 "expr.yp" +#line 48 "pidl/expr.yp" { "$_[1] / $_[3]" } ], [#Rule 29 'exp', 2, sub -#line 49 "expr.yp" +#line 49 "pidl/expr.yp" { "-$_[2]" } ], [#Rule 30 'exp', 2, sub -#line 50 "expr.yp" +#line 50 "pidl/expr.yp" { "&$_[2]" } ], [#Rule 31 'exp', 3, sub -#line 51 "expr.yp" +#line 51 "pidl/expr.yp" { "$_[1]^$_[3]" } ], [#Rule 32 'exp', 3, sub -#line 52 "expr.yp" +#line 52 "pidl/expr.yp" { "($_[2])" } ], [#Rule 33 'func', 4, sub -#line 55 "expr.yp" +#line 55 "pidl/expr.yp" { "$_[1]($_[3])" } ], [#Rule 34 'opt_args', 0, sub -#line 56 "expr.yp" +#line 56 "pidl/expr.yp" { "" } ], [#Rule 35 @@ -1286,7 +1286,7 @@ sub [#Rule 37 'args', 3, sub -#line 57 "expr.yp" +#line 57 "pidl/expr.yp" { "$_[1], $_[3]" } ] ], @@ -1294,7 +1294,7 @@ sub bless($self,$class); } -#line 59 "expr.yp" +#line 59 "pidl/expr.yp" package Parse::Pidl::Expr; -- cgit From a7bc3801f94891880a90b2974dfbadc9e9f8c2ee Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 5 Jan 2007 20:52:12 +0000 Subject: r20567: Print proper errors with filename and line numbers in ParseExpr() (This used to be commit f5dc1b47ecf18068a47f8f68016463ef4a55dc03) --- source4/pidl/lib/Parse/Pidl/Expr.pm | 86 +++++++++++++----------- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 14 ++-- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 46 ++++++------- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 8 +-- source4/pidl/lib/Parse/Pidl/Util.pm | 7 +- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 2 +- 8 files changed, 88 insertions(+), 79 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Expr.pm b/source4/pidl/lib/Parse/Pidl/Expr.pm index 2f1a98f374..fc0a3a92aa 100644 --- a/source4/pidl/lib/Parse/Pidl/Expr.pm +++ b/source4/pidl/lib/Parse/Pidl/Expr.pm @@ -1085,7 +1085,7 @@ sub new { [#Rule 2 'exp', 1, sub -#line 22 "pidl/expr.yp" +#line 22 "expr.yp" { "\"$_[1]\"" } ], [#Rule 3 @@ -1094,187 +1094,187 @@ sub [#Rule 4 'exp', 3, sub -#line 24 "pidl/expr.yp" +#line 24 "expr.yp" { "$_[1].$_[3]" } ], [#Rule 5 'exp', 1, sub -#line 25 "pidl/expr.yp" -{ $_[0]->Lookup($_[1]) } +#line 25 "expr.yp" +{ $_[0]->_Lookup($_[1]) } ], [#Rule 6 'exp', 2, sub -#line 26 "pidl/expr.yp" -{ $_[0]->Dereference($_[2]); "*$_[2]" } +#line 26 "expr.yp" +{ $_[0]->_Dereference($_[2]); "*$_[2]" } ], [#Rule 7 'exp', 2, sub -#line 27 "pidl/expr.yp" +#line 27 "expr.yp" { "~$_[2]" } ], [#Rule 8 'exp', 3, sub -#line 28 "pidl/expr.yp" +#line 28 "expr.yp" { "$_[1] + $_[3]" } ], [#Rule 9 'exp', 3, sub -#line 29 "pidl/expr.yp" +#line 29 "expr.yp" { "$_[1] - $_[3]" } ], [#Rule 10 'exp', 3, sub -#line 30 "pidl/expr.yp" +#line 30 "expr.yp" { "$_[1] * $_[3]" } ], [#Rule 11 'exp', 3, sub -#line 31 "pidl/expr.yp" +#line 31 "expr.yp" { "$_[1] % $_[3]" } ], [#Rule 12 'exp', 3, sub -#line 32 "pidl/expr.yp" +#line 32 "expr.yp" { "$_[1] < $_[3]" } ], [#Rule 13 'exp', 3, sub -#line 33 "pidl/expr.yp" +#line 33 "expr.yp" { "$_[1] > $_[3]" } ], [#Rule 14 'exp', 3, sub -#line 34 "pidl/expr.yp" +#line 34 "expr.yp" { "$_[1] | $_[3]" } ], [#Rule 15 'exp', 3, sub -#line 35 "pidl/expr.yp" +#line 35 "expr.yp" { "$_[1] == $_[3]" } ], [#Rule 16 'exp', 3, sub -#line 36 "pidl/expr.yp" +#line 36 "expr.yp" { "$_[1] <= $_[3]" } ], [#Rule 17 'exp', 3, sub -#line 37 "pidl/expr.yp" +#line 37 "expr.yp" { "$_[1] => $_[3]" } ], [#Rule 18 'exp', 3, sub -#line 38 "pidl/expr.yp" +#line 38 "expr.yp" { "$_[1] << $_[3]" } ], [#Rule 19 'exp', 3, sub -#line 39 "pidl/expr.yp" +#line 39 "expr.yp" { "$_[1] >> $_[3]" } ], [#Rule 20 'exp', 3, sub -#line 40 "pidl/expr.yp" +#line 40 "expr.yp" { "$_[1] != $_[3]" } ], [#Rule 21 'exp', 3, sub -#line 41 "pidl/expr.yp" +#line 41 "expr.yp" { "$_[1] || $_[3]" } ], [#Rule 22 'exp', 3, sub -#line 42 "pidl/expr.yp" +#line 42 "expr.yp" { "$_[1] && $_[3]" } ], [#Rule 23 'exp', 3, sub -#line 43 "pidl/expr.yp" +#line 43 "expr.yp" { "$_[1] & $_[3]" } ], [#Rule 24 'exp', 3, sub -#line 44 "pidl/expr.yp" +#line 44 "expr.yp" { $_[1]."->".$_[3] } ], [#Rule 25 'exp', 5, sub -#line 45 "pidl/expr.yp" +#line 45 "expr.yp" { "$_[1]?$_[3]:$_[5]" } ], [#Rule 26 'exp', 2, sub -#line 46 "pidl/expr.yp" +#line 46 "expr.yp" { "~$_[1]" } ], [#Rule 27 'exp', 2, sub -#line 47 "pidl/expr.yp" +#line 47 "expr.yp" { "not $_[1]" } ], [#Rule 28 'exp', 3, sub -#line 48 "pidl/expr.yp" +#line 48 "expr.yp" { "$_[1] / $_[3]" } ], [#Rule 29 'exp', 2, sub -#line 49 "pidl/expr.yp" +#line 49 "expr.yp" { "-$_[2]" } ], [#Rule 30 'exp', 2, sub -#line 50 "pidl/expr.yp" +#line 50 "expr.yp" { "&$_[2]" } ], [#Rule 31 'exp', 3, sub -#line 51 "pidl/expr.yp" +#line 51 "expr.yp" { "$_[1]^$_[3]" } ], [#Rule 32 'exp', 3, sub -#line 52 "pidl/expr.yp" +#line 52 "expr.yp" { "($_[2])" } ], [#Rule 33 'func', 4, sub -#line 55 "pidl/expr.yp" +#line 55 "expr.yp" { "$_[1]($_[3])" } ], [#Rule 34 'opt_args', 0, sub -#line 56 "pidl/expr.yp" +#line 56 "expr.yp" { "" } ], [#Rule 35 @@ -1286,7 +1286,7 @@ sub [#Rule 37 'args', 3, sub -#line 57 "pidl/expr.yp" +#line 57 "expr.yp" { "$_[1], $_[3]" } ] ], @@ -1294,7 +1294,7 @@ sub bless($self,$class); } -#line 59 "pidl/expr.yp" +#line 59 "expr.yp" package Parse::Pidl::Expr; @@ -1332,13 +1332,13 @@ sub _Lexer { } } -sub Lookup($$) +sub _Lookup($$) { my ($self, $x) = @_; return $self->YYData->{LOOKUP}->($x); } -sub Dereference($$) +sub _Dereference($$) { my ($self, $x) = @_; if (defined($self->YYData->{DEREFERENCE})) { @@ -1346,12 +1346,20 @@ sub Dereference($$) } } +sub _Error($) +{ + my ($self) = @_; + $self->YYData->{ERROR}->("Parse error in `".$self->YYData->{FULL_INPUT}."' near `". $self->YYData->{LAST_TOKEN} . "'"); +} + sub Run { my($self, $data, $error, $lookup, $deref) = @_; + $self->YYData->{FULL_INPUT} = $data; $self->YYData->{INPUT} = $data; $self->YYData->{LOOKUP} = $lookup; $self->YYData->{DEREFERENCE} = $deref; - return $self->YYParse( yylex => \&_Lexer, yyerror => $error ); + $self->YYData->{ERROR} = $error; + return $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error); } 1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 5c88e3d22f..f6b3a6dcac 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -9,7 +9,7 @@ package Parse::Pidl::Samba3::ClientNDR; use strict; use Parse::Pidl qw(fatal warning); use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); -use Parse::Pidl::Util qw(has_property ParseExpr is_constant); +use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::Samba4 qw(DeclLong_cli IsUniqueOut); diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 8d42b483ec..f8ff458275 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -36,7 +36,7 @@ sub AllocOutVar($$$$) } if ($l->{TYPE} eq "ARRAY") { - my $size = ParseExpr($l->{SIZE_IS}, $env); + my $size = ParseExpr($l->{SIZE_IS}, $env, $e); pidl "$name = talloc_zero_size($mem_ctx, sizeof(*$name) * $size);"; } else { pidl "$name = talloc_zero_size($mem_ctx, sizeof(*$name));"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index f820dbbc5a..c851fafd4b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -198,8 +198,8 @@ sub EjsPullArray($$$$$) { my ($e, $l, $var, $name, $env) = @_; my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); - my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env); - my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env); + my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env, $e); + my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env, $e); my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); if ($pl && $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); @@ -238,7 +238,7 @@ sub EjsPullArray($$$$$) sub EjsPullSwitch($$$$$) { my ($e, $l, $var, $name, $env) = @_; - my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env); + my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env, $e); pidl "ejs_set_switch(ejs, $switch_var);"; EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); } @@ -270,7 +270,7 @@ sub EjsPullElementTop($$) my $e = shift; my $env = shift; my $l = $e->{LEVELS}[0]; - my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env); + my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env, $e); my $name = "\"$e->{NAME}\""; EjsPullElement($e, $l, $var, $name, $env); } @@ -488,7 +488,7 @@ sub EjsPushPointer($$$$$) sub EjsPushSwitch($$$$$) { my ($e, $l, $var, $name, $env) = @_; - my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env); + my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env, $e); pidl "ejs_set_switch(ejs, $switch_var);"; EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); } @@ -500,7 +500,7 @@ sub EjsPushArray($$$$$) { my ($e, $l, $var, $name, $env) = @_; my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); - my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env); + my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env, $e); my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); if ($pl && $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); @@ -553,7 +553,7 @@ sub EjsPushElementTop($$) my $e = shift; my $env = shift; my $l = $e->{LEVELS}[0]; - my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env); + my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env, $e); my $name = "\"$e->{NAME}\""; EjsPushElement($e, $l, $var, $name, $env); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index f104ffbad8..debdc8e308 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -257,7 +257,7 @@ sub EnvSubstituteValue($$) foreach my $e (@{$s->{ELEMENTS}}) { next unless (my $v = has_property($e, "value")); - $env->{$e->{NAME}} = ParseExpr($v, $env); + $env->{$e->{NAME}} = ParseExpr($v, $env, $e); } return $env; @@ -309,8 +309,8 @@ sub ParseArrayPushHeader($$$$$) $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))"; } } else { - $size = ParseExpr($l->{SIZE_IS}, $env); - $length = ParseExpr($l->{LENGTH_IS}, $env); + $size = ParseExpr($l->{SIZE_IS}, $env, $e); + $length = ParseExpr($l->{LENGTH_IS}, $env, $e); } if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { @@ -339,7 +339,7 @@ sub ParseArrayPullHeader($$$$$) } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))"; } else { - $length = $size = ParseExpr($l->{SIZE_IS}, $env); + $length = $size = ParseExpr($l->{SIZE_IS}, $env, $e); } if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { @@ -363,7 +363,7 @@ sub ParseArrayPullHeader($$$$$) } if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { - my $size = ParseExpr($l->{SIZE_IS}, $env); + my $size = ParseExpr($l->{SIZE_IS}, $env, $e); defer "if ($var_name) {"; defer_indent; check_null_pointer_deferred($size); @@ -373,7 +373,7 @@ sub ParseArrayPullHeader($$$$$) } if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { - my $length = ParseExpr($l->{LENGTH_IS}, $env); + my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); defer "if ($var_name) {"; defer_indent; check_null_pointer_deferred($length); @@ -404,7 +404,7 @@ sub compression_clen($$$) my $compression = $l->{COMPRESSION}; my ($alg, $clen, $dlen) = split(/ /, $compression); - return ParseExpr($clen, $env); + return ParseExpr($clen, $env, $e); } sub compression_dlen($$$) @@ -413,7 +413,7 @@ sub compression_dlen($$$) my $compression = $l->{COMPRESSION}; my ($alg, $clen, $dlen) = split(/ /, $compression); - return ParseExpr($dlen, $env); + return ParseExpr($dlen, $env, $e); } sub ParseCompressionPushStart($$$$) @@ -474,7 +474,7 @@ sub ParseSubcontextPushStart($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env, $e); pidl "{"; indent; @@ -492,7 +492,7 @@ sub ParseSubcontextPushEnd($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env, $e); if (defined $l->{COMPRESSION}) { ParseCompressionPushEnd($e, $l, $subndr, $env); @@ -507,7 +507,7 @@ sub ParseSubcontextPullStart($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env, $e); pidl "{"; indent; @@ -525,7 +525,7 @@ sub ParseSubcontextPullEnd($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env, $e); if (defined $l->{COMPRESSION}) { ParseCompressionPullEnd($e, $l, $subndr, $env); @@ -590,7 +590,7 @@ sub ParseElementPushLevel } } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and not is_charset_array($e, $l)) { - my $length = ParseExpr($l->{LENGTH_IS}, $env); + my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; $var_name = $var_name . "[$counter]"; @@ -641,7 +641,7 @@ sub ParseElementPush($$$$$$) start_flags($e); if (my $value = has_property($e, "value")) { - $var_name = ParseExpr($value, $env); + $var_name = ParseExpr($value, $env, $e); } ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred); @@ -692,7 +692,7 @@ sub ParseElementPrint($$$) $var_name = append_prefix($e, $var_name); if (my $value = has_property($e, "value")) { - $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env) . ":$var_name"; + $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env, $e) . ":$var_name"; } foreach my $l (@{$e->{LEVELS}}) { @@ -714,7 +714,7 @@ sub ParseElementPrint($$$) if ($l->{IS_ZERO_TERMINATED}) { $length = "ndr_string_length($var_name, sizeof(*$var_name))"; } else { - $length = ParseExpr($l->{LENGTH_IS}, $env); + $length = ParseExpr($l->{LENGTH_IS}, $env, $e); } if (is_charset_array($e,$l)) { @@ -744,7 +744,7 @@ sub ParseElementPrint($$$) } pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; } elsif ($l->{TYPE} eq "SWITCH") { - my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"; } } @@ -774,7 +774,7 @@ sub ParseElementPrint($$$) sub ParseSwitchPull($$$$$$) { my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); check_null_pointer($switch_var); @@ -787,7 +787,7 @@ sub ParseSwitchPull($$$$$$) sub ParseSwitchPush($$$$$$) { my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExpr($l->{SWITCH_IS}, $env); + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); check_null_pointer($switch_var); $var_name = get_pointer_to($var_name); @@ -986,7 +986,7 @@ sub ParseElementPullLevel } } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and not is_charset_array($e, $l)) { - my $length = ParseExpr($l->{LENGTH_IS}, $env); + my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; my $array_name = $var_name; @@ -1155,7 +1155,7 @@ sub ParseStructPush($$) $size = "ndr_string_length(r->$e->{NAME}, sizeof(*r->$e->{NAME}))"; } } else { - $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env); + $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e); } pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; @@ -2012,7 +2012,7 @@ sub AllocateArrayLevel($$$$$) { my ($e,$l,$ndr,$env,$size) = @_; - my $var = ParseExpr($e->{NAME}, $env); + my $var = ParseExpr($e->{NAME}, $env, $e); check_null_pointer($size); my $pl = GetPrevLevel($e, $l); @@ -2093,7 +2093,7 @@ sub ParseFunctionPull($) and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}); if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { - my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env); + my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env, $e); check_null_pointer($size); pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index bc8d27a283..a3e8d3470b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -72,7 +72,7 @@ sub ParserElement($$$) if (has_property($e, "charset")) { fatal($e,"charset() on non-array element") unless (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0); - my $len = ParseExpr(@{$e->{ARRAY_LEN}}[0], $env); + my $len = ParseExpr(@{$e->{ARRAY_LEN}}[0], $env, $e); if ($len eq "*") { $len = "-1"; } $name = ", mem_ctx" if ($t eq "pull"); pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));"; @@ -80,11 +80,11 @@ sub ParserElement($$$) } if (has_property($e, "switch_is")) { - $switch = ", " . ParseExpr($e->{PROPERTIES}->{switch_is}, $env); + $switch = ", " . ParseExpr($e->{PROPERTIES}->{switch_is}, $env, $e); } if (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0) { - my $len = ParseExpr($e->{ARRAY_LEN}[0], $env); + my $len = ParseExpr($e->{ARRAY_LEN}[0], $env, $e); if ($t eq "pull" and not is_constant($len)) { pidl "TDR_ALLOC(mem_ctx, v->$e->{NAME}, $len);"; @@ -101,7 +101,7 @@ sub ParserElement($$$) } if (has_property($e, "value") && $t eq "push") { - pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env).";"; + pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env, $e).";"; } pidl "TDR_CHECK(tdr_$t\_$e->{TYPE}(tdr$name$switch, &v->$e->{NAME}$array));"; diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 2f3547bbb5..11e738fd13 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -13,6 +13,7 @@ $VERSION = '0.01'; use strict; use Parse::Pidl::Expr; +use Parse::Pidl qw(error); ##################################################################### # a dumper wrapper to prevent dependence on the Data::Dumper module @@ -97,15 +98,15 @@ sub useUintEnums() return $useUintEnums; } -sub ParseExpr($$) +sub ParseExpr($$$) { - my($expr, $varlist) = @_; + my($expr, $varlist, $e) = @_; die("Undefined value in ParseExpr") if not defined($expr); my $x = new Parse::Pidl::Expr(); - return $x->Run($expr, sub { my $x = shift; die(MyDumper($x)); }, + return $x->Run($expr, sub { my $x = shift; error($e, $x); }, # Lookup fn sub { my $x = shift; return($varlist->{$x}) if (defined($varlist->{$x})); diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 9526d76a37..9415c16652 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -19,7 +19,7 @@ package Parse::Pidl::Wireshark::NDR; use strict; use Parse::Pidl qw(error); use Parse::Pidl::Typelist qw(getType); -use Parse::Pidl::Util qw(has_property ParseExpr property_matches make_str); +use Parse::Pidl::Util qw(has_property property_matches make_str); use Parse::Pidl::NDR qw(ContainsString GetNextLevel); use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); use Parse::Pidl::Wireshark::Conformance qw(ReadConformance); -- cgit From 40b71722e184e82de6c030d56af6943854599e19 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 5 Jan 2007 21:36:57 +0000 Subject: r20573: fix handling of pointers handling to elements with the charset property metze (This used to be commit 895416c2202cac561e3bda80fe5c05a782dde0b0) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index c851fafd4b..1ce22d5180 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -187,7 +187,11 @@ sub EjsPullPointer($$$$$) sub EjsPullString($$$$$) { my ($e, $l, $var, $name, $env) = @_; + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); $var = get_pointer_to($var); + if (defined($pl) and $pl->{TYPE} eq "POINTER") { + $var = get_pointer_to($var); + } pidl "NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));"; } @@ -248,14 +252,14 @@ sub EjsPullSwitch($$$$$) sub EjsPullElement($$$$$) { my ($e, $l, $var, $name, $env) = @_; - if (has_property($e, "charset")) { + if (($l->{TYPE} eq "POINTER")) { + EjsPullPointer($e, $l, $var, $name, $env); + } elsif (has_property($e, "charset")) { EjsPullString($e, $l, $var, $name, $env); } elsif ($l->{TYPE} eq "ARRAY") { EjsPullArray($e, $l, $var, $name, $env); } elsif ($l->{TYPE} eq "DATA") { EjsPullScalar($e, $l, $var, $name, $env); - } elsif (($l->{TYPE} eq "POINTER")) { - EjsPullPointer($e, $l, $var, $name, $env); } elsif (($l->{TYPE} eq "SWITCH")) { EjsPullSwitch($e, $l, $var, $name, $env); } else { @@ -459,6 +463,10 @@ sub EjsPushScalar($$$$$) sub EjsPushString($$$$$) { my ($e, $l, $var, $name, $env) = @_; + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + if (defined($pl) and $pl->{TYPE} eq "POINTER") { + $var = get_pointer_to($var); + } pidl "NDR_CHECK(ejs_push_string(ejs, v, $name, $var));"; } @@ -531,14 +539,14 @@ sub EjsPushArray($$$$$) sub EjsPushElement($$$$$) { my ($e, $l, $var, $name, $env) = @_; - if (has_property($e, "charset")) { + if (($l->{TYPE} eq "POINTER")) { + EjsPushPointer($e, $l, $var, $name, $env); + } elsif (has_property($e, "charset")) { EjsPushString($e, $l, $var, $name, $env); } elsif ($l->{TYPE} eq "ARRAY") { EjsPushArray($e, $l, $var, $name, $env); } elsif ($l->{TYPE} eq "DATA") { EjsPushScalar($e, $l, $var, $name, $env); - } elsif (($l->{TYPE} eq "POINTER")) { - EjsPushPointer($e, $l, $var, $name, $env); } elsif (($l->{TYPE} eq "SWITCH")) { EjsPushSwitch($e, $l, $var, $name, $env); } else { -- cgit From cfa230c480b0c55a23e23dcb39e1b170da576c95 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 9 Jan 2007 06:02:41 +0000 Subject: r20625: Fix couple of warnings. (This used to be commit 203076129b967ccc6258e807280dc1b75583a064) --- source4/pidl/lib/Parse/Pidl/Expr.pm | 6 +- source4/pidl/lib/Parse/Pidl/IDL.pm | 423 ++++++++++++++++++------------------ 2 files changed, 214 insertions(+), 215 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Expr.pm b/source4/pidl/lib/Parse/Pidl/Expr.pm index fc0a3a92aa..c6e5cd3dca 100644 --- a/source4/pidl/lib/Parse/Pidl/Expr.pm +++ b/source4/pidl/lib/Parse/Pidl/Expr.pm @@ -1349,7 +1349,11 @@ sub _Dereference($$) sub _Error($) { my ($self) = @_; - $self->YYData->{ERROR}->("Parse error in `".$self->YYData->{FULL_INPUT}."' near `". $self->YYData->{LAST_TOKEN} . "'"); + if (defined($self->YYData->{LAST_TOKEN})) { + $self->YYData->{ERROR}->("Parse error in `".$self->YYData->{FULL_INPUT}."' near `". $self->YYData->{LAST_TOKEN} . "'"); + } else { + $self->YYData->{ERROR}->("Parse error in `".$self->YYData->{FULL_INPUT}."'"); + } } sub Run { diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 13a34fae64..3d9eb4ea74 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -37,7 +37,7 @@ sub new { "import" => 6, "include" => 11 }, - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'importlib' => 9, 'interface' => 8, @@ -106,7 +106,7 @@ sub new { } }, {#State 13 - DEFAULT => -125 + DEFAULT => -124 }, {#State 14 DEFAULT => -10 @@ -161,7 +161,7 @@ sub new { } }, {#State 22 - DEFAULT => -121 + DEFAULT => -120 }, {#State 23 ACTIONS => { @@ -187,10 +187,10 @@ sub new { ACTIONS => { "(" => 36 }, - DEFAULT => -96 + DEFAULT => -95 }, {#State 27 - DEFAULT => -94 + DEFAULT => -93 }, {#State 28 DEFAULT => -7 @@ -230,7 +230,7 @@ sub new { } }, {#State 35 - DEFAULT => -93 + DEFAULT => -92 }, {#State 36 ACTIONS => { @@ -238,7 +238,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'text' => 46, @@ -266,7 +266,7 @@ sub new { "const" => 58, "struct" => 61 }, - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'typedecl' => 62, 'function' => 51, @@ -284,7 +284,7 @@ sub new { } }, {#State 40 - DEFAULT => -95 + DEFAULT => -94 }, {#State 41 ACTIONS => { @@ -304,7 +304,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -98 + DEFAULT => -97 }, {#State 42 ACTIONS => { @@ -313,22 +313,22 @@ sub new { } }, {#State 43 - DEFAULT => -104 + DEFAULT => -103 }, {#State 44 - DEFAULT => -124 + DEFAULT => -123 }, {#State 45 - DEFAULT => -103 + DEFAULT => -102 }, {#State 46 - DEFAULT => -105 + DEFAULT => -104 }, {#State 47 ACTIONS => { ";" => 86 }, - DEFAULT => -126, + DEFAULT => -125, GOTOS => { 'optional_semicolon' => 87 } @@ -342,7 +342,7 @@ sub new { } }, {#State 49 - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'property_list' => 89 } @@ -351,7 +351,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 90 }, - DEFAULT => -123, + DEFAULT => -122, GOTOS => { 'optional_identifier' => 91 } @@ -370,7 +370,7 @@ sub new { "const" => 58, "struct" => 61 }, - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'typedecl' => 62, 'function' => 51, @@ -419,7 +419,7 @@ sub new { DEFAULT => -18 }, {#State 56 - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'property_list' => 103 } @@ -445,7 +445,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 90 }, - DEFAULT => -123, + DEFAULT => -122, GOTOS => { 'optional_identifier' => 105 } @@ -457,7 +457,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 90 }, - DEFAULT => -123, + DEFAULT => -122, GOTOS => { 'optional_identifier' => 106 } @@ -466,7 +466,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 90 }, - DEFAULT => -123, + DEFAULT => -122, GOTOS => { 'optional_identifier' => 107 } @@ -489,7 +489,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 108, @@ -503,7 +503,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 109, @@ -517,7 +517,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 110, @@ -531,7 +531,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 111, @@ -545,7 +545,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 112, @@ -559,7 +559,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 113, @@ -573,7 +573,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 114, @@ -587,7 +587,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 115, @@ -602,7 +602,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 117, @@ -616,7 +616,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 118, @@ -630,7 +630,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 119, @@ -644,7 +644,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 115, @@ -659,7 +659,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 121, @@ -673,7 +673,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 122, @@ -687,7 +687,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 123, @@ -701,7 +701,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 124, @@ -710,10 +710,10 @@ sub new { } }, {#State 85 - DEFAULT => -97 + DEFAULT => -96 }, {#State 86 - DEFAULT => -127 + DEFAULT => -126 }, {#State 87 DEFAULT => -12 @@ -748,13 +748,13 @@ sub new { } }, {#State 90 - DEFAULT => -122 + DEFAULT => -121 }, {#State 91 ACTIONS => { "{" => 128 }, - DEFAULT => -77, + DEFAULT => -76, GOTOS => { 'union_body' => 129, 'opt_union_body' => 127 @@ -764,7 +764,7 @@ sub new { ACTIONS => { ";" => 86 }, - DEFAULT => -126, + DEFAULT => -125, GOTOS => { 'optional_semicolon' => 130 } @@ -776,13 +776,13 @@ sub new { DEFAULT => -40 }, {#State 95 - DEFAULT => -48 + DEFAULT => -47 }, {#State 96 - DEFAULT => -46 + DEFAULT => -45 }, {#State 97 - DEFAULT => -45 + DEFAULT => -44 }, {#State 98 ACTIONS => { @@ -793,7 +793,7 @@ sub new { } }, {#State 99 - DEFAULT => -47 + DEFAULT => -46 }, {#State 100 DEFAULT => -41 @@ -824,7 +824,7 @@ sub new { } }, {#State 104 - DEFAULT => -81, + DEFAULT => -80, GOTOS => { 'pointers' => 140 } @@ -833,7 +833,7 @@ sub new { ACTIONS => { "{" => 142 }, - DEFAULT => -67, + DEFAULT => -66, GOTOS => { 'struct_body' => 141, 'opt_struct_body' => 143 @@ -843,7 +843,7 @@ sub new { ACTIONS => { "{" => 144 }, - DEFAULT => -50, + DEFAULT => -49, GOTOS => { 'opt_enum_body' => 146, 'enum_body' => 145 @@ -853,7 +853,7 @@ sub new { ACTIONS => { "{" => 148 }, - DEFAULT => -58, + DEFAULT => -57, GOTOS => { 'bitmap_body' => 149, 'opt_bitmap_body' => 147 @@ -877,7 +877,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -115 + DEFAULT => -114 }, {#State 109 ACTIONS => { @@ -888,7 +888,7 @@ sub new { "{" => 76, "=" => 79 }, - DEFAULT => -106 + DEFAULT => -105 }, {#State 110 ACTIONS => { @@ -908,7 +908,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -110 + DEFAULT => -109 }, {#State 111 ACTIONS => { @@ -928,7 +928,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -118 + DEFAULT => -117 }, {#State 112 ACTIONS => { @@ -939,7 +939,7 @@ sub new { "{" => 76, "=" => 79 }, - DEFAULT => -117 + DEFAULT => -116 }, {#State 113 ACTIONS => { @@ -950,7 +950,7 @@ sub new { "{" => 76, "=" => 79 }, - DEFAULT => -108 + DEFAULT => -107 }, {#State 114 ACTIONS => { @@ -970,7 +970,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -114 + DEFAULT => -113 }, {#State 115 ACTIONS => { @@ -990,7 +990,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -100 + DEFAULT => -99 }, {#State 116 ACTIONS => { @@ -1007,7 +1007,7 @@ sub new { "{" => 76, "=" => 79 }, - DEFAULT => -112 + DEFAULT => -111 }, {#State 118 ACTIONS => { @@ -1018,7 +1018,7 @@ sub new { "{" => 76, "=" => 79 }, - DEFAULT => -113 + DEFAULT => -112 }, {#State 119 ACTIONS => { @@ -1038,7 +1038,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -116 + DEFAULT => -115 }, {#State 120 ACTIONS => { @@ -1055,7 +1055,7 @@ sub new { "{" => 76, "=" => 79 }, - DEFAULT => -111 + DEFAULT => -110 }, {#State 122 ACTIONS => { @@ -1066,7 +1066,7 @@ sub new { "{" => 76, "=" => 79 }, - DEFAULT => -107 + DEFAULT => -106 }, {#State 123 ACTIONS => { @@ -1077,7 +1077,7 @@ sub new { "{" => 76, "=" => 79 }, - DEFAULT => -109 + DEFAULT => -108 }, {#State 124 ACTIONS => { @@ -1097,7 +1097,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -99 + DEFAULT => -98 }, {#State 125 DEFAULT => -14 @@ -1111,22 +1111,22 @@ sub new { } }, {#State 127 - DEFAULT => -79 + DEFAULT => -78 }, {#State 128 - DEFAULT => -74, + DEFAULT => -73, GOTOS => { 'union_elements' => 154 } }, {#State 129 - DEFAULT => -78 + DEFAULT => -77 }, {#State 130 DEFAULT => -15 }, {#State 131 - DEFAULT => -44 + DEFAULT => -43 }, {#State 132 ACTIONS => { @@ -1169,16 +1169,16 @@ sub new { } }, {#State 141 - DEFAULT => -68 + DEFAULT => -67 }, {#State 142 - DEFAULT => -83, + DEFAULT => -82, GOTOS => { 'element_list1' => 159 } }, {#State 143 - DEFAULT => -69 + DEFAULT => -68 }, {#State 144 ACTIONS => { @@ -1191,19 +1191,19 @@ sub new { } }, {#State 145 - DEFAULT => -51 + DEFAULT => -50 }, {#State 146 - DEFAULT => -52 + DEFAULT => -51 }, {#State 147 - DEFAULT => -60 + DEFAULT => -59 }, {#State 148 ACTIONS => { 'IDENTIFIER' => 22 }, - DEFAULT => -63, + DEFAULT => -62, GOTOS => { 'identifier' => 165, 'bitmap_element' => 164, @@ -1212,7 +1212,7 @@ sub new { } }, {#State 149 - DEFAULT => -59 + DEFAULT => -58 }, {#State 150 ACTIONS => { @@ -1220,7 +1220,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 167, @@ -1234,7 +1234,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 168, @@ -1248,7 +1248,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 169, @@ -1260,7 +1260,7 @@ sub new { ACTIONS => { "[" => 170 }, - DEFAULT => -89, + DEFAULT => -88, GOTOS => { 'array_len' => 171 } @@ -1269,7 +1269,7 @@ sub new { ACTIONS => { "}" => 172 }, - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'optional_base_element' => 174, 'property_list' => 173 @@ -1277,11 +1277,11 @@ sub new { }, {#State 155 ACTIONS => { - "," => -85, + "," => -84, "void" => 178, - ")" => -85 + ")" => -84 }, - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'base_element' => 175, 'element_list2' => 177, @@ -1303,13 +1303,13 @@ sub new { } }, {#State 158 - DEFAULT => -82 + DEFAULT => -81 }, {#State 159 ACTIONS => { "}" => 182 }, - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'base_element' => 183, 'property_list' => 176 @@ -1319,10 +1319,10 @@ sub new { ACTIONS => { "=" => 184 }, - DEFAULT => -55 + DEFAULT => -54 }, {#State 161 - DEFAULT => -53 + DEFAULT => -52 }, {#State 162 ACTIONS => { @@ -1334,10 +1334,10 @@ sub new { ACTIONS => { "," => 187 }, - DEFAULT => -64 + DEFAULT => -63 }, {#State 164 - DEFAULT => -61 + DEFAULT => -60 }, {#State 165 ACTIONS => { @@ -1367,7 +1367,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -120 + DEFAULT => -119 }, {#State 168 ACTIONS => { @@ -1387,7 +1387,7 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -101 + DEFAULT => -100 }, {#State 169 ACTIONS => { @@ -1398,7 +1398,7 @@ sub new { "{" => 76, "=" => 79 }, - DEFAULT => -119 + DEFAULT => -118 }, {#State 170 ACTIONS => { @@ -1407,7 +1407,7 @@ sub new { "]" => 190, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 191, @@ -1421,13 +1421,13 @@ sub new { } }, {#State 172 - DEFAULT => -76 + DEFAULT => -75 }, {#State 173 ACTIONS => { "[" => 17 }, - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'base_or_empty' => 193, 'base_element' => 194, @@ -1436,10 +1436,10 @@ sub new { } }, {#State 174 - DEFAULT => -75 + DEFAULT => -74 }, {#State 175 - DEFAULT => -87 + DEFAULT => -86 }, {#State 176 ACTIONS => { @@ -1453,7 +1453,6 @@ sub new { "[" => 17, "struct" => 61 }, - DEFAULT => -43, GOTOS => { 'existingtype' => 99, 'bitmap' => 65, @@ -1473,7 +1472,7 @@ sub new { } }, {#State 178 - DEFAULT => -86 + DEFAULT => -85 }, {#State 179 DEFAULT => -28 @@ -1489,7 +1488,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 201, @@ -1498,7 +1497,7 @@ sub new { } }, {#State 182 - DEFAULT => -66 + DEFAULT => -65 }, {#State 183 ACTIONS => { @@ -1511,7 +1510,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 203, @@ -1520,7 +1519,7 @@ sub new { } }, {#State 185 - DEFAULT => -49 + DEFAULT => -48 }, {#State 186 ACTIONS => { @@ -1546,7 +1545,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 206, @@ -1555,13 +1554,13 @@ sub new { } }, {#State 189 - DEFAULT => -57 + DEFAULT => -56 }, {#State 190 ACTIONS => { "[" => 170 }, - DEFAULT => -89, + DEFAULT => -88, GOTOS => { 'array_len' => 207 } @@ -1590,7 +1589,7 @@ sub new { DEFAULT => -35 }, {#State 193 - DEFAULT => -73 + DEFAULT => -72 }, {#State 194 ACTIONS => { @@ -1598,7 +1597,7 @@ sub new { } }, {#State 195 - DEFAULT => -72 + DEFAULT => -71 }, {#State 196 ACTIONS => { @@ -1613,7 +1612,6 @@ sub new { "[" => 17, "struct" => 61 }, - DEFAULT => -43, GOTOS => { 'existingtype' => 99, 'bitmap' => 65, @@ -1627,13 +1625,13 @@ sub new { } }, {#State 197 - DEFAULT => -81, + DEFAULT => -80, GOTOS => { 'pointers' => 211 } }, {#State 198 - DEFAULT => -92, + DEFAULT => -91, GOTOS => { 'base_element' => 212, 'property_list' => 176 @@ -1650,7 +1648,7 @@ sub new { 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -102, + DEFAULT => -101, GOTOS => { 'identifier' => 45, 'anytext' => 214, @@ -1679,7 +1677,7 @@ sub new { } }, {#State 202 - DEFAULT => -84 + DEFAULT => -83 }, {#State 203 ACTIONS => { @@ -1699,13 +1697,13 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -56 + DEFAULT => -55 }, {#State 204 - DEFAULT => -54 + DEFAULT => -53 }, {#State 205 - DEFAULT => -62 + DEFAULT => -61 }, {#State 206 ACTIONS => { @@ -1725,25 +1723,25 @@ sub new { "." => 82, ">" => 83 }, - DEFAULT => -65 + DEFAULT => -64 }, {#State 207 - DEFAULT => -90 + DEFAULT => -89 }, {#State 208 ACTIONS => { "[" => 170 }, - DEFAULT => -89, + DEFAULT => -88, GOTOS => { 'array_len' => 216 } }, {#State 209 - DEFAULT => -71 + DEFAULT => -70 }, {#State 210 - DEFAULT => -70 + DEFAULT => -69 }, {#State 211 ACTIONS => { @@ -1755,7 +1753,7 @@ sub new { } }, {#State 212 - DEFAULT => -88 + DEFAULT => -87 }, {#State 213 DEFAULT => -27 @@ -1784,13 +1782,13 @@ sub new { DEFAULT => -25 }, {#State 216 - DEFAULT => -91 + DEFAULT => -90 }, {#State 217 ACTIONS => { "[" => 170 }, - DEFAULT => -89, + DEFAULT => -88, GOTOS => { 'array_len' => 219 } @@ -1799,7 +1797,7 @@ sub new { DEFAULT => -26 }, {#State 219 - DEFAULT => -80 + DEFAULT => -79 } ], yyrules => @@ -2085,42 +2083,39 @@ sub 'sign', 1, undef ], [#Rule 43 - 'existingtype', 0, undef - ], - [#Rule 44 'existingtype', 2, sub #line 182 "idl.yp" -{ "$_[1] $_[2]" } +{ ($_[1]?$_[1]:"signed") ." $_[2]" } ], - [#Rule 45 + [#Rule 44 'existingtype', 1, undef ], - [#Rule 46 + [#Rule 45 'type', 1, undef ], - [#Rule 47 + [#Rule 46 'type', 1, undef ], - [#Rule 48 + [#Rule 47 'type', 1, sub #line 186 "idl.yp" { "void" } ], - [#Rule 49 + [#Rule 48 'enum_body', 3, sub #line 188 "idl.yp" { $_[2] } ], - [#Rule 50 + [#Rule 49 'opt_enum_body', 0, undef ], - [#Rule 51 + [#Rule 50 'opt_enum_body', 1, undef ], - [#Rule 52 + [#Rule 51 'enum', 3, sub #line 191 "idl.yp" @@ -2130,40 +2125,40 @@ sub "ELEMENTS" => $_[3] }} ], - [#Rule 53 + [#Rule 52 'enum_elements', 1, sub #line 199 "idl.yp" { [ $_[1] ] } ], - [#Rule 54 + [#Rule 53 'enum_elements', 3, sub #line 200 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 55 + [#Rule 54 'enum_element', 1, undef ], - [#Rule 56 + [#Rule 55 'enum_element', 3, sub #line 204 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 57 + [#Rule 56 'bitmap_body', 3, sub #line 207 "idl.yp" { $_[2] } ], - [#Rule 58 + [#Rule 57 'opt_bitmap_body', 0, undef ], - [#Rule 59 + [#Rule 58 'opt_bitmap_body', 1, undef ], - [#Rule 60 + [#Rule 59 'bitmap', 3, sub #line 210 "idl.yp" @@ -2173,43 +2168,43 @@ sub "ELEMENTS" => $_[3] }} ], - [#Rule 61 + [#Rule 60 'bitmap_elements', 1, sub #line 218 "idl.yp" { [ $_[1] ] } ], - [#Rule 62 + [#Rule 61 'bitmap_elements', 3, sub #line 219 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 63 + [#Rule 62 'opt_bitmap_elements', 0, undef ], - [#Rule 64 + [#Rule 63 'opt_bitmap_elements', 1, undef ], - [#Rule 65 + [#Rule 64 'bitmap_element', 3, sub #line 224 "idl.yp" { "$_[1] ( $_[3] )" } ], - [#Rule 66 + [#Rule 65 'struct_body', 3, sub #line 227 "idl.yp" { $_[2] } ], - [#Rule 67 + [#Rule 66 'opt_struct_body', 0, undef ], - [#Rule 68 + [#Rule 67 'opt_struct_body', 1, undef ], - [#Rule 69 + [#Rule 68 'struct', 3, sub #line 231 "idl.yp" @@ -2219,7 +2214,7 @@ sub "ELEMENTS" => $_[3] }} ], - [#Rule 70 + [#Rule 69 'empty_element', 2, sub #line 239 "idl.yp" @@ -2233,40 +2228,40 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 71 + [#Rule 70 'base_or_empty', 2, undef ], - [#Rule 72 + [#Rule 71 'base_or_empty', 1, undef ], - [#Rule 73 + [#Rule 72 'optional_base_element', 2, sub #line 253 "idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], - [#Rule 74 + [#Rule 73 'union_elements', 0, undef ], - [#Rule 75 + [#Rule 74 'union_elements', 2, sub #line 258 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 76 + [#Rule 75 'union_body', 3, sub #line 261 "idl.yp" { $_[2] } ], - [#Rule 77 + [#Rule 76 'opt_union_body', 0, undef ], - [#Rule 78 + [#Rule 77 'opt_union_body', 1, undef ], - [#Rule 79 + [#Rule 78 'union', 3, sub #line 265 "idl.yp" @@ -2276,7 +2271,7 @@ sub "ELEMENTS" => $_[3] }} ], - [#Rule 80 + [#Rule 79 'base_element', 5, sub #line 273 "idl.yp" @@ -2290,117 +2285,120 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 81 + [#Rule 80 'pointers', 0, sub #line 287 "idl.yp" { 0 } ], - [#Rule 82 + [#Rule 81 'pointers', 2, sub #line 288 "idl.yp" { $_[1]+1 } ], - [#Rule 83 + [#Rule 82 'element_list1', 0, undef ], - [#Rule 84 + [#Rule 83 'element_list1', 3, sub #line 293 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 85 + [#Rule 84 'element_list2', 0, undef ], - [#Rule 86 + [#Rule 85 'element_list2', 1, undef ], - [#Rule 87 + [#Rule 86 'element_list2', 1, sub #line 299 "idl.yp" { [ $_[1] ] } ], - [#Rule 88 + [#Rule 87 'element_list2', 3, sub #line 300 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 89 + [#Rule 88 'array_len', 0, undef ], - [#Rule 90 + [#Rule 89 'array_len', 3, sub #line 305 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], - [#Rule 91 + [#Rule 90 'array_len', 4, sub #line 306 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], - [#Rule 92 + [#Rule 91 'property_list', 0, undef ], - [#Rule 93 + [#Rule 92 'property_list', 4, sub #line 312 "idl.yp" { FlattenHash([$_[1],$_[3]]); } ], - [#Rule 94 + [#Rule 93 'properties', 1, sub #line 315 "idl.yp" { $_[1] } ], - [#Rule 95 + [#Rule 94 'properties', 3, sub #line 316 "idl.yp" { FlattenHash([$_[1], $_[3]]); } ], - [#Rule 96 + [#Rule 95 'property', 1, sub #line 319 "idl.yp" {{ "$_[1]" => "1" }} ], - [#Rule 97 + [#Rule 96 'property', 4, sub #line 320 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], - [#Rule 98 + [#Rule 97 'listtext', 1, undef ], - [#Rule 99 + [#Rule 98 'listtext', 3, sub #line 325 "idl.yp" { "$_[1] $_[3]" } ], - [#Rule 100 + [#Rule 99 'commalisttext', 1, undef ], - [#Rule 101 + [#Rule 100 'commalisttext', 3, sub #line 330 "idl.yp" { "$_[1],$_[3]" } ], - [#Rule 102 + [#Rule 101 'anytext', 0, sub #line 334 "idl.yp" { "" } ], + [#Rule 102 + 'anytext', 1, undef + ], [#Rule 103 'anytext', 1, undef ], @@ -2408,120 +2406,117 @@ sub 'anytext', 1, undef ], [#Rule 105 - 'anytext', 1, undef - ], - [#Rule 106 'anytext', 3, sub #line 336 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 107 + [#Rule 106 'anytext', 3, sub #line 337 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 108 + [#Rule 107 'anytext', 3, sub #line 338 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 109 + [#Rule 108 'anytext', 3, sub #line 339 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 110 + [#Rule 109 'anytext', 3, sub #line 340 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 111 + [#Rule 110 'anytext', 3, sub #line 341 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 112 + [#Rule 111 'anytext', 3, sub #line 342 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 113 + [#Rule 112 'anytext', 3, sub #line 343 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 114 + [#Rule 113 'anytext', 3, sub #line 344 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 115 + [#Rule 114 'anytext', 3, sub #line 345 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 116 + [#Rule 115 'anytext', 3, sub #line 346 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 117 + [#Rule 116 'anytext', 3, sub #line 347 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 118 + [#Rule 117 'anytext', 3, sub #line 348 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 119 + [#Rule 118 'anytext', 5, sub #line 349 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 120 + [#Rule 119 'anytext', 5, sub #line 350 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 121 + [#Rule 120 'identifier', 1, undef ], - [#Rule 122 + [#Rule 121 'optional_identifier', 1, undef ], - [#Rule 123 + [#Rule 122 'optional_identifier', 0, undef ], - [#Rule 124 + [#Rule 123 'constant', 1, undef ], - [#Rule 125 + [#Rule 124 'text', 1, sub #line 364 "idl.yp" { "\"$_[1]\"" } ], - [#Rule 126 + [#Rule 125 'optional_semicolon', 0, undef ], - [#Rule 127 + [#Rule 126 'optional_semicolon', 1, undef ] ], -- cgit From bf39b5e5929449b7ef8685b6c7737efd3a31843b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 9 Jan 2007 15:50:36 +0000 Subject: r20631: Add some tests for the ndr parser. (This used to be commit ded25eca701b8e3e0e13e7ef64d5511d8953eb0d) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 3 ++- source4/pidl/lib/Parse/Pidl/Util.pm | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index f8cae5665f..462e577cdd 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -35,6 +35,7 @@ use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); +@EXPORT_OK = qw(GetElementLevelTable ParseElement); use strict; use Parse::Pidl qw(warning fatal); @@ -837,7 +838,7 @@ sub ValidProperties($$) return unless defined $e->{PROPERTIES}; foreach my $key (keys %{$e->{PROPERTIES}}) { - fatal($e, el_name($e) . ": unknown property '$key'") + warning($e, el_name($e) . ": unknown property '$key'") unless defined($property_list{$key}); fatal($e, el_name($e) . ": property '$key' not allowed on '$t'") diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 11e738fd13..35338492dd 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -6,7 +6,7 @@ package Parse::Pidl::Util; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(has_property property_matches ParseExpr is_constant make_str print_uuid); +@EXPORT = qw(has_property property_matches ParseExpr is_constant make_str print_uuid MyDumper); use vars qw($VERSION); $VERSION = '0.01'; -- cgit From 95f7f4d001684d447ce8e0f880200cfac89f011a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 9 Jan 2007 23:41:25 +0000 Subject: r20637: Don't check for NULL pointers when the pointer is guaranteed to not be NULL (if it is a ref pointer). (This used to be commit 419547df76c38fde1f54b06dc633832523ad3394) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 107 ++++++++++++++--------- source4/pidl/lib/Parse/Pidl/Util.pm | 19 +++- 2 files changed, 84 insertions(+), 42 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index debdc8e308..49f9e051a8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -10,12 +10,14 @@ package Parse::Pidl::Samba4::NDR::Parser; require Exporter; @ISA = qw(Exporter); @EXPORT = qw(is_charset_array); +@EXPORT_OK = qw(check_null_pointer); use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); -use Parse::Pidl::Util qw(has_property ParseExpr print_uuid); +use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::Samba4 qw(is_intree choose_header); +use Parse::Pidl qw(warning); use vars qw($VERSION); $VERSION = '0.01'; @@ -164,29 +166,6 @@ sub deindent() $tabs = substr($tabs, 0, -1); } -##################################################################### -# check that a variable we get from ParseExpr isn't a null pointer -sub check_null_pointer($) -{ - my $size = shift; - if ($size =~ /^\*/) { - my $size2 = substr($size, 1); - pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; - } -} - -##################################################################### -# check that a variable we get from ParseExpr isn't a null pointer, -# putting the check at the end of the structure/function -sub check_null_pointer_deferred($) -{ - my $size = shift; - if ($size =~ /^\*/) { - my $size2 = substr($size, 1); - defer "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; - } -} - ##################################################################### # declare a function public or static, depending on its attributes sub fn_declare($$$) @@ -325,6 +304,61 @@ sub ParseArrayPushHeader($$$$$) return $length; } +sub check_null_pointer($$$) +{ + my ($element, $env, $print_fn) = @_; + + return sub ($) { + my $expandedvar = shift; + my $check = 0; + + # Figure out the number of pointers in $ptr + $expandedvar =~ s/^(\**)//; + my $ptr = $1; + + my $var = undef; + foreach (keys %$env) { + if ($env->{$_} eq $expandedvar) { + $var = $_; + last; + } + } + + if (defined($var)) { + my $e; + # lookup ptr in $e + foreach (@{$element->{PARENT}->{ELEMENTS}}) { + if ($_->{NAME} eq $var) { + $e = $_; + last; + } + } + + $e or die("Environment doesn't match siblings"); + + # See if pointer at pointer level $level + # needs to be checked. + foreach my $l (@{$e->{LEVELS}}) { + if ($l->{TYPE} eq "POINTER" and + $l->{POINTER_INDEX} == length($ptr)) { + # No need to check ref pointers + $check = ($l->{POINTER_TYPE} ne "ref"); + last; + } + + if ($l->{TYPE} eq "DATA") { + warning($element, "too much dereferences for `$var'"); + } + } + } else { + warning($element, "unknown dereferenced expression `$expandedvar'"); + $check = 1; + } + + $print_fn->("if ($ptr$expandedvar == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;") if $check; + } +} + ##################################################################### # parse an array - pull side sub ParseArrayPullHeader($$$$$) @@ -339,21 +373,19 @@ sub ParseArrayPullHeader($$$$$) } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))"; } else { - $length = $size = ParseExpr($l->{SIZE_IS}, $env, $e); + $length = $size = ParseExprExt($l->{SIZE_IS}, $env, $e, + check_null_pointer($e, $env, \&pidl)); } if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { pidl "NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));"; } - if ($l->{IS_VARYING}) { pidl "NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));"; $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")"; } - check_null_pointer($length); - if ($length ne $size) { pidl "if ($length > $size) {"; indent; @@ -363,20 +395,18 @@ sub ParseArrayPullHeader($$$$$) } if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { - my $size = ParseExpr($l->{SIZE_IS}, $env, $e); defer "if ($var_name) {"; defer_indent; - check_null_pointer_deferred($size); + my $size = ParseExprExt($l->{SIZE_IS}, $env, $e, check_null_pointer($e, $env, \&defer)); defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"; defer_deindent; defer "}"; } if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { - my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); defer "if ($var_name) {"; defer_indent; - check_null_pointer_deferred($length); + my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e, check_null_pointer($e, $env, \&defer)); defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"; defer_deindent; defer "}" @@ -661,7 +691,7 @@ sub ParsePtrPush($$$) my ($e,$l,$var_name) = @_; if ($l->{POINTER_TYPE} eq "ref") { - check_null_pointer(get_value_of($var_name)); + pidl "if ($var_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; if ($l->{LEVEL} eq "EMBEDDED") { pidl "NDR_CHECK(ndr_push_ref_ptr(ndr));"; } @@ -774,9 +804,7 @@ sub ParseElementPrint($$$) sub ParseSwitchPull($$$$$$) { my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); - - check_null_pointer($switch_var); + my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, check_null_pointer($e, $env, \&pidl)); $var_name = get_pointer_to($var_name); pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));"; @@ -787,9 +815,8 @@ sub ParseSwitchPull($$$$$$) sub ParseSwitchPush($$$$$$) { my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); + my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, check_null_pointer($e, $env, \&pidl)); - check_null_pointer($switch_var); $var_name = get_pointer_to($var_name); pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"; } @@ -2014,7 +2041,6 @@ sub AllocateArrayLevel($$$$$) my $var = ParseExpr($e->{NAME}, $env, $e); - check_null_pointer($size); my $pl = GetPrevLevel($e, $l); if (defined($pl) and $pl->{TYPE} eq "POINTER" and @@ -2093,8 +2119,7 @@ sub ParseFunctionPull($) and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}); if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { - my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env, $e); - check_null_pointer($size); + my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e, check_null_pointer($e, $env, \&pidl)); pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"; diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 35338492dd..35e25286f5 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -6,7 +6,7 @@ package Parse::Pidl::Util; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(has_property property_matches ParseExpr is_constant make_str print_uuid MyDumper); +@EXPORT = qw(has_property property_matches ParseExpr ParseExprExt is_constant make_str print_uuid MyDumper); use vars qw($VERSION); $VERSION = '0.01'; @@ -115,4 +115,21 @@ sub ParseExpr($$$) undef); } +sub ParseExprExt($$$$) +{ + my($expr, $varlist, $e, $deref) = @_; + + die("Undefined value in ParseExpr") if not defined($expr); + + my $x = new Parse::Pidl::Expr(); + + return $x->Run($expr, sub { my $x = shift; error($e, $x); }, + # Lookup fn + sub { my $x = shift; + return($varlist->{$x}) if (defined($varlist->{$x})); + return $x; + }, + $deref); +} + 1; -- cgit From 348b7bc380e4ce95cf053134e62c3f5ab6520e34 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 10 Jan 2007 00:37:30 +0000 Subject: r20638: Check for NULL pointers (where possible) in print functions. Fixes #4218, but without reintroducing coverity warnings. (This used to be commit a0e2e30d570f246d646f88d7f81ab08208b96131) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 51 ++++++++++++------------ 1 file changed, 26 insertions(+), 25 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 49f9e051a8..2212044d3b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -304,9 +304,9 @@ sub ParseArrayPushHeader($$$$$) return $length; } -sub check_null_pointer($$$) +sub check_null_pointer($$$$) { - my ($element, $env, $print_fn) = @_; + my ($element, $env, $print_fn, $return) = @_; return sub ($) { my $expandedvar = shift; @@ -355,7 +355,7 @@ sub check_null_pointer($$$) $check = 1; } - $print_fn->("if ($ptr$expandedvar == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;") if $check; + $print_fn->("if ($ptr$expandedvar == NULL) $return") if $check; } } @@ -374,7 +374,7 @@ sub ParseArrayPullHeader($$$$$) $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))"; } else { $length = $size = ParseExprExt($l->{SIZE_IS}, $env, $e, - check_null_pointer($e, $env, \&pidl)); + check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;")); } if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { @@ -397,7 +397,7 @@ sub ParseArrayPullHeader($$$$$) if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { defer "if ($var_name) {"; defer_indent; - my $size = ParseExprExt($l->{SIZE_IS}, $env, $e, check_null_pointer($e, $env, \&defer)); + my $size = ParseExprExt($l->{SIZE_IS}, $env, $e, check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;")); defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"; defer_deindent; defer "}"; @@ -406,7 +406,7 @@ sub ParseArrayPullHeader($$$$$) if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { defer "if ($var_name) {"; defer_indent; - my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e, check_null_pointer($e, $env, \&defer)); + my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e, check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;")); defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"; defer_deindent; defer "}" @@ -421,18 +421,16 @@ sub ParseArrayPullHeader($$$$$) sub compression_alg($$) { - my ($e,$l) = @_; - my $compression = $l->{COMPRESSION}; - my ($alg, $clen, $dlen) = split(/ /, $compression); + my ($e, $l) = @_; + my ($alg, $clen, $dlen) = split(/ /, $l->{COMPRESSION}); return $alg; } sub compression_clen($$$) { - my ($e,$l,$env) = @_; - my $compression = $l->{COMPRESSION}; - my ($alg, $clen, $dlen) = split(/ /, $compression); + my ($e, $l, $env) = @_; + my ($alg, $clen, $dlen) = split(/ /, $l->{COMPRESSION}); return ParseExpr($clen, $env, $e); } @@ -440,8 +438,7 @@ sub compression_clen($$$) sub compression_dlen($$$) { my ($e,$l,$env) = @_; - my $compression = $l->{COMPRESSION}; - my ($alg, $clen, $dlen) = split(/ /, $compression); + my ($alg, $clen, $dlen) = split(/ /, $l->{COMPRESSION}); return ParseExpr($dlen, $env, $e); } @@ -504,7 +501,7 @@ sub ParseSubcontextPushStart($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env, $e); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e); pidl "{"; indent; @@ -522,7 +519,7 @@ sub ParseSubcontextPushEnd($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env, $e); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e); if (defined $l->{COMPRESSION}) { ParseCompressionPushEnd($e, $l, $subndr, $env); @@ -537,7 +534,7 @@ sub ParseSubcontextPullStart($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env, $e); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e); pidl "{"; indent; @@ -555,7 +552,7 @@ sub ParseSubcontextPullEnd($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env, $e); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e); if (defined $l->{COMPRESSION}) { ParseCompressionPullEnd($e, $l, $subndr, $env); @@ -710,7 +707,7 @@ sub ParsePtrPush($$$) # print scalars in a structure element sub ParseElementPrint($$$) { - my($e,$var_name,$env) = @_; + my($e, $var_name, $env) = @_; return if (has_property($e, "noprint")); @@ -744,7 +741,8 @@ sub ParseElementPrint($$$) if ($l->{IS_ZERO_TERMINATED}) { $length = "ndr_string_length($var_name, sizeof(*$var_name))"; } else { - $length = ParseExpr($l->{LENGTH_IS}, $env, $e); + $length = ParseExprExt($l->{LENGTH_IS}, $env, $e, + check_null_pointer($e, $env, \&pidl, "return;")); } if (is_charset_array($e,$l)) { @@ -774,7 +772,8 @@ sub ParseElementPrint($$$) } pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; } elsif ($l->{TYPE} eq "SWITCH") { - my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); + my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, + check_null_pointer($e, $env, \&pidl, "return;")); pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"; } } @@ -804,7 +803,8 @@ sub ParseElementPrint($$$) sub ParseSwitchPull($$$$$$) { my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, check_null_pointer($e, $env, \&pidl)); + my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, + check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;")); $var_name = get_pointer_to($var_name); pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));"; @@ -815,7 +815,8 @@ sub ParseSwitchPull($$$$$$) sub ParseSwitchPush($$$$$$) { my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, check_null_pointer($e, $env, \&pidl)); + my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, + check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;")); $var_name = get_pointer_to($var_name); pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"; @@ -1000,7 +1001,7 @@ sub ParseElementPullLevel ParseMemCtxPullStart($e,$l, $var_name); $var_name = get_value_of($var_name); - ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); + ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); ParseMemCtxPullEnd($e,$l); @@ -2119,7 +2120,7 @@ sub ParseFunctionPull($) and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}); if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { - my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e, check_null_pointer($e, $env, \&pidl)); + my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e, check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;")); pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"; -- cgit From d9665a737b978d0fcca1fd23ab04858e2fa81284 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 14 Jan 2007 01:33:16 +0000 Subject: r20746: Don't report each individual test in test_smbclient as a single testsuite. Create separate directory for blackbox tests. (This used to be commit 7e6357f21350d264ebedabd34f2b8f42fc0427ff) --- source4/pidl/lib/Parse/Pidl/Expr.pm | 68 ++++++++-------- source4/pidl/lib/Parse/Pidl/IDL.pm | 154 ++++++++++++++++++------------------ 2 files changed, 111 insertions(+), 111 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Expr.pm b/source4/pidl/lib/Parse/Pidl/Expr.pm index c6e5cd3dca..34c30b824f 100644 --- a/source4/pidl/lib/Parse/Pidl/Expr.pm +++ b/source4/pidl/lib/Parse/Pidl/Expr.pm @@ -1085,7 +1085,7 @@ sub new { [#Rule 2 'exp', 1, sub -#line 22 "expr.yp" +#line 22 "pidl/expr.yp" { "\"$_[1]\"" } ], [#Rule 3 @@ -1094,187 +1094,187 @@ sub [#Rule 4 'exp', 3, sub -#line 24 "expr.yp" +#line 24 "pidl/expr.yp" { "$_[1].$_[3]" } ], [#Rule 5 'exp', 1, sub -#line 25 "expr.yp" +#line 25 "pidl/expr.yp" { $_[0]->_Lookup($_[1]) } ], [#Rule 6 'exp', 2, sub -#line 26 "expr.yp" +#line 26 "pidl/expr.yp" { $_[0]->_Dereference($_[2]); "*$_[2]" } ], [#Rule 7 'exp', 2, sub -#line 27 "expr.yp" +#line 27 "pidl/expr.yp" { "~$_[2]" } ], [#Rule 8 'exp', 3, sub -#line 28 "expr.yp" +#line 28 "pidl/expr.yp" { "$_[1] + $_[3]" } ], [#Rule 9 'exp', 3, sub -#line 29 "expr.yp" +#line 29 "pidl/expr.yp" { "$_[1] - $_[3]" } ], [#Rule 10 'exp', 3, sub -#line 30 "expr.yp" +#line 30 "pidl/expr.yp" { "$_[1] * $_[3]" } ], [#Rule 11 'exp', 3, sub -#line 31 "expr.yp" +#line 31 "pidl/expr.yp" { "$_[1] % $_[3]" } ], [#Rule 12 'exp', 3, sub -#line 32 "expr.yp" +#line 32 "pidl/expr.yp" { "$_[1] < $_[3]" } ], [#Rule 13 'exp', 3, sub -#line 33 "expr.yp" +#line 33 "pidl/expr.yp" { "$_[1] > $_[3]" } ], [#Rule 14 'exp', 3, sub -#line 34 "expr.yp" +#line 34 "pidl/expr.yp" { "$_[1] | $_[3]" } ], [#Rule 15 'exp', 3, sub -#line 35 "expr.yp" +#line 35 "pidl/expr.yp" { "$_[1] == $_[3]" } ], [#Rule 16 'exp', 3, sub -#line 36 "expr.yp" +#line 36 "pidl/expr.yp" { "$_[1] <= $_[3]" } ], [#Rule 17 'exp', 3, sub -#line 37 "expr.yp" +#line 37 "pidl/expr.yp" { "$_[1] => $_[3]" } ], [#Rule 18 'exp', 3, sub -#line 38 "expr.yp" +#line 38 "pidl/expr.yp" { "$_[1] << $_[3]" } ], [#Rule 19 'exp', 3, sub -#line 39 "expr.yp" +#line 39 "pidl/expr.yp" { "$_[1] >> $_[3]" } ], [#Rule 20 'exp', 3, sub -#line 40 "expr.yp" +#line 40 "pidl/expr.yp" { "$_[1] != $_[3]" } ], [#Rule 21 'exp', 3, sub -#line 41 "expr.yp" +#line 41 "pidl/expr.yp" { "$_[1] || $_[3]" } ], [#Rule 22 'exp', 3, sub -#line 42 "expr.yp" +#line 42 "pidl/expr.yp" { "$_[1] && $_[3]" } ], [#Rule 23 'exp', 3, sub -#line 43 "expr.yp" +#line 43 "pidl/expr.yp" { "$_[1] & $_[3]" } ], [#Rule 24 'exp', 3, sub -#line 44 "expr.yp" +#line 44 "pidl/expr.yp" { $_[1]."->".$_[3] } ], [#Rule 25 'exp', 5, sub -#line 45 "expr.yp" +#line 45 "pidl/expr.yp" { "$_[1]?$_[3]:$_[5]" } ], [#Rule 26 'exp', 2, sub -#line 46 "expr.yp" +#line 46 "pidl/expr.yp" { "~$_[1]" } ], [#Rule 27 'exp', 2, sub -#line 47 "expr.yp" +#line 47 "pidl/expr.yp" { "not $_[1]" } ], [#Rule 28 'exp', 3, sub -#line 48 "expr.yp" +#line 48 "pidl/expr.yp" { "$_[1] / $_[3]" } ], [#Rule 29 'exp', 2, sub -#line 49 "expr.yp" +#line 49 "pidl/expr.yp" { "-$_[2]" } ], [#Rule 30 'exp', 2, sub -#line 50 "expr.yp" +#line 50 "pidl/expr.yp" { "&$_[2]" } ], [#Rule 31 'exp', 3, sub -#line 51 "expr.yp" +#line 51 "pidl/expr.yp" { "$_[1]^$_[3]" } ], [#Rule 32 'exp', 3, sub -#line 52 "expr.yp" +#line 52 "pidl/expr.yp" { "($_[2])" } ], [#Rule 33 'func', 4, sub -#line 55 "expr.yp" +#line 55 "pidl/expr.yp" { "$_[1]($_[3])" } ], [#Rule 34 'opt_args', 0, sub -#line 56 "expr.yp" +#line 56 "pidl/expr.yp" { "" } ], [#Rule 35 @@ -1286,7 +1286,7 @@ sub [#Rule 37 'args', 3, sub -#line 57 "expr.yp" +#line 57 "pidl/expr.yp" { "$_[1], $_[3]" } ] ], @@ -1294,7 +1294,7 @@ sub bless($self,$class); } -#line 59 "expr.yp" +#line 59 "pidl/expr.yp" package Parse::Pidl::Expr; diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 3d9eb4ea74..71c4470870 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -1811,37 +1811,37 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "idl.yp" +#line 19 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "idl.yp" +#line 20 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'idl', 2, sub -#line 21 "idl.yp" +#line 21 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 5 'idl', 2, sub -#line 22 "idl.yp" +#line 22 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 6 'idl', 2, sub -#line 23 "idl.yp" +#line 23 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'import', 3, sub -#line 26 "idl.yp" +#line 26 "pidl/idl.yp" {{ "TYPE" => "IMPORT", "PATHS" => $_[2], @@ -1852,7 +1852,7 @@ sub [#Rule 8 'include', 3, sub -#line 33 "idl.yp" +#line 33 "pidl/idl.yp" {{ "TYPE" => "INCLUDE", "PATHS" => $_[2], @@ -1863,7 +1863,7 @@ sub [#Rule 9 'importlib', 3, sub -#line 40 "idl.yp" +#line 40 "pidl/idl.yp" {{ "TYPE" => "IMPORTLIB", "PATHS" => $_[2], @@ -1874,19 +1874,19 @@ sub [#Rule 10 'commalist', 1, sub -#line 49 "idl.yp" +#line 49 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 11 'commalist', 3, sub -#line 50 "idl.yp" +#line 50 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 12 'coclass', 7, sub -#line 54 "idl.yp" +#line 54 "pidl/idl.yp" {{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -1902,13 +1902,13 @@ sub [#Rule 14 'interface_names', 4, sub -#line 66 "idl.yp" +#line 66 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 15 'interface', 8, sub -#line 70 "idl.yp" +#line 70 "pidl/idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -1925,19 +1925,19 @@ sub [#Rule 17 'base_interface', 2, sub -#line 83 "idl.yp" +#line 83 "pidl/idl.yp" { $_[2] } ], [#Rule 18 'definitions', 1, sub -#line 87 "idl.yp" +#line 87 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 19 'definitions', 2, sub -#line 88 "idl.yp" +#line 88 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 20 @@ -1958,7 +1958,7 @@ sub [#Rule 25 'const', 7, sub -#line 96 "idl.yp" +#line 96 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1972,7 +1972,7 @@ sub [#Rule 26 'const', 8, sub -#line 106 "idl.yp" +#line 106 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1987,7 +1987,7 @@ sub [#Rule 27 'function', 7, sub -#line 120 "idl.yp" +#line 120 "pidl/idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2001,7 +2001,7 @@ sub [#Rule 28 'declare', 5, sub -#line 132 "idl.yp" +#line 132 "pidl/idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2023,7 +2023,7 @@ sub [#Rule 32 'decl_enum', 1, sub -#line 146 "idl.yp" +#line 146 "pidl/idl.yp" {{ "TYPE" => "ENUM" }} @@ -2031,7 +2031,7 @@ sub [#Rule 33 'decl_bitmap', 1, sub -#line 152 "idl.yp" +#line 152 "pidl/idl.yp" {{ "TYPE" => "BITMAP" }} @@ -2039,7 +2039,7 @@ sub [#Rule 34 'decl_union', 1, sub -#line 158 "idl.yp" +#line 158 "pidl/idl.yp" {{ "TYPE" => "UNION" }} @@ -2047,7 +2047,7 @@ sub [#Rule 35 'typedef', 6, sub -#line 164 "idl.yp" +#line 164 "pidl/idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[2], @@ -2073,7 +2073,7 @@ sub [#Rule 40 'typedecl', 2, sub -#line 177 "idl.yp" +#line 177 "pidl/idl.yp" { $_[1] } ], [#Rule 41 @@ -2085,7 +2085,7 @@ sub [#Rule 43 'existingtype', 2, sub -#line 182 "idl.yp" +#line 182 "pidl/idl.yp" { ($_[1]?$_[1]:"signed") ." $_[2]" } ], [#Rule 44 @@ -2100,13 +2100,13 @@ sub [#Rule 47 'type', 1, sub -#line 186 "idl.yp" +#line 186 "pidl/idl.yp" { "void" } ], [#Rule 48 'enum_body', 3, sub -#line 188 "idl.yp" +#line 188 "pidl/idl.yp" { $_[2] } ], [#Rule 49 @@ -2118,7 +2118,7 @@ sub [#Rule 51 'enum', 3, sub -#line 191 "idl.yp" +#line 191 "pidl/idl.yp" {{ "TYPE" => "ENUM", "NAME" => $_[2], @@ -2128,13 +2128,13 @@ sub [#Rule 52 'enum_elements', 1, sub -#line 199 "idl.yp" +#line 199 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 53 'enum_elements', 3, sub -#line 200 "idl.yp" +#line 200 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 54 @@ -2143,13 +2143,13 @@ sub [#Rule 55 'enum_element', 3, sub -#line 204 "idl.yp" +#line 204 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 56 'bitmap_body', 3, sub -#line 207 "idl.yp" +#line 207 "pidl/idl.yp" { $_[2] } ], [#Rule 57 @@ -2161,7 +2161,7 @@ sub [#Rule 59 'bitmap', 3, sub -#line 210 "idl.yp" +#line 210 "pidl/idl.yp" {{ "TYPE" => "BITMAP", "NAME" => $_[2], @@ -2171,13 +2171,13 @@ sub [#Rule 60 'bitmap_elements', 1, sub -#line 218 "idl.yp" +#line 218 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 61 'bitmap_elements', 3, sub -#line 219 "idl.yp" +#line 219 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 62 @@ -2189,13 +2189,13 @@ sub [#Rule 64 'bitmap_element', 3, sub -#line 224 "idl.yp" +#line 224 "pidl/idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 65 'struct_body', 3, sub -#line 227 "idl.yp" +#line 227 "pidl/idl.yp" { $_[2] } ], [#Rule 66 @@ -2207,7 +2207,7 @@ sub [#Rule 68 'struct', 3, sub -#line 231 "idl.yp" +#line 231 "pidl/idl.yp" {{ "TYPE" => "STRUCT", "NAME" => $_[2], @@ -2217,7 +2217,7 @@ sub [#Rule 69 'empty_element', 2, sub -#line 239 "idl.yp" +#line 239 "pidl/idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2237,7 +2237,7 @@ sub [#Rule 72 'optional_base_element', 2, sub -#line 253 "idl.yp" +#line 253 "pidl/idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 73 @@ -2246,13 +2246,13 @@ sub [#Rule 74 'union_elements', 2, sub -#line 258 "idl.yp" +#line 258 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 75 'union_body', 3, sub -#line 261 "idl.yp" +#line 261 "pidl/idl.yp" { $_[2] } ], [#Rule 76 @@ -2264,7 +2264,7 @@ sub [#Rule 78 'union', 3, sub -#line 265 "idl.yp" +#line 265 "pidl/idl.yp" {{ "TYPE" => "UNION", "NAME" => $_[2], @@ -2274,7 +2274,7 @@ sub [#Rule 79 'base_element', 5, sub -#line 273 "idl.yp" +#line 273 "pidl/idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2288,13 +2288,13 @@ sub [#Rule 80 'pointers', 0, sub -#line 287 "idl.yp" +#line 287 "pidl/idl.yp" { 0 } ], [#Rule 81 'pointers', 2, sub -#line 288 "idl.yp" +#line 288 "pidl/idl.yp" { $_[1]+1 } ], [#Rule 82 @@ -2303,7 +2303,7 @@ sub [#Rule 83 'element_list1', 3, sub -#line 293 "idl.yp" +#line 293 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 84 @@ -2315,13 +2315,13 @@ sub [#Rule 86 'element_list2', 1, sub -#line 299 "idl.yp" +#line 299 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 87 'element_list2', 3, sub -#line 300 "idl.yp" +#line 300 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 88 @@ -2330,13 +2330,13 @@ sub [#Rule 89 'array_len', 3, sub -#line 305 "idl.yp" +#line 305 "pidl/idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 90 'array_len', 4, sub -#line 306 "idl.yp" +#line 306 "pidl/idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 91 @@ -2345,31 +2345,31 @@ sub [#Rule 92 'property_list', 4, sub -#line 312 "idl.yp" +#line 312 "pidl/idl.yp" { FlattenHash([$_[1],$_[3]]); } ], [#Rule 93 'properties', 1, sub -#line 315 "idl.yp" +#line 315 "pidl/idl.yp" { $_[1] } ], [#Rule 94 'properties', 3, sub -#line 316 "idl.yp" +#line 316 "pidl/idl.yp" { FlattenHash([$_[1], $_[3]]); } ], [#Rule 95 'property', 1, sub -#line 319 "idl.yp" +#line 319 "pidl/idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 96 'property', 4, sub -#line 320 "idl.yp" +#line 320 "pidl/idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 97 @@ -2378,7 +2378,7 @@ sub [#Rule 98 'listtext', 3, sub -#line 325 "idl.yp" +#line 325 "pidl/idl.yp" { "$_[1] $_[3]" } ], [#Rule 99 @@ -2387,13 +2387,13 @@ sub [#Rule 100 'commalisttext', 3, sub -#line 330 "idl.yp" +#line 330 "pidl/idl.yp" { "$_[1],$_[3]" } ], [#Rule 101 'anytext', 0, sub -#line 334 "idl.yp" +#line 334 "pidl/idl.yp" { "" } ], [#Rule 102 @@ -2408,91 +2408,91 @@ sub [#Rule 105 'anytext', 3, sub -#line 336 "idl.yp" +#line 336 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 106 'anytext', 3, sub -#line 337 "idl.yp" +#line 337 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 338 "idl.yp" +#line 338 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 'anytext', 3, sub -#line 339 "idl.yp" +#line 339 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 109 'anytext', 3, sub -#line 340 "idl.yp" +#line 340 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 110 'anytext', 3, sub -#line 341 "idl.yp" +#line 341 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 111 'anytext', 3, sub -#line 342 "idl.yp" +#line 342 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 112 'anytext', 3, sub -#line 343 "idl.yp" +#line 343 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 113 'anytext', 3, sub -#line 344 "idl.yp" +#line 344 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 114 'anytext', 3, sub -#line 345 "idl.yp" +#line 345 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 115 'anytext', 3, sub -#line 346 "idl.yp" +#line 346 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 116 'anytext', 3, sub -#line 347 "idl.yp" +#line 347 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 117 'anytext', 3, sub -#line 348 "idl.yp" +#line 348 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 118 'anytext', 5, sub -#line 349 "idl.yp" +#line 349 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 119 'anytext', 5, sub -#line 350 "idl.yp" +#line 350 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 120 @@ -2510,7 +2510,7 @@ sub [#Rule 124 'text', 1, sub -#line 364 "idl.yp" +#line 364 "pidl/idl.yp" { "\"$_[1]\"" } ], [#Rule 125 @@ -2524,7 +2524,7 @@ sub bless($self,$class); } -#line 375 "idl.yp" +#line 375 "pidl/idl.yp" use Parse::Pidl qw(error); -- cgit From 615895332a73ad372bcb5918190cbfff6ba83e05 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 16 Jan 2007 14:44:23 +0000 Subject: r20830: merge mgmt work (This used to be commit 3cc299dbbe278936281f8e7071e6de8ec1bb219c) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index abc3b786b9..102b0fc769 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -186,7 +186,7 @@ static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_C return NT_STATUS_OK; } -static const struct dcesrv_interface $name\_interface = { +const struct dcesrv_interface dcesrv\_$name\_interface = { .name = \"$name\", .syntax_id = {".print_uuid($uuid).",$if_version}, .bind = $name\__op_bind, @@ -217,7 +217,7 @@ static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const str NTSTATUS ret; const char *name = dcerpc_table_$name.endpoints->names[i]; - ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL); + ret = dcesrv_interface_register(dce_ctx, name, &dcesrv_$name\_interface, NULL); if (!NT_STATUS_IS_OK(ret)) { DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name)); return ret; @@ -229,9 +229,9 @@ static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const str static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version) { - if ($name\_interface.syntax_id.if_version == if_version && - GUID_equal(\&$name\_interface.syntax_id.uuid, uuid)) { - memcpy(iface,&$name\_interface, sizeof(*iface)); + if (dcesrv_$name\_interface.syntax_id.if_version == if_version && + GUID_equal(\&dcesrv\_$name\_interface.syntax_id.uuid, uuid)) { + memcpy(iface,&dcesrv\_$name\_interface, sizeof(*iface)); return True; } @@ -240,8 +240,8 @@ static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const s static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) { - if (strcmp($name\_interface.name, name)==0) { - memcpy(iface,&$name\_interface, sizeof(*iface)); + if (strcmp(dcesrv_$name\_interface.name, name)==0) { + memcpy(iface, &dcesrv_$name\_interface, sizeof(*iface)); return True; } -- cgit From 85520faa42647c9d7ee7e519d4f2139de82ae4a9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 16 Jan 2007 15:51:37 +0000 Subject: r20834: No longer generate extra pointers for top-level [out] unique pointers. (This used to be commit b967f5851f24a4716d386fc569e384b9320b162a) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 17 +++++++-------- source4/pidl/lib/Parse/Pidl/Samba4.pm | 29 +++---------------------- 2 files changed, 11 insertions(+), 35 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index f6b3a6dcac..ade2711d85 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -11,7 +11,7 @@ use Parse::Pidl qw(fatal warning); use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); -use Parse::Pidl::Samba4 qw(DeclLong_cli IsUniqueOut); +use Parse::Pidl::Samba4 qw(DeclLong); use vars qw($VERSION); $VERSION = '0.01'; @@ -35,7 +35,7 @@ sub ParseFunction($$) my $ufn = "DCERPC_".uc($fn->{NAME}); foreach (@{$fn->{ELEMENTS}}) { - $defargs .= ", " . DeclLong_cli($_); + $defargs .= ", " . DeclLong($_); } fn_declare "NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"; pidl "{"; @@ -47,12 +47,7 @@ sub ParseFunction($$) foreach (@{$fn->{ELEMENTS}}) { if (grep(/in/, @{$_->{DIRECTION}})) { - if ( IsUniqueOut($_) ) { - pidl "r.in.$_->{NAME} = *$_->{NAME};"; - } - else { pidl "r.in.$_->{NAME} = $_->{NAME};"; - } } } @@ -83,8 +78,12 @@ sub ParseFunction($$) fatal($e, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); - if ( IsUniqueOut($e) ) { - pidl "*$e->{NAME} = r.out.$e->{NAME};"; + if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") && ($e->{LEVELS}[0]->{POINTER_TYPE} eq "unique") ) { + pidl "if ( $e->{NAME} ) {"; + indent; + pidl "*$e->{NAME} = *r.out.$e->{NAME};"; + deindent; + pidl "}"; } else { pidl "*$e->{NAME} = *r.out.$e->{NAME};"; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index e11bd6a5ff..4ef2daa591 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Samba4; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(is_intree choose_header DeclLong DeclLong_cli IsUniqueOut); +@EXPORT = qw(is_intree choose_header DeclLong); use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::Typelist qw(mapType scalar_is_reference); @@ -32,19 +32,9 @@ sub choose_header($$) return "#include <$out>"; } -sub IsUniqueOut($) -{ - my ($e) = shift; - - return grep(/out/, @{$e->{DIRECTION}}) && - ((($e->{LEVELS}[0]->{TYPE} eq "POINTER") && - ($e->{LEVELS}[0]->{POINTER_TYPE} eq "unique")) || - ($e->{LEVELS}[0]->{TYPE} eq "ARRAY")); -} - -sub DeclLong_int($$) +sub DeclLong($) { - my($element,$cli) = @_; + my($element) = shift; my $ret = ""; if (has_property($element, "represent_as")) { @@ -67,9 +57,6 @@ sub DeclLong_int($$) not has_property($element, "charset"); $numstar++; } - if ($cli && IsUniqueOut($element)) { - $numstar++; - } $ret.="*" foreach (1..$numstar); } $ret.=$element->{NAME}; @@ -81,14 +68,4 @@ sub DeclLong_int($$) return $ret; } -sub DeclLong($) -{ - return DeclLong_int($_, 0); -} - -sub DeclLong_cli($) -{ - return DeclLong_int($_, 1); -} - 1; -- cgit From 652f0a7ef8986acc26381c05b16c55c9f8c31e3a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 16 Jan 2007 17:45:33 +0000 Subject: r20836: Use real type name, to fix compilation with -WC++-compat (This used to be commit 10ca65bd78d27c425ae0347930fd2c9a92fe345c) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 53 +++++++++++++++++++++---- 1 file changed, 46 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index f8ff458275..97cbc8b0ab 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -8,9 +8,9 @@ package Parse::Pidl::Samba3::ServerNDR; use strict; use Parse::Pidl qw(warning fatal); -use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); -use Parse::Pidl::Util qw(has_property ParseExpr is_constant); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::Typelist qw(mapType scalar_is_reference); +use Parse::Pidl::Util qw(ParseExpr has_property is_constant); +use Parse::Pidl::NDR qw(GetNextLevel); use Parse::Pidl::Samba4 qw(DeclLong); use vars qw($VERSION); @@ -25,21 +25,59 @@ sub pidl($) { $res .= $tabs.(shift)."\n"; } sub pidl_hdr($) { $res_hdr .= (shift)."\n"; } sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } +sub DeclLevel($$) +{ + sub DeclLevel($$); + my ($e, $l) = @_; + + my $ret = ""; + + if (has_property($e, "charset")) { + $ret.="const char"; + } else { + $ret.=mapType($e->{TYPE}); + } + + my $numstar = $e->{ORIGINAL}->{POINTERS}; + if ($numstar >= 1) { + $numstar-- if scalar_is_reference($e->{TYPE}); + } + foreach (@{$e->{ORIGINAL}->{ARRAY_LEN}}) + { + next if is_constant($_) and + not has_property($e, "charset"); + $numstar++; + } + $numstar -= $l; + die ("Too few pointers") if $numstar < 0; + if ($numstar > 0) + { + $ret.=" "; + $ret.="*" foreach (1..$numstar); + } + + return $ret; +} + sub AllocOutVar($$$$) { my ($e, $mem_ctx, $name, $env) = @_; my $l = $e->{LEVELS}[0]; + my $nl = $l; if ($l->{TYPE} eq "POINTER") { - $l = GetNextLevel($e, $l); + $nl = GetNextLevel($e, $l); } if ($l->{TYPE} eq "ARRAY") { my $size = ParseExpr($l->{SIZE_IS}, $env, $e); - pidl "$name = talloc_zero_size($mem_ctx, sizeof(*$name) * $size);"; + pidl "$name = talloc_zero_array($mem_ctx, " . DeclLevel($e, 1) . ", $size);"; + } elsif ($l->{TYPE} eq "POINTER" and $nl->{TYPE} eq "ARRAY") { + my $size = ParseExpr($nl->{SIZE_IS}, $env, $e); + pidl "$name = talloc_zero_array($mem_ctx, " . DeclLevel($e, 1) . ", $size);"; } else { - pidl "$name = talloc_zero_size($mem_ctx, sizeof(*$name));"; + pidl "$name = talloc_zero($mem_ctx, " . DeclLevel($e, 1) . ");"; } pidl "if ($name == NULL) {"; @@ -101,7 +139,8 @@ sub ParseFunction($$) my @dir = @{$_->{DIRECTION}}; if (grep(/in/, @dir) and grep(/out/, @dir)) { pidl "r.out.$_->{NAME} = r.in.$_->{NAME};"; - } elsif (grep(/out/, @dir)) { + } elsif (grep(/out/, @dir) and not + has_property($_, "represent_as")) { AllocOutVar($_, "mem_ctx", "r.out.$_->{NAME}", \%env); } if (grep(/in/, @dir)) { $ret .= ", r.in.$_->{NAME}"; } -- cgit From 64e88a8ccf2faa34ee9d182f4e89fa6e44c609a6 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 17 Jan 2007 14:49:36 +0000 Subject: r20850: Prefix all server calls with dcesrv_ (This used to be commit 76c78b0339cd88c61a13745f7f4e037f400db21b) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 14 ++++++-------- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba4/Template.pm | 2 +- 3 files changed, 9 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 2212044d3b..a1bd3e1f96 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -882,9 +882,7 @@ sub CalcNdrFlags($$$) sub ParseMemCtxPullStart($$$) { - my $e = shift; - my $l = shift; - my $ptr_name = shift; + my ($e, $l, $ptr_name) = @_; my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; my $mem_c_ctx = $ptr_name; @@ -998,7 +996,7 @@ sub ParseElementPullLevel } } - ParseMemCtxPullStart($e,$l, $var_name); + ParseMemCtxPullStart($e, $l, $var_name); $var_name = get_value_of($var_name); ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); @@ -1020,7 +1018,7 @@ sub ParseElementPullLevel $var_name = $var_name . "[$counter]"; - ParseMemCtxPullStart($e,$l, $array_name); + ParseMemCtxPullStart($e, $l, $array_name); if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { my $nl = GetNextLevel($e,$l); @@ -1044,10 +1042,10 @@ sub ParseElementPullLevel pidl "}"; } - ParseMemCtxPullEnd($e,$l); + ParseMemCtxPullEnd($e, $l); } elsif ($l->{TYPE} eq "SWITCH") { - ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred); + ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred); } } @@ -2052,7 +2050,7 @@ sub AllocateArrayLevel($$$$$) pidl "}"; if (grep(/in/,@{$e->{DIRECTION}}) and grep(/out/,@{$e->{DIRECTION}})) { - pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));"; + pidl "memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));"; } return; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index 102b0fc769..bd58342189 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -35,9 +35,9 @@ sub gen_dispatch_switch($) pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_IN, r2);\n"; pidl "\t\t}\n"; if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") { - pidl "\t\tr2->out.result = $fn->{NAME}(dce_call, mem_ctx, r2);\n"; + pidl "\t\tr2->out.result = dcesrv_$fn->{NAME}(dce_call, mem_ctx, r2);\n"; } else { - pidl "\t\t$fn->{NAME}(dce_call, mem_ctx, r2);\n"; + pidl "\t\tdcesrv_$fn->{NAME}(dce_call, mem_ctx, r2);\n"; } pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} will reply async\\n\"));\n"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm index 111ae28123..f953d0f2fe 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm @@ -58,7 +58,7 @@ sub Template($) /* $fname */ -static $d->{RETURN_TYPE} $fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, +static $d->{RETURN_TYPE} dcesrv_$fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct $fname *r) { "; -- cgit From 30bfba96d3b7007aa47e037328ea0f2b8e7d1d6e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 22 Jan 2007 00:04:59 +0000 Subject: r20942: Simplify handling of systems that don't support negative enum values by using an ifdef rather than a pidl argument. (This used to be commit 6bada0dcf0c7915d366c7917189375dbabecdd4f) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 15 ++++++++------- source4/pidl/lib/Parse/Pidl/Util.pm | 11 ----------- 2 files changed, 8 insertions(+), 18 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index da7d39a238..96f695d1cd 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -118,8 +118,8 @@ sub HeaderEnum($$) my($enum,$name) = @_; my $first = 1; - if (not Parse::Pidl::Util::useUintEnums()) { - pidl "enum $name {\n"; + pidl "#ifndef USE_UINT_ENUMS\n"; + pidl "enum $name {\n"; $tab_depth++; foreach my $e (@{$enum->{ELEMENTS}}) { unless ($first) { pidl ",\n"; } @@ -129,9 +129,9 @@ sub HeaderEnum($$) } pidl "\n"; $tab_depth--; - pidl "}"; - } else { - my $count = 0; + pidl "};\n"; + pidl "#else\n"; + my $count = 0; pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n"; my $with_val = 0; my $without_val = 0; @@ -154,8 +154,8 @@ sub HeaderEnum($$) } pidl "#define $name ( $value )\n"; } + pidl "#endif\n"; pidl "\n"; - } } ##################################################################### @@ -220,7 +220,8 @@ sub HeaderTypedef($) { my($typedef) = shift; HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); - pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP"); + pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP" or + $typedef->{DATA}->{TYPE} eq "ENUM"); } ##################################################################### diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 35e25286f5..3ca79b6c1c 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -87,17 +87,6 @@ sub print_uuid($) "{".join(',', map {"0x$_"} @node)."}}"; } -# a hack to build on platforms that don't like negative enum values -my $useUintEnums = 0; -sub setUseUintEnums($) -{ - $useUintEnums = shift; -} -sub useUintEnums() -{ - return $useUintEnums; -} - sub ParseExpr($$$) { my($expr, $varlist, $e) = @_; -- cgit From dd08678adda6067a302677f4259719669261c081 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 31 Jan 2007 11:54:01 +0000 Subject: r21075: Generate parameters in structs for the server side Samba 3 code. The current code in Samba 3 is already generated using this pidl patch. (This used to be commit 30a06273d28fb59c6f20154f97c67f4c0a63dee9) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 97cbc8b0ab..52e384814d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -133,8 +133,8 @@ sub ParseFunction($$) pidl "ZERO_STRUCT(r.out);" if ($hasout); - my $proto = "_$fn->{NAME}(pipes_struct *p"; - my $ret = "_$fn->{NAME}(p"; + my $proto = "_$fn->{NAME}(pipes_struct *p, struct $fn->{NAME} *r"; + my $ret = "_$fn->{NAME}(p, &r"; foreach (@{$fn->{ELEMENTS}}) { my @dir = @{$_->{DIRECTION}}; if (grep(/in/, @dir) and grep(/out/, @dir)) { @@ -143,10 +143,6 @@ sub ParseFunction($$) has_property($_, "represent_as")) { AllocOutVar($_, "mem_ctx", "r.out.$_->{NAME}", \%env); } - if (grep(/in/, @dir)) { $ret .= ", r.in.$_->{NAME}"; } - else { $ret .= ", r.out.$_->{NAME}"; } - - $proto .= ", " . DeclLong($_); } $ret .= ")"; $proto .= ");"; -- cgit From ecf2c1effb778a95fd863a5e87ec7e378d228b57 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 7 Feb 2007 19:03:19 +0000 Subject: r21222: Merge a couple of pidl fixes: * Pidl will now warn when trying to use pointers as integers in expressions. * "subcontext()" is now marked as deprecated. The alternatives, transmit_as() / represent_as() should be available soon. * More tests. * Remove some unused code in smbtorture. (This used to be commit 37c0da541e3962164d5af3e3c9560803a733f3b7) --- source4/pidl/lib/Parse/Pidl/Expr.pm | 1211 ++++++++++++---------- source4/pidl/lib/Parse/Pidl/NDR.pm | 7 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 96 +- source4/pidl/lib/Parse/Pidl/Util.pm | 8 +- 4 files changed, 722 insertions(+), 600 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Expr.pm b/source4/pidl/lib/Parse/Pidl/Expr.pm index 34c30b824f..f64db508d6 100644 --- a/source4/pidl/lib/Parse/Pidl/Expr.pm +++ b/source4/pidl/lib/Parse/Pidl/Expr.pm @@ -38,7 +38,9 @@ sub new { }, GOTOS => { 'exp' => 2, - 'func' => 11 + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, {#State 1 @@ -54,33 +56,33 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 12, - 'func' => 11 + 'exp' => 14, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, {#State 2 ACTIONS => { - '' => 14, - "-" => 13, - "<" => 15, - "+" => 16, - "%" => 17, - "==" => 18, - "^" => 19, - "*" => 20, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "/" => 27, - "->" => 28, - "|" => 29, - "<<" => 31, - "=>" => 30, + '' => 16, + "-" => 15, + "<" => 17, + "+" => 18, + "%" => 19, + "==" => 20, + "^" => 21, + "*" => 22, + ">>" => 23, + "!=" => 24, + "?" => 25, + "||" => 26, + "&&" => 27, + "&" => 28, + "/" => 29, + "|" => 30, + "<<" => 32, + "=>" => 31, "<=" => 33, - "." => 32, ">" => 34 } }, @@ -98,7 +100,9 @@ sub new { }, GOTOS => { 'exp' => 35, - 'func' => 11 + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, {#State 4 @@ -115,7 +119,9 @@ sub new { }, GOTOS => { 'exp' => 36, - 'func' => 11 + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, {#State 5 @@ -137,8 +143,10 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 37, - 'func' => 11 + 'exp' => 38, + 'var' => 37, + 'func' => 12, + 'possible_pointer' => 13 } }, {#State 8 @@ -154,46 +162,49 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 38, - 'func' => 11 + 'exp' => 39, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, {#State 9 ACTIONS => { - "-" => 1, - "~" => 3, - "&" => 4, - 'TEXT' => 6, - 'NUM' => 5, - "!" => 8, - "(" => 7, "*" => 9, - 'VAR' => 10 + 'VAR' => 41 }, GOTOS => { - 'exp' => 39, - 'func' => 11 + 'possible_pointer' => 40 } }, {#State 10 ACTIONS => { - "(" => 40 + "(" => 42 }, - DEFAULT => -5 + DEFAULT => -30 }, {#State 11 - DEFAULT => -3 + ACTIONS => { + "->" => 43, + "." => 44 + }, + DEFAULT => -4 }, {#State 12 + DEFAULT => -3 + }, + {#State 13 + DEFAULT => -32 + }, + {#State 14 ACTIONS => { - "^" => 19, - "=>" => 30, - "." => 32, + "^" => 21, + "=>" => 31, "<=" => 33 }, - DEFAULT => -29 + DEFAULT => -26 }, - {#State 13 + {#State 15 ACTIONS => { "-" => 1, "~" => 3, @@ -206,14 +217,16 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 41, - 'func' => 11 + 'exp' => 45, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 14 + {#State 16 DEFAULT => 0 }, - {#State 15 + {#State 17 ACTIONS => { "-" => 1, "~" => 3, @@ -226,11 +239,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 42, - 'func' => 11 + 'exp' => 46, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 16 + {#State 18 ACTIONS => { "-" => 1, "~" => 3, @@ -243,11 +258,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 43, - 'func' => 11 + 'exp' => 47, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 17 + {#State 19 ACTIONS => { "-" => 1, "~" => 3, @@ -260,11 +277,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 44, - 'func' => 11 + 'exp' => 48, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 18 + {#State 20 ACTIONS => { "-" => 1, "~" => 3, @@ -277,11 +296,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 45, - 'func' => 11 + 'exp' => 49, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 19 + {#State 21 ACTIONS => { "-" => 1, "~" => 3, @@ -294,11 +315,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 46, - 'func' => 11 + 'exp' => 50, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 20 + {#State 22 ACTIONS => { "-" => 1, "~" => 3, @@ -311,11 +334,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 47, - 'func' => 11 + 'exp' => 51, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 21 + {#State 23 ACTIONS => { "-" => 1, "~" => 3, @@ -328,11 +353,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 48, - 'func' => 11 + 'exp' => 52, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 22 + {#State 24 ACTIONS => { "-" => 1, "~" => 3, @@ -345,11 +372,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 49, - 'func' => 11 + 'exp' => 53, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 23 + {#State 25 ACTIONS => { "-" => 1, "~" => 3, @@ -362,11 +391,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 50, - 'func' => 11 + 'exp' => 54, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 24 + {#State 26 ACTIONS => { "-" => 1, "~" => 3, @@ -379,11 +410,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 51, - 'func' => 11 + 'exp' => 55, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 25 + {#State 27 ACTIONS => { "-" => 1, "~" => 3, @@ -396,11 +429,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 52, - 'func' => 11 + 'exp' => 56, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 26 + {#State 28 ACTIONS => { "-" => 1, "~" => 3, @@ -413,11 +448,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 53, - 'func' => 11 + 'exp' => 57, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 27 + {#State 29 ACTIONS => { "-" => 1, "~" => 3, @@ -430,16 +467,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 54, - 'func' => 11 - } - }, - {#State 28 - ACTIONS => { - 'VAR' => 55 + 'exp' => 58, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 29 + {#State 30 ACTIONS => { "-" => 1, "~" => 3, @@ -452,11 +486,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 56, - 'func' => 11 + 'exp' => 59, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 30 + {#State 31 ACTIONS => { "-" => 1, "~" => 3, @@ -469,11 +505,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 57, - 'func' => 11 + 'exp' => 60, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 31 + {#State 32 ACTIONS => { "-" => 1, "~" => 3, @@ -486,13 +524,10 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 58, - 'func' => 11 - } - }, - {#State 32 - ACTIONS => { - 'VAR' => 59 + 'exp' => 61, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, {#State 33 @@ -508,8 +543,10 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 60, - 'func' => 11 + 'exp' => 62, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, {#State 34 @@ -525,89 +562,91 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 61, - 'func' => 11 + 'exp' => 63, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, {#State 35 ACTIONS => { - "^" => 19, - "=>" => 30, - "." => 32, + "^" => 21, + "=>" => 31, "<=" => 33 }, - DEFAULT => -7 + DEFAULT => -5 }, {#State 36 ACTIONS => { - "^" => 19, - "=>" => 30, - "." => 32, + "^" => 21, + "=>" => 31, "<=" => 33 }, - DEFAULT => -30 + DEFAULT => -27 }, {#State 37 ACTIONS => { - "-" => 13, - "<" => 15, - "+" => 16, - "%" => 17, - "==" => 18, - "^" => 19, - "*" => 20, - ")" => 62, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "/" => 27, - "->" => 28, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, - "<=" => 33, - ">" => 34 - } + ")" => 64, + "->" => 43, + "." => 44 + }, + DEFAULT => -4 }, {#State 38 ACTIONS => { - "-" => 13, - "<" => 15, - "+" => 16, - "%" => 17, - "==" => 18, - "^" => 19, - "*" => 20, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "/" => 27, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + "-" => 15, + "<" => 17, + "+" => 18, + "%" => 19, + "==" => 20, + "^" => 21, + "*" => 22, + ")" => 65, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "/" => 29, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 - }, - DEFAULT => -27 + } }, {#State 39 ACTIONS => { - "^" => 19, - "=>" => 30, - "." => 32, - "<=" => 33 + "-" => 15, + "<" => 17, + "+" => 18, + "%" => 19, + "==" => 20, + "^" => 21, + "*" => 22, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "/" => 29, + "|" => 30, + "=>" => 31, + "<<" => 32, + "<=" => 33, + ">" => 34 }, - DEFAULT => -6 + DEFAULT => -24 }, {#State 40 + DEFAULT => -31 + }, + {#State 41 + DEFAULT => -30 + }, + {#State 42 ACTIONS => { "-" => 1, "~" => 3, @@ -619,411 +658,410 @@ sub new { "*" => 9, 'VAR' => 10 }, - DEFAULT => -34, + DEFAULT => -37, GOTOS => { - 'exp' => 64, - 'args' => 63, - 'func' => 11, - 'opt_args' => 65 + 'exp' => 69, + 'var' => 11, + 'args' => 66, + 'func' => 12, + 'opt_args' => 70, + 'exp_or_possible_pointer' => 67, + 'possible_pointer' => 68 } }, - {#State 41 + {#State 43 + ACTIONS => { + 'VAR' => 71 + } + }, + {#State 44 ACTIONS => { - "<" => 15, - "==" => 18, - "^" => 19, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + 'VAR' => 72 + } + }, + {#State 45 + ACTIONS => { + "<" => 17, + "==" => 20, + "^" => 21, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 }, - DEFAULT => -9 + DEFAULT => -7 }, - {#State 42 + {#State 46 ACTIONS => { - "==" => 18, - "^" => 19, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "." => 32, + "==" => 20, + "^" => 21, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, "<=" => 33 }, - DEFAULT => -12 + DEFAULT => -10 }, - {#State 43 + {#State 47 ACTIONS => { - "<" => 15, - "==" => 18, - "^" => 19, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + "<" => 17, + "==" => 20, + "^" => 21, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 }, - DEFAULT => -8 + DEFAULT => -6 }, - {#State 44 + {#State 48 ACTIONS => { - "-" => 13, - "<" => 15, - "+" => 16, - "==" => 18, - "^" => 19, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + "-" => 15, + "<" => 17, + "+" => 18, + "==" => 20, + "^" => 21, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 }, - DEFAULT => -11 + DEFAULT => -9 }, - {#State 45 + {#State 49 ACTIONS => { - "^" => 19, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "." => 32, + "^" => 21, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, "<=" => 33 }, - DEFAULT => -15 + DEFAULT => -13 }, - {#State 46 + {#State 50 ACTIONS => { - "-" => 13, - "<" => 15, - "+" => 16, - "%" => 17, - "==" => 18, - "^" => 19, - "*" => 20, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "/" => 27, - "->" => 28, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + "-" => 15, + "<" => 17, + "+" => 18, + "%" => 19, + "==" => 20, + "^" => 21, + "*" => 22, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "/" => 29, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 }, - DEFAULT => -31 + DEFAULT => -28 }, - {#State 47 + {#State 51 ACTIONS => { - "-" => 13, - "<" => 15, - "+" => 16, - "==" => 18, - "^" => 19, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + "-" => 15, + "<" => 17, + "+" => 18, + "==" => 20, + "^" => 21, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 }, - DEFAULT => -10 + DEFAULT => -8 }, - {#State 48 + {#State 52 ACTIONS => { - "<" => 15, - "==" => 18, - "^" => 19, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "." => 32, + "<" => 17, + "==" => 20, + "^" => 21, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, "<=" => 33, ">" => 34 }, - DEFAULT => -19 + DEFAULT => -17 }, - {#State 49 + {#State 53 ACTIONS => { - "^" => 19, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "." => 32, + "^" => 21, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, "<=" => 33 }, - DEFAULT => -20 + DEFAULT => -18 }, - {#State 50 + {#State 54 ACTIONS => { - ":" => 66, - "-" => 13, - "<" => 15, - "+" => 16, - "%" => 17, - "==" => 18, - "^" => 19, - "*" => 20, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "/" => 27, - "->" => 28, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + ":" => 73, + "-" => 15, + "<" => 17, + "+" => 18, + "%" => 19, + "==" => 20, + "^" => 21, + "*" => 22, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "/" => 29, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 } }, - {#State 51 + {#State 55 ACTIONS => { - "^" => 19, - "?" => 23, - "||" => 25, - "=>" => 30, - "." => 32, + "^" => 21, + "?" => 25, + "=>" => 31, "<=" => 33 }, - DEFAULT => -22 + DEFAULT => -19 }, - {#State 52 + {#State 56 ACTIONS => { - "^" => 19, - "?" => 23, - "=>" => 30, - "." => 32, + "^" => 21, + "?" => 25, + "||" => 26, + "=>" => 31, "<=" => 33 }, - DEFAULT => -21 + DEFAULT => -20 }, - {#State 53 + {#State 57 ACTIONS => { - "^" => 19, - "?" => 23, - "&&" => 24, - "||" => 25, - "|" => 29, - "=>" => 30, - "." => 32, + "^" => 21, + "?" => 25, + "&&" => 27, + "||" => 26, + "|" => 30, + "=>" => 31, "<=" => 33 }, - DEFAULT => -23 + DEFAULT => -21 }, - {#State 54 + {#State 58 ACTIONS => { - "-" => 13, - "<" => 15, - "+" => 16, - "==" => 18, - "^" => 19, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + "-" => 15, + "<" => 17, + "+" => 18, + "==" => 20, + "^" => 21, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 }, - DEFAULT => -28 - }, - {#State 55 - DEFAULT => -24 + DEFAULT => -25 }, - {#State 56 + {#State 59 ACTIONS => { - "^" => 19, - "?" => 23, - "&&" => 24, - "||" => 25, - "=>" => 30, - "." => 32, + "^" => 21, + "?" => 25, + "&&" => 27, + "||" => 26, + "=>" => 31, "<=" => 33 }, - DEFAULT => -14 + DEFAULT => -12 }, - {#State 57 + {#State 60 ACTIONS => { - "-" => 13, - "<" => 15, - "+" => 16, - "%" => 17, - "==" => 18, - "^" => 19, - "*" => 20, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "/" => 27, - "->" => 28, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + "-" => 15, + "<" => 17, + "+" => 18, + "%" => 19, + "==" => 20, + "^" => 21, + "*" => 22, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "/" => 29, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 }, - DEFAULT => -17 + DEFAULT => -15 }, - {#State 58 + {#State 61 ACTIONS => { - "<" => 15, - "==" => 18, - "^" => 19, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "." => 32, + "<" => 17, + "==" => 20, + "^" => 21, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, "<=" => 33, ">" => 34 }, - DEFAULT => -18 - }, - {#State 59 - DEFAULT => -4 + DEFAULT => -16 }, - {#State 60 + {#State 62 ACTIONS => { - "-" => 13, - "<" => 15, - "+" => 16, - "%" => 17, - "==" => 18, - "^" => 19, - "*" => 20, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "/" => 27, - "->" => 28, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + "-" => 15, + "<" => 17, + "+" => 18, + "%" => 19, + "==" => 20, + "^" => 21, + "*" => 22, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "/" => 29, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 }, - DEFAULT => -16 + DEFAULT => -14 }, - {#State 61 + {#State 63 ACTIONS => { - "==" => 18, - "^" => 19, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "|" => 29, - "=>" => 30, - "." => 32, + "==" => 20, + "^" => 21, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "|" => 30, + "=>" => 31, "<=" => 33 }, - DEFAULT => -13 + DEFAULT => -11 }, - {#State 62 - DEFAULT => -32 + {#State 64 + DEFAULT => -34 }, - {#State 63 - DEFAULT => -35 + {#State 65 + DEFAULT => -29 }, - {#State 64 + {#State 66 + DEFAULT => -38 + }, + {#State 67 + ACTIONS => { + "," => 74 + }, + DEFAULT => -41 + }, + {#State 68 + DEFAULT => -32 + }, + {#State 69 ACTIONS => { - "-" => 13, - "<" => 15, - "+" => 16, - "%" => 17, - "," => 67, - "==" => 18, - "^" => 19, - "*" => 20, - ">>" => 21, - "!=" => 22, - "?" => 23, - "&&" => 24, - "||" => 25, - "&" => 26, - "->" => 28, - "/" => 27, - "|" => 29, - "=>" => 30, - "<<" => 31, - "." => 32, + "-" => 15, + "<" => 17, + "+" => 18, + "%" => 19, + "==" => 20, + "^" => 21, + "*" => 22, + ">>" => 23, + "!=" => 24, + "?" => 25, + "&&" => 27, + "||" => 26, + "&" => 28, + "/" => 29, + "|" => 30, + "=>" => 31, + "<<" => 32, "<=" => 33, ">" => 34 }, - DEFAULT => -36 + DEFAULT => -39 }, - {#State 65 + {#State 70 ACTIONS => { - ")" => 68 + ")" => 75 } }, - {#State 66 + {#State 71 + DEFAULT => -35 + }, + {#State 72 + DEFAULT => -33 + }, + {#State 73 ACTIONS => { "-" => 1, "~" => 3, @@ -1036,11 +1074,13 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 69, - 'func' => 11 + 'exp' => 76, + 'var' => 11, + 'func' => 12, + 'possible_pointer' => 13 } }, - {#State 67 + {#State 74 ACTIONS => { "-" => 1, "~" => 3, @@ -1053,25 +1093,27 @@ sub new { 'VAR' => 10 }, GOTOS => { - 'exp' => 64, - 'args' => 70, - 'func' => 11 + 'exp' => 69, + 'var' => 11, + 'args' => 77, + 'func' => 12, + 'exp_or_possible_pointer' => 67, + 'possible_pointer' => 68 } }, - {#State 68 - DEFAULT => -33 + {#State 75 + DEFAULT => -36 }, - {#State 69 + {#State 76 ACTIONS => { - "^" => 19, - "=>" => 30, - "." => 32, + "^" => 21, + "=>" => 31, "<=" => 33 }, - DEFAULT => -25 + DEFAULT => -22 }, - {#State 70 - DEFAULT => -37 + {#State 77 + DEFAULT => -42 } ], yyrules => @@ -1085,208 +1127,229 @@ sub new { [#Rule 2 'exp', 1, sub -#line 22 "pidl/expr.yp" +#line 22 "expr.yp" { "\"$_[1]\"" } ], [#Rule 3 'exp', 1, undef ], [#Rule 4 - 'exp', 3, -sub -#line 24 "pidl/expr.yp" -{ "$_[1].$_[3]" } + 'exp', 1, undef ], [#Rule 5 - 'exp', 1, -sub -#line 25 "pidl/expr.yp" -{ $_[0]->_Lookup($_[1]) } - ], - [#Rule 6 - 'exp', 2, -sub -#line 26 "pidl/expr.yp" -{ $_[0]->_Dereference($_[2]); "*$_[2]" } - ], - [#Rule 7 'exp', 2, sub -#line 27 "pidl/expr.yp" +#line 25 "expr.yp" { "~$_[2]" } ], - [#Rule 8 + [#Rule 6 'exp', 3, sub -#line 28 "pidl/expr.yp" +#line 26 "expr.yp" { "$_[1] + $_[3]" } ], - [#Rule 9 + [#Rule 7 'exp', 3, sub -#line 29 "pidl/expr.yp" +#line 27 "expr.yp" { "$_[1] - $_[3]" } ], - [#Rule 10 + [#Rule 8 'exp', 3, sub -#line 30 "pidl/expr.yp" +#line 28 "expr.yp" { "$_[1] * $_[3]" } ], - [#Rule 11 + [#Rule 9 'exp', 3, sub -#line 31 "pidl/expr.yp" +#line 29 "expr.yp" { "$_[1] % $_[3]" } ], - [#Rule 12 + [#Rule 10 'exp', 3, sub -#line 32 "pidl/expr.yp" +#line 30 "expr.yp" { "$_[1] < $_[3]" } ], - [#Rule 13 + [#Rule 11 'exp', 3, sub -#line 33 "pidl/expr.yp" +#line 31 "expr.yp" { "$_[1] > $_[3]" } ], - [#Rule 14 + [#Rule 12 'exp', 3, sub -#line 34 "pidl/expr.yp" +#line 32 "expr.yp" { "$_[1] | $_[3]" } ], - [#Rule 15 + [#Rule 13 'exp', 3, sub -#line 35 "pidl/expr.yp" +#line 33 "expr.yp" { "$_[1] == $_[3]" } ], - [#Rule 16 + [#Rule 14 'exp', 3, sub -#line 36 "pidl/expr.yp" +#line 34 "expr.yp" { "$_[1] <= $_[3]" } ], - [#Rule 17 + [#Rule 15 'exp', 3, sub -#line 37 "pidl/expr.yp" +#line 35 "expr.yp" { "$_[1] => $_[3]" } ], - [#Rule 18 + [#Rule 16 'exp', 3, sub -#line 38 "pidl/expr.yp" +#line 36 "expr.yp" { "$_[1] << $_[3]" } ], - [#Rule 19 + [#Rule 17 'exp', 3, sub -#line 39 "pidl/expr.yp" +#line 37 "expr.yp" { "$_[1] >> $_[3]" } ], - [#Rule 20 + [#Rule 18 'exp', 3, sub -#line 40 "pidl/expr.yp" +#line 38 "expr.yp" { "$_[1] != $_[3]" } ], - [#Rule 21 + [#Rule 19 'exp', 3, sub -#line 41 "pidl/expr.yp" +#line 39 "expr.yp" { "$_[1] || $_[3]" } ], - [#Rule 22 + [#Rule 20 'exp', 3, sub -#line 42 "pidl/expr.yp" +#line 40 "expr.yp" { "$_[1] && $_[3]" } ], - [#Rule 23 + [#Rule 21 'exp', 3, sub -#line 43 "pidl/expr.yp" +#line 41 "expr.yp" { "$_[1] & $_[3]" } ], - [#Rule 24 - 'exp', 3, -sub -#line 44 "pidl/expr.yp" -{ $_[1]."->".$_[3] } - ], - [#Rule 25 + [#Rule 22 'exp', 5, sub -#line 45 "pidl/expr.yp" +#line 42 "expr.yp" { "$_[1]?$_[3]:$_[5]" } ], - [#Rule 26 + [#Rule 23 'exp', 2, sub -#line 46 "pidl/expr.yp" +#line 43 "expr.yp" { "~$_[1]" } ], - [#Rule 27 + [#Rule 24 'exp', 2, sub -#line 47 "pidl/expr.yp" +#line 44 "expr.yp" { "not $_[1]" } ], - [#Rule 28 + [#Rule 25 'exp', 3, sub -#line 48 "pidl/expr.yp" +#line 45 "expr.yp" { "$_[1] / $_[3]" } ], - [#Rule 29 + [#Rule 26 'exp', 2, sub -#line 49 "pidl/expr.yp" +#line 46 "expr.yp" { "-$_[2]" } ], - [#Rule 30 + [#Rule 27 'exp', 2, sub -#line 50 "pidl/expr.yp" +#line 47 "expr.yp" { "&$_[2]" } ], - [#Rule 31 + [#Rule 28 'exp', 3, sub -#line 51 "pidl/expr.yp" +#line 48 "expr.yp" { "$_[1]^$_[3]" } ], - [#Rule 32 + [#Rule 29 'exp', 3, sub -#line 52 "pidl/expr.yp" +#line 49 "expr.yp" { "($_[2])" } + ], + [#Rule 30 + 'possible_pointer', 1, +sub +#line 53 "expr.yp" +{ $_[0]->_Lookup($_[1]) } + ], + [#Rule 31 + 'possible_pointer', 2, +sub +#line 54 "expr.yp" +{ $_[0]->_Dereference($_[2]); "*$_[2]" } + ], + [#Rule 32 + 'var', 1, +sub +#line 57 "expr.yp" +{ $_[0]->_Use($_[1]) } ], [#Rule 33 + 'var', 3, +sub +#line 58 "expr.yp" +{ $_[0]->_Use("$_[1].$_[3]") } + ], + [#Rule 34 + 'var', 3, +sub +#line 59 "expr.yp" +{ "($_[2])" } + ], + [#Rule 35 + 'var', 3, +sub +#line 60 "expr.yp" +{ $_[0]->_Use("*$_[1]"); $_[1]."->".$_[3] } + ], + [#Rule 36 'func', 4, sub -#line 55 "pidl/expr.yp" +#line 64 "expr.yp" { "$_[1]($_[3])" } ], - [#Rule 34 + [#Rule 37 'opt_args', 0, sub -#line 56 "pidl/expr.yp" +#line 65 "expr.yp" { "" } ], - [#Rule 35 + [#Rule 38 'opt_args', 1, undef ], - [#Rule 36 + [#Rule 39 + 'exp_or_possible_pointer', 1, undef + ], + [#Rule 40 + 'exp_or_possible_pointer', 1, undef + ], + [#Rule 41 'args', 1, undef ], - [#Rule 37 + [#Rule 42 'args', 3, sub -#line 57 "pidl/expr.yp" +#line 68 "expr.yp" { "$_[1], $_[3]" } ] ], @@ -1294,7 +1357,7 @@ sub bless($self,$class); } -#line 59 "pidl/expr.yp" +#line 71 "expr.yp" package Parse::Pidl::Expr; @@ -1332,6 +1395,15 @@ sub _Lexer { } } +sub _Use($$) +{ + my ($self, $x) = @_; + if (defined($self->YYData->{USE})) { + return $self->YYData->{USE}->($x); + } + return $x; +} + sub _Lookup($$) { my ($self, $x) = @_; @@ -1357,12 +1429,13 @@ sub _Error($) } sub Run { - my($self, $data, $error, $lookup, $deref) = @_; + my($self, $data, $error, $lookup, $deref, $use) = @_; $self->YYData->{FULL_INPUT} = $data; $self->YYData->{INPUT} = $data; $self->YYData->{LOOKUP} = $lookup; $self->YYData->{DEREFERENCE} = $deref; $self->YYData->{ERROR} = $error; + $self->YYData->{USE} = $use; return $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error); } diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 462e577cdd..2ba8461e4a 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -35,7 +35,7 @@ use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); -@EXPORT_OK = qw(GetElementLevelTable ParseElement); +@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement); use strict; use Parse::Pidl qw(warning fatal); @@ -902,7 +902,6 @@ sub ValidElement($) } } - if (has_property($e, "subcontext") and has_property($e, "represent_as")) { fatal($e, el_name($e) . " : subcontext() and represent_as() can not be used on the same element"); } @@ -919,6 +918,10 @@ sub ValidElement($) fatal($e, el_name($e) . " : represent_as() and value() can not be used on the same element"); } + if (has_property($e, "subcontext")) { + warning($e, "subcontext() is deprecated. Use represent_as() or transmit_as() instead"); + } + if (defined (has_property($e, "subcontext_size")) and not defined(has_property($e, "subcontext"))) { fatal($e, el_name($e) . " : subcontext_size() on non-subcontext element"); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index a1bd3e1f96..1e199ba62b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -304,6 +304,51 @@ sub ParseArrayPushHeader($$$$$) return $length; } +sub check_fully_dereferenced($$) +{ + my ($element, $env) = @_; + + return sub ($) { + my $origvar = shift; + my $check = 0; + + # Figure out the number of pointers in $ptr + my $expandedvar = $origvar; + $expandedvar =~ s/^(\**)//; + my $ptr = $1; + + my $var = undef; + foreach (keys %$env) { + if ($env->{$_} eq $expandedvar) { + $var = $_; + last; + } + } + + return($origvar) unless (defined($var)); + my $e; + foreach (@{$element->{PARENT}->{ELEMENTS}}) { + if ($_->{NAME} eq $var) { + $e = $_; + last; + } + } + + $e or die("Environment doesn't match siblings"); + + # See if pointer at pointer level $level + # needs to be checked. + my $nump = 0; + foreach (@{$e->{LEVELS}}) { + if ($_->{TYPE} eq "POINTER") { + $nump = $_->{POINTER_INDEX}+1; + } + } + warning($element->{ORIGINAL}, "Got pointer for `$e->{NAME}', expected fully derefenced variable") if ($nump > length($ptr)); + return ($origvar); + } +} + sub check_null_pointer($$$$) { my ($element, $env, $print_fn, $return) = @_; @@ -373,8 +418,8 @@ sub ParseArrayPullHeader($$$$$) } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))"; } else { - $length = $size = ParseExprExt($l->{SIZE_IS}, $env, $e, - check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;")); + $length = $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, + check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); } if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { @@ -397,7 +442,7 @@ sub ParseArrayPullHeader($$$$$) if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { defer "if ($var_name) {"; defer_indent; - my $size = ParseExprExt($l->{SIZE_IS}, $env, $e, check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;")); + my $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"; defer_deindent; defer "}"; @@ -406,7 +451,7 @@ sub ParseArrayPullHeader($$$$$) if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { defer "if ($var_name) {"; defer_indent; - my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e, check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;")); + my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"; defer_deindent; defer "}" @@ -432,7 +477,7 @@ sub compression_clen($$$) my ($e, $l, $env) = @_; my ($alg, $clen, $dlen) = split(/ /, $l->{COMPRESSION}); - return ParseExpr($clen, $env, $e); + return ParseExpr($clen, $env, $e->{ORIGINAL}); } sub compression_dlen($$$) @@ -440,7 +485,7 @@ sub compression_dlen($$$) my ($e,$l,$env) = @_; my ($alg, $clen, $dlen) = split(/ /, $l->{COMPRESSION}); - return ParseExpr($dlen, $env, $e); + return ParseExpr($dlen, $env, $e->{ORIGINAL}); } sub ParseCompressionPushStart($$$$) @@ -501,7 +546,7 @@ sub ParseSubcontextPushStart($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL}); pidl "{"; indent; @@ -519,7 +564,7 @@ sub ParseSubcontextPushEnd($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL}); if (defined $l->{COMPRESSION}) { ParseCompressionPushEnd($e, $l, $subndr, $env); @@ -534,7 +579,7 @@ sub ParseSubcontextPullStart($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL}); pidl "{"; indent; @@ -552,7 +597,7 @@ sub ParseSubcontextPullEnd($$$$) { my ($e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; - my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e); + my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL}); if (defined $l->{COMPRESSION}) { ParseCompressionPullEnd($e, $l, $subndr, $env); @@ -617,7 +662,7 @@ sub ParseElementPushLevel } } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and not is_charset_array($e, $l)) { - my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); + my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL}); my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; $var_name = $var_name . "[$counter]"; @@ -668,7 +713,7 @@ sub ParseElementPush($$$$$$) start_flags($e); if (my $value = has_property($e, "value")) { - $var_name = ParseExpr($value, $env, $e); + $var_name = ParseExpr($value, $env, $e->{ORIGINAL}); } ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred); @@ -719,7 +764,7 @@ sub ParseElementPrint($$$) $var_name = append_prefix($e, $var_name); if (my $value = has_property($e, "value")) { - $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env, $e) . ":$var_name"; + $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env, $e->{ORIGINAL}) . ":$var_name"; } foreach my $l (@{$e->{LEVELS}}) { @@ -741,8 +786,8 @@ sub ParseElementPrint($$$) if ($l->{IS_ZERO_TERMINATED}) { $length = "ndr_string_length($var_name, sizeof(*$var_name))"; } else { - $length = ParseExprExt($l->{LENGTH_IS}, $env, $e, - check_null_pointer($e, $env, \&pidl, "return;")); + $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL}, + check_null_pointer($e, $env, \&pidl, "return;"), check_fully_dereferenced($e, $env)); } if (is_charset_array($e,$l)) { @@ -772,8 +817,8 @@ sub ParseElementPrint($$$) } pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; } elsif ($l->{TYPE} eq "SWITCH") { - my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, - check_null_pointer($e, $env, \&pidl, "return;")); + my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, + check_null_pointer($e, $env, \&pidl, "return;"), check_fully_dereferenced($e, $env)); pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"; } } @@ -803,8 +848,8 @@ sub ParseElementPrint($$$) sub ParseSwitchPull($$$$$$) { my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, - check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;")); + my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, + check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); $var_name = get_pointer_to($var_name); pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));"; @@ -815,8 +860,8 @@ sub ParseSwitchPull($$$$$$) sub ParseSwitchPush($$$$$$) { my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; - my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e, - check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;")); + my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, + check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); $var_name = get_pointer_to($var_name); pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"; @@ -1012,7 +1057,7 @@ sub ParseElementPullLevel } } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and not is_charset_array($e, $l)) { - my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); + my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL}); my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; my $array_name = $var_name; @@ -1181,7 +1226,7 @@ sub ParseStructPush($$) $size = "ndr_string_length(r->$e->{NAME}, sizeof(*r->$e->{NAME}))"; } } else { - $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e); + $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL}); } pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; @@ -2038,7 +2083,7 @@ sub AllocateArrayLevel($$$$$) { my ($e,$l,$ndr,$env,$size) = @_; - my $var = ParseExpr($e->{NAME}, $env, $e); + my $var = ParseExpr($e->{NAME}, $env, $e->{ORIGINAL}); my $pl = GetPrevLevel($e, $l); if (defined($pl) and @@ -2118,7 +2163,8 @@ sub ParseFunctionPull($) and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}); if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { - my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e, check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;")); + my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), + check_fully_dereferenced($e, $env)); pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"; diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 3ca79b6c1c..00185fbef7 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -101,12 +101,12 @@ sub ParseExpr($$$) return($varlist->{$x}) if (defined($varlist->{$x})); return $x; }, - undef); + undef, undef); } -sub ParseExprExt($$$$) +sub ParseExprExt($$$$$) { - my($expr, $varlist, $e, $deref) = @_; + my($expr, $varlist, $e, $deref, $use) = @_; die("Undefined value in ParseExpr") if not defined($expr); @@ -118,7 +118,7 @@ sub ParseExprExt($$$$) return($varlist->{$x}) if (defined($varlist->{$x})); return $x; }, - $deref); + $deref, $use); } 1; -- cgit From 45db1030651e69896fdb9e78aa2e2495a7ce7ff5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 8 Feb 2007 23:54:31 +0000 Subject: r21253: Merge some pidl fixes: * Add tests for wireshark dissector generator * Add tests for the header code * Some cleanups * Fix handling of elements without [in] or [out] (This used to be commit 1aecba7100685ed291ea13b0ae47fb0cf9e6a6c8) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 31 ++++++--- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 46 ++++++------- source4/pidl/lib/Parse/Pidl/Util.pm | 75 +++++++++++++++++----- .../pidl/lib/Parse/Pidl/Wireshark/Conformance.pm | 48 +++++++++++--- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 6 +- 5 files changed, 150 insertions(+), 56 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 96f695d1cd..2b5b9c9e01 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -9,7 +9,6 @@ package Parse::Pidl::Samba4::Header; use strict; use Parse::Pidl::Typelist qw(mapType); use Parse::Pidl::Util qw(has_property is_constant); -use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel); use Parse::Pidl::Samba4 qw(is_intree); use vars qw($VERSION); @@ -236,15 +235,25 @@ sub HeaderConst($) } } +sub ElementDirection($) +{ + my ($e) = @_; + + return "inout" if (has_property($e, "in") and has_property($e, "out")); + return "in" if (has_property($e, "in")); + return "out" if (has_property($e, "out")); + return "inout"; +} + ##################################################################### # parse a function sub HeaderFunctionInOut($$) { my($fn,$prop) = @_; - foreach (@{$fn->{ELEMENTS}}) { - HeaderElement($_) if (has_property($_, $prop)); - } + foreach (@{$fn->{ELEMENTS}}) { + HeaderElement($_) if (ElementDirection($_) eq $prop); + } } ##################################################################### @@ -255,8 +264,8 @@ sub HeaderFunctionInOut_needed($$) return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void"); - foreach (@{$fn->{ELEMENTS}}) { - return 1 if (has_property($_, $prop)); + foreach (@{$fn->{ELEMENTS}}) { + return 1 if (ElementDirection($_) eq $prop); } return undef; @@ -278,19 +287,23 @@ sub HeaderFunction($) $tab_depth++; my $needed = 0; - if (HeaderFunctionInOut_needed($fn, "in")) { + if (HeaderFunctionInOut_needed($fn, "in") or + HeaderFunctionInOut_needed($fn, "inout")) { pidl tabs()."struct {\n"; $tab_depth++; HeaderFunctionInOut($fn, "in"); + HeaderFunctionInOut($fn, "inout"); $tab_depth--; pidl tabs()."} in;\n\n"; $needed++; } - if (HeaderFunctionInOut_needed($fn, "out")) { + if (HeaderFunctionInOut_needed($fn, "out") or + HeaderFunctionInOut_needed($fn, "inout")) { pidl tabs()."struct {\n"; $tab_depth++; HeaderFunctionInOut($fn, "out"); + HeaderFunctionInOut($fn, "inout"); if ($fn->{RETURN_TYPE} ne "void") { pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n"; } @@ -299,7 +312,7 @@ sub HeaderFunction($) $needed++; } - if (! $needed) { + if (!$needed) { # sigh - some compilers don't like empty structures pidl tabs()."int _dummy_element;\n"; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 1e199ba62b..3b1bc726ff 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -10,7 +10,7 @@ package Parse::Pidl::Samba4::NDR::Parser; require Exporter; @ISA = qw(Exporter); @EXPORT = qw(is_charset_array); -@EXPORT_OK = qw(check_null_pointer); +@EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv); use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); @@ -451,7 +451,9 @@ sub ParseArrayPullHeader($$$$$) if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { defer "if ($var_name) {"; defer_indent; - my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); + my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL}, + check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;"), + check_fully_dereferenced($e, $env)); defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"; defer_deindent; defer "}" @@ -689,12 +691,12 @@ sub ParseElementPushLevel ##################################################################### # parse scalars in a structure element -sub ParseElementPush($$$$$$) +sub ParseElementPush($$$$$) { - my ($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_; + my ($e,$ndr,$env,$primitives,$deferred) = @_; my $subndr = undef; - my $var_name = $var_prefix.$e->{NAME}; + my $var_name = $env->{$e->{NAME}}; return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); @@ -1096,11 +1098,11 @@ sub ParseElementPullLevel ##################################################################### # parse scalars in a structure element - pull size -sub ParseElementPull($$$$$$) +sub ParseElementPull($$$$$) { - my($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_; + my($e,$ndr,$env,$primitives,$deferred) = @_; - my $var_name = $var_prefix.$e->{NAME}; + my $var_name = $env->{$e->{NAME}}; my $represent_name; my $transmit_name; @@ -1247,7 +1249,7 @@ sub ParseStructPush($$) } foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPush($e, "ndr", "r->", $env, 1, 0); + ParseElementPush($e, "ndr", $env, 1, 0); } deindent; @@ -1261,7 +1263,7 @@ sub ParseStructPush($$) pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));"; } foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPush($e, "ndr", "r->", $env, 0, 1); + ParseElementPush($e, "ndr", $env, 0, 1); } deindent; @@ -1547,7 +1549,7 @@ sub ParseStructPull($$) } foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPull($e, "ndr", "r->", $env, 1, 0); + ParseElementPull($e, "ndr", $env, 1, 0); } add_deferred(); @@ -1562,7 +1564,7 @@ sub ParseStructPull($$) pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));"; } foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPull($e, "ndr", "r->", $env, 0, 1); + ParseElementPull($e, "ndr", $env, 0, 1); } add_deferred(); @@ -1662,7 +1664,7 @@ sub ParseUnionPush($$) pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));"; } DeclareArrayVariables($el); - ParseElementPush($el, "ndr", "r->", {}, 1, 0); + ParseElementPush($el, "ndr", {$el->{NAME} => "r->$el->{NAME}"}, 1, 0); deindent; } pidl "break;"; @@ -1689,7 +1691,7 @@ sub ParseUnionPush($$) pidl "$el->{CASE}:"; if ($el->{TYPE} ne "EMPTY") { indent; - ParseElementPush($el, "ndr", "r->", {}, 0, 1); + ParseElementPush($el, "ndr", {$el->{NAME} => "r->$el->{NAME}"}, 0, 1); deindent; } pidl "break;"; @@ -1810,7 +1812,7 @@ sub ParseUnionPull($$) # and store it based on the toplevel struct/union pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));"; } - ParseElementPull($el, "ndr", "r->", {}, 1, 0); + ParseElementPull($el, "ndr", {$el->{NAME} => "r->$el->{NAME}"}, 1, 0); deindent; } pidl "break; }"; @@ -1837,7 +1839,7 @@ sub ParseUnionPull($$) pidl "$el->{CASE}:"; if ($el->{TYPE} ne "EMPTY") { indent; - ParseElementPull($el, "ndr", "r->", {}, 0, 1); + ParseElementPull($el, "ndr", {$el->{NAME} => "r->$el->{NAME}"}, 0, 1); deindent; } pidl "break;"; @@ -1993,7 +1995,7 @@ sub ParseFunctionPrint($) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - ParseElementPrint($e, "r->in.$e->{NAME}", $env); + ParseElementPrint($e, $env->{$e->{NAME}}, $env); } } pidl "ndr->depth--;"; @@ -2008,7 +2010,7 @@ sub ParseFunctionPrint($) $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - ParseElementPrint($e, "r->out.$e->{NAME}", $env); + ParseElementPrint($e, $env->{$e->{NAME}}, $env); } } if ($fn->{RETURN_TYPE}) { @@ -2050,7 +2052,7 @@ sub ParseFunctionPush($) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - ParseElementPush($e, "ndr", "r->in.", $env, 1, 1); + ParseElementPush($e, "ndr", $env, 1, 1); } } @@ -2063,7 +2065,7 @@ sub ParseFunctionPush($) $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - ParseElementPush($e, "ndr", "r->out.", $env, 1, 1); + ParseElementPush($e, "ndr", $env, 1, 1); } } @@ -2147,7 +2149,7 @@ sub ParseFunctionPull($) foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/in/, @{$e->{DIRECTION}})); - ParseElementPull($e, "ndr", "r->in.", $env, 1, 1); + ParseElementPull($e, "ndr", $env, 1, 1); } # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's @@ -2194,7 +2196,7 @@ sub ParseFunctionPull($) $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { next unless grep(/out/, @{$e->{DIRECTION}}); - ParseElementPull($e, "ndr", "r->out.", $env, 1, 1); + ParseElementPull($e, "ndr", $env, 1, 1); } if ($fn->{RETURN_TYPE}) { diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 00185fbef7..8716094abd 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -15,9 +15,31 @@ use strict; use Parse::Pidl::Expr; use Parse::Pidl qw(error); -##################################################################### -# a dumper wrapper to prevent dependence on the Data::Dumper module -# unless we actually need it +=head1 NAME + +Parse::Pidl::Util - Generic utility functions for pidl + +=head1 SYNOPSIS + +use Parse::Pidl::Util; + +=head1 DESCRIPTION + +Simple module that contains a couple of trivial helper functions +used throughout the various pidl modules. + +=head1 FUNCTIONS + +=over 4 + +=cut + +=item B +a dumper wrapper to prevent dependence on the Data::Dumper module +unless we actually need it + +=cut + sub MyDumper($) { require Data::Dumper; @@ -25,8 +47,10 @@ sub MyDumper($) return Data::Dumper::Dumper($s); } -##################################################################### -# see if a pidl property list contains a given property +=item B +see if a pidl property list contains a given property + +=cut sub has_property($$) { my($e, $p) = @_; @@ -36,8 +60,10 @@ sub has_property($$) return $e->{PROPERTIES}->{$p}; } -##################################################################### -# see if a pidl property matches a value +=item B +see if a pidl property matches a value + +=cut sub property_matches($$$) { my($e,$p,$v) = @_; @@ -53,16 +79,22 @@ sub property_matches($$$) return undef; } -# return 1 if the string is a C constant +=item B +return 1 if the string is a C constant + +=cut sub is_constant($) { my $s = shift; - return 1 if (defined $s && $s =~ /^\d+$/); - return 1 if (defined $s && $s =~ /^0x[0-9A-Fa-f]+$/); + return 1 if ($s =~ /^\d+$/); + return 1 if ($s =~ /^0x[0-9A-Fa-f]+$/); return 0; } -# return a "" quoted string, unless already quoted +=item B +return a "" quoted string, unless already quoted + +=cut sub make_str($) { my $str = shift; @@ -72,6 +104,10 @@ sub make_str($) return "\"$str\""; } +=item B +Print C representation of a UUID. + +=cut sub print_uuid($) { my ($uuid) = @_; @@ -87,12 +123,14 @@ sub print_uuid($) "{".join(',', map {"0x$_"} @node)."}}"; } +=item B +Interpret an IDL expression, substituting particular variables. + +=cut sub ParseExpr($$$) { my($expr, $varlist, $e) = @_; - die("Undefined value in ParseExpr") if not defined($expr); - my $x = new Parse::Pidl::Expr(); return $x->Run($expr, sub { my $x = shift; error($e, $x); }, @@ -104,12 +142,15 @@ sub ParseExpr($$$) undef, undef); } +=item B +Interpret an IDL expression, substituting particular variables. Can call +callbacks when pointers are being dereferenced or variables are being used. + +=cut sub ParseExprExt($$$$$) { my($expr, $varlist, $e, $deref, $use) = @_; - die("Undefined value in ParseExpr") if not defined($expr); - my $x = new Parse::Pidl::Expr(); return $x->Run($expr, sub { my $x = shift; error($e, $x); }, @@ -121,4 +162,8 @@ sub ParseExprExt($$$$$) $deref, $use); } +=back + +=cut + 1; diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm index 4ad60319a6..9798c7c552 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm @@ -96,7 +96,7 @@ use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); -@EXPORT_OK = qw(ReadConformance); +@EXPORT_OK = qw(ReadConformance ReadConformanceFH); use strict; @@ -157,7 +157,7 @@ sub handle_hf_rename($$$$) my ($pos,$data,$old,$new) = @_; unless(defined($new)) { - error($pos, "incomplete HF_RENAME command"); + warning($pos, "incomplete HF_RENAME command"); return; } @@ -253,6 +253,11 @@ sub handle_manual($$$) { my ($pos,$data,$fn) = @_; + unless(defined($fn)) { + warning($pos, "incomplete MANUAL command"); + return; + } + $data->{manual}->{$fn} = 1; } @@ -271,6 +276,11 @@ sub handle_fielddescription($$$$) { my ($pos,$data,$field,$desc) = @_; + unless(defined($desc)) { + warning($pos, "incomplete FIELD_DESCRIPTION command"); + return; + } + $data->{fielddescription}->{$field} = { DESCRIPTION => $desc, POS => $pos, @@ -314,16 +324,26 @@ my %field_handlers = ( sub ReadConformance($$) { my ($f,$data) = @_; + my $ret; - $data->{override} = ""; + open(IN,"<$f") or return undef; - my $incodeblock = 0; + $ret = ReadConformanceFH(*IN, $data, $f); - open(IN,"<$f") or return undef; + close(IN); + + return $ret; +} + +sub ReadConformanceFH($$$) +{ + my ($fh,$data,$f) = @_; + + my $incodeblock = 0; my $ln = 0; - foreach () { + foreach (<$fh>) { $ln++; next if (/^#.*$/); next if (/^$/); @@ -337,7 +357,11 @@ sub ReadConformance($$) $incodeblock = 0; next; } elsif ($incodeblock) { - $data->{override}.="$_\n"; + if (exists $data->{override}) { + $data->{override}.="$_\n"; + } else { + $data->{override} = "$_\n"; + } next; } @@ -349,6 +373,8 @@ sub ReadConformance($$) my $pos = { FILE => $f, LINE => $ln }; + next unless(defined($cmd)); + if (not defined($field_handlers{$cmd})) { warning($pos, "Unknown command `$cmd'"); next; @@ -357,7 +383,13 @@ sub ReadConformance($$) $field_handlers{$cmd}($pos, $data, @fields); } - close(IN); + if ($incodeblock) { + warning({ FILE => $f, LINE => $ln }, + "Expecting CODE END"); + return undef; + } + + return 1; } 1; diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 9415c16652..646f5fdabc 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -2,7 +2,7 @@ # Samba4 NDR parser generator for IDL structures # Copyright tridge@samba.org 2000-2003 # Copyright tpot@samba.org 2001,2005 -# Copyright jelmer@samba.org 2004-2005 +# Copyright jelmer@samba.org 2004-2007 # Portions based on idl2eth.c by Ronnie Sahlberg # released under the GNU GPL @@ -918,7 +918,9 @@ sub Parse($$$$) $parser.=$res{ett}; $parser.=$res{hf}; $parser.=$res{def}; - $parser.=$conformance->{override}; + if (exists ($conformance->{override})) { + $parser.=$conformance->{override}; + } $parser.=$res{code}; my $header = "/* autogenerated by pidl */\n\n"; -- cgit From 97416e6b011a3c733d07f83073bf12796c7ecc6b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 12 Feb 2007 12:12:12 +0000 Subject: r21297: Remove the GTK+ tools and library from the main repository. They are now maintained separately in bzr at http://people.samba.org/bzr/jelmer/samba-gtk This also adds some more headers to the list that is installed and a couple of extra #include lines so these headers can be used externally without problems. (This used to be commit 07652f65ce7a5b19130f1a27cbf0e1e5fae13454) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 2b5b9c9e01..110a483fc4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -378,8 +378,10 @@ sub Parse($) %headerstructs = (); pidl "/* header auto-generated by pidl */\n\n"; if (!is_intree()) { - pidl "#include \n\n"; + pidl "#include \n"; } + pidl "#include \n"; + pidl "\n"; foreach (@{$idl}) { ($_->{TYPE} eq "INTERFACE") && HeaderInterface($_); -- cgit From e50dc79226bcb722485019533033500b0e145a46 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 14 Feb 2007 12:44:50 +0000 Subject: r21332: Fix bug in pidl that prevented value(0) from working. Bug reported by metze. (This used to be commit 8212a3b8e0d3d59264f659c3f657b165ececefeb) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 3b1bc726ff..045b243b2a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -10,7 +10,8 @@ package Parse::Pidl::Samba4::NDR::Parser; require Exporter; @ISA = qw(Exporter); @EXPORT = qw(is_charset_array); -@EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv); +@EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv + GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv); use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); @@ -234,7 +235,7 @@ sub EnvSubstituteValue($$) # Substitute the value() values in the env foreach my $e (@{$s->{ELEMENTS}}) { - next unless (my $v = has_property($e, "value")); + next unless (defined(my $v = has_property($e, "value"))); $env->{$e->{NAME}} = ParseExpr($v, $env, $e); } @@ -714,7 +715,7 @@ sub ParseElementPush($$$$$) start_flags($e); - if (my $value = has_property($e, "value")) { + if (defined(my $value = has_property($e, "value"))) { $var_name = ParseExpr($value, $env, $e->{ORIGINAL}); } @@ -765,7 +766,7 @@ sub ParseElementPrint($$$) $var_name = append_prefix($e, $var_name); - if (my $value = has_property($e, "value")) { + if (defined(my $value = has_property($e, "value"))) { $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env, $e->{ORIGINAL}) . ":$var_name"; } -- cgit From a7fa0d7063dd8abe5d9cdb3721fe0733983f5310 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 14 Feb 2007 14:23:59 +0000 Subject: r21338: Fix handling of top-level arrays for the Samba 3 client code. This doesn't fix the winreg code yet (as that's an array on top of a pointer), but at least it gets us closer. Also added a couple of tests for the Samba 3 client code. (This used to be commit 4a5b62ad622d7be08591e19bc2e89f665fff445a) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 54 +++++++++++++++++++------ 1 file changed, 42 insertions(+), 12 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index ade2711d85..3b596aba65 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -6,18 +6,22 @@ package Parse::Pidl::Samba3::ClientNDR; +use Exporter; +@ISA = qw(Exporter); +@EXPORT_OK = qw(GenerateFunctionInEnv ParseFunction $res $res_hdr); + use strict; use Parse::Pidl qw(fatal warning); use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); -use Parse::Pidl::Util qw(has_property is_constant); +use Parse::Pidl::Util qw(has_property is_constant ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::Samba4 qw(DeclLong); use vars qw($VERSION); $VERSION = '0.01'; -my $res; -my $res_hdr; +our $res; +our $res_hdr; my $tabs = ""; sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } @@ -25,13 +29,26 @@ sub pidl($) { $res .= $tabs.(shift)."\n"; } sub pidl_hdr($) { $res_hdr .= (shift)."\n"; } sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } +sub GenerateFunctionInEnv($) +{ + my $fn = shift; + my %env; + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = "r.in.$e->{NAME}"; + } + } + + return \%env; +} + sub ParseFunction($$) { - my ($if,$fn) = @_; + my ($uif, $fn) = @_; my $inargs = ""; my $defargs = ""; - my $uif = uc($if->{NAME}); my $ufn = "DCERPC_".uc($fn->{NAME}); foreach (@{$fn->{ELEMENTS}}) { @@ -58,7 +75,7 @@ sub ParseFunction($$) pidl "status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, $ufn, &r, (ndr_pull_flags_fn_t)ndr_pull_$fn->{NAME}, (ndr_push_flags_fn_t)ndr_push_$fn->{NAME});"; pidl ""; - pidl "if ( !NT_STATUS_IS_OK(status) ) {"; + pidl "if (!NT_STATUS_IS_OK(status)) {"; indent; pidl "return status;"; deindent; @@ -78,16 +95,29 @@ sub ParseFunction($$) fatal($e, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); - if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") && ($e->{LEVELS}[0]->{POINTER_TYPE} eq "unique") ) { + if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") and + ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") ) { pidl "if ( $e->{NAME} ) {"; indent; + } + + if ($e->{LEVELS}[0]->{TYPE} eq "ARRAY") { + # This is a call to GenerateFunctionInEnv intentionally. + # Since the data is being copied into a user-provided data + # structure, the user should be able to know the size beforehand + # to allocate a structure of the right size. + my $env = GenerateFunctionInEnv($fn); + my $size_is = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e); + pidl "memcpy($e->{NAME}, r.out.$e->{NAME}, $size_is);"; + } else { pidl "*$e->{NAME} = *r.out.$e->{NAME};"; + } + + if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") and + ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") ) { deindent; pidl "}"; - } else { - pidl "*$e->{NAME} = *r.out.$e->{NAME};"; } - } pidl""; @@ -99,7 +129,7 @@ sub ParseFunction($$) } elsif ($fn->{RETURN_TYPE} eq "WERROR") { pidl "return werror_to_ntstatus(r.out.result);"; } else { - pidl "/* Sorry, don't know how to convert $fn->{RETURN_TYPE} to NTSTATUS */"; + pidl "#warning Sorry, don't know how to convert $fn->{RETURN_TYPE} to NTSTATUS"; pidl "return NT_STATUS_OK;"; } @@ -116,7 +146,7 @@ sub ParseInterface($) pidl_hdr "#ifndef __CLI_$uif\__"; pidl_hdr "#define __CLI_$uif\__"; - ParseFunction($if, $_) foreach (@{$if->{FUNCTIONS}}); + ParseFunction($if->{NAME}, $_) foreach (@{$if->{FUNCTIONS}}); pidl_hdr "#endif /* __CLI_$uif\__ */"; } -- cgit From 627fc227916b041de8e1050cab0431467be44b20 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 14 Feb 2007 14:42:42 +0000 Subject: r21340: Fix warning undef (This used to be commit 2669f2c8ad09505b37f64104eefce6f0b10e9ab5) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 646f5fdabc..6bde87c47b 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -17,7 +17,7 @@ Parse::Pidl::Wireshark::NDR - Parser generator for Wireshark package Parse::Pidl::Wireshark::NDR; use strict; -use Parse::Pidl qw(error); +use Parse::Pidl qw(error warning); use Parse::Pidl::Typelist qw(getType); use Parse::Pidl::Util qw(has_property property_matches make_str); use Parse::Pidl::NDR qw(ContainsString GetNextLevel); -- cgit From 0fd260039498ac8331665cd2102b597198f58fbb Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 16 Feb 2007 14:13:14 +0000 Subject: r21384: Change warning to pidl warning, fix uppercasing. (This used to be commit a45a677084ba1bc63a8f74892c12ca6f0d9b5071) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 3b596aba65..0ffa321782 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -129,7 +129,7 @@ sub ParseFunction($$) } elsif ($fn->{RETURN_TYPE} eq "WERROR") { pidl "return werror_to_ntstatus(r.out.result);"; } else { - pidl "#warning Sorry, don't know how to convert $fn->{RETURN_TYPE} to NTSTATUS"; + warning($fn->{ORIGINAL}, "Unable to convert $fn->{RETURN_TYPE} to NTSTATUS"); pidl "return NT_STATUS_OK;"; } @@ -146,7 +146,7 @@ sub ParseInterface($) pidl_hdr "#ifndef __CLI_$uif\__"; pidl_hdr "#define __CLI_$uif\__"; - ParseFunction($if->{NAME}, $_) foreach (@{$if->{FUNCTIONS}}); + ParseFunction(uc($if->{NAME}), $_) foreach (@{$if->{FUNCTIONS}}); pidl_hdr "#endif /* __CLI_$uif\__ */"; } -- cgit From ec587914ed4df87b6aedab129fb59248b137f07b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 17 Feb 2007 23:38:57 +0000 Subject: r21411: Add some simple tests for the wireshark NDR generator. (This used to be commit 361977448210dfd889abca19b520cd259b9d0855) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 6bde87c47b..4a890fb630 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -16,6 +16,10 @@ Parse::Pidl::Wireshark::NDR - Parser generator for Wireshark package Parse::Pidl::Wireshark::NDR; +use Exporter; +@ISA = qw(Exporter); +@EXPORT_OK = qw(field2name @ett %res PrintIdl); + use strict; use Parse::Pidl qw(error warning); use Parse::Pidl::Typelist qw(getType); @@ -28,7 +32,7 @@ use File::Basename; use vars qw($VERSION); $VERSION = '0.01'; -my @ett; +our @ett; my %hf_used = (); my %return_types = (); @@ -66,7 +70,7 @@ sub field2name($) return $field; } -my %res = (); +our %res = (); my $tabs = ""; my $cur_fn = undef; sub pidl_fn_start($) @@ -108,7 +112,7 @@ sub deindent() sub PrintIdl($) { - my $idl = shift; + my ($idl) = @_; foreach (split /\n/, $idl) { pidl_code "/* IDL: $_ */"; -- cgit From ae76a5a92819bfd2d31bc5d23a540c6c71b47354 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 18 Feb 2007 12:54:03 +0000 Subject: r21427: Add tests for Needed*(), in preparation of refactoring. (This used to be commit a21e7b22ac99c66e2b23d0fa694a8a2ea6e7994e) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 36 +++++++++--------------- 1 file changed, 14 insertions(+), 22 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 045b243b2a..d4c4d55c57 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -11,7 +11,8 @@ require Exporter; @ISA = qw(Exporter); @EXPORT = qw(is_charset_array); @EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv - GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv); + GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction + NeededElement NeededTypedef); use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); @@ -2483,6 +2484,14 @@ sub Parse($$$) return ($res_hdr, $res); } +sub NeededElement($$$) +{ + my ($e, $dir, $needed) = @_; + + return if (defined($needed->{"$dir\_$e->{TYPE}"})); + $needed->{"$dir\_$e->{TYPE}"} = 1; +} + sub NeededFunction($$) { my ($fn,$needed) = @_; @@ -2491,15 +2500,7 @@ sub NeededFunction($$) $needed->{"print_$fn->{NAME}"} = 1; foreach my $e (@{$fn->{ELEMENTS}}) { $e->{PARENT} = $fn; - unless(defined($needed->{"pull_$e->{TYPE}"})) { - $needed->{"pull_$e->{TYPE}"} = 1; - } - unless(defined($needed->{"push_$e->{TYPE}"})) { - $needed->{"push_$e->{TYPE}"} = 1; - } - unless(defined($needed->{"print_$e->{TYPE}"})) { - $needed->{"print_$e->{TYPE}"} = 1; - } + NeededElement($e, $_, $needed) foreach ("pull", "push", "print"); } } @@ -2522,18 +2523,9 @@ sub NeededTypedef($$) if (has_property($e, "compression")) { $needed->{"compression"} = 1; } - if ($needed->{"pull_$t->{NAME}"} and - not defined($needed->{"pull_$e->{TYPE}"})) { - $needed->{"pull_$e->{TYPE}"} = 1; - } - if ($needed->{"push_$t->{NAME}"} and - not defined($needed->{"push_$e->{TYPE}"})) { - $needed->{"push_$e->{TYPE}"} = 1; - } - if ($needed->{"print_$t->{NAME}"} and - not defined($needed->{"print_$e->{TYPE}"})) { - $needed->{"print_$e->{TYPE}"} = 1; - } + NeededElement($e, "pull", $needed) if ($needed->{"pull_$t->{NAME}"}); + NeededElement($e, "push", $needed) if ($needed->{"push_$t->{NAME}"}); + NeededElement($e, "print", $needed) if ($needed->{"print_$t->{NAME}"}); } } } -- cgit From 2b43de2ed8025ef598c31d41f0fe710f8e3a3658 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 18 Feb 2007 13:44:01 +0000 Subject: r21428: Handle representation types in Needed(). (This used to be commit 34517c69e67d7eafa00e6fe0072bd04f074cdbde) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 4 +-- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 34 +++++++++++++++++++----- 2 files changed, 29 insertions(+), 9 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 2ba8461e4a..b76a0f5a38 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -371,7 +371,7 @@ sub ParseElement($) TYPE => $e->{TYPE}, PROPERTIES => $e->{PROPERTIES}, LEVELS => GetElementLevelTable($e), - REPRESENTATION_TYPE => $e->{PROPERTIES}->{represent_as}, + REPRESENTATION_TYPE => ($e->{PROPERTIES}->{represent_as} or $e->{TYPE}), ALIGN => align_type($e->{TYPE}), ORIGINAL => $e }; @@ -388,7 +388,7 @@ sub ParseStruct($$) my $e = ParseElement($x); if ($x != $struct->{ELEMENTS}[-1] and $e->{LEVELS}[0]->{IS_SURROUNDING}) { - print "$x->{FILE}:$x->{LINE}: error: conformant member not at end of struct\n"; + fatal($x, "conformant member not at end of struct"); } push @elements, $e; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index d4c4d55c57..6e4d5825d0 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -703,7 +703,7 @@ sub ParseElementPush($$$$$) return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); # Representation type is different from transmit_as - if ($e->{REPRESENTATION_TYPE}) { + if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { pidl "{"; indent; my $transmit_name = "_transmit_$e->{NAME}"; @@ -724,7 +724,7 @@ sub ParseElementPush($$$$$) end_flags($e); - if ($e->{REPRESENTATION_TYPE}) { + if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { deindent; pidl "}"; } @@ -760,7 +760,7 @@ sub ParseElementPrint($$$) return if (has_property($e, "noprint")); - if ($e->{REPRESENTATION_TYPE}) { + if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { pidl "ndr_print_$e->{REPRESENTATION_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; return; } @@ -1110,7 +1110,7 @@ sub ParseElementPull($$$$$) return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); - if ($e->{REPRESENTATION_TYPE}) { + if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { pidl "{"; indent; $represent_name = $var_name; @@ -1128,7 +1128,7 @@ sub ParseElementPull($$$$$) end_flags($e); # Representation type is different from transmit_as - if ($e->{REPRESENTATION_TYPE}) { + if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { pidl "NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}($transmit_name, ".get_pointer_to($represent_name)."));"; deindent; pidl "}"; @@ -2488,8 +2488,28 @@ sub NeededElement($$$) { my ($e, $dir, $needed) = @_; - return if (defined($needed->{"$dir\_$e->{TYPE}"})); - $needed->{"$dir\_$e->{TYPE}"} = 1; + return if ($e->{TYPE} eq "EMPTY"); + + my @fn = (); + if ($dir eq "print") { + push(@fn, "print_$e->{REPRESENTATION_TYPE}"); + } elsif ($dir eq "pull") { + push (@fn, "pull_$e->{TYPE}"); + push (@fn, "ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}") + if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}); + } elsif ($dir eq "push") { + push (@fn, "push_$e->{TYPE}"); + push (@fn, "ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}") + if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}); + } else { + die("invalid direction `$dir'"); + } + + foreach (@fn) { + unless (defined($needed->{$_})) { + $needed->{$_} = 1; + } + } } sub NeededFunction($$) -- cgit From 8cf122c2d2a0913fd9a7c55032c549598844111c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 18 Feb 2007 16:21:28 +0000 Subject: r21430: Support tagged types without typedef. This means: struct foo { ... }; in IDL will now work. This is the first step towards nested types and using typedefs for partial types (such as "typedef int *bar;"), a requirement for complex uses of represent_as(). (This used to be commit a716aa70f0c90898e6fcf57d63a2cf4c40e7d4df) --- source4/pidl/lib/Parse/Pidl/Expr.pm | 72 +- source4/pidl/lib/Parse/Pidl/IDL.pm | 1792 +++++++++++----------- source4/pidl/lib/Parse/Pidl/NDR.pm | 84 +- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 10 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 213 ++- 5 files changed, 1126 insertions(+), 1045 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Expr.pm b/source4/pidl/lib/Parse/Pidl/Expr.pm index f64db508d6..4e02be0575 100644 --- a/source4/pidl/lib/Parse/Pidl/Expr.pm +++ b/source4/pidl/lib/Parse/Pidl/Expr.pm @@ -1127,7 +1127,7 @@ sub new { [#Rule 2 'exp', 1, sub -#line 22 "expr.yp" +#line 22 "pidl/expr.yp" { "\"$_[1]\"" } ], [#Rule 3 @@ -1139,199 +1139,199 @@ sub [#Rule 5 'exp', 2, sub -#line 25 "expr.yp" +#line 25 "pidl/expr.yp" { "~$_[2]" } ], [#Rule 6 'exp', 3, sub -#line 26 "expr.yp" +#line 26 "pidl/expr.yp" { "$_[1] + $_[3]" } ], [#Rule 7 'exp', 3, sub -#line 27 "expr.yp" +#line 27 "pidl/expr.yp" { "$_[1] - $_[3]" } ], [#Rule 8 'exp', 3, sub -#line 28 "expr.yp" +#line 28 "pidl/expr.yp" { "$_[1] * $_[3]" } ], [#Rule 9 'exp', 3, sub -#line 29 "expr.yp" +#line 29 "pidl/expr.yp" { "$_[1] % $_[3]" } ], [#Rule 10 'exp', 3, sub -#line 30 "expr.yp" +#line 30 "pidl/expr.yp" { "$_[1] < $_[3]" } ], [#Rule 11 'exp', 3, sub -#line 31 "expr.yp" +#line 31 "pidl/expr.yp" { "$_[1] > $_[3]" } ], [#Rule 12 'exp', 3, sub -#line 32 "expr.yp" +#line 32 "pidl/expr.yp" { "$_[1] | $_[3]" } ], [#Rule 13 'exp', 3, sub -#line 33 "expr.yp" +#line 33 "pidl/expr.yp" { "$_[1] == $_[3]" } ], [#Rule 14 'exp', 3, sub -#line 34 "expr.yp" +#line 34 "pidl/expr.yp" { "$_[1] <= $_[3]" } ], [#Rule 15 'exp', 3, sub -#line 35 "expr.yp" +#line 35 "pidl/expr.yp" { "$_[1] => $_[3]" } ], [#Rule 16 'exp', 3, sub -#line 36 "expr.yp" +#line 36 "pidl/expr.yp" { "$_[1] << $_[3]" } ], [#Rule 17 'exp', 3, sub -#line 37 "expr.yp" +#line 37 "pidl/expr.yp" { "$_[1] >> $_[3]" } ], [#Rule 18 'exp', 3, sub -#line 38 "expr.yp" +#line 38 "pidl/expr.yp" { "$_[1] != $_[3]" } ], [#Rule 19 'exp', 3, sub -#line 39 "expr.yp" +#line 39 "pidl/expr.yp" { "$_[1] || $_[3]" } ], [#Rule 20 'exp', 3, sub -#line 40 "expr.yp" +#line 40 "pidl/expr.yp" { "$_[1] && $_[3]" } ], [#Rule 21 'exp', 3, sub -#line 41 "expr.yp" +#line 41 "pidl/expr.yp" { "$_[1] & $_[3]" } ], [#Rule 22 'exp', 5, sub -#line 42 "expr.yp" +#line 42 "pidl/expr.yp" { "$_[1]?$_[3]:$_[5]" } ], [#Rule 23 'exp', 2, sub -#line 43 "expr.yp" +#line 43 "pidl/expr.yp" { "~$_[1]" } ], [#Rule 24 'exp', 2, sub -#line 44 "expr.yp" +#line 44 "pidl/expr.yp" { "not $_[1]" } ], [#Rule 25 'exp', 3, sub -#line 45 "expr.yp" +#line 45 "pidl/expr.yp" { "$_[1] / $_[3]" } ], [#Rule 26 'exp', 2, sub -#line 46 "expr.yp" +#line 46 "pidl/expr.yp" { "-$_[2]" } ], [#Rule 27 'exp', 2, sub -#line 47 "expr.yp" +#line 47 "pidl/expr.yp" { "&$_[2]" } ], [#Rule 28 'exp', 3, sub -#line 48 "expr.yp" +#line 48 "pidl/expr.yp" { "$_[1]^$_[3]" } ], [#Rule 29 'exp', 3, sub -#line 49 "expr.yp" +#line 49 "pidl/expr.yp" { "($_[2])" } ], [#Rule 30 'possible_pointer', 1, sub -#line 53 "expr.yp" +#line 53 "pidl/expr.yp" { $_[0]->_Lookup($_[1]) } ], [#Rule 31 'possible_pointer', 2, sub -#line 54 "expr.yp" +#line 54 "pidl/expr.yp" { $_[0]->_Dereference($_[2]); "*$_[2]" } ], [#Rule 32 'var', 1, sub -#line 57 "expr.yp" +#line 57 "pidl/expr.yp" { $_[0]->_Use($_[1]) } ], [#Rule 33 'var', 3, sub -#line 58 "expr.yp" +#line 58 "pidl/expr.yp" { $_[0]->_Use("$_[1].$_[3]") } ], [#Rule 34 'var', 3, sub -#line 59 "expr.yp" +#line 59 "pidl/expr.yp" { "($_[2])" } ], [#Rule 35 'var', 3, sub -#line 60 "expr.yp" +#line 60 "pidl/expr.yp" { $_[0]->_Use("*$_[1]"); $_[1]."->".$_[3] } ], [#Rule 36 'func', 4, sub -#line 64 "expr.yp" +#line 64 "pidl/expr.yp" { "$_[1]($_[3])" } ], [#Rule 37 'opt_args', 0, sub -#line 65 "expr.yp" +#line 65 "pidl/expr.yp" { "" } ], [#Rule 38 @@ -1349,7 +1349,7 @@ sub [#Rule 42 'args', 3, sub -#line 68 "expr.yp" +#line 68 "pidl/expr.yp" { "$_[1], $_[3]" } ] ], @@ -1357,7 +1357,7 @@ sub bless($self,$class); } -#line 71 "expr.yp" +#line 71 "pidl/expr.yp" package Parse::Pidl::Expr; diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 71c4470870..e547b2caa8 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -258,29 +258,24 @@ sub new { }, {#State 39 ACTIONS => { - "typedef" => 49, - "union" => 50, - "enum" => 63, - "bitmap" => 64, "declare" => 56, - "const" => 58, - "struct" => 61 + "const" => 60 }, DEFAULT => -91, GOTOS => { - 'typedecl' => 62, - 'function' => 51, - 'bitmap' => 65, + 'typedecl' => 49, + 'function' => 50, 'definitions' => 52, + 'bitmap' => 51, 'definition' => 55, 'property_list' => 54, 'usertype' => 53, - 'declare' => 67, - 'const' => 66, + 'const' => 59, + 'declare' => 58, 'struct' => 57, - 'enum' => 59, - 'typedef' => 60, - 'union' => 68 + 'typedef' => 62, + 'enum' => 61, + 'union' => 63 } }, {#State 40 @@ -288,28 +283,28 @@ sub new { }, {#State 41 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, DEFAULT => -97 }, {#State 42 ACTIONS => { - "," => 84, - ")" => 85 + "," => 79, + ")" => 80 } }, {#State 43 @@ -326,11 +321,11 @@ sub new { }, {#State 47 ACTIONS => { - ";" => 86 + ";" => 82 }, DEFAULT => -125, GOTOS => { - 'optional_semicolon' => 87 + 'optional_semicolon' => 81 } }, {#State 48 @@ -338,81 +333,69 @@ sub new { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 88 + 'identifier' => 83 } }, {#State 49 - DEFAULT => -91, - GOTOS => { - 'property_list' => 89 - } + DEFAULT => -24 }, {#State 50 - ACTIONS => { - 'IDENTIFIER' => 90 - }, - DEFAULT => -122, - GOTOS => { - 'optional_identifier' => 91 - } + DEFAULT => -20 }, {#State 51 - DEFAULT => -20 + DEFAULT => -39 }, {#State 52 ACTIONS => { - "}" => 92, - "typedef" => 49, - "union" => 50, - "enum" => 63, - "bitmap" => 64, + "}" => 84, "declare" => 56, - "const" => 58, - "struct" => 61 + "const" => 60 }, DEFAULT => -91, GOTOS => { - 'typedecl' => 62, - 'function' => 51, - 'bitmap' => 65, - 'definition' => 93, + 'typedecl' => 49, + 'function' => 50, + 'bitmap' => 51, + 'definition' => 85, 'property_list' => 54, 'usertype' => 53, - 'const' => 66, + 'const' => 59, 'struct' => 57, - 'declare' => 67, - 'enum' => 59, - 'typedef' => 60, - 'union' => 68 + 'declare' => 58, + 'typedef' => 62, + 'enum' => 61, + 'union' => 63 } }, {#State 53 ACTIONS => { - ";" => 94 + ";" => 86 } }, {#State 54 ACTIONS => { + "typedef" => 87, 'IDENTIFIER' => 22, - "signed" => 100, - "union" => 50, - "enum" => 63, - "bitmap" => 64, - 'void' => 95, - "unsigned" => 101, + "signed" => 95, + "union" => 88, + "enum" => 97, + "bitmap" => 98, + 'void' => 89, + "unsigned" => 99, "[" => 17, - "struct" => 61 + "struct" => 94 }, GOTOS => { - 'existingtype' => 99, - 'bitmap' => 65, - 'usertype' => 96, - 'identifier' => 97, + 'existingtype' => 96, + 'bitmap' => 51, + 'usertype' => 91, + 'property_list' => 90, + 'identifier' => 92, 'struct' => 57, - 'enum' => 59, - 'type' => 102, - 'union' => 68, - 'sign' => 98 + 'enum' => 61, + 'type' => 100, + 'union' => 63, + 'sign' => 93 } }, {#State 55 @@ -421,69 +404,36 @@ sub new { {#State 56 DEFAULT => -91, GOTOS => { - 'property_list' => 103 + 'property_list' => 101 } }, {#State 57 DEFAULT => -36 }, {#State 58 - ACTIONS => { - 'IDENTIFIER' => 22 - }, - GOTOS => { - 'identifier' => 104 - } + DEFAULT => -23 }, {#State 59 - DEFAULT => -38 + DEFAULT => -21 }, {#State 60 - DEFAULT => -22 - }, - {#State 61 ACTIONS => { - 'IDENTIFIER' => 90 + 'IDENTIFIER' => 22 }, - DEFAULT => -122, GOTOS => { - 'optional_identifier' => 105 + 'identifier' => 102 } }, + {#State 61 + DEFAULT => -38 + }, {#State 62 - DEFAULT => -24 + DEFAULT => -22 }, {#State 63 - ACTIONS => { - 'IDENTIFIER' => 90 - }, - DEFAULT => -122, - GOTOS => { - 'optional_identifier' => 106 - } - }, - {#State 64 - ACTIONS => { - 'IDENTIFIER' => 90 - }, - DEFAULT => -122, - GOTOS => { - 'optional_identifier' => 107 - } - }, - {#State 65 - DEFAULT => -39 - }, - {#State 66 - DEFAULT => -21 - }, - {#State 67 - DEFAULT => -23 - }, - {#State 68 DEFAULT => -37 }, - {#State 69 + {#State 64 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -492,12 +442,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 108, + 'anytext' => 103, 'text' => 46, 'constant' => 43 } }, - {#State 70 + {#State 65 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -506,12 +456,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 109, + 'anytext' => 104, 'text' => 46, 'constant' => 43 } }, - {#State 71 + {#State 66 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -520,12 +470,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 110, + 'anytext' => 105, 'text' => 46, 'constant' => 43 } }, - {#State 72 + {#State 67 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -534,12 +484,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 111, + 'anytext' => 106, 'text' => 46, 'constant' => 43 } }, - {#State 73 + {#State 68 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -548,12 +498,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 112, + 'anytext' => 107, 'text' => 46, 'constant' => 43 } }, - {#State 74 + {#State 69 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -562,12 +512,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 113, + 'anytext' => 108, 'text' => 46, 'constant' => 43 } }, - {#State 75 + {#State 70 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -576,12 +526,13 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 114, + 'anytext' => 109, 'text' => 46, - 'constant' => 43 + 'constant' => 43, + 'commalisttext' => 110 } }, - {#State 76 + {#State 71 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -590,13 +541,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 115, + 'anytext' => 111, 'text' => 46, - 'constant' => 43, - 'commalisttext' => 116 + 'constant' => 43 } }, - {#State 77 + {#State 72 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -605,12 +555,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 117, + 'anytext' => 112, 'text' => 46, 'constant' => 43 } }, - {#State 78 + {#State 73 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -619,12 +569,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 118, + 'anytext' => 113, 'text' => 46, 'constant' => 43 } }, - {#State 79 + {#State 74 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -633,12 +583,13 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 119, + 'anytext' => 109, 'text' => 46, - 'constant' => 43 + 'constant' => 43, + 'commalisttext' => 114 } }, - {#State 80 + {#State 75 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -649,11 +600,10 @@ sub new { 'identifier' => 45, 'anytext' => 115, 'text' => 46, - 'constant' => 43, - 'commalisttext' => 120 + 'constant' => 43 } }, - {#State 81 + {#State 76 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -662,12 +612,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 121, + 'anytext' => 116, 'text' => 46, 'constant' => 43 } }, - {#State 82 + {#State 77 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -676,12 +626,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 122, + 'anytext' => 117, 'text' => 46, 'constant' => 43 } }, - {#State 83 + {#State 78 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -690,12 +640,12 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 123, + 'anytext' => 118, 'text' => 46, 'constant' => 43 } }, - {#State 84 + {#State 79 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -704,785 +654,807 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 124, + 'anytext' => 119, 'text' => 46, 'constant' => 43 } }, - {#State 85 + {#State 80 DEFAULT => -96 }, - {#State 86 + {#State 81 + DEFAULT => -12 + }, + {#State 82 DEFAULT => -126 }, - {#State 87 - DEFAULT => -12 + {#State 83 + ACTIONS => { + ";" => 120 + } }, - {#State 88 + {#State 84 ACTIONS => { - ";" => 125 + ";" => 82 + }, + DEFAULT => -125, + GOTOS => { + 'optional_semicolon' => 121 } }, - {#State 89 + {#State 85 + DEFAULT => -19 + }, + {#State 86 + DEFAULT => -40 + }, + {#State 87 ACTIONS => { 'IDENTIFIER' => 22, - "signed" => 100, - "union" => 50, - "enum" => 63, - "bitmap" => 64, - 'void' => 95, - "unsigned" => 101, - "[" => 17, - "struct" => 61 + "signed" => 95, + 'void' => 89, + "unsigned" => 99 }, + DEFAULT => -91, GOTOS => { - 'existingtype' => 99, - 'bitmap' => 65, - 'usertype' => 96, - 'identifier' => 97, + 'existingtype' => 96, + 'bitmap' => 51, + 'usertype' => 91, + 'property_list' => 90, + 'identifier' => 92, 'struct' => 57, - 'enum' => 59, - 'type' => 126, - 'union' => 68, - 'sign' => 98 + 'enum' => 61, + 'type' => 122, + 'union' => 63, + 'sign' => 93 } }, - {#State 90 - DEFAULT => -121 - }, - {#State 91 + {#State 88 ACTIONS => { - "{" => 128 + 'IDENTIFIER' => 123 }, - DEFAULT => -76, + DEFAULT => -122, GOTOS => { - 'union_body' => 129, - 'opt_union_body' => 127 + 'optional_identifier' => 124 + } + }, + {#State 89 + DEFAULT => -47 + }, + {#State 90 + ACTIONS => { + "union" => 88, + "enum" => 97, + "bitmap" => 98, + "[" => 17, + "struct" => 94 } }, + {#State 91 + DEFAULT => -45 + }, {#State 92 + DEFAULT => -44 + }, + {#State 93 ACTIONS => { - ";" => 86 + 'IDENTIFIER' => 22 }, - DEFAULT => -125, GOTOS => { - 'optional_semicolon' => 130 + 'identifier' => 125 } }, - {#State 93 - DEFAULT => -19 - }, {#State 94 - DEFAULT => -40 + ACTIONS => { + 'IDENTIFIER' => 123 + }, + DEFAULT => -122, + GOTOS => { + 'optional_identifier' => 126 + } }, {#State 95 - DEFAULT => -47 + DEFAULT => -41 }, {#State 96 - DEFAULT => -45 + DEFAULT => -46 }, {#State 97 - DEFAULT => -44 + ACTIONS => { + 'IDENTIFIER' => 123 + }, + DEFAULT => -122, + GOTOS => { + 'optional_identifier' => 127 + } }, {#State 98 ACTIONS => { - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 123 }, + DEFAULT => -122, GOTOS => { - 'identifier' => 131 + 'optional_identifier' => 128 } }, {#State 99 - DEFAULT => -46 - }, - {#State 100 - DEFAULT => -41 - }, - {#State 101 DEFAULT => -42 }, - {#State 102 + {#State 100 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 132 + 'identifier' => 129 } }, - {#State 103 + {#State 101 ACTIONS => { - "union" => 133, - "enum" => 138, - "bitmap" => 139, + "union" => 130, + "enum" => 135, + "bitmap" => 136, "[" => 17 }, GOTOS => { - 'decl_enum' => 134, - 'decl_bitmap' => 135, - 'decl_type' => 137, - 'decl_union' => 136 + 'decl_enum' => 131, + 'decl_bitmap' => 132, + 'decl_type' => 134, + 'decl_union' => 133 } }, - {#State 104 + {#State 102 DEFAULT => -80, GOTOS => { - 'pointers' => 140 + 'pointers' => 137 } }, + {#State 103 + ACTIONS => { + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 + }, + DEFAULT => -114 + }, + {#State 104 + ACTIONS => { + ":" => 64, + "<" => 67, + "~" => 68, + "?" => 66, + "{" => 70, + "=" => 73 + }, + DEFAULT => -105 + }, {#State 105 ACTIONS => { - "{" => 142 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, - DEFAULT => -66, - GOTOS => { - 'struct_body' => 141, - 'opt_struct_body' => 143 - } + DEFAULT => -113 }, {#State 106 ACTIONS => { - "{" => 144 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, - DEFAULT => -49, - GOTOS => { - 'opt_enum_body' => 146, - 'enum_body' => 145 - } + DEFAULT => -109 }, {#State 107 ACTIONS => { - "{" => 148 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, - DEFAULT => -57, - GOTOS => { - 'bitmap_body' => 149, - 'opt_bitmap_body' => 147 - } + DEFAULT => -117 }, {#State 108 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 + ":" => 64, + "<" => 67, + "~" => 68, + "?" => 66, + "{" => 70, + "=" => 73 }, - DEFAULT => -114 + DEFAULT => -116 }, {#State 109 ACTIONS => { - ":" => 69, - "<" => 71, - "~" => 72, - "?" => 75, - "{" => 76, - "=" => 79 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, - DEFAULT => -105 + DEFAULT => -99 }, {#State 110 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 - }, - DEFAULT => -109 + "}" => 138, + "," => 139 + } }, {#State 111 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 + ":" => 64, + "<" => 67, + "~" => 68, + "?" => 66, + "{" => 70, + "=" => 73 }, - DEFAULT => -117 + DEFAULT => -111 }, {#State 112 ACTIONS => { - ":" => 69, - "<" => 71, - "~" => 72, - "?" => 75, - "{" => 76, - "=" => 79 + ":" => 64, + "<" => 67, + "~" => 68, + "?" => 66, + "{" => 70, + "=" => 73 }, - DEFAULT => -116 + DEFAULT => -112 }, {#State 113 ACTIONS => { - ":" => 69, - "<" => 71, - "~" => 72, - "?" => 75, - "{" => 76, - "=" => 79 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, - DEFAULT => -107 + DEFAULT => -115 }, {#State 114 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 - }, - DEFAULT => -113 + "," => 139, + ")" => 140 + } }, {#State 115 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 + ":" => 64, + "<" => 67, + "~" => 68, + "?" => 66, + "{" => 70, + "=" => 73 }, - DEFAULT => -99 + DEFAULT => -110 }, {#State 116 ACTIONS => { - "}" => 150, - "," => 151 - } + ":" => 64, + "<" => 67, + "~" => 68, + "?" => 66, + "{" => 70, + "=" => 73 + }, + DEFAULT => -107 }, {#State 117 ACTIONS => { - ":" => 69, - "<" => 71, - "~" => 72, - "?" => 75, - "{" => 76, - "=" => 79 + ":" => 64, + "<" => 67, + "~" => 68, + "?" => 66, + "{" => 70, + "=" => 73 }, - DEFAULT => -111 + DEFAULT => -106 }, {#State 118 ACTIONS => { - ":" => 69, - "<" => 71, - "~" => 72, - "?" => 75, - "{" => 76, - "=" => 79 + ":" => 64, + "<" => 67, + "~" => 68, + "?" => 66, + "{" => 70, + "=" => 73 }, - DEFAULT => -112 + DEFAULT => -108 }, {#State 119 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, - DEFAULT => -115 + DEFAULT => -98 }, {#State 120 - ACTIONS => { - "," => 151, - ")" => 152 - } + DEFAULT => -14 }, {#State 121 - ACTIONS => { - ":" => 69, - "<" => 71, - "~" => 72, - "?" => 75, - "{" => 76, - "=" => 79 - }, - DEFAULT => -110 + DEFAULT => -15 }, {#State 122 ACTIONS => { - ":" => 69, - "<" => 71, - "~" => 72, - "?" => 75, - "{" => 76, - "=" => 79 + 'IDENTIFIER' => 22 }, - DEFAULT => -106 + GOTOS => { + 'identifier' => 141 + } }, {#State 123 - ACTIONS => { - ":" => 69, - "<" => 71, - "~" => 72, - "?" => 75, - "{" => 76, - "=" => 79 - }, - DEFAULT => -108 + DEFAULT => -121 }, {#State 124 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 + "{" => 143 }, - DEFAULT => -98 + DEFAULT => -76, + GOTOS => { + 'union_body' => 144, + 'opt_union_body' => 142 + } }, {#State 125 - DEFAULT => -14 + DEFAULT => -43 }, {#State 126 ACTIONS => { - 'IDENTIFIER' => 22 + "{" => 146 }, + DEFAULT => -66, GOTOS => { - 'identifier' => 153 + 'struct_body' => 145, + 'opt_struct_body' => 147 } }, {#State 127 - DEFAULT => -78 + ACTIONS => { + "{" => 148 + }, + DEFAULT => -49, + GOTOS => { + 'opt_enum_body' => 150, + 'enum_body' => 149 + } }, {#State 128 - DEFAULT => -73, + ACTIONS => { + "{" => 152 + }, + DEFAULT => -57, GOTOS => { - 'union_elements' => 154 + 'bitmap_body' => 153, + 'opt_bitmap_body' => 151 } }, {#State 129 - DEFAULT => -77 + ACTIONS => { + "(" => 154 + } }, {#State 130 - DEFAULT => -15 + DEFAULT => -34 }, {#State 131 - DEFAULT => -43 + DEFAULT => -29 }, {#State 132 - ACTIONS => { - "(" => 155 - } + DEFAULT => -30 }, {#State 133 - DEFAULT => -34 + DEFAULT => -31 }, {#State 134 - DEFAULT => -29 + ACTIONS => { + 'IDENTIFIER' => 22 + }, + GOTOS => { + 'identifier' => 155 + } }, {#State 135 - DEFAULT => -30 + DEFAULT => -32 }, {#State 136 - DEFAULT => -31 + DEFAULT => -33 }, {#State 137 ACTIONS => { - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 22, + "*" => 157 }, GOTOS => { 'identifier' => 156 } }, {#State 138 - DEFAULT => -32 + ACTIONS => { + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 45, + 'anytext' => 158, + 'text' => 46, + 'constant' => 43 + } }, {#State 139 - DEFAULT => -33 + ACTIONS => { + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 45, + 'anytext' => 159, + 'text' => 46, + 'constant' => 43 + } }, {#State 140 ACTIONS => { - 'IDENTIFIER' => 22, - "*" => 158 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, + DEFAULT => -101, GOTOS => { - 'identifier' => 157 + 'identifier' => 45, + 'anytext' => 160, + 'text' => 46, + 'constant' => 43 } }, {#State 141 - DEFAULT => -67 - }, - {#State 142 - DEFAULT => -82, + ACTIONS => { + "[" => 161 + }, + DEFAULT => -88, GOTOS => { - 'element_list1' => 159 + 'array_len' => 162 } }, - {#State 143 - DEFAULT => -68 + {#State 142 + DEFAULT => -78 }, - {#State 144 - ACTIONS => { - 'IDENTIFIER' => 22 - }, + {#State 143 + DEFAULT => -73, GOTOS => { - 'identifier' => 160, - 'enum_element' => 161, - 'enum_elements' => 162 + 'union_elements' => 163 } }, + {#State 144 + DEFAULT => -77 + }, {#State 145 - DEFAULT => -50 + DEFAULT => -67 }, {#State 146 - DEFAULT => -51 + DEFAULT => -82, + GOTOS => { + 'element_list1' => 164 + } }, {#State 147 - DEFAULT => -59 + DEFAULT => -68 }, {#State 148 ACTIONS => { 'IDENTIFIER' => 22 }, - DEFAULT => -62, GOTOS => { 'identifier' => 165, - 'bitmap_element' => 164, - 'bitmap_elements' => 163, - 'opt_bitmap_elements' => 166 + 'enum_element' => 166, + 'enum_elements' => 167 } }, {#State 149 - DEFAULT => -58 + DEFAULT => -50 }, {#State 150 - ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -101, - GOTOS => { - 'identifier' => 45, - 'anytext' => 167, - 'text' => 46, - 'constant' => 43 - } + DEFAULT => -51 }, {#State 151 - ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -101, - GOTOS => { - 'identifier' => 45, - 'anytext' => 168, - 'text' => 46, - 'constant' => 43 - } + DEFAULT => -59 }, {#State 152 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -62, GOTOS => { - 'identifier' => 45, - 'anytext' => 169, - 'text' => 46, - 'constant' => 43 + 'identifier' => 170, + 'bitmap_element' => 169, + 'bitmap_elements' => 168, + 'opt_bitmap_elements' => 171 } }, {#State 153 - ACTIONS => { - "[" => 170 - }, - DEFAULT => -88, - GOTOS => { - 'array_len' => 171 - } + DEFAULT => -58 }, {#State 154 ACTIONS => { - "}" => 172 + "," => -84, + "void" => 175, + ")" => -84 }, DEFAULT => -91, GOTOS => { - 'optional_base_element' => 174, + 'base_element' => 172, + 'element_list2' => 174, 'property_list' => 173 } }, {#State 155 ACTIONS => { - "," => -84, - "void" => 178, - ")" => -84 - }, - DEFAULT => -91, - GOTOS => { - 'base_element' => 175, - 'element_list2' => 177, - 'property_list' => 176 + ";" => 176 } }, {#State 156 ACTIONS => { - ";" => 179 - } - }, - {#State 157 - ACTIONS => { - "[" => 170, - "=" => 181 + "[" => 161, + "=" => 178 }, GOTOS => { - 'array_len' => 180 + 'array_len' => 177 } }, - {#State 158 + {#State 157 DEFAULT => -81 }, + {#State 158 + ACTIONS => { + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 + }, + DEFAULT => -119 + }, {#State 159 ACTIONS => { - "}" => 182 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, - DEFAULT => -91, - GOTOS => { - 'base_element' => 183, - 'property_list' => 176 - } + DEFAULT => -100 }, {#State 160 ACTIONS => { - "=" => 184 + ":" => 64, + "<" => 67, + "~" => 68, + "?" => 66, + "{" => 70, + "=" => 73 }, - DEFAULT => -54 + DEFAULT => -118 }, {#State 161 - DEFAULT => -52 + ACTIONS => { + 'CONSTANT' => 44, + 'TEXT' => 13, + "]" => 179, + 'IDENTIFIER' => 22 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 45, + 'anytext' => 180, + 'text' => 46, + 'constant' => 43 + } }, {#State 162 ACTIONS => { - "}" => 185, - "," => 186 + ";" => 181 } }, {#State 163 ACTIONS => { - "," => 187 + "}" => 182 }, - DEFAULT => -63 + DEFAULT => -91, + GOTOS => { + 'optional_base_element' => 184, + 'property_list' => 183 + } }, {#State 164 - DEFAULT => -60 + ACTIONS => { + "}" => 185 + }, + DEFAULT => -91, + GOTOS => { + 'base_element' => 186, + 'property_list' => 173 + } }, {#State 165 ACTIONS => { - "=" => 188 - } + "=" => 187 + }, + DEFAULT => -54 }, {#State 166 - ACTIONS => { - "}" => 189 - } + DEFAULT => -52 }, {#State 167 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 - }, - DEFAULT => -119 + "}" => 188, + "," => 189 + } }, {#State 168 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 + "," => 190 }, - DEFAULT => -100 + DEFAULT => -63 }, {#State 169 - ACTIONS => { - ":" => 69, - "<" => 71, - "~" => 72, - "?" => 75, - "{" => 76, - "=" => 79 - }, - DEFAULT => -118 + DEFAULT => -60 }, {#State 170 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - "]" => 190, - 'IDENTIFIER' => 22 - }, - DEFAULT => -101, - GOTOS => { - 'identifier' => 45, - 'anytext' => 191, - 'text' => 46, - 'constant' => 43 + "=" => 191 } }, {#State 171 ACTIONS => { - ";" => 192 + "}" => 192 } }, {#State 172 - DEFAULT => -75 + DEFAULT => -86 }, {#State 173 ACTIONS => { + 'IDENTIFIER' => 22, + "signed" => 95, + 'void' => 89, + "unsigned" => 99, "[" => 17 }, DEFAULT => -91, GOTOS => { - 'base_or_empty' => 193, - 'base_element' => 194, - 'empty_element' => 195, - 'property_list' => 196 - } - }, - {#State 174 - DEFAULT => -74 - }, - {#State 175 - DEFAULT => -86 - }, - {#State 176 - ACTIONS => { - 'IDENTIFIER' => 22, - "signed" => 100, - "union" => 50, - "enum" => 63, - "bitmap" => 64, - 'void' => 95, - "unsigned" => 101, - "[" => 17, - "struct" => 61 - }, - GOTOS => { - 'existingtype' => 99, - 'bitmap' => 65, - 'usertype' => 96, - 'identifier' => 97, + 'existingtype' => 96, + 'bitmap' => 51, + 'usertype' => 91, + 'property_list' => 90, + 'identifier' => 92, 'struct' => 57, - 'enum' => 59, - 'type' => 197, - 'union' => 68, - 'sign' => 98 + 'enum' => 61, + 'type' => 193, + 'union' => 63, + 'sign' => 93 } }, - {#State 177 + {#State 174 ACTIONS => { - "," => 198, - ")" => 199 + "," => 194, + ")" => 195 } }, - {#State 178 + {#State 175 DEFAULT => -85 }, - {#State 179 + {#State 176 DEFAULT => -28 }, - {#State 180 + {#State 177 ACTIONS => { - "=" => 200 + "=" => 196 } }, - {#State 181 + {#State 178 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -1491,20 +1463,70 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 201, + 'anytext' => 197, 'text' => 46, 'constant' => 43 } }, + {#State 179 + ACTIONS => { + "[" => 161 + }, + DEFAULT => -88, + GOTOS => { + 'array_len' => 198 + } + }, + {#State 180 + ACTIONS => { + "-" => 65, + ":" => 64, + "?" => 66, + "<" => 67, + "+" => 69, + "~" => 68, + "&" => 71, + "{" => 70, + "/" => 72, + "=" => 73, + "|" => 75, + "(" => 74, + "*" => 76, + "." => 77, + "]" => 199, + ">" => 78 + } + }, + {#State 181 + DEFAULT => -35 + }, {#State 182 - DEFAULT => -65 + DEFAULT => -75 }, {#State 183 ACTIONS => { - ";" => 202 + "[" => 17 + }, + DEFAULT => -91, + GOTOS => { + 'base_or_empty' => 200, + 'base_element' => 201, + 'empty_element' => 202, + 'property_list' => 203 } }, {#State 184 + DEFAULT => -74 + }, + {#State 185 + DEFAULT => -65 + }, + {#State 186 + ACTIONS => { + ";" => 204 + } + }, + {#State 187 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -1513,33 +1535,33 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 203, + 'anytext' => 205, 'text' => 46, 'constant' => 43 } }, - {#State 185 + {#State 188 DEFAULT => -48 }, - {#State 186 + {#State 189 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 160, - 'enum_element' => 204 + 'identifier' => 165, + 'enum_element' => 206 } }, - {#State 187 + {#State 190 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 165, - 'bitmap_element' => 205 + 'identifier' => 170, + 'bitmap_element' => 207 } }, - {#State 188 + {#State 191 ACTIONS => { 'CONSTANT' => 44, 'TEXT' => 13, @@ -1548,245 +1570,211 @@ sub new { DEFAULT => -101, GOTOS => { 'identifier' => 45, - 'anytext' => 206, + 'anytext' => 208, 'text' => 46, 'constant' => 43 } }, - {#State 189 + {#State 192 DEFAULT => -56 }, - {#State 190 - ACTIONS => { - "[" => 170 - }, - DEFAULT => -88, + {#State 193 + DEFAULT => -80, GOTOS => { - 'array_len' => 207 - } - }, - {#State 191 - ACTIONS => { - "-" => 70, - ":" => 69, - "?" => 75, - "<" => 71, - "+" => 73, - "~" => 72, - "&" => 77, - "{" => 76, - "/" => 78, - "=" => 79, - "|" => 81, - "(" => 80, - "*" => 74, - "." => 82, - "]" => 208, - ">" => 83 + 'pointers' => 209 } }, - {#State 192 - DEFAULT => -35 - }, - {#State 193 - DEFAULT => -72 - }, {#State 194 - ACTIONS => { - ";" => 209 + DEFAULT => -91, + GOTOS => { + 'base_element' => 210, + 'property_list' => 173 } }, {#State 195 - DEFAULT => -71 + ACTIONS => { + ";" => 211 + } }, {#State 196 ACTIONS => { - 'IDENTIFIER' => 22, - "signed" => 100, - "union" => 50, - ";" => 210, - "enum" => 63, - "bitmap" => 64, - 'void' => 95, - "unsigned" => 101, - "[" => 17, - "struct" => 61 + 'CONSTANT' => 44, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, + DEFAULT => -101, GOTOS => { - 'existingtype' => 99, - 'bitmap' => 65, - 'usertype' => 96, - 'identifier' => 97, - 'struct' => 57, - 'enum' => 59, - 'type' => 197, - 'union' => 68, - 'sign' => 98 + 'identifier' => 45, + 'anytext' => 212, + 'text' => 46, + 'constant' => 43 } }, {#State 197 - DEFAULT => -80, - GOTOS => { - 'pointers' => 211 + ACTIONS => { + "-" => 65, + ":" => 64, + "?" => 66, + "<" => 67, + ";" => 213, + "+" => 69, + "~" => 68, + "&" => 71, + "{" => 70, + "/" => 72, + "=" => 73, + "|" => 75, + "(" => 74, + "*" => 76, + "." => 77, + ">" => 78 } }, {#State 198 - DEFAULT => -91, - GOTOS => { - 'base_element' => 212, - 'property_list' => 176 - } + DEFAULT => -89 }, {#State 199 ACTIONS => { - ";" => 213 - } - }, - {#State 200 - ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + "[" => 161 }, - DEFAULT => -101, + DEFAULT => -88, GOTOS => { - 'identifier' => 45, - 'anytext' => 214, - 'text' => 46, - 'constant' => 43 + 'array_len' => 214 } }, + {#State 200 + DEFAULT => -72 + }, {#State 201 ACTIONS => { - "-" => 70, - ":" => 69, - "?" => 75, - "<" => 71, - ";" => 215, - "+" => 73, - "~" => 72, - "&" => 77, - "{" => 76, - "/" => 78, - "=" => 79, - "|" => 81, - "(" => 80, - "*" => 74, - "." => 82, - ">" => 83 + ";" => 215 } }, {#State 202 - DEFAULT => -83 + DEFAULT => -71 }, {#State 203 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 + 'IDENTIFIER' => 22, + "signed" => 95, + ";" => 216, + 'void' => 89, + "unsigned" => 99, + "[" => 17 }, - DEFAULT => -55 + DEFAULT => -91, + GOTOS => { + 'existingtype' => 96, + 'bitmap' => 51, + 'usertype' => 91, + 'property_list' => 90, + 'identifier' => 92, + 'struct' => 57, + 'enum' => 61, + 'type' => 193, + 'union' => 63, + 'sign' => 93 + } }, {#State 204 - DEFAULT => -53 + DEFAULT => -83 }, {#State 205 - DEFAULT => -61 - }, - {#State 206 ACTIONS => { - "-" => 70, - ":" => 69, - "<" => 71, - "+" => 73, - "~" => 72, - "*" => 74, - "?" => 75, - "{" => 76, - "&" => 77, - "/" => 78, - "=" => 79, - "(" => 80, - "|" => 81, - "." => 82, - ">" => 83 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, - DEFAULT => -64 + DEFAULT => -55 + }, + {#State 206 + DEFAULT => -53 }, {#State 207 - DEFAULT => -89 + DEFAULT => -61 }, {#State 208 ACTIONS => { - "[" => 170 + "-" => 65, + ":" => 64, + "<" => 67, + "+" => 69, + "~" => 68, + "*" => 76, + "?" => 66, + "{" => 70, + "&" => 71, + "/" => 72, + "=" => 73, + "(" => 74, + "|" => 75, + "." => 77, + ">" => 78 }, - DEFAULT => -88, - GOTOS => { - 'array_len' => 216 - } + DEFAULT => -64 }, {#State 209 - DEFAULT => -70 - }, - {#State 210 - DEFAULT => -69 - }, - {#State 211 ACTIONS => { 'IDENTIFIER' => 22, - "*" => 158 + "*" => 157 }, GOTOS => { 'identifier' => 217 } }, - {#State 212 + {#State 210 DEFAULT => -87 }, - {#State 213 + {#State 211 DEFAULT => -27 }, - {#State 214 + {#State 212 ACTIONS => { - "-" => 70, - ":" => 69, - "?" => 75, - "<" => 71, + "-" => 65, + ":" => 64, + "?" => 66, + "<" => 67, ";" => 218, - "+" => 73, - "~" => 72, - "&" => 77, - "{" => 76, - "/" => 78, - "=" => 79, - "|" => 81, - "(" => 80, - "*" => 74, - "." => 82, - ">" => 83 + "+" => 69, + "~" => 68, + "&" => 71, + "{" => 70, + "/" => 72, + "=" => 73, + "|" => 75, + "(" => 74, + "*" => 76, + "." => 77, + ">" => 78 } }, - {#State 215 + {#State 213 DEFAULT => -25 }, - {#State 216 + {#State 214 DEFAULT => -90 }, + {#State 215 + DEFAULT => -70 + }, + {#State 216 + DEFAULT => -69 + }, {#State 217 ACTIONS => { - "[" => 170 + "[" => 161 }, DEFAULT => -88, GOTOS => { @@ -1811,37 +1799,37 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "pidl/idl.yp" +#line 19 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "pidl/idl.yp" +#line 20 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'idl', 2, sub -#line 21 "pidl/idl.yp" +#line 21 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 5 'idl', 2, sub -#line 22 "pidl/idl.yp" +#line 22 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 6 'idl', 2, sub -#line 23 "pidl/idl.yp" +#line 23 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'import', 3, sub -#line 26 "pidl/idl.yp" +#line 26 "idl.yp" {{ "TYPE" => "IMPORT", "PATHS" => $_[2], @@ -1852,7 +1840,7 @@ sub [#Rule 8 'include', 3, sub -#line 33 "pidl/idl.yp" +#line 33 "idl.yp" {{ "TYPE" => "INCLUDE", "PATHS" => $_[2], @@ -1863,7 +1851,7 @@ sub [#Rule 9 'importlib', 3, sub -#line 40 "pidl/idl.yp" +#line 40 "idl.yp" {{ "TYPE" => "IMPORTLIB", "PATHS" => $_[2], @@ -1874,19 +1862,19 @@ sub [#Rule 10 'commalist', 1, sub -#line 49 "pidl/idl.yp" +#line 49 "idl.yp" { [ $_[1] ] } ], [#Rule 11 'commalist', 3, sub -#line 50 "pidl/idl.yp" +#line 50 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 12 'coclass', 7, sub -#line 54 "pidl/idl.yp" +#line 54 "idl.yp" {{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -1902,13 +1890,13 @@ sub [#Rule 14 'interface_names', 4, sub -#line 66 "pidl/idl.yp" +#line 66 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 15 'interface', 8, sub -#line 70 "pidl/idl.yp" +#line 70 "idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -1925,19 +1913,19 @@ sub [#Rule 17 'base_interface', 2, sub -#line 83 "pidl/idl.yp" +#line 83 "idl.yp" { $_[2] } ], [#Rule 18 'definitions', 1, sub -#line 87 "pidl/idl.yp" +#line 87 "idl.yp" { [ $_[1] ] } ], [#Rule 19 'definitions', 2, sub -#line 88 "pidl/idl.yp" +#line 88 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 20 @@ -1958,7 +1946,7 @@ sub [#Rule 25 'const', 7, sub -#line 96 "pidl/idl.yp" +#line 96 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1972,7 +1960,7 @@ sub [#Rule 26 'const', 8, sub -#line 106 "pidl/idl.yp" +#line 106 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1987,7 +1975,7 @@ sub [#Rule 27 'function', 7, sub -#line 120 "pidl/idl.yp" +#line 120 "idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -2001,7 +1989,7 @@ sub [#Rule 28 'declare', 5, sub -#line 132 "pidl/idl.yp" +#line 132 "idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -2023,7 +2011,7 @@ sub [#Rule 32 'decl_enum', 1, sub -#line 146 "pidl/idl.yp" +#line 146 "idl.yp" {{ "TYPE" => "ENUM" }} @@ -2031,7 +2019,7 @@ sub [#Rule 33 'decl_bitmap', 1, sub -#line 152 "pidl/idl.yp" +#line 152 "idl.yp" {{ "TYPE" => "BITMAP" }} @@ -2039,7 +2027,7 @@ sub [#Rule 34 'decl_union', 1, sub -#line 158 "pidl/idl.yp" +#line 158 "idl.yp" {{ "TYPE" => "UNION" }} @@ -2047,10 +2035,10 @@ sub [#Rule 35 'typedef', 6, sub -#line 164 "pidl/idl.yp" +#line 164 "idl.yp" {{ "TYPE" => "TYPEDEF", - "PROPERTIES" => $_[2], + "PROPERTIES" => $_[1], "NAME" => $_[4], "DATA" => $_[3], "ARRAY_LEN" => $_[5], @@ -2073,7 +2061,7 @@ sub [#Rule 40 'typedecl', 2, sub -#line 177 "pidl/idl.yp" +#line 177 "idl.yp" { $_[1] } ], [#Rule 41 @@ -2085,7 +2073,7 @@ sub [#Rule 43 'existingtype', 2, sub -#line 182 "pidl/idl.yp" +#line 182 "idl.yp" { ($_[1]?$_[1]:"signed") ." $_[2]" } ], [#Rule 44 @@ -2100,13 +2088,13 @@ sub [#Rule 47 'type', 1, sub -#line 186 "pidl/idl.yp" +#line 186 "idl.yp" { "void" } ], [#Rule 48 'enum_body', 3, sub -#line 188 "pidl/idl.yp" +#line 188 "idl.yp" { $_[2] } ], [#Rule 49 @@ -2116,25 +2104,26 @@ sub 'opt_enum_body', 1, undef ], [#Rule 51 - 'enum', 3, + 'enum', 4, sub -#line 191 "pidl/idl.yp" +#line 191 "idl.yp" {{ "TYPE" => "ENUM", - "NAME" => $_[2], - "ELEMENTS" => $_[3] + "PROPERTIES" => $_[1], + "NAME" => $_[3], + "ELEMENTS" => $_[4] }} ], [#Rule 52 'enum_elements', 1, sub -#line 199 "pidl/idl.yp" +#line 200 "idl.yp" { [ $_[1] ] } ], [#Rule 53 'enum_elements', 3, sub -#line 200 "pidl/idl.yp" +#line 201 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 54 @@ -2143,13 +2132,13 @@ sub [#Rule 55 'enum_element', 3, sub -#line 204 "pidl/idl.yp" +#line 205 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 56 'bitmap_body', 3, sub -#line 207 "pidl/idl.yp" +#line 208 "idl.yp" { $_[2] } ], [#Rule 57 @@ -2159,25 +2148,26 @@ sub 'opt_bitmap_body', 1, undef ], [#Rule 59 - 'bitmap', 3, + 'bitmap', 4, sub -#line 210 "pidl/idl.yp" +#line 211 "idl.yp" {{ "TYPE" => "BITMAP", - "NAME" => $_[2], - "ELEMENTS" => $_[3] + "PROPERTIES" => $_[1], + "NAME" => $_[3], + "ELEMENTS" => $_[4] }} ], [#Rule 60 'bitmap_elements', 1, sub -#line 218 "pidl/idl.yp" +#line 220 "idl.yp" { [ $_[1] ] } ], [#Rule 61 'bitmap_elements', 3, sub -#line 219 "pidl/idl.yp" +#line 221 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 62 @@ -2189,13 +2179,13 @@ sub [#Rule 64 'bitmap_element', 3, sub -#line 224 "pidl/idl.yp" +#line 226 "idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 65 'struct_body', 3, sub -#line 227 "pidl/idl.yp" +#line 229 "idl.yp" { $_[2] } ], [#Rule 66 @@ -2205,19 +2195,20 @@ sub 'opt_struct_body', 1, undef ], [#Rule 68 - 'struct', 3, + 'struct', 4, sub -#line 231 "pidl/idl.yp" +#line 233 "idl.yp" {{ "TYPE" => "STRUCT", - "NAME" => $_[2], - "ELEMENTS" => $_[3] + "PROPERTIES" => $_[1], + "NAME" => $_[3], + "ELEMENTS" => $_[4] }} ], [#Rule 69 'empty_element', 2, sub -#line 239 "pidl/idl.yp" +#line 242 "idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2237,7 +2228,7 @@ sub [#Rule 72 'optional_base_element', 2, sub -#line 253 "pidl/idl.yp" +#line 256 "idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 73 @@ -2246,13 +2237,13 @@ sub [#Rule 74 'union_elements', 2, sub -#line 258 "pidl/idl.yp" +#line 261 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 75 'union_body', 3, sub -#line 261 "pidl/idl.yp" +#line 264 "idl.yp" { $_[2] } ], [#Rule 76 @@ -2262,19 +2253,20 @@ sub 'opt_union_body', 1, undef ], [#Rule 78 - 'union', 3, + 'union', 4, sub -#line 265 "pidl/idl.yp" +#line 268 "idl.yp" {{ "TYPE" => "UNION", - "NAME" => $_[2], - "ELEMENTS" => $_[3] + "PROPERTIES" => $_[1], + "NAME" => $_[3], + "ELEMENTS" => $_[4] }} ], [#Rule 79 'base_element', 5, sub -#line 273 "pidl/idl.yp" +#line 277 "idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2288,13 +2280,13 @@ sub [#Rule 80 'pointers', 0, sub -#line 287 "pidl/idl.yp" +#line 291 "idl.yp" { 0 } ], [#Rule 81 'pointers', 2, sub -#line 288 "pidl/idl.yp" +#line 292 "idl.yp" { $_[1]+1 } ], [#Rule 82 @@ -2303,7 +2295,7 @@ sub [#Rule 83 'element_list1', 3, sub -#line 293 "pidl/idl.yp" +#line 297 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 84 @@ -2315,13 +2307,13 @@ sub [#Rule 86 'element_list2', 1, sub -#line 299 "pidl/idl.yp" +#line 303 "idl.yp" { [ $_[1] ] } ], [#Rule 87 'element_list2', 3, sub -#line 300 "pidl/idl.yp" +#line 304 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 88 @@ -2330,13 +2322,13 @@ sub [#Rule 89 'array_len', 3, sub -#line 305 "pidl/idl.yp" +#line 309 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 90 'array_len', 4, sub -#line 306 "pidl/idl.yp" +#line 310 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 91 @@ -2345,31 +2337,31 @@ sub [#Rule 92 'property_list', 4, sub -#line 312 "pidl/idl.yp" +#line 316 "idl.yp" { FlattenHash([$_[1],$_[3]]); } ], [#Rule 93 'properties', 1, sub -#line 315 "pidl/idl.yp" +#line 319 "idl.yp" { $_[1] } ], [#Rule 94 'properties', 3, sub -#line 316 "pidl/idl.yp" +#line 320 "idl.yp" { FlattenHash([$_[1], $_[3]]); } ], [#Rule 95 'property', 1, sub -#line 319 "pidl/idl.yp" +#line 323 "idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 96 'property', 4, sub -#line 320 "pidl/idl.yp" +#line 324 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 97 @@ -2378,7 +2370,7 @@ sub [#Rule 98 'listtext', 3, sub -#line 325 "pidl/idl.yp" +#line 329 "idl.yp" { "$_[1] $_[3]" } ], [#Rule 99 @@ -2387,13 +2379,13 @@ sub [#Rule 100 'commalisttext', 3, sub -#line 330 "pidl/idl.yp" +#line 334 "idl.yp" { "$_[1],$_[3]" } ], [#Rule 101 'anytext', 0, sub -#line 334 "pidl/idl.yp" +#line 338 "idl.yp" { "" } ], [#Rule 102 @@ -2408,91 +2400,91 @@ sub [#Rule 105 'anytext', 3, sub -#line 336 "pidl/idl.yp" +#line 340 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 106 'anytext', 3, sub -#line 337 "pidl/idl.yp" +#line 341 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 338 "pidl/idl.yp" +#line 342 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 'anytext', 3, sub -#line 339 "pidl/idl.yp" +#line 343 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 109 'anytext', 3, sub -#line 340 "pidl/idl.yp" +#line 344 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 110 'anytext', 3, sub -#line 341 "pidl/idl.yp" +#line 345 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 111 'anytext', 3, sub -#line 342 "pidl/idl.yp" +#line 346 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 112 'anytext', 3, sub -#line 343 "pidl/idl.yp" +#line 347 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 113 'anytext', 3, sub -#line 344 "pidl/idl.yp" +#line 348 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 114 'anytext', 3, sub -#line 345 "pidl/idl.yp" +#line 349 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 115 'anytext', 3, sub -#line 346 "pidl/idl.yp" +#line 350 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 116 'anytext', 3, sub -#line 347 "pidl/idl.yp" +#line 351 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 117 'anytext', 3, sub -#line 348 "pidl/idl.yp" +#line 352 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 118 'anytext', 5, sub -#line 349 "pidl/idl.yp" +#line 353 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 119 'anytext', 5, sub -#line 350 "pidl/idl.yp" +#line 354 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 120 @@ -2510,7 +2502,7 @@ sub [#Rule 124 'text', 1, sub -#line 364 "pidl/idl.yp" +#line 368 "idl.yp" { "\"$_[1]\"" } ], [#Rule 125 @@ -2524,7 +2516,7 @@ sub bless($self,$class); } -#line 375 "pidl/idl.yp" +#line 379 "idl.yp" use Parse::Pidl qw(error); diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index b76a0f5a38..d55df7a452 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -383,6 +383,7 @@ sub ParseStruct($$) my @elements = (); my $surrounding = undef; + foreach my $x (@{$struct->{ELEMENTS}}) { my $e = ParseElement($x); @@ -403,13 +404,20 @@ sub ParseStruct($$) && property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) { $surrounding = $struct->{ELEMENTS}[-1]; } + + my $align = undef; + if ($struct->{NAME}) { + $align = align_type($struct->{NAME}); + } return { TYPE => "STRUCT", + NAME => $struct->{NAME}, SURROUNDING_ELEMENT => $surrounding, ELEMENTS => \@elements, PROPERTIES => $struct->{PROPERTIES}, - ORIGINAL => $struct + ORIGINAL => $struct, + ALIGN => $align }; } @@ -444,6 +452,7 @@ sub ParseUnion($$) return { TYPE => "UNION", + NAME => $e->{NAME}, SWITCH_TYPE => $switch_type, ELEMENTS => \@elements, PROPERTIES => $e->{PROPERTIES}, @@ -458,6 +467,7 @@ sub ParseEnum($$) return { TYPE => "ENUM", + NAME => $e->{NAME}, BASE_TYPE => Parse::Pidl::Typelist::enum_type_fn($e), ELEMENTS => $e->{ELEMENTS}, PROPERTIES => $e->{PROPERTIES}, @@ -471,6 +481,7 @@ sub ParseBitmap($$) return { TYPE => "BITMAP", + NAME => $e->{NAME}, BASE_TYPE => Parse::Pidl::Typelist::bitmap_type_fn($e), ELEMENTS => $e->{ELEMENTS}, PROPERTIES => $e->{PROPERTIES}, @@ -501,8 +512,8 @@ sub ParseTypedef($$) { my ($ndr,$d) = @_; - if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) { - $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES}; + if (defined($d->{DATA}->{PROPERTIES}) && !defined($d->{PROPERTIES})) { + $d->{PROPERTIES} = $d->{DATA}->{PROPERTIES}; } my $data = ParseType($ndr, $d->{DATA}); @@ -865,7 +876,7 @@ sub mapToScalar($) } ##################################################################### -# parse a struct +# validate an element sub ValidElement($) { my $e = shift; @@ -881,8 +892,8 @@ sub ValidElement($) fatal($e, el_name($e) . ": switch_is() used on non-union type $e->{TYPE} which is a $type->{DATA}->{TYPE}"); } - if (!has_property($type, "nodiscriminant") and defined($e2)) { - my $discriminator_type = has_property($type, "switch_type"); + if (not has_property($type->{DATA}, "nodiscriminant") and defined($e2)) { + my $discriminator_type = has_property($type->{DATA}, "switch_type"); $discriminator_type = "uint32" unless defined ($discriminator_type); my $t1 = mapToScalar($discriminator_type); @@ -940,12 +951,30 @@ sub ValidElement($) } ##################################################################### -# parse a struct +# validate an enum +sub ValidEnum($) +{ + my ($enum) = @_; + + ValidProperties($enum, "ENUM"); +} + +##################################################################### +# validate a bitmap +sub ValidBitmap($) +{ + my ($bitmap) = @_; + + ValidProperties($bitmap, "BITMAP"); +} + +##################################################################### +# validate a struct sub ValidStruct($) { my($struct) = shift; - ValidProperties($struct,"STRUCT"); + ValidProperties($struct, "STRUCT"); foreach my $e (@{$struct->{ELEMENTS}}) { $e->{PARENT} = $struct; @@ -994,23 +1023,15 @@ sub ValidTypedef($) my($typedef) = shift; my $data = $typedef->{DATA}; - ValidProperties($typedef,"TYPEDEF"); + ValidProperties($typedef, "TYPEDEF"); $data->{PARENT} = $typedef; - if (ref($data) eq "HASH") { - if ($data->{TYPE} eq "STRUCT") { - ValidStruct($data); - } - - if ($data->{TYPE} eq "UNION") { - ValidUnion($data); - } - } + ValidType($data) if (ref($data) eq "HASH"); } ##################################################################### -# parse a function +# validate a function sub ValidFunction($) { my($fn) = shift; @@ -1026,6 +1047,21 @@ sub ValidFunction($) } } +##################################################################### +# validate a type +sub ValidType($) +{ + my ($t) = @_; + + { + TYPEDEF => \&ValidTypedef, + STRUCT => \&ValidStruct, + UNION => \&ValidUnion, + ENUM => \&ValidEnum, + BITMAP => \&ValidBitmap + }->{$t->{TYPE}}->($t); +} + ##################################################################### # parse the interface definitions sub ValidInterface($) @@ -1059,10 +1095,12 @@ sub ValidInterface($) } foreach my $d (@{$data}) { - ($d->{TYPE} eq "TYPEDEF") && - ValidTypedef($d); - ($d->{TYPE} eq "FUNCTION") && - ValidFunction($d); + ($d->{TYPE} eq "FUNCTION") && ValidFunction($d); + ($d->{TYPE} eq "TYPEDEF" or + $d->{TYPE} eq "STRUCT" or + $d->{TYPE} eq "UNION" or + $d->{TYPE} eq "ENUM" or + $d->{TYPE} eq "BITMAP") && ValidType($d); } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 110a483fc4..fbc00d7c13 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -219,8 +219,6 @@ sub HeaderTypedef($) { my($typedef) = shift; HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); - pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP" or - $typedef->{DATA}->{TYPE} eq "ENUM"); } ##################################################################### @@ -354,8 +352,12 @@ sub HeaderInterface($) } foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "TYPEDEF"); - HeaderTypedef($d); + HeaderTypedef($d) if ($d->{TYPE} eq "TYPEDEF"); + HeaderStruct($d, $d->{NAME}) if ($d->{TYPE} eq "STRUCT"); + HeaderUnion($d, $d->{NAME}) if ($d->{TYPE} eq "UNION"); + HeaderEnum($d, $d->{NAME}) if ($d->{TYPE} eq "ENUM"); + HeaderBitmap($d, $d->{NAME}) if ($d->{TYPE} eq "BITMAP"); + pidl ";\n\n"; } foreach my $d (@{$interface->{DATA}}) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 6e4d5825d0..15618bb534 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -12,7 +12,7 @@ require Exporter; @EXPORT = qw(is_charset_array); @EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction - NeededElement NeededTypedef); + NeededElement NeededType); use strict; use Parse::Pidl::Typelist qw(hasType getType mapType); @@ -1335,10 +1335,10 @@ sub ParseEnumPrint($$) end_flags($enum); } -sub DeclEnum($) +sub DeclEnum($$$) { - my ($e,$t) = @_; - return "enum $e->{NAME} " . + my ($e,$t,$name) = @_; + return "enum $name " . ($t eq "pull"?"*":"") . "r"; } @@ -1418,10 +1418,10 @@ sub ParseBitmapPrint($$) end_flags($bitmap); } -sub DeclBitmap($$) +sub DeclBitmap($$$) { - my ($e,$t) = @_; - return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e->{DATA})) . + my ($e,$t,$name) = @_; + return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e)) . ($t eq "pull"?" *":" ") . "r"; } @@ -1581,27 +1581,27 @@ sub ParseStructPull($$) ##################################################################### # calculate size of ndr struct -sub ParseStructNdrSize($) +sub ParseStructNdrSize($$) { - my $t = shift; + my ($t, $name) = @_; my $sizevar; if (my $flags = has_property($t, "flag")) { pidl "flags |= $flags;"; } - pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});"; + pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$name);"; } -sub DeclStruct($) +sub DeclStruct($$$) { - my ($e,$t) = @_; - return ($t ne "pull"?"const ":"") . "struct $e->{NAME} *r"; + my ($e,$t,$name) = @_; + return ($t ne "pull"?"const ":"") . "struct $name *r"; } -sub ArgsStructNdrSize($) +sub ArgsStructNdrSize($$) { - my $d = shift; - return "const struct $d->{NAME} *r, int flags"; + my ($d, $name) = @_; + return "const struct $name *r, int flags"; } $typefamily{STRUCT} = { @@ -1615,16 +1615,16 @@ $typefamily{STRUCT} = { ##################################################################### # calculate size of ndr struct -sub ParseUnionNdrSize($) +sub ParseUnionNdrSize($$) { - my $t = shift; + my ($t, $name) = @_; my $sizevar; if (my $flags = has_property($t, "flag")) { pidl "flags |= $flags;"; } - pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});"; + pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$name);"; } ##################################################################### @@ -1864,16 +1864,16 @@ sub ParseUnionPull($$) pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); } -sub DeclUnion($$) +sub DeclUnion($$$) { - my ($e,$t) = @_; - return ($t ne "pull"?"const ":"") . "union $e->{NAME} *r"; + my ($e,$t,$name) = @_; + return ($t ne "pull"?"const ":"") . "union $name *r"; } -sub ArgsUnionNdrSize($) +sub ArgsUnionNdrSize($$) { - my $d = shift; - return "const union $d->{NAME} *r, uint32_t level, int flags"; + my ($d,$name) = @_; + return "const union $name *r, uint32_t level, int flags"; } $typefamily{UNION} = { @@ -1887,81 +1887,62 @@ $typefamily{UNION} = { ##################################################################### # parse a typedef - push side -sub ParseTypedefPush($) +sub ParseTypedefPush($$) { - my($e) = shift; - - my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push"); - fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)") or return; + my($e,$name) = @_; - pidl "{"; - indent; - $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $e->{NAME}); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl "";; + $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $name); } ##################################################################### # parse a typedef - pull side -sub ParseTypedefPull($) +sub ParseTypedefPull($$) { - my($e) = shift; - - my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull"); - - fn_declare("pull", $e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)") or return; + my($e,$name) = @_; - pidl "{"; - indent; - $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $e->{NAME}); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; + $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $name); } ##################################################################### # parse a typedef - print side -sub ParseTypedefPrint($) +sub ParseTypedefPrint($$) { - my($e) = shift; - - my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print"); - - pidl_hdr "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args);"; - - return if (has_property($e, "noprint")); + my($e,$name) = @_; - pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; - pidl "{"; - indent; - $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME}); - deindent; - pidl "}"; - pidl ""; + $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $name); } ##################################################################### ## calculate the size of a structure -sub ParseTypedefNdrSize($) +sub ParseTypedefNdrSize($$) { - my($t) = shift; + my($t,$name) = @_; - my $tf = $typefamily{$t->{DATA}->{TYPE}}; - my $args = $tf->{SIZE_FN_ARGS}->($t); + $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t->{DATA}, $name); +} - fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)") or return; +sub DeclTypedef($$$) +{ + my ($e, $t, $name) = @_; + + return $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e->{DATA}, $t, $name); +} - pidl "{"; - indent; - $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t); - deindent; - pidl "}"; - pidl ""; +sub ArgsTypedefNdrSize($$) +{ + my ($d, $name) = @_; + return $typefamily{$d->{DATA}->{TYPE}}->{SIZE_FN_ARGS}->($d->{DATA}, $name); } +$typefamily{TYPEDEF} = { + PUSH_FN_BODY => \&ParseTypedefPush, + DECL => \&DeclTypedef, + PULL_FN_BODY => \&ParseTypedefPull, + PRINT_FN_BODY => \&ParseTypedefPrint, + SIZE_FN_ARGS => \&ArgsTypedefNdrSize, + SIZE_FN_BODY => \&ParseTypedefNdrSize, +}; + ##################################################################### # parse a function - print side sub ParseFunctionPrint($) @@ -2379,6 +2360,74 @@ sub HeaderInterface($) } +sub ParseTypePush($) +{ + my ($e) = @_; + + my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}); + fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)") or return; + + pidl "{"; + indent; + $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($e, $e->{NAME}); + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl "";; +} + +sub ParseTypePull($) +{ + my ($e) = @_; + + my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "pull", $e->{NAME}); + + fn_declare("pull", $e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)") or return; + + pidl "{"; + indent; + $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($e, $e->{NAME}); + pidl "return NT_STATUS_OK;"; + deindent; + pidl "}"; + pidl ""; +} + +sub ParseTypePrint($) +{ + my ($e) = @_; + my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "print", $e->{NAME}); + + pidl_hdr "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args);"; + + return if (has_property($e, "noprint")); + + pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; + pidl "{"; + indent; + $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($e, $e->{NAME}); + deindent; + pidl "}"; + pidl ""; +} + +sub ParseTypeNdrSize($) +{ + my ($t) = @_; + + my $tf = $typefamily{$t->{TYPE}}; + my $args = $tf->{SIZE_FN_ARGS}->($t, $t->{NAME}); + + fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)") or return; + + pidl "{"; + indent; + $typefamily{$t->{TYPE}}->{SIZE_FN_BODY}->($t, $t->{NAME}); + deindent; + pidl "}"; + pidl ""; +} + ##################################################################### # parse the interface definitions sub ParseInterface($$) @@ -2398,15 +2447,15 @@ sub ParseInterface($$) # Typedefs foreach my $d (@{$interface->{TYPES}}) { - ($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d); - ($needed->{"pull_$d->{NAME}"}) && ParseTypedefPull($d); - ($needed->{"print_$d->{NAME}"}) && ParseTypedefPrint($d); + ($needed->{"push_$d->{NAME}"}) && ParseTypePush($d); + ($needed->{"pull_$d->{NAME}"}) && ParseTypePull($d); + ($needed->{"print_$d->{NAME}"}) && ParseTypePrint($d); # Make sure we don't generate a function twice... $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = $needed->{"print_$d->{NAME}"} = 0; - ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypedefNdrSize($d); + ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypeNdrSize($d); } # Functions @@ -2524,7 +2573,7 @@ sub NeededFunction($$) } } -sub NeededTypedef($$) +sub NeededType($$) { my ($t,$needed) = @_; if (has_property($t, "public")) { @@ -2556,7 +2605,7 @@ sub NeededInterface($$) { my ($interface,$needed) = @_; NeededFunction($_, $needed) foreach (@{$interface->{FUNCTIONS}}); - NeededTypedef($_, $needed) foreach (reverse @{$interface->{TYPES}}); + NeededType($_, $needed) foreach (reverse @{$interface->{TYPES}}); } 1; -- cgit From f9885687878560c21c569a850cb7023b062b4e33 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 18 Feb 2007 16:46:59 +0000 Subject: r21431: More tests, work on support in wireshark for tagged types. (This used to be commit a91e624af22aae5b460ccf94d2540b8780f90070) --- source4/pidl/lib/Parse/Pidl/Dump.pm | 22 ++++++++++++---------- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 22 +++++++++++++++------- 2 files changed, 27 insertions(+), 17 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Dump.pm b/source4/pidl/lib/Parse/Pidl/Dump.pm index 88f18de322..bf5811c116 100644 --- a/source4/pidl/lib/Parse/Pidl/Dump.pm +++ b/source4/pidl/lib/Parse/Pidl/Dump.pm @@ -24,7 +24,7 @@ use Exporter; use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); -@EXPORT_OK = qw(DumpTypedef DumpStruct DumpEnum DumpBitmap DumpUnion DumpFunction); +@EXPORT_OK = qw(DumpType DumpTypedef DumpStruct DumpEnum DumpBitmap DumpUnion DumpFunction); use strict; use Parse::Pidl::Util qw(has_property); @@ -87,7 +87,12 @@ sub DumpStruct($) my($struct) = shift; my($res); - $res .= "struct {\n"; + $res .= "struct "; + if ($struct->{NAME}) { + $res.="$struct->{NAME} "; + } + + $res.="{\n"; if (defined $struct->{ELEMENTS}) { foreach (@{$struct->{ELEMENTS}}) { $res .= "\t" . DumpElement($_) . ";\n"; @@ -185,18 +190,15 @@ sub DumpUnion($) sub DumpType($) { my($data) = shift; - my($res); if (ref($data) eq "HASH") { - ($data->{TYPE} eq "STRUCT") && ($res .= DumpStruct($data)); - ($data->{TYPE} eq "UNION") && ($res .= DumpUnion($data)); - ($data->{TYPE} eq "ENUM") && ($res .= DumpEnum($data)); - ($data->{TYPE} eq "BITMAP") && ($res .= DumpBitmap($data)); + return DumpStruct($data) if ($data->{TYPE} eq "STRUCT"); + return DumpUnion($data) if ($data->{TYPE} eq "UNION"); + return DumpEnum($data) if ($data->{TYPE} eq "ENUM"); + return DumpBitmap($data) if ($data->{TYPE} eq "BITMAP"); } else { - $res .= "$data"; + return $data; } - - return $res; } ##################################################################### diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 4a890fb630..9ba6f2f3e0 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -25,7 +25,7 @@ use Parse::Pidl qw(error warning); use Parse::Pidl::Typelist qw(getType); use Parse::Pidl::Util qw(has_property property_matches make_str); use Parse::Pidl::NDR qw(ContainsString GetNextLevel); -use Parse::Pidl::Dump qw(DumpTypedef DumpFunction); +use Parse::Pidl::Dump qw(DumpType DumpFunction); use Parse::Pidl::Wireshark::Conformance qw(ReadConformance); use File::Basename; @@ -127,7 +127,7 @@ sub Interface($) { my($interface) = @_; Const($_,$interface->{NAME}) foreach (@{$interface->{CONSTS}}); - Typedef($_,$interface->{NAME}) foreach (@{$interface->{TYPES}}); + Type($_, $_->{NAME}, $interface->{NAME}) foreach (@{$interface->{TYPES}}); Function($_,$interface->{NAME}) foreach (@{$interface->{FUNCTIONS}}); } @@ -637,18 +637,26 @@ sub Const($$) } } -sub Typedef($$) +sub Typedef($$$) { - my ($e,$ifname) = @_; + my ($e,$name,$ifname) = @_; + + Type($e->{DATA}, $name, $ifname); +} + +sub Type($$$) +{ + my ($e, $name, $ifname) = @_; - PrintIdl DumpTypedef($e->{ORIGINAL}); + PrintIdl DumpType($e->{ORIGINAL}); { ENUM => \&Enum, STRUCT => \&Struct, UNION => \&Union, - BITMAP => \&Bitmap - }->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $ifname); + BITMAP => \&Bitmap, + TYPEDEF => \&Typedef + }->{$e->{TYPE}}->($e, $name, $ifname); } sub RegisterInterface($) -- cgit From d425796fff07b8bc7b9eb49bc8db71aff9c1161f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 18 Feb 2007 16:54:54 +0000 Subject: r21432: Handle properties on tagged types in TDR. (This used to be commit 0d739c7e9807682cd5bc433c3e4f2d4bbe4f1b69) --- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index a3e8d3470b..cde5da2b6b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -207,7 +207,7 @@ sub ParserTypedef($$) return if (has_property($e, "no$t")); - $e->{DATA}->{PROPERTIES} = $e->{PROPERTIES}; + $e->{PROPERTIES} = $e->{DATA}->{PROPERTIES}; { STRUCT => \&ParserStruct, UNION => \&ParserUnion, ENUM => \&ParserEnum, BITMAP => \&ParserBitmap -- cgit From 0515f728e64dde0c197aee6180dce79ad281d5f8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 18 Feb 2007 18:44:56 +0000 Subject: r21433: Get rid of the COM support code - it's not used and unmaintained. We can always bring it back if we need to. This code was getting in the way while refactoring. Add some tests for TDR. Get rid of typedef in lib/registry/tdr_regf.idl and fix the TDR code to be able to deal with it. (This used to be commit 1ad0f99a439f0d52a735b391bf9900d50171aca5) --- source4/pidl/lib/Parse/Pidl/ODL.pm | 102 ------- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 4 +- source4/pidl/lib/Parse/Pidl/Samba4.pm | 6 +- source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm | 142 ---------- source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm | 219 --------------- source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm | 327 ----------------------- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 4 +- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 8 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 22 +- source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 4 +- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 65 +++-- source4/pidl/lib/Parse/Pidl/Typelist.pm | 51 ++-- 13 files changed, 91 insertions(+), 865 deletions(-) delete mode 100644 source4/pidl/lib/Parse/Pidl/ODL.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm delete mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/ODL.pm b/source4/pidl/lib/Parse/Pidl/ODL.pm deleted file mode 100644 index ee8d030a37..0000000000 --- a/source4/pidl/lib/Parse/Pidl/ODL.pm +++ /dev/null @@ -1,102 +0,0 @@ -########################################## -# Converts ODL stuctures to IDL structures -# (C) 2004-2005 Jelmer Vernooij - -package Parse::Pidl::ODL; - -use Parse::Pidl::Util qw(has_property); -use Parse::Pidl::Typelist qw(hasType getType); -use strict; - -use vars qw($VERSION); -$VERSION = '0.01'; - -##################################################################### -# find an interface in an array of interfaces -sub get_interface($$) -{ - my($if,$n) = @_; - - foreach(@$if) { - next if ($_->{TYPE} ne "INTERFACE"); - return $_ if($_->{NAME} eq $n); - } - - return 0; -} - -sub FunctionAddObjArgs($) -{ - my $e = shift; - - unshift(@{$e->{ELEMENTS}}, { - 'NAME' => 'ORPCthis', - 'POINTERS' => 0, - 'PROPERTIES' => { 'in' => '1' }, - 'TYPE' => 'ORPCTHIS', - 'FILE' => $e->{FILE}, - 'LINE' => $e->{LINE} - }); - unshift(@{$e->{ELEMENTS}}, { - 'NAME' => 'ORPCthat', - 'POINTERS' => 1, - 'PROPERTIES' => { 'out' => '1', 'ref' => '1' }, - 'TYPE' => 'ORPCTHAT', - 'FILE' => $e->{FILE}, - 'LINE' => $e->{LINE} - }); -} - -sub ReplaceInterfacePointers($) -{ - my $e = shift; - - foreach my $x (@{$e->{ELEMENTS}}) { - next unless (hasType($x->{TYPE})); - next unless getType($x->{TYPE})->{DATA}->{TYPE} eq "INTERFACE"; - - $x->{TYPE} = "MInterfacePointer"; - } -} - -# Add ORPC specific bits to an interface. -sub ODL2IDL($) -{ - my $odl = shift; - my $addedorpc = 0; - - foreach my $x (@$odl) { - next if ($x->{TYPE} ne "INTERFACE"); - # Add [in] ORPCTHIS *this, [out] ORPCTHAT *that - # and replace interfacepointers with MInterfacePointer - # for 'object' interfaces - if (has_property($x, "object")) { - foreach my $e (@{$x->{DATA}}) { - ($e->{TYPE} eq "FUNCTION") && FunctionAddObjArgs($e); - ReplaceInterfacePointers($e); - } - $addedorpc = 1; - } - - if ($x->{BASE}) { - my $base = get_interface($odl, $x->{BASE}); - - foreach my $fn (reverse @{$base->{DATA}}) { - next unless ($fn->{TYPE} eq "FUNCTION"); - unshift (@{$x->{DATA}}, $fn); - push (@{$x->{INHERITED_FUNCTIONS}}, $fn->{NAME}); - } - } - } - - unshift (@$odl, { - TYPE => "IMPORT", - PATHS => [ "\"orpc.idl\"" ], - FILE => undef, - LINE => undef - }) if ($addedorpc); - - return $odl; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 0ffa321782..8fa37ca300 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -12,7 +12,7 @@ use Exporter; use strict; use Parse::Pidl qw(fatal warning); -use Parse::Pidl::Typelist qw(hasType getType mapType scalar_is_reference); +use Parse::Pidl::Typelist qw(hasType getType mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::Samba4 qw(DeclLong); diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 52e384814d..aa4f3dd1ce 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -8,7 +8,7 @@ package Parse::Pidl::Samba3::ServerNDR; use strict; use Parse::Pidl qw(warning fatal); -use Parse::Pidl::Typelist qw(mapType scalar_is_reference); +use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(ParseExpr has_property is_constant); use Parse::Pidl::NDR qw(GetNextLevel); use Parse::Pidl::Samba4 qw(DeclLong); @@ -35,7 +35,7 @@ sub DeclLevel($$) if (has_property($e, "charset")) { $ret.="const char"; } else { - $ret.=mapType($e->{TYPE}); + $ret.=mapTypeName($e->{TYPE}); } my $numstar = $e->{ORIGINAL}->{POINTERS}; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index 4ef2daa591..f0c6ae38e8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -10,7 +10,7 @@ require Exporter; @EXPORT = qw(is_intree choose_header DeclLong); use Parse::Pidl::Util qw(has_property is_constant); -use Parse::Pidl::Typelist qw(mapType scalar_is_reference); +use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use strict; use vars qw($VERSION); @@ -38,12 +38,12 @@ sub DeclLong($) my $ret = ""; if (has_property($element, "represent_as")) { - $ret.=mapType($element->{PROPERTIES}->{represent_as})." "; + $ret.=mapTypeName($element->{PROPERTIES}->{represent_as})." "; } else { if (has_property($element, "charset")) { $ret.="const char"; } else { - $ret.=mapType($element->{TYPE}); + $ret.=mapTypeName($element->{TYPE}); } $ret.=" "; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm deleted file mode 100644 index 85dab37246..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Header.pm +++ /dev/null @@ -1,142 +0,0 @@ -# COM Header generation -# (C) 2005 Jelmer Vernooij - -package Parse::Pidl::Samba4::COM::Header; - -use Parse::Pidl::Typelist qw(mapType); -use Parse::Pidl::Util qw(has_property is_constant); - -use vars qw($VERSION); -$VERSION = '0.01'; - -use strict; - -sub GetArgumentProtoList($) -{ - my $f = shift; - my $res = ""; - - foreach my $a (@{$f->{ELEMENTS}}) { - - $res .= ", " . mapType($a->{TYPE}) . " "; - - my $l = $a->{POINTERS}; - $l-- if (Parse::Pidl::Typelist::scalar_is_reference($a->{TYPE})); - foreach my $i (1..$l) { - $res .= "*"; - } - - if (defined $a->{ARRAY_LEN}[0] && !is_constant($a->{ARRAY_LEN}[0]) && - !$a->{POINTERS}) { - $res .= "*"; - } - $res .= $a->{NAME}; - if (defined $a->{ARRAY_LEN}[0] && is_constant($a->{ARRAY_LEN}[0])) { - $res .= "[$a->{ARRAY_LEN}[0]]"; - } - } - - return $res; -} - -sub GetArgumentList($) -{ - my $f = shift; - my $res = ""; - - foreach (@{$f->{ELEMENTS}}) { $res .= ", $_->{NAME}"; } - - return $res; -} - -##################################################################### -# generate vtable structure for COM interface -sub HeaderVTable($) -{ - my $interface = shift; - my $res; - $res .= "#define " . uc($interface->{NAME}) . "_METHODS \\\n"; - if (defined($interface->{BASE})) { - $res .= "\t" . uc($interface->{BASE} . "_METHODS") . "\\\n"; - } - - my $data = $interface->{DATA}; - foreach my $d (@{$data}) { - $res .= "\t" . mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION"); - } - $res .= "\n"; - $res .= "struct $interface->{NAME}_vtable {\n"; - $res .= "\tstruct GUID iid;\n"; - $res .= "\t" . uc($interface->{NAME}) . "_METHODS\n"; - $res .= "};\n\n"; - - return $res; -} - -sub ParseInterface($) -{ - my $if = shift; - my $res; - - $res .="\n\n/* $if->{NAME} */\n"; - - $res .="#define COM_" . uc($if->{NAME}) . "_UUID $if->{PROPERTIES}->{uuid}\n\n"; - - $res .="struct $if->{NAME}_vtable;\n\n"; - - $res .="struct $if->{NAME} { - struct com_context *ctx; - struct $if->{NAME}_vtable *vtable; - void *object_data; -};\n\n"; - - $res.=HeaderVTable($if); - - foreach my $d (@{$if->{DATA}}) { - next if ($d->{TYPE} ne "FUNCTION"); - - $res .= "#define $if->{NAME}_$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . ") "; - - $res .= "((interface)->vtable->$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . "))"; - - $res .="\n"; - } - - return $res; -} - -sub ParseCoClass($) -{ - my $c = shift; - my $res = ""; - $res .= "#define CLSID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{uuid}\n"; - if (has_property($c, "progid")) { - $res .= "#define PROGID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{progid}\n"; - } - $res .= "\n"; - return $res; -} - -sub Parse($$) -{ - my ($idl,$ndr_header) = @_; - my $res = ""; - - $res .= "#include \"librpc/gen_ndr/orpc.h\"\n" . - "#include \"$ndr_header\"\n\n"; - - foreach (@{$idl}) - { - if ($_->{TYPE} eq "INTERFACE" && has_property($_, "object")) { - $res.=ParseInterface($_); - } - - if ($_->{TYPE} eq "COCLASS") { - $res.=ParseCoClass($_); - } - } - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm deleted file mode 100644 index e6366f0f3d..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Proxy.pm +++ /dev/null @@ -1,219 +0,0 @@ -################################################### -# DCOM parser for Samba -# Basically the glue between COM and DCE/RPC with NDR -# Copyright jelmer@samba.org 2003-2005 -# released under the GNU GPL - -package Parse::Pidl::Samba4::COM::Proxy; - -use Parse::Pidl::Samba4::COM::Header; -use Parse::Pidl::Util qw(has_property); - -use vars qw($VERSION); -$VERSION = '0.01'; - -use strict; - -my($res); - -sub ParseVTable($$) -{ - my $interface = shift; - my $name = shift; - - # Generate the vtable - $res .="\tstruct $interface->{NAME}_vtable $name = {"; - - if (defined($interface->{BASE})) { - $res .= "\n\t\t{},"; - } - - my $data = $interface->{DATA}; - - foreach my $d (@{$data}) { - if ($d->{TYPE} eq "FUNCTION") { - $res .= "\n\t\tdcom_proxy_$interface->{NAME}_$d->{NAME}"; - $res .= ","; - } - } - - $res .= "\n\t};\n\n"; -} - -sub ParseRegFunc($) -{ - my $interface = shift; - - $res .= "static NTSTATUS dcom_proxy_$interface->{NAME}_init(void) -{ - struct GUID base_iid; - struct $interface->{NAME}_vtable *proxy_vtable = talloc(talloc_autofree_context(), struct $interface->{NAME}_vtable); -"; - - if (defined($interface->{BASE})) { - $res.= " - const void *base_vtable; - - base_iid = dcerpc_table_$interface->{BASE}.uuid; - - base_vtable = dcom_proxy_vtable_by_iid(&base_iid); - if (base_vtable == NULL) { - DEBUG(0, (\"No proxy registered for base interface '$interface->{BASE}'\\n\")); - return NT_STATUS_FOOBAR; - } - - memcpy(&proxy_vtable, base_vtable, sizeof(struct $interface->{BASE}_vtable)); - -"; - } - foreach my $x (@{$interface->{DATA}}) { - next unless ($x->{TYPE} eq "FUNCTION"); - - $res .= "\tproxy_vtable.$x->{NAME} = dcom_proxy_$interface->{NAME}_$x->{NAME};\n"; - } - - $res.= " - proxy_vtable.iid = dcerpc_table_$interface->{NAME}.uuid; - - return dcom_register_proxy(&proxy_vtable); -}\n\n"; -} - -##################################################################### -# parse a function -sub ParseFunction($$) -{ - my $interface = shift; - my $fn = shift; - my $name = $fn->{NAME}; - my $uname = uc $name; - - $res.=" -static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . Parse::Pidl::Samba4::COM::Header::GetArgumentProtoList($fn) . ") -{ - struct dcerpc_pipe *p; - NTSTATUS status = dcom_get_pipe(d, &p); - struct $name r; - struct rpc_request *req; - - if (NT_STATUS_IS_ERR(status)) { - return status; - } - - ZERO_STRUCT(r.in.ORPCthis); - r.in.ORPCthis.version.MajorVersion = COM_MAJOR_VERSION; - r.in.ORPCthis.version.MinorVersion = COM_MINOR_VERSION; -"; - - # Put arguments into r - foreach my $a (@{$fn->{ELEMENTS}}) { - next unless (has_property($a, "in")); - if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) { - $res .="\tNDR_CHECK(dcom_OBJREF_from_IUnknown(&r.in.$a->{NAME}.obj, $a->{NAME}));\n"; - } else { - $res .= "\tr.in.$a->{NAME} = $a->{NAME};\n"; - } - } - - $res .=" - if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) { - NDR_PRINT_IN_DEBUG($name, &r); - } - - status = dcerpc_ndr_request(p, &d->ipid, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, &r); - - if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) { - NDR_PRINT_OUT_DEBUG($name, r); - } - -"; - - # Put r info back into arguments - foreach my $a (@{$fn->{ELEMENTS}}) { - next unless (has_property($a, "out")); - - if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) { - $res .="\tNDR_CHECK(dcom_IUnknown_from_OBJREF(d->ctx, &$a->{NAME}, r.out.$a->{NAME}.obj));\n"; - } else { - $res .= "\t*$a->{NAME} = r.out.$a->{NAME};\n"; - } - - } - - if ($fn->{RETURN_TYPE} eq "NTSTATUS") { - $res .= "\tif (NT_STATUS_IS_OK(status)) status = r.out.result;\n"; - } - - $res .= - " - return r.out.result; -}\n\n"; -} - -##################################################################### -# parse the interface definitions -sub ParseInterface($) -{ - my($interface) = shift; - my($data) = $interface->{DATA}; - $res = "/* DCOM proxy for $interface->{NAME} generated by pidl */\n\n"; - foreach my $d (@{$data}) { - ($d->{TYPE} eq "FUNCTION") && - ParseFunction($interface, $d); - } - - ParseRegFunc($interface); -} - -sub RegistrationFunction($$) -{ - my $idl = shift; - my $basename = shift; - - my $res = "\n\nNTSTATUS dcom_$basename\_init(void)\n"; - $res .= "{\n"; - $res .="\tNTSTATUS status = NT_STATUS_OK;\n"; - foreach my $interface (@{$idl}) { - next if $interface->{TYPE} ne "INTERFACE"; - next if not has_property($interface, "object"); - - my $data = $interface->{DATA}; - my $count = 0; - foreach my $d (@{$data}) { - if ($d->{TYPE} eq "FUNCTION") { $count++; } - } - - next if ($count == 0); - - $res .= "\tstatus = dcom_$interface->{NAME}_init();\n"; - $res .= "\tif (NT_STATUS_IS_ERR(status)) {\n"; - $res .= "\t\treturn status;\n"; - $res .= "\t}\n\n"; - } - $res .= "\treturn status;\n"; - $res .= "}\n\n"; - - return $res; -} - -sub Parse($$) -{ - my ($pidl,$comh_filename) = @_; - my $res = ""; - - $res .= "#include \"includes.h\"\n" . - "#include \"lib/com/dcom/dcom.h\"\n" . - "#include \"$comh_filename\"\n"; - - foreach (@{$pidl}) { - next if ($_->{TYPE} ne "INTERFACE"); - next if has_property($_, "local"); - next unless has_property($_, "object"); - - $res .= ParseInterface($_); - } - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm b/source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm deleted file mode 100644 index 150acbfde9..0000000000 --- a/source4/pidl/lib/Parse/Pidl/Samba4/COM/Stub.pm +++ /dev/null @@ -1,327 +0,0 @@ -################################################### -# DCOM stub boilerplate generator -# Copyright jelmer@samba.org 2004-2005 -# Copyright tridge@samba.org 2003 -# Copyright metze@samba.org 2004 -# released under the GNU GPL - -package Parse::Pidl::Samba4::COM::Stub; - -use Parse::Pidl::Util qw(has_property); -use strict; - -use vars qw($VERSION); -$VERSION = '0.01'; - -my($res); - -sub pidl($) -{ - $res .= shift; -} - -##################################################### -# generate the switch statement for function dispatch -sub gen_dispatch_switch($) -{ - my $data = shift; - - my $count = 0; - foreach my $d (@{$data}) { - next if ($d->{TYPE} ne "FUNCTION"); - - pidl "\tcase $count: {\n"; - if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") { - pidl "\t\tNTSTATUS result;\n"; - } - pidl "\t\tstruct $d->{NAME} *r2 = r;\n"; - pidl "\t\tif (DEBUGLEVEL > 10) {\n"; - pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_IN, r2);\n"; - pidl "\t\t}\n"; - if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") { - pidl "\t\tresult = vtable->$d->{NAME}(iface, mem_ctx, r2);\n"; - } else { - pidl "\t\tvtable->$d->{NAME}(iface, mem_ctx, r2);\n"; - } - pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; - pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} will reply async\\n\"));\n"; - pidl "\t\t}\n"; - pidl "\t\tbreak;\n\t}\n"; - $count++; - } -} - -##################################################### -# generate the switch statement for function reply -sub gen_reply_switch($) -{ - my $data = shift; - - my $count = 0; - foreach my $d (@{$data}) { - next if ($d->{TYPE} ne "FUNCTION"); - - pidl "\tcase $count: {\n"; - pidl "\t\tstruct $d->{NAME} *r2 = r;\n"; - pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n"; - pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} replied async\\n\"));\n"; - pidl "\t\t}\n"; - pidl "\t\tif (DEBUGLEVEL > 10 && dce_call->fault_code == 0) {\n"; - pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n"; - pidl "\t\t}\n"; - pidl "\t\tif (dce_call->fault_code != 0) {\n"; - pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $d->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n"; - pidl "\t\t}\n"; - pidl "\t\tbreak;\n\t}\n"; - $count++; - } -} - -##################################################################### -# produce boilerplate code for a interface -sub Boilerplate_Iface($) -{ - my($interface) = shift; - my($data) = $interface->{DATA}; - my $name = $interface->{NAME}; - my $uname = uc $name; - my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}); - my $if_version = $interface->{PROPERTIES}->{version}; - - pidl " -static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface) -{ -#ifdef DCESRV_INTERFACE_$uname\_BIND - return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface); -#else - return NT_STATUS_OK; -#endif -} - -static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface) -{ -#ifdef DCESRV_INTERFACE_$uname\_UNBIND - DCESRV_INTERFACE_$uname\_UNBIND(context, iface); -#else - return; -#endif -} - -static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r) -{ - NTSTATUS status; - uint16_t opnum = dce_call->pkt.u.request.opnum; - - dce_call->fault_code = 0; - - if (opnum >= dcerpc_table_$name.num_calls) { - dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; - return NT_STATUS_NET_WRITE_FAULT; - } - - *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size); - NT_STATUS_HAVE_NO_MEMORY(*r); - - /* unravel the NDR for the packet */ - status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); - if (!NT_STATUS_IS_OK(status)) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, - &dce_call->pkt.u.request.stub_and_verifier); - dce_call->fault_code = DCERPC_FAULT_NDR; - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) -{ - uint16_t opnum = dce_call->pkt.u.request.opnum; - struct GUID ipid = dce_call->pkt.u.request.object.object; - struct dcom_interface_p *iface = dcom_get_local_iface_p(&ipid); - const struct dcom_$name\_vtable *vtable = iface->vtable; - - switch (opnum) { -"; - gen_dispatch_switch($data); - -pidl " - default: - dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; - break; - } - - if (dce_call->fault_code != 0) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, - &dce_call->pkt.u.request.stub_and_verifier); - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r) -{ - uint16_t opnum = dce_call->pkt.u.request.opnum; - - switch (opnum) { -"; - gen_reply_switch($data); - -pidl " - default: - dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; - break; - } - - if (dce_call->fault_code != 0) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, - &dce_call->pkt.u.request.stub_and_verifier); - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r) -{ - NTSTATUS status; - uint16_t opnum = dce_call->pkt.u.request.opnum; - - status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); - if (!NT_STATUS_IS_OK(status)) { - dce_call->fault_code = DCERPC_FAULT_NDR; - return NT_STATUS_NET_WRITE_FAULT; - } - - return NT_STATUS_OK; -} - -static const struct dcesrv_interface $name\_interface = { - .name = \"$name\", - .uuid = $uuid, - .if_version = $if_version, - .bind = $name\__op_bind, - .unbind = $name\__op_unbind, - .ndr_pull = $name\__op_ndr_pull, - .dispatch = $name\__op_dispatch, - .reply = $name\__op_reply, - .ndr_push = $name\__op_ndr_push -}; - -"; -} - -##################################################################### -# produce boilerplate code for an endpoint server -sub Boilerplate_Ep_Server($) -{ - my($interface) = shift; - my $name = $interface->{NAME}; - my $uname = uc $name; - - pidl " -static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server) -{ - int i; - - for (i=0;icount;i++) { - NTSTATUS ret; - const char *name = dcerpc_table_$name.endpoints->names[i]; - - ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL); - if (!NT_STATUS_IS_OK(ret)) { - DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name)); - return ret; - } - } - - return NT_STATUS_OK; -} - -static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version) -{ - if (dcerpc_table_$name.if_version == if_version && - strcmp(dcerpc_table_$name.uuid, uuid)==0) { - memcpy(iface,&dcerpc_table_$name, sizeof(*iface)); - return True; - } - - return False; -} - -static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) -{ - if (strcmp(dcerpc_table_$name.name, name)==0) { - memcpy(iface,&dcerpc_table_$name, sizeof(*iface)); - return True; - } - - return False; -} - -NTSTATUS dcerpc_server_$name\_init(void) -{ - NTSTATUS ret; - struct dcesrv_endpoint_server ep_server; - - /* fill in our name */ - ep_server.name = \"$name\"; - - /* fill in all the operations */ - ep_server.init_server = $name\__op_init_server; - - ep_server.interface_by_uuid = $name\__op_interface_by_uuid; - ep_server.interface_by_name = $name\__op_interface_by_name; - - /* register ourselves with the DCERPC subsystem. */ - ret = dcerpc_register_ep_server(&ep_server); - - if (!NT_STATUS_IS_OK(ret)) { - DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\")); - return ret; - } - - return ret; -} - -"; -} - -##################################################################### -# dcom interface stub from a parsed IDL structure -sub ParseInterface($) -{ - my($interface) = shift; - - return "" if has_property($interface, "local"); - - my($data) = $interface->{DATA}; - my $count = 0; - - $res = ""; - - if (!defined $interface->{PROPERTIES}->{uuid}) { - return $res; - } - - if (!defined $interface->{PROPERTIES}->{version}) { - $interface->{PROPERTIES}->{version} = "0.0"; - } - - foreach my $d (@{$data}) { - if ($d->{TYPE} eq "FUNCTION") { $count++; } - } - - if ($count == 0) { - return $res; - } - - $res = "/* dcom interface stub generated by pidl */\n\n"; - Boilerplate_Iface($interface); - Boilerplate_Ep_Server($interface); - - return $res; -} - -1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 1ce22d5180..59dc5f001d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -380,7 +380,7 @@ sub EjsBitmapPull($$) my $name = shift; my $d = shift; my $type_fn = $d->{BASE_TYPE}; - my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE}); + my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)"); pidl "{"; indent; @@ -648,7 +648,7 @@ sub EjsBitmapPush($$) my $name = shift; my $d = shift; my $type_fn = $d->{BASE_TYPE}; - my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE}); + my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); # put the bitmap elements in the constants array foreach my $e (@{$d->{ELEMENTS}}) { if ($e =~ /^(\w*)\s*(.*)\s*$/) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index fbc00d7c13..7e52dbc2ee 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Samba4::Header; use strict; -use Parse::Pidl::Typelist qw(mapType); +use Parse::Pidl::Typelist qw(mapTypeName); use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::Samba4 qw(is_intree); @@ -55,7 +55,7 @@ sub HeaderElement($) pidl tabs(); if (has_property($element, "represent_as")) { - pidl mapType($element->{PROPERTIES}->{represent_as})." "; + pidl mapTypeName($element->{PROPERTIES}->{represent_as})." "; } else { HeaderType($element, $element->{TYPE}, ""); pidl " "; @@ -209,7 +209,7 @@ sub HeaderType($$$) if (has_property($e, "charset")) { pidl "const char"; } else { - pidl mapType($e->{TYPE}); + pidl mapTypeName($e->{TYPE}); } } @@ -303,7 +303,7 @@ sub HeaderFunction($) HeaderFunctionInOut($fn, "out"); HeaderFunctionInOut($fn, "inout"); if ($fn->{RETURN_TYPE} ne "void") { - pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n"; + pidl tabs().mapTypeName($fn->{RETURN_TYPE}) . " result;\n"; } $tab_depth--; pidl tabs()."} out;\n\n"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 15618bb534..46898e6ad8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -15,7 +15,7 @@ require Exporter; NeededElement NeededType); use strict; -use Parse::Pidl::Typelist qw(hasType getType mapType); +use Parse::Pidl::Typelist qw(hasType getType mapTypeName); use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::Samba4 qw(is_intree choose_header); @@ -636,7 +636,7 @@ sub ParseElementPushLevel # Allow speedups for arrays of scalar types if (is_charset_array($e,$l)) { - pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; + pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; return; } elsif (has_fast_array($e,$l)) { pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; @@ -707,7 +707,7 @@ sub ParseElementPush($$$$$) pidl "{"; indent; my $transmit_name = "_transmit_$e->{NAME}"; - pidl mapType($e->{TYPE}) ." $transmit_name;"; + pidl mapTypeName($e->{TYPE}) ." $transmit_name;"; pidl "NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}($var_name, " . get_pointer_to($transmit_name) . "));"; $var_name = $transmit_name; } @@ -1014,7 +1014,7 @@ sub ParseElementPullLevel if ($l->{IS_ZERO_TERMINATED}) { CheckStringTerminator($ndr, $e, $l, $length); } - pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; + pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; return; } elsif (has_fast_array($e, $l)) { if ($l->{IS_ZERO_TERMINATED}) { @@ -1116,7 +1116,7 @@ sub ParseElementPull($$$$$) $represent_name = $var_name; $transmit_name = "_transmit_$e->{NAME}"; $var_name = $transmit_name; - pidl mapType($e->{TYPE})." $var_name;"; + pidl mapTypeName($e->{TYPE})." $var_name;"; } $var_name = append_prefix($e, $var_name); @@ -1294,7 +1294,7 @@ sub ParseEnumPull($$) { my($enum,$name) = @_; my($type_fn) = $enum->{BASE_TYPE}; - my($type_v_decl) = mapType($type_fn); + my($type_v_decl) = mapTypeName($type_fn); pidl "$type_v_decl v;"; start_flags($enum); @@ -1369,7 +1369,7 @@ sub ParseBitmapPull($$) { my($bitmap,$name) = @_; my $type_fn = $bitmap->{BASE_TYPE}; - my($type_decl) = mapType($bitmap->{BASE_TYPE}); + my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); pidl "$type_decl v;"; start_flags($bitmap); @@ -1384,7 +1384,7 @@ sub ParseBitmapPull($$) sub ParseBitmapPrintElement($$$) { my($e,$bitmap,$name) = @_; - my($type_decl) = mapType($bitmap->{BASE_TYPE}); + my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); my($type_fn) = $bitmap->{BASE_TYPE}; my($flag); @@ -1402,7 +1402,7 @@ sub ParseBitmapPrintElement($$$) sub ParseBitmapPrint($$) { my($bitmap,$name) = @_; - my($type_decl) = mapType($bitmap->{TYPE}); + my($type_decl) = mapTypeName($bitmap->{TYPE}); my($type_fn) = $bitmap->{BASE_TYPE}; start_flags($bitmap); @@ -1421,7 +1421,7 @@ sub ParseBitmapPrint($$) sub DeclBitmap($$$) { my ($e,$t,$name) = @_; - return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e)) . + return mapTypeName(Parse::Pidl::Typelist::bitmap_type_fn($e)) . ($t eq "pull"?" *":" ") . "r"; } @@ -1771,7 +1771,7 @@ sub ParseUnionPull($$) if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) { $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)->{DATA}); } - pidl mapType($switch_type) . " _level;"; + pidl mapTypeName($switch_type) . " _level;"; } my %double_cases = (); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm index 57ff007d1b..d541f318ee 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -8,7 +8,7 @@ package Parse::Pidl::Samba4::SWIG; use vars qw($VERSION); use Parse::Pidl::Samba4 qw(DeclLong); -use Parse::Pidl::Typelist qw(mapType); +use Parse::Pidl::Typelist qw(mapTypeName); use Parse::Pidl::Util qw(has_property); $VERSION = '0.01'; @@ -77,7 +77,7 @@ sub ParseInterface($$) $name =~ s/^$if->{NAME}_//g; $name =~ s/^$basename\_//g; $args .= "TALLOC_CTX *mem_ctx = NULL"; - pidl mapType($fn->{RETURN_TYPE}) . " $name($args)"; + pidl mapTypeName($fn->{RETURN_TYPE}) . " $name($args)"; pidl "{"; indent; pidl "struct $fn->{NAME} r;"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index cde5da2b6b..f1f23bf84b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -1,6 +1,6 @@ ################################################### # Trivial Parser Generator -# Copyright jelmer@samba.org 2005 +# Copyright jelmer@samba.org 2005-2007 # released under the GNU GPL package Parse::Pidl::Samba4::TDR; @@ -8,13 +8,17 @@ use Parse::Pidl qw(fatal); use Parse::Pidl::Util qw(has_property ParseExpr is_constant); use Parse::Pidl::Samba4 qw(is_intree choose_header); +use Exporter; +@ISA = qw(Exporter); +@EXPORT_OK = qw(ParserType $ret $ret_hdr); + use vars qw($VERSION); $VERSION = '0.01'; use strict; -my $ret; -my $ret_hdr; +our $ret; +our $ret_hdr; my $tabs = ""; sub indent() { $tabs.="\t"; } @@ -117,14 +121,14 @@ sub ParserElement($$$) sub ParserStruct($$$$) { - my ($e,$n,$t,$p) = @_; + my ($e,$t,$p) = @_; - fn_declare($p,,"NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", struct $n *v)"); + fn_declare($p,"NTSTATUS tdr_$t\_$e->{NAME} (struct tdr_$t *tdr".typearg($t).", struct $e->{NAME} *v)"); pidl "{"; indent; pidl "int i;" if (ContainsArray($e)); if ($t eq "print") { - pidl "tdr->print(tdr, \"\%-25s: struct $n\", name);"; + pidl "tdr->print(tdr, \"\%-25s: struct $e->{NAME}\", name);"; pidl "tdr->level++;"; } @@ -141,16 +145,16 @@ sub ParserStruct($$$$) deindent; pidl "}"; } -sub ParserUnion($$$$) +sub ParserUnion($$$) { - my ($e,$n,$t,$p) = @_; + my ($e,$t,$p) = @_; - fn_declare($p,"NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".typearg($t).", int level, union $n *v)"); + fn_declare($p,"NTSTATUS tdr_$t\_$e->{NAME}(struct tdr_$t *tdr".typearg($t).", int level, union $e->{NAME} *v)"); pidl "{"; indent; pidl "int i;" if (ContainsArray($e)); if ($t eq "print") { - pidl "tdr->print(tdr, \"\%-25s: union $n\", name);"; + pidl "tdr->print(tdr, \"\%-25s: union $e->{NAME}\", name);"; pidl "tdr->level++;"; } @@ -174,19 +178,19 @@ sub ParserUnion($$$$) deindent; pidl "}"; } -sub ParserBitmap($$$$) +sub ParserBitmap($$$) { - my ($e,$n,$t,$p) = @_; + my ($e,$t,$p) = @_; return if ($p); - pidl "#define tdr_$t\_$n tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e); + pidl "#define tdr_$t\_$e->{NAME} tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e); } -sub ParserEnum($$$$) +sub ParserEnum($$$) { - my ($e,$n,$t,$p) = @_; + my ($e,$t,$p) = @_; my $bt = ($e->{PROPERTIES}->{base_type} or "uint8"); - fn_declare($p, "NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".typearg($t).", enum $n *v)"); + fn_declare($p, "NTSTATUS tdr_$t\_$e->{NAME} (struct tdr_$t *tdr".typearg($t).", enum $e->{NAME} *v)"); pidl "{"; if ($t eq "pull") { pidl "\t$bt\_t r;"; @@ -201,17 +205,27 @@ sub ParserEnum($$$$) pidl "}"; } -sub ParserTypedef($$) +sub ParserTypedef($$$) +{ + my ($e,$t,$p) = @_; + + ParserType($e->{DATA},$t); +} + +sub ParserType($$) { my ($e,$t) = @_; return if (has_property($e, "no$t")); - $e->{PROPERTIES} = $e->{DATA}->{PROPERTIES}; - - { STRUCT => \&ParserStruct, UNION => \&ParserUnion, - ENUM => \&ParserEnum, BITMAP => \&ParserBitmap - }->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $t, has_property($e, "public")); + my $handlers = { + STRUCT => \&ParserStruct, UNION => \&ParserUnion, + ENUM => \&ParserEnum, BITMAP => \&ParserBitmap, + TYPEDEF => \&ParserTypedef + }; + + $handlers->{$e->{TYPE}}->($e, $t, has_property($e, "public")) + if (defined($handlers->{$e->{TYPE}})); pidl ""; } @@ -224,10 +238,9 @@ sub ParserInterface($) pidl_hdr "#define __TDR_$x->{NAME}_HEADER__"; foreach (@{$x->{DATA}}) { - next if ($_->{TYPE} ne "TYPEDEF"); - ParserTypedef($_, "pull"); - ParserTypedef($_, "push"); - ParserTypedef($_, "print"); + ParserType($_, "pull"); + ParserType($_, "push"); + ParserType($_, "print"); } pidl_hdr "#endif /* __TDR_$x->{NAME}_HEADER__ */"; diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 7be7e5a5c3..a098f1ab05 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -7,14 +7,14 @@ package Parse::Pidl::Typelist; require Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(hasType getType mapType scalar_is_reference expandAlias); +@EXPORT_OK = qw(hasType getType mapTypeName scalar_is_reference expandAlias); use vars qw($VERSION); $VERSION = '0.01'; use Parse::Pidl::Util qw(has_property); use strict; -my %typedefs = (); +my %types = (); my @reference_scalars = ( "string", "string_array", "nbt_string", @@ -89,14 +89,14 @@ sub mapScalarType($) sub addType($) { my $t = shift; - $typedefs{$t->{NAME}} = $t; + $types{$t->{NAME}} = $t; } sub getType($) { my $t = shift; return undef if not hasType($t); - return $typedefs{$t}; + return $types{$t}; } sub typeIs($$) @@ -110,7 +110,7 @@ sub typeIs($$) sub hasType($) { my $t = shift; - return 1 if defined($typedefs{$t}); + return 1 if defined($types{$t}); return 0; } @@ -178,7 +178,22 @@ sub bitmap_type_fn($) return "uint32"; } -sub mapType($) +sub mapType($$) +{ + sub mapType($$); + my ($t, $n) = @_; + + return mapType($t->{DATA}, $n) if ($t->{TYPE} eq "TYPEDEF"); + return mapType($t->{DATA}, $n) if ($t->{TYPE} eq "DECLARE"); + return mapScalarType($n) if ($t->{TYPE} eq "SCALAR"); + return "enum $n" if ($t->{TYPE} eq "ENUM"); + return "struct $n" if ($t->{TYPE} eq "STRUCT"); + return "union $n" if ($t->{TYPE} eq "UNION"); + return mapScalarType(bitmap_type_fn($t)) if ($t->{TYPE} eq "BITMAP"); + die("Unknown type $t->{TYPE}"); +} + +sub mapTypeName($) { my $t = shift; return "void" unless defined($t); @@ -189,17 +204,8 @@ sub mapType($) # Best guess return "struct $t"; } - return mapScalarType($t) if ($dt->{DATA}->{TYPE} eq "SCALAR"); - return "enum $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "ENUM"); - return "struct $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "STRUCT"); - return "struct $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "INTERFACE"); - return "union $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "UNION"); - - if ($dt->{DATA}->{TYPE} eq "BITMAP") { - return mapScalarType(bitmap_type_fn($dt->{DATA})); - } - die("Unknown type $dt->{DATA}->{TYPE}"); + return mapType($dt, $dt->{NAME}); } sub LoadIdl($) @@ -209,17 +215,14 @@ sub LoadIdl($) foreach my $x (@{$idl}) { next if $x->{TYPE} ne "INTERFACE"; - # DCOM interfaces can be types as well - addType({ - NAME => $x->{NAME}, - TYPE => "TYPEDEF", - DATA => $x - }) if (has_property($x, "object")); - foreach my $y (@{$x->{DATA}}) { addType($y) if ( $y->{TYPE} eq "TYPEDEF" - or $y->{TYPE} eq "DECLARE"); + or $y->{TYPE} eq "DECLARE" + or $y->{TYPE} eq "UNION" + or $y->{TYPE} eq "STRUCT" + or $y->{TYPE} eq "ENUM" + or $y->{TYPE} eq "BITMAP"); } } } -- cgit From 127ccc27d45f4da84a6687562f50d733a011adfe Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 18 Feb 2007 23:48:16 +0000 Subject: r21437: Cherrypick typelib tests. (This used to be commit 9ba814d033412150d383d3687f02775d4efc618e) --- source4/pidl/lib/Parse/Pidl/Typelist.pm | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index a098f1ab05..55f8390f65 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -7,7 +7,10 @@ package Parse::Pidl::Typelist; require Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(hasType getType mapTypeName scalar_is_reference expandAlias); +@EXPORT_OK = qw(hasType getType mapTypeName scalar_is_reference expandAlias + mapScalarType addType typeIs is_scalar enum_type_fn + bitmap_type_fn mapType +); use vars qw($VERSION); $VERSION = '0.01'; -- cgit From 5340489807985b3bb4c10eacfa701d643ee7a36c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 18 Feb 2007 23:57:26 +0000 Subject: r21440: Support different variables in environments. (This used to be commit 1702a663ba4ce6f5803e265a969f2be564fce1e3) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 46898e6ad8..dfd7296cdd 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -216,16 +216,16 @@ sub end_flags($) } } -sub GenerateStructEnv($) +sub GenerateStructEnv($$) { - my $x = shift; + my ($x, $v) = @_; my %env; foreach my $e (@{$x->{ELEMENTS}}) { - $env{$e->{NAME}} = "r->$e->{NAME}"; + $env{$e->{NAME}} = "$v->$e->{NAME}"; } - $env{"this"} = "r"; + $env{"this"} = $v; return \%env; } @@ -1198,7 +1198,7 @@ sub ParseStructPush($$) return unless defined($struct->{ELEMENTS}); - my $env = GenerateStructEnv($struct); + my $env = GenerateStructEnv($struct, "r"); EnvSubstituteValue($env, $struct); @@ -1440,7 +1440,7 @@ sub ParseStructPrint($$) return unless defined $struct->{ELEMENTS}; - my $env = GenerateStructEnv($struct); + my $env = GenerateStructEnv($struct, "r"); EnvSubstituteValue($env, $struct); @@ -1521,7 +1521,7 @@ sub ParseStructPull($$) return unless defined $struct->{ELEMENTS}; - my $env = GenerateStructEnv($struct); + my $env = GenerateStructEnv($struct, "r"); # declare any internal pointers we need foreach my $e (@{$struct->{ELEMENTS}}) { -- cgit From cc1e315604d702451dbd602bb8b2daf10c81c4e8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 19 Feb 2007 00:48:05 +0000 Subject: r21442: Allow more flexible data structure names. (This used to be commit 5b091c5d75f8580f10bc6a61a0e2203abec98784) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 217 ++++++++++++----------- 1 file changed, 111 insertions(+), 106 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index dfd7296cdd..7a9ea21440 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1192,13 +1192,13 @@ sub ParsePtrPull($$$$) ##################################################################### # parse a struct -sub ParseStructPush($$) +sub ParseStructPush($$$) { - my($struct,$name) = @_; + my ($struct, $name, $varname) = @_; return unless defined($struct->{ELEMENTS}); - my $env = GenerateStructEnv($struct, "r"); + my $env = GenerateStructEnv($struct, $varname); EnvSubstituteValue($env, $struct); @@ -1225,9 +1225,9 @@ sub ParseStructPush($$) if ($e->{LEVELS}[0]->{IS_ZERO_TERMINATED}) { if (has_property($e, "charset")) { - $size = "ndr_charset_length(r->$e->{NAME}, CH_$e->{PROPERTIES}->{charset})"; + $size = "ndr_charset_length($varname->$e->{NAME}, CH_$e->{PROPERTIES}->{charset})"; } else { - $size = "ndr_string_length(r->$e->{NAME}, sizeof(*r->$e->{NAME}))"; + $size = "ndr_string_length($varname->$e->{NAME}, sizeof(*$varname->$e->{NAME}))"; } } else { $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL}); @@ -1235,7 +1235,7 @@ sub ParseStructPush($$) pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; } else { - pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));"; + pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, $varname->$e->{NAME})));"; } } @@ -1247,7 +1247,7 @@ sub ParseStructPush($$) if (defined($struct->{PROPERTIES}{relative_base})) { # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));"; + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; } foreach my $e (@{$struct->{ELEMENTS}}) { @@ -1262,7 +1262,7 @@ sub ParseStructPush($$) if (defined($struct->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));"; + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"; } foreach my $e (@{$struct->{ELEMENTS}}) { ParseElementPush($e, "ndr", $env, 0, 1); @@ -1278,44 +1278,44 @@ sub ParseStructPush($$) ##################################################################### # generate a push function for an enum -sub ParseEnumPush($$) +sub ParseEnumPush($$$) { - my($enum,$name) = @_; + my($enum,$name,$varname) = @_; my($type_fn) = $enum->{BASE_TYPE}; start_flags($enum); - pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; + pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, $varname));"; end_flags($enum); } ##################################################################### # generate a pull function for an enum -sub ParseEnumPull($$) +sub ParseEnumPull($$$) { - my($enum,$name) = @_; + my($enum,$name,$varname) = @_; my($type_fn) = $enum->{BASE_TYPE}; my($type_v_decl) = mapTypeName($type_fn); pidl "$type_v_decl v;"; start_flags($enum); pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; - pidl "*r = v;"; + pidl "*$varname = v;"; end_flags($enum); } ##################################################################### # generate a print function for an enum -sub ParseEnumPrint($$) +sub ParseEnumPrint($$$) { - my($enum,$name) = @_; + my($enum,$name,$varname) = @_; pidl "const char *val = NULL;"; pidl ""; start_flags($enum); - pidl "switch (r) {"; + pidl "switch ($varname) {"; indent; my $els = \@{$enum->{ELEMENTS}}; foreach my $i (0 .. $#{$els}) { @@ -1330,16 +1330,16 @@ sub ParseEnumPrint($$) deindent; pidl "}"; - pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);"; + pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, $varname);"; end_flags($enum); } -sub DeclEnum($$$) +sub DeclEnum($$$$) { - my ($e,$t,$name) = @_; + my ($e,$t,$name,$varname) = @_; return "enum $name " . - ($t eq "pull"?"*":"") . "r"; + ($t eq "pull"?"*":"") . $varname; } $typefamily{ENUM} = { @@ -1351,39 +1351,39 @@ $typefamily{ENUM} = { ##################################################################### # generate a push function for a bitmap -sub ParseBitmapPush($$) +sub ParseBitmapPush($$$) { - my($bitmap,$name) = @_; + my($bitmap,$name,$varname) = @_; my($type_fn) = $bitmap->{BASE_TYPE}; start_flags($bitmap); - pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));"; + pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, $varname));"; end_flags($bitmap); } ##################################################################### # generate a pull function for an bitmap -sub ParseBitmapPull($$) +sub ParseBitmapPull($$$) { - my($bitmap,$name) = @_; + my($bitmap,$name,$varname) = @_; my $type_fn = $bitmap->{BASE_TYPE}; my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); pidl "$type_decl v;"; start_flags($bitmap); pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; - pidl "*r = v;"; + pidl "*$varname = v;"; end_flags($bitmap); } ##################################################################### # generate a print function for an bitmap -sub ParseBitmapPrintElement($$$) +sub ParseBitmapPrintElement($$$$) { - my($e,$bitmap,$name) = @_; + my($e,$bitmap,$name,$varname) = @_; my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); my($type_fn) = $bitmap->{BASE_TYPE}; my($flag); @@ -1394,35 +1394,35 @@ sub ParseBitmapPrintElement($$$) die "Bitmap: \"$name\" invalid Flag: \"$e\""; } - pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);"; + pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, $varname);"; } ##################################################################### # generate a print function for an bitmap -sub ParseBitmapPrint($$) +sub ParseBitmapPrint($$$) { - my($bitmap,$name) = @_; + my($bitmap,$name,$varname) = @_; my($type_decl) = mapTypeName($bitmap->{TYPE}); my($type_fn) = $bitmap->{BASE_TYPE}; start_flags($bitmap); - pidl "ndr_print_$type_fn(ndr, name, r);"; + pidl "ndr_print_$type_fn(ndr, name, $varname);"; pidl "ndr->depth++;"; foreach my $e (@{$bitmap->{ELEMENTS}}) { - ParseBitmapPrintElement($e, $bitmap, $name); + ParseBitmapPrintElement($e, $bitmap, $name, $varname); } pidl "ndr->depth--;"; end_flags($bitmap); } -sub DeclBitmap($$$) +sub DeclBitmap($$$$) { - my ($e,$t,$name) = @_; + my ($e,$t,$name,$varname) = @_; return mapTypeName(Parse::Pidl::Typelist::bitmap_type_fn($e)) . - ($t eq "pull"?" *":" ") . "r"; + ($t eq "pull"?" *":" ") . $varname; } $typefamily{BITMAP} = { @@ -1434,13 +1434,13 @@ $typefamily{BITMAP} = { ##################################################################### # generate a struct print function -sub ParseStructPrint($$) +sub ParseStructPrint($$$) { - my($struct,$name) = @_; + my($struct,$name,$varname) = @_; return unless defined $struct->{ELEMENTS}; - my $env = GenerateStructEnv($struct, "r"); + my $env = GenerateStructEnv($struct, $varname); EnvSubstituteValue($env, $struct); @@ -1452,7 +1452,8 @@ sub ParseStructPrint($$) pidl "ndr->depth++;"; - ParseElementPrint($_, "r->$_->{NAME}", $env) foreach (@{$struct->{ELEMENTS}}); + ParseElementPrint($_, $env->{$_->{NAME}}, $env) + foreach (@{$struct->{ELEMENTS}}); pidl "ndr->depth--;"; end_flags($struct); @@ -1515,13 +1516,13 @@ sub DeclareMemCtxVariables($) ##################################################################### # parse a struct - pull side -sub ParseStructPull($$) +sub ParseStructPull($$$) { - my($struct,$name) = @_; + my($struct,$name,$varname) = @_; return unless defined $struct->{ELEMENTS}; - my $env = GenerateStructEnv($struct, "r"); + my $env = GenerateStructEnv($struct, $varname); # declare any internal pointers we need foreach my $e (@{$struct->{ELEMENTS}}) { @@ -1539,7 +1540,7 @@ sub ParseStructPull($$) indent; if (defined $struct->{SURROUNDING_ELEMENT}) { - pidl "NDR_CHECK(ndr_pull_array_size(ndr, &r->$struct->{SURROUNDING_ELEMENT}->{NAME}));"; + pidl "NDR_CHECK(ndr_pull_array_size(ndr, &$varname->$struct->{SURROUNDING_ELEMENT}->{NAME}));"; } pidl "NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));"; @@ -1547,7 +1548,7 @@ sub ParseStructPull($$) if (defined($struct->{PROPERTIES}{relative_base})) { # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));"; + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; } foreach my $e (@{$struct->{ELEMENTS}}) { @@ -1563,7 +1564,7 @@ sub ParseStructPull($$) if (defined($struct->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));"; + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, $varname));"; } foreach my $e (@{$struct->{ELEMENTS}}) { ParseElementPull($e, "ndr", $env, 0, 1); @@ -1581,27 +1582,27 @@ sub ParseStructPull($$) ##################################################################### # calculate size of ndr struct -sub ParseStructNdrSize($$) +sub ParseStructNdrSize($$$) { - my ($t, $name) = @_; + my ($t, $name, $varname) = @_; my $sizevar; if (my $flags = has_property($t, "flag")) { pidl "flags |= $flags;"; } - pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$name);"; + pidl "return ndr_size_struct($varname, flags, (ndr_push_flags_fn_t)ndr_push_$name);"; } -sub DeclStruct($$$) +sub DeclStruct($$$$) { - my ($e,$t,$name) = @_; - return ($t ne "pull"?"const ":"") . "struct $name *r"; + my ($e,$t,$name,$varname) = @_; + return ($t ne "pull"?"const ":"") . "struct $name *$varname"; } -sub ArgsStructNdrSize($$) +sub ArgsStructNdrSize($$$) { - my ($d, $name) = @_; - return "const struct $name *r, int flags"; + my ($d, $name, $varname) = @_; + return "const struct $name *$varname, int flags"; } $typefamily{STRUCT} = { @@ -1615,23 +1616,23 @@ $typefamily{STRUCT} = { ##################################################################### # calculate size of ndr struct -sub ParseUnionNdrSize($$) +sub ParseUnionNdrSize($$$) { - my ($t, $name) = @_; + my ($t, $name, $varname) = @_; my $sizevar; if (my $flags = has_property($t, "flag")) { pidl "flags |= $flags;"; } - pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$name);"; + pidl "return ndr_size_union($varname, flags, level, (ndr_push_flags_fn_t)ndr_push_$name);"; } ##################################################################### # parse a union - push side -sub ParseUnionPush($$) +sub ParseUnionPush($$$) { - my ($e,$name) = @_; + my ($e,$name,$varname) = @_; my $have_default = 0; # save the old relative_base_offset @@ -1640,7 +1641,7 @@ sub ParseUnionPush($$) start_flags($e); - pidl "level = ndr_push_get_switch_value(ndr, r);"; + pidl "level = ndr_push_get_switch_value(ndr, $varname);"; pidl "if (ndr_flags & NDR_SCALARS) {"; indent; @@ -1663,10 +1664,10 @@ sub ParseUnionPush($$) pidl "NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));"; # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));"; + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; } DeclareArrayVariables($el); - ParseElementPush($el, "ndr", {$el->{NAME} => "r->$el->{NAME}"}, 1, 0); + ParseElementPush($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); deindent; } pidl "break;"; @@ -1685,7 +1686,7 @@ sub ParseUnionPush($$) if (defined($e->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));"; + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"; } pidl "switch (level) {"; indent; @@ -1693,7 +1694,7 @@ sub ParseUnionPush($$) pidl "$el->{CASE}:"; if ($el->{TYPE} ne "EMPTY") { indent; - ParseElementPush($el, "ndr", {$el->{NAME} => "r->$el->{NAME}"}, 0, 1); + ParseElementPush($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); deindent; } pidl "break;"; @@ -1715,9 +1716,9 @@ sub ParseUnionPush($$) ##################################################################### # print a union -sub ParseUnionPrint($$) +sub ParseUnionPrint($$$) { - my ($e,$name) = @_; + my ($e,$name,$varname) = @_; my $have_default = 0; pidl "int level;"; @@ -1727,7 +1728,7 @@ sub ParseUnionPrint($$) start_flags($e); - pidl "level = ndr_print_get_switch_value(ndr, r);"; + pidl "level = ndr_print_get_switch_value(ndr, $varname);"; pidl "ndr_print_union(ndr, name, level, \"$name\");"; @@ -1740,7 +1741,7 @@ sub ParseUnionPrint($$) pidl "$el->{CASE}:"; if ($el->{TYPE} ne "EMPTY") { indent; - ParseElementPrint($el, "r->$el->{NAME}", {}); + ParseElementPrint($el, "$varname->$el->{NAME}", {}); deindent; } pidl "break;"; @@ -1758,9 +1759,9 @@ sub ParseUnionPrint($$) ##################################################################### # parse a union - pull side -sub ParseUnionPull($$) +sub ParseUnionPull($$$) { - my ($e,$name) = @_; + my ($e,$name,$varname) = @_; my $have_default = 0; my $switch_type = $e->{SWITCH_TYPE}; @@ -1784,7 +1785,7 @@ sub ParseUnionPull($$) start_flags($e); - pidl "level = ndr_pull_get_switch_value(ndr, r);"; + pidl "level = ndr_pull_get_switch_value(ndr, $varname);"; pidl "if (ndr_flags & NDR_SCALARS) {"; indent; @@ -1812,9 +1813,9 @@ sub ParseUnionPull($$) pidl "NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));"; # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));"; + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; } - ParseElementPull($el, "ndr", {$el->{NAME} => "r->$el->{NAME}"}, 1, 0); + ParseElementPull($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); deindent; } pidl "break; }"; @@ -1833,7 +1834,7 @@ sub ParseUnionPull($$) if (defined($e->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));"; + pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, $varname));"; } pidl "switch (level) {"; indent; @@ -1841,7 +1842,7 @@ sub ParseUnionPull($$) pidl "$el->{CASE}:"; if ($el->{TYPE} ne "EMPTY") { indent; - ParseElementPull($el, "ndr", {$el->{NAME} => "r->$el->{NAME}"}, 0, 1); + ParseElementPull($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); deindent; } pidl "break;"; @@ -1864,10 +1865,10 @@ sub ParseUnionPull($$) pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); } -sub DeclUnion($$$) +sub DeclUnion($$$$) { - my ($e,$t,$name) = @_; - return ($t ne "pull"?"const ":"") . "union $name *r"; + my ($e,$t,$name,$varname) = @_; + return ($t ne "pull"?"const ":"") . "union $name *$varname"; } sub ArgsUnionNdrSize($$) @@ -1887,51 +1888,51 @@ $typefamily{UNION} = { ##################################################################### # parse a typedef - push side -sub ParseTypedefPush($$) +sub ParseTypedefPush($$$) { - my($e,$name) = @_; + my($e,$name,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $name); + $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $name, $varname); } ##################################################################### # parse a typedef - pull side -sub ParseTypedefPull($$) +sub ParseTypedefPull($$$) { - my($e,$name) = @_; + my($e,$name,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $name); + $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $name, $varname); } ##################################################################### # parse a typedef - print side -sub ParseTypedefPrint($$) +sub ParseTypedefPrint($$$) { - my($e,$name) = @_; + my($e,$name,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $name); + $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $name, $varname); } ##################################################################### ## calculate the size of a structure -sub ParseTypedefNdrSize($$) +sub ParseTypedefNdrSize($$$) { - my($t,$name) = @_; + my($t,$name,$varname) = @_; - $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t->{DATA}, $name); + $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t->{DATA}, $name, $varname); } -sub DeclTypedef($$$) +sub DeclTypedef($$$$) { - my ($e, $t, $name) = @_; + my ($e, $t, $name, $varname) = @_; - return $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e->{DATA}, $t, $name); + return $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e->{DATA}, $t, $name, $varname); } -sub ArgsTypedefNdrSize($$) +sub ArgsTypedefNdrSize($$$) { - my ($d, $name) = @_; - return $typefamily{$d->{DATA}->{TYPE}}->{SIZE_FN_ARGS}->($d->{DATA}, $name); + my ($d, $name, $varname) = @_; + return $typefamily{$d->{DATA}->{TYPE}}->{SIZE_FN_ARGS}->($d->{DATA}, $name, $varname); } $typefamily{TYPEDEF} = { @@ -2364,12 +2365,13 @@ sub ParseTypePush($) { my ($e) = @_; - my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}); + my $varname = "r"; + my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}, $varname); fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)") or return; pidl "{"; indent; - $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($e, $e->{NAME}); + $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($e, $e->{NAME}, $varname); pidl "return NT_STATUS_OK;"; deindent; pidl "}"; @@ -2380,13 +2382,14 @@ sub ParseTypePull($) { my ($e) = @_; - my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "pull", $e->{NAME}); + my $varname = "r"; + my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "pull", $e->{NAME}, $varname); fn_declare("pull", $e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)") or return; pidl "{"; indent; - $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($e, $e->{NAME}); + $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($e, $e->{NAME}, $varname); pidl "return NT_STATUS_OK;"; deindent; pidl "}"; @@ -2396,7 +2399,8 @@ sub ParseTypePull($) sub ParseTypePrint($) { my ($e) = @_; - my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "print", $e->{NAME}); + my $varname = "r"; + my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "print", $e->{NAME}, $varname); pidl_hdr "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args);"; @@ -2405,7 +2409,7 @@ sub ParseTypePrint($) pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; pidl "{"; indent; - $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($e, $e->{NAME}); + $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($e, $e->{NAME}, $varname); deindent; pidl "}"; pidl ""; @@ -2415,14 +2419,15 @@ sub ParseTypeNdrSize($) { my ($t) = @_; + my $varname = "r"; my $tf = $typefamily{$t->{TYPE}}; - my $args = $tf->{SIZE_FN_ARGS}->($t, $t->{NAME}); + my $args = $tf->{SIZE_FN_ARGS}->($t, $t->{NAME}, $varname); fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)") or return; pidl "{"; indent; - $typefamily{$t->{TYPE}}->{SIZE_FN_BODY}->($t, $t->{NAME}); + $typefamily{$t->{TYPE}}->{SIZE_FN_BODY}->($t, $t->{NAME}, $varname); deindent; pidl "}"; pidl ""; -- cgit From 32afb0d15fa2d941ec1c01fd9cf23200481652c9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 19 Feb 2007 01:51:46 +0000 Subject: r21443: Refactor some of the NDR code in preparation of nested data structure support. (This used to be commit 1afedaad44d5d375ebd277017ec61bf9b5741d8a) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 227 +++++++++++++---------- 1 file changed, 125 insertions(+), 102 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 7a9ea21440..a4957fc7d9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1190,6 +1190,32 @@ sub ParsePtrPull($$$$) pidl "}"; } +sub ParseStructPushPrimitives($$$$) +{ + my ($struct, $name, $varname, $env) = @_; + + pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));"; + + if (defined($struct->{PROPERTIES}{relative_base})) { + # set the current offset as base for relative pointers + # and store it based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; + } + + ParseElementPush($_, "ndr", $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); +} + +sub ParseStructPushDeferred($$$$) +{ + my ($struct, $name, $varname, $env) = @_; + if (defined($struct->{PROPERTIES}{relative_base})) { + # retrieve the current offset as base for relative pointers + # based on the toplevel struct/union + pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"; + } + ParseElementPush($_, "ndr", $env, 0, 1) foreach (@{$struct->{ELEMENTS}}); +} + ##################################################################### # parse a struct sub ParseStructPush($$$) @@ -1202,12 +1228,7 @@ sub ParseStructPush($$$) EnvSubstituteValue($env, $struct); - # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base}); - - foreach my $e (@{$struct->{ELEMENTS}}) { - DeclareArrayVariables($e); - } + DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}}); start_flags($struct); @@ -1241,39 +1262,17 @@ sub ParseStructPush($$$) pidl "if (ndr_flags & NDR_SCALARS) {"; indent; - - pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));"; - - if (defined($struct->{PROPERTIES}{relative_base})) { - # set the current offset as base for relative pointers - # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; - } - - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPush($e, "ndr", $env, 1, 0); - } - + ParseStructPushPrimitives($struct, $name, $varname, $env); deindent; pidl "}"; pidl "if (ndr_flags & NDR_BUFFERS) {"; indent; - if (defined($struct->{PROPERTIES}{relative_base})) { - # retrieve the current offset as base for relative pointers - # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"; - } - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPush($e, "ndr", $env, 0, 1); - } - + ParseStructPushDeferred($struct, $name, $varname, $env); deindent; pidl "}"; end_flags($struct); - # restore the old relative_base_offset - pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base}); } ##################################################################### @@ -1514,30 +1513,9 @@ sub DeclareMemCtxVariables($) } } -##################################################################### -# parse a struct - pull side -sub ParseStructPull($$$) +sub ParseStructPullPrimitives($$$$) { - my($struct,$name,$varname) = @_; - - return unless defined $struct->{ELEMENTS}; - - my $env = GenerateStructEnv($struct, $varname); - - # declare any internal pointers we need - foreach my $e (@{$struct->{ELEMENTS}}) { - DeclarePtrVariables($e); - DeclareArrayVariables($e); - DeclareMemCtxVariables($e); - } - - # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base}); - - start_flags($struct); - - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; + my($struct,$name,$varname,$env) = @_; if (defined $struct->{SURROUNDING_ELEMENT}) { pidl "NDR_CHECK(ndr_pull_array_size(ndr, &$varname->$struct->{SURROUNDING_ELEMENT}->{NAME}));"; @@ -1551,16 +1529,15 @@ sub ParseStructPull($$$) pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; } - foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPull($e, "ndr", $env, 1, 0); - } + ParseElementPull($_, "ndr", $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); add_deferred(); +} + +sub ParseStructPullDeferred($$$$) +{ + my ($struct,$name,$varname,$env) = @_; - deindent; - pidl "}"; - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; if (defined($struct->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union @@ -1571,13 +1548,39 @@ sub ParseStructPull($$$) } add_deferred(); +} + +##################################################################### +# parse a struct - pull side +sub ParseStructPull($$$) +{ + my($struct,$name,$varname) = @_; + + return unless defined $struct->{ELEMENTS}; + + # declare any internal pointers we need + foreach my $e (@{$struct->{ELEMENTS}}) { + DeclarePtrVariables($e); + DeclareArrayVariables($e); + DeclareMemCtxVariables($e); + } + + start_flags($struct); + + my $env = GenerateStructEnv($struct, $varname); + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + ParseStructPullPrimitives($struct,$name,$varname,$env); + deindent; + pidl "}"; + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + ParseStructPullDeferred($struct,$name,$varname,$env); deindent; pidl "}"; end_flags($struct); - # restore the old relative_base_offset - pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base}); } ##################################################################### @@ -1635,8 +1638,6 @@ sub ParseUnionPush($$$) my ($e,$name,$varname) = @_; my $have_default = 0; - # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base}); pidl "int level;"; start_flags($e); @@ -1710,8 +1711,6 @@ sub ParseUnionPush($$$) deindent; pidl "}"; end_flags($e); - # restore the old relative_base_offset - pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); } ##################################################################### @@ -1757,38 +1756,10 @@ sub ParseUnionPrint($$$) end_flags($e); } -##################################################################### -# parse a union - pull side -sub ParseUnionPull($$$) +sub ParseUnionPullPrimitives($$$$) { - my ($e,$name,$varname) = @_; + my ($e,$name,$varname,$switch_type) = @_; my $have_default = 0; - my $switch_type = $e->{SWITCH_TYPE}; - - # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base}); - pidl "int level;"; - if (defined($switch_type)) { - if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) { - $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)->{DATA}); - } - pidl mapTypeName($switch_type) . " _level;"; - } - - my %double_cases = (); - foreach my $el (@{$e->{ELEMENTS}}) { - next if ($el->{TYPE} eq "EMPTY"); - next if ($double_cases{"$el->{NAME}"}); - DeclareMemCtxVariables($el); - $double_cases{"$el->{NAME}"} = 1; - } - - start_flags($e); - - pidl "level = ndr_pull_get_switch_value(ndr, $varname);"; - - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; if (defined($switch_type)) { pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));"; @@ -1827,10 +1798,13 @@ sub ParseUnionPull($$$) } deindent; pidl "}"; - deindent; - pidl "}"; - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; +} + +sub ParseUnionPullDeferred($$$) +{ + my ($e,$name,$varname) = @_; + my $have_default = 0; + if (defined($e->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union @@ -1839,6 +1813,10 @@ sub ParseUnionPull($$$) pidl "switch (level) {"; indent; foreach my $el (@{$e->{ELEMENTS}}) { + if ($el->{CASE} eq "default") { + $have_default = 1; + } + pidl "$el->{CASE}:"; if ($el->{TYPE} ne "EMPTY") { indent; @@ -1855,14 +1833,51 @@ sub ParseUnionPull($$$) deindent; pidl "}"; + +} + +##################################################################### +# parse a union - pull side +sub ParseUnionPull($$$) +{ + my ($e,$name,$varname) = @_; + my $switch_type = $e->{SWITCH_TYPE}; + + pidl "int level;"; + if (defined($switch_type)) { + if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) { + $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)->{DATA}); + } + pidl mapTypeName($switch_type) . " _level;"; + } + + my %double_cases = (); + foreach my $el (@{$e->{ELEMENTS}}) { + next if ($el->{TYPE} eq "EMPTY"); + next if ($double_cases{"$el->{NAME}"}); + DeclareMemCtxVariables($el); + $double_cases{"$el->{NAME}"} = 1; + } + + start_flags($e); + + pidl "level = ndr_pull_get_switch_value(ndr, $varname);"; + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + ParseUnionPullPrimitives($e,$name,$varname,$switch_type); + deindent; + pidl "}"; + + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + ParseUnionPullDeferred($e,$name,$varname); deindent; pidl "}"; add_deferred(); end_flags($e); - # restore the old relative_base_offset - pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base}); } sub DeclUnion($$$$) @@ -2371,7 +2386,11 @@ sub ParseTypePush($) pidl "{"; indent; + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($e, $e->{NAME}, $varname); + # restore the old relative_base_offset + pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); pidl "return NT_STATUS_OK;"; deindent; pidl "}"; @@ -2389,7 +2408,11 @@ sub ParseTypePull($) pidl "{"; indent; + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($e, $e->{NAME}, $varname); + # restore the old relative_base_offset + pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); pidl "return NT_STATUS_OK;"; deindent; pidl "}"; -- cgit From 29cdad41817f5bb3c9c79c4cbb8f94244b21b9e1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 19 Feb 2007 19:42:51 +0000 Subject: r21455: Fix a bug in our handling of conformant arrays. The conformant array was always pushed, even if just the buffers part of a struct had to be pushed. Pull was not affected. (This used to be commit ffe387920473fb365f740942098085eb40299c84) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 60 ++++++++++++------------ 1 file changed, 30 insertions(+), 30 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index a4957fc7d9..8393d6f3c0 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -12,7 +12,7 @@ require Exporter; @EXPORT = qw(is_charset_array); @EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction - NeededElement NeededType); + NeededElement NeededType $res); use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName); @@ -110,7 +110,7 @@ sub get_value_of($) } } -my $res; +our $res; my $deferred = []; my $tabs = ""; @@ -1194,6 +1194,34 @@ sub ParseStructPushPrimitives($$$$) { my ($struct, $name, $varname, $env) = @_; + # see if the structure contains a conformant array. If it + # does, then it must be the last element of the structure, and + # we need to push the conformant length early, as it fits on + # the wire before the structure (and even before the structure + # alignment) + if (defined($struct->{SURROUNDING_ELEMENT})) { + my $e = $struct->{SURROUNDING_ELEMENT}; + + if (defined($e->{LEVELS}[0]) and + $e->{LEVELS}[0]->{TYPE} eq "ARRAY") { + my $size; + + if ($e->{LEVELS}[0]->{IS_ZERO_TERMINATED}) { + if (has_property($e, "charset")) { + $size = "ndr_charset_length($varname->$e->{NAME}, CH_$e->{PROPERTIES}->{charset})"; + } else { + $size = "ndr_string_length($varname->$e->{NAME}, sizeof(*$varname->$e->{NAME}))"; + } + } else { + $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL}); + } + + pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; + } else { + pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, $varname->$e->{NAME})));"; + } + } + pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));"; if (defined($struct->{PROPERTIES}{relative_base})) { @@ -1232,34 +1260,6 @@ sub ParseStructPush($$$) start_flags($struct); - # see if the structure contains a conformant array. If it - # does, then it must be the last element of the structure, and - # we need to push the conformant length early, as it fits on - # the wire before the structure (and even before the structure - # alignment) - if (defined($struct->{SURROUNDING_ELEMENT})) { - my $e = $struct->{SURROUNDING_ELEMENT}; - - if (defined($e->{LEVELS}[0]) and - $e->{LEVELS}[0]->{TYPE} eq "ARRAY") { - my $size; - - if ($e->{LEVELS}[0]->{IS_ZERO_TERMINATED}) { - if (has_property($e, "charset")) { - $size = "ndr_charset_length($varname->$e->{NAME}, CH_$e->{PROPERTIES}->{charset})"; - } else { - $size = "ndr_string_length($varname->$e->{NAME}, sizeof(*$varname->$e->{NAME}))"; - } - } else { - $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL}); - } - - pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; - } else { - pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, $varname->$e->{NAME})));"; - } - } - pidl "if (ndr_flags & NDR_SCALARS) {"; indent; ParseStructPushPrimitives($struct, $name, $varname, $env); -- cgit From ac0433e3d3b5feb7629f67f35ea914c11686591c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 19 Feb 2007 21:37:54 +0000 Subject: r21456: Allow anonymous and non-anonymous nested structures/unions/enums/bitmaps to be used in the Samba 4 NDR parser. This doesn't actually work yet as Parse::Pidl::NDR doesn't handle nested data structures yet, but it's a first step. (This used to be commit 8aac1fc98b812a0668bc0d803d1e2831396b455e) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 148 ++++++++++++++++------- 1 file changed, 105 insertions(+), 43 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 8393d6f3c0..8a72b1233e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -752,6 +752,28 @@ sub ParsePtrPush($$$) } } +sub ParseDataPrint($$$) +{ + my ($e, $l, $var_name) = @_; + + if (not ref($l->{DATA_TYPE}) or + defined($l->{DATA_TYPE}->{NAME})) { + my $t; + if (ref($l->{DATA_TYPE})) { + $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; + } else { + $t = $l->{DATA_TYPE}; + } + if (not Parse::Pidl::Typelist::is_scalar($t) or + Parse::Pidl::Typelist::scalar_is_reference($t)) { + $var_name = get_pointer_to($var_name); + } + pidl "ndr_print_$t(ndr, \"$e->{NAME}\", $var_name);"; + } else { + ParseTypePrint($l->{DATA_TYPE}, $var_name); + } +} + ##################################################################### # print scalars in a structure element sub ParseElementPrint($$$) @@ -816,10 +838,7 @@ sub ParseElementPrint($$$) $var_name = $var_name . "[$counter]"; } } elsif ($l->{TYPE} eq "DATA") { - if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - $var_name = get_pointer_to($var_name); - } - pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; + ParseDataPrint($e, $l, $var_name); } elsif ($l->{TYPE} eq "SWITCH") { my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, \&pidl, "return;"), check_fully_dereferenced($e, $env)); @@ -875,20 +894,32 @@ sub ParseDataPull($$$$$) { my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; - if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - $var_name = get_pointer_to($var_name); - } + if (not ref($l->{DATA_TYPE}) or + defined($l->{DATA_TYPE}->{NAME})) { + my $t; + if (ref($l->{DATA_TYPE}) eq "HASH") { + $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; + } else { + $t = $l->{DATA_TYPE}; + } - $var_name = get_pointer_to($var_name); + if (Parse::Pidl::Typelist::scalar_is_reference($t)) { + $var_name = get_pointer_to($var_name); + } - pidl "NDR_CHECK(ndr_pull_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));"; + $var_name = get_pointer_to($var_name); - if (my $range = has_property($e, "range")) { - $var_name = get_value_of($var_name); - my ($low, $high) = split(/ /, $range, 2); - pidl "if ($var_name < $low || $var_name > $high) {"; - pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");"; - pidl "}"; + pidl "NDR_CHECK(ndr_pull_$t($ndr, $ndr_flags, $var_name));"; + + if (my $range = has_property($e, "range")) { + $var_name = get_value_of($var_name); + my ($low, $high) = split(/ /, $range, 2); + pidl "if ($var_name < $low || $var_name > $high) {"; + pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");"; + pidl "}"; + } + } else { + ParseTypePull($l->{DATA_TYPE}, $var_name); } } @@ -896,12 +927,24 @@ sub ParseDataPush($$$$$) { my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; - # strings are passed by value rather than reference - if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - $var_name = get_pointer_to($var_name); - } + if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { + my $t; + if (ref($l->{DATA_TYPE}) eq "HASH") { + $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; + } else { + $t = $l->{DATA_TYPE}; + } + + # strings are passed by value rather than reference + if (not Parse::Pidl::Typelist::is_scalar($t) or + Parse::Pidl::Typelist::scalar_is_reference($t)) { + $var_name = get_pointer_to($var_name); + } - pidl "NDR_CHECK(ndr_push_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));"; + pidl "NDR_CHECK(ndr_push_$t($ndr, $ndr_flags, $var_name));"; + } else { + ParseTypePush($l->{DATA_TYPE}, $var_name); + } } sub CalcNdrFlags($$$) @@ -2376,53 +2419,72 @@ sub HeaderInterface($) } -sub ParseTypePush($) +sub ParseTypePush($$) { - my ($e) = @_; - - my $varname = "r"; - my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}, $varname); - fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)") or return; + my ($e, $varname) = @_; - pidl "{"; - indent; # save the old relative_base_offset pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($e, $e->{NAME}, $varname); # restore the old relative_base_offset pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); +} + +sub ParseTypePushFunction($$) +{ + my ($e, $varname) = @_; + + my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}, $varname); + fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)") or return; + + pidl "{"; + indent; + ParseTypePush($e, $varname); pidl "return NT_STATUS_OK;"; deindent; pidl "}"; pidl "";; } -sub ParseTypePull($) +sub ParseTypePull($$) { - my ($e) = @_; + my ($e, $varname) = @_; + + # save the old relative_base_offset + pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); + $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($e, $e->{NAME}, $varname); + # restore the old relative_base_offset + pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); +} + + +sub ParseTypePullFunction($$) +{ + my ($e, $varname) = @_; - my $varname = "r"; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "pull", $e->{NAME}, $varname); fn_declare("pull", $e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)") or return; pidl "{"; indent; - # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); - $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($e, $e->{NAME}, $varname); - # restore the old relative_base_offset - pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); + ParseTypePull($e, $varname); pidl "return NT_STATUS_OK;"; deindent; pidl "}"; pidl ""; } -sub ParseTypePrint($) +sub ParseTypePrint($$) { - my ($e) = @_; - my $varname = "r"; + my ($e, $varname) = @_; + + $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($e, $e->{NAME}, $varname); +} + +sub ParseTypePrintFunction($$) +{ + my ($e, $varname) = @_; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "print", $e->{NAME}, $varname); pidl_hdr "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args);"; @@ -2432,7 +2494,7 @@ sub ParseTypePrint($) pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; pidl "{"; indent; - $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($e, $e->{NAME}, $varname); + ParseTypePrint($e, $varname); deindent; pidl "}"; pidl ""; @@ -2475,9 +2537,9 @@ sub ParseInterface($$) # Typedefs foreach my $d (@{$interface->{TYPES}}) { - ($needed->{"push_$d->{NAME}"}) && ParseTypePush($d); - ($needed->{"pull_$d->{NAME}"}) && ParseTypePull($d); - ($needed->{"print_$d->{NAME}"}) && ParseTypePrint($d); + ($needed->{"push_$d->{NAME}"}) && ParseTypePushFunction($d, "r"); + ($needed->{"pull_$d->{NAME}"}) && ParseTypePullFunction($d, "r"); + ($needed->{"print_$d->{NAME}"}) && ParseTypePrintFunction($d, "r"); # Make sure we don't generate a function twice... $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = -- cgit From 4e757aa64c76a4d15db88cfb20cf118cc739789d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 19 Feb 2007 22:10:23 +0000 Subject: r21457: Cope with anonymous nested types in the NDR layer. This doesn't handled named nested types yet, as these have to be registered. (This used to be commit 9b0416b5d06286c81c73477a24cb591fd4b23d18) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 37 +++++++++++++++++++------------------ 1 file changed, 19 insertions(+), 18 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index d55df7a452..a921e5cbe5 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -257,8 +257,6 @@ sub GetElementLevelTable($) push (@$order, { TYPE => "DATA", - CONVERT_TO => has_property($e, ""), - CONVERT_FROM => has_property($e, ""), DATA_TYPE => $e->{TYPE}, IS_DEFERRED => $is_deferred, CONTAINS_DEFERRED => can_contain_deferred($e), @@ -360,12 +358,16 @@ sub align_type($) die("Unknown data type type $dt->{TYPE}"); } -sub ParseElement($) +sub ParseElement($$) { - my $e = shift; + my ($e, $pointer_default) = @_; $e->{TYPE} = expandAlias($e->{TYPE}); + if (ref($e->{TYPE}) eq "HASH") { + $e->{TYPE} = ParseType($e->{TYPE}, $pointer_default); + } + return { NAME => $e->{NAME}, TYPE => $e->{TYPE}, @@ -379,14 +381,13 @@ sub ParseElement($) sub ParseStruct($$) { - my ($ndr,$struct) = @_; + my ($struct, $pointer_default) = @_; my @elements = (); my $surrounding = undef; - foreach my $x (@{$struct->{ELEMENTS}}) { - my $e = ParseElement($x); + my $e = ParseElement($x, $pointer_default); if ($x != $struct->{ELEMENTS}[-1] and $e->{LEVELS}[0]->{IS_SURROUNDING}) { fatal($x, "conformant member not at end of struct"); @@ -423,7 +424,7 @@ sub ParseStruct($$) sub ParseUnion($$) { - my ($ndr,$e) = @_; + my ($e, $pointer_default) = @_; my @elements = (); my $switch_type = has_property($e, "switch_type"); unless (defined($switch_type)) { $switch_type = "uint32"; } @@ -437,7 +438,7 @@ sub ParseUnion($$) if ($x->{TYPE} eq "EMPTY") { $t = { TYPE => "EMPTY" }; } else { - $t = ParseElement($x); + $t = ParseElement($x, $pointer_default); } if (has_property($x, "default")) { $t->{CASE} = "default"; @@ -463,7 +464,7 @@ sub ParseUnion($$) sub ParseEnum($$) { - my ($ndr,$e) = @_; + my ($e, $pointer_default) = @_; return { TYPE => "ENUM", @@ -477,7 +478,7 @@ sub ParseEnum($$) sub ParseBitmap($$) { - my ($ndr,$e) = @_; + my ($e, $pointer_default) = @_; return { TYPE => "BITMAP", @@ -491,10 +492,10 @@ sub ParseBitmap($$) sub ParseType($$) { - my ($ndr, $d) = @_; + my ($d, $pointer_default) = @_; if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "UNION") { - CheckPointerTypes($d, $ndr->{PROPERTIES}->{pointer_default}); + CheckPointerTypes($d, $pointer_default); } my $data = { @@ -503,20 +504,20 @@ sub ParseType($$) ENUM => \&ParseEnum, BITMAP => \&ParseBitmap, TYPEDEF => \&ParseTypedef, - }->{$d->{TYPE}}->($ndr, $d); + }->{$d->{TYPE}}->($d, $pointer_default); return $data; } sub ParseTypedef($$) { - my ($ndr,$d) = @_; + my ($d, $pointer_default) = @_; if (defined($d->{DATA}->{PROPERTIES}) && !defined($d->{PROPERTIES})) { $d->{PROPERTIES} = $d->{DATA}->{PROPERTIES}; } - my $data = ParseType($ndr, $d->{DATA}); + my $data = ParseType($d->{DATA}, $pointer_default); $data->{ALIGN} = align_type($d->{NAME}); return { @@ -550,7 +551,7 @@ sub ParseFunction($$$) } foreach my $x (@{$d->{ELEMENTS}}) { - my $e = ParseElement($x); + my $e = ParseElement($x, $ndr->{PROPERTIES}->{pointer_default}); push (@{$e->{DIRECTION}}, "in") if (has_property($x, "in")); push (@{$e->{DIRECTION}}, "out") if (has_property($x, "out")); @@ -618,7 +619,7 @@ sub ParseInterface($) } elsif ($d->{TYPE} eq "CONST") { push (@consts, ParseConst($idl, $d)); } else { - push (@types, ParseType($idl, $d)); + push (@types, ParseType($d, $idl->{PROPERTIES}->{pointer_default})); } } -- cgit From 4b6ee4837998c4fafec5b7b80c67944d3d986f30 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 19 Feb 2007 23:11:01 +0000 Subject: r21458: Prepare for generating separate primitives/deferred code. (This used to be commit efaf476337e536740068334ee9af01eb6ce97c4f) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 43 +++++++++++++----------- 1 file changed, 23 insertions(+), 20 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 8a72b1233e..edd0ae157a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -643,9 +643,9 @@ sub ParseElementPushLevel return; } } elsif ($l->{TYPE} eq "SWITCH") { - ParseSwitchPush($e, $l, $ndr, $var_name, $ndr_flags, $env); + ParseSwitchPush($e, $l, $ndr, $var_name, $env); } elsif ($l->{TYPE} eq "DATA") { - ParseDataPush($e, $l, $ndr, $var_name, $ndr_flags); + ParseDataPush($e, $l, $ndr, $var_name, $primitives, $deferred); } } @@ -868,9 +868,9 @@ sub ParseElementPrint($$$) ##################################################################### # parse scalars in a structure element - pull size -sub ParseSwitchPull($$$$$$) +sub ParseSwitchPull($$$$$) { - my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; + my($e,$l,$ndr,$var_name,$env) = @_; my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); @@ -880,9 +880,9 @@ sub ParseSwitchPull($$$$$$) ##################################################################### # push switch element -sub ParseSwitchPush($$$$$$) +sub ParseSwitchPush($$$$$) { - my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_; + my($e,$l,$ndr,$var_name,$env) = @_; my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); @@ -890,12 +890,14 @@ sub ParseSwitchPush($$$$$$) pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"; } -sub ParseDataPull($$$$$) +sub ParseDataPull($$$$$$) { - my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; + my ($e,$l,$ndr,$var_name,$primitives,$deferred) = @_; if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { + + my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); my $t; if (ref($l->{DATA_TYPE}) eq "HASH") { $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; @@ -919,13 +921,13 @@ sub ParseDataPull($$$$$) pidl "}"; } } else { - ParseTypePull($l->{DATA_TYPE}, $var_name); + ParseTypePull($l->{DATA_TYPE}, $var_name, $primitives, $deferred); } } -sub ParseDataPush($$$$$) +sub ParseDataPush($$$$$$) { - my ($e,$l,$ndr,$var_name,$ndr_flags) = @_; + my ($e,$l,$ndr,$var_name,$primitives,$deferred) = @_; if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { my $t; @@ -941,9 +943,10 @@ sub ParseDataPush($$$$$) $var_name = get_pointer_to($var_name); } + my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); pidl "NDR_CHECK(ndr_push_$t($ndr, $ndr_flags, $var_name));"; } else { - ParseTypePush($l->{DATA_TYPE}, $var_name); + ParseTypePush($l->{DATA_TYPE}, $var_name, $primitives, $deferred); } } @@ -1069,9 +1072,9 @@ sub ParseElementPullLevel } elsif ($l->{TYPE} eq "POINTER") { ParsePtrPull($e, $l, $ndr, $var_name); } elsif ($l->{TYPE} eq "SWITCH") { - ParseSwitchPull($e, $l, $ndr, $var_name, $ndr_flags, $env); + ParseSwitchPull($e, $l, $ndr, $var_name, $env); } elsif ($l->{TYPE} eq "DATA") { - ParseDataPull($e, $l, $ndr, $var_name, $ndr_flags); + ParseDataPull($e, $l, $ndr, $var_name, $primitives, $deferred); } } @@ -2419,9 +2422,9 @@ sub HeaderInterface($) } -sub ParseTypePush($$) +sub ParseTypePush($$$$) { - my ($e, $varname) = @_; + my ($e, $varname, $primitives, $deferred) = @_; # save the old relative_base_offset pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); @@ -2439,16 +2442,16 @@ sub ParseTypePushFunction($$) pidl "{"; indent; - ParseTypePush($e, $varname); + ParseTypePush($e, $varname, 1, 1); pidl "return NT_STATUS_OK;"; deindent; pidl "}"; pidl "";; } -sub ParseTypePull($$) +sub ParseTypePull($$$$) { - my ($e, $varname) = @_; + my ($e, $varname, $primitives, $deferred) = @_; # save the old relative_base_offset pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); @@ -2468,7 +2471,7 @@ sub ParseTypePullFunction($$) pidl "{"; indent; - ParseTypePull($e, $varname); + ParseTypePull($e, $varname, 1, 1); pidl "return NT_STATUS_OK;"; deindent; pidl "}"; -- cgit From 8f83985f2890ac2b47a33853812d62bbb90e9cf4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 20 Feb 2007 01:27:48 +0000 Subject: r21459: Remove name argument, more refactoring. (This used to be commit fad03f6c51b40bca2b60036835b998056fec0faa) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 133 +++++++++++++---------- 1 file changed, 76 insertions(+), 57 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index edd0ae157a..4566279009 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1236,9 +1236,9 @@ sub ParsePtrPull($$$$) pidl "}"; } -sub ParseStructPushPrimitives($$$$) +sub ParseStructPushPrimitives($$$) { - my ($struct, $name, $varname, $env) = @_; + my ($struct, $varname, $env) = @_; # see if the structure contains a conformant array. If it # does, then it must be the last element of the structure, and @@ -1279,9 +1279,9 @@ sub ParseStructPushPrimitives($$$$) ParseElementPush($_, "ndr", $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); } -sub ParseStructPushDeferred($$$$) +sub ParseStructPushDeferred($$$) { - my ($struct, $name, $varname, $env) = @_; + my ($struct, $varname, $env) = @_; if (defined($struct->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union @@ -1292,9 +1292,9 @@ sub ParseStructPushDeferred($$$$) ##################################################################### # parse a struct -sub ParseStructPush($$$) +sub ParseStructPush($$) { - my ($struct, $name, $varname) = @_; + my ($struct, $varname) = @_; return unless defined($struct->{ELEMENTS}); @@ -1308,13 +1308,13 @@ sub ParseStructPush($$$) pidl "if (ndr_flags & NDR_SCALARS) {"; indent; - ParseStructPushPrimitives($struct, $name, $varname, $env); + ParseStructPushPrimitives($struct, $varname, $env); deindent; pidl "}"; pidl "if (ndr_flags & NDR_BUFFERS) {"; indent; - ParseStructPushDeferred($struct, $name, $varname, $env); + ParseStructPushDeferred($struct, $varname, $env); deindent; pidl "}"; @@ -1323,9 +1323,9 @@ sub ParseStructPush($$$) ##################################################################### # generate a push function for an enum -sub ParseEnumPush($$$) +sub ParseEnumPush($$) { - my($enum,$name,$varname) = @_; + my($enum,$varname) = @_; my($type_fn) = $enum->{BASE_TYPE}; start_flags($enum); @@ -1335,9 +1335,9 @@ sub ParseEnumPush($$$) ##################################################################### # generate a pull function for an enum -sub ParseEnumPull($$$) +sub ParseEnumPull($$) { - my($enum,$name,$varname) = @_; + my($enum,$varname) = @_; my($type_fn) = $enum->{BASE_TYPE}; my($type_v_decl) = mapTypeName($type_fn); @@ -1396,9 +1396,9 @@ $typefamily{ENUM} = { ##################################################################### # generate a push function for a bitmap -sub ParseBitmapPush($$$) +sub ParseBitmapPush($$) { - my($bitmap,$name,$varname) = @_; + my($bitmap,$varname) = @_; my($type_fn) = $bitmap->{BASE_TYPE}; start_flags($bitmap); @@ -1410,9 +1410,9 @@ sub ParseBitmapPush($$$) ##################################################################### # generate a pull function for an bitmap -sub ParseBitmapPull($$$) +sub ParseBitmapPull($$) { - my($bitmap,$name,$varname) = @_; + my($bitmap,$varname) = @_; my $type_fn = $bitmap->{BASE_TYPE}; my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); @@ -1559,9 +1559,9 @@ sub DeclareMemCtxVariables($) } } -sub ParseStructPullPrimitives($$$$) +sub ParseStructPullPrimitives($$$) { - my($struct,$name,$varname,$env) = @_; + my($struct,$varname,$env) = @_; if (defined $struct->{SURROUNDING_ELEMENT}) { pidl "NDR_CHECK(ndr_pull_array_size(ndr, &$varname->$struct->{SURROUNDING_ELEMENT}->{NAME}));"; @@ -1580,9 +1580,9 @@ sub ParseStructPullPrimitives($$$$) add_deferred(); } -sub ParseStructPullDeferred($$$$) +sub ParseStructPullDeferred($$$) { - my ($struct,$name,$varname,$env) = @_; + my ($struct,$varname,$env) = @_; if (defined($struct->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers @@ -1598,9 +1598,9 @@ sub ParseStructPullDeferred($$$$) ##################################################################### # parse a struct - pull side -sub ParseStructPull($$$) +sub ParseStructPull($$) { - my($struct,$name,$varname) = @_; + my($struct,$varname) = @_; return unless defined $struct->{ELEMENTS}; @@ -1617,12 +1617,12 @@ sub ParseStructPull($$$) pidl "if (ndr_flags & NDR_SCALARS) {"; indent; - ParseStructPullPrimitives($struct,$name,$varname,$env); + ParseStructPullPrimitives($struct,$varname,$env); deindent; pidl "}"; pidl "if (ndr_flags & NDR_BUFFERS) {"; indent; - ParseStructPullDeferred($struct,$name,$varname,$env); + ParseStructPullDeferred($struct,$varname,$env); deindent; pidl "}"; @@ -1677,21 +1677,13 @@ sub ParseUnionNdrSize($$$) pidl "return ndr_size_union($varname, flags, level, (ndr_push_flags_fn_t)ndr_push_$name);"; } -##################################################################### -# parse a union - push side -sub ParseUnionPush($$$) +sub ParseUnionPushPrimitives($$) { - my ($e,$name,$varname) = @_; - my $have_default = 0; - - pidl "int level;"; - - start_flags($e); + my ($e, $varname) = @_; - pidl "level = ndr_push_get_switch_value(ndr, $varname);"; + my $have_default = 0; - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; + pidl "int level = ndr_push_get_switch_value(ndr, $varname);"; if (defined($e->{SWITCH_TYPE})) { pidl "NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));"; @@ -1726,10 +1718,15 @@ sub ParseUnionPush($$$) } deindent; pidl "}"; - deindent; - pidl "}"; - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; +} + +sub ParseUnionPushDeferred($$) +{ + my ($e, $varname) = @_; + + my $have_default = 0; + + pidl "int level = ndr_push_get_switch_value(ndr, $varname);"; if (defined($e->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union @@ -1738,6 +1735,10 @@ sub ParseUnionPush($$$) pidl "switch (level) {"; indent; foreach my $el (@{$e->{ELEMENTS}}) { + if ($el->{CASE} eq "default") { + $have_default = 1; + } + pidl "$el->{CASE}:"; if ($el->{TYPE} ne "EMPTY") { indent; @@ -1753,7 +1754,25 @@ sub ParseUnionPush($$$) } deindent; pidl "}"; +} + +##################################################################### +# parse a union - push side +sub ParseUnionPush($$) +{ + my ($e,$varname) = @_; + my $have_default = 0; + start_flags($e); + + pidl "if (ndr_flags & NDR_SCALARS) {"; + indent; + ParseUnionPushPrimitives($e, $varname); + deindent; + pidl "}"; + pidl "if (ndr_flags & NDR_BUFFERS) {"; + indent; + ParseUnionPushDeferred($e, $varname); deindent; pidl "}"; end_flags($e); @@ -1802,15 +1821,15 @@ sub ParseUnionPrint($$$) end_flags($e); } -sub ParseUnionPullPrimitives($$$$) +sub ParseUnionPullPrimitives($$$) { - my ($e,$name,$varname,$switch_type) = @_; + my ($e,$varname,$switch_type) = @_; my $have_default = 0; if (defined($switch_type)) { pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));"; pidl "if (_level != level) {"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $name\", _level);"; + pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $varname\", _level);"; pidl "}"; } @@ -1846,9 +1865,9 @@ sub ParseUnionPullPrimitives($$$$) pidl "}"; } -sub ParseUnionPullDeferred($$$) +sub ParseUnionPullDeferred($$) { - my ($e,$name,$varname) = @_; + my ($e,$varname) = @_; my $have_default = 0; if (defined($e->{PROPERTIES}{relative_base})) { @@ -1884,9 +1903,9 @@ sub ParseUnionPullDeferred($$$) ##################################################################### # parse a union - pull side -sub ParseUnionPull($$$) +sub ParseUnionPull($$) { - my ($e,$name,$varname) = @_; + my ($e,$varname) = @_; my $switch_type = $e->{SWITCH_TYPE}; pidl "int level;"; @@ -1911,13 +1930,13 @@ sub ParseUnionPull($$$) pidl "if (ndr_flags & NDR_SCALARS) {"; indent; - ParseUnionPullPrimitives($e,$name,$varname,$switch_type); + ParseUnionPullPrimitives($e,$varname,$switch_type); deindent; pidl "}"; pidl "if (ndr_flags & NDR_BUFFERS) {"; indent; - ParseUnionPullDeferred($e,$name,$varname); + ParseUnionPullDeferred($e,$varname); deindent; pidl "}"; @@ -1949,20 +1968,20 @@ $typefamily{UNION} = { ##################################################################### # parse a typedef - push side -sub ParseTypedefPush($$$) +sub ParseTypedefPush($$) { - my($e,$name,$varname) = @_; + my($e,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $name, $varname); + $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $varname); } ##################################################################### # parse a typedef - pull side -sub ParseTypedefPull($$$) +sub ParseTypedefPull($$) { - my($e,$name,$varname) = @_; + my($e,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $name, $varname); + $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $varname); } ##################################################################### @@ -2428,7 +2447,7 @@ sub ParseTypePush($$$$) # save the old relative_base_offset pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); - $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($e, $e->{NAME}, $varname); + $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($e, $varname); # restore the old relative_base_offset pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); } @@ -2455,7 +2474,7 @@ sub ParseTypePull($$$$) # save the old relative_base_offset pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); - $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($e, $e->{NAME}, $varname); + $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($e, $varname); # restore the old relative_base_offset pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); } -- cgit From 90789cb08b84d3b916df3ed11fa9c68dd3075600 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 21 Feb 2007 10:31:14 +0000 Subject: r21484: Fix Needed* for nested datastructures. (This used to be commit ec3c9ebfd0de287411ce399967409f902653d5c6) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 16 +++++ source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 76 ++++++++++-------------- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 70 ++++++++++++++-------- 3 files changed, 93 insertions(+), 69 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index a921e5cbe5..7322856cdd 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -588,6 +588,21 @@ sub CheckPointerTypes($$) } } +sub FindNestedTypes($$) +{ + sub FindNestedTypes($$); + my ($l, $t) = @_; + + return if not defined($t->{ELEMENTS}); + + foreach (@{$t->{ELEMENTS}}) { + if (ref($_->{TYPE}) eq "HASH") { + push (@$l, $_->{TYPE}) if (defined($_->{TYPE}->{NAME})); + FindNestedTypes($l, $_->{TYPE}); + } + } +} + sub ParseInterface($) { my $idl = shift; @@ -620,6 +635,7 @@ sub ParseInterface($) push (@consts, ParseConst($idl, $d)); } else { push (@types, ParseType($d, $idl->{PROPERTIES}->{pointer_default})); + FindNestedTypes(\@types, $d); } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 59dc5f001d..13a8460a81 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -8,7 +8,8 @@ package Parse::Pidl::Samba4::EJS; use strict; use Parse::Pidl::Typelist; -use Parse::Pidl::Util qw(has_property); +use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel); use vars qw($VERSION); $VERSION = '0.01'; @@ -45,7 +46,6 @@ sub deindent() $tabs = substr($tabs, 0, -1); } -# this should probably be in ndr.pm sub GenerateStructEnv($) { my $x = shift; @@ -177,7 +177,7 @@ sub EjsPullPointer($$$$$) indent; pidl "EJS_ALLOC(ejs, $var);"; $var = get_value_of($var); - EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); + EjsPullElement($e, GetNextLevel($e, $l), $var, $name, $env); deindent; pidl "}"; } @@ -187,7 +187,7 @@ sub EjsPullPointer($$$$$) sub EjsPullString($$$$$) { my ($e, $l, $var, $name, $env) = @_; - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + my $pl = GetPrevLevel($e, $l); $var = get_pointer_to($var); if (defined($pl) and $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); @@ -201,10 +201,10 @@ sub EjsPullString($$$$$) sub EjsPullArray($$$$$) { my ($e, $l, $var, $name, $env) = @_; - my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); - my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env, $e); - my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env, $e); - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + my $nl = GetNextLevel($e, $l); + my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); + my $size = ParseExpr($l->{SIZE_IS}, $env, $e); + my $pl = GetPrevLevel($e, $l); if ($pl && $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); } @@ -242,9 +242,9 @@ sub EjsPullArray($$$$$) sub EjsPullSwitch($$$$$) { my ($e, $l, $var, $name, $env) = @_; - my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env, $e); + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); pidl "ejs_set_switch(ejs, $switch_var);"; - EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); + EjsPullElement($e, GetNextLevel($e, $l), $var, $name, $env); } ########################### @@ -271,10 +271,9 @@ sub EjsPullElement($$$$$) # pull a structure/union element at top level sub EjsPullElementTop($$) { - my $e = shift; - my $env = shift; + my ($e, $env) = @_; my $l = $e->{LEVELS}[0]; - my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env, $e); + my $var = ParseExpr($e->{NAME}, $env, $e); my $name = "\"$e->{NAME}\""; EjsPullElement($e, $l, $var, $name, $env); } @@ -283,8 +282,7 @@ sub EjsPullElementTop($$) # pull a struct sub EjsStructPull($$) { - my $name = shift; - my $d = shift; + my ($name, $d) = @_; my $env = GenerateStructEnv($d); fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)"); pidl "{"; @@ -302,10 +300,8 @@ sub EjsStructPull($$) # pull a union sub EjsUnionPull($$) { - my $name = shift; - my $d = shift; + my ($name, $d) = @_; my $have_default = 0; - my $env = GenerateStructEnv($d); fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)"); pidl "{"; indent; @@ -319,7 +315,7 @@ sub EjsUnionPull($$) pidl "$e->{CASE}:"; indent; if ($e->{TYPE} ne "EMPTY") { - EjsPullElementTop($e, $env); + EjsPullElementTop($e, { $e->{NAME} => "r->$e->{NAME}"}); } pidl "break;"; deindent; @@ -359,8 +355,7 @@ sub EjsEnumConstant($) # pull a enum sub EjsEnumPull($$) { - my $name = shift; - my $d = shift; + my ($name, $d) = @_; EjsEnumConstant($d); fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)"); pidl "{"; @@ -377,8 +372,7 @@ sub EjsEnumPull($$) # pull a bitmap sub EjsBitmapPull($$) { - my $name = shift; - my $d = shift; + my ($name, $d) = @_; my $type_fn = $d->{BASE_TYPE}; my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)"); @@ -449,7 +443,7 @@ sub EjsPushScalar($$$$$) { my ($e, $l, $var, $name, $env) = @_; # have to handle strings specially :( - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + my $pl = GetPrevLevel($e, $l); if ((not Parse::Pidl::Typelist::scalar_is_reference($e->{TYPE})) or (defined($pl) and $pl->{TYPE} eq "POINTER")) { @@ -463,7 +457,7 @@ sub EjsPushScalar($$$$$) sub EjsPushString($$$$$) { my ($e, $l, $var, $name, $env) = @_; - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + my $pl = GetPrevLevel($e, $l); if (defined($pl) and $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); } @@ -486,7 +480,7 @@ sub EjsPushPointer($$$$$) pidl "} else {"; indent; $var = get_value_of($var); - EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); + EjsPushElement($e, GetNextLevel($e, $l), $var, $name, $env); deindent; pidl "}"; } @@ -496,9 +490,9 @@ sub EjsPushPointer($$$$$) sub EjsPushSwitch($$$$$) { my ($e, $l, $var, $name, $env) = @_; - my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env, $e); + my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); pidl "ejs_set_switch(ejs, $switch_var);"; - EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env); + EjsPushElement($e, GetNextLevel($e, $l), $var, $name, $env); } @@ -507,9 +501,9 @@ sub EjsPushSwitch($$$$$) sub EjsPushArray($$$$$) { my ($e, $l, $var, $name, $env) = @_; - my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l); - my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env, $e); - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + my $nl = GetNextLevel($e, $l); + my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); + my $pl = GetPrevLevel($e, $l); if ($pl && $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); } @@ -558,10 +552,9 @@ sub EjsPushElement($$$$$) # push a structure/union element at top level sub EjsPushElementTop($$) { - my $e = shift; - my $env = shift; + my ($e, $env) = @_; my $l = $e->{LEVELS}[0]; - my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env, $e); + my $var = ParseExpr($e->{NAME}, $env, $e); my $name = "\"$e->{NAME}\""; EjsPushElement($e, $l, $var, $name, $env); } @@ -570,8 +563,7 @@ sub EjsPushElementTop($$) # push a struct sub EjsStructPush($$) { - my $name = shift; - my $d = shift; + my ($name, $d) = @_; my $env = GenerateStructEnv($d); fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)"); pidl "{"; @@ -589,10 +581,8 @@ sub EjsStructPush($$) # push a union sub EjsUnionPush($$) { - my $name = shift; - my $d = shift; + my ($name, $d) = @_; my $have_default = 0; - my $env = GenerateStructEnv($d); fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)"); pidl "{"; indent; @@ -606,7 +596,7 @@ sub EjsUnionPush($$) pidl "$e->{CASE}:"; indent; if ($e->{TYPE} ne "EMPTY") { - EjsPushElementTop($e, $env); + EjsPushElementTop($e, { $e->{NAME} => "r->$e->{NAME}"} ); } pidl "break;"; deindent; @@ -645,8 +635,7 @@ sub EjsEnumPush($$) # push a bitmap sub EjsBitmapPush($$) { - my $name = shift; - my $d = shift; + my ($name, $d) = @_; my $type_fn = $d->{BASE_TYPE}; my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); # put the bitmap elements in the constants array @@ -719,8 +708,7 @@ sub EjsPushFunction($) # generate a ejs mapping function sub EjsFunction($$) { - my $d = shift; - my $iface = shift; + my ($d, $iface) = @_; my $name = $d->{NAME}; my $callnum = uc("DCERPC_$name"); my $table = "&dcerpc_table_$iface"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 4566279009..2ae4a3b17e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -12,7 +12,7 @@ require Exporter; @EXPORT = qw(is_charset_array); @EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction - NeededElement NeededType $res); + NeededElement NeededType $res NeededInterface); use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName); @@ -2651,17 +2651,32 @@ sub NeededElement($$$) return if ($e->{TYPE} eq "EMPTY"); + my ($t, $rt); + if (ref($e->{TYPE}) eq "HASH") { + $t = $e->{TYPE}->{TYPE}."_".$e->{TYPE}->{NAME}; + } else { + $t = $e->{TYPE}; + } + + if (ref($e->{REPRESENTATION_TYPE}) eq "HASH") { + $rt = $e->{REPRESENTATION_TYPE}->{TYPE}."_".$e->{REPRESENTATION_TYPE}->{NAME}; + } else { + $rt = $e->{REPRESENTATION_TYPE}; + } + + die ("$e->{NAME} $t, $rt FOO") unless ($rt ne ""); + my @fn = (); if ($dir eq "print") { - push(@fn, "print_$e->{REPRESENTATION_TYPE}"); + push(@fn, "print_$rt"); } elsif ($dir eq "pull") { - push (@fn, "pull_$e->{TYPE}"); - push (@fn, "ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}") - if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}); + push (@fn, "pull_$t"); + push (@fn, "ndr_$t\_to_$rt") + if ($rt ne $t); } elsif ($dir eq "push") { - push (@fn, "push_$e->{TYPE}"); - push (@fn, "ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}") - if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}); + push (@fn, "push_$t"); + push (@fn, "ndr_$rt\_to_$t") + if ($rt ne $t); } else { die("invalid direction `$dir'"); } @@ -2685,28 +2700,21 @@ sub NeededFunction($$) } } -sub NeededType($$) +sub NeededType($$$) { - my ($t,$needed) = @_; - if (has_property($t, "public")) { - $needed->{"pull_$t->{NAME}"} = 1; - $needed->{"push_$t->{NAME}"} = 1; - $needed->{"print_$t->{NAME}"} = 1; - } + sub NeededType($$$); + my ($t,$needed,$req) = @_; - if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") { - if (has_property($t, "gensize")) { - $needed->{"ndr_size_$t->{NAME}"} = 1; - } + NeededType($t->{DATA}, $needed, $req) if ($t->{TYPE} eq "TYPEDEF"); - for my $e (@{$t->{DATA}->{ELEMENTS}}) { - $e->{PARENT} = $t->{DATA}; + if ($t->{TYPE} eq "STRUCT" or $t->{TYPE} eq "UNION") { + for my $e (@{$t->{ELEMENTS}}) { + $e->{PARENT} = $t; if (has_property($e, "compression")) { $needed->{"compression"} = 1; } - NeededElement($e, "pull", $needed) if ($needed->{"pull_$t->{NAME}"}); - NeededElement($e, "push", $needed) if ($needed->{"push_$t->{NAME}"}); - NeededElement($e, "print", $needed) if ($needed->{"print_$t->{NAME}"}); + NeededElement($e, $req, $needed); + NeededType($e->{TYPE}, $needed, $req) if (ref($e->{TYPE}) eq "HASH"); } } } @@ -2717,7 +2725,19 @@ sub NeededInterface($$) { my ($interface,$needed) = @_; NeededFunction($_, $needed) foreach (@{$interface->{FUNCTIONS}}); - NeededType($_, $needed) foreach (reverse @{$interface->{TYPES}}); + foreach (reverse @{$interface->{TYPES}}) { + if (has_property($_, "public")) { + $needed->{"pull\_$_->{NAME}"} = $needed->{"push\_$_->{NAME}"} = + $needed->{"print\_$_->{NAME}"} = 1; + } + + NeededType($_, $needed, "pull") if ($needed->{"pull_$_->{NAME}"}); + NeededType($_, $needed, "push") if ($needed->{"push_$_->{NAME}"}); + NeededType($_, $needed, "print") if ($needed->{"print_$_->{NAME}"}); + if (has_property($_, "gensize")) { + $needed->{"ndr_size_$_->{NAME}"} = 1; + } + } } 1; -- cgit From 613d1c1fb9d86120c062ab640b69842bd246187c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 21 Feb 2007 10:55:03 +0000 Subject: r21486: Remove spurious semicolons. (This used to be commit d2307f3f7e364a2d17f48301a921a532ae313986) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 7e52dbc2ee..39e6c4233c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -128,10 +128,10 @@ sub HeaderEnum($$) } pidl "\n"; $tab_depth--; - pidl "};\n"; + pidl "}\n"; pidl "#else\n"; my $count = 0; - pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n"; + pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF}\n"; my $with_val = 0; my $without_val = 0; foreach my $e (@{$enum->{ELEMENTS}}) { @@ -154,7 +154,6 @@ sub HeaderEnum($$) pidl "#define $name ( $value )\n"; } pidl "#endif\n"; - pidl "\n"; } ##################################################################### @@ -357,7 +356,11 @@ sub HeaderInterface($) HeaderUnion($d, $d->{NAME}) if ($d->{TYPE} eq "UNION"); HeaderEnum($d, $d->{NAME}) if ($d->{TYPE} eq "ENUM"); HeaderBitmap($d, $d->{NAME}) if ($d->{TYPE} eq "BITMAP"); - pidl ";\n\n"; + pidl ";\n\n" if ($d->{TYPE} eq "BITMAP" or + $d->{TYPE} eq "STRUCT" or + $d->{TYPE} eq "TYPEDEF" or + $d->{TYPE} eq "UNION" or + $d->{TYPE} eq "ENUM"); } foreach my $d (@{$interface->{DATA}}) { -- cgit From a074602362acd881e3e7ac3b987df93fee3cb9f8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 21 Feb 2007 11:32:48 +0000 Subject: r21487: Fix warning when using anonymous types, initial work on nested type support in ejs. (This used to be commit a396c5de12cd958fe0457fa5372e539132ad7ed9) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 34 +++++++++++++++++++----- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 3 +++ 2 files changed, 31 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 13a8460a81..0d2f0fc8f2 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -157,7 +157,15 @@ sub EjsPullScalar($$$$$) and (defined($pl) and $pl->{TYPE} eq "POINTER")) { $var = get_pointer_to($var); } - pidl "NDR_CHECK(ejs_pull_$e->{TYPE}(ejs, v, $name, $var));"; + + my $t; + if (ref($e->{TYPE}) eq "HASH") { + $t = "$e->{TYPE}->{TYPE}_$e->{TYPE}->{NAME}"; + } else { + $t = $e->{TYPE}; + } + + pidl "NDR_CHECK(ejs_pull_$t(ejs, v, $name, $var));"; } ########################### @@ -449,7 +457,15 @@ sub EjsPushScalar($$$$$) or (defined($pl) and $pl->{TYPE} eq "POINTER")) { $var = get_pointer_to($var); } - pidl "NDR_CHECK(ejs_push_$e->{TYPE}(ejs, v, $name, $var));"; + + my $t; + if (ref($e->{TYPE}) eq "HASH") { + $t = "$e->{TYPE}->{TYPE}_$e->{TYPE}->{NAME}"; + } else { + $t = $e->{TYPE}; + } + + pidl "NDR_CHECK(ejs_push_$t(ejs, v, $name, $var));"; } ########################### @@ -877,11 +893,17 @@ sub NeededTypedef($$) foreach (@{$t->{DATA}->{ELEMENTS}}) { next if (has_property($_, "subcontext")); #FIXME: Support subcontexts - unless (defined($needed->{"pull_$_->{TYPE}"})) { - $needed->{"pull_$_->{TYPE}"} = $needed->{"pull_$t->{NAME}"}; + my $n; + if (ref($_->{TYPE}) eq "HASH") { + $n = "$_->{TYPE}->{TYPE}_$_->{TYPE}->{NAME}"; + } else { + $n = $_->{TYPE}; + } + unless (defined($needed->{"pull_$n"})) { + $needed->{"pull_$n"} = $needed->{"pull_$t->{NAME}"}; } - unless (defined($needed->{"push_$_->{TYPE}"})) { - $needed->{"push_$_->{TYPE}"} = $needed->{"push_$t->{NAME}"}; + unless (defined($needed->{"push_$n"})) { + $needed->{"push_$n"} = $needed->{"push_$t->{NAME}"}; } } } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 2ae4a3b17e..b6209d9f9a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2651,6 +2651,9 @@ sub NeededElement($$$) return if ($e->{TYPE} eq "EMPTY"); + return if (ref($e->{TYPE}) eq "HASH" and + not defined($e->{TYPE}->{NAME})); + my ($t, $rt); if (ref($e->{TYPE}) eq "HASH") { $t = $e->{TYPE}->{TYPE}."_".$e->{TYPE}->{NAME}; -- cgit From b76461f425fbfe425a7c0773626f53e394b48386 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 21 Feb 2007 12:35:21 +0000 Subject: r21490: Add some tests for the EJS code More work on supporting nested types in EJS. (This used to be commit cb7faeab88952b59add1c814e1881ee9bb88b7ec) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 105 ++++++++++-------------------- 1 file changed, 33 insertions(+), 72 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 0d2f0fc8f2..910b47a4a1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -6,16 +6,23 @@ package Parse::Pidl::Samba4::EJS; +use Exporter; +@ISA = qw(Exporter); +@EXPORT_OK = qw(get_pointer_to get_value_of check_null_pointer $res + $res_hdr fn_declare); + use strict; use Parse::Pidl::Typelist; use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel); +use Parse::Pidl::Samba4::NDR::Parser qw(GenerateStructEnv GenerateFunctionInEnv + GenerateFunctionOutEnv); use vars qw($VERSION); $VERSION = '0.01'; -my $res; -my $res_hdr; +our $res; +our $res_hdr; my %constants; @@ -46,52 +53,6 @@ sub deindent() $tabs = substr($tabs, 0, -1); } -sub GenerateStructEnv($) -{ - my $x = shift; - my %env; - - foreach my $e (@{$x->{ELEMENTS}}) { - if ($e->{NAME}) { - $env{$e->{NAME}} = "r->$e->{NAME}"; - } - } - - $env{"this"} = "r"; - - return \%env; -} - -sub GenerateFunctionInEnv($) -{ - my $fn = shift; - my %env; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->in.$e->{NAME}"; - } - } - - return \%env; -} - -sub GenerateFunctionOutEnv($) -{ - my $fn = shift; - my %env; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/out/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->out.$e->{NAME}"; - } elsif (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->in.$e->{NAME}"; - } - } - - return \%env; -} - sub get_pointer_to($) { my $var_name = shift; @@ -127,7 +88,6 @@ sub check_null_pointer($) } } - ##################################################################### # work out is a parse function should be declared static or not sub fn_declare($$) @@ -291,7 +251,7 @@ sub EjsPullElementTop($$) sub EjsStructPull($$) { my ($name, $d) = @_; - my $env = GenerateStructEnv($d); + my $env = GenerateStructEnv($d, "r"); fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)"); pidl "{"; indent; @@ -391,7 +351,6 @@ sub EjsBitmapPull($$) pidl "}"; } - ########################### # generate a structure pull sub EjsTypedefPull($) @@ -580,7 +539,7 @@ sub EjsPushElementTop($$) sub EjsStructPush($$) { my ($name, $d) = @_; - my $env = GenerateStructEnv($d); + my $env = GenerateStructEnv($d, "r"); fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)"); pidl "{"; indent; @@ -879,32 +838,25 @@ sub NeededFunction($$) } } -sub NeededTypedef($$) +sub NeededType($$$) { - my ($t,$needed) = @_; + sub NeededType($$$); + my ($t,$needed,$req) = @_; - if (has_property($t, "public")) { - $needed->{"pull_$t->{NAME}"} = not has_property($t, "noejs"); - $needed->{"push_$t->{NAME}"} = not has_property($t, "noejs"); - } + NeededType($t->{DATA}, $needed, $req) if ($t->{TYPE} eq "TYPEDEF"); - return if (($t->{DATA}->{TYPE} ne "STRUCT") and - ($t->{DATA}->{TYPE} ne "UNION")); + return if (($t->{TYPE} ne "STRUCT") and + ($t->{TYPE} ne "UNION")); - foreach (@{$t->{DATA}->{ELEMENTS}}) { + foreach (@{$t->{ELEMENTS}}) { next if (has_property($_, "subcontext")); #FIXME: Support subcontexts my $n; - if (ref($_->{TYPE}) eq "HASH") { - $n = "$_->{TYPE}->{TYPE}_$_->{TYPE}->{NAME}"; - } else { - $n = $_->{TYPE}; - } - unless (defined($needed->{"pull_$n"})) { - $needed->{"pull_$n"} = $needed->{"pull_$t->{NAME}"}; - } - unless (defined($needed->{"push_$n"})) { - $needed->{"push_$n"} = $needed->{"push_$t->{NAME}"}; + if (ref($_->{TYPE}) eq "HASH" and defined($_->{TYPE}->{NAME})) { + $needed->{"$req\_$_->{TYPE}->{TYPE}_$_->{TYPE}->{NAME}"} = 1; + } elsif (ref($_->{TYPE}) ne "HASH") { + $needed->{$req."_".$_->{TYPE}} = 1; } + NeededType($_->{TYPE}, $needed, $req) if (ref($_->{TYPE}) eq "HASH"); } } @@ -915,7 +867,16 @@ sub NeededInterface($$) my ($interface,$needed) = @_; NeededFunction($_, $needed) foreach (@{$interface->{FUNCTIONS}}); - NeededTypedef($_, $needed) foreach (reverse @{$interface->{TYPES}}); + + foreach (reverse @{$interface->{TYPES}}) { + if (has_property($_, "public")) { + $needed->{"pull_$_->{NAME}"} = not has_property($_, "noejs"); + $needed->{"push_$_->{NAME}"} = not has_property($_, "noejs"); + } + + NeededType($_, $needed, "pull") if ($needed->{"pull_$_->{NAME}"}); + NeededType($_, $needed, "push") if ($needed->{"push_$_->{NAME}"}); + } } 1; -- cgit From 79a1b1a928f0f8cdd6c60d74291bf048c8484f0b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 21 Feb 2007 14:35:25 +0000 Subject: r21492: Finish work on nested type support in EJS. (This used to be commit e88055b76a3d81fcc40773d880f76a1c3f53fbf0) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 243 ++++++++++++++------------- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 4 +- 2 files changed, 127 insertions(+), 120 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 910b47a4a1..9edd2a4a33 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -110,22 +110,25 @@ sub EjsPullScalar($$$$$) return if (has_property($e, "value")); - my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); + if (ref($e->{TYPE}) eq "HASH" and not defined($e->{TYPE}->{NAME})) { + EjsTypePull($e->{TYPE}, $var); + } else { + my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); $var = get_pointer_to($var); # have to handle strings specially :( - if (Parse::Pidl::Typelist::scalar_is_reference($e->{TYPE}) - and (defined($pl) and $pl->{TYPE} eq "POINTER")) { + if (Parse::Pidl::Typelist::scalar_is_reference($e->{TYPE}) + and (defined($pl) and $pl->{TYPE} eq "POINTER")) { $var = get_pointer_to($var); } - my $t; - if (ref($e->{TYPE}) eq "HASH") { - $t = "$e->{TYPE}->{TYPE}_$e->{TYPE}->{NAME}"; - } else { - $t = $e->{TYPE}; + my $t; + if (ref($e->{TYPE}) eq "HASH") { + $t = "$e->{TYPE}->{TYPE}_$e->{TYPE}->{NAME}"; + } else { + $t = $e->{TYPE}; + } + pidl "NDR_CHECK(ejs_pull_$t(ejs, v, $name, $var));"; } - - pidl "NDR_CHECK(ejs_pull_$t(ejs, v, $name, $var));"; } ########################### @@ -163,7 +166,6 @@ sub EjsPullString($$$$$) pidl "NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));"; } - ########################### # pull an array element sub EjsPullArray($$$$$) @@ -250,29 +252,20 @@ sub EjsPullElementTop($$) # pull a struct sub EjsStructPull($$) { - my ($name, $d) = @_; - my $env = GenerateStructEnv($d, "r"); - fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)"); - pidl "{"; - indent; + my ($d, $varname) = @_; + my $env = GenerateStructEnv($d, $varname); pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; - foreach my $e (@{$d->{ELEMENTS}}) { + foreach my $e (@{$d->{ELEMENTS}}) { EjsPullElementTop($e, $env); } - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; } ########################### # pull a union sub EjsUnionPull($$) { - my ($name, $d) = @_; + my ($d, $varname) = @_; my $have_default = 0; - fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)"); - pidl "{"; - indent; pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; pidl "switch (ejs->switch_var) {"; indent; @@ -283,7 +276,7 @@ sub EjsUnionPull($$) pidl "$e->{CASE}:"; indent; if ($e->{TYPE} ne "EMPTY") { - EjsPullElementTop($e, { $e->{NAME} => "r->$e->{NAME}"}); + EjsPullElementTop($e, { $e->{NAME} => "$varname->$e->{NAME}"}); } pidl "break;"; deindent; @@ -296,9 +289,6 @@ sub EjsUnionPull($$) } deindent; pidl "}"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; } ############################################## @@ -323,50 +313,66 @@ sub EjsEnumConstant($) # pull a enum sub EjsEnumPull($$) { - my ($name, $d) = @_; + my ($d, $varname) = @_; EjsEnumConstant($d); - fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)"); - pidl "{"; - indent; pidl "unsigned e;"; pidl "NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));"; - pidl "*r = e;"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; + pidl "*$varname = e;"; } ########################### # pull a bitmap sub EjsBitmapPull($$) { - my ($name, $d) = @_; + my ($d, $varname) = @_; my $type_fn = $d->{BASE_TYPE}; - my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); - fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)"); + pidl "NDR_CHECK(ejs_pull_$type_fn(ejs, v, name, $varname));"; +} + +sub EjsTypePullFunction($$) +{ + sub EjsTypePullFunction($$); + my ($d, $name) = @_; + return if (has_property($d, "noejs")); + + if ($d->{TYPE} eq "TYPEDEF") { + EjsTypePullFunction($d->{DATA}, $name); + return; + } + + if ($d->{TYPE} eq "STRUCT") { + fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)"); + } elsif ($d->{TYPE} eq "UNION") { + fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)"); + } elsif ($d->{TYPE} eq "ENUM") { + fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)"); + } elsif ($d->{TYPE} eq "BITMAP") { + my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); + fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)"); + } pidl "{"; indent; - pidl "return ejs_pull_$type_fn(ejs, v, name, r);"; + + EjsTypePull($d, "r"); + + pidl "return NT_STATUS_OK;"; deindent; - pidl "}"; + pidl "}\n"; } -########################### -# generate a structure pull -sub EjsTypedefPull($) +sub EjsTypePull($$) { - my $d = shift; - return if (has_property($d, "noejs")); - if ($d->{DATA}->{TYPE} eq 'STRUCT') { - EjsStructPull($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'UNION') { - EjsUnionPull($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'ENUM') { - EjsEnumPull($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') { - EjsBitmapPull($d->{NAME}, $d->{DATA}); + my ($d, $varname) = @_; + if ($d->{TYPE} eq 'STRUCT') { + EjsStructPull($d, $varname); + } elsif ($d->{TYPE} eq 'UNION') { + EjsUnionPull($d, $varname); + } elsif ($d->{TYPE} eq 'ENUM') { + EjsEnumPull($d, $varname); + } elsif ($d->{TYPE} eq 'BITMAP') { + EjsBitmapPull($d, $varname); } else { - warn "Unhandled pull typedef $d->{NAME} of type $d->{DATA}->{TYPE}"; + warn "Unhandled pull $varname of type $d->{TYPE}"; } } @@ -403,28 +409,32 @@ sub EjsPullFunction($) pidl "}\n"; } - ########################### # push a scalar element sub EjsPushScalar($$$$$) { my ($e, $l, $var, $name, $env) = @_; - # have to handle strings specially :( + + if (ref($e->{TYPE}) eq "HASH" and not defined($e->{TYPE}->{NAME})) { + EjsTypePush($e->{TYPE}, get_pointer_to($var)); + } else { + # have to handle strings specially :( my $pl = GetPrevLevel($e, $l); - if ((not Parse::Pidl::Typelist::scalar_is_reference($e->{TYPE})) - or (defined($pl) and $pl->{TYPE} eq "POINTER")) { - $var = get_pointer_to($var); - } + if ((not Parse::Pidl::Typelist::scalar_is_reference($e->{TYPE})) + or (defined($pl) and $pl->{TYPE} eq "POINTER")) { + $var = get_pointer_to($var); + } - my $t; - if (ref($e->{TYPE}) eq "HASH") { - $t = "$e->{TYPE}->{TYPE}_$e->{TYPE}->{NAME}"; - } else { - $t = $e->{TYPE}; - } + my $t; + if (ref($e->{TYPE}) eq "HASH") { + $t = "$e->{TYPE}->{TYPE}_$e->{TYPE}->{NAME}"; + } else { + $t = $e->{TYPE}; + } - pidl "NDR_CHECK(ejs_push_$t(ejs, v, $name, $var));"; + pidl "NDR_CHECK(ejs_push_$t(ejs, v, $name, $var));"; + } } ########################### @@ -470,7 +480,6 @@ sub EjsPushSwitch($$$$$) EjsPushElement($e, GetNextLevel($e, $l), $var, $name, $env); } - ########################### # push an array element sub EjsPushArray($$$$$) @@ -538,29 +547,20 @@ sub EjsPushElementTop($$) # push a struct sub EjsStructPush($$) { - my ($name, $d) = @_; - my $env = GenerateStructEnv($d, "r"); - fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)"); - pidl "{"; - indent; + my ($d, $varname) = @_; + my $env = GenerateStructEnv($d, $varname); pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; foreach my $e (@{$d->{ELEMENTS}}) { EjsPushElementTop($e, $env); } - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; } ########################### # push a union sub EjsUnionPush($$) { - my ($name, $d) = @_; + my ($d, $varname) = @_; my $have_default = 0; - fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)"); - pidl "{"; - indent; pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; pidl "switch (ejs->switch_var) {"; indent; @@ -571,7 +571,7 @@ sub EjsUnionPush($$) pidl "$e->{CASE}:"; indent; if ($e->{TYPE} ne "EMPTY") { - EjsPushElementTop($e, { $e->{NAME} => "r->$e->{NAME}"} ); + EjsPushElementTop($e, { $e->{NAME} => "$varname->$e->{NAME}"} ); } pidl "break;"; deindent; @@ -584,35 +584,24 @@ sub EjsUnionPush($$) } deindent; pidl "}"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; } ########################### # push a enum sub EjsEnumPush($$) { - my $name = shift; - my $d = shift; + my ($d, $varname) = @_; EjsEnumConstant($d); - fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)"); - pidl "{"; - indent; - pidl "unsigned e = *r;"; + pidl "unsigned e = ".get_value_of($varname).";"; pidl "NDR_CHECK(ejs_push_enum(ejs, v, name, &e));"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; } ########################### # push a bitmap sub EjsBitmapPush($$) { - my ($name, $d) = @_; + my ($d, $varname) = @_; my $type_fn = $d->{BASE_TYPE}; - my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); # put the bitmap elements in the constants array foreach my $e (@{$d->{ELEMENTS}}) { if ($e =~ /^(\w*)\s*(.*)\s*$/) { @@ -621,36 +610,55 @@ sub EjsBitmapPush($$) $constants{$bname} = $v; } } - fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)"); + pidl "NDR_CHECK(ejs_push_$type_fn(ejs, v, name, $varname));"; +} + +sub EjsTypePushFunction($$) +{ + sub EjsTypePushFunction($$); + my ($d, $name) = @_; + return if (has_property($d, "noejs")); + + if ($d->{TYPE} eq "TYPEDEF") { + EjsTypePushFunction($d->{DATA}, $name); + return; + } + + if ($d->{TYPE} eq "STRUCT") { + fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)"); + } elsif ($d->{TYPE} eq "UNION") { + fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)"); + } elsif ($d->{TYPE} eq "ENUM") { + fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)"); + } elsif ($d->{TYPE} eq "BITMAP") { + my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); + fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)"); + } pidl "{"; indent; - pidl "return ejs_push_$type_fn(ejs, v, name, r);"; + EjsTypePush($d, "r"); + pidl "return NT_STATUS_OK;"; deindent; - pidl "}"; + pidl "}\n"; } - -########################### -# generate a structure push -sub EjsTypedefPush($) +sub EjsTypePush($$) { - my $d = shift; - return if (has_property($d, "noejs")); + my ($d, $varname) = @_; - if ($d->{DATA}->{TYPE} eq 'STRUCT') { - EjsStructPush($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'UNION') { - EjsUnionPush($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'ENUM') { - EjsEnumPush($d->{NAME}, $d->{DATA}); - } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') { - EjsBitmapPush($d->{NAME}, $d->{DATA}); + if ($d->{TYPE} eq 'STRUCT') { + EjsStructPush($d, $varname); + } elsif ($d->{TYPE} eq 'UNION') { + EjsUnionPush($d, $varname); + } elsif ($d->{TYPE} eq 'ENUM') { + EjsEnumPush($d, $varname); + } elsif ($d->{TYPE} eq 'BITMAP') { + EjsBitmapPush($d, $varname); } else { - warn "Unhandled push typedef $d->{NAME} of type $d->{DATA}->{TYPE}"; + warn "Unhandled push $varname of type $d->{TYPE}"; } } - ##################### # generate a function sub EjsPushFunction($) @@ -678,7 +686,6 @@ sub EjsPushFunction($) pidl "}\n"; } - ################################# # generate a ejs mapping function sub EjsFunction($$) @@ -730,8 +737,8 @@ sub EjsInterface($$) pidl_hdr "\n"; foreach my $d (@{$interface->{TYPES}}) { - ($needed->{"push_$d->{NAME}"}) && EjsTypedefPush($d); - ($needed->{"pull_$d->{NAME}"}) && EjsTypedefPull($d); + ($needed->{"push_$d->{NAME}"}) && EjsTypePushFunction($d, $d->{NAME}); + ($needed->{"pull_$d->{NAME}"}) && EjsTypePullFunction($d, $d->{NAME}); } foreach my $d (@{$interface->{FUNCTIONS}}) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 39e6c4233c..11ecc17001 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Samba4::Header; use strict; -use Parse::Pidl::Typelist qw(mapTypeName); +use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::Samba4 qw(is_intree); @@ -61,7 +61,7 @@ sub HeaderElement($) pidl " "; my $numstar = $element->{POINTERS}; if ($numstar >= 1) { - $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE}); + $numstar-- if (scalar_is_reference($element->{TYPE})); } foreach (@{$element->{ARRAY_LEN}}) { -- cgit From f487c24a79223c295afc60e05a0fac9794c3a22d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 21 Feb 2007 20:59:01 +0000 Subject: r21493: Patch from Ronnie Sahlberg. From his email: This patch changes the function name and signature that pidl generate a call for when dissecting a policy handle to a new, more PIDL-friendly function. It also stores the procedure name in a new pinfo-> field so that helpers that want to know the procedure name can finbd out easily. The new PIDL helper function for policy handles use this new field and will show OpenHKU(<...>) opened in frame X closed in frame Y for the policy handle. (This used to be commit 0c4fb484f0e515eb4055c58cd73ca798a8c46d69) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 9ba6f2f3e0..c61a05e90c 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -427,7 +427,7 @@ sub Function($$$) PrintIdl DumpFunction($fn->{ORIGINAL}); pidl_fn_start "$ifname\_dissect\_$fn_name\_response"; pidl_code "static int"; - pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; + pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo, proto_tree *tree _U_, guint8 *drep _U_)"; pidl_code "{"; indent; if ( not defined($fn->{RETURN_TYPE})) { @@ -446,6 +446,7 @@ sub Function($$$) error($fn, "unknown return type `$fn->{RETURN_TYPE}'"); } + pidl_code "pinfo->dcerpc_procedure_name=\"${fn_name}\";"; foreach (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$_->{DIRECTION}})) { pidl_code "$dissectornames{$_->{NAME}}"; @@ -491,9 +492,10 @@ sub Function($$$) pidl_fn_start "$ifname\_dissect\_$fn_name\_request"; pidl_code "static int"; - pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; + pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo, proto_tree *tree _U_, guint8 *drep _U_)"; pidl_code "{"; indent; + pidl_code "pinfo->dcerpc_procedure_name=\"${fn_name}\";"; foreach (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$_->{DIRECTION}})) { pidl_code "$dissectornames{$_->{NAME}}"; @@ -849,7 +851,7 @@ sub Initialize($) register_type("long", "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4); register_type("dlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8); register_type("GUID", "offset = dissect_ndr_uuid_t(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4); - register_type("policy_handle", "offset = dissect_nt_policy_hnd(tvb, offset, pinfo, tree, drep, \@HF\@, NULL, NULL, \@PARAM\@&0x01, \@PARAM\@&0x02);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); + register_type("policy_handle", "offset = PIDL_dissect_policy_hnd(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); register_type("NTTIME", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); register_type("NTTIME_hyper", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); register_type("time_t", "offset = dissect_ndr_time_t(tvb, offset, pinfo,tree, drep, \@HF\@, NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4); -- cgit From 882c5a8b43632517d7b6340b17174721a8b7a388 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 Feb 2007 09:35:32 +0000 Subject: r21531: Use pidl-specific utility functions. Patch from Ronnie Sahlberg (This used to be commit e6fdcdf95e984a254cebd197269cf3e911009f02) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index c61a05e90c..72d353aa14 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -841,14 +841,14 @@ sub Initialize($) foreach my $bytes (qw(1 2 4 8)) { my $bits = $bytes * 8; - register_type("uint$bits", "offset = dissect_ndr_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@,NULL);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes); - register_type("int$bits", "offset = dissect_ndr_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes); + register_type("uint$bits", "offset = PIDL_dissect_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes); + register_type("int$bits", "offset = PIDL_dissect_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes); } register_type("udlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4); - register_type("bool8", "offset = dissect_ndr_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); - register_type("char", "offset = dissect_ndr_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1); - register_type("long", "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4); + register_type("bool8", "offset = PIDL_dissect_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + register_type("char", "offset = PIDL_dissect_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + register_type("long", "offset = PIDL_dissect_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT32", "BASE_DEC", 0, "NULL", 4); register_type("dlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8); register_type("GUID", "offset = dissect_ndr_uuid_t(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4); register_type("policy_handle", "offset = PIDL_dissect_policy_hnd(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); @@ -864,9 +864,9 @@ sub Initialize($) offset = dissect_ndr_nt_SID_with_options(tvb, offset, pinfo, tree, drep, param); ","FT_STRING", "BASE_DEC", 0, "NULL", 4); register_type("WERROR", - "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(WERR_errors)", 4); + "offset = PIDL_dissect_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_UINT32", "BASE_DEC", 0, "VALS(WERR_errors)", 4); register_type("NTSTATUS", - "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4); + "offset = PIDL_dissect_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4); } -- cgit From cb8fceab28c71c7513e0732e1a9e2c9f61bfa31b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 Feb 2007 09:55:57 +0000 Subject: r21532: Add tests for StripPrefixes utility function. (This used to be commit 365052555e0e9224bdfda0c2a10f78cbeee5b06c) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 72d353aa14..914d54d985 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -18,7 +18,7 @@ package Parse::Pidl::Wireshark::NDR; use Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(field2name @ett %res PrintIdl); +@EXPORT_OK = qw(field2name @ett %res PrintIdl StripPrefixes); use strict; use Parse::Pidl qw(error warning); @@ -46,11 +46,11 @@ my %ptrtype_mappings = ( "ptr" => "NDR_POINTER_PTR" ); -sub StripPrefixes($) +sub StripPrefixes($$) { - my ($s) = @_; + my ($s, $prefixes) = @_; - foreach (@{$conformance->{strip_prefixes}}) { + foreach (@$prefixes) { $s =~ s/^$_\_//g; } @@ -135,9 +135,9 @@ sub Enum($$$) { my ($e,$name,$ifname) = @_; my $valsstring = "$ifname\_$name\_vals"; - my $dissectorname = "$ifname\_dissect\_enum\_".StripPrefixes($name); + my $dissectorname = "$ifname\_dissect\_enum\_".StripPrefixes($name, $conformance->{strip_prefixes}); - return if (defined($conformance->{noemit}->{StripPrefixes($name)})); + return if (defined($conformance->{noemit}->{StripPrefixes($name, $conformance->{strip_prefixes})})); foreach (@{$e->{ELEMENTS}}) { if (/([^=]*)=(.*)/) { @@ -176,7 +176,7 @@ sub Enum($$$) sub Bitmap($$$) { my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_bitmap\_".StripPrefixes($name); + my $dissectorname = "$ifname\_dissect\_bitmap\_".StripPrefixes($name, $conformance->{strip_prefixes}); register_ett("ett_$ifname\_$name"); @@ -272,7 +272,7 @@ sub ElementLevel($$$$$$) } elsif ($l->{LEVEL} eq "EMBEDDED") { $type = "embedded"; } - pidl_code "offset = dissect_ndr_$type\_pointer(tvb, offset, pinfo, tree, drep, $myname\_, $ptrtype_mappings{$l->{POINTER_TYPE}}, \"Pointer to ".field2name(StripPrefixes($e->{NAME})) . " ($e->{TYPE})\",$hf);"; + pidl_code "offset = dissect_ndr_$type\_pointer(tvb, offset, pinfo, tree, drep, $myname\_, $ptrtype_mappings{$l->{POINTER_TYPE}}, \"Pointer to ".field2name(StripPrefixes($e->{NAME}, $conformance->{strip_prefixes})) . " ($e->{TYPE})\",$hf);"; } elsif ($l->{TYPE} eq "ARRAY") { if ($l->{IS_INLINE}) { error($e->{ORIGINAL}, "Inline arrays not supported"); @@ -353,7 +353,7 @@ sub Element($$$) { my ($e,$pn,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_element\_".StripPrefixes($pn)."\_".StripPrefixes($e->{NAME}); + my $dissectorname = "$ifname\_dissect\_element\_".StripPrefixes($pn, $conformance->{strip_prefixes})."\_".StripPrefixes($e->{NAME}, $conformance->{strip_prefixes}); my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; @@ -381,7 +381,7 @@ sub Element($$$) my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", $type->{FT_TYPE}, $type->{BASE_TYPE}, $type->{VALSSTRING}, $type->{MASK}, ""); $hf_used{$hf} = 1; - my $eltname = StripPrefixes($pn) . ".$e->{NAME}"; + my $eltname = StripPrefixes($pn, $conformance->{strip_prefixes}) . ".$e->{NAME}"; if (defined($conformance->{noemit}->{$eltname})) { return $call_code; } @@ -513,9 +513,9 @@ sub Function($$$) sub Struct($$$) { my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_struct\_".StripPrefixes($name); + my $dissectorname = "$ifname\_dissect\_struct\_".StripPrefixes($name, $conformance->{strip_prefixes}); - return if (defined($conformance->{noemit}->{StripPrefixes($name)})); + return if (defined($conformance->{noemit}->{StripPrefixes($name, $conformance->{strip_prefixes})})); register_ett("ett_$ifname\_$name"); @@ -563,9 +563,9 @@ sub Union($$$) { my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect_".StripPrefixes($name); + my $dissectorname = "$ifname\_dissect_".StripPrefixes($name, $conformance->{strip_prefixes}); - return if (defined($conformance->{noemit}->{StripPrefixes($name)})); + return if (defined($conformance->{noemit}->{StripPrefixes($name, $conformance->{strip_prefixes})})); register_ett("ett_$ifname\_$name"); -- cgit From b8c219a270e50f165a326c3657618c78e2ff58c5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 26 Feb 2007 01:03:19 +0000 Subject: r21534: Add some more tests for wireshark. (This used to be commit b10432096181cf8e7d729e58a5ab54fac5eaa5fe) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 1 - source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 6 +++--- 2 files changed, 3 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index b6209d9f9a..e1a19a7d3b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2479,7 +2479,6 @@ sub ParseTypePull($$$$) pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); } - sub ParseTypePullFunction($$) { my ($e, $varname) = @_; diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 914d54d985..db7d2cf241 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -18,7 +18,7 @@ package Parse::Pidl::Wireshark::NDR; use Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(field2name @ett %res PrintIdl StripPrefixes); +@EXPORT_OK = qw(field2name @ett %res PrintIdl StripPrefixes %hf_used RegisterInterfaceHandoff $conformance register_hf_field CheckUsed); use strict; use Parse::Pidl qw(error warning); @@ -34,11 +34,11 @@ $VERSION = '0.01'; our @ett; -my %hf_used = (); +our %hf_used = (); my %return_types = (); my %dissector_used = (); -my $conformance = undef; +our $conformance = undef; my %ptrtype_mappings = ( "unique" => "NDR_POINTER_UNIQUE", -- cgit From 2916cc628ad18ea16e8f1b8521c42963cc7b0a79 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Feb 2007 12:46:19 +0000 Subject: r21555: Some tests for TYPE in wireshark conformance files. (This used to be commit 2a44c8c9c296462350fcae1960265a6ef0f317d8) --- source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm index 9798c7c552..44eb77f836 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm @@ -96,7 +96,7 @@ use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); -@EXPORT_OK = qw(ReadConformance ReadConformanceFH); +@EXPORT_OK = qw(ReadConformance ReadConformanceFH valid_ft_type valid_base_type); use strict; -- cgit From 6f3c968e64ef5677759dafcc88092d3db2b4c6e9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Feb 2007 20:35:56 +0000 Subject: r21567: Add some more wireshark tests. (This used to be commit 40e2956058fe4aaebf3f7269bce90339d7faf24f) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index db7d2cf241..0374b60132 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -18,7 +18,7 @@ package Parse::Pidl::Wireshark::NDR; use Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(field2name @ett %res PrintIdl StripPrefixes %hf_used RegisterInterfaceHandoff $conformance register_hf_field CheckUsed); +@EXPORT_OK = qw(field2name @ett %res PrintIdl StripPrefixes %hf_used RegisterInterfaceHandoff $conformance register_hf_field CheckUsed ProcessImport ProcessInclude find_type DumpEttList DumpEttDeclaration DumpHfList DumpHfDeclaration DumpFunctionTable); use strict; use Parse::Pidl qw(error warning); @@ -671,7 +671,7 @@ sub RegisterInterface($) indent; $res{code}.=DumpHfList()."\n"; - $res{code}.="\n".DumpEttList()."\n"; + $res{code}.="\n".DumpEttList(@ett)."\n"; if (defined($x->{UUID})) { # These can be changed to non-pidl_code names if the old dissectors @@ -730,8 +730,9 @@ sub ProcessInclude { my @includes = @_; foreach (@includes) { - pidl_hdr "#include \"$_\"\n"; + pidl_hdr "#include \"$_\""; } + pidl_hdr ""; } sub ProcessImport @@ -741,8 +742,9 @@ sub ProcessImport next if($_ eq "security"); s/\.idl\"$//; s/^\"//; - pidl_hdr "#include \"packet-dcerpc-$_\.h\"\n"; + pidl_hdr "#include \"packet-dcerpc-$_\.h\""; } + pidl_hdr ""; } sub ProcessInterface($) @@ -924,7 +926,7 @@ sub Parse($$$$) ProcessInclude(@{$_->{PATHS}}) if ($_->{TYPE} eq "INCLUDE"); } - $res{ett} = DumpEttDeclaration(); + $res{ett} = DumpEttDeclaration(@ett); $res{hf} = DumpHfDeclaration(); my $parser = $notice; @@ -956,8 +958,9 @@ sub register_ett($) push (@ett, $name); } -sub DumpEttList() +sub DumpEttList { + my @ett = @_; my $res = "\tstatic gint *ett[] = {\n"; foreach (@ett) { $res .= "\t\t&$_,\n"; @@ -966,8 +969,9 @@ sub DumpEttList() return "$res\t};\n"; } -sub DumpEttDeclaration() +sub DumpEttDeclaration { + my @ett = @_; my $res = "\n/* Ett declarations */\n"; foreach (@ett) { $res .= "static gint $_ = -1;\n"; -- cgit From f5f0e502b3eadacd3ef1ee382f63e02cbbf9ae58 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Feb 2007 21:37:31 +0000 Subject: r21568: More tests. (This used to be commit c7bde9c1f537cbcf8e71177e6c3969699c046ecb) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 0374b60132..3c38801fae 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -18,7 +18,7 @@ package Parse::Pidl::Wireshark::NDR; use Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(field2name @ett %res PrintIdl StripPrefixes %hf_used RegisterInterfaceHandoff $conformance register_hf_field CheckUsed ProcessImport ProcessInclude find_type DumpEttList DumpEttDeclaration DumpHfList DumpHfDeclaration DumpFunctionTable); +@EXPORT_OK = qw(field2name @ett %res PrintIdl StripPrefixes %hf_used RegisterInterfaceHandoff $conformance register_hf_field CheckUsed ProcessImport ProcessInclude find_type DumpEttList DumpEttDeclaration DumpHfList DumpHfDeclaration DumpFunctionTable register_type register_ett); use strict; use Parse::Pidl qw(error warning); -- cgit From d7a7b7fb0c423c461c24e8157ad926d0cee07da1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Feb 2007 23:47:07 +0000 Subject: r21572: More work towards supporting tagged types. (This used to be commit 4d28396f0928444406334888f4bc345e74a380df) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 16 ++++++++++------ source4/pidl/lib/Parse/Pidl/Typelist.pm | 7 +++++++ 2 files changed, 17 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 7322856cdd..3e45bca1ad 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -35,7 +35,7 @@ use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); -@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement); +@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type); use strict; use Parse::Pidl qw(warning fatal); @@ -335,7 +335,11 @@ sub find_largest_alignment($) sub align_type($) { sub align_type($); - my $e = shift; + my ($e) = @_; + + if (ref($e) eq "HASH" and $e->{TYPE} eq "SCALAR") { + return $scalar_alignment->{$e->{NAME}}; + } unless (hasType($e)) { # it must be an external type - all we can do is guess @@ -343,16 +347,16 @@ sub align_type($) return 4; } - my $dt = getType($e)->{DATA}; + my $dt = getType($e); - if ($dt->{TYPE} eq "ENUM") { + if ($dt->{TYPE} eq "TYPEDEF") { + return align_type($dt->{DATA}); + } elsif ($dt->{TYPE} eq "ENUM") { return align_type(Parse::Pidl::Typelist::enum_type_fn($dt)); } elsif ($dt->{TYPE} eq "BITMAP") { return align_type(Parse::Pidl::Typelist::bitmap_type_fn($dt)); } elsif (($dt->{TYPE} eq "STRUCT") or ($dt->{TYPE} eq "UNION")) { return find_largest_alignment($dt); - } elsif ($dt->{TYPE} eq "SCALAR") { - return $scalar_alignment->{$dt->{NAME}}; } die("Unknown data type type $dt->{TYPE}"); diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 55f8390f65..b25ab62e03 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -98,7 +98,9 @@ sub addType($) sub getType($) { my $t = shift; + return ($t) if (ref($t) eq "HASH" and not defined($t->{NAME})); return undef if not hasType($t); + return $types{$t->{NAME}} if (ref($t) eq "HASH"); return $types{$t}; } @@ -113,6 +115,11 @@ sub typeIs($$) sub hasType($) { my $t = shift; + if (ref($t) eq "HASH") { + return 1 if (defined($types{$t->{NAME}}) and + $types{$t->{NAME}}->{TYPE} eq $t->{TYPE}); + return 0; + } return 1 if defined($types{$t}); return 0; } -- cgit From c1aef15fe7e7a7558b6ede11babc1932263814e6 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 28 Feb 2007 00:19:57 +0000 Subject: r21573: Remove more code that assumed all types are typedefs. (This used to be commit bbbfbfa870c44a6148c3d4d47ff409098e85fcc3) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 16 +++++++++------- source4/pidl/lib/Parse/Pidl/Typelist.pm | 18 +++++++++++++----- 2 files changed, 22 insertions(+), 12 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 3e45bca1ad..934aba3a02 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -35,7 +35,7 @@ use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); -@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type); +@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar); use strict; use Parse::Pidl qw(warning fatal); @@ -880,17 +880,19 @@ sub ValidProperties($$) sub mapToScalar($) { + sub mapToScalar($); my $t = shift; + return $t->{NAME} if (ref($t) eq "HASH" and $t->{TYPE} eq "SCALAR"); my $ti = getType($t); if (not defined ($ti)) { return undef; - } elsif ($ti->{DATA}->{TYPE} eq "ENUM") { - return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA}); - } elsif ($ti->{DATA}->{TYPE} eq "BITMAP") { - return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA}); - } elsif ($ti->{DATA}->{TYPE} eq "SCALAR") { - return $t; + } elsif ($ti->{TYPE} eq "TYPEDEF") { + return mapToScalar($ti->{DATA}); + } elsif ($ti->{TYPE} eq "ENUM") { + return Parse::Pidl::Typelist::enum_type_fn($ti); + } elsif ($ti->{TYPE} eq "BITMAP") { + return Parse::Pidl::Typelist::bitmap_type_fn($ti); } return undef; diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index b25ab62e03..72c4b18d0b 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -107,8 +107,13 @@ sub getType($) sub typeIs($$) { my ($t,$tt) = @_; - - return 1 if (hasType($t) and getType($t)->{DATA}->{TYPE} eq $tt); + + if (ref($t) eq "HASH") { + return 1 if ($t->{TYPE} eq $tt); + return 0; + } + return 1 if (hasType($t) and getType($t)->{TYPE} eq "TYPEDEF" and + getType($t)->{DATA}->{TYPE} eq $tt); return 0; } @@ -116,6 +121,7 @@ sub hasType($) { my $t = shift; if (ref($t) eq "HASH") { + return 1 if (not defined($t->{NAME})); return 1 if (defined($types{$t->{NAME}}) and $types{$t->{NAME}}->{TYPE} eq $t->{TYPE}); return 0; @@ -128,10 +134,12 @@ sub is_scalar($) { my $type = shift; - return 0 unless(hasType($type)); + return 1 if (ref($type) eq "HASH" and $type->{TYPE} eq "SCALAR"); - if (my $dt = getType($type)->{DATA}->{TYPE}) { - return 1 if ($dt eq "SCALAR" or $dt eq "ENUM" or $dt eq "BITMAP"); + if (my $dt = getType($type)) { + return is_scalar($dt->{DATA}) if ($dt->{TYPE} eq "TYPEDEF"); + return 1 if ($dt->{TYPE} eq "SCALAR" or $dt->{TYPE} eq "ENUM" or + $dt->{TYPE} eq "BITMAP"); } return 0; -- cgit From a635df47da4c0f8434dc51349600edf9ef0805f1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 28 Feb 2007 00:28:14 +0000 Subject: r21574: Fix handling of DECLARE. (This used to be commit 6a4033464bf269176f928a5b3b7e63aad1bb1e7a) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Typelist.pm | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 934aba3a02..998b19aabf 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -349,7 +349,7 @@ sub align_type($) my $dt = getType($e); - if ($dt->{TYPE} eq "TYPEDEF") { + if ($dt->{TYPE} eq "TYPEDEF" or $dt->{TYPE} eq "DECLARE") { return align_type($dt->{DATA}); } elsif ($dt->{TYPE} eq "ENUM") { return align_type(Parse::Pidl::Typelist::enum_type_fn($dt)); diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 72c4b18d0b..8e311554bc 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -132,6 +132,7 @@ sub hasType($) sub is_scalar($) { + sub is_scalar($); my $type = shift; return 1 if (ref($type) eq "HASH" and $type->{TYPE} eq "SCALAR"); -- cgit From 240b470f4404b6a3517312827b74f775ae85a855 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 28 Feb 2007 00:35:21 +0000 Subject: r21575: Fix handling of is_scalar() for declares. (This used to be commit f0bc29df7297f8f91175091e5f4b14f4ae4b0591) --- source4/pidl/lib/Parse/Pidl/Typelist.pm | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 8e311554bc..e635411f3c 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -138,7 +138,8 @@ sub is_scalar($) return 1 if (ref($type) eq "HASH" and $type->{TYPE} eq "SCALAR"); if (my $dt = getType($type)) { - return is_scalar($dt->{DATA}) if ($dt->{TYPE} eq "TYPEDEF"); + return is_scalar($dt->{DATA}) if ($dt->{TYPE} eq "TYPEDEF" or + $dt->{TYPE} eq "DECLARE"); return 1 if ($dt->{TYPE} eq "SCALAR" or $dt->{TYPE} eq "ENUM" or $dt->{TYPE} eq "BITMAP"); } -- cgit From 4c99e87f9bf30ea3f7e22263ded9f9a0372a73c6 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 28 Feb 2007 01:51:37 +0000 Subject: r21578: Use utility function for naming pull/push/print functions. (This used to be commit e0f626b79c43eb59ad3c6e3fb6c267504764bfef) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 73 +++++++++++++----------- 1 file changed, 39 insertions(+), 34 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index e1a19a7d3b..16d60ace53 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -12,7 +12,7 @@ require Exporter; @EXPORT = qw(is_charset_array); @EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction - NeededElement NeededType $res NeededInterface); + NeededElement NeededType $res NeededInterface TypeFunctionName); use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName); @@ -898,20 +898,14 @@ sub ParseDataPull($$$$$$) defined($l->{DATA_TYPE}->{NAME})) { my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - my $t; - if (ref($l->{DATA_TYPE}) eq "HASH") { - $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; - } else { - $t = $l->{DATA_TYPE}; - } - if (Parse::Pidl::Typelist::scalar_is_reference($t)) { + if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); } $var_name = get_pointer_to($var_name); - pidl "NDR_CHECK(ndr_pull_$t($ndr, $ndr_flags, $var_name));"; + pidl "NDR_CHECK(".TypeFunctionName("ndr_pull", $l->{DATA_TYPE})."($ndr, $ndr_flags, $var_name));"; if (my $range = has_property($e, "range")) { $var_name = get_value_of($var_name); @@ -2457,7 +2451,7 @@ sub ParseTypePushFunction($$) my ($e, $varname) = @_; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}, $varname); - fn_declare("push", $e, "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)") or return; + fn_declare("push", $e, "NTSTATUS ".TypeFunctionName("ndr_push", $e)."(struct ndr_push *ndr, int ndr_flags, $args)") or return; pidl "{"; indent; @@ -2485,7 +2479,7 @@ sub ParseTypePullFunction($$) my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "pull", $e->{NAME}, $varname); - fn_declare("pull", $e, "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)") or return; + fn_declare("pull", $e, "NTSTATUS ".TypeFunctionName("ndr_pull", $e)."(struct ndr_pull *ndr, int ndr_flags, $args)") or return; pidl "{"; indent; @@ -2508,11 +2502,11 @@ sub ParseTypePrintFunction($$) my ($e, $varname) = @_; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "print", $e->{NAME}, $varname); - pidl_hdr "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args);"; + pidl_hdr "void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *ndr, const char *name, $args);"; return if (has_property($e, "noprint")); - pidl "_PUBLIC_ void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)"; + pidl "_PUBLIC_ void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *ndr, const char *name, $args)"; pidl "{"; indent; ParseTypePrint($e, $varname); @@ -2558,26 +2552,27 @@ sub ParseInterface($$) # Typedefs foreach my $d (@{$interface->{TYPES}}) { - ($needed->{"push_$d->{NAME}"}) && ParseTypePushFunction($d, "r"); - ($needed->{"pull_$d->{NAME}"}) && ParseTypePullFunction($d, "r"); - ($needed->{"print_$d->{NAME}"}) && ParseTypePrintFunction($d, "r"); + ($needed->{TypeFunctionName("ndr_push", $d)}) && ParseTypePushFunction($d, "r"); + ($needed->{TypeFunctionName("ndr_pull", $d)}) && ParseTypePullFunction($d, "r"); + ($needed->{TypeFunctionName("ndr_print", $d)}) && ParseTypePrintFunction($d, "r"); # Make sure we don't generate a function twice... - $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = - $needed->{"print_$d->{NAME}"} = 0; + $needed->{TypeFunctionName("ndr_push", $d)} = + $needed->{TypeFunctionName("ndr_pull", $d)} = + $needed->{TypeFunctionName("ndr_print", $d)} = 0; ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypeNdrSize($d); } # Functions foreach my $d (@{$interface->{FUNCTIONS}}) { - ($needed->{"push_$d->{NAME}"}) && ParseFunctionPush($d); - ($needed->{"pull_$d->{NAME}"}) && ParseFunctionPull($d); - ($needed->{"print_$d->{NAME}"}) && ParseFunctionPrint($d); + ($needed->{"ndr_push_$d->{NAME}"}) && ParseFunctionPush($d); + ($needed->{"ndr_pull_$d->{NAME}"}) && ParseFunctionPull($d); + ($needed->{"ndr_print_$d->{NAME}"}) && ParseFunctionPrint($d); # Make sure we don't generate a function twice... - $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} = - $needed->{"print_$d->{NAME}"} = 0; + $needed->{"ndr_push_$d->{NAME}"} = $needed->{"ndr_pull_$d->{NAME}"} = + $needed->{"ndr_print_$d->{NAME}"} = 0; } FunctionTable($interface); @@ -2670,13 +2665,13 @@ sub NeededElement($$$) my @fn = (); if ($dir eq "print") { - push(@fn, "print_$rt"); + push(@fn, TypeFunctionName("ndr_print", $e->{REPRESENTATION_TYPE})); } elsif ($dir eq "pull") { - push (@fn, "pull_$t"); + push (@fn, TypeFunctionName("ndr_pull", $e->{TYPE})); push (@fn, "ndr_$t\_to_$rt") if ($rt ne $t); } elsif ($dir eq "push") { - push (@fn, "push_$t"); + push (@fn, TypeFunctionName("ndr_push", $e->{TYPE})); push (@fn, "ndr_$rt\_to_$t") if ($rt ne $t); } else { @@ -2693,9 +2688,9 @@ sub NeededElement($$$) sub NeededFunction($$) { my ($fn,$needed) = @_; - $needed->{"pull_$fn->{NAME}"} = 1; - $needed->{"push_$fn->{NAME}"} = 1; - $needed->{"print_$fn->{NAME}"} = 1; + $needed->{"ndr_pull_$fn->{NAME}"} = 1; + $needed->{"ndr_push_$fn->{NAME}"} = 1; + $needed->{"ndr_print_$fn->{NAME}"} = 1; foreach my $e (@{$fn->{ELEMENTS}}) { $e->{PARENT} = $fn; NeededElement($e, $_, $needed) foreach ("pull", "push", "print"); @@ -2729,17 +2724,27 @@ sub NeededInterface($$) NeededFunction($_, $needed) foreach (@{$interface->{FUNCTIONS}}); foreach (reverse @{$interface->{TYPES}}) { if (has_property($_, "public")) { - $needed->{"pull\_$_->{NAME}"} = $needed->{"push\_$_->{NAME}"} = - $needed->{"print\_$_->{NAME}"} = 1; + $needed->{TypeFunctionName("ndr_pull", $_)} = $needed->{TypeFunctionName("ndr_push", $_)} = + $needed->{TypeFunctionName("ndr_print", $_)} = 1; } - NeededType($_, $needed, "pull") if ($needed->{"pull_$_->{NAME}"}); - NeededType($_, $needed, "push") if ($needed->{"push_$_->{NAME}"}); - NeededType($_, $needed, "print") if ($needed->{"print_$_->{NAME}"}); + NeededType($_, $needed, "pull") if ($needed->{TypeFunctionName("ndr_pull", $_)}); + NeededType($_, $needed, "push") if ($needed->{TypeFunctionName("ndr_push", $_)}); + NeededType($_, $needed, "print") if ($needed->{TypeFunctionName("ndr_print", $_)}); if (has_property($_, "gensize")) { $needed->{"ndr_size_$_->{NAME}"} = 1; } } } +sub TypeFunctionName($$) +{ + my ($prefix, $t) = @_; + + return "$prefix\_$t->{NAME}" if (ref($t) eq "HASH" and + ($t->{TYPE} eq "TYPEDEF" or $t->{TYPE} eq "DECLARE")); + return "$prefix\_$t->{TYPE}_$t->{NAME}" if (ref($t) eq "HASH"); + return "$prefix\_$t"; +} + 1; -- cgit From 3bc13d6eeda1a8e5e0ebec8c85c3aaf2ded2b111 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 28 Feb 2007 02:01:58 +0000 Subject: r21579: Use utility function to determine function names in ejs code. (This used to be commit 1736de4c73a82be8357808dc8ec93d3917213449) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 40 +++++++++++++++++++------------ 1 file changed, 25 insertions(+), 15 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 9edd2a4a33..c254bfad38 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -9,7 +9,7 @@ package Parse::Pidl::Samba4::EJS; use Exporter; @ISA = qw(Exporter); @EXPORT_OK = qw(get_pointer_to get_value_of check_null_pointer $res - $res_hdr fn_declare); + $res_hdr fn_declare TypeFunctionName); use strict; use Parse::Pidl::Typelist; @@ -737,8 +737,8 @@ sub EjsInterface($$) pidl_hdr "\n"; foreach my $d (@{$interface->{TYPES}}) { - ($needed->{"push_$d->{NAME}"}) && EjsTypePushFunction($d, $d->{NAME}); - ($needed->{"pull_$d->{NAME}"}) && EjsTypePullFunction($d, $d->{NAME}); + ($needed->{TypeFunctionName("ejs_push", $d)}) && EjsTypePushFunction($d, $d->{NAME}); + ($needed->{TypeFunctionName("ejs_pull", $d)}) && EjsTypePullFunction($d, $d->{NAME}); } foreach my $d (@{$interface->{FUNCTIONS}}) { @@ -831,16 +831,16 @@ sub NeededFunction($$) { my ($fn,$needed) = @_; - $needed->{"pull_$fn->{NAME}"} = 1; - $needed->{"push_$fn->{NAME}"} = 1; + $needed->{"ejs_pull_$fn->{NAME}"} = 1; + $needed->{"ejs_push_$fn->{NAME}"} = 1; foreach (@{$fn->{ELEMENTS}}) { next if (has_property($_, "subcontext")); #FIXME: Support subcontexts if (grep(/in/, @{$_->{DIRECTION}})) { - $needed->{"pull_$_->{TYPE}"} = 1; + $needed->{TypeFunctionName("ejs_pull", $_->{TYPE})} = 1; } if (grep(/out/, @{$_->{DIRECTION}})) { - $needed->{"push_$_->{TYPE}"} = 1; + $needed->{TypeFunctionName("ejs_push", $_->{TYPE})} = 1; } } } @@ -858,10 +858,8 @@ sub NeededType($$$) foreach (@{$t->{ELEMENTS}}) { next if (has_property($_, "subcontext")); #FIXME: Support subcontexts my $n; - if (ref($_->{TYPE}) eq "HASH" and defined($_->{TYPE}->{NAME})) { - $needed->{"$req\_$_->{TYPE}->{TYPE}_$_->{TYPE}->{NAME}"} = 1; - } elsif (ref($_->{TYPE}) ne "HASH") { - $needed->{$req."_".$_->{TYPE}} = 1; + if (ref($_->{TYPE}) ne "HASH" or defined($_->{TYPE}->{NAME})) { + $needed->{TypeFunctionName("ejs_$req", $_->{TYPE})} = 1; } NeededType($_->{TYPE}, $needed, $req) if (ref($_->{TYPE}) eq "HASH"); } @@ -877,13 +875,25 @@ sub NeededInterface($$) foreach (reverse @{$interface->{TYPES}}) { if (has_property($_, "public")) { - $needed->{"pull_$_->{NAME}"} = not has_property($_, "noejs"); - $needed->{"push_$_->{NAME}"} = not has_property($_, "noejs"); + $needed->{TypeFunctionName("ejs_pull", $_)} = not has_property($_, "noejs"); + $needed->{TypeFunctionName("ejs_push", $_)} = not has_property($_, "noejs"); } - NeededType($_, $needed, "pull") if ($needed->{"pull_$_->{NAME}"}); - NeededType($_, $needed, "push") if ($needed->{"push_$_->{NAME}"}); + NeededType($_, $needed, "pull") if ($needed->{TypeFunctionName("ejs_pull", $_)}); + NeededType($_, $needed, "push") if ($needed->{TypeFunctionName("ejs_push", $_)}); } } +sub TypeFunctionName($$) +{ + my ($prefix, $t) = @_; + + return "$prefix\_$t->{NAME}" if (ref($t) eq "HASH" and + ($t->{TYPE} eq "TYPEDEF" or $t->{TYPE} eq "DECLARE")); + return "$prefix\_$t->{TYPE}_$t->{NAME}" if (ref($t) eq "HASH"); + return "$prefix\_$t"; +} + + + 1; -- cgit From 5ba8169109253c96f71e0e039b1c0b7a1056eab0 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 28 Feb 2007 13:25:53 +0000 Subject: r21584: Support for tagged types has landed! It's now possible to use "struct foo" without a typedef in IDL files. echo_info4 is the first type that's been converted. (This used to be commit 3ac68e858df9b53cf5e0a84741916214a53b3121) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 3 +- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 46 +++++++++++++--------------- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 22 ++++++++----- 3 files changed, 37 insertions(+), 34 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 998b19aabf..f05e3120c7 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -35,7 +35,7 @@ use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); -@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar); +@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType); use strict; use Parse::Pidl qw(warning fatal); @@ -499,6 +499,7 @@ sub ParseType($$) my ($d, $pointer_default) = @_; if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "UNION") { + return $d if (not defined($d->{ELEMENTS})); CheckPointerTypes($d, $pointer_default); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index c254bfad38..054074297b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -426,14 +426,7 @@ sub EjsPushScalar($$$$$) $var = get_pointer_to($var); } - my $t; - if (ref($e->{TYPE}) eq "HASH") { - $t = "$e->{TYPE}->{TYPE}_$e->{TYPE}->{NAME}"; - } else { - $t = $e->{TYPE}; - } - - pidl "NDR_CHECK(ejs_push_$t(ejs, v, $name, $var));"; + pidl "NDR_CHECK(".TypeFunctionName("ejs_push", $e->{TYPE})."(ejs, v, $name, $var));"; } } @@ -619,21 +612,22 @@ sub EjsTypePushFunction($$) my ($d, $name) = @_; return if (has_property($d, "noejs")); - if ($d->{TYPE} eq "TYPEDEF") { - EjsTypePushFunction($d->{DATA}, $name); - return; - } - - if ($d->{TYPE} eq "STRUCT") { - fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)"); - } elsif ($d->{TYPE} eq "UNION") { - fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)"); - } elsif ($d->{TYPE} eq "ENUM") { - fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)"); - } elsif ($d->{TYPE} eq "BITMAP") { - my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); - fn_declare($d, "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)"); - } + my $var = undef; + my $dt = $d; + if ($dt->{TYPE} eq "TYPEDEF") { + $dt = $dt->{DATA}; + } + if ($dt->{TYPE} eq "STRUCT") { + $var = "const struct $name *r"; + } elsif ($dt->{TYPE} eq "UNION") { + $var = "const union $name *r"; + } elsif ($dt->{TYPE} eq "ENUM") { + $var = "const enum $name *r"; + } elsif ($dt->{TYPE} eq "BITMAP") { + my($type_decl) = Parse::Pidl::Typelist::mapTypeName($dt->{BASE_TYPE}); + $var = "const $type_decl *r"; + } + fn_declare($d, "NTSTATUS ".TypeFunctionName("ejs_push", $d) . "(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $var)"); pidl "{"; indent; EjsTypePush($d, "r"); @@ -644,6 +638,7 @@ sub EjsTypePushFunction($$) sub EjsTypePush($$) { + sub EjsTypePush($$); my ($d, $varname) = @_; if ($d->{TYPE} eq 'STRUCT') { @@ -654,6 +649,8 @@ sub EjsTypePush($$) EjsEnumPush($d, $varname); } elsif ($d->{TYPE} eq 'BITMAP') { EjsBitmapPush($d, $varname); + } elsif ($d->{TYPE} eq 'TYPEDEF') { + EjsTypePush($d->{DATA}, $varname); } else { warn "Unhandled push $varname of type $d->{TYPE}"; } @@ -677,8 +674,7 @@ sub EjsPushFunction($) } if ($d->{RETURN_TYPE}) { - my $t = $d->{RETURN_TYPE}; - pidl "NDR_CHECK(ejs_push_$t(ejs, v, \"result\", &r->out.result));"; + pidl "NDR_CHECK(".TypeFunctionName("ejs_push", $d->{RETURN_TYPE})."(ejs, v, \"result\", &r->out.result));"; } pidl "return NT_STATUS_OK;"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 11ecc17001..2eddf22b05 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -57,7 +57,11 @@ sub HeaderElement($) if (has_property($element, "represent_as")) { pidl mapTypeName($element->{PROPERTIES}->{represent_as})." "; } else { - HeaderType($element, $element->{TYPE}, ""); + if (ref($element->{TYPE}) eq "HASH") { + HeaderType($element, $element->{TYPE}, $element->{TYPE}->{NAME}); + } else { + HeaderType($element, $element->{TYPE}, ""); + } pidl " "; my $numstar = $element->{POINTERS}; if ($numstar >= 1) { @@ -90,14 +94,14 @@ sub HeaderElement($) sub HeaderStruct($$) { my($struct,$name) = @_; - pidl "struct $name {\n"; + pidl "struct $name"; + return if (not defined($struct->{ELEMENTS})); + pidl " {\n"; $tab_depth++; my $el_count=0; - if (defined $struct->{ELEMENTS}) { - foreach (@{$struct->{ELEMENTS}}) { - HeaderElement($_); - $el_count++; - } + foreach (@{$struct->{ELEMENTS}}) { + HeaderElement($_); + $el_count++; } if ($el_count == 0) { # some compilers can't handle empty structures @@ -174,7 +178,9 @@ sub HeaderUnion($$) my($union,$name) = @_; my %done = (); - pidl "union $name {\n"; + pidl "union $name"; + return if (not defined($union->{ELEMENTS})); + pidl " {\n"; $tab_depth++; foreach my $e (@{$union->{ELEMENTS}}) { if ($e->{TYPE} ne "EMPTY") { -- cgit From f653871d770006620533b7dc50f350991d567712 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 2 Mar 2007 14:05:52 +0000 Subject: r21654: Add simple test for print functions. (This used to be commit 3c9df011a85aa8178a26d66faaaed5c88757800e) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 16d60ace53..ac4b390e76 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -12,7 +12,7 @@ require Exporter; @EXPORT = qw(is_charset_array); @EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction - NeededElement NeededType $res NeededInterface TypeFunctionName); + NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint); use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName); -- cgit From 1afda7bdde90948027e3230c19753280afb16e96 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 2 Mar 2007 14:53:09 +0000 Subject: r21656: Move tests a bit closer to the things they test, should make syncing with samba3 easier. (This used to be commit 4d755fb5d7adedd1dd8bad917b921324411bfd59) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 3 --- 1 file changed, 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index ac4b390e76..eaf66ea0c3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1481,8 +1481,6 @@ sub ParseStructPrint($$$) my $env = GenerateStructEnv($struct, $varname); - EnvSubstituteValue($env, $struct); - DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}}); pidl "ndr_print_struct(ndr, name, \"$name\");"; @@ -2049,7 +2047,6 @@ sub ParseFunctionPrint($) pidl "ndr->depth++;"; my $env = GenerateFunctionInEnv($fn); - EnvSubstituteValue($env, $fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { -- cgit From 035adfb94399a2e2d5d4ca26aaa214576f5c0b64 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 4 Mar 2007 14:16:52 +0000 Subject: r21681: Fix bug in the parsing code that parsed "struct foo;" the same as "struct foo {};". Reported by one of the OpenChange folks, thanks! (This used to be commit d65b520f08ea4ee82c35ff334a58aa6ffc403d67) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 2358 ++++++++++++++++++------------------ source4/pidl/lib/Parse/Pidl/NDR.pm | 5 +- 2 files changed, 1167 insertions(+), 1196 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index e547b2caa8..36c83c5922 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -37,7 +37,7 @@ sub new { "import" => 6, "include" => 11 }, - DEFAULT => -91, + DEFAULT => -89, GOTOS => { 'importlib' => 9, 'interface' => 8, @@ -106,7 +106,7 @@ sub new { } }, {#State 13 - DEFAULT => -124 + DEFAULT => -122 }, {#State 14 DEFAULT => -10 @@ -161,7 +161,7 @@ sub new { } }, {#State 22 - DEFAULT => -120 + DEFAULT => -118 }, {#State 23 ACTIONS => { @@ -170,27 +170,23 @@ sub new { }, {#State 24 ACTIONS => { - ":" => 32 - }, - DEFAULT => -16, - GOTOS => { - 'base_interface' => 33 + "{" => 32 } }, {#State 25 ACTIONS => { - "," => 34, - "]" => 35 + "," => 33, + "]" => 34 } }, {#State 26 ACTIONS => { - "(" => 36 + "(" => 35 }, - DEFAULT => -95 + DEFAULT => -93 }, {#State 27 - DEFAULT => -93 + DEFAULT => -91 }, {#State 28 DEFAULT => -7 @@ -204,1588 +200,1572 @@ sub new { {#State 31 DEFAULT => -13, GOTOS => { - 'interface_names' => 37 + 'interface_names' => 36 } }, {#State 32 ACTIONS => { - 'IDENTIFIER' => 22 + "declare" => 44, + "const" => 48 }, + DEFAULT => -89, GOTOS => { - 'identifier' => 38 + 'typedecl' => 37, + 'function' => 38, + 'definitions' => 40, + 'bitmap' => 39, + 'definition' => 43, + 'property_list' => 42, + 'usertype' => 41, + 'const' => 47, + 'declare' => 46, + 'struct' => 45, + 'typedef' => 50, + 'enum' => 49, + 'union' => 51 } }, {#State 33 - ACTIONS => { - "{" => 39 - } - }, - {#State 34 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { 'identifier' => 26, - 'property' => 40 + 'property' => 52 } }, - {#State 35 - DEFAULT => -92 + {#State 34 + DEFAULT => -90 }, - {#State 36 + {#State 35 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'text' => 46, - 'listtext' => 42, - 'anytext' => 41, - 'constant' => 43 + 'identifier' => 57, + 'text' => 58, + 'listtext' => 54, + 'anytext' => 53, + 'constant' => 55 } }, - {#State 37 + {#State 36 ACTIONS => { - "}" => 47, - "interface" => 48 + "}" => 59, + "interface" => 60 } }, + {#State 37 + DEFAULT => -22 + }, {#State 38 - DEFAULT => -17 + DEFAULT => -18 }, {#State 39 + DEFAULT => -37 + }, + {#State 40 ACTIONS => { - "declare" => 56, - "const" => 60 + "}" => 61, + "declare" => 44, + "const" => 48 }, - DEFAULT => -91, + DEFAULT => -89, GOTOS => { - 'typedecl' => 49, - 'function' => 50, - 'definitions' => 52, - 'bitmap' => 51, - 'definition' => 55, - 'property_list' => 54, - 'usertype' => 53, - 'const' => 59, - 'declare' => 58, - 'struct' => 57, - 'typedef' => 62, - 'enum' => 61, - 'union' => 63 + 'typedecl' => 37, + 'function' => 38, + 'bitmap' => 39, + 'definition' => 62, + 'property_list' => 42, + 'usertype' => 41, + 'const' => 47, + 'struct' => 45, + 'declare' => 46, + 'typedef' => 50, + 'enum' => 49, + 'union' => 51 } }, - {#State 40 - DEFAULT => -94 - }, {#State 41 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 - }, - DEFAULT => -97 + ";" => 63 + } }, {#State 42 ACTIONS => { - "," => 79, - ")" => 80 + "typedef" => 64, + 'IDENTIFIER' => 22, + "signed" => 72, + "union" => 65, + "enum" => 74, + "bitmap" => 75, + 'void' => 66, + "unsigned" => 76, + "[" => 17, + "struct" => 71 + }, + GOTOS => { + 'existingtype' => 73, + 'bitmap' => 39, + 'usertype' => 68, + 'property_list' => 67, + 'identifier' => 69, + 'struct' => 45, + 'enum' => 49, + 'type' => 77, + 'union' => 51, + 'sign' => 70 } }, {#State 43 - DEFAULT => -103 + DEFAULT => -16 }, {#State 44 - DEFAULT => -123 + DEFAULT => -89, + GOTOS => { + 'property_list' => 78 + } }, {#State 45 - DEFAULT => -102 + DEFAULT => -34 }, {#State 46 - DEFAULT => -104 + DEFAULT => -21 }, {#State 47 - ACTIONS => { - ";" => 82 - }, - DEFAULT => -125, - GOTOS => { - 'optional_semicolon' => 81 - } + DEFAULT => -19 }, {#State 48 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 83 + 'identifier' => 79 } }, {#State 49 - DEFAULT => -24 + DEFAULT => -36 }, {#State 50 DEFAULT => -20 }, {#State 51 - DEFAULT => -39 + DEFAULT => -35 }, {#State 52 - ACTIONS => { - "}" => 84, - "declare" => 56, - "const" => 60 - }, - DEFAULT => -91, - GOTOS => { - 'typedecl' => 49, - 'function' => 50, - 'bitmap' => 51, - 'definition' => 85, - 'property_list' => 54, - 'usertype' => 53, - 'const' => 59, - 'struct' => 57, - 'declare' => 58, - 'typedef' => 62, - 'enum' => 61, - 'union' => 63 - } + DEFAULT => -92 }, {#State 53 ACTIONS => { - ";" => 86 - } + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 + }, + DEFAULT => -95 }, {#State 54 ACTIONS => { - "typedef" => 87, - 'IDENTIFIER' => 22, - "signed" => 95, - "union" => 88, - "enum" => 97, - "bitmap" => 98, - 'void' => 89, - "unsigned" => 99, - "[" => 17, - "struct" => 94 - }, - GOTOS => { - 'existingtype' => 96, - 'bitmap' => 51, - 'usertype' => 91, - 'property_list' => 90, - 'identifier' => 92, - 'struct' => 57, - 'enum' => 61, - 'type' => 100, - 'union' => 63, - 'sign' => 93 + "," => 95, + ")" => 96 } }, {#State 55 - DEFAULT => -18 + DEFAULT => -101 }, {#State 56 - DEFAULT => -91, - GOTOS => { - 'property_list' => 101 - } + DEFAULT => -121 }, {#State 57 - DEFAULT => -36 + DEFAULT => -100 }, {#State 58 - DEFAULT => -23 + DEFAULT => -102 }, {#State 59 - DEFAULT => -21 + ACTIONS => { + ";" => 97 + }, + DEFAULT => -123, + GOTOS => { + 'optional_semicolon' => 98 + } }, {#State 60 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 102 + 'identifier' => 99 } }, {#State 61 - DEFAULT => -38 + ACTIONS => { + ";" => 97 + }, + DEFAULT => -123, + GOTOS => { + 'optional_semicolon' => 100 + } }, {#State 62 - DEFAULT => -22 + DEFAULT => -17 }, {#State 63 - DEFAULT => -37 + DEFAULT => -38 }, {#State 64 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 22, + "signed" => 72, + 'void' => 66, + "unsigned" => 76 }, - DEFAULT => -101, + DEFAULT => -89, GOTOS => { - 'identifier' => 45, - 'anytext' => 103, - 'text' => 46, - 'constant' => 43 + 'existingtype' => 73, + 'bitmap' => 39, + 'usertype' => 68, + 'property_list' => 67, + 'identifier' => 69, + 'struct' => 45, + 'enum' => 49, + 'type' => 101, + 'union' => 51, + 'sign' => 70 } }, {#State 65 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 102 }, - DEFAULT => -101, + DEFAULT => -120, GOTOS => { - 'identifier' => 45, - 'anytext' => 104, - 'text' => 46, - 'constant' => 43 + 'optional_identifier' => 103 } }, {#State 66 + DEFAULT => -45 + }, + {#State 67 + ACTIONS => { + "union" => 65, + "enum" => 74, + "bitmap" => 75, + "[" => 17, + "struct" => 71 + } + }, + {#State 68 + DEFAULT => -43 + }, + {#State 69 + DEFAULT => -42 + }, + {#State 70 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, GOTOS => { - 'identifier' => 45, - 'anytext' => 105, - 'text' => 46, - 'constant' => 43 + 'identifier' => 104 } }, - {#State 67 + {#State 71 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 102 }, - DEFAULT => -101, + DEFAULT => -120, GOTOS => { - 'identifier' => 45, - 'anytext' => 106, - 'text' => 46, - 'constant' => 43 + 'optional_identifier' => 105 } }, - {#State 68 + {#State 72 + DEFAULT => -39 + }, + {#State 73 + DEFAULT => -44 + }, + {#State 74 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 102 }, - DEFAULT => -101, + DEFAULT => -120, GOTOS => { - 'identifier' => 45, - 'anytext' => 107, - 'text' => 46, - 'constant' => 43 + 'optional_identifier' => 106 } }, - {#State 69 + {#State 75 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 102 }, - DEFAULT => -101, + DEFAULT => -120, GOTOS => { - 'identifier' => 45, - 'anytext' => 108, - 'text' => 46, - 'constant' => 43 + 'optional_identifier' => 107 } }, - {#State 70 + {#State 76 + DEFAULT => -40 + }, + {#State 77 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, GOTOS => { - 'identifier' => 45, - 'anytext' => 109, - 'text' => 46, - 'constant' => 43, - 'commalisttext' => 110 + 'identifier' => 108 } }, - {#State 71 + {#State 78 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + "union" => 109, + "enum" => 114, + "bitmap" => 115, + "[" => 17 }, - DEFAULT => -101, GOTOS => { - 'identifier' => 45, - 'anytext' => 111, - 'text' => 46, - 'constant' => 43 + 'decl_enum' => 110, + 'decl_bitmap' => 111, + 'decl_type' => 113, + 'decl_union' => 112 } }, - {#State 72 + {#State 79 + DEFAULT => -78, + GOTOS => { + 'pointers' => 116 + } + }, + {#State 80 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 112, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 117, + 'text' => 58, + 'constant' => 55 } }, - {#State 73 + {#State 81 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 113, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 118, + 'text' => 58, + 'constant' => 55 } }, - {#State 74 + {#State 82 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 109, - 'text' => 46, - 'constant' => 43, - 'commalisttext' => 114 + 'identifier' => 57, + 'anytext' => 119, + 'text' => 58, + 'constant' => 55 } }, - {#State 75 + {#State 83 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 115, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 120, + 'text' => 58, + 'constant' => 55 } }, - {#State 76 + {#State 84 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 116, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 121, + 'text' => 58, + 'constant' => 55 } }, - {#State 77 + {#State 85 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 117, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 122, + 'text' => 58, + 'constant' => 55 } }, - {#State 78 + {#State 86 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 118, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 123, + 'text' => 58, + 'constant' => 55 } }, - {#State 79 + {#State 87 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 119, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 124, + 'text' => 58, + 'constant' => 55, + 'commalisttext' => 125 } }, - {#State 80 - DEFAULT => -96 - }, - {#State 81 - DEFAULT => -12 - }, - {#State 82 - DEFAULT => -126 - }, - {#State 83 + {#State 88 ACTIONS => { - ";" => 120 + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -99, + GOTOS => { + 'identifier' => 57, + 'anytext' => 126, + 'text' => 58, + 'constant' => 55 } }, - {#State 84 + {#State 89 ACTIONS => { - ";" => 82 + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -125, + DEFAULT => -99, GOTOS => { - 'optional_semicolon' => 121 + 'identifier' => 57, + 'anytext' => 127, + 'text' => 58, + 'constant' => 55 } }, - {#State 85 - DEFAULT => -19 - }, - {#State 86 - DEFAULT => -40 - }, - {#State 87 + {#State 90 ACTIONS => { - 'IDENTIFIER' => 22, - "signed" => 95, - 'void' => 89, - "unsigned" => 99 + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -91, + DEFAULT => -99, GOTOS => { - 'existingtype' => 96, - 'bitmap' => 51, - 'usertype' => 91, - 'property_list' => 90, - 'identifier' => 92, - 'struct' => 57, - 'enum' => 61, - 'type' => 122, - 'union' => 63, - 'sign' => 93 + 'identifier' => 57, + 'anytext' => 128, + 'text' => 58, + 'constant' => 55 } }, - {#State 88 + {#State 91 ACTIONS => { - 'IDENTIFIER' => 123 + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -122, + DEFAULT => -99, GOTOS => { - 'optional_identifier' => 124 + 'identifier' => 57, + 'anytext' => 124, + 'text' => 58, + 'constant' => 55, + 'commalisttext' => 129 } }, - {#State 89 - DEFAULT => -47 - }, - {#State 90 + {#State 92 ACTIONS => { - "union" => 88, - "enum" => 97, - "bitmap" => 98, - "[" => 17, - "struct" => 94 + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -99, + GOTOS => { + 'identifier' => 57, + 'anytext' => 130, + 'text' => 58, + 'constant' => 55 } }, - {#State 91 - DEFAULT => -45 - }, - {#State 92 - DEFAULT => -44 - }, {#State 93 ACTIONS => { + 'CONSTANT' => 56, + 'TEXT' => 13, 'IDENTIFIER' => 22 }, + DEFAULT => -99, GOTOS => { - 'identifier' => 125 + 'identifier' => 57, + 'anytext' => 131, + 'text' => 58, + 'constant' => 55 } }, {#State 94 ACTIONS => { - 'IDENTIFIER' => 123 + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -122, + DEFAULT => -99, GOTOS => { - 'optional_identifier' => 126 + 'identifier' => 57, + 'anytext' => 132, + 'text' => 58, + 'constant' => 55 } }, {#State 95 - DEFAULT => -41 - }, - {#State 96 - DEFAULT => -46 - }, - {#State 97 ACTIONS => { - 'IDENTIFIER' => 123 + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -122, + DEFAULT => -99, GOTOS => { - 'optional_identifier' => 127 + 'identifier' => 57, + 'anytext' => 133, + 'text' => 58, + 'constant' => 55 } }, + {#State 96 + DEFAULT => -94 + }, + {#State 97 + DEFAULT => -124 + }, {#State 98 - ACTIONS => { - 'IDENTIFIER' => 123 - }, - DEFAULT => -122, - GOTOS => { - 'optional_identifier' => 128 - } + DEFAULT => -12 }, {#State 99 - DEFAULT => -42 - }, - {#State 100 ACTIONS => { - 'IDENTIFIER' => 22 - }, - GOTOS => { - 'identifier' => 129 + ";" => 134 } }, + {#State 100 + DEFAULT => -15 + }, {#State 101 ACTIONS => { - "union" => 130, - "enum" => 135, - "bitmap" => 136, - "[" => 17 + 'IDENTIFIER' => 22 }, GOTOS => { - 'decl_enum' => 131, - 'decl_bitmap' => 132, - 'decl_type' => 134, - 'decl_union' => 133 + 'identifier' => 135 } }, {#State 102 - DEFAULT => -80, - GOTOS => { - 'pointers' => 137 - } + DEFAULT => -119 }, {#State 103 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 + "{" => 137 }, - DEFAULT => -114 + DEFAULT => -74, + GOTOS => { + 'union_body' => 138, + 'opt_union_body' => 136 + } }, {#State 104 - ACTIONS => { - ":" => 64, - "<" => 67, - "~" => 68, - "?" => 66, - "{" => 70, - "=" => 73 - }, - DEFAULT => -105 + DEFAULT => -41 }, {#State 105 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 + "{" => 140 }, - DEFAULT => -113 + DEFAULT => -64, + GOTOS => { + 'struct_body' => 139, + 'opt_struct_body' => 141 + } }, {#State 106 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 + "{" => 142 }, - DEFAULT => -109 + DEFAULT => -47, + GOTOS => { + 'opt_enum_body' => 144, + 'enum_body' => 143 + } }, {#State 107 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 + "{" => 146 }, - DEFAULT => -117 + DEFAULT => -55, + GOTOS => { + 'bitmap_body' => 147, + 'opt_bitmap_body' => 145 + } }, {#State 108 ACTIONS => { - ":" => 64, - "<" => 67, - "~" => 68, - "?" => 66, - "{" => 70, - "=" => 73 - }, - DEFAULT => -116 + "(" => 148 + } }, {#State 109 - ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 - }, - DEFAULT => -99 + DEFAULT => -32 }, {#State 110 - ACTIONS => { - "}" => 138, - "," => 139 - } + DEFAULT => -27 }, {#State 111 - ACTIONS => { - ":" => 64, - "<" => 67, - "~" => 68, - "?" => 66, - "{" => 70, - "=" => 73 - }, - DEFAULT => -111 + DEFAULT => -28 }, {#State 112 - ACTIONS => { - ":" => 64, - "<" => 67, - "~" => 68, - "?" => 66, - "{" => 70, - "=" => 73 - }, - DEFAULT => -112 + DEFAULT => -29 }, {#State 113 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 + 'IDENTIFIER' => 22 }, - DEFAULT => -115 + GOTOS => { + 'identifier' => 149 + } }, {#State 114 - ACTIONS => { - "," => 139, - ")" => 140 - } + DEFAULT => -30 }, {#State 115 - ACTIONS => { - ":" => 64, - "<" => 67, - "~" => 68, - "?" => 66, - "{" => 70, - "=" => 73 - }, - DEFAULT => -110 + DEFAULT => -31 }, {#State 116 ACTIONS => { - ":" => 64, - "<" => 67, - "~" => 68, - "?" => 66, - "{" => 70, - "=" => 73 + 'IDENTIFIER' => 22, + "*" => 151 }, - DEFAULT => -107 + GOTOS => { + 'identifier' => 150 + } }, {#State 117 ACTIONS => { - ":" => 64, - "<" => 67, - "~" => 68, - "?" => 66, - "{" => 70, - "=" => 73 + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 }, - DEFAULT => -106 + DEFAULT => -112 }, {#State 118 ACTIONS => { - ":" => 64, - "<" => 67, - "~" => 68, - "?" => 66, - "{" => 70, - "=" => 73 + ":" => 80, + "<" => 82, + "~" => 83, + "?" => 86, + "{" => 87, + "=" => 90 }, - DEFAULT => -108 + DEFAULT => -103 }, {#State 119 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 }, - DEFAULT => -98 + DEFAULT => -107 }, {#State 120 - DEFAULT => -14 + ACTIONS => { + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 + }, + DEFAULT => -115 }, {#State 121 - DEFAULT => -15 + ACTIONS => { + ":" => 80, + "<" => 82, + "~" => 83, + "?" => 86, + "{" => 87, + "=" => 90 + }, + DEFAULT => -114 }, {#State 122 ACTIONS => { - 'IDENTIFIER' => 22 + ":" => 80, + "<" => 82, + "~" => 83, + "?" => 86, + "{" => 87, + "=" => 90 }, - GOTOS => { - 'identifier' => 141 - } + DEFAULT => -105 }, {#State 123 - DEFAULT => -121 + ACTIONS => { + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 + }, + DEFAULT => -111 }, {#State 124 ACTIONS => { - "{" => 143 + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 }, - DEFAULT => -76, - GOTOS => { - 'union_body' => 144, - 'opt_union_body' => 142 - } + DEFAULT => -97 }, {#State 125 - DEFAULT => -43 + ACTIONS => { + "}" => 152, + "," => 153 + } }, {#State 126 ACTIONS => { - "{" => 146 + ":" => 80, + "<" => 82, + "~" => 83, + "?" => 86, + "{" => 87, + "=" => 90 }, - DEFAULT => -66, - GOTOS => { - 'struct_body' => 145, - 'opt_struct_body' => 147 - } + DEFAULT => -109 }, {#State 127 ACTIONS => { - "{" => 148 + ":" => 80, + "<" => 82, + "~" => 83, + "?" => 86, + "{" => 87, + "=" => 90 }, - DEFAULT => -49, - GOTOS => { - 'opt_enum_body' => 150, - 'enum_body' => 149 - } + DEFAULT => -110 }, {#State 128 ACTIONS => { - "{" => 152 + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 }, - DEFAULT => -57, - GOTOS => { - 'bitmap_body' => 153, - 'opt_bitmap_body' => 151 - } + DEFAULT => -113 }, {#State 129 ACTIONS => { - "(" => 154 + "," => 153, + ")" => 154 } }, {#State 130 - DEFAULT => -34 + ACTIONS => { + ":" => 80, + "<" => 82, + "~" => 83, + "?" => 86, + "{" => 87, + "=" => 90 + }, + DEFAULT => -108 }, {#State 131 - DEFAULT => -29 + ACTIONS => { + ":" => 80, + "<" => 82, + "~" => 83, + "?" => 86, + "{" => 87, + "=" => 90 + }, + DEFAULT => -104 }, {#State 132 - DEFAULT => -30 - }, - {#State 133 - DEFAULT => -31 - }, - {#State 134 ACTIONS => { - 'IDENTIFIER' => 22 + ":" => 80, + "<" => 82, + "~" => 83, + "?" => 86, + "{" => 87, + "=" => 90 }, - GOTOS => { - 'identifier' => 155 - } - }, - {#State 135 - DEFAULT => -32 - }, - {#State 136 - DEFAULT => -33 + DEFAULT => -106 }, - {#State 137 + {#State 133 ACTIONS => { - 'IDENTIFIER' => 22, - "*" => 157 + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 }, - GOTOS => { - 'identifier' => 156 - } + DEFAULT => -96 }, - {#State 138 + {#State 134 + DEFAULT => -14 + }, + {#State 135 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + "[" => 155 }, - DEFAULT => -101, + DEFAULT => -86, GOTOS => { - 'identifier' => 45, - 'anytext' => 158, - 'text' => 46, - 'constant' => 43 + 'array_len' => 156 } }, - {#State 139 - ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -101, + {#State 136 + DEFAULT => -76 + }, + {#State 137 + DEFAULT => -71, GOTOS => { - 'identifier' => 45, - 'anytext' => 159, - 'text' => 46, - 'constant' => 43 + 'union_elements' => 157 } }, + {#State 138 + DEFAULT => -75 + }, + {#State 139 + DEFAULT => -65 + }, {#State 140 - ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -101, + DEFAULT => -80, GOTOS => { - 'identifier' => 45, - 'anytext' => 160, - 'text' => 46, - 'constant' => 43 + 'element_list1' => 158 } }, {#State 141 + DEFAULT => -66 + }, + {#State 142 ACTIONS => { - "[" => 161 + 'IDENTIFIER' => 22 }, - DEFAULT => -88, GOTOS => { - 'array_len' => 162 + 'identifier' => 159, + 'enum_element' => 160, + 'enum_elements' => 161 } }, - {#State 142 - DEFAULT => -78 - }, {#State 143 - DEFAULT => -73, - GOTOS => { - 'union_elements' => 163 - } + DEFAULT => -48 }, {#State 144 - DEFAULT => -77 + DEFAULT => -49 }, {#State 145 - DEFAULT => -67 + DEFAULT => -57 }, {#State 146 - DEFAULT => -82, + ACTIONS => { + 'IDENTIFIER' => 22 + }, + DEFAULT => -60, GOTOS => { - 'element_list1' => 164 + 'identifier' => 164, + 'bitmap_element' => 163, + 'bitmap_elements' => 162, + 'opt_bitmap_elements' => 165 } }, {#State 147 - DEFAULT => -68 + DEFAULT => -56 }, {#State 148 ACTIONS => { - 'IDENTIFIER' => 22 + "," => -82, + "void" => 169, + ")" => -82 }, + DEFAULT => -89, GOTOS => { - 'identifier' => 165, - 'enum_element' => 166, - 'enum_elements' => 167 + 'base_element' => 166, + 'element_list2' => 168, + 'property_list' => 167 } }, {#State 149 - DEFAULT => -50 + ACTIONS => { + ";" => 170 + } }, {#State 150 - DEFAULT => -51 + ACTIONS => { + "[" => 155, + "=" => 172 + }, + GOTOS => { + 'array_len' => 171 + } }, {#State 151 - DEFAULT => -59 + DEFAULT => -79 }, {#State 152 ACTIONS => { + 'CONSTANT' => 56, + 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -62, + DEFAULT => -99, GOTOS => { - 'identifier' => 170, - 'bitmap_element' => 169, - 'bitmap_elements' => 168, - 'opt_bitmap_elements' => 171 + 'identifier' => 57, + 'anytext' => 173, + 'text' => 58, + 'constant' => 55 } }, {#State 153 - DEFAULT => -58 + ACTIONS => { + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 + }, + DEFAULT => -99, + GOTOS => { + 'identifier' => 57, + 'anytext' => 174, + 'text' => 58, + 'constant' => 55 + } }, {#State 154 ACTIONS => { - "," => -84, - "void" => 175, - ")" => -84 + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -91, + DEFAULT => -99, GOTOS => { - 'base_element' => 172, - 'element_list2' => 174, - 'property_list' => 173 + 'identifier' => 57, + 'anytext' => 175, + 'text' => 58, + 'constant' => 55 } }, {#State 155 ACTIONS => { - ";" => 176 + 'CONSTANT' => 56, + 'TEXT' => 13, + "]" => 176, + 'IDENTIFIER' => 22 + }, + DEFAULT => -99, + GOTOS => { + 'identifier' => 57, + 'anytext' => 177, + 'text' => 58, + 'constant' => 55 } }, {#State 156 ACTIONS => { - "[" => 161, - "=" => 178 - }, - GOTOS => { - 'array_len' => 177 + ";" => 178 } }, {#State 157 - DEFAULT => -81 + ACTIONS => { + "}" => 179 + }, + DEFAULT => -89, + GOTOS => { + 'optional_base_element' => 181, + 'property_list' => 180 + } }, {#State 158 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 + "}" => 182 }, - DEFAULT => -119 + DEFAULT => -89, + GOTOS => { + 'base_element' => 183, + 'property_list' => 167 + } }, {#State 159 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 + "=" => 184 }, - DEFAULT => -100 + DEFAULT => -52 }, {#State 160 - ACTIONS => { - ":" => 64, - "<" => 67, - "~" => 68, - "?" => 66, - "{" => 70, - "=" => 73 - }, - DEFAULT => -118 + DEFAULT => -50 }, {#State 161 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - "]" => 179, - 'IDENTIFIER' => 22 - }, - DEFAULT => -101, - GOTOS => { - 'identifier' => 45, - 'anytext' => 180, - 'text' => 46, - 'constant' => 43 + "}" => 185, + "," => 186 } }, {#State 162 ACTIONS => { - ";" => 181 - } + "," => 187 + }, + DEFAULT => -61 }, {#State 163 - ACTIONS => { - "}" => 182 - }, - DEFAULT => -91, - GOTOS => { - 'optional_base_element' => 184, - 'property_list' => 183 - } + DEFAULT => -58 }, {#State 164 ACTIONS => { - "}" => 185 - }, - DEFAULT => -91, - GOTOS => { - 'base_element' => 186, - 'property_list' => 173 + "=" => 188 } }, {#State 165 ACTIONS => { - "=" => 187 - }, - DEFAULT => -54 + "}" => 189 + } }, {#State 166 - DEFAULT => -52 + DEFAULT => -84 }, {#State 167 ACTIONS => { - "}" => 188, - "," => 189 + 'IDENTIFIER' => 22, + "signed" => 72, + 'void' => 66, + "unsigned" => 76, + "[" => 17 + }, + DEFAULT => -89, + GOTOS => { + 'existingtype' => 73, + 'bitmap' => 39, + 'usertype' => 68, + 'property_list' => 67, + 'identifier' => 69, + 'struct' => 45, + 'enum' => 49, + 'type' => 190, + 'union' => 51, + 'sign' => 70 } }, {#State 168 ACTIONS => { - "," => 190 - }, - DEFAULT => -63 + "," => 191, + ")" => 192 + } }, {#State 169 - DEFAULT => -60 + DEFAULT => -83 }, {#State 170 - ACTIONS => { - "=" => 191 - } + DEFAULT => -26 }, {#State 171 ACTIONS => { - "}" => 192 + "=" => 193 } }, {#State 172 - DEFAULT => -86 - }, - {#State 173 ACTIONS => { - 'IDENTIFIER' => 22, - "signed" => 95, - 'void' => 89, - "unsigned" => 99, - "[" => 17 + 'CONSTANT' => 56, + 'TEXT' => 13, + 'IDENTIFIER' => 22 }, - DEFAULT => -91, + DEFAULT => -99, GOTOS => { - 'existingtype' => 96, - 'bitmap' => 51, - 'usertype' => 91, - 'property_list' => 90, - 'identifier' => 92, - 'struct' => 57, - 'enum' => 61, - 'type' => 193, - 'union' => 63, - 'sign' => 93 + 'identifier' => 57, + 'anytext' => 194, + 'text' => 58, + 'constant' => 55 } }, - {#State 174 + {#State 173 ACTIONS => { - "," => 194, - ")" => 195 - } - }, - {#State 175 - DEFAULT => -85 - }, - {#State 176 - DEFAULT => -28 + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 + }, + DEFAULT => -117 }, - {#State 177 + {#State 174 ACTIONS => { - "=" => 196 - } + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 + }, + DEFAULT => -98 }, - {#State 178 + {#State 175 ACTIONS => { - 'CONSTANT' => 44, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + ":" => 80, + "<" => 82, + "~" => 83, + "?" => 86, + "{" => 87, + "=" => 90 }, - DEFAULT => -101, - GOTOS => { - 'identifier' => 45, - 'anytext' => 197, - 'text' => 46, - 'constant' => 43 - } + DEFAULT => -116 }, - {#State 179 + {#State 176 ACTIONS => { - "[" => 161 + "[" => 155 }, - DEFAULT => -88, + DEFAULT => -86, GOTOS => { - 'array_len' => 198 + 'array_len' => 195 } }, - {#State 180 + {#State 177 ACTIONS => { - "-" => 65, - ":" => 64, - "?" => 66, - "<" => 67, - "+" => 69, - "~" => 68, - "&" => 71, - "{" => 70, - "/" => 72, - "=" => 73, - "|" => 75, - "(" => 74, - "*" => 76, - "." => 77, - "]" => 199, - ">" => 78 + "-" => 81, + ":" => 80, + "?" => 86, + "<" => 82, + "+" => 84, + "~" => 83, + "&" => 88, + "{" => 87, + "/" => 89, + "=" => 90, + "|" => 92, + "(" => 91, + "*" => 85, + "." => 93, + "]" => 196, + ">" => 94 } }, - {#State 181 - DEFAULT => -35 + {#State 178 + DEFAULT => -33 }, - {#State 182 - DEFAULT => -75 + {#State 179 + DEFAULT => -73 }, - {#State 183 + {#State 180 ACTIONS => { "[" => 17 }, - DEFAULT => -91, + DEFAULT => -89, GOTOS => { - 'base_or_empty' => 200, - 'base_element' => 201, - 'empty_element' => 202, - 'property_list' => 203 + 'base_or_empty' => 197, + 'base_element' => 198, + 'empty_element' => 199, + 'property_list' => 200 } }, - {#State 184 - DEFAULT => -74 + {#State 181 + DEFAULT => -72 }, - {#State 185 - DEFAULT => -65 + {#State 182 + DEFAULT => -63 }, - {#State 186 + {#State 183 ACTIONS => { - ";" => 204 + ";" => 201 } }, - {#State 187 + {#State 184 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 205, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 202, + 'text' => 58, + 'constant' => 55 } }, - {#State 188 - DEFAULT => -48 + {#State 185 + DEFAULT => -46 }, - {#State 189 + {#State 186 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 165, - 'enum_element' => 206 + 'identifier' => 159, + 'enum_element' => 203 } }, - {#State 190 + {#State 187 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 170, - 'bitmap_element' => 207 + 'identifier' => 164, + 'bitmap_element' => 204 } }, - {#State 191 + {#State 188 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 208, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 205, + 'text' => 58, + 'constant' => 55 } }, - {#State 192 - DEFAULT => -56 + {#State 189 + DEFAULT => -54 }, - {#State 193 - DEFAULT => -80, + {#State 190 + DEFAULT => -78, GOTOS => { - 'pointers' => 209 + 'pointers' => 206 } }, - {#State 194 - DEFAULT => -91, + {#State 191 + DEFAULT => -89, GOTOS => { - 'base_element' => 210, - 'property_list' => 173 + 'base_element' => 207, + 'property_list' => 167 } }, - {#State 195 + {#State 192 ACTIONS => { - ";" => 211 + ";" => 208 } }, - {#State 196 + {#State 193 ACTIONS => { - 'CONSTANT' => 44, + 'CONSTANT' => 56, 'TEXT' => 13, 'IDENTIFIER' => 22 }, - DEFAULT => -101, + DEFAULT => -99, GOTOS => { - 'identifier' => 45, - 'anytext' => 212, - 'text' => 46, - 'constant' => 43 + 'identifier' => 57, + 'anytext' => 209, + 'text' => 58, + 'constant' => 55 } }, - {#State 197 + {#State 194 ACTIONS => { - "-" => 65, - ":" => 64, - "?" => 66, - "<" => 67, - ";" => 213, - "+" => 69, - "~" => 68, - "&" => 71, - "{" => 70, - "/" => 72, - "=" => 73, - "|" => 75, - "(" => 74, - "*" => 76, - "." => 77, - ">" => 78 + "-" => 81, + ":" => 80, + "?" => 86, + "<" => 82, + ";" => 210, + "+" => 84, + "~" => 83, + "&" => 88, + "{" => 87, + "/" => 89, + "=" => 90, + "|" => 92, + "(" => 91, + "*" => 85, + "." => 93, + ">" => 94 } }, - {#State 198 - DEFAULT => -89 + {#State 195 + DEFAULT => -87 }, - {#State 199 + {#State 196 ACTIONS => { - "[" => 161 + "[" => 155 }, - DEFAULT => -88, + DEFAULT => -86, GOTOS => { - 'array_len' => 214 + 'array_len' => 211 } }, - {#State 200 - DEFAULT => -72 + {#State 197 + DEFAULT => -70 }, - {#State 201 + {#State 198 ACTIONS => { - ";" => 215 + ";" => 212 } }, - {#State 202 - DEFAULT => -71 + {#State 199 + DEFAULT => -69 }, - {#State 203 + {#State 200 ACTIONS => { 'IDENTIFIER' => 22, - "signed" => 95, - ";" => 216, - 'void' => 89, - "unsigned" => 99, + "signed" => 72, + ";" => 213, + 'void' => 66, + "unsigned" => 76, "[" => 17 }, - DEFAULT => -91, + DEFAULT => -89, GOTOS => { - 'existingtype' => 96, - 'bitmap' => 51, - 'usertype' => 91, - 'property_list' => 90, - 'identifier' => 92, - 'struct' => 57, - 'enum' => 61, - 'type' => 193, - 'union' => 63, - 'sign' => 93 + 'existingtype' => 73, + 'bitmap' => 39, + 'usertype' => 68, + 'property_list' => 67, + 'identifier' => 69, + 'struct' => 45, + 'enum' => 49, + 'type' => 190, + 'union' => 51, + 'sign' => 70 } }, + {#State 201 + DEFAULT => -81 + }, + {#State 202 + ACTIONS => { + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 + }, + DEFAULT => -53 + }, + {#State 203 + DEFAULT => -51 + }, {#State 204 - DEFAULT => -83 + DEFAULT => -59 }, {#State 205 ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 - }, - DEFAULT => -55 + "-" => 81, + ":" => 80, + "<" => 82, + "+" => 84, + "~" => 83, + "*" => 85, + "?" => 86, + "{" => 87, + "&" => 88, + "/" => 89, + "=" => 90, + "(" => 91, + "|" => 92, + "." => 93, + ">" => 94 + }, + DEFAULT => -62 }, {#State 206 - DEFAULT => -53 + ACTIONS => { + 'IDENTIFIER' => 22, + "*" => 151 + }, + GOTOS => { + 'identifier' => 214 + } }, {#State 207 - DEFAULT => -61 + DEFAULT => -85 }, {#State 208 - ACTIONS => { - "-" => 65, - ":" => 64, - "<" => 67, - "+" => 69, - "~" => 68, - "*" => 76, - "?" => 66, - "{" => 70, - "&" => 71, - "/" => 72, - "=" => 73, - "(" => 74, - "|" => 75, - "." => 77, - ">" => 78 - }, - DEFAULT => -64 + DEFAULT => -25 }, {#State 209 ACTIONS => { - 'IDENTIFIER' => 22, - "*" => 157 - }, - GOTOS => { - 'identifier' => 217 + "-" => 81, + ":" => 80, + "?" => 86, + "<" => 82, + ";" => 215, + "+" => 84, + "~" => 83, + "&" => 88, + "{" => 87, + "/" => 89, + "=" => 90, + "|" => 92, + "(" => 91, + "*" => 85, + "." => 93, + ">" => 94 } }, {#State 210 - DEFAULT => -87 + DEFAULT => -23 }, {#State 211 - DEFAULT => -27 + DEFAULT => -88 }, {#State 212 - ACTIONS => { - "-" => 65, - ":" => 64, - "?" => 66, - "<" => 67, - ";" => 218, - "+" => 69, - "~" => 68, - "&" => 71, - "{" => 70, - "/" => 72, - "=" => 73, - "|" => 75, - "(" => 74, - "*" => 76, - "." => 77, - ">" => 78 - } + DEFAULT => -68 }, {#State 213 - DEFAULT => -25 + DEFAULT => -67 }, {#State 214 - DEFAULT => -90 - }, - {#State 215 - DEFAULT => -70 - }, - {#State 216 - DEFAULT => -69 - }, - {#State 217 ACTIONS => { - "[" => 161 + "[" => 155 }, - DEFAULT => -88, + DEFAULT => -86, GOTOS => { - 'array_len' => 219 + 'array_len' => 216 } }, - {#State 218 - DEFAULT => -26 + {#State 215 + DEFAULT => -24 }, - {#State 219 - DEFAULT => -79 + {#State 216 + DEFAULT => -77 } ], yyrules => @@ -1894,59 +1874,49 @@ sub { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 15 - 'interface', 8, + 'interface', 7, sub #line 70 "idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], "NAME" => $_[3], - "BASE" => $_[4], - "DATA" => $_[6], - "FILE" => $_[0]->YYData->{FILE}, - "LINE" => $_[0]->YYData->{LINE}, - }} - ], - [#Rule 16 - 'base_interface', 0, undef - ], - [#Rule 17 - 'base_interface', 2, -sub -#line 83 "idl.yp" -{ $_[2] } + "DATA" => $_[5], + "FILE" => $_[0]->YYData->{FILE}, + "LINE" => $_[0]->YYData->{LINE}, + }} ], - [#Rule 18 + [#Rule 16 'definitions', 1, sub -#line 87 "idl.yp" +#line 81 "idl.yp" { [ $_[1] ] } ], - [#Rule 19 + [#Rule 17 'definitions', 2, sub -#line 88 "idl.yp" +#line 82 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 20 + [#Rule 18 'definition', 1, undef ], - [#Rule 21 + [#Rule 19 'definition', 1, undef ], - [#Rule 22 + [#Rule 20 'definition', 1, undef ], - [#Rule 23 + [#Rule 21 'definition', 1, undef ], - [#Rule 24 + [#Rule 22 'definition', 1, undef ], - [#Rule 25 + [#Rule 23 'const', 7, sub -#line 96 "idl.yp" +#line 90 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1957,10 +1927,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 26 + [#Rule 24 'const', 8, sub -#line 106 "idl.yp" +#line 100 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1972,10 +1942,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 27 + [#Rule 25 'function', 7, sub -#line 120 "idl.yp" +#line 114 "idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -1986,10 +1956,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 28 + [#Rule 26 'declare', 5, sub -#line 132 "idl.yp" +#line 126 "idl.yp" {{ "TYPE" => "DECLARE", "PROPERTIES" => $_[2], @@ -1999,43 +1969,43 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 29 + [#Rule 27 'decl_type', 1, undef ], - [#Rule 30 + [#Rule 28 'decl_type', 1, undef ], - [#Rule 31 + [#Rule 29 'decl_type', 1, undef ], - [#Rule 32 + [#Rule 30 'decl_enum', 1, sub -#line 146 "idl.yp" +#line 140 "idl.yp" {{ "TYPE" => "ENUM" }} ], - [#Rule 33 + [#Rule 31 'decl_bitmap', 1, sub -#line 152 "idl.yp" +#line 146 "idl.yp" {{ "TYPE" => "BITMAP" }} ], - [#Rule 34 + [#Rule 32 'decl_union', 1, sub -#line 158 "idl.yp" +#line 152 "idl.yp" {{ "TYPE" => "UNION" }} ], - [#Rule 35 + [#Rule 33 'typedef', 6, sub -#line 164 "idl.yp" +#line 158 "idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[1], @@ -2046,67 +2016,67 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 36 + [#Rule 34 'usertype', 1, undef ], - [#Rule 37 + [#Rule 35 'usertype', 1, undef ], - [#Rule 38 + [#Rule 36 'usertype', 1, undef ], - [#Rule 39 + [#Rule 37 'usertype', 1, undef ], - [#Rule 40 + [#Rule 38 'typedecl', 2, sub -#line 177 "idl.yp" +#line 171 "idl.yp" { $_[1] } ], - [#Rule 41 + [#Rule 39 'sign', 1, undef ], - [#Rule 42 + [#Rule 40 'sign', 1, undef ], - [#Rule 43 + [#Rule 41 'existingtype', 2, sub -#line 182 "idl.yp" +#line 176 "idl.yp" { ($_[1]?$_[1]:"signed") ." $_[2]" } ], - [#Rule 44 + [#Rule 42 'existingtype', 1, undef ], - [#Rule 45 + [#Rule 43 'type', 1, undef ], - [#Rule 46 + [#Rule 44 'type', 1, undef ], - [#Rule 47 + [#Rule 45 'type', 1, sub -#line 186 "idl.yp" +#line 180 "idl.yp" { "void" } ], - [#Rule 48 + [#Rule 46 'enum_body', 3, sub -#line 188 "idl.yp" +#line 182 "idl.yp" { $_[2] } ], - [#Rule 49 + [#Rule 47 'opt_enum_body', 0, undef ], - [#Rule 50 + [#Rule 48 'opt_enum_body', 1, undef ], - [#Rule 51 + [#Rule 49 'enum', 4, sub -#line 191 "idl.yp" +#line 185 "idl.yp" {{ "TYPE" => "ENUM", "PROPERTIES" => $_[1], @@ -2114,43 +2084,43 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 52 + [#Rule 50 'enum_elements', 1, sub -#line 200 "idl.yp" +#line 194 "idl.yp" { [ $_[1] ] } ], - [#Rule 53 + [#Rule 51 'enum_elements', 3, sub -#line 201 "idl.yp" +#line 195 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 54 + [#Rule 52 'enum_element', 1, undef ], - [#Rule 55 + [#Rule 53 'enum_element', 3, sub -#line 205 "idl.yp" +#line 199 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 56 + [#Rule 54 'bitmap_body', 3, sub -#line 208 "idl.yp" +#line 202 "idl.yp" { $_[2] } ], - [#Rule 57 + [#Rule 55 'opt_bitmap_body', 0, undef ], - [#Rule 58 + [#Rule 56 'opt_bitmap_body', 1, undef ], - [#Rule 59 + [#Rule 57 'bitmap', 4, sub -#line 211 "idl.yp" +#line 205 "idl.yp" {{ "TYPE" => "BITMAP", "PROPERTIES" => $_[1], @@ -2158,46 +2128,46 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 60 + [#Rule 58 'bitmap_elements', 1, sub -#line 220 "idl.yp" +#line 214 "idl.yp" { [ $_[1] ] } ], - [#Rule 61 + [#Rule 59 'bitmap_elements', 3, sub -#line 221 "idl.yp" +#line 215 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 62 + [#Rule 60 'opt_bitmap_elements', 0, undef ], - [#Rule 63 + [#Rule 61 'opt_bitmap_elements', 1, undef ], - [#Rule 64 + [#Rule 62 'bitmap_element', 3, sub -#line 226 "idl.yp" +#line 220 "idl.yp" { "$_[1] ( $_[3] )" } ], - [#Rule 65 + [#Rule 63 'struct_body', 3, sub -#line 229 "idl.yp" +#line 223 "idl.yp" { $_[2] } ], - [#Rule 66 + [#Rule 64 'opt_struct_body', 0, undef ], - [#Rule 67 + [#Rule 65 'opt_struct_body', 1, undef ], - [#Rule 68 + [#Rule 66 'struct', 4, sub -#line 233 "idl.yp" +#line 227 "idl.yp" {{ "TYPE" => "STRUCT", "PROPERTIES" => $_[1], @@ -2205,10 +2175,10 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 69 + [#Rule 67 'empty_element', 2, sub -#line 242 "idl.yp" +#line 236 "idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2219,43 +2189,43 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 70 + [#Rule 68 'base_or_empty', 2, undef ], - [#Rule 71 + [#Rule 69 'base_or_empty', 1, undef ], - [#Rule 72 + [#Rule 70 'optional_base_element', 2, sub -#line 256 "idl.yp" +#line 250 "idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], - [#Rule 73 + [#Rule 71 'union_elements', 0, undef ], - [#Rule 74 + [#Rule 72 'union_elements', 2, sub -#line 261 "idl.yp" +#line 255 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 75 + [#Rule 73 'union_body', 3, sub -#line 264 "idl.yp" +#line 258 "idl.yp" { $_[2] } ], - [#Rule 76 + [#Rule 74 'opt_union_body', 0, undef ], - [#Rule 77 + [#Rule 75 'opt_union_body', 1, undef ], - [#Rule 78 + [#Rule 76 'union', 4, sub -#line 268 "idl.yp" +#line 262 "idl.yp" {{ "TYPE" => "UNION", "PROPERTIES" => $_[1], @@ -2263,10 +2233,10 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 79 + [#Rule 77 'base_element', 5, sub -#line 277 "idl.yp" +#line 271 "idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2277,238 +2247,241 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 80 + [#Rule 78 'pointers', 0, sub -#line 291 "idl.yp" +#line 285 "idl.yp" { 0 } ], - [#Rule 81 + [#Rule 79 'pointers', 2, sub -#line 292 "idl.yp" +#line 286 "idl.yp" { $_[1]+1 } ], - [#Rule 82 - 'element_list1', 0, undef + [#Rule 80 + 'element_list1', 0, +sub +#line 290 "idl.yp" +{ [] } ], - [#Rule 83 + [#Rule 81 'element_list1', 3, sub -#line 297 "idl.yp" +#line 291 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 84 + [#Rule 82 'element_list2', 0, undef ], - [#Rule 85 + [#Rule 83 'element_list2', 1, undef ], - [#Rule 86 + [#Rule 84 'element_list2', 1, sub -#line 303 "idl.yp" +#line 297 "idl.yp" { [ $_[1] ] } ], - [#Rule 87 + [#Rule 85 'element_list2', 3, sub -#line 304 "idl.yp" +#line 298 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 88 + [#Rule 86 'array_len', 0, undef ], - [#Rule 89 + [#Rule 87 'array_len', 3, sub -#line 309 "idl.yp" +#line 303 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], - [#Rule 90 + [#Rule 88 'array_len', 4, sub -#line 310 "idl.yp" +#line 304 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], - [#Rule 91 + [#Rule 89 'property_list', 0, undef ], - [#Rule 92 + [#Rule 90 'property_list', 4, sub -#line 316 "idl.yp" +#line 310 "idl.yp" { FlattenHash([$_[1],$_[3]]); } ], - [#Rule 93 + [#Rule 91 'properties', 1, sub -#line 319 "idl.yp" +#line 313 "idl.yp" { $_[1] } ], - [#Rule 94 + [#Rule 92 'properties', 3, sub -#line 320 "idl.yp" +#line 314 "idl.yp" { FlattenHash([$_[1], $_[3]]); } ], - [#Rule 95 + [#Rule 93 'property', 1, sub -#line 323 "idl.yp" +#line 317 "idl.yp" {{ "$_[1]" => "1" }} ], - [#Rule 96 + [#Rule 94 'property', 4, sub -#line 324 "idl.yp" +#line 318 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], - [#Rule 97 + [#Rule 95 'listtext', 1, undef ], - [#Rule 98 + [#Rule 96 'listtext', 3, sub -#line 329 "idl.yp" +#line 323 "idl.yp" { "$_[1] $_[3]" } ], - [#Rule 99 + [#Rule 97 'commalisttext', 1, undef ], - [#Rule 100 + [#Rule 98 'commalisttext', 3, sub -#line 334 "idl.yp" +#line 328 "idl.yp" { "$_[1],$_[3]" } ], - [#Rule 101 + [#Rule 99 'anytext', 0, sub -#line 338 "idl.yp" +#line 332 "idl.yp" { "" } ], + [#Rule 100 + 'anytext', 1, undef + ], + [#Rule 101 + 'anytext', 1, undef + ], [#Rule 102 'anytext', 1, undef ], [#Rule 103 - 'anytext', 1, undef + 'anytext', 3, +sub +#line 334 "idl.yp" +{ "$_[1]$_[2]$_[3]" } ], [#Rule 104 - 'anytext', 1, undef + 'anytext', 3, +sub +#line 335 "idl.yp" +{ "$_[1]$_[2]$_[3]" } ], [#Rule 105 'anytext', 3, sub -#line 340 "idl.yp" +#line 336 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 106 'anytext', 3, sub -#line 341 "idl.yp" +#line 337 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 342 "idl.yp" +#line 338 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 'anytext', 3, sub -#line 343 "idl.yp" +#line 339 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 109 'anytext', 3, sub -#line 344 "idl.yp" +#line 340 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 110 'anytext', 3, sub -#line 345 "idl.yp" +#line 341 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 111 'anytext', 3, sub -#line 346 "idl.yp" +#line 342 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 112 'anytext', 3, sub -#line 347 "idl.yp" +#line 343 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 113 'anytext', 3, sub -#line 348 "idl.yp" +#line 344 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 114 'anytext', 3, sub -#line 349 "idl.yp" +#line 345 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 115 'anytext', 3, sub -#line 350 "idl.yp" +#line 346 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 116 - 'anytext', 3, -sub -#line 351 "idl.yp" -{ "$_[1]$_[2]$_[3]" } - ], - [#Rule 117 - 'anytext', 3, -sub -#line 352 "idl.yp" -{ "$_[1]$_[2]$_[3]" } - ], - [#Rule 118 'anytext', 5, sub -#line 353 "idl.yp" +#line 347 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 119 + [#Rule 117 'anytext', 5, sub -#line 354 "idl.yp" +#line 348 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 120 + [#Rule 118 'identifier', 1, undef ], - [#Rule 121 + [#Rule 119 'optional_identifier', 1, undef ], - [#Rule 122 + [#Rule 120 'optional_identifier', 0, undef ], - [#Rule 123 + [#Rule 121 'constant', 1, undef ], - [#Rule 124 + [#Rule 122 'text', 1, sub -#line 368 "idl.yp" +#line 362 "idl.yp" { "\"$_[1]\"" } ], - [#Rule 125 + [#Rule 123 'optional_semicolon', 0, undef ], - [#Rule 126 + [#Rule 124 'optional_semicolon', 1, undef ] ], @@ -2516,7 +2489,7 @@ sub bless($self,$class); } -#line 379 "idl.yp" +#line 373 "idl.yp" use Parse::Pidl qw(error); @@ -2548,10 +2521,6 @@ sub CleanData($) if (ref($v) eq "ARRAY") { foreach my $i (0 .. $#{$v}) { CleanData($v->[$i]); - if (ref($v->[$i]) eq "ARRAY" && $#{$v->[$i]}==-1) { - $v->[$i] = undef; - next; - } } # this removes any undefined elements from the array @{$v} = grep { defined $_ } @{$v}; @@ -2559,7 +2528,6 @@ sub CleanData($) foreach my $x (keys %{$v}) { CleanData($v->{$x}); if (!defined $v->{$x}) { delete($v->{$x}); next; } - if (ref($v->{$x}) eq "ARRAY" && $#{$v->{$x}}==-1) { delete($v->{$x}); next; } } } return $v; diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index f05e3120c7..88420374ee 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -271,10 +271,13 @@ sub GetElementLevelTable($) ##################################################################### # see if a type contains any deferred data -sub can_contain_deferred +sub can_contain_deferred($) { + sub can_contain_deferred($); my $e = shift; + print "$e->{NAME}\n"; + return 0 if (Parse::Pidl::Typelist::is_scalar($e->{TYPE})); return 1 unless (hasType($e->{TYPE})); # assume the worst -- cgit From f29b5e90b17e9ca3a27a56915a3d75df380b5d09 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 4 Mar 2007 14:31:18 +0000 Subject: r21682: Remove accidently committed debug command. (This used to be commit 74a3681d65f570acf2756b40e0ad82799b86e9ec) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 2 -- 1 file changed, 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 88420374ee..1d7ca16707 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -276,8 +276,6 @@ sub can_contain_deferred($) sub can_contain_deferred($); my $e = shift; - print "$e->{NAME}\n"; - return 0 if (Parse::Pidl::Typelist::is_scalar($e->{TYPE})); return 1 unless (hasType($e->{TYPE})); # assume the worst -- cgit From 452f8e76cb4ca89db11f882e47dd94af06476da5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Mar 2007 23:04:08 +0000 Subject: r21995: Patch from Ronnie Sahlberg. Change the signatures for all functions it generates to specify _U_ so that GCC "parameter not used" warnings are suppressed. (This used to be commit ec6c503e9d077103c3fecff08400beb2a28e462d) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 3c38801fae..279f4c0cf2 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -146,7 +146,7 @@ sub Enum($$$) } pidl_hdr "extern const value_string $valsstring\[];"; - pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 *param);"; + pidl_hdr "int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_);"; pidl_def "const value_string ".$valsstring."[] = {"; foreach (@{$e->{ELEMENTS}}) { @@ -159,7 +159,7 @@ sub Enum($$$) pidl_fn_start $dissectorname; pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 *param)"; + pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_)"; pidl_code "{"; indent; pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, param);"; @@ -180,11 +180,11 @@ sub Bitmap($$$) register_ett("ett_$ifname\_$name"); - pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);"; + pidl_hdr "int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_);"; pidl_fn_start $dissectorname; pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_)"; pidl_code "{"; indent; pidl_code "proto_item *item = NULL;"; @@ -390,10 +390,10 @@ sub Element($$$) foreach (@{$e->{LEVELS}}) { next if ($_->{TYPE} eq "SWITCH"); - pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);"; + pidl_def "static int $dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_);"; pidl_fn_start "$dissectorname$add"; pidl_code "static int"; - pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)"; + pidl_code "$dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; pidl_code "{"; indent; @@ -427,7 +427,7 @@ sub Function($$$) PrintIdl DumpFunction($fn->{ORIGINAL}); pidl_fn_start "$ifname\_dissect\_$fn_name\_response"; pidl_code "static int"; - pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo, proto_tree *tree _U_, guint8 *drep _U_)"; + pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; pidl_code "{"; indent; if ( not defined($fn->{RETURN_TYPE})) { @@ -492,7 +492,7 @@ sub Function($$$) pidl_fn_start "$ifname\_dissect\_$fn_name\_request"; pidl_code "static int"; - pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo, proto_tree *tree _U_, guint8 *drep _U_)"; + pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; pidl_code "{"; indent; pidl_code "pinfo->dcerpc_procedure_name=\"${fn_name}\";"; @@ -522,11 +522,11 @@ sub Struct($$$) my $res = ""; ($res.="\t".Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}}); - pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_);"; + pidl_hdr "int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_);"; pidl_fn_start $dissectorname; pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_)"; pidl_code "{"; indent; pidl_code "proto_item *item = NULL;"; @@ -591,7 +591,7 @@ sub Union($$$) pidl_fn_start $dissectorname; pidl_code "static int"; - pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)"; + pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_)"; pidl_code "{"; indent; pidl_code "proto_item *item = NULL;"; -- cgit From 256054f4e12ddd2d65734cda8a33ee24e50931e8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Mar 2007 23:22:41 +0000 Subject: r21996: Fix a bug for invalid casts of pointers. Patch by Ronnie Sahlberg. (This used to be commit 52a13ddf0242318785b05a8888640b2172435c45) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 279f4c0cf2..e6dd954b74 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -162,7 +162,14 @@ sub Enum($$$) pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_)"; pidl_code "{"; indent; - pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, param);"; + pidl_code "g$e->{BASE_TYPE} parameter;"; + pidl_code "parameter=(g$e->{BASE_TYPE})*param;"; + pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, ¶meter);"; + pidl_code "if(param){"; + indent; + pidl_code "*param=(guint32)parameter;"; + deindent; + pidl_code "}"; pidl_code "return offset;"; deindent; pidl_code "}\n"; -- cgit From cbd42dc5a1a296d0f4038448933d68bc4b94ff22 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 28 Mar 2007 22:52:37 +0000 Subject: r22004: Check for dereferencing null pointers. Patch by Ronnie Sahlberg. (This used to be commit fa5722111dede37d0d6f9a9d227b7ec3ae28f1d4) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index e6dd954b74..51e3933013 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -162,8 +162,12 @@ sub Enum($$$) pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_)"; pidl_code "{"; indent; - pidl_code "g$e->{BASE_TYPE} parameter;"; + pidl_code "g$e->{BASE_TYPE} parameter=0;"; + pidl_code "if(param){"; + indent; pidl_code "parameter=(g$e->{BASE_TYPE})*param;"; + deindent; + pidl_code "}"; pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, ¶meter);"; pidl_code "if(param){"; indent; -- cgit From 2882b2ba63ea65c806643f86d996513414c827d0 Mon Sep 17 00:00:00 2001 From: James Peach Date: Mon, 2 Apr 2007 17:06:14 +0000 Subject: r22029: Make sure we respect $srcdir correctly for the srcdir != builddir case. (This used to be commit 0db4256a472975c5097135fa87315038a1350a72) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index f0c6ae38e8..f6c0ee38f7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -18,8 +18,10 @@ $VERSION = '0.01'; sub is_intree() { - return 4 if (-f "kdc/kdc.c"); - return 3 if (-f "include/smb.h"); + my $srcdir = $ENV{srcdir}; + $srcdir = $srcdir ? "$srcdir/" : ""; + return 4 if (-f "${srcdir}kdc/kdc.c"); + return 3 if (-f "${srcdir}include/smb.h"); return 0; } -- cgit From a0bfcfa55d9f00ffab59e8cf7529cadf108a5629 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 19 Apr 2007 01:26:15 +0000 Subject: r22357: Don't use 'our' (This used to be commit 7989ee2aa015264dc9334b5e15d4fe6cb55f4e09) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 7 ++----- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 8 ++++---- 5 files changed, 12 insertions(+), 15 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 8fa37ca300..a2219bdab2 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -20,8 +20,8 @@ use Parse::Pidl::Samba4 qw(DeclLong); use vars qw($VERSION); $VERSION = '0.01'; -our $res; -our $res_hdr; +my $res; +my $res_hdr; my $tabs = ""; sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 054074297b..ea8a96872c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -21,8 +21,8 @@ use Parse::Pidl::Samba4::NDR::Parser qw(GenerateStructEnv GenerateFunctionInEnv use vars qw($VERSION); $VERSION = '0.01'; -our $res; -our $res_hdr; +my $res; +my $res_hdr; my %constants; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index eaf66ea0c3..719d885c2d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -9,10 +9,7 @@ package Parse::Pidl::Samba4::NDR::Parser; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(is_charset_array); -@EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv - GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction - NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint); +@EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint); use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName); @@ -110,7 +107,7 @@ sub get_value_of($) } } -our $res; +my $res; my $deferred = []; my $tabs = ""; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index f1f23bf84b..dc1c715353 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -17,8 +17,8 @@ $VERSION = '0.01'; use strict; -our $ret; -our $ret_hdr; +my $ret; +my $ret_hdr; my $tabs = ""; sub indent() { $tabs.="\t"; } diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 51e3933013..aafaa3cc2b 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -32,13 +32,13 @@ use File::Basename; use vars qw($VERSION); $VERSION = '0.01'; -our @ett; +my @ett; -our %hf_used = (); +my %hf_used = (); my %return_types = (); my %dissector_used = (); -our $conformance = undef; +my $conformance = undef; my %ptrtype_mappings = ( "unique" => "NDR_POINTER_UNIQUE", @@ -70,7 +70,7 @@ sub field2name($) return $field; } -our %res = (); +my %res = (); my $tabs = ""; my $cur_fn = undef; sub pidl_fn_start($) -- cgit From 3b39a0df0aa941c88a872f24279584cd86558b6c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 22 Apr 2007 10:42:33 +0000 Subject: r22453: Fix TDR testsuite without using our. (This used to be commit 2c82aea0d3cb43b6d653fa7d64d490eddef26903) --- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 213 +++++++++++++++--------------- 1 file changed, 109 insertions(+), 104 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index dc1c715353..a3cb4f3016 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -17,14 +17,16 @@ $VERSION = '0.01'; use strict; -my $ret; -my $ret_hdr; -my $tabs = ""; - -sub indent() { $tabs.="\t"; } -sub deindent() { $tabs = substr($tabs, 1); } -sub pidl($) { $ret .= $tabs.(shift)."\n"; } -sub pidl_hdr($) { $ret_hdr .= (shift)."\n"; } +sub new($) { + my ($class) = shift; + my $self = { ret => "", ret_hdr => "", tabs => "" }; + bless($self, $class); +} + +sub indent($) { my $self = shift; $self->{tabs}.="\t"; } +sub deindent($) { my $self = shift; $self->{tabs} = substr($self->{tabs}, 1); } +sub pidl($$) { my $self = shift; $self->{ret} .= $self->{tabs}.(shift)."\n"; } +sub pidl_hdr($$) { my $self = shift; $self->{ret_hdr} .= (shift)."\n"; } sub typearg($) { my $t = shift; return(", const char *name") if ($t eq "print"); @@ -32,10 +34,14 @@ sub typearg($) { return(""); } -sub fn_declare($$) +sub fn_declare($$$) { - my ($p, $d) = @_; - if ($p) { pidl $d; pidl_hdr "$d;"; } else { pidl "static $d"; } + my ($self, $p, $d) = @_; + if ($p) { + $self->pidl($d); $self->pidl_hdr("$d;"); + } else { + $self->pidl("static $d"); + } } sub ContainsArray($) @@ -50,9 +56,9 @@ sub ContainsArray($) return 0; } -sub ParserElement($$$) +sub ParserElement($$$$) { - my ($e,$t,$env) = @_; + my ($self, $e,$t,$env) = @_; my $switch = ""; my $array = ""; my $name = ""; @@ -67,10 +73,10 @@ sub ParserElement($$$) } if (has_property($e, "flag")) { - pidl "{"; - indent; - pidl "uint32_t saved_flags = tdr->flags;"; - pidl "tdr->flags |= $e->{PROPERTIES}->{flag};"; + $self->pidl("{"); + $self->indent; + $self->pidl("uint32_t saved_flags = tdr->flags;"); + $self->pidl("tdr->flags |= $e->{PROPERTIES}->{flag};"); } if (has_property($e, "charset")) { @@ -79,7 +85,7 @@ sub ParserElement($$$) my $len = ParseExpr(@{$e->{ARRAY_LEN}}[0], $env, $e); if ($len eq "*") { $len = "-1"; } $name = ", mem_ctx" if ($t eq "pull"); - pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));"; + $self->pidl("TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));"); return; } @@ -91,12 +97,12 @@ sub ParserElement($$$) my $len = ParseExpr($e->{ARRAY_LEN}[0], $env, $e); if ($t eq "pull" and not is_constant($len)) { - pidl "TDR_ALLOC(mem_ctx, v->$e->{NAME}, $len);"; + $self->pidl("TDR_ALLOC(mem_ctx, v->$e->{NAME}, $len);"); $mem_ctx = "v->$e->{NAME}"; } - pidl "for (i = 0; i < $len; i++) {"; - indent; + $self->pidl("for (i = 0; i < $len; i++) {"); + $self->indent; $array = "[i]"; } @@ -105,116 +111,116 @@ sub ParserElement($$$) } if (has_property($e, "value") && $t eq "push") { - pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env, $e).";"; + $self->pidl("v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env, $e).";"); } - pidl "TDR_CHECK(tdr_$t\_$e->{TYPE}(tdr$name$switch, &v->$e->{NAME}$array));"; + $self->pidl("TDR_CHECK(tdr_$t\_$e->{TYPE}(tdr$name$switch, &v->$e->{NAME}$array));"); - if ($array) { deindent; pidl "}"; } + if ($array) { $self->deindent; $self->pidl("}"); } if (has_property($e, "flag")) { - pidl "tdr->flags = saved_flags;"; - deindent; - pidl "}"; + $self->pidl("tdr->flags = saved_flags;"); + $self->deindent; + $self->pidl("}"); } } -sub ParserStruct($$$$) +sub ParserStruct($$$$$) { - my ($e,$t,$p) = @_; + my ($self, $e,$t,$p) = @_; - fn_declare($p,"NTSTATUS tdr_$t\_$e->{NAME} (struct tdr_$t *tdr".typearg($t).", struct $e->{NAME} *v)"); - pidl "{"; indent; - pidl "int i;" if (ContainsArray($e)); + $self->fn_declare($p,"NTSTATUS tdr_$t\_$e->{NAME} (struct tdr_$t *tdr".typearg($t).", struct $e->{NAME} *v)"); + $self->pidl("{"); $self->indent; + $self->pidl("int i;") if (ContainsArray($e)); if ($t eq "print") { - pidl "tdr->print(tdr, \"\%-25s: struct $e->{NAME}\", name);"; - pidl "tdr->level++;"; + $self->pidl("tdr->print(tdr, \"\%-25s: struct $e->{NAME}\", name);"); + $self->pidl("tdr->level++;"); } my %env = map { $_->{NAME} => "v->$_->{NAME}" } @{$e->{ELEMENTS}}; $env{"this"} = "v"; - ParserElement($_, $t, \%env) foreach (@{$e->{ELEMENTS}}); + $self->ParserElement($_, $t, \%env) foreach (@{$e->{ELEMENTS}}); if ($t eq "print") { - pidl "tdr->level--;"; + $self->pidl("tdr->level--;"); } - pidl "return NT_STATUS_OK;"; + $self->pidl("return NT_STATUS_OK;"); - deindent; pidl "}"; + $self->deindent; $self->pidl("}"); } -sub ParserUnion($$$) +sub ParserUnion($$$$) { - my ($e,$t,$p) = @_; + my ($self, $e,$t,$p) = @_; - fn_declare($p,"NTSTATUS tdr_$t\_$e->{NAME}(struct tdr_$t *tdr".typearg($t).", int level, union $e->{NAME} *v)"); - pidl "{"; indent; - pidl "int i;" if (ContainsArray($e)); + $self->fn_declare($p,"NTSTATUS tdr_$t\_$e->{NAME}(struct tdr_$t *tdr".typearg($t).", int level, union $e->{NAME} *v)"); + $self->pidl("{"); $self->indent; + $self->pidl("int i;") if (ContainsArray($e)); if ($t eq "print") { - pidl "tdr->print(tdr, \"\%-25s: union $e->{NAME}\", name);"; - pidl "tdr->level++;"; + $self->pidl("tdr->print(tdr, \"\%-25s: union $e->{NAME}\", name);"); + $self->pidl("tdr->level++;"); } - pidl "switch (level) {"; indent; + $self->pidl("switch (level) {"); $self->indent; foreach (@{$e->{ELEMENTS}}) { if (has_property($_, "case")) { - pidl "case " . $_->{PROPERTIES}->{case} . ":"; + $self->pidl("case " . $_->{PROPERTIES}->{case} . ":"); } elsif (has_property($_, "default")) { - pidl "default:"; + $self->pidl("default:"); } - indent; ParserElement($_, $t, {}); deindent; - pidl "break;"; + $self->indent; $self->ParserElement($_, $t, {}); $self->deindent; + $self->pidl("break;"); } - deindent; pidl "}"; + $self->deindent; $self->pidl("}"); if ($t eq "print") { - pidl "tdr->level--;"; + $self->pidl("tdr->level--;"); } - pidl "return NT_STATUS_OK;\n"; - deindent; pidl "}"; + $self->pidl("return NT_STATUS_OK;\n"); + $self->deindent; $self->pidl("}"); } -sub ParserBitmap($$$) +sub ParserBitmap($$$$) { - my ($e,$t,$p) = @_; + my ($self,$e,$t,$p) = @_; return if ($p); - pidl "#define tdr_$t\_$e->{NAME} tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e); + $self->pidl("#define tdr_$t\_$e->{NAME} tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e)); } -sub ParserEnum($$$) +sub ParserEnum($$$$) { - my ($e,$t,$p) = @_; + my ($self,$e,$t,$p) = @_; my $bt = ($e->{PROPERTIES}->{base_type} or "uint8"); - fn_declare($p, "NTSTATUS tdr_$t\_$e->{NAME} (struct tdr_$t *tdr".typearg($t).", enum $e->{NAME} *v)"); - pidl "{"; + $self->fn_declare($p, "NTSTATUS tdr_$t\_$e->{NAME} (struct tdr_$t *tdr".typearg($t).", enum $e->{NAME} *v)"); + $self->pidl("{"); if ($t eq "pull") { - pidl "\t$bt\_t r;"; - pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, mem_ctx, \&r));"; - pidl "\t*v = r;"; + $self->pidl("\t$bt\_t r;"); + $self->pidl("\tTDR_CHECK(tdr_$t\_$bt(tdr, mem_ctx, \&r));"); + $self->pidl("\t*v = r;"); } elsif ($t eq "push") { - pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));"; + $self->pidl("\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));"); } elsif ($t eq "print") { - pidl "\t/* FIXME */"; + $self->pidl("\t/* FIXME */"); } - pidl "\treturn NT_STATUS_OK;"; - pidl "}"; + $self->pidl("\treturn NT_STATUS_OK;"); + $self->pidl("}"); } -sub ParserTypedef($$$) +sub ParserTypedef($$$$) { - my ($e,$t,$p) = @_; + my ($self, $e,$t,$p) = @_; - ParserType($e->{DATA},$t); + $self->ParserType($e->{DATA},$t); } -sub ParserType($$) +sub ParserType($$$) { - my ($e,$t) = @_; + my ($self, $e,$t) = @_; return if (has_property($e, "no$t")); @@ -224,53 +230,52 @@ sub ParserType($$) TYPEDEF => \&ParserTypedef }; - $handlers->{$e->{TYPE}}->($e, $t, has_property($e, "public")) + $handlers->{$e->{TYPE}}->($self, $e, $t, has_property($e, "public")) if (defined($handlers->{$e->{TYPE}})); - pidl ""; + $self->pidl(""); } -sub ParserInterface($) +sub ParserInterface($$) { - my $x = shift; + my ($self,$x) = @_; - pidl_hdr "#ifndef __TDR_$x->{NAME}_HEADER__"; - pidl_hdr "#define __TDR_$x->{NAME}_HEADER__"; + $self->pidl_hdr("#ifndef __TDR_$x->{NAME}_HEADER__"); + $self->pidl_hdr("#define __TDR_$x->{NAME}_HEADER__"); foreach (@{$x->{DATA}}) { - ParserType($_, "pull"); - ParserType($_, "push"); - ParserType($_, "print"); + $self->ParserType($_, "pull"); + $self->ParserType($_, "push"); + $self->ParserType($_, "print"); } - pidl_hdr "#endif /* __TDR_$x->{NAME}_HEADER__ */"; + $self->pidl_hdr("#endif /* __TDR_$x->{NAME}_HEADER__ */"); } -sub Parser($$$) +sub Parser($$$$) { - my ($idl,$hdrname,$baseheader) = @_; - $ret = ""; $ret_hdr = ""; - pidl "/* autogenerated by pidl */"; + my ($self,$idl,$hdrname,$baseheader) = @_; + $self->pidl("/* autogenerated by pidl */"); if (is_intree()) { - pidl "#include \"includes.h\""; + $self->pidl("#include \"includes.h\""); } else { - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; + $self->pidl("#include "); + $self->pidl("#include "); + $self->pidl("#include "); + $self->pidl("#include "); + $self->pidl("#include "); + $self->pidl("#include "); + $self->pidl("#include "); } - pidl "#include \"$hdrname\""; - pidl ""; - pidl_hdr "/* autogenerated by pidl */"; - pidl_hdr "#include \"$baseheader\""; - pidl_hdr choose_header("tdr/tdr.h", "tdr.h"); - pidl_hdr ""; - - foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } - return ($ret_hdr, $ret); + $self->pidl("#include \"$hdrname\""); + $self->pidl(""); + $self->pidl_hdr("/* autogenerated by pidl */"); + $self->pidl_hdr("#include \"$baseheader\""); + $self->pidl_hdr(choose_header("tdr/tdr.h", "tdr.h")); + $self->pidl_hdr(""); + + foreach (@$idl) { $self->ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); } + return ($self->{ret_hdr}, $self->{ret}); } 1; -- cgit From 68d92f0a123374972ee2aa54dd708f089cb59837 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 22 Apr 2007 13:57:07 +0000 Subject: r22456: Merge wireshark and ejs test improvements. (This used to be commit 0375978403dde8ef5052dcca544f118e5387e887) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 616 +++++++++--------- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 919 ++++++++++++++------------- 2 files changed, 768 insertions(+), 767 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index ea8a96872c..0473341db3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -8,8 +8,7 @@ package Parse::Pidl::Samba4::EJS; use Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(get_pointer_to get_value_of check_null_pointer $res - $res_hdr fn_declare TypeFunctionName); +@EXPORT_OK = qw(get_pointer_to get_value_of check_null_pointer fn_declare TypeFunctionName); use strict; use Parse::Pidl::Typelist; @@ -21,36 +20,38 @@ use Parse::Pidl::Samba4::NDR::Parser qw(GenerateStructEnv GenerateFunctionInEnv use vars qw($VERSION); $VERSION = '0.01'; -my $res; -my $res_hdr; - -my %constants; - -my $tabs = ""; +sub new($) { + my ($class) = @_; + my $self = { res => "", res_hdr => "", tabs => "", constants => {}}; + bless($self, $class); +} -sub pidl_hdr ($) +sub pidl_hdr ($$) { - $res_hdr .= shift; + my $self = shift; + $self->{res_hdr} .= shift; } -sub pidl($) +sub pidl($$) { - my $d = shift; + my ($self, $d) = @_; if ($d) { - $res .= $tabs; - $res .= $d; + $self->{res} .= $self->{tabs}; + $self->{res} .= $d; } - $res .= "\n"; + $self->{res} .= "\n"; } -sub indent() +sub indent($) { - $tabs .= "\t"; + my ($self) = @_; + $self->{tabs} .= "\t"; } -sub deindent() +sub deindent($) { - $tabs = substr($tabs, 0, -1); + my ($self) = @_; + $self->{tabs} = substr($self->{tabs}, 0, -1); } sub get_pointer_to($) @@ -79,39 +80,39 @@ sub get_value_of($) ##################################################################### # check that a variable we get from ParseExpr isn't a null pointer -sub check_null_pointer($) +sub check_null_pointer($$) { - my $size = shift; + my ($self, $size) = @_; if ($size =~ /^\*/) { my $size2 = substr($size, 1); - pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; + $self->pidl("if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"); } } ##################################################################### # work out is a parse function should be declared static or not -sub fn_declare($$) +sub fn_declare($$$) { - my ($fn,$decl) = @_; + my ($self,$fn,$decl) = @_; if (has_property($fn, "public")) { - pidl_hdr "$decl;\n"; - pidl "_PUBLIC_ $decl"; + $self->pidl_hdr("$decl;\n"); + $self->pidl("_PUBLIC_ $decl"); } else { - pidl "static $decl"; + $self->pidl("static $decl"); } } ########################### # pull a scalar element -sub EjsPullScalar($$$$$) +sub EjsPullScalar($$$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; return if (has_property($e, "value")); if (ref($e->{TYPE}) eq "HASH" and not defined($e->{TYPE}->{NAME})) { - EjsTypePull($e->{TYPE}, $var); + $self->EjsTypePull($e->{TYPE}, $var); } else { my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l); $var = get_pointer_to($var); @@ -127,50 +128,50 @@ sub EjsPullScalar($$$$$) } else { $t = $e->{TYPE}; } - pidl "NDR_CHECK(ejs_pull_$t(ejs, v, $name, $var));"; + $self->pidl("NDR_CHECK(ejs_pull_$t(ejs, v, $name, $var));"); } } ########################### # pull a pointer element -sub EjsPullPointer($$$$$) +sub EjsPullPointer($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; - pidl "if (ejs_pull_null(ejs, v, $name)) {"; - indent; + my ($self, $e, $l, $var, $name, $env) = @_; + $self->pidl("if (ejs_pull_null(ejs, v, $name)) {"); + $self->indent; if ($l->{POINTER_TYPE} eq "ref") { - pidl "return NT_STATUS_INVALID_PARAMETER_MIX;"; + $self->pidl("return NT_STATUS_INVALID_PARAMETER_MIX;"); } else { - pidl "$var = NULL;"; + $self->pidl("$var = NULL;"); } - deindent; - pidl "} else {"; - indent; - pidl "EJS_ALLOC(ejs, $var);"; + $self->deindent; + $self->pidl("} else {"); + $self->indent; + $self->pidl("EJS_ALLOC(ejs, $var);"); $var = get_value_of($var); - EjsPullElement($e, GetNextLevel($e, $l), $var, $name, $env); - deindent; - pidl "}"; + $self->EjsPullElement($e, GetNextLevel($e, $l), $var, $name, $env); + $self->deindent; + $self->pidl("}"); } ########################### # pull a string element -sub EjsPullString($$$$$) +sub EjsPullString($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; my $pl = GetPrevLevel($e, $l); $var = get_pointer_to($var); if (defined($pl) and $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); } - pidl "NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));"; + $self->pidl("NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));"); } ########################### # pull an array element -sub EjsPullArray($$$$$) +sub EjsPullArray($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; my $nl = GetNextLevel($e, $l); my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); my $size = ParseExpr($l->{SIZE_IS}, $env, $e); @@ -181,121 +182,121 @@ sub EjsPullArray($$$$$) # uint8 arrays are treated as data blobs if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { if (!$l->{IS_FIXED}) { - check_null_pointer($size); - pidl "EJS_ALLOC_N(ejs, $var, $size);"; + $self->check_null_pointer($size); + $self->pidl("EJS_ALLOC_N(ejs, $var, $size);"); } - check_null_pointer($length); - pidl "ejs_pull_array_uint8(ejs, v, $name, $var, $length);"; + $self->check_null_pointer($length); + $self->pidl("ejs_pull_array_uint8(ejs, v, $name, $var, $length);"); return; } my $avar = $var . "[i]"; - pidl "{"; - indent; - pidl "uint32_t i;"; + $self->pidl("{"); + $self->indent; + $self->pidl("uint32_t i;"); if (!$l->{IS_FIXED}) { - pidl "EJS_ALLOC_N(ejs, $var, $size);"; + $self->pidl("EJS_ALLOC_N(ejs, $var, $size);"); } - pidl "for (i=0;i<$length;i++) {"; - indent; - pidl "char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"; - EjsPullElement($e, $nl, $avar, "id", $env); - pidl "talloc_free(id);"; - deindent; - pidl "}"; - pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);"; - deindent; - pidl "}"; + $self->pidl("for (i=0;i<$length;i++) {"); + $self->indent; + $self->pidl("char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"); + $self->EjsPullElement($e, $nl, $avar, "id", $env); + $self->pidl("talloc_free(id);"); + $self->deindent; + $self->pidl("}"); + $self->pidl("ejs_push_uint32(ejs, v, $name \".length\", &i);"); + $self->deindent; + $self->pidl("}"); } ########################### # pull a switch element -sub EjsPullSwitch($$$$$) +sub EjsPullSwitch($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); - pidl "ejs_set_switch(ejs, $switch_var);"; - EjsPullElement($e, GetNextLevel($e, $l), $var, $name, $env); + $self->pidl("ejs_set_switch(ejs, $switch_var);"); + $self->EjsPullElement($e, GetNextLevel($e, $l), $var, $name, $env); } ########################### # pull a structure element -sub EjsPullElement($$$$$) +sub EjsPullElement($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; if (($l->{TYPE} eq "POINTER")) { - EjsPullPointer($e, $l, $var, $name, $env); + $self->EjsPullPointer($e, $l, $var, $name, $env); } elsif (has_property($e, "charset")) { - EjsPullString($e, $l, $var, $name, $env); + $self->EjsPullString($e, $l, $var, $name, $env); } elsif ($l->{TYPE} eq "ARRAY") { - EjsPullArray($e, $l, $var, $name, $env); + $self->EjsPullArray($e, $l, $var, $name, $env); } elsif ($l->{TYPE} eq "DATA") { - EjsPullScalar($e, $l, $var, $name, $env); + $self->EjsPullScalar($e, $l, $var, $name, $env); } elsif (($l->{TYPE} eq "SWITCH")) { - EjsPullSwitch($e, $l, $var, $name, $env); + $self->EjsPullSwitch($e, $l, $var, $name, $env); } else { - pidl "return ejs_panic(ejs, \"unhandled pull type $l->{TYPE}\");"; + $self->pidl("return ejs_panic(ejs, \"unhandled pull type $l->{TYPE}\");"); } } ############################################# # pull a structure/union element at top level -sub EjsPullElementTop($$) +sub EjsPullElementTop($$$) { - my ($e, $env) = @_; + my ($self, $e, $env) = @_; my $l = $e->{LEVELS}[0]; my $var = ParseExpr($e->{NAME}, $env, $e); my $name = "\"$e->{NAME}\""; - EjsPullElement($e, $l, $var, $name, $env); + $self->EjsPullElement($e, $l, $var, $name, $env); } ########################### # pull a struct -sub EjsStructPull($$) +sub EjsStructPull($$$) { - my ($d, $varname) = @_; + my ($self, $d, $varname) = @_; my $env = GenerateStructEnv($d, $varname); - pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; + $self->pidl("NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"); foreach my $e (@{$d->{ELEMENTS}}) { - EjsPullElementTop($e, $env); + $self->EjsPullElementTop($e, $env); } } ########################### # pull a union -sub EjsUnionPull($$) +sub EjsUnionPull($$$) { - my ($d, $varname) = @_; + my ($self, $d, $varname) = @_; my $have_default = 0; - pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"; - pidl "switch (ejs->switch_var) {"; - indent; + $self->pidl("NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"); + $self->pidl("switch (ejs->switch_var) {"); + $self->indent; foreach my $e (@{$d->{ELEMENTS}}) { if ($e->{CASE} eq "default") { $have_default = 1; } - pidl "$e->{CASE}:"; - indent; + $self->pidl("$e->{CASE}:"); + $self->indent; if ($e->{TYPE} ne "EMPTY") { - EjsPullElementTop($e, { $e->{NAME} => "$varname->$e->{NAME}"}); + $self->EjsPullElementTop($e, { $e->{NAME} => "$varname->$e->{NAME}"}); } - pidl "break;"; - deindent; + $self->pidl("break;"); + $self->deindent; } if (! $have_default) { - pidl "default:"; - indent; - pidl "return ejs_panic(ejs, \"Bad switch value\");"; - deindent; + $self->pidl("default:"); + $self->indent; + $self->pidl("return ejs_panic(ejs, \"Bad switch value\");"); + $self->deindent; } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } ############################################## # put the enum elements in the constants array -sub EjsEnumConstant($) +sub EjsEnumConstant($$) { - my $d = shift; + my ($self, $d) = @_; my $v = 0; foreach my $e (@{$d->{ELEMENTS}}) { my $el = $e; @@ -304,73 +305,73 @@ sub EjsEnumConstant($) $el = $1; $v = $2; } - $constants{$el} = $v; + $self->{constants}->{$el} = $v; $v++; } } ########################### # pull a enum -sub EjsEnumPull($$) +sub EjsEnumPull($$$) { - my ($d, $varname) = @_; - EjsEnumConstant($d); - pidl "unsigned e;"; - pidl "NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));"; - pidl "*$varname = e;"; + my ($self, $d, $varname) = @_; + $self->EjsEnumConstant($d); + $self->pidl("unsigned e;"); + $self->pidl("NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));"); + $self->pidl("*$varname = e;"); } ########################### # pull a bitmap -sub EjsBitmapPull($$) +sub EjsBitmapPull($$$) { - my ($d, $varname) = @_; + my ($self, $d, $varname) = @_; my $type_fn = $d->{BASE_TYPE}; - pidl "NDR_CHECK(ejs_pull_$type_fn(ejs, v, name, $varname));"; + $self->pidl("NDR_CHECK(ejs_pull_$type_fn(ejs, v, name, $varname));"); } -sub EjsTypePullFunction($$) +sub EjsTypePullFunction($$$) { - sub EjsTypePullFunction($$); - my ($d, $name) = @_; + sub EjsTypePullFunction($$$); + my ($self, $d, $name) = @_; return if (has_property($d, "noejs")); if ($d->{TYPE} eq "TYPEDEF") { - EjsTypePullFunction($d->{DATA}, $name); + $self->EjsTypePullFunction($d->{DATA}, $name); return; } if ($d->{TYPE} eq "STRUCT") { - fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)"); + $self->fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)"); } elsif ($d->{TYPE} eq "UNION") { - fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)"); + $self->fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)"); } elsif ($d->{TYPE} eq "ENUM") { - fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)"); + $self->fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)"); } elsif ($d->{TYPE} eq "BITMAP") { my($type_decl) = Parse::Pidl::Typelist::mapTypeName($d->{BASE_TYPE}); - fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)"); + $self->fn_declare($d, "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)"); } - pidl "{"; - indent; + $self->pidl("{"); + $self->indent; - EjsTypePull($d, "r"); + $self->EjsTypePull($d, "r"); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; + $self->pidl("return NT_STATUS_OK;"); + $self->deindent; + $self->pidl("}\n"); } -sub EjsTypePull($$) +sub EjsTypePull($$$) { - my ($d, $varname) = @_; + my ($self, $d, $varname) = @_; if ($d->{TYPE} eq 'STRUCT') { - EjsStructPull($d, $varname); + $self->EjsStructPull($d, $varname); } elsif ($d->{TYPE} eq 'UNION') { - EjsUnionPull($d, $varname); + $self->EjsUnionPull($d, $varname); } elsif ($d->{TYPE} eq 'ENUM') { - EjsEnumPull($d, $varname); + $self->EjsEnumPull($d, $varname); } elsif ($d->{TYPE} eq 'BITMAP') { - EjsBitmapPull($d, $varname); + $self->EjsBitmapPull($d, $varname); } else { warn "Unhandled pull $varname of type $d->{TYPE}"; } @@ -378,16 +379,16 @@ sub EjsTypePull($$) ##################### # generate a function -sub EjsPullFunction($) +sub EjsPullFunction($$) { - my $d = shift; + my ($self, $d) = @_; my $env = GenerateFunctionInEnv($d); my $name = $d->{NAME}; - pidl "\nstatic NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, struct $name *r)"; - pidl "{"; - indent; - pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));"; + $self->pidl("\nstatic NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, struct $name *r)"); + $self->pidl("{"); + $self->indent; + $self->pidl("NDR_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));"); # we pull non-array elements before array elements as arrays # may have length_is() or size_is() properties that depend @@ -395,28 +396,28 @@ sub EjsPullFunction($) foreach my $e (@{$d->{ELEMENTS}}) { next unless (grep(/in/, @{$e->{DIRECTION}})); next if (has_property($e, "length_is") || has_property($e, "size_is")); - EjsPullElementTop($e, $env); + $self->EjsPullElementTop($e, $env); } foreach my $e (@{$d->{ELEMENTS}}) { next unless (grep(/in/, @{$e->{DIRECTION}})); next unless (has_property($e, "length_is") || has_property($e, "size_is")); - EjsPullElementTop($e, $env); + $self->EjsPullElementTop($e, $env); } - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; + $self->pidl("return NT_STATUS_OK;"); + $self->deindent; + $self->pidl("}\n"); } ########################### # push a scalar element -sub EjsPushScalar($$$$$) +sub EjsPushScalar($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; if (ref($e->{TYPE}) eq "HASH" and not defined($e->{TYPE}->{NAME})) { - EjsTypePush($e->{TYPE}, get_pointer_to($var)); + $self->EjsTypePush($e->{TYPE}, get_pointer_to($var)); } else { # have to handle strings specially :( my $pl = GetPrevLevel($e, $l); @@ -426,58 +427,58 @@ sub EjsPushScalar($$$$$) $var = get_pointer_to($var); } - pidl "NDR_CHECK(".TypeFunctionName("ejs_push", $e->{TYPE})."(ejs, v, $name, $var));"; + $self->pidl("NDR_CHECK(".TypeFunctionName("ejs_push", $e->{TYPE})."(ejs, v, $name, $var));"); } } ########################### # push a string element -sub EjsPushString($$$$$) +sub EjsPushString($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; my $pl = GetPrevLevel($e, $l); if (defined($pl) and $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); } - pidl "NDR_CHECK(ejs_push_string(ejs, v, $name, $var));"; + $self->pidl("NDR_CHECK(ejs_push_string(ejs, v, $name, $var));"); } ########################### # push a pointer element -sub EjsPushPointer($$$$$) +sub EjsPushPointer($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; - pidl "if (NULL == $var) {"; - indent; + my ($self, $e, $l, $var, $name, $env) = @_; + $self->pidl("if (NULL == $var) {"); + $self->indent; if ($l->{POINTER_TYPE} eq "ref") { - pidl "return NT_STATUS_INVALID_PARAMETER_MIX;"; + $self->pidl("return NT_STATUS_INVALID_PARAMETER_MIX;"); } else { - pidl "NDR_CHECK(ejs_push_null(ejs, v, $name));"; + $self->pidl("NDR_CHECK(ejs_push_null(ejs, v, $name));"); } - deindent; - pidl "} else {"; - indent; + $self->deindent; + $self->pidl("} else {"); + $self->indent; $var = get_value_of($var); - EjsPushElement($e, GetNextLevel($e, $l), $var, $name, $env); - deindent; - pidl "}"; + $self->EjsPushElement($e, GetNextLevel($e, $l), $var, $name, $env); + $self->deindent; + $self->pidl("}"); } ########################### # push a switch element -sub EjsPushSwitch($$$$$) +sub EjsPushSwitch($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; my $switch_var = ParseExpr($l->{SWITCH_IS}, $env, $e); - pidl "ejs_set_switch(ejs, $switch_var);"; - EjsPushElement($e, GetNextLevel($e, $l), $var, $name, $env); + $self->pidl("ejs_set_switch(ejs, $switch_var);"); + $self->EjsPushElement($e, GetNextLevel($e, $l), $var, $name, $env); } ########################### # push an array element -sub EjsPushArray($$$$$) +sub EjsPushArray($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; my $nl = GetNextLevel($e, $l); my $length = ParseExpr($l->{LENGTH_IS}, $env, $e); my $pl = GetPrevLevel($e, $l); @@ -486,130 +487,130 @@ sub EjsPushArray($$$$$) } # uint8 arrays are treated as data blobs if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') { - check_null_pointer($length); - pidl "ejs_push_array_uint8(ejs, v, $name, $var, $length);"; + $self->check_null_pointer($length); + $self->pidl("ejs_push_array_uint8(ejs, v, $name, $var, $length);"); return; } my $avar = $var . "[i]"; - pidl "{"; - indent; - pidl "uint32_t i;"; - pidl "for (i=0;i<$length;i++) {"; - indent; - pidl "const char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"; - EjsPushElement($e, $nl, $avar, "id", $env); - deindent; - pidl "}"; - pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);"; - deindent; - pidl "}"; + $self->pidl("{"); + $self->indent; + $self->pidl("uint32_t i;"); + $self->pidl("for (i=0;i<$length;i++) {"); + $self->indent; + $self->pidl("const char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);"); + $self->EjsPushElement($e, $nl, $avar, "id", $env); + $self->deindent; + $self->pidl("}"); + $self->pidl("ejs_push_uint32(ejs, v, $name \".length\", &i);"); + $self->deindent; + $self->pidl("}"); } ################################ # push a structure/union element -sub EjsPushElement($$$$$) +sub EjsPushElement($$$$$$) { - my ($e, $l, $var, $name, $env) = @_; + my ($self, $e, $l, $var, $name, $env) = @_; if (($l->{TYPE} eq "POINTER")) { - EjsPushPointer($e, $l, $var, $name, $env); + $self->EjsPushPointer($e, $l, $var, $name, $env); } elsif (has_property($e, "charset")) { - EjsPushString($e, $l, $var, $name, $env); + $self->EjsPushString($e, $l, $var, $name, $env); } elsif ($l->{TYPE} eq "ARRAY") { - EjsPushArray($e, $l, $var, $name, $env); + $self->EjsPushArray($e, $l, $var, $name, $env); } elsif ($l->{TYPE} eq "DATA") { - EjsPushScalar($e, $l, $var, $name, $env); + $self->EjsPushScalar($e, $l, $var, $name, $env); } elsif (($l->{TYPE} eq "SWITCH")) { - EjsPushSwitch($e, $l, $var, $name, $env); + $self->EjsPushSwitch($e, $l, $var, $name, $env); } else { - pidl "return ejs_panic(ejs, \"unhandled push type $l->{TYPE}\");"; + $self->pidl("return ejs_panic(ejs, \"unhandled push type $l->{TYPE}\");"); } } ############################################# # push a structure/union element at top level -sub EjsPushElementTop($$) +sub EjsPushElementTop($$$) { - my ($e, $env) = @_; + my ($self, $e, $env) = @_; my $l = $e->{LEVELS}[0]; my $var = ParseExpr($e->{NAME}, $env, $e); my $name = "\"$e->{NAME}\""; - EjsPushElement($e, $l, $var, $name, $env); + $self->EjsPushElement($e, $l, $var, $name, $env); } ########################### # push a struct -sub EjsStructPush($$) +sub EjsStructPush($$$) { - my ($d, $varname) = @_; + my ($self, $d, $varname) = @_; my $env = GenerateStructEnv($d, $varname); - pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; + $self->pidl("NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"); foreach my $e (@{$d->{ELEMENTS}}) { - EjsPushElementTop($e, $env); + $self->EjsPushElementTop($e, $env); } } ########################### # push a union -sub EjsUnionPush($$) +sub EjsUnionPush($$$) { - my ($d, $varname) = @_; + my ($self, $d, $varname) = @_; my $have_default = 0; - pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"; - pidl "switch (ejs->switch_var) {"; - indent; + $self->pidl("NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"); + $self->pidl("switch (ejs->switch_var) {"); + $self->indent; foreach my $e (@{$d->{ELEMENTS}}) { if ($e->{CASE} eq "default") { $have_default = 1; } - pidl "$e->{CASE}:"; - indent; + $self->pidl("$e->{CASE}:"); + $self->indent; if ($e->{TYPE} ne "EMPTY") { - EjsPushElementTop($e, { $e->{NAME} => "$varname->$e->{NAME}"} ); + $self->EjsPushElementTop($e, { $e->{NAME} => "$varname->$e->{NAME}"} ); } - pidl "break;"; - deindent; + $self->pidl("break;"); + $self->deindent; } if (! $have_default) { - pidl "default:"; - indent; - pidl "return ejs_panic(ejs, \"Bad switch value\");"; - deindent; + $self->pidl("default:"); + $self->indent; + $self->pidl("return ejs_panic(ejs, \"Bad switch value\");"); + $self->deindent; } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } ########################### # push a enum -sub EjsEnumPush($$) +sub EjsEnumPush($$$) { - my ($d, $varname) = @_; - EjsEnumConstant($d); - pidl "unsigned e = ".get_value_of($varname).";"; - pidl "NDR_CHECK(ejs_push_enum(ejs, v, name, &e));"; + my ($self, $d, $varname) = @_; + $self->EjsEnumConstant($d); + $self->pidl("unsigned e = ".get_value_of($varname).";"); + $self->pidl("NDR_CHECK(ejs_push_enum(ejs, v, name, &e));"); } ########################### # push a bitmap -sub EjsBitmapPush($$) +sub EjsBitmapPush($$$) { - my ($d, $varname) = @_; + my ($self, $d, $varname) = @_; my $type_fn = $d->{BASE_TYPE}; # put the bitmap elements in the constants array foreach my $e (@{$d->{ELEMENTS}}) { if ($e =~ /^(\w*)\s*(.*)\s*$/) { my $bname = $1; my $v = $2; - $constants{$bname} = $v; + $self->{constants}->{$bname} = $v; } } - pidl "NDR_CHECK(ejs_push_$type_fn(ejs, v, name, $varname));"; + $self->pidl("NDR_CHECK(ejs_push_$type_fn(ejs, v, name, $varname));"); } -sub EjsTypePushFunction($$) +sub EjsTypePushFunction($$$) { - sub EjsTypePushFunction($$); - my ($d, $name) = @_; + sub EjsTypePushFunction($$$); + my ($self, $d, $name) = @_; return if (has_property($d, "noejs")); my $var = undef; @@ -627,30 +628,30 @@ sub EjsTypePushFunction($$) my($type_decl) = Parse::Pidl::Typelist::mapTypeName($dt->{BASE_TYPE}); $var = "const $type_decl *r"; } - fn_declare($d, "NTSTATUS ".TypeFunctionName("ejs_push", $d) . "(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $var)"); - pidl "{"; - indent; - EjsTypePush($d, "r"); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; + $self->fn_declare($d, "NTSTATUS ".TypeFunctionName("ejs_push", $d) . "(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $var)"); + $self->pidl("{"); + $self->indent; + $self->EjsTypePush($d, "r"); + $self->pidl("return NT_STATUS_OK;"); + $self->deindent; + $self->pidl("}\n"); } -sub EjsTypePush($$) +sub EjsTypePush($$$) { - sub EjsTypePush($$); - my ($d, $varname) = @_; + sub EjsTypePush($$$); + my ($self, $d, $varname) = @_; if ($d->{TYPE} eq 'STRUCT') { - EjsStructPush($d, $varname); + $self->EjsStructPush($d, $varname); } elsif ($d->{TYPE} eq 'UNION') { - EjsUnionPush($d, $varname); + $self->EjsUnionPush($d, $varname); } elsif ($d->{TYPE} eq 'ENUM') { - EjsEnumPush($d, $varname); + $self->EjsEnumPush($d, $varname); } elsif ($d->{TYPE} eq 'BITMAP') { - EjsBitmapPush($d, $varname); + $self->EjsBitmapPush($d, $varname); } elsif ($d->{TYPE} eq 'TYPEDEF') { - EjsTypePush($d->{DATA}, $varname); + $self->EjsTypePush($d->{DATA}, $varname); } else { warn "Unhandled push $varname of type $d->{TYPE}"; } @@ -658,145 +659,142 @@ sub EjsTypePush($$) ##################### # generate a function -sub EjsPushFunction($) +sub EjsPushFunction($$) { - my $d = shift; + my ($self, $d) = @_; my $env = GenerateFunctionOutEnv($d); - pidl "\nstatic NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const struct $d->{NAME} *r)"; - pidl "{"; - indent; - pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));"; + $self->pidl("\nstatic NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const struct $d->{NAME} *r)"); + $self->pidl("{"); + $self->indent; + $self->pidl("NDR_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));"); foreach my $e (@{$d->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); - EjsPushElementTop($e, $env); + $self->EjsPushElementTop($e, $env); } if ($d->{RETURN_TYPE}) { - pidl "NDR_CHECK(".TypeFunctionName("ejs_push", $d->{RETURN_TYPE})."(ejs, v, \"result\", &r->out.result));"; + $self->pidl("NDR_CHECK(".TypeFunctionName("ejs_push", $d->{RETURN_TYPE})."(ejs, v, \"result\", &r->out.result));"); } - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}\n"; + $self->pidl("return NT_STATUS_OK;"); + $self->deindent; + $self->pidl("}\n"); } ################################# # generate a ejs mapping function -sub EjsFunction($$) +sub EjsFunction($$$) { - my ($d, $iface) = @_; + my ($self, $d, $iface) = @_; my $name = $d->{NAME}; my $callnum = uc("DCERPC_$name"); my $table = "&dcerpc_table_$iface"; - pidl "static int ejs_$name(int eid, int argc, struct MprVar **argv)"; - pidl "{"; - indent; - pidl "return ejs_rpc_call(eid, argc, argv, $table, $callnum, (ejs_pull_function_t)ejs_pull_$name, (ejs_push_function_t)ejs_push_$name);"; - deindent; - pidl "}\n"; + $self->pidl("static int ejs_$name(int eid, int argc, struct MprVar **argv)"); + $self->pidl("{"); + $self->indent; + $self->pidl("return ejs_rpc_call(eid, argc, argv, $table, $callnum, (ejs_pull_function_t)ejs_pull_$name, (ejs_push_function_t)ejs_push_$name);"); + $self->deindent; + $self->pidl("}\n"); } ################### # handle a constant -sub EjsConst($) +sub EjsConst($$) { - my $const = shift; - $constants{$const->{NAME}} = $const->{VALUE}; + my ($self, $const) = @_; + $self->{constants}->{$const->{NAME}} = $const->{VALUE}; } sub EjsImport { + my $self = shift; my @imports = @_; foreach (@imports) { s/\.idl\"$//; s/^\"//; - pidl_hdr "#include \"librpc/gen_ndr/ndr_$_\_ejs\.h\"\n"; + $self->pidl_hdr("#include \"librpc/gen_ndr/ndr_$_\_ejs\.h\"\n"); } } ##################################################################### # parse the interface definitions -sub EjsInterface($$) +sub EjsInterface($$$) { - my($interface,$needed) = @_; + my($self,$interface,$needed) = @_; my @fns = (); my $name = $interface->{NAME}; - %constants = (); - - pidl_hdr "#ifndef _HEADER_EJS_$interface->{NAME}\n"; - pidl_hdr "#define _HEADER_EJS_$interface->{NAME}\n\n"; + $self->pidl_hdr("#ifndef _HEADER_EJS_$interface->{NAME}\n"); + $self->pidl_hdr("#define _HEADER_EJS_$interface->{NAME}\n\n"); - pidl_hdr "\n"; + $self->pidl_hdr("\n"); foreach my $d (@{$interface->{TYPES}}) { - ($needed->{TypeFunctionName("ejs_push", $d)}) && EjsTypePushFunction($d, $d->{NAME}); - ($needed->{TypeFunctionName("ejs_pull", $d)}) && EjsTypePullFunction($d, $d->{NAME}); + ($needed->{TypeFunctionName("ejs_push", $d)}) && $self->EjsTypePushFunction($d, $d->{NAME}); + ($needed->{TypeFunctionName("ejs_pull", $d)}) && $self->EjsTypePullFunction($d, $d->{NAME}); } foreach my $d (@{$interface->{FUNCTIONS}}) { next if not defined($d->{OPNUM}); next if has_property($d, "noejs"); - EjsPullFunction($d); - EjsPushFunction($d); - EjsFunction($d, $name); + $self->EjsPullFunction($d); + $self->EjsPushFunction($d); + $self->EjsFunction($d, $name); push (@fns, $d->{NAME}); } foreach my $d (@{$interface->{CONSTS}}) { - EjsConst($d); + $self->EjsConst($d); } - pidl "static int ejs_$name\_init(int eid, int argc, struct MprVar **argv)"; - pidl "{"; - indent; - pidl "struct MprVar *obj = mprInitObject(eid, \"$name\", argc, argv);"; + $self->pidl("static int ejs_$name\_init(int eid, int argc, struct MprVar **argv)"); + $self->pidl("{"); + $self->indent; + $self->pidl("struct MprVar *obj = mprInitObject(eid, \"$name\", argc, argv);"); foreach (@fns) { - pidl "mprSetCFunction(obj, \"$_\", ejs_$_);"; + $self->pidl("mprSetCFunction(obj, \"$_\", ejs_$_);"); } - foreach my $v (keys %constants) { - my $value = $constants{$v}; + foreach my $v (keys %{$self->{constants}}) { + my $value = $self->{constants}->{$v}; if (substr($value, 0, 1) eq "\"") { - pidl "mprSetVar(obj, \"$v\", mprString($value));"; + $self->pidl("mprSetVar(obj, \"$v\", mprString($value));"); } else { - pidl "mprSetVar(obj, \"$v\", mprCreateNumberVar($value));"; + $self->pidl("mprSetVar(obj, \"$v\", mprCreateNumberVar($value));"); } } - pidl "return ejs_rpc_init(obj, \"$name\");"; - deindent; - pidl "}\n"; + $self->pidl("return ejs_rpc_init(obj, \"$name\");"); + $self->deindent; + $self->pidl("}\n"); - pidl "NTSTATUS ejs_init_$name(void)"; - pidl "{"; - indent; - pidl "ejsDefineCFunction(-1, \"$name\_init\", ejs_$name\_init, NULL, MPR_VAR_SCRIPT_HANDLE);"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; + $self->pidl("NTSTATUS ejs_init_$name(void)"); + $self->pidl("{"); + $self->indent; + $self->pidl("ejsDefineCFunction(-1, \"$name\_init\", ejs_$name\_init, NULL, MPR_VAR_SCRIPT_HANDLE);"); + $self->pidl("return NT_STATUS_OK;"); + $self->deindent; + $self->pidl("}"); - pidl_hdr "\n"; - pidl_hdr "#endif /* _HEADER_EJS_$interface->{NAME} */\n"; + $self->pidl_hdr("\n"); + $self->pidl_hdr("#endif /* _HEADER_EJS_$interface->{NAME} */\n"); } ##################################################################### # parse a parsed IDL into a C header -sub Parse($$) +sub Parse($$$) { - my($ndr,$hdr) = @_; + my($self,$ndr,$hdr) = @_; my $ejs_hdr = $hdr; $ejs_hdr =~ s/.h$/_ejs.h/; - $res = ""; - $res_hdr = ""; - pidl_hdr "/* header auto-generated by pidl */\n\n"; + $self->pidl_hdr("/* header auto-generated by pidl */\n\n"); - pidl " + $self->pidl(" /* EJS wrapper functions auto-generated by pidl */ #include \"includes.h\" #include \"librpc/rpc/dcerpc.h\" @@ -807,7 +805,7 @@ sub Parse($$) #include \"$hdr\" #include \"$ejs_hdr\" -"; +"); my %needed = (); @@ -816,11 +814,11 @@ sub Parse($$) } foreach my $x (@$ndr) { - ($x->{TYPE} eq "INTERFACE") && EjsInterface($x, \%needed); - ($x->{TYPE} eq "IMPORT") && EjsImport(@{$x->{PATHS}}); + ($x->{TYPE} eq "INTERFACE") && $self->EjsInterface($x, \%needed); + ($x->{TYPE} eq "IMPORT") && $self->EjsImport(@{$x->{PATHS}}); } - return ($res_hdr, $res); + return ($self->{res_hdr}, $self->{res}); } sub NeededFunction($$) diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index aafaa3cc2b..523fff9537 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -18,7 +18,7 @@ package Parse::Pidl::Wireshark::NDR; use Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(field2name @ett %res PrintIdl StripPrefixes %hf_used RegisterInterfaceHandoff $conformance register_hf_field CheckUsed ProcessImport ProcessInclude find_type DumpEttList DumpEttDeclaration DumpHfList DumpHfDeclaration DumpFunctionTable register_type register_ett); +@EXPORT_OK = qw(field2name %res PrintIdl StripPrefixes RegisterInterfaceHandoff register_hf_field CheckUsed ProcessImport ProcessInclude find_type DumpEttList DumpEttDeclaration DumpHfList DumpHfDeclaration DumpFunctionTable register_type register_ett); use strict; use Parse::Pidl qw(error warning); @@ -32,14 +32,9 @@ use File::Basename; use vars qw($VERSION); $VERSION = '0.01'; -my @ett; - -my %hf_used = (); my %return_types = (); my %dissector_used = (); -my $conformance = undef; - my %ptrtype_mappings = ( "unique" => "NDR_POINTER_UNIQUE", "ref" => "NDR_POINTER_REF", @@ -70,157 +65,166 @@ sub field2name($) return $field; } -my %res = (); -my $tabs = ""; -my $cur_fn = undef; -sub pidl_fn_start($) +sub new($) { - my $fn = shift; - $cur_fn = $fn; + my ($class) = @_; + my $self = {res => {hdr => "", def => "", code => ""}, tabs => "", cur_fn => undef, + hf_used => {}, ett => [], conformance => undef + + }; + bless($self, $class); } -sub pidl_fn_end($) + +sub pidl_fn_start($$) { - my $fn = shift; - die("Inconsistent state: $fn != $cur_fn") if ($fn ne $cur_fn); - $cur_fn = undef; + my ($self, $fn) = @_; + $self->{cur_fn} = $fn; +} +sub pidl_fn_end($$) +{ + my ($self, $fn) = @_; + die("Inconsistent state: $fn != $self->{cur_fn}") if ($fn ne $self->{cur_fn}); + $self->{cur_fn} = undef; } -sub pidl_code($) +sub pidl_code($$) { - my $d = shift; - return if (defined($cur_fn) and defined($conformance->{manual}->{$cur_fn})); + my ($self, $d) = @_; + return if (defined($self->{cur_fn}) and defined($self->{conformance}->{manual}->{$self->{cur_fn}})); if ($d) { - $res{code} .= $tabs; - $res{code} .= $d; + $self->{res}->{code} .= $self->{tabs}; + $self->{res}->{code} .= $d; } - $res{code} .="\n"; + $self->{res}->{code} .="\n"; } -sub pidl_hdr($) { my $x = shift; $res{hdr} .= "$x\n"; } -sub pidl_def($) { my $x = shift; $res{def} .= "$x\n"; } +sub pidl_hdr($$) { my ($self,$x) = @_; $self->{res}->{hdr} .= "$x\n"; } +sub pidl_def($$) { my ($self,$x) = @_; $self->{res}->{def} .= "$x\n"; } -sub indent() +sub indent($) { - $tabs .= "\t"; + my ($self) = @_; + $self->{tabs} .= "\t"; } -sub deindent() +sub deindent($) { - $tabs = substr($tabs, 0, -1); + my ($self) = @_; + $self->{tabs} = substr($self->{tabs}, 0, -1); } -sub PrintIdl($) +sub PrintIdl($$) { - my ($idl) = @_; + my ($self, $idl) = @_; foreach (split /\n/, $idl) { - pidl_code "/* IDL: $_ */"; + $self->pidl_code("/* IDL: $_ */"); } - pidl_code ""; + $self->pidl_code(""); } ##################################################################### # parse the interface definitions -sub Interface($) +sub Interface($$) { - my($interface) = @_; - Const($_,$interface->{NAME}) foreach (@{$interface->{CONSTS}}); - Type($_, $_->{NAME}, $interface->{NAME}) foreach (@{$interface->{TYPES}}); - Function($_,$interface->{NAME}) foreach (@{$interface->{FUNCTIONS}}); + my($self, $interface) = @_; + $self->Const($_,$interface->{NAME}) foreach (@{$interface->{CONSTS}}); + $self->Type($_, $_->{NAME}, $interface->{NAME}) foreach (@{$interface->{TYPES}}); + $self->Function($_,$interface->{NAME}) foreach (@{$interface->{FUNCTIONS}}); } -sub Enum($$$) +sub Enum($$$$) { - my ($e,$name,$ifname) = @_; + my ($self, $e,$name,$ifname) = @_; my $valsstring = "$ifname\_$name\_vals"; - my $dissectorname = "$ifname\_dissect\_enum\_".StripPrefixes($name, $conformance->{strip_prefixes}); + my $dissectorname = "$ifname\_dissect\_enum\_".StripPrefixes($name, $self->{conformance}->{strip_prefixes}); - return if (defined($conformance->{noemit}->{StripPrefixes($name, $conformance->{strip_prefixes})})); + return if (defined($self->{conformance}->{noemit}->{StripPrefixes($name, $self->{conformance}->{strip_prefixes})})); foreach (@{$e->{ELEMENTS}}) { if (/([^=]*)=(.*)/) { - pidl_hdr "#define $1 ($2)"; + $self->pidl_hdr("#define $1 ($2)"); } } - pidl_hdr "extern const value_string $valsstring\[];"; - pidl_hdr "int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_);"; + $self->pidl_hdr("extern const value_string $valsstring\[];"); + $self->pidl_hdr("int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_);"); - pidl_def "const value_string ".$valsstring."[] = {"; + $self->pidl_def("const value_string ".$valsstring."[] = {"); foreach (@{$e->{ELEMENTS}}) { next unless (/([^=]*)=(.*)/); - pidl_def "\t{ $1, \"$1\" },"; + $self->pidl_def("\t{ $1, \"$1\" },"); } - pidl_def "{ 0, NULL }"; - pidl_def "};"; - - pidl_fn_start $dissectorname; - pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_)"; - pidl_code "{"; - indent; - pidl_code "g$e->{BASE_TYPE} parameter=0;"; - pidl_code "if(param){"; - indent; - pidl_code "parameter=(g$e->{BASE_TYPE})*param;"; - deindent; - pidl_code "}"; - pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, ¶meter);"; - pidl_code "if(param){"; - indent; - pidl_code "*param=(guint32)parameter;"; - deindent; - pidl_code "}"; - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end $dissectorname; + $self->pidl_def("{ 0, NULL }"); + $self->pidl_def("};"); + + $self->pidl_fn_start($dissectorname); + $self->pidl_code("int"); + $self->pidl_code("$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 *param _U_)"); + $self->pidl_code("{"); + $self->indent; + $self->pidl_code("g$e->{BASE_TYPE} parameter=0;"); + $self->pidl_code("if(param){"); + $self->indent; + $self->pidl_code("parameter=(g$e->{BASE_TYPE})*param;"); + $self->deindent; + $self->pidl_code("}"); + $self->pidl_code("offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, ¶meter);"); + $self->pidl_code("if(param){"); + $self->indent; + $self->pidl_code("*param=(guint32)parameter;"); + $self->deindent; + $self->pidl_code("}"); + $self->pidl_code("return offset;"); + $self->deindent; + $self->pidl_code("}\n"); + $self->pidl_fn_end($dissectorname); my $enum_size = $e->{BASE_TYPE}; $enum_size =~ s/uint//g; - register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$enum_size", "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8); + $self->register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$enum_size", "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8); } -sub Bitmap($$$) +sub Bitmap($$$$) { - my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_bitmap\_".StripPrefixes($name, $conformance->{strip_prefixes}); + my ($self,$e,$name,$ifname) = @_; + my $dissectorname = "$ifname\_dissect\_bitmap\_".StripPrefixes($name, $self->{conformance}->{strip_prefixes}); - register_ett("ett_$ifname\_$name"); + $self->register_ett("ett_$ifname\_$name"); - pidl_hdr "int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_);"; + $self->pidl_hdr("int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_);"); - pidl_fn_start $dissectorname; - pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_)"; - pidl_code "{"; - indent; - pidl_code "proto_item *item = NULL;"; - pidl_code "proto_tree *tree = NULL;"; - pidl_code ""; + $self->pidl_fn_start($dissectorname); + $self->pidl_code("int"); + $self->pidl_code("$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_)"); + $self->pidl_code("{"); + $self->indent; + $self->pidl_code("proto_item *item = NULL;"); + $self->pidl_code("proto_tree *tree = NULL;"); + $self->pidl_code(""); - pidl_code "g$e->{BASE_TYPE} flags;"; + $self->pidl_code("g$e->{BASE_TYPE} flags;"); if ($e->{ALIGN} > 1) { - pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; + $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;"); } - pidl_code ""; + $self->pidl_code(""); - pidl_code "if (parent_tree) {"; - indent; - pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);"; - pidl_code "tree = proto_item_add_subtree(item,ett_$ifname\_$name);"; - deindent; - pidl_code "}\n"; + $self->pidl_code("if (parent_tree) {"); + $self->indent; + $self->pidl_code("item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);"); + $self->pidl_code("tree = proto_item_add_subtree(item,ett_$ifname\_$name);"); + $self->deindent; + $self->pidl_code("}\n"); - pidl_code "offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);"; + $self->pidl_code("offset = dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);"); - pidl_code "proto_item_append_text(item, \": \");\n"; - pidl_code "if (!flags)"; - pidl_code "\tproto_item_append_text(item, \"(No values set)\");\n"; + $self->pidl_code("proto_item_append_text(item, \": \");\n"); + $self->pidl_code("if (!flags)"); + $self->pidl_code("\tproto_item_append_text(item, \"(No values set)\");\n"); foreach (@{$e->{ELEMENTS}}) { next unless (/([^ ]*) (.*)/); @@ -228,52 +232,52 @@ sub Bitmap($$$) my $hf_bitname = "hf_$ifname\_$name\_$en"; my $filtername = "$ifname\.$name\.$en"; - $hf_used{$hf_bitname} = 1; + $self->{hf_used}->{$hf_bitname} = 1; - register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, ""); + $self->register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, ""); - pidl_def "static const true_false_string $name\_$en\_tfs = {"; - if (defined($conformance->{tfs}->{$hf_bitname})) { - pidl_def " $conformance->{tfs}->{$hf_bitname}->{TRUE_STRING},"; - pidl_def " $conformance->{tfs}->{$hf_bitname}->{FALSE_STRING},"; - $conformance->{tfs}->{$hf_bitname}->{USED} = 1; + $self->pidl_def("static const true_false_string $name\_$en\_tfs = {"); + if (defined($self->{conformance}->{tfs}->{$hf_bitname})) { + $self->pidl_def(" $self->{conformance}->{tfs}->{$hf_bitname}->{TRUE_STRING},"); + $self->pidl_def(" $self->{conformance}->{tfs}->{$hf_bitname}->{FALSE_STRING},"); + $self->{conformance}->{tfs}->{$hf_bitname}->{USED} = 1; } else { - pidl_def " \"$en is SET\","; - pidl_def " \"$en is NOT SET\","; + $self->pidl_def(" \"$en is SET\","); + $self->pidl_def(" \"$en is NOT SET\","); } - pidl_def "};"; + $self->pidl_def("};"); - pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);"; - pidl_code "if (flags&$ev){"; - pidl_code "\tproto_item_append_text(item, \"$en\");"; - pidl_code "\tif (flags & (~$ev))"; - pidl_code "\t\tproto_item_append_text(item, \", \");"; - pidl_code "}"; - pidl_code "flags&=(~$ev);"; - pidl_code ""; + $self->pidl_code("proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);"); + $self->pidl_code("if (flags&$ev){"); + $self->pidl_code("\tproto_item_append_text(item, \"$en\");"); + $self->pidl_code("\tif (flags & (~$ev))"); + $self->pidl_code("\t\tproto_item_append_text(item, \", \");"); + $self->pidl_code("}"); + $self->pidl_code("flags&=(~$ev);"); + $self->pidl_code(""); } - pidl_code "if (flags) {"; - pidl_code "\tproto_item_append_text(item, \"Unknown bitmap value 0x%x\", flags);"; - pidl_code "}\n"; - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end $dissectorname; + $self->pidl_code("if (flags) {"); + $self->pidl_code("\tproto_item_append_text(item, \"Unknown bitmap value 0x%x\", flags);"); + $self->pidl_code("}\n"); + $self->pidl_code("return offset;"); + $self->deindent; + $self->pidl_code("}\n"); + $self->pidl_fn_end($dissectorname); my $size = $e->{BASE_TYPE}; $size =~ s/uint//g; - register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$size", "BASE_HEX", "0", "NULL", $size/8); + $self->register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$size", "BASE_HEX", "0", "NULL", $size/8); } -sub ElementLevel($$$$$$) +sub ElementLevel($$$$$$$) { - my ($e,$l,$hf,$myname,$pn,$ifname) = @_; + my ($self,$e,$l,$hf,$myname,$pn,$ifname) = @_; my $param = 0; - if (defined($conformance->{dissectorparams}->{$myname})) { - $param = $conformance->{dissectorparams}->{$myname}->{PARAM}; + if (defined($self->{conformance}->{dissectorparams}->{$myname})) { + $param = $self->{conformance}->{dissectorparams}->{$myname}->{PARAM}; } if ($l->{TYPE} eq "POINTER") { @@ -283,27 +287,27 @@ sub ElementLevel($$$$$$) } elsif ($l->{LEVEL} eq "EMBEDDED") { $type = "embedded"; } - pidl_code "offset = dissect_ndr_$type\_pointer(tvb, offset, pinfo, tree, drep, $myname\_, $ptrtype_mappings{$l->{POINTER_TYPE}}, \"Pointer to ".field2name(StripPrefixes($e->{NAME}, $conformance->{strip_prefixes})) . " ($e->{TYPE})\",$hf);"; + $self->pidl_code("offset = dissect_ndr_$type\_pointer(tvb, offset, pinfo, tree, drep, $myname\_, $ptrtype_mappings{$l->{POINTER_TYPE}}, \"Pointer to ".field2name(StripPrefixes($e->{NAME}, $self->{conformance}->{strip_prefixes})) . " ($e->{TYPE})\",$hf);"); } elsif ($l->{TYPE} eq "ARRAY") { if ($l->{IS_INLINE}) { error($e->{ORIGINAL}, "Inline arrays not supported"); } elsif ($l->{IS_FIXED}) { - pidl_code "int i;"; - pidl_code "for (i = 0; i < $l->{SIZE_IS}; i++)"; - pidl_code "\toffset = $myname\_(tvb, offset, pinfo, tree, drep);"; + $self->pidl_code("int i;"); + $self->pidl_code("for (i = 0; i < $l->{SIZE_IS}; i++)"); + $self->pidl_code("\toffset = $myname\_(tvb, offset, pinfo, tree, drep);"); } else { my $type = ""; $type .= "c" if ($l->{IS_CONFORMANT}); $type .= "v" if ($l->{IS_VARYING}); unless ($l->{IS_ZERO_TERMINATED}) { - pidl_code "offset = dissect_ndr_u" . $type . "array(tvb, offset, pinfo, tree, drep, $myname\_);"; + $self->pidl_code("offset = dissect_ndr_u" . $type . "array(tvb, offset, pinfo, tree, drep, $myname\_);"); } else { my $nl = GetNextLevel($e,$l); - pidl_code "char *data;"; - pidl_code ""; - pidl_code "offset = dissect_ndr_$type" . "string(tvb, offset, pinfo, tree, drep, sizeof(g$nl->{DATA_TYPE}), $hf, FALSE, &data);"; - pidl_code "proto_item_append_text(tree, \": %s\", data);"; + $self->pidl_code("char *data;"); + $self->pidl_code(""); + $self->pidl_code("offset = dissect_ndr_$type" . "string(tvb, offset, pinfo, tree, drep, sizeof(g$nl->{DATA_TYPE}), $hf, FALSE, &data);"); + $self->pidl_code("proto_item_append_text(tree, \": %s\", data);"); } } } elsif ($l->{TYPE} eq "DATA") { @@ -314,47 +318,47 @@ sub ElementLevel($$$$$$) ($bs = 1) if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_ASCII.*")); if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) { - pidl_code "char *data;\n"; - pidl_code "offset = dissect_ndr_cvstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, &data);"; - pidl_code "proto_item_append_text(tree, \": %s\", data);"; + $self->pidl_code("char *data;\n"); + $self->pidl_code("offset = dissect_ndr_cvstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, &data);"); + $self->pidl_code("proto_item_append_text(tree, \": %s\", data);"); } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*")) { - pidl_code "offset = dissect_ndr_vstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, NULL);"; + $self->pidl_code("offset = dissect_ndr_vstring(tvb, offset, pinfo, tree, drep, $bs, $hf, FALSE, NULL);"); } else { warn("Unable to handle string with flags $e->{PROPERTIES}->{flag}"); } } else { my $call; - if ($conformance->{imports}->{$l->{DATA_TYPE}}) { - $call = $conformance->{imports}->{$l->{DATA_TYPE}}->{DATA}; - $conformance->{imports}->{$l->{DATA_TYPE}}->{USED} = 1; - } elsif (defined($conformance->{imports}->{"$pn.$e->{NAME}"})) { - $call = $conformance->{imports}->{"$pn.$e->{NAME}"}->{DATA}; - $conformance->{imports}->{"$pn.$e->{NAME}"}->{USED} = 1; + if ($self->{conformance}->{imports}->{$l->{DATA_TYPE}}) { + $call = $self->{conformance}->{imports}->{$l->{DATA_TYPE}}->{DATA}; + $self->{conformance}->{imports}->{$l->{DATA_TYPE}}->{USED} = 1; + } elsif (defined($self->{conformance}->{imports}->{"$pn.$e->{NAME}"})) { + $call = $self->{conformance}->{imports}->{"$pn.$e->{NAME}"}->{DATA}; + $self->{conformance}->{imports}->{"$pn.$e->{NAME}"}->{USED} = 1; - } elsif (defined($conformance->{types}->{$l->{DATA_TYPE}})) { - $call= $conformance->{types}->{$l->{DATA_TYPE}}->{DISSECTOR_NAME}; - $conformance->{types}->{$l->{DATA_TYPE}}->{USED} = 1; + } elsif (defined($self->{conformance}->{types}->{$l->{DATA_TYPE}})) { + $call= $self->{conformance}->{types}->{$l->{DATA_TYPE}}->{DISSECTOR_NAME}; + $self->{conformance}->{types}->{$l->{DATA_TYPE}}->{USED} = 1; } else { - pidl_code "offset = $ifname\_dissect_struct_" . $l->{DATA_TYPE} . "(tvb,offset,pinfo,tree,drep,$hf,$param);"; + $self->pidl_code("offset = $ifname\_dissect_struct_" . $l->{DATA_TYPE} . "(tvb,offset,pinfo,tree,drep,$hf,$param);"); return; } $call =~ s/\@HF\@/$hf/g; $call =~ s/\@PARAM\@/$param/g; - pidl_code "$call"; + $self->pidl_code($call); } } elsif ($_->{TYPE} eq "SUBCONTEXT") { my $num_bits = ($l->{HEADER_SIZE}*8); - pidl_code "guint$num_bits size;"; - pidl_code "int start_offset = offset;"; - pidl_code "tvbuff_t *subtvb;"; - pidl_code "offset = dissect_ndr_uint$num_bits(tvb, offset, pinfo, tree, drep, $hf, &size);"; - pidl_code "proto_tree_add_text(tree, tvb, start_offset, offset - start_offset + size, \"Subcontext size\");"; - - pidl_code "subtvb = tvb_new_subset(tvb, offset, size, -1);"; - pidl_code "$myname\_(subtvb, 0, pinfo, tree, drep);"; + $self->pidl_code("guint$num_bits size;"); + $self->pidl_code("int start_offset = offset;"); + $self->pidl_code("tvbuff_t *subtvb;"); + $self->pidl_code("offset = dissect_ndr_uint$num_bits(tvb, offset, pinfo, tree, drep, $hf, &size);"); + $self->pidl_code("proto_tree_add_text(tree, tvb, start_offset, offset - start_offset + size, \"Subcontext size\");"); + + $self->pidl_code("subtvb = tvb_new_subset(tvb, offset, size, -1);"); + $self->pidl_code("$myname\_(subtvb, 0, pinfo, tree, drep);"); } else { die("Unknown type `$_->{TYPE}'"); } @@ -362,13 +366,13 @@ sub ElementLevel($$$$$$) sub Element($$$) { - my ($e,$pn,$ifname) = @_; + my ($self,$e,$pn,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_element\_".StripPrefixes($pn, $conformance->{strip_prefixes})."\_".StripPrefixes($e->{NAME}, $conformance->{strip_prefixes}); + my $dissectorname = "$ifname\_dissect\_element\_".StripPrefixes($pn, $self->{conformance}->{strip_prefixes})."\_".StripPrefixes($e->{NAME}, $self->{conformance}->{strip_prefixes}); my $call_code = "offset = $dissectorname(tvb, offset, pinfo, tree, drep);"; - my $type = find_type($e->{TYPE}); + my $type = $self->find_type($e->{TYPE}); if (not defined($type)) { # default settings @@ -389,11 +393,11 @@ sub Element($$$) }; } - my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", $type->{FT_TYPE}, $type->{BASE_TYPE}, $type->{VALSSTRING}, $type->{MASK}, ""); - $hf_used{$hf} = 1; + my $hf = $self->register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", $type->{FT_TYPE}, $type->{BASE_TYPE}, $type->{VALSSTRING}, $type->{MASK}, ""); + $self->{hf_used}->{$hf} = 1; - my $eltname = StripPrefixes($pn, $conformance->{strip_prefixes}) . ".$e->{NAME}"; - if (defined($conformance->{noemit}->{$eltname})) { + my $eltname = StripPrefixes($pn, $self->{conformance}->{strip_prefixes}) . ".$e->{NAME}"; + if (defined($self->{conformance}->{noemit}->{$eltname})) { return $call_code; } @@ -401,20 +405,20 @@ sub Element($$$) foreach (@{$e->{LEVELS}}) { next if ($_->{TYPE} eq "SWITCH"); - pidl_def "static int $dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_);"; - pidl_fn_start "$dissectorname$add"; - pidl_code "static int"; - pidl_code "$dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; - pidl_code "{"; - indent; - - ElementLevel($e,$_,$hf,$dissectorname.$add,$pn,$ifname); - - pidl_code ""; - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end "$dissectorname$add"; + $self->pidl_def("static int $dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_);"); + $self->pidl_fn_start("$dissectorname$add"); + $self->pidl_code("static int"); + $self->pidl_code("$dissectorname$add(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"); + $self->pidl_code("{"); + $self->indent; + + $self->ElementLevel($e,$_,$hf,$dissectorname.$add,$pn,$ifname); + + $self->pidl_code(""); + $self->pidl_code("return offset;"); + $self->deindent; + $self->pidl_code("}\n"); + $self->pidl_fn_end("$dissectorname$add"); $add.="_"; last if ($_->{TYPE} eq "ARRAY" and $_->{IS_ZERO_TERMINATED}); } @@ -424,32 +428,32 @@ sub Element($$$) sub Function($$$) { - my ($fn,$ifname) = @_; + my ($self, $fn,$ifname) = @_; my %dissectornames; foreach (@{$fn->{ELEMENTS}}) { - $dissectornames{$_->{NAME}} = Element($_, $fn->{NAME}, $ifname) if not defined($dissectornames{$_->{NAME}}); + $dissectornames{$_->{NAME}} = $self->Element($_, $fn->{NAME}, $ifname) if not defined($dissectornames{$_->{NAME}}); } my $fn_name = $_->{NAME}; $fn_name =~ s/^${ifname}_//; - PrintIdl DumpFunction($fn->{ORIGINAL}); - pidl_fn_start "$ifname\_dissect\_$fn_name\_response"; - pidl_code "static int"; - pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; - pidl_code "{"; - indent; + $self->PrintIdl(DumpFunction($fn->{ORIGINAL})); + $self->pidl_fn_start("$ifname\_dissect\_$fn_name\_response"); + $self->pidl_code("static int"); + $self->pidl_code("$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"); + $self->pidl_code("{"); + $self->indent; if ( not defined($fn->{RETURN_TYPE})) { } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS" or $fn->{RETURN_TYPE} eq "WERROR") { - pidl_code "guint32 status;\n"; + $self->pidl_code("guint32 status;\n"); } elsif (my $type = getType($fn->{RETURN_TYPE})) { if ($type->{DATA}->{TYPE} eq "ENUM") { - pidl_code "g".Parse::Pidl::Typelist::enum_type_fn($type->{DATA}) . " status;\n"; + $self->pidl_code("g".Parse::Pidl::Typelist::enum_type_fn($type->{DATA}) . " status;\n"); } elsif ($type->{DATA}->{TYPE} eq "SCALAR") { - pidl_code "g$fn->{RETURN_TYPE} status;\n"; + $self->pidl_code("g$fn->{RETURN_TYPE} status;\n"); } else { error($fn, "return type `$fn->{RETURN_TYPE}' not yet supported"); } @@ -457,25 +461,25 @@ sub Function($$$) error($fn, "unknown return type `$fn->{RETURN_TYPE}'"); } - pidl_code "pinfo->dcerpc_procedure_name=\"${fn_name}\";"; + $self->pidl_code("pinfo->dcerpc_procedure_name=\"${fn_name}\";"); foreach (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$_->{DIRECTION}})) { - pidl_code "$dissectornames{$_->{NAME}}"; - pidl_code "offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"; - pidl_code ""; + $self->pidl_code("$dissectornames{$_->{NAME}}"); + $self->pidl_code("offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"); + $self->pidl_code(""); } } if (not defined($fn->{RETURN_TYPE})) { } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { - pidl_code "offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, &status);\n"; - pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; - pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, NT_errors, \"Unknown NT status 0x%08x\"));\n"; + $self->pidl_code("offset = dissect_ntstatus(tvb, offset, pinfo, tree, drep, hf\_$ifname\_status, &status);\n"); + $self->pidl_code("if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"); + $self->pidl_code("\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, NT_errors, \"Unknown NT status 0x%08x\"));\n"); $return_types{$ifname}->{"status"} = ["NTSTATUS", "NT Error"]; } elsif ($fn->{RETURN_TYPE} eq "WERROR") { - pidl_code "offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, &status);\n"; - pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; - pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, WERR_errors, \"Unknown DOS error 0x%08x\"));\n"; + $self->pidl_code("offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep, hf\_$ifname\_werror, &status);\n"); + $self->pidl_code("if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"); + $self->pidl_code("\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Error: %s\", val_to_str(status, WERR_errors, \"Unknown DOS error 0x%08x\"));\n"); $return_types{$ifname}->{"werror"} = ["WERROR", "Windows Error"]; } elsif (my $type = getType($fn->{RETURN_TYPE})) { @@ -483,108 +487,107 @@ sub Function($$$) my $return_type = "g".Parse::Pidl::Typelist::enum_type_fn($type->{DATA}); my $return_dissect = "dissect_ndr_" .Parse::Pidl::Typelist::enum_type_fn($type->{DATA}); - pidl_code "offset = $return_dissect(tvb, offset, pinfo, tree, drep, hf\_$ifname\_$fn->{RETURN_TYPE}_status, &status);"; - pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; - pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Status: %s\", val_to_str(status, $ifname\_$fn->{RETURN_TYPE}\_vals, \"Unknown " . $fn->{RETURN_TYPE} . " error 0x%08x\"));\n"; + $self->pidl_code("offset = $return_dissect(tvb, offset, pinfo, tree, drep, hf\_$ifname\_$fn->{RETURN_TYPE}_status, &status);"); + $self->pidl_code("if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"); + $self->pidl_code("\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Status: %s\", val_to_str(status, $ifname\_$fn->{RETURN_TYPE}\_vals, \"Unknown " . $fn->{RETURN_TYPE} . " error 0x%08x\"));\n"); $return_types{$ifname}->{$fn->{RETURN_TYPE}."_status"} = [$fn->{RETURN_TYPE}, $fn->{RETURN_TYPE}]; } elsif ($type->{DATA}->{TYPE} eq "SCALAR") { - pidl_code "offset = dissect_ndr_$fn->{RETURN_TYPE}(tvb, offset, pinfo, tree, drep, hf\_$ifname\_$fn->{RETURN_TYPE}_status, &status);"; - pidl_code "if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"; - pidl_code "\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Status: %d\", status);\n"; + $self->pidl_code("offset = dissect_ndr_$fn->{RETURN_TYPE}(tvb, offset, pinfo, tree, drep, hf\_$ifname\_$fn->{RETURN_TYPE}_status, &status);"); + $self->pidl_code("if (status != 0 && check_col(pinfo->cinfo, COL_INFO))"); + $self->pidl_code("\tcol_append_fstr(pinfo->cinfo, COL_INFO, \", Status: %d\", status);\n"); $return_types{$ifname}->{$fn->{RETURN_TYPE}."_status"} = [$fn->{RETURN_TYPE}, $fn->{RETURN_TYPE}]; } } - - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end "$ifname\_dissect\_$fn_name\_response"; - - pidl_fn_start "$ifname\_dissect\_$fn_name\_request"; - pidl_code "static int"; - pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"; - pidl_code "{"; - indent; - pidl_code "pinfo->dcerpc_procedure_name=\"${fn_name}\";"; + $self->pidl_code("return offset;"); + $self->deindent; + $self->pidl_code("}\n"); + $self->pidl_fn_end("$ifname\_dissect\_$fn_name\_response"); + + $self->pidl_fn_start("$ifname\_dissect\_$fn_name\_request"); + $self->pidl_code("static int"); + $self->pidl_code("$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)"); + $self->pidl_code("{"); + $self->indent; + $self->pidl_code("pinfo->dcerpc_procedure_name=\"${fn_name}\";"); foreach (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$_->{DIRECTION}})) { - pidl_code "$dissectornames{$_->{NAME}}"; - pidl_code "offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"; + $self->pidl_code("$dissectornames{$_->{NAME}}"); + $self->pidl_code("offset = dissect_deferred_pointers(pinfo, tvb, offset, drep);"); } } - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end "$ifname\_dissect\_$fn_name\_request"; + $self->pidl_code("return offset;"); + $self->deindent; + $self->pidl_code("}\n"); + $self->pidl_fn_end("$ifname\_dissect\_$fn_name\_request"); } -sub Struct($$$) +sub Struct($$$$) { - my ($e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect\_struct\_".StripPrefixes($name, $conformance->{strip_prefixes}); + my ($self,$e,$name,$ifname) = @_; + my $dissectorname = "$ifname\_dissect\_struct\_".StripPrefixes($name, $self->{conformance}->{strip_prefixes}); - return if (defined($conformance->{noemit}->{StripPrefixes($name, $conformance->{strip_prefixes})})); + return if (defined($self->{conformance}->{noemit}->{StripPrefixes($name, $self->{conformance}->{strip_prefixes})})); - register_ett("ett_$ifname\_$name"); + $self->register_ett("ett_$ifname\_$name"); my $res = ""; - ($res.="\t".Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}}); + ($res.="\t".$self->Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}}); - pidl_hdr "int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_);"; + $self->pidl_hdr("int $dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_);"); - pidl_fn_start $dissectorname; - pidl_code "int"; - pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_)"; - pidl_code "{"; - indent; - pidl_code "proto_item *item = NULL;"; - pidl_code "proto_tree *tree = NULL;"; - pidl_code "int old_offset;"; - pidl_code ""; + $self->pidl_fn_start($dissectorname); + $self->pidl_code("int"); + $self->pidl_code("$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_)"); + $self->pidl_code("{"); + $self->indent; + $self->pidl_code("proto_item *item = NULL;"); + $self->pidl_code("proto_tree *tree = NULL;"); + $self->pidl_code("int old_offset;"); + $self->pidl_code(""); if ($e->{ALIGN} > 1) { - pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; + $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;"); } - pidl_code ""; - - pidl_code "old_offset = offset;"; - pidl_code ""; - pidl_code "if (parent_tree) {"; - indent; - pidl_code "item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);"; - pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; - deindent; - pidl_code "}"; - - pidl_code "\n$res"; - - pidl_code "proto_item_set_len(item, offset-old_offset);\n"; - pidl_code "return offset;"; - deindent; - pidl_code "}\n"; - pidl_fn_end $dissectorname; - - register_type($name, "offset = $dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); + $self->pidl_code(""); + + $self->pidl_code("old_offset = offset;"); + $self->pidl_code(""); + $self->pidl_code("if (parent_tree) {"); + $self->indent; + $self->pidl_code("item = proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);"); + $self->pidl_code("tree = proto_item_add_subtree(item, ett_$ifname\_$name);"); + $self->deindent; + $self->pidl_code("}"); + + $self->pidl_code("\n$res"); + + $self->pidl_code("proto_item_set_len(item, offset-old_offset);\n"); + $self->pidl_code("return offset;"); + $self->deindent; + $self->pidl_code("}\n"); + $self->pidl_fn_end($dissectorname); + + $self->register_type($name, "offset = $dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); } -sub Union($$$) +sub Union($$$$) { - my ($e,$name,$ifname) = @_; + my ($self,$e,$name,$ifname) = @_; - my $dissectorname = "$ifname\_dissect_".StripPrefixes($name, $conformance->{strip_prefixes}); + my $dissectorname = "$ifname\_dissect_".StripPrefixes($name, $self->{conformance}->{strip_prefixes}); - return if (defined($conformance->{noemit}->{StripPrefixes($name, $conformance->{strip_prefixes})})); + return if (defined($self->{conformance}->{noemit}->{StripPrefixes($name, $self->{conformance}->{strip_prefixes})})); - register_ett("ett_$ifname\_$name"); + $self->register_ett("ett_$ifname\_$name"); my $res = ""; foreach (@{$e->{ELEMENTS}}) { $res.="\n\t\t$_->{CASE}:\n"; if ($_->{TYPE} ne "EMPTY") { - $res.="\t\t\t".Element($_, $name, $ifname)."\n"; + $res.="\t\t\t".$self->Element($_, $name, $ifname)."\n"; } $res.="\t\tbreak;\n"; } @@ -600,68 +603,68 @@ sub Union($$$) $switch_dissect = "dissect_ndr_$e->{SWITCH_TYPE}"; } - pidl_fn_start $dissectorname; - pidl_code "static int"; - pidl_code "$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_)"; - pidl_code "{"; - indent; - pidl_code "proto_item *item = NULL;"; - pidl_code "proto_tree *tree = NULL;"; - pidl_code "int old_offset;"; - pidl_code "$switch_type level;"; - pidl_code ""; + $self->pidl_fn_start($dissectorname); + $self->pidl_code("static int"); + $self->pidl_code("$dissectorname(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *parent_tree _U_, guint8 *drep _U_, int hf_index _U_, guint32 param _U_)"); + $self->pidl_code("{"); + $self->indent; + $self->pidl_code("proto_item *item = NULL;"); + $self->pidl_code("proto_tree *tree = NULL;"); + $self->pidl_code("int old_offset;"); + $self->pidl_code("$switch_type level;"); + $self->pidl_code(""); if ($e->{ALIGN} > 1) { - pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;"; + $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;"); } - pidl_code ""; + $self->pidl_code(""); - pidl_code "old_offset = offset;"; - pidl_code "if (parent_tree) {"; - indent; - pidl_code "item = proto_tree_add_text(parent_tree, tvb, offset, -1, \"$name\");"; - pidl_code "tree = proto_item_add_subtree(item, ett_$ifname\_$name);"; - deindent; - pidl_code "}"; + $self->pidl_code("old_offset = offset;"); + $self->pidl_code("if (parent_tree) {"); + $self->indent; + $self->pidl_code("item = proto_tree_add_text(parent_tree, tvb, offset, -1, \"$name\");"); + $self->pidl_code("tree = proto_item_add_subtree(item, ett_$ifname\_$name);"); + $self->deindent; + $self->pidl_code("}"); - pidl_code ""; + $self->pidl_code(""); - pidl_code "offset = $switch_dissect(tvb, offset, pinfo, tree, drep, hf_index, &level);"; + $self->pidl_code("offset = $switch_dissect(tvb, offset, pinfo, tree, drep, hf_index, &level);"); - pidl_code "switch(level) {$res\t}"; - pidl_code "proto_item_set_len(item, offset-old_offset);\n"; - pidl_code "return offset;"; - deindent; - pidl_code "}"; - pidl_fn_end $dissectorname; + $self->pidl_code("switch(level) {$res\t}"); + $self->pidl_code("proto_item_set_len(item, offset-old_offset);\n"); + $self->pidl_code("return offset;"); + $self->deindent; + $self->pidl_code("}"); + $self->pidl_fn_end($dissectorname); - register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); + $self->register_type($name, "offset = $dissectorname(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0); } -sub Const($$) +sub Const($$$) { - my ($const,$ifname) = @_; + my ($self,$const,$ifname) = @_; if (!defined($const->{ARRAY_LEN}[0])) { - pidl_hdr "#define $const->{NAME}\t( $const->{VALUE} )\n"; + $self->pidl_hdr("#define $const->{NAME}\t( $const->{VALUE} )\n"); } else { - pidl_hdr "#define $const->{NAME}\t $const->{VALUE}\n"; + $self->pidl_hdr("#define $const->{NAME}\t $const->{VALUE}\n"); } } -sub Typedef($$$) +sub Typedef($$$$) { - my ($e,$name,$ifname) = @_; + my ($self,$e,$name,$ifname) = @_; - Type($e->{DATA}, $name, $ifname); + $self->Type($e->{DATA}, $name, $ifname); } -sub Type($$$) +sub Type($$$$) { - my ($e, $name, $ifname) = @_; + my ($self, $e, $name, $ifname) = @_; - PrintIdl DumpType($e->{ORIGINAL}); + $self->PrintIdl(DumpType($e->{ORIGINAL})); { ENUM => \&Enum, @@ -669,20 +672,20 @@ sub Type($$$) UNION => \&Union, BITMAP => \&Bitmap, TYPEDEF => \&Typedef - }->{$e->{TYPE}}->($e, $name, $ifname); + }->{$e->{TYPE}}->($self, $e, $name, $ifname); } -sub RegisterInterface($) +sub RegisterInterface($$) { - my ($x) = @_; + my ($self, $x) = @_; - pidl_fn_start "proto_register_dcerpc_$x->{NAME}"; - pidl_code "void proto_register_dcerpc_$x->{NAME}(void)"; - pidl_code "{"; - indent; + $self->pidl_fn_start("proto_register_dcerpc_$x->{NAME}"); + $self->pidl_code("void proto_register_dcerpc_$x->{NAME}(void)"); + $self->pidl_code("{"); + $self->indent; - $res{code}.=DumpHfList()."\n"; - $res{code}.="\n".DumpEttList(@ett)."\n"; + $self->{res}->{code}.=$self->DumpHfList()."\n"; + $self->{res}->{code}.="\n".DumpEttList($self->{ett})."\n"; if (defined($x->{UUID})) { # These can be changed to non-pidl_code names if the old dissectors @@ -696,140 +699,142 @@ sub RegisterInterface($) $name = $x->{PROPERTIES}->{helpstring}; } - if (defined($conformance->{protocols}->{$x->{NAME}})) { - $short_name = $conformance->{protocols}->{$x->{NAME}}->{SHORTNAME}; - $name = $conformance->{protocols}->{$x->{NAME}}->{LONGNAME}; - $filter_name = $conformance->{protocols}->{$x->{NAME}}->{FILTERNAME}; + if (defined($self->{conformance}->{protocols}->{$x->{NAME}})) { + $short_name = $self->{conformance}->{protocols}->{$x->{NAME}}->{SHORTNAME}; + $name = $self->{conformance}->{protocols}->{$x->{NAME}}->{LONGNAME}; + $filter_name = $self->{conformance}->{protocols}->{$x->{NAME}}->{FILTERNAME}; } - pidl_code "proto_dcerpc_$x->{NAME} = proto_register_protocol(".make_str($name).", ".make_str($short_name).", ".make_str($filter_name).");"; + $self->pidl_code("proto_dcerpc_$x->{NAME} = proto_register_protocol(".make_str($name).", ".make_str($short_name).", ".make_str($filter_name).");"); - pidl_code "proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));"; - pidl_code "proto_register_subtree_array(ett, array_length(ett));"; + $self->pidl_code("proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));"); + $self->pidl_code("proto_register_subtree_array(ett, array_length(ett));"); } else { - pidl_code "proto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");"; - pidl_code "proto_register_field_array(proto_dcerpc, hf, array_length(hf));"; - pidl_code "proto_register_subtree_array(ett, array_length(ett));"; + $self->pidl_code("proto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");"); + $self->pidl_code("proto_register_field_array(proto_dcerpc, hf, array_length(hf));"); + $self->pidl_code("proto_register_subtree_array(ett, array_length(ett));"); } - deindent; - pidl_code "}\n"; - pidl_fn_end "proto_register_dcerpc_$x->{NAME}"; + $self->deindent; + $self->pidl_code("}\n"); + $self->pidl_fn_end("proto_register_dcerpc_$x->{NAME}"); } -sub RegisterInterfaceHandoff($) +sub RegisterInterfaceHandoff($$) { - my $x = shift; + my ($self,$x) = @_; if (defined($x->{UUID})) { - pidl_fn_start "proto_reg_handoff_dcerpc_$x->{NAME}"; - pidl_code "void proto_reg_handoff_dcerpc_$x->{NAME}(void)"; - pidl_code "{"; - indent; - pidl_code "dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},"; - pidl_code "\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},"; - pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);"; - deindent; - pidl_code "}"; - pidl_fn_end "proto_reg_handoff_dcerpc_$x->{NAME}"; - - $hf_used{"hf_$x->{NAME}_opnum"} = 1; + $self->pidl_fn_start("proto_reg_handoff_dcerpc_$x->{NAME}"); + $self->pidl_code("void proto_reg_handoff_dcerpc_$x->{NAME}(void)"); + $self->pidl_code("{"); + $self->indent; + $self->pidl_code("dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},"); + $self->pidl_code("\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},"); + $self->pidl_code("\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);"); + $self->deindent; + $self->pidl_code("}"); + $self->pidl_fn_end("proto_reg_handoff_dcerpc_$x->{NAME}"); + + $self->{hf_used}->{"hf_$x->{NAME}_opnum"} = 1; } } sub ProcessInclude { + my $self = shift; my @includes = @_; foreach (@includes) { - pidl_hdr "#include \"$_\""; + $self->pidl_hdr("#include \"$_\""); } - pidl_hdr ""; + $self->pidl_hdr(""); } sub ProcessImport { + my $self = shift; my @imports = @_; foreach (@imports) { next if($_ eq "security"); s/\.idl\"$//; s/^\"//; - pidl_hdr "#include \"packet-dcerpc-$_\.h\""; + $self->pidl_hdr("#include \"packet-dcerpc-$_\.h\""); } - pidl_hdr ""; + $self->pidl_hdr(""); } -sub ProcessInterface($) +sub ProcessInterface($$) { - my ($x) = @_; + my ($self, $x) = @_; - push(@{$conformance->{strip_prefixes}}, $x->{NAME}); + push(@{$self->{conformance}->{strip_prefixes}}, $x->{NAME}); my $define = "__PACKET_DCERPC_" . uc($_->{NAME}) . "_H"; - pidl_hdr "#ifndef $define"; - pidl_hdr "#define $define"; - pidl_hdr ""; + $self->pidl_hdr("#ifndef $define"); + $self->pidl_hdr("#define $define"); + $self->pidl_hdr(""); - pidl_def "static gint proto_dcerpc_$x->{NAME} = -1;"; - register_ett("ett_dcerpc_$x->{NAME}"); - register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, ""); + $self->pidl_def("static gint proto_dcerpc_$x->{NAME} = -1;"); + $self->register_ett("ett_dcerpc_$x->{NAME}"); + $self->register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, ""); if (defined($x->{UUID})) { my $if_uuid = $x->{UUID}; - pidl_def "/* Version information */\n\n"; + $self->pidl_def("/* Version information */\n\n"); - pidl_def "static e_uuid_t uuid_dcerpc_$x->{NAME} = {"; - pidl_def "\t0x" . substr($if_uuid, 1, 8) + $self->pidl_def("static e_uuid_t uuid_dcerpc_$x->{NAME} = {"); + $self->pidl_def("\t0x" . substr($if_uuid, 1, 8) . ", 0x" . substr($if_uuid, 10, 4) - . ", 0x" . substr($if_uuid, 15, 4) . ","; - pidl_def "\t{ 0x" . substr($if_uuid, 20, 2) + . ", 0x" . substr($if_uuid, 15, 4) . ","); + $self->pidl_def("\t{ 0x" . substr($if_uuid, 20, 2) . ", 0x" . substr($if_uuid, 22, 2) . ", 0x" . substr($if_uuid, 25, 2) . ", 0x" . substr($if_uuid, 27, 2) . ", 0x" . substr($if_uuid, 29, 2) . ", 0x" . substr($if_uuid, 31, 2) . ", 0x" . substr($if_uuid, 33, 2) - . ", 0x" . substr($if_uuid, 35, 2) . " }"; - pidl_def "};"; + . ", 0x" . substr($if_uuid, 35, 2) . " }"); + $self->pidl_def("};"); my $maj = $x->{VERSION}; $maj =~ s/\.(.*)$//g; - pidl_def "static guint16 ver_dcerpc_$x->{NAME} = $maj;"; - pidl_def ""; + $self->pidl_def("static guint16 ver_dcerpc_$x->{NAME} = $maj;"); + $self->pidl_def(""); } $return_types{$x->{NAME}} = {}; - Interface($x); + $self->Interface($x); - pidl_code "\n".DumpFunctionTable($x); + $self->pidl_code("\n".DumpFunctionTable($x)); foreach (keys %{$return_types{$x->{NAME}}}) { my ($type, $desc) = @{$return_types{$x->{NAME}}->{$_}}; - my $dt = find_type($type); + my $dt = $self->find_type($type); $dt or die("Unable to find information about return type `$type'"); - register_hf_field("hf_$x->{NAME}_$_", $desc, "$x->{NAME}.$_", $dt->{FT_TYPE}, "BASE_HEX", $dt->{VALSSTRING}, 0, ""); - $hf_used{"hf_$x->{NAME}_$_"} = 1; + $self->register_hf_field("hf_$x->{NAME}_$_", $desc, "$x->{NAME}.$_", $dt->{FT_TYPE}, "BASE_HEX", $dt->{VALSSTRING}, 0, ""); + $self->{hf_used}->{"hf_$x->{NAME}_$_"} = 1; } - RegisterInterface($x); - RegisterInterfaceHandoff($x); + $self->RegisterInterface($x); + $self->RegisterInterfaceHandoff($x); - pidl_hdr "#endif /* $define */"; + $self->pidl_hdr("#endif /* $define */"); } -sub find_type($) +sub find_type($$) { - my $n = shift; + my ($self, $n) = @_; - return $conformance->{types}->{$n}; + return $self->{conformance}->{types}->{$n}; } -sub register_type($$$$$$$) +sub register_type($$$$$$$$) { - my ($type,$call,$ft,$base,$mask,$vals,$length) = @_; + my ($self, $type,$call,$ft,$base,$mask,$vals,$length) = @_; - $conformance->{types}->{$type} = { + $self->{conformance}->{types}->{$type} = { NAME => $type, DISSECTOR_NAME => $call, FT_TYPE => $ft, @@ -841,61 +846,57 @@ sub register_type($$$$$$$) } # Loads the default types -sub Initialize($) +sub Initialize($$) { - my $cnf_file = shift; + my ($self, $cnf_file) = @_; - $conformance = { + $self->{conformance} = { imports => {}, header_fields=> {} }; - ReadConformance($cnf_file, $conformance) or print STDERR "warning: No conformance file `$cnf_file'\n"; + ReadConformance($cnf_file, $self->{conformance}) or print STDERR "warning: No conformance file `$cnf_file'\n"; foreach my $bytes (qw(1 2 4 8)) { my $bits = $bytes * 8; - register_type("uint$bits", "offset = PIDL_dissect_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes); - register_type("int$bits", "offset = PIDL_dissect_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes); + $self->register_type("uint$bits", "offset = PIDL_dissect_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes); + $self->register_type("int$bits", "offset = PIDL_dissect_uint$bits(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes); } - register_type("udlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4); - register_type("bool8", "offset = PIDL_dissect_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT8", "BASE_DEC", 0, "NULL", 1); - register_type("char", "offset = PIDL_dissect_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT8", "BASE_DEC", 0, "NULL", 1); - register_type("long", "offset = PIDL_dissect_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT32", "BASE_DEC", 0, "NULL", 4); - register_type("dlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8); - register_type("GUID", "offset = dissect_ndr_uuid_t(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4); - register_type("policy_handle", "offset = PIDL_dissect_policy_hnd(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); - register_type("NTTIME", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); - register_type("NTTIME_hyper", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); - register_type("time_t", "offset = dissect_ndr_time_t(tvb, offset, pinfo,tree, drep, \@HF\@, NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4); - register_type("NTTIME_1sec", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); - register_type("SID", " + $self->register_type("udlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4); + $self->register_type("bool8", "offset = PIDL_dissect_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + $self->register_type("char", "offset = PIDL_dissect_uint8(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT8", "BASE_DEC", 0, "NULL", 1); + $self->register_type("long", "offset = PIDL_dissect_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_INT32", "BASE_DEC", 0, "NULL", 4); + $self->register_type("dlong", "offset = dissect_ndr_duint32(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8); + $self->register_type("GUID", "offset = dissect_ndr_uuid_t(tvb, offset, pinfo, tree, drep, \@HF\@, NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4); + $self->register_type("policy_handle", "offset = PIDL_dissect_policy_hnd(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_BYTES", "BASE_NONE", 0, "NULL", 4); + $self->register_type("NTTIME", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + $self->register_type("NTTIME_hyper", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + $self->register_type("time_t", "offset = dissect_ndr_time_t(tvb, offset, pinfo,tree, drep, \@HF\@, NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4); + $self->register_type("NTTIME_1sec", "offset = dissect_ndr_nt_NTTIME(tvb, offset, pinfo, tree, drep, \@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4); + $self->register_type("SID", " dcerpc_info *di = (dcerpc_info *)pinfo->private_data; di->hf_index = \@HF\@; offset = dissect_ndr_nt_SID_with_options(tvb, offset, pinfo, tree, drep, param); ","FT_STRING", "BASE_DEC", 0, "NULL", 4); - register_type("WERROR", + $self->register_type("WERROR", "offset = PIDL_dissect_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_UINT32", "BASE_DEC", 0, "VALS(WERR_errors)", 4); - register_type("NTSTATUS", + $self->register_type("NTSTATUS", "offset = PIDL_dissect_uint32(tvb, offset, pinfo, tree, drep, \@HF\@, \@PARAM\@);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4); } ##################################################################### # Generate Wireshark parser and header code -sub Parse($$$$) +sub Parse($$$$$) { - my($ndr,$idl_file,$h_filename,$cnf_file) = @_; - Initialize($cnf_file); - - return (undef, undef) if defined($conformance->{noemit_dissector}); - - $tabs = ""; + my($self,$ndr,$idl_file,$h_filename,$cnf_file) = @_; + + $self->Initialize($cnf_file); - %res = (code=>"",def=>"",hdr=>""); - @ett = (); + return (undef, undef) if defined($self->{conformance}->{noemit_dissector}); my $notice = "/* DO NOT EDIT @@ -910,50 +911,50 @@ sub Parse($$$$) "; - pidl_hdr $notice; + $self->pidl_hdr($notice); - $res{headers} = "\n"; - $res{headers} .= "#ifdef HAVE_CONFIG_H\n"; - $res{headers} .= "#include \"config.h\"\n"; - $res{headers} .= "#endif\n\n"; - $res{headers} .= "#include \n"; - $res{headers} .= "#include \n"; - $res{headers} .= "#include \n\n"; + $self->{res}->{headers} = "\n"; + $self->{res}->{headers} .= "#ifdef HAVE_CONFIG_H\n"; + $self->{res}->{headers} .= "#include \"config.h\"\n"; + $self->{res}->{headers} .= "#endif\n\n"; + $self->{res}->{headers} .= "#include \n"; + $self->{res}->{headers} .= "#include \n"; + $self->{res}->{headers} .= "#include \n\n"; - $res{headers} .= "#include \"packet-dcerpc.h\"\n"; - $res{headers} .= "#include \"packet-dcerpc-nt.h\"\n"; - $res{headers} .= "#include \"packet-windows-common.h\"\n"; + $self->{res}->{headers} .= "#include \"packet-dcerpc.h\"\n"; + $self->{res}->{headers} .= "#include \"packet-dcerpc-nt.h\"\n"; + $self->{res}->{headers} .= "#include \"packet-windows-common.h\"\n"; my $h_basename = basename($h_filename); - $res{headers} .= "#include \"$h_basename\"\n"; - pidl_code ""; + $self->{res}->{headers} .= "#include \"$h_basename\"\n"; + $self->pidl_code(""); # Wireshark protocol registration foreach (@$ndr) { - ProcessInterface($_) if ($_->{TYPE} eq "INTERFACE"); - ProcessImport(@{$_->{PATHS}}) if ($_->{TYPE} eq "IMPORT"); - ProcessInclude(@{$_->{PATHS}}) if ($_->{TYPE} eq "INCLUDE"); + $self->ProcessInterface($_) if ($_->{TYPE} eq "INTERFACE"); + $self->ProcessImport(@{$_->{PATHS}}) if ($_->{TYPE} eq "IMPORT"); + $self->ProcessInclude(@{$_->{PATHS}}) if ($_->{TYPE} eq "INCLUDE"); } - $res{ett} = DumpEttDeclaration(@ett); - $res{hf} = DumpHfDeclaration(); + $self->{res}->{ett} = DumpEttDeclaration($self->{ett}); + $self->{res}->{hf} = $self->DumpHfDeclaration(); my $parser = $notice; - $parser.= $res{headers}; - $parser.=$res{ett}; - $parser.=$res{hf}; - $parser.=$res{def}; - if (exists ($conformance->{override})) { - $parser.=$conformance->{override}; + $parser.= $self->{res}->{headers}; + $parser.=$self->{res}->{ett}; + $parser.=$self->{res}->{hf}; + $parser.=$self->{res}->{def}; + if (exists ($self->{conformance}->{override})) { + $parser.=$self->{conformance}->{override}; } - $parser.=$res{code}; + $parser.=$self->{res}->{code}; my $header = "/* autogenerated by pidl */\n\n"; - $header.=$res{hdr}; + $header.=$self->{res}->{hdr}; - CheckUsed($conformance); + $self->CheckUsed($self->{conformance}); return ($parser,$header); } @@ -962,18 +963,18 @@ sub Parse($$$$) # ETT ############################################################################### -sub register_ett($) +sub register_ett($$) { - my $name = shift; + my ($self, $name) = @_; - push (@ett, $name); + push (@{$self->{ett}}, $name); } sub DumpEttList { - my @ett = @_; + my ($ett) = @_; my $res = "\tstatic gint *ett[] = {\n"; - foreach (@ett) { + foreach (@$ett) { $res .= "\t\t&$_,\n"; } @@ -982,9 +983,9 @@ sub DumpEttList sub DumpEttDeclaration { - my @ett = @_; + my ($ett) = @_; my $res = "\n/* Ett declarations */\n"; - foreach (@ett) { + foreach (@$ett) { $res .= "static gint $_ = -1;\n"; } @@ -995,16 +996,16 @@ sub DumpEttDeclaration # HF ############################################################################### -sub register_hf_field($$$$$$$$) +sub register_hf_field($$$$$$$$$) { - my ($index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; + my ($self,$index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_; - if (defined ($conformance->{hf_renames}->{$index})) { - $conformance->{hf_renames}->{$index}->{USED} = 1; - return $conformance->{hf_renames}->{$index}->{NEWNAME}; + if (defined ($self->{conformance}->{hf_renames}->{$index})) { + $self->{conformance}->{hf_renames}->{$index}->{USED} = 1; + return $self->{conformance}->{hf_renames}->{$index}->{NEWNAME}; } - $conformance->{header_fields}->{$index} = { + $self->{conformance}->{header_fields}->{$index} = { INDEX => $index, NAME => $name, FILTER => $filter_name, @@ -1016,22 +1017,23 @@ sub register_hf_field($$$$$$$$) }; if ((not defined($blurb) or $blurb eq "") and - defined($conformance->{fielddescription}->{$index})) { - $conformance->{header_fields}->{$index}->{BLURB} = - $conformance->{fielddescription}->{$index}->{DESCRIPTION}; - $conformance->{fielddescription}->{$index}->{USED} = 1; + defined($self->{conformance}->{fielddescription}->{$index})) { + $self->{conformance}->{header_fields}->{$index}->{BLURB} = + $self->{conformance}->{fielddescription}->{$index}->{DESCRIPTION}; + $self->{conformance}->{fielddescription}->{$index}->{USED} = 1; } return $index; } -sub DumpHfDeclaration() +sub DumpHfDeclaration($) { + my ($self) = @_; my $res = ""; $res = "\n/* Header field declarations */\n"; - foreach (keys %{$conformance->{header_fields}}) + foreach (keys %{$self->{conformance}->{header_fields}}) { $res .= "static gint $_ = -1;\n"; } @@ -1039,11 +1041,12 @@ sub DumpHfDeclaration() return "$res\n"; } -sub DumpHfList() +sub DumpHfList($) { + my ($self) = @_; my $res = "\tstatic hf_register_info hf[] = {\n"; - foreach (values %{$conformance->{header_fields}}) + foreach (values %{$self->{conformance}->{header_fields}}) { $res .= "\t{ &$_->{INDEX}, { ".make_str($_->{NAME}).", ".make_str($_->{FILTER}).", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALSSTRING}, $_->{MASK}, ".make_str($_->{BLURB}).", HFILL }}, @@ -1075,11 +1078,11 @@ sub DumpFunctionTable($) return "$res};\n"; } -sub CheckUsed($) +sub CheckUsed($$) { - my $conformance = shift; + my ($self, $conformance) = @_; foreach (values %{$conformance->{header_fields}}) { - if (not defined($hf_used{$_->{INDEX}})) { + if (not defined($self->{hf_used}->{$_->{INDEX}})) { warning($_->{POS}, "hf field `$_->{INDEX}' not used"); } } -- cgit From b0d209087939c0de765349c80a22884b956f3f0f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 22 Apr 2007 14:19:22 +0000 Subject: r22457: Fix tests for Samba3 client generator. (This used to be commit cf5162ad100c1a8201d3309549c8ff0d3bd5a732) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 157 ++++++++++++------------ 1 file changed, 79 insertions(+), 78 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index a2219bdab2..27b71053fb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -20,14 +20,18 @@ use Parse::Pidl::Samba4 qw(DeclLong); use vars qw($VERSION); $VERSION = '0.01'; -my $res; -my $res_hdr; -my $tabs = ""; -sub indent() { $tabs.="\t"; } -sub deindent() { $tabs = substr($tabs, 1); } -sub pidl($) { $res .= $tabs.(shift)."\n"; } -sub pidl_hdr($) { $res_hdr .= (shift)."\n"; } -sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } +sub indent($) { my ($self) = @_; $self->{tabs}.="\t"; } +sub deindent($) { my ($self) = @_; $self->{tabs} = substr($self->{tabs}, 1); } +sub pidl($$) { my ($self,$txt) = @_; $self->{res} .= "$self->{tabs}$txt\n"; } +sub pidl_hdr($$) { my ($self, $txt) = @_; $self->{res_hdr} .= "$txt\n"; } +sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); } + +sub new($) +{ + my ($class) = shift; + my $self = { res => "", res_hdr => "", tabs => "" }; + bless($self, $class); +} sub GenerateFunctionInEnv($) { @@ -43,9 +47,9 @@ sub GenerateFunctionInEnv($) return \%env; } -sub ParseFunction($$) +sub ParseFunction($$$) { - my ($uif, $fn) = @_; + my ($self, $uif, $fn) = @_; my $inargs = ""; my $defargs = ""; @@ -54,42 +58,42 @@ sub ParseFunction($$) foreach (@{$fn->{ELEMENTS}}) { $defargs .= ", " . DeclLong($_); } - fn_declare "NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"; - pidl "{"; - indent; - pidl "struct $fn->{NAME} r;"; - pidl "NTSTATUS status;"; - pidl ""; - pidl "/* In parameters */"; + $self->fn_declare("NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"); + $self->pidl("{"); + $self->indent; + $self->pidl("struct $fn->{NAME} r;"); + $self->pidl("NTSTATUS status;"); + $self->pidl(""); + $self->pidl("/* In parameters */"); foreach (@{$fn->{ELEMENTS}}) { if (grep(/in/, @{$_->{DIRECTION}})) { - pidl "r.in.$_->{NAME} = $_->{NAME};"; + $self->pidl("r.in.$_->{NAME} = $_->{NAME};"); } } - pidl ""; - pidl "if (DEBUGLEVEL >= 10)"; - pidl "\tNDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"; - pidl ""; - pidl "status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, $ufn, &r, (ndr_pull_flags_fn_t)ndr_pull_$fn->{NAME}, (ndr_push_flags_fn_t)ndr_push_$fn->{NAME});"; - pidl ""; - - pidl "if (!NT_STATUS_IS_OK(status)) {"; - indent; - pidl "return status;"; - deindent; - pidl "}"; - - pidl ""; - pidl "if (DEBUGLEVEL >= 10)"; - pidl "\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);"; - pidl ""; - pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\treturn status;"; - pidl "}"; - pidl ""; - pidl "/* Return variables */"; + $self->pidl(""); + $self->pidl("if (DEBUGLEVEL >= 10)"); + $self->pidl("\tNDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"); + $self->pidl(""); + $self->pidl("status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, $ufn, &r, (ndr_pull_flags_fn_t)ndr_pull_$fn->{NAME}, (ndr_push_flags_fn_t)ndr_push_$fn->{NAME});"); + $self->pidl(""); + + $self->pidl("if (!NT_STATUS_IS_OK(status)) {"); + $self->indent; + $self->pidl("return status;"); + $self->deindent; + $self->pidl("}"); + + $self->pidl(""); + $self->pidl("if (DEBUGLEVEL >= 10)"); + $self->pidl("\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);"); + $self->pidl(""); + $self->pidl("if (NT_STATUS_IS_ERR(status)) {"); + $self->pidl("\treturn status;"); + $self->pidl("}"); + $self->pidl(""); + $self->pidl("/* Return variables */"); foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); @@ -97,8 +101,8 @@ sub ParseFunction($$) if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") and ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") ) { - pidl "if ( $e->{NAME} ) {"; - indent; + $self->pidl("if ( $e->{NAME} ) {"); + $self->indent; } if ($e->{LEVELS}[0]->{TYPE} eq "ARRAY") { @@ -108,70 +112,67 @@ sub ParseFunction($$) # to allocate a structure of the right size. my $env = GenerateFunctionInEnv($fn); my $size_is = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e); - pidl "memcpy($e->{NAME}, r.out.$e->{NAME}, $size_is);"; + $self->pidl("memcpy($e->{NAME}, r.out.$e->{NAME}, $size_is);"); } else { - pidl "*$e->{NAME} = *r.out.$e->{NAME};"; + $self->pidl("*$e->{NAME} = *r.out.$e->{NAME};"); } if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") and ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") ) { - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } } - pidl""; - pidl "/* Return result */"; + $self->pidl(""); + $self->pidl("/* Return result */"); if (not $fn->{RETURN_TYPE}) { - pidl "return NT_STATUS_OK;"; + $self->pidl("return NT_STATUS_OK;"); } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { - pidl "return r.out.result;"; + $self->pidl("return r.out.result;"); } elsif ($fn->{RETURN_TYPE} eq "WERROR") { - pidl "return werror_to_ntstatus(r.out.result);"; + $self->pidl("return werror_to_ntstatus(r.out.result);"); } else { warning($fn->{ORIGINAL}, "Unable to convert $fn->{RETURN_TYPE} to NTSTATUS"); - pidl "return NT_STATUS_OK;"; + $self->pidl("return NT_STATUS_OK;"); } - deindent; - pidl "}"; - pidl ""; + $self->deindent; + $self->pidl("}"); + $self->pidl(""); } -sub ParseInterface($) +sub ParseInterface($$) { - my $if = shift; + my ($self, $if) = @_; my $uif = uc($if->{NAME}); - pidl_hdr "#ifndef __CLI_$uif\__"; - pidl_hdr "#define __CLI_$uif\__"; - ParseFunction(uc($if->{NAME}), $_) foreach (@{$if->{FUNCTIONS}}); - pidl_hdr "#endif /* __CLI_$uif\__ */"; + $self->pidl_hdr("#ifndef __CLI_$uif\__"); + $self->pidl_hdr("#define __CLI_$uif\__"); + $self->ParseFunction(uc($if->{NAME}), $_) foreach (@{$if->{FUNCTIONS}}); + $self->pidl_hdr("#endif /* __CLI_$uif\__ */"); } -sub Parse($$$) +sub Parse($$$$) { - my($ndr,$header,$ndr_header) = @_; - - $res = ""; - $res_hdr = ""; - - pidl "/*"; - pidl " * Unix SMB/CIFS implementation."; - pidl " * client auto-generated by pidl. DO NOT MODIFY!"; - pidl " */"; - pidl ""; - pidl "#include \"includes.h\""; - pidl "#include \"$header\""; - pidl_hdr "#include \"$ndr_header\""; - pidl ""; + my($self,$ndr,$header,$ndr_header) = @_; + + $self->pidl("/*"); + $self->pidl(" * Unix SMB/CIFS implementation."); + $self->pidl(" * client auto-generated by pidl. DO NOT MODIFY!"); + $self->pidl(" */"); + $self->pidl(""); + $self->pidl("#include \"includes.h\""); + $self->pidl("#include \"$header\""); + $self->pidl_hdr("#include \"$ndr_header\""); + $self->pidl(""); foreach (@$ndr) { - ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); + $self->ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); } - return ($res, $res_hdr); + return ($self->{res}, $self->{res_hdr}); } 1; -- cgit From cc5ad07d84df94f8f2bc16fcb8015f1cf843c1e3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 22 Apr 2007 15:59:34 +0000 Subject: r22462: Fix test suite for ndr parser without using 'our' (This used to be commit d491e60c70de8d78c333b317a143919c1a68c6d9) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 1624 +++++++++++----------- 1 file changed, 812 insertions(+), 812 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 719d885c2d..b65df06884 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -24,6 +24,12 @@ $VERSION = '0.01'; # list of known types my %typefamily; +sub new($$) { + my ($class) = @_; + my $self = { res => "", res_hdr => "", deferred => [], tabs => "", defer_tabs => "" }; + bless($self, $class); +} + sub get_typefamily($) { my $n = shift; @@ -107,25 +113,19 @@ sub get_value_of($) } } -my $res; -my $deferred = []; -my $tabs = ""; - #################################### # pidl() is our basic output routine -sub pidl($) +sub pidl($$) { - my $d = shift; + my ($self, $d) = @_; if ($d) { - $res .= $tabs; - $res .= $d; + $self->{res} .= $self->{tabs}; + $self->{res} .= $d; } - $res .="\n"; + $self->{res} .="\n"; } -my $res_hdr; - -sub pidl_hdr ($) { my $d = shift; $res_hdr .= "$d\n"; } +sub pidl_hdr($$) { my ($self, $d) = @_; $self->{res_hdr} .= "$d\n"; } #################################### # defer() is like pidl(), but adds to @@ -133,54 +133,56 @@ sub pidl_hdr ($) { my $d = shift; $res_hdr .= "$d\n"; } # output buffer at the end of the structure/union/function # This is needed to cope with code that must be pushed back # to the end of a block of elements -my $defer_tabs = ""; -sub defer_indent() { $defer_tabs.="\t"; } -sub defer_deindent() { $defer_tabs=substr($defer_tabs, 0, -1); } +sub defer_indent($) { my ($self) = @_; $self->{defer_tabs}.="\t"; } +sub defer_deindent($) { my ($self) = @_; $self->{defer_tabs}=substr($self->{defer_tabs}, 0, -1); } -sub defer($) +sub defer($$) { - my $d = shift; + my ($self, $d) = @_; if ($d) { - push(@$deferred, $defer_tabs.$d); + push(@{$self->{deferred}}, $self->{defer_tabs}.$d); } } ######################################## # add the deferred content to the current # output -sub add_deferred() +sub add_deferred($) { - pidl $_ foreach (@$deferred); - $deferred = []; - $defer_tabs = ""; + my ($self) = @_; + $self->pidl($_) foreach (@{$self->{deferred}}); + $self->{deferred} = []; + $self->{defer_tabs} = ""; } -sub indent() +sub indent($) { - $tabs .= "\t"; + my ($self) = @_; + $self->{tabs} .= "\t"; } -sub deindent() +sub deindent($) { - $tabs = substr($tabs, 0, -1); + my ($self) = @_; + $self->{tabs} = substr($self->{tabs}, 0, -1); } ##################################################################### # declare a function public or static, depending on its attributes -sub fn_declare($$$) +sub fn_declare($$$$) { - my ($type,$fn,$decl) = @_; + my ($self,$type,$fn,$decl) = @_; if (has_property($fn, "no$type")) { - pidl_hdr "$decl;"; + $self->pidl_hdr("$decl;"); return 0; } if (has_property($fn, "public")) { - pidl_hdr "$decl;"; - pidl "_PUBLIC_ $decl"; + $self->pidl_hdr("$decl;"); + $self->pidl("_PUBLIC_ $decl"); } else { - pidl "static $decl"; + $self->pidl("static $decl"); } return 1; @@ -188,28 +190,28 @@ sub fn_declare($$$) ################################################################### # setup any special flags for an element or structure -sub start_flags($) +sub start_flags($$) { - my $e = shift; + my ($self, $e) = @_; my $flags = has_property($e, "flag"); if (defined $flags) { - pidl "{"; - indent; - pidl "uint32_t _flags_save_$e->{TYPE} = ndr->flags;"; - pidl "ndr_set_flags(&ndr->flags, $flags);"; + $self->pidl("{"); + $self->indent; + $self->pidl("uint32_t _flags_save_$e->{TYPE} = ndr->flags;"); + $self->pidl("ndr_set_flags(&ndr->flags, $flags);"); } } ################################################################### # end any special flags for an element or structure -sub end_flags($) +sub end_flags($$) { - my $e = shift; + my ($self, $e) = @_; my $flags = has_property($e, "flag"); if (defined $flags) { - pidl "ndr->flags = _flags_save_$e->{TYPE};"; - deindent; - pidl "}"; + $self->pidl("ndr->flags = _flags_save_$e->{TYPE};"); + $self->deindent; + $self->pidl("}"); } } @@ -273,9 +275,9 @@ sub GenerateFunctionOutEnv($) ##################################################################### # parse the data of an array - push side -sub ParseArrayPushHeader($$$$$) +sub ParseArrayPushHeader($$$$$$) { - my ($e,$l,$ndr,$var_name,$env) = @_; + my ($self,$e,$l,$ndr,$var_name,$env) = @_; my $size; my $length; @@ -292,12 +294,12 @@ sub ParseArrayPushHeader($$$$$) } if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { - pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));"; + $self->pidl("NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));"); } if ($l->{IS_VARYING}) { - pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));"; # array offset - pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));"; + $self->pidl("NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));"); # array offset + $self->pidl("NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));"); } return $length; @@ -405,9 +407,9 @@ sub check_null_pointer($$$$) ##################################################################### # parse an array - pull side -sub ParseArrayPullHeader($$$$$) +sub ParseArrayPullHeader($$$$$$) { - my ($e,$l,$ndr,$var_name,$env) = @_; + my ($self,$e,$l,$ndr,$var_name,$env) = @_; my $length; my $size; @@ -418,48 +420,48 @@ sub ParseArrayPullHeader($$$$$) $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))"; } else { $length = $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); + check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); } if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { - pidl "NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));"; + $self->pidl("NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));"); } if ($l->{IS_VARYING}) { - pidl "NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));"; + $self->pidl("NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));"); $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")"; } if ($length ne $size) { - pidl "if ($length > $size) {"; - indent; - pidl "return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);"; - deindent; - pidl "}"; + $self->pidl("if ($length > $size) {"); + $self->indent; + $self->pidl("return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);"); + $self->deindent; + $self->pidl("}"); } if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { - defer "if ($var_name) {"; - defer_indent; - my $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); - defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"; - defer_deindent; - defer "}"; + $self->defer("if ($var_name) {"); + $self->defer_indent; + my $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->defer(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); + $self->defer("NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"); + $self->defer_deindent; + $self->defer("}"); } if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) { - defer "if ($var_name) {"; - defer_indent; + $self->defer("if ($var_name) {"); + $self->defer_indent; my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, \&defer, "return NT_STATUS_INVALID_PARAMETER_MIX;"), + check_null_pointer($e, $env, sub { $self->defer(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); - defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"; - defer_deindent; - defer "}" + $self->defer("NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"); + $self->defer_deindent; + $self->defer("}"); } if (not $l->{IS_FIXED} and not is_charset_array($e, $l)) { - AllocateArrayLevel($e,$l,$ndr,$env,$size); + $self->AllocateArrayLevel($e,$l,$ndr,$env,$size); } return $length; @@ -489,129 +491,129 @@ sub compression_dlen($$$) return ParseExpr($dlen, $env, $e->{ORIGINAL}); } -sub ParseCompressionPushStart($$$$) +sub ParseCompressionPushStart($$$$$) { - my ($e,$l,$ndr,$env) = @_; + my ($self,$e,$l,$ndr,$env) = @_; my $comndr = "$ndr\_compressed"; my $alg = compression_alg($e, $l); my $dlen = compression_dlen($e, $l, $env); - pidl "{"; - indent; - pidl "struct ndr_push *$comndr;"; - pidl "NDR_CHECK(ndr_push_compression_start($ndr, &$comndr, $alg, $dlen));"; + $self->pidl("{"); + $self->indent; + $self->pidl("struct ndr_push *$comndr;"); + $self->pidl("NDR_CHECK(ndr_push_compression_start($ndr, &$comndr, $alg, $dlen));"); return $comndr; } -sub ParseCompressionPushEnd($$$$) +sub ParseCompressionPushEnd($$$$$) { - my ($e,$l,$ndr,$env) = @_; + my ($self,$e,$l,$ndr,$env) = @_; my $comndr = "$ndr\_compressed"; my $alg = compression_alg($e, $l); my $dlen = compression_dlen($e, $l, $env); - pidl "NDR_CHECK(ndr_push_compression_end($ndr, $comndr, $alg, $dlen));"; - deindent; - pidl "}"; + $self->pidl("NDR_CHECK(ndr_push_compression_end($ndr, $comndr, $alg, $dlen));"); + $self->deindent; + $self->pidl("}"); } -sub ParseCompressionPullStart($$$$) +sub ParseCompressionPullStart($$$$$) { - my ($e,$l,$ndr,$env) = @_; + my ($self,$e,$l,$ndr,$env) = @_; my $comndr = "$ndr\_compressed"; my $alg = compression_alg($e, $l); my $dlen = compression_dlen($e, $l, $env); - pidl "{"; - indent; - pidl "struct ndr_pull *$comndr;"; - pidl "NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen));"; + $self->pidl("{"); + $self->indent; + $self->pidl("struct ndr_pull *$comndr;"); + $self->pidl("NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen));"); return $comndr; } -sub ParseCompressionPullEnd($$$$) +sub ParseCompressionPullEnd($$$$$) { - my ($e,$l,$ndr,$env) = @_; + my ($self,$e,$l,$ndr,$env) = @_; my $comndr = "$ndr\_compressed"; my $alg = compression_alg($e, $l); my $dlen = compression_dlen($e, $l, $env); - pidl "NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));"; - deindent; - pidl "}"; + $self->pidl("NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));"); + $self->deindent; + $self->pidl("}"); } -sub ParseSubcontextPushStart($$$$) +sub ParseSubcontextPushStart($$$$$) { - my ($e,$l,$ndr,$env) = @_; + my ($self,$e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL}); - pidl "{"; - indent; - pidl "struct ndr_push *$subndr;"; - pidl "NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + $self->pidl("{"); + $self->indent; + $self->pidl("struct ndr_push *$subndr;"); + $self->pidl("NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"); if (defined $l->{COMPRESSION}) { - $subndr = ParseCompressionPushStart($e, $l, $subndr, $env); + $subndr = $self->ParseCompressionPushStart($e, $l, $subndr, $env); } return $subndr; } -sub ParseSubcontextPushEnd($$$$) +sub ParseSubcontextPushEnd($$$$$) { - my ($e,$l,$ndr,$env) = @_; + my ($self,$e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL}); if (defined $l->{COMPRESSION}) { - ParseCompressionPushEnd($e, $l, $subndr, $env); + $self->ParseCompressionPushEnd($e, $l, $subndr, $env); } - pidl "NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; - deindent; - pidl "}"; + $self->pidl("NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"); + $self->deindent; + $self->pidl("}"); } -sub ParseSubcontextPullStart($$$$) +sub ParseSubcontextPullStart($$$$$) { - my ($e,$l,$ndr,$env) = @_; + my ($self,$e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL}); - pidl "{"; - indent; - pidl "struct ndr_pull *$subndr;"; - pidl "NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"; + $self->pidl("{"); + $self->indent; + $self->pidl("struct ndr_pull *$subndr;"); + $self->pidl("NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));"); if (defined $l->{COMPRESSION}) { - $subndr = ParseCompressionPullStart($e, $l, $subndr, $env); + $subndr = $self->ParseCompressionPullStart($e, $l, $subndr, $env); } return $subndr; } -sub ParseSubcontextPullEnd($$$$) +sub ParseSubcontextPullEnd($$$$$) { - my ($e,$l,$ndr,$env) = @_; + my ($self,$e,$l,$ndr,$env) = @_; my $subndr = "_ndr_$e->{NAME}"; my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE}, $env, $e->{ORIGINAL}); if (defined $l->{COMPRESSION}) { - ParseCompressionPullEnd($e, $l, $subndr, $env); + $self->ParseCompressionPullEnd($e, $l, $subndr, $env); } - pidl "NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"; - deindent; - pidl "}"; + $self->pidl("NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));"); + $self->deindent; + $self->pidl("}"); } sub ParseElementPushLevel { - my ($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; + my ($self,$e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); @@ -621,45 +623,45 @@ sub ParseElementPushLevel if (defined($ndr_flags)) { if ($l->{TYPE} eq "SUBCONTEXT") { - my $subndr = ParseSubcontextPushStart($e, $l, $ndr, $env); - ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1); - ParseSubcontextPushEnd($e, $l, $ndr, $env); + my $subndr = $self->ParseSubcontextPushStart($e, $l, $ndr, $env); + $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1); + $self->ParseSubcontextPushEnd($e, $l, $ndr, $env); } elsif ($l->{TYPE} eq "POINTER") { - ParsePtrPush($e, $l, $var_name); + $self->ParsePtrPush($e, $l, $var_name); } elsif ($l->{TYPE} eq "ARRAY") { - my $length = ParseArrayPushHeader($e, $l, $ndr, $var_name, $env); + my $length = $self->ParseArrayPushHeader($e, $l, $ndr, $var_name, $env); my $nl = GetNextLevel($e, $l); # Allow speedups for arrays of scalar types if (is_charset_array($e,$l)) { - pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; + $self->pidl("NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"); return; } elsif (has_fast_array($e,$l)) { - pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; + $self->pidl("NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"); return; } } elsif ($l->{TYPE} eq "SWITCH") { - ParseSwitchPush($e, $l, $ndr, $var_name, $env); + $self->ParseSwitchPush($e, $l, $ndr, $var_name, $env); } elsif ($l->{TYPE} eq "DATA") { - ParseDataPush($e, $l, $ndr, $var_name, $primitives, $deferred); + $self->ParseDataPush($e, $l, $ndr, $var_name, $primitives, $deferred); } } if ($l->{TYPE} eq "POINTER" and $deferred) { if ($l->{POINTER_TYPE} ne "ref") { - pidl "if ($var_name) {"; - indent; + $self->pidl("if ($var_name) {"); + $self->indent; if ($l->{POINTER_TYPE} eq "relative") { - pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));"; + $self->pidl("NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));"); } } $var_name = get_value_of($var_name); - ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1); + $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1); if ($l->{POINTER_TYPE} ne "ref") { - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and not is_charset_array($e, $l)) { @@ -669,30 +671,30 @@ sub ParseElementPushLevel $var_name = $var_name . "[$counter]"; if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { - pidl "for ($counter = 0; $counter < $length; $counter++) {"; - indent; - ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0); - deindent; - pidl "}"; + $self->pidl("for ($counter = 0; $counter < $length; $counter++) {"); + $self->indent; + $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0); + $self->deindent; + $self->pidl("}"); } if ($deferred and ContainsDeferred($e, $l)) { - pidl "for ($counter = 0; $counter < $length; $counter++) {"; - indent; - ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1); - deindent; - pidl "}"; + $self->pidl("for ($counter = 0; $counter < $length; $counter++) {"); + $self->indent; + $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1); + $self->deindent; + $self->pidl("}"); } } elsif ($l->{TYPE} eq "SWITCH") { - ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred); + $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred); } } ##################################################################### # parse scalars in a structure element -sub ParseElementPush($$$$$) +sub ParseElementPush($$$$$$) { - my ($e,$ndr,$env,$primitives,$deferred) = @_; + my ($self,$e,$ndr,$env,$primitives,$deferred) = @_; my $subndr = undef; my $var_name = $env->{$e->{NAME}}; @@ -701,57 +703,57 @@ sub ParseElementPush($$$$$) # Representation type is different from transmit_as if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { - pidl "{"; - indent; + $self->pidl("{"); + $self->indent; my $transmit_name = "_transmit_$e->{NAME}"; - pidl mapTypeName($e->{TYPE}) ." $transmit_name;"; - pidl "NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}($var_name, " . get_pointer_to($transmit_name) . "));"; + $self->pidl(mapTypeName($e->{TYPE}) ." $transmit_name;"); + $self->pidl("NDR_CHECK(ndr_$e->{REPRESENTATION_TYPE}_to_$e->{TYPE}($var_name, " . get_pointer_to($transmit_name) . "));"); $var_name = $transmit_name; } $var_name = append_prefix($e, $var_name); - start_flags($e); + $self->start_flags($e); if (defined(my $value = has_property($e, "value"))) { $var_name = ParseExpr($value, $env, $e->{ORIGINAL}); } - ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred); + $self->ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred); - end_flags($e); + $self->end_flags($e); if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } } ##################################################################### # parse a pointer in a struct element or function -sub ParsePtrPush($$$) +sub ParsePtrPush($$$$) { - my ($e,$l,$var_name) = @_; + my ($self,$e,$l,$var_name) = @_; if ($l->{POINTER_TYPE} eq "ref") { - pidl "if ($var_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"; + $self->pidl("if ($var_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"); if ($l->{LEVEL} eq "EMBEDDED") { - pidl "NDR_CHECK(ndr_push_ref_ptr(ndr));"; + $self->pidl("NDR_CHECK(ndr_push_ref_ptr(ndr));"); } } elsif ($l->{POINTER_TYPE} eq "relative") { - pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));"; + $self->pidl("NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));"); } elsif ($l->{POINTER_TYPE} eq "unique") { - pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));"; + $self->pidl("NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));"); } elsif ($l->{POINTER_TYPE} eq "full") { - pidl "NDR_CHECK(ndr_push_full_ptr(ndr, $var_name));"; + $self->pidl("NDR_CHECK(ndr_push_full_ptr(ndr, $var_name));"); } else { die("Unhandled pointer type $l->{POINTER_TYPE}"); } } -sub ParseDataPrint($$$) +sub ParseDataPrint($$$$) { - my ($e, $l, $var_name) = @_; + my ($self, $e, $l, $var_name) = @_; if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { @@ -765,22 +767,22 @@ sub ParseDataPrint($$$) Parse::Pidl::Typelist::scalar_is_reference($t)) { $var_name = get_pointer_to($var_name); } - pidl "ndr_print_$t(ndr, \"$e->{NAME}\", $var_name);"; + $self->pidl("ndr_print_$t(ndr, \"$e->{NAME}\", $var_name);"); } else { - ParseTypePrint($l->{DATA_TYPE}, $var_name); + $self->ParseTypePrint($l->{DATA_TYPE}, $var_name); } } ##################################################################### # print scalars in a structure element -sub ParseElementPrint($$$) +sub ParseElementPrint($$$$) { - my($e, $var_name, $env) = @_; + my($self, $e, $var_name, $env) = @_; return if (has_property($e, "noprint")); if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { - pidl "ndr_print_$e->{REPRESENTATION_TYPE}(ndr, \"$e->{NAME}\", $var_name);"; + $self->pidl("ndr_print_$e->{REPRESENTATION_TYPE}(ndr, \"$e->{NAME}\", $var_name);"); return; } @@ -792,11 +794,11 @@ sub ParseElementPrint($$$) foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { - pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);"; - pidl "ndr->depth++;"; + $self->pidl("ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);"); + $self->pidl("ndr->depth++;"); if ($l->{POINTER_TYPE} ne "ref") { - pidl "if ($var_name) {"; - indent; + $self->pidl("if ($var_name) {"); + $self->indent; } $var_name = get_value_of($var_name); } elsif ($l->{TYPE} eq "ARRAY") { @@ -810,86 +812,86 @@ sub ParseElementPrint($$$) $length = "ndr_string_length($var_name, sizeof(*$var_name))"; } else { $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, \&pidl, "return;"), check_fully_dereferenced($e, $env)); + check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return;"), check_fully_dereferenced($e, $env)); } if (is_charset_array($e,$l)) { - pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);"; + $self->pidl("ndr_print_string(ndr, \"$e->{NAME}\", $var_name);"); last; } elsif (has_fast_array($e, $l)) { my $nl = GetNextLevel($e, $l); - pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);"; + $self->pidl("ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);"); last; } else { my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; - pidl "ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);"; - pidl 'ndr->depth++;'; - pidl "for ($counter=0;$counter<$length;$counter++) {"; - indent; - pidl "char *idx_$l->{LEVEL_INDEX}=NULL;"; - pidl "asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);"; - pidl "if (idx_$l->{LEVEL_INDEX}) {"; - indent; + $self->pidl("ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);"); + $self->pidl("ndr->depth++;"); + $self->pidl("for ($counter=0;$counter<$length;$counter++) {"); + $self->indent; + $self->pidl("char *idx_$l->{LEVEL_INDEX}=NULL;"); + $self->pidl("asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);"); + $self->pidl("if (idx_$l->{LEVEL_INDEX}) {"); + $self->indent; $var_name = $var_name . "[$counter]"; } } elsif ($l->{TYPE} eq "DATA") { - ParseDataPrint($e, $l, $var_name); + $self->ParseDataPrint($e, $l, $var_name); } elsif ($l->{TYPE} eq "SWITCH") { my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, \&pidl, "return;"), check_fully_dereferenced($e, $env)); - pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"; + check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return;"), check_fully_dereferenced($e, $env)); + $self->pidl("ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"); } } foreach my $l (reverse @{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { if ($l->{POINTER_TYPE} ne "ref") { - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } - pidl "ndr->depth--;"; + $self->pidl("ndr->depth--;"); } elsif (($l->{TYPE} eq "ARRAY") and not is_charset_array($e,$l) and not has_fast_array($e,$l)) { - pidl "free(idx_$l->{LEVEL_INDEX});"; - deindent; - pidl "}"; - deindent; - pidl "}"; - pidl "ndr->depth--;"; + $self->pidl("free(idx_$l->{LEVEL_INDEX});"); + $self->deindent; + $self->pidl("}"); + $self->deindent; + $self->pidl("}"); + $self->pidl("ndr->depth--;"); } } } ##################################################################### # parse scalars in a structure element - pull size -sub ParseSwitchPull($$$$$) +sub ParseSwitchPull($$$$$$) { - my($e,$l,$ndr,$var_name,$env) = @_; + my($self,$e,$l,$ndr,$var_name,$env) = @_; my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); + check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); $var_name = get_pointer_to($var_name); - pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));"; + $self->pidl("NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));"); } ##################################################################### # push switch element -sub ParseSwitchPush($$$$$) +sub ParseSwitchPush($$$$$$) { - my($e,$l,$ndr,$var_name,$env) = @_; + my($self,$e,$l,$ndr,$var_name,$env) = @_; my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); + check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); $var_name = get_pointer_to($var_name); - pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"; + $self->pidl("NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"); } -sub ParseDataPull($$$$$$) +sub ParseDataPull($$$$$$$) { - my ($e,$l,$ndr,$var_name,$primitives,$deferred) = @_; + my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_; if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { @@ -902,23 +904,23 @@ sub ParseDataPull($$$$$$) $var_name = get_pointer_to($var_name); - pidl "NDR_CHECK(".TypeFunctionName("ndr_pull", $l->{DATA_TYPE})."($ndr, $ndr_flags, $var_name));"; + $self->pidl("NDR_CHECK(".TypeFunctionName("ndr_pull", $l->{DATA_TYPE})."($ndr, $ndr_flags, $var_name));"); if (my $range = has_property($e, "range")) { $var_name = get_value_of($var_name); my ($low, $high) = split(/ /, $range, 2); - pidl "if ($var_name < $low || $var_name > $high) {"; - pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");"; - pidl "}"; + $self->pidl("if ($var_name < $low || $var_name > $high) {"); + $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");"); + $self->pidl("}"); } } else { - ParseTypePull($l->{DATA_TYPE}, $var_name, $primitives, $deferred); + $self->ParseTypePull($l->{DATA_TYPE}, $var_name, $primitives, $deferred); } } -sub ParseDataPush($$$$$$) +sub ParseDataPush($$$$$$$) { - my ($e,$l,$ndr,$var_name,$primitives,$deferred) = @_; + my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_; if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { my $t; @@ -935,9 +937,9 @@ sub ParseDataPush($$$$$$) } my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - pidl "NDR_CHECK(ndr_push_$t($ndr, $ndr_flags, $var_name));"; + $self->pidl("NDR_CHECK(ndr_push_$t($ndr, $ndr_flags, $var_name));"); } else { - ParseTypePush($l->{DATA_TYPE}, $var_name, $primitives, $deferred); + $self->ParseTypePush($l->{DATA_TYPE}, $var_name, $primitives, $deferred); } } @@ -966,9 +968,9 @@ sub CalcNdrFlags($$$) return undef; } -sub ParseMemCtxPullStart($$$) +sub ParseMemCtxPullStart($$$$) { - my ($e, $l, $ptr_name) = @_; + my ($self, $e, $l, $ptr_name) = @_; my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; my $mem_c_ctx = $ptr_name; @@ -988,14 +990,13 @@ sub ParseMemCtxPullStart($$$) } } - pidl "$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);"; - pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);"; + $self->pidl("$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);"); + $self->pidl("NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);"); } -sub ParseMemCtxPullEnd($$) +sub ParseMemCtxPullEnd($$$) { - my $e = shift; - my $l = shift; + my ($self, $e, $l) = @_; my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; my $mem_r_flags = "0"; @@ -1014,21 +1015,21 @@ sub ParseMemCtxPullEnd($$) } } - pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);"; + $self->pidl("NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);"); } -sub CheckStringTerminator($$$$) +sub CheckStringTerminator($$$$$) { - my ($ndr,$e,$l,$length) = @_; + my ($self,$ndr,$e,$l,$length) = @_; my $nl = GetNextLevel($e, $l); # Make sure last element is zero! - pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $length, sizeof($nl->{DATA_TYPE}_t)));"; + $self->pidl("NDR_CHECK(ndr_check_string_terminator($ndr, $length, sizeof($nl->{DATA_TYPE}_t)));"); } sub ParseElementPullLevel { - my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; + my($self,$e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_; my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); @@ -1039,62 +1040,62 @@ sub ParseElementPullLevel # Only pull something if there's actually something to be pulled if (defined($ndr_flags)) { if ($l->{TYPE} eq "SUBCONTEXT") { - my $subndr = ParseSubcontextPullStart($e, $l, $ndr, $env); - ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1); - ParseSubcontextPullEnd($e, $l, $ndr, $env); + my $subndr = $self->ParseSubcontextPullStart($e, $l, $ndr, $env); + $self->ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1); + $self->ParseSubcontextPullEnd($e, $l, $ndr, $env); } elsif ($l->{TYPE} eq "ARRAY") { - my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env); + my $length = $self->ParseArrayPullHeader($e, $l, $ndr, $var_name, $env); my $nl = GetNextLevel($e, $l); if (is_charset_array($e,$l)) { if ($l->{IS_ZERO_TERMINATED}) { - CheckStringTerminator($ndr, $e, $l, $length); + $self->CheckStringTerminator($ndr, $e, $l, $length); } - pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"; + $self->pidl("NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapTypeName($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));"); return; } elsif (has_fast_array($e, $l)) { if ($l->{IS_ZERO_TERMINATED}) { - CheckStringTerminator($ndr,$e,$l,$length); + $self->CheckStringTerminator($ndr,$e,$l,$length); } - pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"; + $self->pidl("NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));"); return; } } elsif ($l->{TYPE} eq "POINTER") { - ParsePtrPull($e, $l, $ndr, $var_name); + $self->ParsePtrPull($e, $l, $ndr, $var_name); } elsif ($l->{TYPE} eq "SWITCH") { - ParseSwitchPull($e, $l, $ndr, $var_name, $env); + $self->ParseSwitchPull($e, $l, $ndr, $var_name, $env); } elsif ($l->{TYPE} eq "DATA") { - ParseDataPull($e, $l, $ndr, $var_name, $primitives, $deferred); + $self->ParseDataPull($e, $l, $ndr, $var_name, $primitives, $deferred); } } # add additional constructions if ($l->{TYPE} eq "POINTER" and $deferred) { if ($l->{POINTER_TYPE} ne "ref") { - pidl "if ($var_name) {"; - indent; + $self->pidl("if ($var_name) {"); + $self->indent; if ($l->{POINTER_TYPE} eq "relative") { - pidl "struct ndr_pull_save _relative_save;"; - pidl "ndr_pull_save(ndr, &_relative_save);"; - pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));"; + $self->pidl("struct ndr_pull_save _relative_save;"); + $self->pidl("ndr_pull_save(ndr, &_relative_save);"); + $self->pidl("NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));"); } } - ParseMemCtxPullStart($e, $l, $var_name); + $self->ParseMemCtxPullStart($e, $l, $var_name); $var_name = get_value_of($var_name); - ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); + $self->ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); - ParseMemCtxPullEnd($e,$l); + $self->ParseMemCtxPullEnd($e,$l); if ($l->{POINTER_TYPE} ne "ref") { if ($l->{POINTER_TYPE} eq "relative") { - pidl "ndr_pull_restore(ndr, &_relative_save);"; + $self->pidl("ndr_pull_restore(ndr, &_relative_save);"); } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and not is_charset_array($e, $l)) { @@ -1104,42 +1105,42 @@ sub ParseElementPullLevel $var_name = $var_name . "[$counter]"; - ParseMemCtxPullStart($e, $l, $array_name); + $self->ParseMemCtxPullStart($e, $l, $array_name); if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { my $nl = GetNextLevel($e,$l); if ($l->{IS_ZERO_TERMINATED}) { - CheckStringTerminator($ndr,$e,$l,$length); + $self->CheckStringTerminator($ndr,$e,$l,$length); } - pidl "for ($counter = 0; $counter < $length; $counter++) {"; - indent; - ParseElementPullLevel($e, $nl, $ndr, $var_name, $env, 1, 0); - deindent; - pidl "}"; + $self->pidl("for ($counter = 0; $counter < $length; $counter++) {"); + $self->indent; + $self->ParseElementPullLevel($e, $nl, $ndr, $var_name, $env, 1, 0); + $self->deindent; + $self->pidl("}"); } if ($deferred and ContainsDeferred($e, $l)) { - pidl "for ($counter = 0; $counter < $length; $counter++) {"; - indent; - ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1); - deindent; - pidl "}"; + $self->pidl("for ($counter = 0; $counter < $length; $counter++) {"); + $self->indent; + $self->ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1); + $self->deindent; + $self->pidl("}"); } - ParseMemCtxPullEnd($e, $l); + $self->ParseMemCtxPullEnd($e, $l); } elsif ($l->{TYPE} eq "SWITCH") { - ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred); + $self->ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred); } } ##################################################################### # parse scalars in a structure element - pull size -sub ParseElementPull($$$$$) +sub ParseElementPull($$$$$$) { - my($e,$ndr,$env,$primitives,$deferred) = @_; + my($self,$e,$ndr,$env,$primitives,$deferred) = @_; my $var_name = $env->{$e->{NAME}}; my $represent_name; @@ -1148,35 +1149,35 @@ sub ParseElementPull($$$$$) return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0])); if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { - pidl "{"; - indent; + $self->pidl("{"); + $self->indent; $represent_name = $var_name; $transmit_name = "_transmit_$e->{NAME}"; $var_name = $transmit_name; - pidl mapTypeName($e->{TYPE})." $var_name;"; + $self->pidl(mapTypeName($e->{TYPE})." $var_name;"); } $var_name = append_prefix($e, $var_name); - start_flags($e); + $self->start_flags($e); - ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred); + $self->ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred); - end_flags($e); + $self->end_flags($e); # Representation type is different from transmit_as if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { - pidl "NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}($transmit_name, ".get_pointer_to($represent_name)."));"; - deindent; - pidl "}"; + $self->pidl("NDR_CHECK(ndr_$e->{TYPE}_to_$e->{REPRESENTATION_TYPE}($transmit_name, ".get_pointer_to($represent_name)."));"); + $self->deindent; + $self->pidl("}"); } } ##################################################################### # parse a pointer in a struct element or function -sub ParsePtrPull($$$$) +sub ParsePtrPull($$$$$) { - my($e,$l,$ndr,$var_name) = @_; + my($self, $e,$l,$ndr,$var_name) = @_; my $nl = GetNextLevel($e, $l); my $next_is_array = ($nl->{TYPE} eq "ARRAY"); @@ -1185,22 +1186,22 @@ sub ParsePtrPull($$$$) if ($l->{POINTER_TYPE} eq "ref") { if ($l->{LEVEL} eq "EMBEDDED") { - pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"; + $self->pidl("NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"); } if (!$next_is_array and !$next_is_string) { - pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; - pidl "\tNDR_PULL_ALLOC($ndr, $var_name);"; - pidl "}"; + $self->pidl("if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"); + $self->pidl("\tNDR_PULL_ALLOC($ndr, $var_name);"); + $self->pidl("}"); } return; } elsif (($l->{POINTER_TYPE} eq "unique") or ($l->{POINTER_TYPE} eq "relative") or ($l->{POINTER_TYPE} eq "full")) { - pidl "NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));"; - pidl "if (_ptr_$e->{NAME}) {"; - indent; + $self->pidl("NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));"); + $self->pidl("if (_ptr_$e->{NAME}) {"); + $self->indent; } else { die("Unhandled pointer type $l->{POINTER_TYPE}"); } @@ -1208,28 +1209,28 @@ sub ParsePtrPull($$$$) # Don't do this for arrays, they're allocated at the actual level # of the array unless ($next_is_array or $next_is_string) { - pidl "NDR_PULL_ALLOC($ndr, $var_name);"; + $self->pidl("NDR_PULL_ALLOC($ndr, $var_name);"); } else { # FIXME: Yes, this is nasty. # We allocate an array twice # - once just to indicate that it's there, # - then the real allocation... - pidl "NDR_PULL_ALLOC($ndr, $var_name);"; + $self->pidl("NDR_PULL_ALLOC($ndr, $var_name);"); } - #pidl "memset($var_name, 0, sizeof($var_name));"; + #$self->pidl("memset($var_name, 0, sizeof($var_name));"); if ($l->{POINTER_TYPE} eq "relative") { - pidl "NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));"; + $self->pidl("NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));"); } - deindent; - pidl "} else {"; - pidl "\t$var_name = NULL;"; - pidl "}"; + $self->deindent; + $self->pidl("} else {"); + $self->pidl("\t$var_name = NULL;"); + $self->pidl("}"); } -sub ParseStructPushPrimitives($$$) +sub ParseStructPushPrimitives($$$$) { - my ($struct, $varname, $env) = @_; + my ($self, $struct, $varname, $env) = @_; # see if the structure contains a conformant array. If it # does, then it must be the last element of the structure, and @@ -1253,39 +1254,39 @@ sub ParseStructPushPrimitives($$$) $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL}); } - pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"; + $self->pidl("NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"); } else { - pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, $varname->$e->{NAME})));"; + $self->pidl("NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, $varname->$e->{NAME})));"); } } - pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));"; + $self->pidl("NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));"); if (defined($struct->{PROPERTIES}{relative_base})) { # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; + $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"); } - ParseElementPush($_, "ndr", $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); + $self->ParseElementPush($_, "ndr", $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); } sub ParseStructPushDeferred($$$) { - my ($struct, $varname, $env) = @_; + my ($self, $struct, $varname, $env) = @_; if (defined($struct->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"; + $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"); } - ParseElementPush($_, "ndr", $env, 0, 1) foreach (@{$struct->{ELEMENTS}}); + $self->ParseElementPush($_, "ndr", $env, 0, 1) foreach (@{$struct->{ELEMENTS}}); } ##################################################################### # parse a struct -sub ParseStructPush($$) +sub ParseStructPush($$$) { - my ($struct, $varname) = @_; + my ($self, $struct, $varname) = @_; return unless defined($struct->{ELEMENTS}); @@ -1293,66 +1294,66 @@ sub ParseStructPush($$) EnvSubstituteValue($env, $struct); - DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}}); + $self->DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}}); - start_flags($struct); + $self->start_flags($struct); - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; - ParseStructPushPrimitives($struct, $varname, $env); - deindent; - pidl "}"; + $self->pidl("if (ndr_flags & NDR_SCALARS) {"); + $self->indent; + $self->ParseStructPushPrimitives($struct, $varname, $env); + $self->deindent; + $self->pidl("}"); - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; - ParseStructPushDeferred($struct, $varname, $env); - deindent; - pidl "}"; + $self->pidl("if (ndr_flags & NDR_BUFFERS) {"); + $self->indent; + $self->ParseStructPushDeferred($struct, $varname, $env); + $self->deindent; + $self->pidl("}"); - end_flags($struct); + $self->end_flags($struct); } ##################################################################### # generate a push function for an enum -sub ParseEnumPush($$) +sub ParseEnumPush($$$) { - my($enum,$varname) = @_; + my($self,$enum,$varname) = @_; my($type_fn) = $enum->{BASE_TYPE}; - start_flags($enum); - pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, $varname));"; - end_flags($enum); + $self->start_flags($enum); + $self->pidl("NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, $varname));"); + $self->end_flags($enum); } ##################################################################### # generate a pull function for an enum -sub ParseEnumPull($$) +sub ParseEnumPull($$$) { - my($enum,$varname) = @_; + my($self,$enum,$varname) = @_; my($type_fn) = $enum->{BASE_TYPE}; my($type_v_decl) = mapTypeName($type_fn); - pidl "$type_v_decl v;"; - start_flags($enum); - pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; - pidl "*$varname = v;"; + $self->pidl("$type_v_decl v;"); + $self->start_flags($enum); + $self->pidl("NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"); + $self->pidl("*$varname = v;"); - end_flags($enum); + $self->end_flags($enum); } ##################################################################### # generate a print function for an enum -sub ParseEnumPrint($$$) +sub ParseEnumPrint($$$$) { - my($enum,$name,$varname) = @_; + my($self,$enum,$name,$varname) = @_; - pidl "const char *val = NULL;"; - pidl ""; + $self->pidl("const char *val = NULL;"); + $self->pidl(""); - start_flags($enum); + $self->start_flags($enum); - pidl "switch ($varname) {"; - indent; + $self->pidl("switch ($varname) {"); + $self->indent; my $els = \@{$enum->{ELEMENTS}}; foreach my $i (0 .. $#{$els}) { my $e = ${$els}[$i]; @@ -1360,15 +1361,15 @@ sub ParseEnumPrint($$$) if ($e =~ /^(.*)=/) { $e = $1; } - pidl "case $e: val = \"$e\"; break;"; + $self->pidl("case $e: val = \"$e\"; break;"); } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); - pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, $varname);"; + $self->pidl("ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, $varname);"); - end_flags($enum); + $self->end_flags($enum); } sub DeclEnum($$$$) @@ -1387,39 +1388,39 @@ $typefamily{ENUM} = { ##################################################################### # generate a push function for a bitmap -sub ParseBitmapPush($$) +sub ParseBitmapPush($$$) { - my($bitmap,$varname) = @_; + my($self,$bitmap,$varname) = @_; my($type_fn) = $bitmap->{BASE_TYPE}; - start_flags($bitmap); + $self->start_flags($bitmap); - pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, $varname));"; + $self->pidl("NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, $varname));"); - end_flags($bitmap); + $self->end_flags($bitmap); } ##################################################################### # generate a pull function for an bitmap -sub ParseBitmapPull($$) +sub ParseBitmapPull($$$) { - my($bitmap,$varname) = @_; + my($self,$bitmap,$varname) = @_; my $type_fn = $bitmap->{BASE_TYPE}; my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); - pidl "$type_decl v;"; - start_flags($bitmap); - pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"; - pidl "*$varname = v;"; + $self->pidl("$type_decl v;"); + $self->start_flags($bitmap); + $self->pidl("NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"); + $self->pidl("*$varname = v;"); - end_flags($bitmap); + $self->end_flags($bitmap); } ##################################################################### # generate a print function for an bitmap -sub ParseBitmapPrintElement($$$$) +sub ParseBitmapPrintElement($$$$$) { - my($e,$bitmap,$name,$varname) = @_; + my($self,$e,$bitmap,$name,$varname) = @_; my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); my($type_fn) = $bitmap->{BASE_TYPE}; my($flag); @@ -1430,28 +1431,28 @@ sub ParseBitmapPrintElement($$$$) die "Bitmap: \"$name\" invalid Flag: \"$e\""; } - pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, $varname);"; + $self->pidl("ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, $varname);"); } ##################################################################### # generate a print function for an bitmap -sub ParseBitmapPrint($$$) +sub ParseBitmapPrint($$$$) { - my($bitmap,$name,$varname) = @_; + my($self,$bitmap,$name,$varname) = @_; my($type_decl) = mapTypeName($bitmap->{TYPE}); my($type_fn) = $bitmap->{BASE_TYPE}; - start_flags($bitmap); + $self->start_flags($bitmap); - pidl "ndr_print_$type_fn(ndr, name, $varname);"; + $self->pidl("ndr_print_$type_fn(ndr, name, $varname);"); - pidl "ndr->depth++;"; + $self->pidl("ndr->depth++;"); foreach my $e (@{$bitmap->{ELEMENTS}}) { - ParseBitmapPrintElement($e, $bitmap, $name, $varname); + $self->ParseBitmapPrintElement($e, $bitmap, $name, $varname); } - pidl "ndr->depth--;"; + $self->pidl("ndr->depth--;"); - end_flags($bitmap); + $self->end_flags($bitmap); } sub DeclBitmap($$$$) @@ -1470,50 +1471,50 @@ $typefamily{BITMAP} = { ##################################################################### # generate a struct print function -sub ParseStructPrint($$$) +sub ParseStructPrint($$$$) { - my($struct,$name,$varname) = @_; + my($self,$struct,$name,$varname) = @_; return unless defined $struct->{ELEMENTS}; my $env = GenerateStructEnv($struct, $varname); - DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}}); + $self->DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}}); - pidl "ndr_print_struct(ndr, name, \"$name\");"; + $self->pidl("ndr_print_struct(ndr, name, \"$name\");"); - start_flags($struct); + $self->start_flags($struct); - pidl "ndr->depth++;"; + $self->pidl("ndr->depth++;"); - ParseElementPrint($_, $env->{$_->{NAME}}, $env) + $self->ParseElementPrint($_, $env->{$_->{NAME}}, $env) foreach (@{$struct->{ELEMENTS}}); - pidl "ndr->depth--;"; + $self->pidl("ndr->depth--;"); - end_flags($struct); + $self->end_flags($struct); } -sub DeclarePtrVariables($) +sub DeclarePtrVariables($$) { - my $e = shift; + my ($self,$e) = @_; foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER" and not ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP")) { - pidl "uint32_t _ptr_$e->{NAME};"; + $self->pidl("uint32_t _ptr_$e->{NAME};"); last; } } } -sub DeclareArrayVariables($) +sub DeclareArrayVariables($$) { - my $e = shift; + my ($self,$e) = @_; foreach my $l (@{$e->{LEVELS}}) { next if has_fast_array($e,$l); next if is_charset_array($e,$l); if ($l->{TYPE} eq "ARRAY") { - pidl "uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};"; + $self->pidl("uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};"); } } } @@ -1538,97 +1539,97 @@ sub need_decl_mem_ctx($$) return 0; } -sub DeclareMemCtxVariables($) +sub DeclareMemCtxVariables($$) { - my $e = shift; + my ($self,$e) = @_; foreach my $l (@{$e->{LEVELS}}) { if (need_decl_mem_ctx($e, $l)) { - pidl "TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};"; + $self->pidl("TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};"); } } } -sub ParseStructPullPrimitives($$$) +sub ParseStructPullPrimitives($$$$) { - my($struct,$varname,$env) = @_; + my($self,$struct,$varname,$env) = @_; if (defined $struct->{SURROUNDING_ELEMENT}) { - pidl "NDR_CHECK(ndr_pull_array_size(ndr, &$varname->$struct->{SURROUNDING_ELEMENT}->{NAME}));"; + $self->pidl("NDR_CHECK(ndr_pull_array_size(ndr, &$varname->$struct->{SURROUNDING_ELEMENT}->{NAME}));"); } - pidl "NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));"; + $self->pidl("NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));"); if (defined($struct->{PROPERTIES}{relative_base})) { # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; + $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, $varname, ndr->offset));"); } - ParseElementPull($_, "ndr", $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); + $self->ParseElementPull($_, "ndr", $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); - add_deferred(); + $self->add_deferred(); } -sub ParseStructPullDeferred($$$) +sub ParseStructPullDeferred($$$$) { - my ($struct,$varname,$env) = @_; + my ($self,$struct,$varname,$env) = @_; if (defined($struct->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, $varname));"; + $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, $varname));"); } foreach my $e (@{$struct->{ELEMENTS}}) { - ParseElementPull($e, "ndr", $env, 0, 1); + $self->ParseElementPull($e, "ndr", $env, 0, 1); } - add_deferred(); + $self->add_deferred(); } ##################################################################### # parse a struct - pull side -sub ParseStructPull($$) +sub ParseStructPull($$$) { - my($struct,$varname) = @_; + my($self,$struct,$varname) = @_; return unless defined $struct->{ELEMENTS}; # declare any internal pointers we need foreach my $e (@{$struct->{ELEMENTS}}) { - DeclarePtrVariables($e); - DeclareArrayVariables($e); - DeclareMemCtxVariables($e); + $self->DeclarePtrVariables($e); + $self->DeclareArrayVariables($e); + $self->DeclareMemCtxVariables($e); } - start_flags($struct); + $self->start_flags($struct); my $env = GenerateStructEnv($struct, $varname); - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; - ParseStructPullPrimitives($struct,$varname,$env); - deindent; - pidl "}"; - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; - ParseStructPullDeferred($struct,$varname,$env); - deindent; - pidl "}"; + $self->pidl("if (ndr_flags & NDR_SCALARS) {"); + $self->indent; + $self->ParseStructPullPrimitives($struct,$varname,$env); + $self->deindent; + $self->pidl("}"); + $self->pidl("if (ndr_flags & NDR_BUFFERS) {"); + $self->indent; + $self->ParseStructPullDeferred($struct,$varname,$env); + $self->deindent; + $self->pidl("}"); - end_flags($struct); + $self->end_flags($struct); } ##################################################################### # calculate size of ndr struct -sub ParseStructNdrSize($$$) +sub ParseStructNdrSize($$$$) { - my ($t, $name, $varname) = @_; + my ($self,$t, $name, $varname) = @_; my $sizevar; if (my $flags = has_property($t, "flag")) { - pidl "flags |= $flags;"; + $self->pidl("flags |= $flags;"); } - pidl "return ndr_size_struct($varname, flags, (ndr_push_flags_fn_t)ndr_push_$name);"; + $self->pidl("return ndr_size_struct($varname, flags, (ndr_push_flags_fn_t)ndr_push_$name);"); } sub DeclStruct($$$$) @@ -1656,282 +1657,282 @@ $typefamily{STRUCT} = { # calculate size of ndr struct sub ParseUnionNdrSize($$$) { - my ($t, $name, $varname) = @_; + my ($self, $t, $name, $varname) = @_; my $sizevar; if (my $flags = has_property($t, "flag")) { - pidl "flags |= $flags;"; + $self->pidl("flags |= $flags;"); } - pidl "return ndr_size_union($varname, flags, level, (ndr_push_flags_fn_t)ndr_push_$name);"; + $self->pidl("return ndr_size_union($varname, flags, level, (ndr_push_flags_fn_t)ndr_push_$name);"); } -sub ParseUnionPushPrimitives($$) +sub ParseUnionPushPrimitives($$$) { - my ($e, $varname) = @_; + my ($self, $e, $varname) = @_; my $have_default = 0; - pidl "int level = ndr_push_get_switch_value(ndr, $varname);"; + $self->pidl("int level = ndr_push_get_switch_value(ndr, $varname);"); if (defined($e->{SWITCH_TYPE})) { - pidl "NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));"; + $self->pidl("NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));"); } - pidl "switch (level) {"; - indent; + $self->pidl("switch (level) {"); + $self->indent; foreach my $el (@{$e->{ELEMENTS}}) { if ($el->{CASE} eq "default") { $have_default = 1; } - pidl "$el->{CASE}:"; + $self->pidl("$el->{CASE}:"); if ($el->{TYPE} ne "EMPTY") { - indent; + $self->indent; if (defined($e->{PROPERTIES}{relative_base})) { - pidl "NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));"; + $self->pidl("NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));"); # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; + $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"); } - DeclareArrayVariables($el); - ParseElementPush($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); - deindent; + $self->DeclareArrayVariables($el); + $self->ParseElementPush($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); + $self->deindent; } - pidl "break;"; - pidl ""; + $self->pidl("break;"); + $self->pidl(""); } if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + $self->pidl("default:"); + $self->pidl("\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } -sub ParseUnionPushDeferred($$) +sub ParseUnionPushDeferred($$$) { - my ($e, $varname) = @_; + my ($self,$e,$varname) = @_; my $have_default = 0; - pidl "int level = ndr_push_get_switch_value(ndr, $varname);"; + $self->pidl("int level = ndr_push_get_switch_value(ndr, $varname);"); if (defined($e->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"; + $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"); } - pidl "switch (level) {"; - indent; + $self->pidl("switch (level) {"); + $self->indent; foreach my $el (@{$e->{ELEMENTS}}) { if ($el->{CASE} eq "default") { $have_default = 1; } - pidl "$el->{CASE}:"; + $self->pidl("$el->{CASE}:"); if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPush($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); - deindent; + $self->indent; + $self->ParseElementPush($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); + $self->deindent; } - pidl "break;"; - pidl ""; + $self->pidl("break;"); + $self->pidl(""); } if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + $self->pidl("default:"); + $self->pidl("\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } ##################################################################### # parse a union - push side -sub ParseUnionPush($$) +sub ParseUnionPush($$$) { - my ($e,$varname) = @_; + my ($self,$e,$varname) = @_; my $have_default = 0; - start_flags($e); + $self->start_flags($e); - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; - ParseUnionPushPrimitives($e, $varname); - deindent; - pidl "}"; - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; - ParseUnionPushDeferred($e, $varname); - deindent; - pidl "}"; - end_flags($e); + $self->pidl("if (ndr_flags & NDR_SCALARS) {"); + $self->indent; + $self->ParseUnionPushPrimitives($e, $varname); + $self->deindent; + $self->pidl("}"); + $self->pidl("if (ndr_flags & NDR_BUFFERS) {"); + $self->indent; + $self->ParseUnionPushDeferred($e, $varname); + $self->deindent; + $self->pidl("}"); + $self->end_flags($e); } ##################################################################### # print a union -sub ParseUnionPrint($$$) +sub ParseUnionPrint($$$$) { - my ($e,$name,$varname) = @_; + my ($self,$e,$name,$varname) = @_; my $have_default = 0; - pidl "int level;"; + $self->pidl("int level;"); foreach my $el (@{$e->{ELEMENTS}}) { - DeclareArrayVariables($el); + $self->DeclareArrayVariables($el); } - start_flags($e); + $self->start_flags($e); - pidl "level = ndr_print_get_switch_value(ndr, $varname);"; + $self->pidl("level = ndr_print_get_switch_value(ndr, $varname);"); - pidl "ndr_print_union(ndr, name, level, \"$name\");"; + $self->pidl("ndr_print_union(ndr, name, level, \"$name\");"); - pidl "switch (level) {"; - indent; + $self->pidl("switch (level) {"); + $self->indent; foreach my $el (@{$e->{ELEMENTS}}) { if ($el->{CASE} eq "default") { $have_default = 1; } - pidl "$el->{CASE}:"; + $self->pidl("$el->{CASE}:"); if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPrint($el, "$varname->$el->{NAME}", {}); - deindent; + $self->indent; + $self->ParseElementPrint($el, "$varname->$el->{NAME}", {}); + $self->deindent; } - pidl "break;"; - pidl ""; + $self->pidl("break;"); + $self->pidl(""); } if (! $have_default) { - pidl "default:"; - pidl "\tndr_print_bad_level(ndr, name, level);"; + $self->pidl("default:"); + $self->pidl("\tndr_print_bad_level(ndr, name, level);"); } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); - end_flags($e); + $self->end_flags($e); } -sub ParseUnionPullPrimitives($$$) +sub ParseUnionPullPrimitives($$$$) { - my ($e,$varname,$switch_type) = @_; + my ($self,$e,$varname,$switch_type) = @_; my $have_default = 0; if (defined($switch_type)) { - pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));"; - pidl "if (_level != level) {"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $varname\", _level);"; - pidl "}"; + $self->pidl("NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));"); + $self->pidl("if (_level != level) {"); + $self->pidl("\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $varname\", _level);"); + $self->pidl("}"); } - pidl "switch (level) {"; - indent; + $self->pidl("switch (level) {"); + $self->indent; foreach my $el (@{$e->{ELEMENTS}}) { if ($el->{CASE} eq "default") { $have_default = 1; } - pidl "$el->{CASE}: {"; + $self->pidl("$el->{CASE}: {"); if ($el->{TYPE} ne "EMPTY") { - indent; - DeclarePtrVariables($el); - DeclareArrayVariables($el); + $self->indent; + $self->DeclarePtrVariables($el); + $self->DeclareArrayVariables($el); if (defined($e->{PROPERTIES}{relative_base})) { - pidl "NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));"; + $self->pidl("NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));"); # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, $varname, ndr->offset));"; + $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, $varname, ndr->offset));"); } - ParseElementPull($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); - deindent; + $self->ParseElementPull($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); + $self->deindent; } - pidl "break; }"; - pidl ""; + $self->pidl("break; }"); + $self->pidl(""); } if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + $self->pidl("default:"); + $self->pidl("\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } -sub ParseUnionPullDeferred($$) +sub ParseUnionPullDeferred($$$) { - my ($e,$varname) = @_; + my ($self,$e,$varname) = @_; my $have_default = 0; if (defined($e->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, $varname));"; + $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, $varname));"); } - pidl "switch (level) {"; - indent; + $self->pidl("switch (level) {"); + $self->indent; foreach my $el (@{$e->{ELEMENTS}}) { if ($el->{CASE} eq "default") { $have_default = 1; } - pidl "$el->{CASE}:"; + $self->pidl("$el->{CASE}:"); if ($el->{TYPE} ne "EMPTY") { - indent; - ParseElementPull($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); - deindent; + $self->indent; + $self->ParseElementPull($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); + $self->deindent; } - pidl "break;"; - pidl ""; + $self->pidl("break;"); + $self->pidl(""); } if (! $have_default) { - pidl "default:"; - pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"; + $self->pidl("default:"); + $self->pidl("\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); } ##################################################################### # parse a union - pull side -sub ParseUnionPull($$) +sub ParseUnionPull($$$) { - my ($e,$varname) = @_; + my ($self,$e,$varname) = @_; my $switch_type = $e->{SWITCH_TYPE}; - pidl "int level;"; + $self->pidl("int level;"); if (defined($switch_type)) { if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) { $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type)->{DATA}); } - pidl mapTypeName($switch_type) . " _level;"; + $self->pidl(mapTypeName($switch_type) . " _level;"); } my %double_cases = (); foreach my $el (@{$e->{ELEMENTS}}) { next if ($el->{TYPE} eq "EMPTY"); next if ($double_cases{"$el->{NAME}"}); - DeclareMemCtxVariables($el); + $self->DeclareMemCtxVariables($el); $double_cases{"$el->{NAME}"} = 1; } - start_flags($e); + $self->start_flags($e); - pidl "level = ndr_pull_get_switch_value(ndr, $varname);"; + $self->pidl("level = ndr_pull_get_switch_value(ndr, $varname);"); - pidl "if (ndr_flags & NDR_SCALARS) {"; - indent; - ParseUnionPullPrimitives($e,$varname,$switch_type); - deindent; - pidl "}"; + $self->pidl("if (ndr_flags & NDR_SCALARS) {"); + $self->indent; + $self->ParseUnionPullPrimitives($e,$varname,$switch_type); + $self->deindent; + $self->pidl("}"); - pidl "if (ndr_flags & NDR_BUFFERS) {"; - indent; - ParseUnionPullDeferred($e,$varname); - deindent; - pidl "}"; + $self->pidl("if (ndr_flags & NDR_BUFFERS) {"); + $self->indent; + $self->ParseUnionPullDeferred($e,$varname); + $self->deindent; + $self->pidl("}"); - add_deferred(); + $self->add_deferred(); - end_flags($e); + $self->end_flags($e); } sub DeclUnion($$$$) @@ -1957,38 +1958,38 @@ $typefamily{UNION} = { ##################################################################### # parse a typedef - push side -sub ParseTypedefPush($$) +sub ParseTypedefPush($$$) { - my($e,$varname) = @_; + my($self,$e,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $varname); + $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($self, $e->{DATA}, $varname); } ##################################################################### # parse a typedef - pull side -sub ParseTypedefPull($$) +sub ParseTypedefPull($$$) { - my($e,$varname) = @_; + my($self,$e,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $varname); + $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($self, $e->{DATA}, $varname); } ##################################################################### # parse a typedef - print side -sub ParseTypedefPrint($$$) +sub ParseTypedefPrint($$$$) { - my($e,$name,$varname) = @_; + my($self,$e,$name,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $name, $varname); + $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($self, $e->{DATA}, $name, $varname); } ##################################################################### ## calculate the size of a structure -sub ParseTypedefNdrSize($$$) +sub ParseTypedefNdrSize($$$$) { - my($t,$name,$varname) = @_; + my($self,$t,$name,$varname) = @_; - $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t->{DATA}, $name, $varname); + $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($self, $t->{DATA}, $name, $varname); } sub DeclTypedef($$$$) @@ -2015,88 +2016,88 @@ $typefamily{TYPEDEF} = { ##################################################################### # parse a function - print side -sub ParseFunctionPrint($) +sub ParseFunctionPrint($$) { - my($fn) = shift; + my($self, $fn) = @_; - pidl_hdr "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r);"; + $self->pidl_hdr("void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r);"); return if has_property($fn, "noprint"); - pidl "_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"; - pidl "{"; - indent; + $self->pidl("_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"); + $self->pidl("{"); + $self->indent; foreach my $e (@{$fn->{ELEMENTS}}) { - DeclareArrayVariables($e); + $self->DeclareArrayVariables($e); } - pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");"; - pidl "ndr->depth++;"; + $self->pidl("ndr_print_struct(ndr, name, \"$fn->{NAME}\");"); + $self->pidl("ndr->depth++;"); - pidl "if (flags & NDR_SET_VALUES) {"; - pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;"; - pidl "}"; + $self->pidl("if (flags & NDR_SET_VALUES) {"); + $self->pidl("\tndr->flags |= LIBNDR_PRINT_SET_VALUES;"); + $self->pidl("}"); - pidl "if (flags & NDR_IN) {"; - indent; - pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");"; - pidl "ndr->depth++;"; + $self->pidl("if (flags & NDR_IN) {"); + $self->indent; + $self->pidl("ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");"); + $self->pidl("ndr->depth++;"); my $env = GenerateFunctionInEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - ParseElementPrint($e, $env->{$e->{NAME}}, $env); + $self->ParseElementPrint($e, $env->{$e->{NAME}}, $env); } } - pidl "ndr->depth--;"; - deindent; - pidl "}"; + $self->pidl("ndr->depth--;"); + $self->deindent; + $self->pidl("}"); - pidl "if (flags & NDR_OUT) {"; - indent; - pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");"; - pidl "ndr->depth++;"; + $self->pidl("if (flags & NDR_OUT) {"); + $self->indent; + $self->pidl("ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");"); + $self->pidl("ndr->depth++;"); $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - ParseElementPrint($e, $env->{$e->{NAME}}, $env); + $self->ParseElementPrint($e, $env->{$e->{NAME}}, $env); } } if ($fn->{RETURN_TYPE}) { - pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);"; + $self->pidl("ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);"); } - pidl "ndr->depth--;"; - deindent; - pidl "}"; + $self->pidl("ndr->depth--;"); + $self->deindent; + $self->pidl("}"); - pidl "ndr->depth--;"; - deindent; - pidl "}"; - pidl ""; + $self->pidl("ndr->depth--;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); } ##################################################################### # parse a function -sub ParseFunctionPush($) +sub ParseFunctionPush($$) { - my($fn) = shift; + my($self, $fn) = @_; - fn_declare("push", $fn, "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)") or return; + $self->fn_declare("push", $fn, "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)") or return; return if has_property($fn, "nopush"); - pidl "{"; - indent; + $self->pidl("{"); + $self->indent; foreach my $e (@{$fn->{ELEMENTS}}) { - DeclareArrayVariables($e); + $self->DeclareArrayVariables($e); } - pidl "if (flags & NDR_IN) {"; - indent; + $self->pidl("if (flags & NDR_IN) {"); + $self->indent; my $env = GenerateFunctionInEnv($fn); @@ -2104,38 +2105,38 @@ sub ParseFunctionPush($) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - ParseElementPush($e, "ndr", $env, 1, 1); + $self->ParseElementPush($e, "ndr", $env, 1, 1); } } - deindent; - pidl "}"; + $self->deindent; + $self->pidl("}"); - pidl "if (flags & NDR_OUT) {"; - indent; + $self->pidl("if (flags & NDR_OUT) {"); + $self->indent; $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - ParseElementPush($e, "ndr", $env, 1, 1); + $self->ParseElementPush($e, "ndr", $env, 1, 1); } } if ($fn->{RETURN_TYPE}) { - pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));"; + $self->pidl("NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));"); } - deindent; - pidl "}"; - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; + $self->deindent; + $self->pidl("}"); + $self->pidl("return NT_STATUS_OK;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); } -sub AllocateArrayLevel($$$$$) +sub AllocateArrayLevel($$$$$$) { - my ($e,$l,$ndr,$env,$size) = @_; + my ($self,$e,$l,$ndr,$env,$size) = @_; my $var = ParseExpr($e->{NAME}, $env, $e->{ORIGINAL}); @@ -2144,47 +2145,47 @@ sub AllocateArrayLevel($$$$$) $pl->{TYPE} eq "POINTER" and $pl->{POINTER_TYPE} eq "ref" and not $l->{IS_ZERO_TERMINATED}) { - pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"; - pidl "\tNDR_PULL_ALLOC_N($ndr, $var, $size);"; - pidl "}"; + $self->pidl("if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"); + $self->pidl("\tNDR_PULL_ALLOC_N($ndr, $var, $size);"); + $self->pidl("}"); if (grep(/in/,@{$e->{DIRECTION}}) and grep(/out/,@{$e->{DIRECTION}})) { - pidl "memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));"; + $self->pidl("memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));"); } return; } - pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);"; + $self->pidl("NDR_PULL_ALLOC_N($ndr, $var, $size);"); } ##################################################################### # parse a function -sub ParseFunctionPull($) +sub ParseFunctionPull($$) { - my($fn) = shift; + my($self,$fn) = @_; # pull function args - fn_declare("pull", $fn, "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)") or return; + $self->fn_declare("pull", $fn, "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)") or return; - pidl "{"; - indent; + $self->pidl("{"); + $self->indent; # declare any internal pointers we need foreach my $e (@{$fn->{ELEMENTS}}) { - DeclarePtrVariables($e); - DeclareArrayVariables($e); + $self->DeclarePtrVariables($e); + $self->DeclareArrayVariables($e); } my %double_cases = (); foreach my $e (@{$fn->{ELEMENTS}}) { next if ($e->{TYPE} eq "EMPTY"); next if ($double_cases{"$e->{NAME}"}); - DeclareMemCtxVariables($e); + $self->DeclareMemCtxVariables($e); $double_cases{"$e->{NAME}"} = 1; } - pidl "if (flags & NDR_IN) {"; - indent; + $self->pidl("if (flags & NDR_IN) {"); + $self->indent; # auto-init the out section of a structure. I originally argued that # this was a bad idea as it hides bugs, but coping correctly @@ -2192,8 +2193,8 @@ sub ParseFunctionPull($) # out to be too tricky (tridge) foreach my $e (@{$fn->{ELEMENTS}}) { next unless grep(/out/, @{$e->{DIRECTION}}); - pidl "ZERO_STRUCT(r->out);"; - pidl ""; + $self->pidl("ZERO_STRUCT(r->out);"); + $self->pidl(""); last; } @@ -2201,7 +2202,7 @@ sub ParseFunctionPull($) foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/in/, @{$e->{DIRECTION}})); - ParseElementPull($e, "ndr", $env, 1, 1); + $self->ParseElementPull($e, "ndr", $env, 1, 1); } # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's @@ -2217,96 +2218,96 @@ sub ParseFunctionPull($) and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}); if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { - my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, \&pidl, "return NT_STATUS_INVALID_PARAMETER_MIX;"), + my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); - pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"; + $self->pidl("NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"); if (grep(/in/, @{$e->{DIRECTION}})) { - pidl "memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));"; + $self->pidl("memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));"); } else { - pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));"; + $self->pidl("memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));"); } } else { - pidl "NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});"; + $self->pidl("NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});"); if (grep(/in/, @{$e->{DIRECTION}})) { - pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};"; + $self->pidl("*r->out.$e->{NAME} = *r->in.$e->{NAME};"); } else { - pidl "ZERO_STRUCTP(r->out.$e->{NAME});"; + $self->pidl("ZERO_STRUCTP(r->out.$e->{NAME});"); } } } - add_deferred(); - deindent; - pidl "}"; + $self->add_deferred(); + $self->deindent; + $self->pidl("}"); - pidl "if (flags & NDR_OUT) {"; - indent; + $self->pidl("if (flags & NDR_OUT) {"); + $self->indent; $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { next unless grep(/out/, @{$e->{DIRECTION}}); - ParseElementPull($e, "ndr", $env, 1, 1); + $self->ParseElementPull($e, "ndr", $env, 1, 1); } if ($fn->{RETURN_TYPE}) { - pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));"; + $self->pidl("NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));"); } - add_deferred(); - deindent; - pidl "}"; + $self->add_deferred(); + $self->deindent; + $self->pidl("}"); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; + $self->pidl("return NT_STATUS_OK;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); } ##################################################################### # produce a function call table -sub FunctionTable($) +sub FunctionTable($$) { - my($interface) = shift; + my($self,$interface) = @_; my $count = 0; my $uname = uc $interface->{NAME}; return if ($#{$interface->{FUNCTIONS}}+1 == 0); return unless defined ($interface->{PROPERTIES}->{uuid}); - pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {"; + $self->pidl("static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {"); foreach my $d (@{$interface->{FUNCTIONS}}) { next if not defined($d->{OPNUM}); - pidl "\t{"; - pidl "\t\t\"$d->{NAME}\","; - pidl "\t\tsizeof(struct $d->{NAME}),"; - pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},"; - pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},"; - pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME},"; - pidl "\t\t".($d->{ASYNC}?"True":"False").","; - pidl "\t},"; + $self->pidl("\t{"); + $self->pidl("\t\t\"$d->{NAME}\","); + $self->pidl("\t\tsizeof(struct $d->{NAME}),"); + $self->pidl("\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},"); + $self->pidl("\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},"); + $self->pidl("\t\t(ndr_print_function_t) ndr_print_$d->{NAME},"); + $self->pidl("\t\t".($d->{ASYNC}?"True":"False").","); + $self->pidl("\t},"); $count++; } - pidl "\t{ NULL, 0, NULL, NULL, NULL, False }"; - pidl "};"; - pidl ""; + $self->pidl("\t{ NULL, 0, NULL, NULL, NULL, False }"); + $self->pidl("};"); + $self->pidl(""); - pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {"; + $self->pidl("static const char * const $interface->{NAME}\_endpoint_strings[] = {"); foreach my $ep (@{$interface->{ENDPOINTS}}) { - pidl "\t$ep, "; + $self->pidl("\t$ep, "); } my $endpoint_count = $#{$interface->{ENDPOINTS}}+1; - pidl "};"; - pidl ""; + $self->pidl("};"); + $self->pidl(""); - pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {"; - pidl "\t.count\t= $endpoint_count,"; - pidl "\t.names\t= $interface->{NAME}\_endpoint_strings"; - pidl "};"; - pidl ""; + $self->pidl("static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {"); + $self->pidl("\t.count\t= $endpoint_count,"); + $self->pidl("\t.names\t= $interface->{NAME}\_endpoint_strings"); + $self->pidl("};"); + $self->pidl(""); if (! defined $interface->{PROPERTIES}->{authservice}) { $interface->{PROPERTIES}->{authservice} = "\"host\""; @@ -2315,32 +2316,32 @@ sub FunctionTable($) my @a = split / /, $interface->{PROPERTIES}->{authservice}; my $authservice_count = $#a + 1; - pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {"; + $self->pidl("static const char * const $interface->{NAME}\_authservice_strings[] = {"); foreach my $ap (@a) { - pidl "\t$ap, "; + $self->pidl("\t$ap, "); } - pidl "};"; - pidl ""; + $self->pidl("};"); + $self->pidl(""); - pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {"; - pidl "\t.count\t= $endpoint_count,"; - pidl "\t.names\t= $interface->{NAME}\_authservice_strings"; - pidl "};"; - pidl ""; + $self->pidl("static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {"); + $self->pidl("\t.count\t= $endpoint_count,"); + $self->pidl("\t.names\t= $interface->{NAME}\_authservice_strings"); + $self->pidl("};"); + $self->pidl(""); - pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {"; - pidl "\t.name\t\t= \"$interface->{NAME}\","; - pidl "\t.syntax_id\t= {"; - pidl "\t\t" . print_uuid($interface->{UUID}) .","; - pidl "\t\tDCERPC_$uname\_VERSION"; - pidl "\t},"; - pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,"; - pidl "\t.num_calls\t= $count,"; - pidl "\t.calls\t\t= $interface->{NAME}\_calls,"; - pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,"; - pidl "\t.authservices\t= &$interface->{NAME}\_authservices"; - pidl "};"; - pidl ""; + $self->pidl("\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {"); + $self->pidl("\t.name\t\t= \"$interface->{NAME}\","); + $self->pidl("\t.syntax_id\t= {"); + $self->pidl("\t\t" . print_uuid($interface->{UUID}) .","); + $self->pidl("\t\tDCERPC_$uname\_VERSION"); + $self->pidl("\t},"); + $self->pidl("\t.helpstring\t= DCERPC_$uname\_HELPSTRING,"); + $self->pidl("\t.num_calls\t= $count,"); + $self->pidl("\t.calls\t\t= $interface->{NAME}\_calls,"); + $self->pidl("\t.endpoints\t= &$interface->{NAME}\_endpoints,"); + $self->pidl("\t.authservices\t= &$interface->{NAME}\_authservices"); + $self->pidl("};"); + $self->pidl(""); } @@ -2348,11 +2349,12 @@ sub FunctionTable($) # generate include statements for imported idl files sub HeaderImport { + my $self = shift; my @imports = @_; foreach (@imports) { s/\.idl\"$//; s/^\"//; - pidl choose_header("librpc/gen_ndr/ndr_$_\.h", "gen_ndr/ndr_$_.h"); + $self->pidl(choose_header("librpc/gen_ndr/ndr_$_\.h", "gen_ndr/ndr_$_.h")); } } @@ -2360,9 +2362,10 @@ sub HeaderImport # generate include statements for included header files sub HeaderInclude { + my $self = shift; my @includes = @_; foreach (@includes) { - pidl_hdr "#include $_"; + $self->pidl_hdr("#include $_"); } } @@ -2370,37 +2373,37 @@ sub HeaderInclude # generate prototypes and defines for the interface definitions # FIXME: these prototypes are for the DCE/RPC client functions, not the # NDR parser and so do not belong here, technically speaking -sub HeaderInterface($) +sub HeaderInterface($$) { - my($interface) = shift; + my($self,$interface) = @_; my $count = 0; - pidl_hdr choose_header("librpc/ndr/libndr.h", "ndr.h"); + $self->pidl_hdr(choose_header("librpc/ndr/libndr.h", "ndr.h")); if (has_property($interface, "object")) { - pidl choose_header("librpc/gen_ndr/ndr_orpc.h", "ndr/orpc.h"); + $self->pidl(choose_header("librpc/gen_ndr/ndr_orpc.h", "ndr/orpc.h")); } if (defined $interface->{PROPERTIES}->{helper}) { - HeaderInclude(split / /, $interface->{PROPERTIES}->{helper}); + $self->HeaderInclude(split / /, $interface->{PROPERTIES}->{helper}); } if (defined $interface->{PROPERTIES}->{uuid}) { my $name = uc $interface->{NAME}; - pidl_hdr "#define DCERPC_$name\_UUID " . - Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid})); + $self->pidl_hdr("#define DCERPC_$name\_UUID " . + Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid}))); if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; } - pidl_hdr "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}"; + $self->pidl_hdr("#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}"); - pidl_hdr "#define DCERPC_$name\_NAME \"$interface->{NAME}\""; + $self->pidl_hdr("#define DCERPC_$name\_NAME \"$interface->{NAME}\""); if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; } - pidl_hdr "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}"; + $self->pidl_hdr("#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}"); - pidl_hdr "extern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};"; - pidl_hdr "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);"; + $self->pidl_hdr("extern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};"); + $self->pidl_hdr("NTSTATUS dcerpc_server_$interface->{NAME}_init(void);"); } foreach (@{$interface->{FUNCTIONS}}) { @@ -2413,9 +2416,9 @@ sub HeaderInterface($) $val .= " + DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT"; } - pidl_hdr "#define DCERPC_$u_name ($val)"; + $self->pidl_hdr("#define DCERPC_$u_name ($val)"); - pidl_hdr ""; + $self->pidl_hdr(""); $count++; } @@ -2425,198 +2428,195 @@ sub HeaderInterface($) $val .= " + DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT"; } - pidl_hdr "#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ($val)"; + $self->pidl_hdr("#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ($val)"); } -sub ParseTypePush($$$$) +sub ParseTypePush($$$$$) { - my ($e, $varname, $primitives, $deferred) = @_; + my ($self,$e,$varname, $primitives, $deferred) = @_; # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); - $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($e, $varname); + $self->pidl("uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);") if defined(has_property($e, "relative_base")); + $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($self, $e, $varname); # restore the old relative_base_offset - pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); + $self->pidl("ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base")); } -sub ParseTypePushFunction($$) +sub ParseTypePushFunction($$$) { - my ($e, $varname) = @_; + my ($self, $e, $varname) = @_; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}, $varname); - fn_declare("push", $e, "NTSTATUS ".TypeFunctionName("ndr_push", $e)."(struct ndr_push *ndr, int ndr_flags, $args)") or return; + $self->fn_declare("push", $e, "NTSTATUS ".TypeFunctionName("ndr_push", $e)."(struct ndr_push *ndr, int ndr_flags, $args)") or return; - pidl "{"; - indent; - ParseTypePush($e, $varname, 1, 1); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl "";; + $self->pidl("{"); + $self->indent; + $self->ParseTypePush($e, $varname, 1, 1); + $self->pidl("return NT_STATUS_OK;"); + $self->deindent; + $self->pidl("}"); + $self->pidl("");; } -sub ParseTypePull($$$$) +sub ParseTypePull($$$$$) { - my ($e, $varname, $primitives, $deferred) = @_; + my ($self, $e, $varname, $primitives, $deferred) = @_; # save the old relative_base_offset - pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined(has_property($e, "relative_base")); - $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($e, $varname); + $self->pidl("uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);") if defined(has_property($e, "relative_base")); + $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($self, $e, $varname); # restore the old relative_base_offset - pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined(has_property($e, "relative_base")); + $self->pidl("ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base")); } sub ParseTypePullFunction($$) { - my ($e, $varname) = @_; + my ($self, $e, $varname) = @_; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "pull", $e->{NAME}, $varname); - fn_declare("pull", $e, "NTSTATUS ".TypeFunctionName("ndr_pull", $e)."(struct ndr_pull *ndr, int ndr_flags, $args)") or return; + $self->fn_declare("pull", $e, "NTSTATUS ".TypeFunctionName("ndr_pull", $e)."(struct ndr_pull *ndr, int ndr_flags, $args)") or return; - pidl "{"; - indent; - ParseTypePull($e, $varname, 1, 1); - pidl "return NT_STATUS_OK;"; - deindent; - pidl "}"; - pidl ""; + $self->pidl("{"); + $self->indent; + $self->ParseTypePull($e, $varname, 1, 1); + $self->pidl("return NT_STATUS_OK;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); } -sub ParseTypePrint($$) +sub ParseTypePrint($$$) { - my ($e, $varname) = @_; + my ($self, $e, $varname) = @_; - $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($e, $e->{NAME}, $varname); + $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($self, $e, $e->{NAME}, $varname); } -sub ParseTypePrintFunction($$) +sub ParseTypePrintFunction($$$) { - my ($e, $varname) = @_; + my ($self, $e, $varname) = @_; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "print", $e->{NAME}, $varname); - pidl_hdr "void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *ndr, const char *name, $args);"; + $self->pidl_hdr("void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *ndr, const char *name, $args);"); return if (has_property($e, "noprint")); - pidl "_PUBLIC_ void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *ndr, const char *name, $args)"; - pidl "{"; - indent; - ParseTypePrint($e, $varname); - deindent; - pidl "}"; - pidl ""; + $self->pidl("_PUBLIC_ void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *ndr, const char *name, $args)"); + $self->pidl("{"); + $self->indent; + $self->ParseTypePrint($e, $varname); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); } -sub ParseTypeNdrSize($) +sub ParseTypeNdrSize($$) { - my ($t) = @_; + my ($self,$t) = @_; my $varname = "r"; my $tf = $typefamily{$t->{TYPE}}; my $args = $tf->{SIZE_FN_ARGS}->($t, $t->{NAME}, $varname); - fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)") or return; + $self->fn_declare("size", $t, "size_t ndr_size_$t->{NAME}($args)") or return; - pidl "{"; - indent; - $typefamily{$t->{TYPE}}->{SIZE_FN_BODY}->($t, $t->{NAME}, $varname); - deindent; - pidl "}"; - pidl ""; + $self->pidl("{"); + $self->indent; + $typefamily{$t->{TYPE}}->{SIZE_FN_BODY}->($self,$t, $t->{NAME}, $varname); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); } ##################################################################### # parse the interface definitions -sub ParseInterface($$) +sub ParseInterface($$$) { - my($interface,$needed) = @_; + my($self,$interface,$needed) = @_; - pidl_hdr "#ifndef _HEADER_NDR_$interface->{NAME}"; - pidl_hdr "#define _HEADER_NDR_$interface->{NAME}"; + $self->pidl_hdr("#ifndef _HEADER_NDR_$interface->{NAME}"); + $self->pidl_hdr("#define _HEADER_NDR_$interface->{NAME}"); - pidl_hdr ""; + $self->pidl_hdr(""); if ($needed->{"compression"}) { - pidl choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h"); + $self->pidl(choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h")); } - HeaderInterface($interface); + $self->HeaderInterface($interface); # Typedefs foreach my $d (@{$interface->{TYPES}}) { - ($needed->{TypeFunctionName("ndr_push", $d)}) && ParseTypePushFunction($d, "r"); - ($needed->{TypeFunctionName("ndr_pull", $d)}) && ParseTypePullFunction($d, "r"); - ($needed->{TypeFunctionName("ndr_print", $d)}) && ParseTypePrintFunction($d, "r"); + ($needed->{TypeFunctionName("ndr_push", $d)}) && $self->ParseTypePushFunction($d, "r"); + ($needed->{TypeFunctionName("ndr_pull", $d)}) && $self->ParseTypePullFunction($d, "r"); + ($needed->{TypeFunctionName("ndr_print", $d)}) && $self->ParseTypePrintFunction($d, "r"); # Make sure we don't generate a function twice... $needed->{TypeFunctionName("ndr_push", $d)} = $needed->{TypeFunctionName("ndr_pull", $d)} = $needed->{TypeFunctionName("ndr_print", $d)} = 0; - ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypeNdrSize($d); + ($needed->{"ndr_size_$d->{NAME}"}) && $self->ParseTypeNdrSize($d); } # Functions foreach my $d (@{$interface->{FUNCTIONS}}) { - ($needed->{"ndr_push_$d->{NAME}"}) && ParseFunctionPush($d); - ($needed->{"ndr_pull_$d->{NAME}"}) && ParseFunctionPull($d); - ($needed->{"ndr_print_$d->{NAME}"}) && ParseFunctionPrint($d); + ($needed->{"ndr_push_$d->{NAME}"}) && $self->ParseFunctionPush($d); + ($needed->{"ndr_pull_$d->{NAME}"}) && $self->ParseFunctionPull($d); + ($needed->{"ndr_print_$d->{NAME}"}) && $self->ParseFunctionPrint($d); # Make sure we don't generate a function twice... $needed->{"ndr_push_$d->{NAME}"} = $needed->{"ndr_pull_$d->{NAME}"} = $needed->{"ndr_print_$d->{NAME}"} = 0; } - FunctionTable($interface); + $self->FunctionTable($interface); - pidl_hdr "#endif /* _HEADER_NDR_$interface->{NAME} */"; + $self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */"); } -sub GenerateIncludes() +sub GenerateIncludes($) { + my ($self) = @_; if (is_intree()) { - pidl "#include \"includes.h\""; + $self->pidl("#include \"includes.h\""); } else { - pidl "#define _GNU_SOURCE"; - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; - pidl "#include "; + $self->pidl("#define _GNU_SOURCE"); + $self->pidl("#include "); + $self->pidl("#include "); + $self->pidl("#include "); + $self->pidl("#include "); + $self->pidl("#include "); + $self->pidl("#include "); } # Samba3 has everything in include/includes.h if (is_intree() != 3) { - pidl choose_header("libcli/util/nterr.h", "core/nterr.h"); - pidl choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h"); - pidl choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h"); - pidl choose_header("librpc/rpc/dcerpc.h", "dcerpc.h"); #FIXME: This shouldn't be here! + $self->pidl(choose_header("libcli/util/nterr.h", "core/nterr.h")); + $self->pidl(choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h")); + $self->pidl(choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h")); + $self->pidl(choose_header("librpc/rpc/dcerpc.h", "dcerpc.h")); #FIXME: This shouldn't be here! } } ##################################################################### # parse a parsed IDL structure back into an IDL file -sub Parse($$$) +sub Parse($$$$) { - my($ndr,$gen_header,$ndr_header) = @_; - - $tabs = ""; - $res = ""; + my($self, $ndr,$gen_header,$ndr_header) = @_; - $res_hdr = ""; - pidl_hdr "/* header auto-generated by pidl */"; - pidl_hdr ""; - pidl_hdr "#include \"$gen_header\"" if ($gen_header); - pidl_hdr ""; + $self->pidl_hdr("/* header auto-generated by pidl */"); + $self->pidl_hdr(""); + $self->pidl_hdr("#include \"$gen_header\"") if ($gen_header); + $self->pidl_hdr(""); - pidl "/* parser auto-generated by pidl */"; - pidl ""; - GenerateIncludes(); - pidl "#include \"$ndr_header\"" if ($ndr_header); - pidl ""; + $self->pidl("/* parser auto-generated by pidl */"); + $self->pidl(""); + $self->GenerateIncludes(); + $self->pidl("#include \"$ndr_header\"") if ($ndr_header); + $self->pidl(""); my %needed = (); @@ -2625,12 +2625,12 @@ sub Parse($$$) } foreach (@{$ndr}) { - ($_->{TYPE} eq "INTERFACE") && ParseInterface($_, \%needed); - ($_->{TYPE} eq "IMPORT") && HeaderImport(@{$_->{PATHS}}); - ($_->{TYPE} eq "INCLUDE") && HeaderInclude(@{$_->{PATHS}}); + ($_->{TYPE} eq "INTERFACE") && $self->ParseInterface($_, \%needed); + ($_->{TYPE} eq "IMPORT") && $self->HeaderImport(@{$_->{PATHS}}); + ($_->{TYPE} eq "INCLUDE") && $self->HeaderInclude(@{$_->{PATHS}}); } - return ($res_hdr, $res); + return ($self->{res_hdr}, $self->{res}); } sub NeededElement($$$) -- cgit From 771b57b3fcd0daeb3731f18e5b4ef95013150b82 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 25 Apr 2007 16:10:54 +0000 Subject: r22520: Fix the TYPE command. (This used to be commit b81b0d3308bf51c2e22d54024b3d6f1a59c6b283) --- source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm | 6 ++++++ source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 2 ++ 2 files changed, 8 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm index 44eb77f836..b53c56e741 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm @@ -124,6 +124,12 @@ sub handle_type($$$$$$$$$$) warning($pos, "invalid BASE_TYPE `$base_type'"); } + $dissectorname =~ s/^\"(.*)\"$/$1/g; + + if (not ($dissectorname =~ /;$/)) { + warning($pos, "missing semicolon"); + } + $data->{types}->{$name} = { NAME => $name, POS => $pos, diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 523fff9537..ea3f0db961 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -834,6 +834,8 @@ sub register_type($$$$$$$$) { my ($self, $type,$call,$ft,$base,$mask,$vals,$length) = @_; + return if (defined($self->{conformance}->{types}->{$type})); + $self->{conformance}->{types}->{$type} = { NAME => $type, DISSECTOR_NAME => $call, -- cgit From 118313f9a390a4904c5cfb17e42cd8506ac49f3a Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 1 May 2007 01:57:17 +0000 Subject: r22617: assume we have defered elements if the type is just provides via 'declare' this should fix the problem with the winbind IRPC calls metze (This used to be commit 5abbb4673a49a9dee4002cc6f2ee8180b85cb5e5) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 1d7ca16707..d2556cb8e6 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -281,6 +281,8 @@ sub can_contain_deferred($) my $type = getType($e->{TYPE}); + return 1 if ($type->{TYPE} eq "DECLARE"); # assume the worst + foreach my $x (@{$type->{DATA}->{ELEMENTS}}) { return 1 if ($x->{POINTERS}); return 1 if (can_contain_deferred ($x)); -- cgit From bab99337f88853d6c7a3f418ec175b33974a3d48 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 1 May 2007 02:00:57 +0000 Subject: r22618: handle the properties related to the type and not to 'declare' to avoid a pidl warning with: declare [switch_type(uint16)] union netr_Validation; void foo([in] uint16 level, [in,switch_is(level)] netrValidation info); metze (This used to be commit 3b3344f1df000974ad89bf370e99fd6b6dc42000) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 1122 ++++++++++++++++++------------------ 1 file changed, 561 insertions(+), 561 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 36c83c5922..d1bde8483d 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -326,6 +326,10 @@ sub new { {#State 44 DEFAULT => -89, GOTOS => { + 'decl_enum' => 79, + 'decl_bitmap' => 80, + 'decl_type' => 82, + 'decl_union' => 81, 'property_list' => 78 } }, @@ -343,7 +347,7 @@ sub new { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 79 + 'identifier' => 83 } }, {#State 49 @@ -360,28 +364,28 @@ sub new { }, {#State 53 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -95 }, {#State 54 ACTIONS => { - "," => 95, - ")" => 96 + "," => 99, + ")" => 100 } }, {#State 55 @@ -398,11 +402,11 @@ sub new { }, {#State 59 ACTIONS => { - ";" => 97 + ";" => 101 }, DEFAULT => -123, GOTOS => { - 'optional_semicolon' => 98 + 'optional_semicolon' => 102 } }, {#State 60 @@ -410,16 +414,16 @@ sub new { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 99 + 'identifier' => 103 } }, {#State 61 ACTIONS => { - ";" => 97 + ";" => 101 }, DEFAULT => -123, GOTOS => { - 'optional_semicolon' => 100 + 'optional_semicolon' => 104 } }, {#State 62 @@ -444,18 +448,18 @@ sub new { 'identifier' => 69, 'struct' => 45, 'enum' => 49, - 'type' => 101, + 'type' => 105, 'union' => 51, 'sign' => 70 } }, {#State 65 ACTIONS => { - 'IDENTIFIER' => 102 + 'IDENTIFIER' => 106 }, DEFAULT => -120, GOTOS => { - 'optional_identifier' => 103 + 'optional_identifier' => 107 } }, {#State 66 @@ -481,16 +485,16 @@ sub new { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 104 + 'identifier' => 108 } }, {#State 71 ACTIONS => { - 'IDENTIFIER' => 102 + 'IDENTIFIER' => 106 }, DEFAULT => -120, GOTOS => { - 'optional_identifier' => 105 + 'optional_identifier' => 109 } }, {#State 72 @@ -501,20 +505,20 @@ sub new { }, {#State 74 ACTIONS => { - 'IDENTIFIER' => 102 + 'IDENTIFIER' => 106 }, DEFAULT => -120, GOTOS => { - 'optional_identifier' => 106 + 'optional_identifier' => 110 } }, {#State 75 ACTIONS => { - 'IDENTIFIER' => 102 + 'IDENTIFIER' => 106 }, DEFAULT => -120, GOTOS => { - 'optional_identifier' => 107 + 'optional_identifier' => 111 } }, {#State 76 @@ -525,30 +529,41 @@ sub new { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 108 + 'identifier' => 112 } }, {#State 78 ACTIONS => { - "union" => 109, + "union" => 113, "enum" => 114, "bitmap" => 115, "[" => 17 + } + }, + {#State 79 + DEFAULT => -27 + }, + {#State 80 + DEFAULT => -28 + }, + {#State 81 + DEFAULT => -29 + }, + {#State 82 + ACTIONS => { + 'IDENTIFIER' => 22 }, GOTOS => { - 'decl_enum' => 110, - 'decl_bitmap' => 111, - 'decl_type' => 113, - 'decl_union' => 112 + 'identifier' => 116 } }, - {#State 79 + {#State 83 DEFAULT => -78, GOTOS => { - 'pointers' => 116 + 'pointers' => 117 } }, - {#State 80 + {#State 84 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -557,12 +572,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 117, + 'anytext' => 118, 'text' => 58, 'constant' => 55 } }, - {#State 81 + {#State 85 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -571,12 +586,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 118, + 'anytext' => 119, 'text' => 58, 'constant' => 55 } }, - {#State 82 + {#State 86 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -585,12 +600,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 119, + 'anytext' => 120, 'text' => 58, 'constant' => 55 } }, - {#State 83 + {#State 87 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -599,12 +614,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 120, + 'anytext' => 121, 'text' => 58, 'constant' => 55 } }, - {#State 84 + {#State 88 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -613,12 +628,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 121, + 'anytext' => 122, 'text' => 58, 'constant' => 55 } }, - {#State 85 + {#State 89 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -627,12 +642,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 122, + 'anytext' => 123, 'text' => 58, 'constant' => 55 } }, - {#State 86 + {#State 90 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -641,12 +656,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 123, + 'anytext' => 124, 'text' => 58, 'constant' => 55 } }, - {#State 87 + {#State 91 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -655,13 +670,13 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 124, + 'anytext' => 125, 'text' => 58, 'constant' => 55, - 'commalisttext' => 125 + 'commalisttext' => 126 } }, - {#State 88 + {#State 92 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -670,12 +685,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 126, + 'anytext' => 127, 'text' => 58, 'constant' => 55 } }, - {#State 89 + {#State 93 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -684,12 +699,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 127, + 'anytext' => 128, 'text' => 58, 'constant' => 55 } }, - {#State 90 + {#State 94 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -698,12 +713,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 128, + 'anytext' => 129, 'text' => 58, 'constant' => 55 } }, - {#State 91 + {#State 95 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -712,13 +727,13 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 124, + 'anytext' => 125, 'text' => 58, 'constant' => 55, - 'commalisttext' => 129 + 'commalisttext' => 130 } }, - {#State 92 + {#State 96 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -727,12 +742,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 130, + 'anytext' => 131, 'text' => 58, 'constant' => 55 } }, - {#State 93 + {#State 97 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -741,12 +756,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 131, + 'anytext' => 132, 'text' => 58, 'constant' => 55 } }, - {#State 94 + {#State 98 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -755,12 +770,12 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 132, + 'anytext' => 133, 'text' => 58, 'constant' => 55 } }, - {#State 95 + {#State 99 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -769,106 +784,89 @@ sub new { DEFAULT => -99, GOTOS => { 'identifier' => 57, - 'anytext' => 133, + 'anytext' => 134, 'text' => 58, 'constant' => 55 } }, - {#State 96 + {#State 100 DEFAULT => -94 }, - {#State 97 + {#State 101 DEFAULT => -124 }, - {#State 98 + {#State 102 DEFAULT => -12 }, - {#State 99 + {#State 103 ACTIONS => { - ";" => 134 + ";" => 135 } }, - {#State 100 + {#State 104 DEFAULT => -15 }, - {#State 101 + {#State 105 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 135 + 'identifier' => 136 } }, - {#State 102 + {#State 106 DEFAULT => -119 }, - {#State 103 + {#State 107 ACTIONS => { - "{" => 137 + "{" => 138 }, DEFAULT => -74, GOTOS => { - 'union_body' => 138, - 'opt_union_body' => 136 + 'union_body' => 139, + 'opt_union_body' => 137 } }, - {#State 104 + {#State 108 DEFAULT => -41 }, - {#State 105 + {#State 109 ACTIONS => { - "{" => 140 + "{" => 141 }, DEFAULT => -64, GOTOS => { - 'struct_body' => 139, - 'opt_struct_body' => 141 + 'struct_body' => 140, + 'opt_struct_body' => 142 } }, - {#State 106 + {#State 110 ACTIONS => { - "{" => 142 + "{" => 143 }, DEFAULT => -47, GOTOS => { - 'opt_enum_body' => 144, - 'enum_body' => 143 + 'opt_enum_body' => 145, + 'enum_body' => 144 } }, - {#State 107 + {#State 111 ACTIONS => { - "{" => 146 + "{" => 147 }, DEFAULT => -55, GOTOS => { - 'bitmap_body' => 147, - 'opt_bitmap_body' => 145 + 'bitmap_body' => 148, + 'opt_bitmap_body' => 146 } }, - {#State 108 + {#State 112 ACTIONS => { - "(" => 148 + "(" => 149 } }, - {#State 109 - DEFAULT => -32 - }, - {#State 110 - DEFAULT => -27 - }, - {#State 111 - DEFAULT => -28 - }, - {#State 112 - DEFAULT => -29 - }, {#State 113 - ACTIONS => { - 'IDENTIFIER' => 22 - }, - GOTOS => { - 'identifier' => 149 - } + DEFAULT => -32 }, {#State 114 DEFAULT => -30 @@ -877,355 +875,358 @@ sub new { DEFAULT => -31 }, {#State 116 + ACTIONS => { + ";" => 150 + } + }, + {#State 117 ACTIONS => { 'IDENTIFIER' => 22, - "*" => 151 + "*" => 152 }, GOTOS => { - 'identifier' => 150 + 'identifier' => 151 } }, - {#State 117 + {#State 118 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -112 }, - {#State 118 + {#State 119 ACTIONS => { - ":" => 80, - "<" => 82, - "~" => 83, - "?" => 86, - "{" => 87, - "=" => 90 + ":" => 84, + "<" => 86, + "~" => 87, + "?" => 90, + "{" => 91, + "=" => 94 }, DEFAULT => -103 }, - {#State 119 + {#State 120 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -107 }, - {#State 120 + {#State 121 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -115 }, - {#State 121 + {#State 122 ACTIONS => { - ":" => 80, - "<" => 82, - "~" => 83, - "?" => 86, - "{" => 87, - "=" => 90 + ":" => 84, + "<" => 86, + "~" => 87, + "?" => 90, + "{" => 91, + "=" => 94 }, DEFAULT => -114 }, - {#State 122 + {#State 123 ACTIONS => { - ":" => 80, - "<" => 82, - "~" => 83, - "?" => 86, - "{" => 87, - "=" => 90 + ":" => 84, + "<" => 86, + "~" => 87, + "?" => 90, + "{" => 91, + "=" => 94 }, DEFAULT => -105 }, - {#State 123 + {#State 124 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -111 }, - {#State 124 + {#State 125 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -97 }, - {#State 125 + {#State 126 ACTIONS => { - "}" => 152, - "," => 153 + "}" => 153, + "," => 154 } }, - {#State 126 + {#State 127 ACTIONS => { - ":" => 80, - "<" => 82, - "~" => 83, - "?" => 86, - "{" => 87, - "=" => 90 + ":" => 84, + "<" => 86, + "~" => 87, + "?" => 90, + "{" => 91, + "=" => 94 }, DEFAULT => -109 }, - {#State 127 + {#State 128 ACTIONS => { - ":" => 80, - "<" => 82, - "~" => 83, - "?" => 86, - "{" => 87, - "=" => 90 + ":" => 84, + "<" => 86, + "~" => 87, + "?" => 90, + "{" => 91, + "=" => 94 }, DEFAULT => -110 }, - {#State 128 + {#State 129 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -113 }, - {#State 129 + {#State 130 ACTIONS => { - "," => 153, - ")" => 154 + "," => 154, + ")" => 155 } }, - {#State 130 + {#State 131 ACTIONS => { - ":" => 80, - "<" => 82, - "~" => 83, - "?" => 86, - "{" => 87, - "=" => 90 + ":" => 84, + "<" => 86, + "~" => 87, + "?" => 90, + "{" => 91, + "=" => 94 }, DEFAULT => -108 }, - {#State 131 + {#State 132 ACTIONS => { - ":" => 80, - "<" => 82, - "~" => 83, - "?" => 86, - "{" => 87, - "=" => 90 + ":" => 84, + "<" => 86, + "~" => 87, + "?" => 90, + "{" => 91, + "=" => 94 }, DEFAULT => -104 }, - {#State 132 + {#State 133 ACTIONS => { - ":" => 80, - "<" => 82, - "~" => 83, - "?" => 86, - "{" => 87, - "=" => 90 + ":" => 84, + "<" => 86, + "~" => 87, + "?" => 90, + "{" => 91, + "=" => 94 }, DEFAULT => -106 }, - {#State 133 + {#State 134 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -96 }, - {#State 134 + {#State 135 DEFAULT => -14 }, - {#State 135 + {#State 136 ACTIONS => { - "[" => 155 + "[" => 156 }, DEFAULT => -86, GOTOS => { - 'array_len' => 156 + 'array_len' => 157 } }, - {#State 136 + {#State 137 DEFAULT => -76 }, - {#State 137 + {#State 138 DEFAULT => -71, GOTOS => { - 'union_elements' => 157 + 'union_elements' => 158 } }, - {#State 138 + {#State 139 DEFAULT => -75 }, - {#State 139 + {#State 140 DEFAULT => -65 }, - {#State 140 + {#State 141 DEFAULT => -80, GOTOS => { - 'element_list1' => 158 + 'element_list1' => 159 } }, - {#State 141 + {#State 142 DEFAULT => -66 }, - {#State 142 + {#State 143 ACTIONS => { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 159, - 'enum_element' => 160, - 'enum_elements' => 161 + 'identifier' => 160, + 'enum_element' => 161, + 'enum_elements' => 162 } }, - {#State 143 + {#State 144 DEFAULT => -48 }, - {#State 144 + {#State 145 DEFAULT => -49 }, - {#State 145 + {#State 146 DEFAULT => -57 }, - {#State 146 + {#State 147 ACTIONS => { 'IDENTIFIER' => 22 }, DEFAULT => -60, GOTOS => { - 'identifier' => 164, - 'bitmap_element' => 163, - 'bitmap_elements' => 162, - 'opt_bitmap_elements' => 165 + 'identifier' => 165, + 'bitmap_element' => 164, + 'bitmap_elements' => 163, + 'opt_bitmap_elements' => 166 } }, - {#State 147 + {#State 148 DEFAULT => -56 }, - {#State 148 + {#State 149 ACTIONS => { "," => -82, - "void" => 169, + "void" => 170, ")" => -82 }, DEFAULT => -89, GOTOS => { - 'base_element' => 166, - 'element_list2' => 168, - 'property_list' => 167 - } - }, - {#State 149 - ACTIONS => { - ";" => 170 + 'base_element' => 167, + 'element_list2' => 169, + 'property_list' => 168 } }, {#State 150 + DEFAULT => -26 + }, + {#State 151 ACTIONS => { - "[" => 155, + "[" => 156, "=" => 172 }, GOTOS => { 'array_len' => 171 } }, - {#State 151 + {#State 152 DEFAULT => -79 }, - {#State 152 + {#State 153 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -1239,7 +1240,7 @@ sub new { 'constant' => 55 } }, - {#State 153 + {#State 154 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -1253,7 +1254,7 @@ sub new { 'constant' => 55 } }, - {#State 154 + {#State 155 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -1267,7 +1268,7 @@ sub new { 'constant' => 55 } }, - {#State 155 + {#State 156 ACTIONS => { 'CONSTANT' => 56, 'TEXT' => 13, @@ -1282,12 +1283,12 @@ sub new { 'constant' => 55 } }, - {#State 156 + {#State 157 ACTIONS => { ";" => 178 } }, - {#State 157 + {#State 158 ACTIONS => { "}" => 179 }, @@ -1297,54 +1298,54 @@ sub new { 'property_list' => 180 } }, - {#State 158 + {#State 159 ACTIONS => { "}" => 182 }, DEFAULT => -89, GOTOS => { 'base_element' => 183, - 'property_list' => 167 + 'property_list' => 168 } }, - {#State 159 + {#State 160 ACTIONS => { "=" => 184 }, DEFAULT => -52 }, - {#State 160 + {#State 161 DEFAULT => -50 }, - {#State 161 + {#State 162 ACTIONS => { "}" => 185, "," => 186 } }, - {#State 162 + {#State 163 ACTIONS => { "," => 187 }, DEFAULT => -61 }, - {#State 163 + {#State 164 DEFAULT => -58 }, - {#State 164 + {#State 165 ACTIONS => { "=" => 188 } }, - {#State 165 + {#State 166 ACTIONS => { "}" => 189 } }, - {#State 166 + {#State 167 DEFAULT => -84 }, - {#State 167 + {#State 168 ACTIONS => { 'IDENTIFIER' => 22, "signed" => 72, @@ -1366,17 +1367,14 @@ sub new { 'sign' => 70 } }, - {#State 168 + {#State 169 ACTIONS => { "," => 191, ")" => 192 } }, - {#State 169 - DEFAULT => -83 - }, {#State 170 - DEFAULT => -26 + DEFAULT => -83 }, {#State 171 ACTIONS => { @@ -1399,58 +1397,58 @@ sub new { }, {#State 173 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -117 }, {#State 174 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -98 }, {#State 175 ACTIONS => { - ":" => 80, - "<" => 82, - "~" => 83, - "?" => 86, - "{" => 87, - "=" => 90 + ":" => 84, + "<" => 86, + "~" => 87, + "?" => 90, + "{" => 91, + "=" => 94 }, DEFAULT => -116 }, {#State 176 ACTIONS => { - "[" => 155 + "[" => 156 }, DEFAULT => -86, GOTOS => { @@ -1459,22 +1457,22 @@ sub new { }, {#State 177 ACTIONS => { - "-" => 81, - ":" => 80, - "?" => 86, - "<" => 82, - "+" => 84, - "~" => 83, - "&" => 88, - "{" => 87, - "/" => 89, - "=" => 90, - "|" => 92, - "(" => 91, - "*" => 85, - "." => 93, + "-" => 85, + ":" => 84, + "?" => 90, + "<" => 86, + "+" => 88, + "~" => 87, + "&" => 92, + "{" => 91, + "/" => 93, + "=" => 94, + "|" => 96, + "(" => 95, + "*" => 89, + "." => 97, "]" => 196, - ">" => 94 + ">" => 98 } }, {#State 178 @@ -1528,7 +1526,7 @@ sub new { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 159, + 'identifier' => 160, 'enum_element' => 203 } }, @@ -1537,7 +1535,7 @@ sub new { 'IDENTIFIER' => 22 }, GOTOS => { - 'identifier' => 164, + 'identifier' => 165, 'bitmap_element' => 204 } }, @@ -1568,7 +1566,7 @@ sub new { DEFAULT => -89, GOTOS => { 'base_element' => 207, - 'property_list' => 167 + 'property_list' => 168 } }, {#State 192 @@ -1592,22 +1590,22 @@ sub new { }, {#State 194 ACTIONS => { - "-" => 81, - ":" => 80, - "?" => 86, - "<" => 82, + "-" => 85, + ":" => 84, + "?" => 90, + "<" => 86, ";" => 210, - "+" => 84, - "~" => 83, - "&" => 88, - "{" => 87, - "/" => 89, - "=" => 90, - "|" => 92, - "(" => 91, - "*" => 85, - "." => 93, - ">" => 94 + "+" => 88, + "~" => 87, + "&" => 92, + "{" => 91, + "/" => 93, + "=" => 94, + "|" => 96, + "(" => 95, + "*" => 89, + "." => 97, + ">" => 98 } }, {#State 195 @@ -1615,7 +1613,7 @@ sub new { }, {#State 196 ACTIONS => { - "[" => 155 + "[" => 156 }, DEFAULT => -86, GOTOS => { @@ -1661,21 +1659,21 @@ sub new { }, {#State 202 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -53 }, @@ -1687,28 +1685,28 @@ sub new { }, {#State 205 ACTIONS => { - "-" => 81, - ":" => 80, - "<" => 82, - "+" => 84, - "~" => 83, - "*" => 85, - "?" => 86, - "{" => 87, - "&" => 88, - "/" => 89, - "=" => 90, - "(" => 91, - "|" => 92, - "." => 93, - ">" => 94 + "-" => 85, + ":" => 84, + "<" => 86, + "+" => 88, + "~" => 87, + "*" => 89, + "?" => 90, + "{" => 91, + "&" => 92, + "/" => 93, + "=" => 94, + "(" => 95, + "|" => 96, + "." => 97, + ">" => 98 }, DEFAULT => -62 }, {#State 206 ACTIONS => { 'IDENTIFIER' => 22, - "*" => 151 + "*" => 152 }, GOTOS => { 'identifier' => 214 @@ -1722,22 +1720,22 @@ sub new { }, {#State 209 ACTIONS => { - "-" => 81, - ":" => 80, - "?" => 86, - "<" => 82, + "-" => 85, + ":" => 84, + "?" => 90, + "<" => 86, ";" => 215, - "+" => 84, - "~" => 83, - "&" => 88, - "{" => 87, - "/" => 89, - "=" => 90, - "|" => 92, - "(" => 91, - "*" => 85, - "." => 93, - ">" => 94 + "+" => 88, + "~" => 87, + "&" => 92, + "{" => 91, + "/" => 93, + "=" => 94, + "|" => 96, + "(" => 95, + "*" => 89, + "." => 97, + ">" => 98 } }, {#State 210 @@ -1754,7 +1752,7 @@ sub new { }, {#State 214 ACTIONS => { - "[" => 155 + "[" => 156 }, DEFAULT => -86, GOTOS => { @@ -1779,37 +1777,37 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "idl.yp" +#line 19 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "idl.yp" +#line 20 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'idl', 2, sub -#line 21 "idl.yp" +#line 21 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 5 'idl', 2, sub -#line 22 "idl.yp" +#line 22 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 6 'idl', 2, sub -#line 23 "idl.yp" +#line 23 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'import', 3, sub -#line 26 "idl.yp" +#line 26 "pidl/idl.yp" {{ "TYPE" => "IMPORT", "PATHS" => $_[2], @@ -1820,7 +1818,7 @@ sub [#Rule 8 'include', 3, sub -#line 33 "idl.yp" +#line 33 "pidl/idl.yp" {{ "TYPE" => "INCLUDE", "PATHS" => $_[2], @@ -1831,7 +1829,7 @@ sub [#Rule 9 'importlib', 3, sub -#line 40 "idl.yp" +#line 40 "pidl/idl.yp" {{ "TYPE" => "IMPORTLIB", "PATHS" => $_[2], @@ -1842,19 +1840,19 @@ sub [#Rule 10 'commalist', 1, sub -#line 49 "idl.yp" +#line 49 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 11 'commalist', 3, sub -#line 50 "idl.yp" +#line 50 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 12 'coclass', 7, sub -#line 54 "idl.yp" +#line 54 "pidl/idl.yp" {{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -1870,13 +1868,13 @@ sub [#Rule 14 'interface_names', 4, sub -#line 66 "idl.yp" +#line 66 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 15 'interface', 7, sub -#line 70 "idl.yp" +#line 70 "pidl/idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -1889,13 +1887,13 @@ sub [#Rule 16 'definitions', 1, sub -#line 81 "idl.yp" +#line 81 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 17 'definitions', 2, sub -#line 82 "idl.yp" +#line 82 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 18 @@ -1916,7 +1914,7 @@ sub [#Rule 23 'const', 7, sub -#line 90 "idl.yp" +#line 90 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1930,7 +1928,7 @@ sub [#Rule 24 'const', 8, sub -#line 100 "idl.yp" +#line 100 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1945,7 +1943,7 @@ sub [#Rule 25 'function', 7, sub -#line 114 "idl.yp" +#line 114 "pidl/idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -1957,14 +1955,13 @@ sub }} ], [#Rule 26 - 'declare', 5, + 'declare', 4, sub -#line 126 "idl.yp" +#line 126 "pidl/idl.yp" {{ "TYPE" => "DECLARE", - "PROPERTIES" => $_[2], - "NAME" => $_[4], - "DATA" => $_[3], + "NAME" => $_[3], + "DATA" => $_[2], "FILE" => $_[0]->YYData->{FILE}, "LINE" => $_[0]->YYData->{LINE}, }} @@ -1979,33 +1976,36 @@ sub 'decl_type', 1, undef ], [#Rule 30 - 'decl_enum', 1, + 'decl_enum', 2, sub -#line 140 "idl.yp" +#line 139 "pidl/idl.yp" {{ - "TYPE" => "ENUM" + "TYPE" => "ENUM", + "PROPERTIES" => $_[1] }} ], [#Rule 31 - 'decl_bitmap', 1, + 'decl_bitmap', 2, sub -#line 146 "idl.yp" +#line 146 "pidl/idl.yp" {{ - "TYPE" => "BITMAP" + "TYPE" => "BITMAP", + "PROPERTIES" => $_[1] }} ], [#Rule 32 - 'decl_union', 1, + 'decl_union', 2, sub -#line 152 "idl.yp" +#line 153 "pidl/idl.yp" {{ - "TYPE" => "UNION" + "TYPE" => "UNION", + "PROPERTIES" => $_[1] }} ], [#Rule 33 'typedef', 6, sub -#line 158 "idl.yp" +#line 160 "pidl/idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[1], @@ -2031,7 +2031,7 @@ sub [#Rule 38 'typedecl', 2, sub -#line 171 "idl.yp" +#line 173 "pidl/idl.yp" { $_[1] } ], [#Rule 39 @@ -2043,7 +2043,7 @@ sub [#Rule 41 'existingtype', 2, sub -#line 176 "idl.yp" +#line 178 "pidl/idl.yp" { ($_[1]?$_[1]:"signed") ." $_[2]" } ], [#Rule 42 @@ -2058,13 +2058,13 @@ sub [#Rule 45 'type', 1, sub -#line 180 "idl.yp" +#line 182 "pidl/idl.yp" { "void" } ], [#Rule 46 'enum_body', 3, sub -#line 182 "idl.yp" +#line 184 "pidl/idl.yp" { $_[2] } ], [#Rule 47 @@ -2076,7 +2076,7 @@ sub [#Rule 49 'enum', 4, sub -#line 185 "idl.yp" +#line 187 "pidl/idl.yp" {{ "TYPE" => "ENUM", "PROPERTIES" => $_[1], @@ -2087,13 +2087,13 @@ sub [#Rule 50 'enum_elements', 1, sub -#line 194 "idl.yp" +#line 196 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 51 'enum_elements', 3, sub -#line 195 "idl.yp" +#line 197 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 52 @@ -2102,13 +2102,13 @@ sub [#Rule 53 'enum_element', 3, sub -#line 199 "idl.yp" +#line 201 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 54 'bitmap_body', 3, sub -#line 202 "idl.yp" +#line 204 "pidl/idl.yp" { $_[2] } ], [#Rule 55 @@ -2120,7 +2120,7 @@ sub [#Rule 57 'bitmap', 4, sub -#line 205 "idl.yp" +#line 207 "pidl/idl.yp" {{ "TYPE" => "BITMAP", "PROPERTIES" => $_[1], @@ -2131,13 +2131,13 @@ sub [#Rule 58 'bitmap_elements', 1, sub -#line 214 "idl.yp" +#line 216 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 59 'bitmap_elements', 3, sub -#line 215 "idl.yp" +#line 217 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 60 @@ -2149,13 +2149,13 @@ sub [#Rule 62 'bitmap_element', 3, sub -#line 220 "idl.yp" +#line 222 "pidl/idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 63 'struct_body', 3, sub -#line 223 "idl.yp" +#line 225 "pidl/idl.yp" { $_[2] } ], [#Rule 64 @@ -2167,7 +2167,7 @@ sub [#Rule 66 'struct', 4, sub -#line 227 "idl.yp" +#line 229 "pidl/idl.yp" {{ "TYPE" => "STRUCT", "PROPERTIES" => $_[1], @@ -2178,7 +2178,7 @@ sub [#Rule 67 'empty_element', 2, sub -#line 236 "idl.yp" +#line 238 "pidl/idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2198,7 +2198,7 @@ sub [#Rule 70 'optional_base_element', 2, sub -#line 250 "idl.yp" +#line 252 "pidl/idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 71 @@ -2207,13 +2207,13 @@ sub [#Rule 72 'union_elements', 2, sub -#line 255 "idl.yp" +#line 257 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 73 'union_body', 3, sub -#line 258 "idl.yp" +#line 260 "pidl/idl.yp" { $_[2] } ], [#Rule 74 @@ -2225,7 +2225,7 @@ sub [#Rule 76 'union', 4, sub -#line 262 "idl.yp" +#line 264 "pidl/idl.yp" {{ "TYPE" => "UNION", "PROPERTIES" => $_[1], @@ -2236,7 +2236,7 @@ sub [#Rule 77 'base_element', 5, sub -#line 271 "idl.yp" +#line 273 "pidl/idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2250,25 +2250,25 @@ sub [#Rule 78 'pointers', 0, sub -#line 285 "idl.yp" +#line 287 "pidl/idl.yp" { 0 } ], [#Rule 79 'pointers', 2, sub -#line 286 "idl.yp" +#line 288 "pidl/idl.yp" { $_[1]+1 } ], [#Rule 80 'element_list1', 0, sub -#line 290 "idl.yp" +#line 292 "pidl/idl.yp" { [] } ], [#Rule 81 'element_list1', 3, sub -#line 291 "idl.yp" +#line 293 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 82 @@ -2280,13 +2280,13 @@ sub [#Rule 84 'element_list2', 1, sub -#line 297 "idl.yp" +#line 299 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 85 'element_list2', 3, sub -#line 298 "idl.yp" +#line 300 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 86 @@ -2295,13 +2295,13 @@ sub [#Rule 87 'array_len', 3, sub -#line 303 "idl.yp" +#line 305 "pidl/idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 88 'array_len', 4, sub -#line 304 "idl.yp" +#line 306 "pidl/idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 89 @@ -2310,31 +2310,31 @@ sub [#Rule 90 'property_list', 4, sub -#line 310 "idl.yp" +#line 312 "pidl/idl.yp" { FlattenHash([$_[1],$_[3]]); } ], [#Rule 91 'properties', 1, sub -#line 313 "idl.yp" +#line 315 "pidl/idl.yp" { $_[1] } ], [#Rule 92 'properties', 3, sub -#line 314 "idl.yp" +#line 316 "pidl/idl.yp" { FlattenHash([$_[1], $_[3]]); } ], [#Rule 93 'property', 1, sub -#line 317 "idl.yp" +#line 319 "pidl/idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 94 'property', 4, sub -#line 318 "idl.yp" +#line 320 "pidl/idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 95 @@ -2343,7 +2343,7 @@ sub [#Rule 96 'listtext', 3, sub -#line 323 "idl.yp" +#line 325 "pidl/idl.yp" { "$_[1] $_[3]" } ], [#Rule 97 @@ -2352,13 +2352,13 @@ sub [#Rule 98 'commalisttext', 3, sub -#line 328 "idl.yp" +#line 330 "pidl/idl.yp" { "$_[1],$_[3]" } ], [#Rule 99 'anytext', 0, sub -#line 332 "idl.yp" +#line 334 "pidl/idl.yp" { "" } ], [#Rule 100 @@ -2373,91 +2373,91 @@ sub [#Rule 103 'anytext', 3, sub -#line 334 "idl.yp" +#line 336 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 104 'anytext', 3, sub -#line 335 "idl.yp" +#line 337 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 105 'anytext', 3, sub -#line 336 "idl.yp" +#line 338 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 106 'anytext', 3, sub -#line 337 "idl.yp" +#line 339 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 338 "idl.yp" +#line 340 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 'anytext', 3, sub -#line 339 "idl.yp" +#line 341 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 109 'anytext', 3, sub -#line 340 "idl.yp" +#line 342 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 110 'anytext', 3, sub -#line 341 "idl.yp" +#line 343 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 111 'anytext', 3, sub -#line 342 "idl.yp" +#line 344 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 112 'anytext', 3, sub -#line 343 "idl.yp" +#line 345 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 113 'anytext', 3, sub -#line 344 "idl.yp" +#line 346 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 114 'anytext', 3, sub -#line 345 "idl.yp" +#line 347 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 115 'anytext', 3, sub -#line 346 "idl.yp" +#line 348 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 116 'anytext', 5, sub -#line 347 "idl.yp" +#line 349 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 117 'anytext', 5, sub -#line 348 "idl.yp" +#line 350 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 118 @@ -2475,7 +2475,7 @@ sub [#Rule 122 'text', 1, sub -#line 362 "idl.yp" +#line 364 "pidl/idl.yp" { "\"$_[1]\"" } ], [#Rule 123 @@ -2489,7 +2489,7 @@ sub bless($self,$class); } -#line 373 "idl.yp" +#line 375 "pidl/idl.yp" use Parse::Pidl qw(error); -- cgit From 0bc6c5a7b159bdd4678a378819b9346523729033 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 2 May 2007 18:00:02 +0000 Subject: r22640: - generate nicer output - fix compiler warning about unused ';' metze (This used to be commit 715060187f482486f00e2d6b2cd62d2a0e215a2f) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 2eddf22b05..f43c042da9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -43,7 +43,7 @@ sub HeaderProperties($$) } if ($ret) { - pidl "/* [" . substr($ret, 0, -1) . "] */"; + pidl " /* [" . substr($ret, 0, -1) . "] */"; } } @@ -108,10 +108,12 @@ sub HeaderStruct($$) pidl tabs()."char _empty_;\n"; } $tab_depth--; - pidl tabs()."}"; + + pidl "};"; if (defined $struct->{PROPERTIES}) { HeaderProperties($struct->{PROPERTIES}, []); } + pidl "\n\n"; } ##################################################################### @@ -132,10 +134,10 @@ sub HeaderEnum($$) } pidl "\n"; $tab_depth--; - pidl "}\n"; + pidl "};\n"; pidl "#else\n"; my $count = 0; - pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF}\n"; + pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n"; my $with_val = 0; my $without_val = 0; foreach my $e (@{$enum->{ELEMENTS}}) { @@ -191,11 +193,12 @@ sub HeaderUnion($$) } } $tab_depth--; - pidl "}"; + pidl "};"; if (defined $union->{PROPERTIES}) { HeaderProperties($union->{PROPERTIES}, []); } + pidl "\n\n"; } ##################################################################### @@ -297,7 +300,7 @@ sub HeaderFunction($) HeaderFunctionInOut($fn, "in"); HeaderFunctionInOut($fn, "inout"); $tab_depth--; - pidl tabs()."} in;\n\n"; + pidl tabs()."} in;\n"; $needed++; } @@ -311,7 +314,7 @@ sub HeaderFunction($) pidl tabs().mapTypeName($fn->{RETURN_TYPE}) . " result;\n"; } $tab_depth--; - pidl tabs()."} out;\n\n"; + pidl tabs()."} out;\n"; $needed++; } @@ -362,11 +365,6 @@ sub HeaderInterface($) HeaderUnion($d, $d->{NAME}) if ($d->{TYPE} eq "UNION"); HeaderEnum($d, $d->{NAME}) if ($d->{TYPE} eq "ENUM"); HeaderBitmap($d, $d->{NAME}) if ($d->{TYPE} eq "BITMAP"); - pidl ";\n\n" if ($d->{TYPE} eq "BITMAP" or - $d->{TYPE} eq "STRUCT" or - $d->{TYPE} eq "TYPEDEF" or - $d->{TYPE} eq "UNION" or - $d->{TYPE} eq "ENUM"); } foreach my $d (@{$interface->{DATA}}) { -- cgit From c83c6740ab8a82354b4f6d5be610389e58f8a926 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 4 May 2007 10:44:41 +0000 Subject: r22667: revert revision 22640 as it breaks nested structs in idl metze (This used to be commit b5c84460fc8599fbd894bcf8c4f7b440e2424af1) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index f43c042da9..2eddf22b05 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -43,7 +43,7 @@ sub HeaderProperties($$) } if ($ret) { - pidl " /* [" . substr($ret, 0, -1) . "] */"; + pidl "/* [" . substr($ret, 0, -1) . "] */"; } } @@ -108,12 +108,10 @@ sub HeaderStruct($$) pidl tabs()."char _empty_;\n"; } $tab_depth--; - - pidl "};"; + pidl tabs()."}"; if (defined $struct->{PROPERTIES}) { HeaderProperties($struct->{PROPERTIES}, []); } - pidl "\n\n"; } ##################################################################### @@ -134,10 +132,10 @@ sub HeaderEnum($$) } pidl "\n"; $tab_depth--; - pidl "};\n"; + pidl "}\n"; pidl "#else\n"; my $count = 0; - pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n"; + pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF}\n"; my $with_val = 0; my $without_val = 0; foreach my $e (@{$enum->{ELEMENTS}}) { @@ -193,12 +191,11 @@ sub HeaderUnion($$) } } $tab_depth--; + pidl "}"; - pidl "};"; if (defined $union->{PROPERTIES}) { HeaderProperties($union->{PROPERTIES}, []); } - pidl "\n\n"; } ##################################################################### @@ -300,7 +297,7 @@ sub HeaderFunction($) HeaderFunctionInOut($fn, "in"); HeaderFunctionInOut($fn, "inout"); $tab_depth--; - pidl tabs()."} in;\n"; + pidl tabs()."} in;\n\n"; $needed++; } @@ -314,7 +311,7 @@ sub HeaderFunction($) pidl tabs().mapTypeName($fn->{RETURN_TYPE}) . " result;\n"; } $tab_depth--; - pidl tabs()."} out;\n"; + pidl tabs()."} out;\n\n"; $needed++; } @@ -365,6 +362,11 @@ sub HeaderInterface($) HeaderUnion($d, $d->{NAME}) if ($d->{TYPE} eq "UNION"); HeaderEnum($d, $d->{NAME}) if ($d->{TYPE} eq "ENUM"); HeaderBitmap($d, $d->{NAME}) if ($d->{TYPE} eq "BITMAP"); + pidl ";\n\n" if ($d->{TYPE} eq "BITMAP" or + $d->{TYPE} eq "STRUCT" or + $d->{TYPE} eq "TYPEDEF" or + $d->{TYPE} eq "UNION" or + $d->{TYPE} eq "ENUM"); } foreach my $d (@{$interface->{DATA}}) { -- cgit From ac0e2b606f35a43328c2df0280a1612ed19d0dbc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 7 May 2007 12:31:42 +0000 Subject: r22741: Add MSVC-specific pragma's for Wireshark. Patch from Ronnie. (This used to be commit 40d6235b2491462bae480415e2ae075c041b3b7e) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index ea3f0db961..1fb9c4034f 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -919,6 +919,14 @@ sub Parse($$$$$) $self->{res}->{headers} .= "#ifdef HAVE_CONFIG_H\n"; $self->{res}->{headers} .= "#include \"config.h\"\n"; $self->{res}->{headers} .= "#endif\n\n"; + + $res{headers} .= "#ifdef _MSC_VER\n"; + $res{headers} .= "#pragma warning(disable:4005)\n"; + $res{headers} .= "#pragma warning(disable:4013)\n"; + $res{headers} .= "#pragma warning(disable:4018)\n"; + $res{headers} .= "#pragma warning(disable:4101)\n"; + $res{headers} .= "#endif\n\n"; + $self->{res}->{headers} .= "#include \n"; $self->{res}->{headers} .= "#include \n"; $self->{res}->{headers} .= "#include \n\n"; -- cgit From b157580538a26f0b71fb9d06f167e385064432d5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 7 May 2007 12:41:23 +0000 Subject: r22742: Fix tests. (This used to be commit 7240c2d7e30968b751d944f8a9a50573fcbe6671) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index 1fb9c4034f..ac923bef74 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -920,12 +920,12 @@ sub Parse($$$$$) $self->{res}->{headers} .= "#include \"config.h\"\n"; $self->{res}->{headers} .= "#endif\n\n"; - $res{headers} .= "#ifdef _MSC_VER\n"; - $res{headers} .= "#pragma warning(disable:4005)\n"; - $res{headers} .= "#pragma warning(disable:4013)\n"; - $res{headers} .= "#pragma warning(disable:4018)\n"; - $res{headers} .= "#pragma warning(disable:4101)\n"; - $res{headers} .= "#endif\n\n"; + $self->{res}->{headers} .= "#ifdef _MSC_VER\n"; + $self->{res}->{headers} .= "#pragma warning(disable:4005)\n"; + $self->{res}->{headers} .= "#pragma warning(disable:4013)\n"; + $self->{res}->{headers} .= "#pragma warning(disable:4018)\n"; + $self->{res}->{headers} .= "#pragma warning(disable:4101)\n"; + $self->{res}->{headers} .= "#endif\n\n"; $self->{res}->{headers} .= "#include \n"; $self->{res}->{headers} .= "#include \n"; -- cgit From 7bf94150dac76fac39fe0999afe1d596970c5bb4 Mon Sep 17 00:00:00 2001 From: Ronnie Sahlberg Date: Thu, 5 Jul 2007 07:19:14 +0000 Subject: r23721: For unions, The TAG and the ARM are aligned independently. Move emitting ALIGN_TO_x_BYTES to after the tag has been dissected so the alignment only affects the ARM. (This used to be commit 22945854d91c87cc17df681db5fd3c6871cdaadc) --- source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index ac923bef74..ffe104c941 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -614,12 +614,6 @@ sub Union($$$$) $self->pidl_code("$switch_type level;"); $self->pidl_code(""); - if ($e->{ALIGN} > 1) { - $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;"); - } - - $self->pidl_code(""); - $self->pidl_code("old_offset = offset;"); $self->pidl_code("if (parent_tree) {"); $self->indent; @@ -632,6 +626,12 @@ sub Union($$$$) $self->pidl_code("offset = $switch_dissect(tvb, offset, pinfo, tree, drep, hf_index, &level);"); + if ($e->{ALIGN} > 1) { + $self->pidl_code("ALIGN_TO_$e->{ALIGN}_BYTES;"); + $self->pidl_code(""); + } + + $self->pidl_code("switch(level) {$res\t}"); $self->pidl_code("proto_item_set_len(item, offset-old_offset);\n"); $self->pidl_code("return offset;"); -- cgit From 0479a2f1cbae51fcd8dbdc3c148c808421fb4d25 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Tue, 10 Jul 2007 02:07:03 +0000 Subject: r23792: convert Samba4 to GPLv3 There are still a few tidyups of old FSF addresses to come (in both s3 and s4). More commits soon. (This used to be commit fcf38a38ac691abd0fa51b89dc951a08e89fdafa) --- source4/pidl/lib/Parse/Pidl/Samba4/Template.pm | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm index f953d0f2fe..a35fc7d2eb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Template.pm @@ -30,7 +30,7 @@ sub Template($) 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 + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -39,8 +39,7 @@ sub Template($) GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with this program. If not, see . */ #include \"includes.h\" -- cgit From 2b3161d8de92528be192f593256e97ec9658f88b Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 14 Aug 2007 11:50:45 +0000 Subject: r24407: $element->{ARRAY_LEN} doesn't exist... and a few lines above we use $element->{ORIGINAL}->{ARRAY_LEN} I assume it was just forgotten in the update. metze (This used to be commit 89ea0339b5f95b27ad0eaed430d1f264722a7e84) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index f6c0ee38f7..326ac83751 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -62,7 +62,7 @@ sub DeclLong($) $ret.="*" foreach (1..$numstar); } $ret.=$element->{NAME}; - foreach (@{$element->{ARRAY_LEN}}) { + foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) { next unless (is_constant($_) and not has_property($element, "charset")); $ret.="[$_]"; } -- cgit From 645e87281c78f944fd6fe2ae52c6e0f058c665ff Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 15 Aug 2007 06:08:02 +0000 Subject: r24446: We only need one genric GenerateFunctionInEnv function metze (This used to be commit 0c5be644ba13c68b7378a6ae9dcd314018ece25d) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 17 ++--------------- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 18 +++++++++++------- 2 files changed, 13 insertions(+), 22 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 27b71053fb..5352e41f24 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -16,6 +16,7 @@ use Parse::Pidl::Typelist qw(hasType getType mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::Samba4 qw(DeclLong); +use Parse::Pidl::Samba4::NDR::Parser qw(GenerateFunctionInEnv); use vars qw($VERSION); $VERSION = '0.01'; @@ -33,20 +34,6 @@ sub new($) bless($self, $class); } -sub GenerateFunctionInEnv($) -{ - my $fn = shift; - my %env; - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r.in.$e->{NAME}"; - } - } - - return \%env; -} - sub ParseFunction($$$) { my ($self, $uif, $fn) = @_; @@ -110,7 +97,7 @@ sub ParseFunction($$$) # Since the data is being copied into a user-provided data # structure, the user should be able to know the size beforehand # to allocate a structure of the right size. - my $env = GenerateFunctionInEnv($fn); + my $env = GenerateFunctionInEnv($fn, "r."); my $size_is = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e); $self->pidl("memcpy($e->{NAME}, r.out.$e->{NAME}, $size_is);"); } else { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index b65df06884..73ff28eed0 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -243,30 +243,34 @@ sub EnvSubstituteValue($$) return $env; } -sub GenerateFunctionInEnv($) +sub GenerateFunctionInEnv($;$) { - my $fn = shift; + my ($fn, $base) = @_; my %env; + $base = "r->" unless defined($base); + foreach my $e (@{$fn->{ELEMENTS}}) { if (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->in.$e->{NAME}"; + $env{$e->{NAME}} = $base."in.$e->{NAME}"; } } return \%env; } -sub GenerateFunctionOutEnv($) +sub GenerateFunctionOutEnv($;$) { - my $fn = shift; + my ($fn, $base) = @_; my %env; + $base = "r->" unless defined($base); + foreach my $e (@{$fn->{ELEMENTS}}) { if (grep (/out/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->out.$e->{NAME}"; + $env{$e->{NAME}} = $base."out.$e->{NAME}"; } elsif (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = "r->in.$e->{NAME}"; + $env{$e->{NAME}} = $base."in.$e->{NAME}"; } } -- cgit From eab315fe1e584e96fc84cee96ec842610b2dcdce Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 15 Aug 2007 09:18:25 +0000 Subject: r24452: bail out instead of only giving a warning on incorrect idl files metze (This used to be commit 8aacab6f6a04d0f56bed945e07cd894ac1344ace) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index d2556cb8e6..a3282226a1 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -244,15 +244,15 @@ sub GetElementLevelTable($) } if (scalar(@size_is) > 0) { - warning($e, "size_is() on non-array element"); + fatal($e, "size_is() on non-array element"); } if (scalar(@length_is) > 0) { - warning($e, "length_is() on non-array element"); + fatal($e, "length_is() on non-array element"); } if (has_property($e, "string")) { - warning($e, "string() attribute on non-array element"); + fatal($e, "string() attribute on non-array element"); } push (@$order, { @@ -1142,7 +1142,7 @@ sub Validate($) ($x->{TYPE} eq "INTERFACE") && ValidInterface($x); ($x->{TYPE} eq "IMPORTLIB") && - warning($x, "importlib() not supported"); + fatal($x, "importlib() not supported"); } } -- cgit From 449c9f1f1c03fdc026c56a900dd23b9506dbabf1 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 15 Aug 2007 10:23:28 +0000 Subject: r24454: when level 0 is a pointer we need to look for an array in level 1... metze (This used to be commit ca50b1ad3afbf02fef7c6d1fcbe11d23c515d340) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 5352e41f24..42120bec78 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -83,31 +83,35 @@ sub ParseFunction($$$) $self->pidl("/* Return variables */"); foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); + my $level = 0; fatal($e, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); - if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") and - ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") ) { - $self->pidl("if ( $e->{NAME} ) {"); - $self->indent; + if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { + $level = 1; + if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") { + $self->pidl("if ( $e->{NAME} ) {"); + $self->indent; + } } - if ($e->{LEVELS}[0]->{TYPE} eq "ARRAY") { + if ($e->{LEVELS}[$level]->{TYPE} eq "ARRAY") { # This is a call to GenerateFunctionInEnv intentionally. # Since the data is being copied into a user-provided data # structure, the user should be able to know the size beforehand # to allocate a structure of the right size. my $env = GenerateFunctionInEnv($fn, "r."); - my $size_is = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e); + my $size_is = ParseExpr($e->{LEVELS}[$level]->{SIZE_IS}, $env, $e->{ORIGINAL}); $self->pidl("memcpy($e->{NAME}, r.out.$e->{NAME}, $size_is);"); } else { $self->pidl("*$e->{NAME} = *r.out.$e->{NAME};"); } - if ( ($e->{LEVELS}[0]->{TYPE} eq "POINTER") and - ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") ) { - $self->deindent; - $self->pidl("}"); + if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { + if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") { + $self->deindent; + $self->pidl("}"); + } } } -- cgit From ff71b118b8050c419f98e4e306994523922488cb Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 15 Aug 2007 14:02:23 +0000 Subject: r24463: we have a function to correctly create an $env object so don't try it manually and introduce bugs:-) metze (This used to be commit a79129a4ae412f29a0d730f49327269a92ec8402) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index aa4f3dd1ce..d6311ed360 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -12,6 +12,7 @@ use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(ParseExpr has_property is_constant); use Parse::Pidl::NDR qw(GetNextLevel); use Parse::Pidl::Samba4 qw(DeclLong); +use Parse::Pidl::Samba4::NDR::Parser qw(GenerateFunctionOutEnv); use vars qw($VERSION); $VERSION = '0.01'; @@ -123,12 +124,10 @@ sub ParseFunction($$) pidl "\tNDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"; pidl ""; - my %env = (); + my $env = GenerateFunctionOutEnv($fn, "r."); my $hasout = 0; foreach (@{$fn->{ELEMENTS}}) { if (grep(/out/, @{$_->{DIRECTION}})) { $hasout = 1; } - next unless (grep (/in/, @{$_->{DIRECTION}})); - $env{$_->{NAME}} = "r.in.$_->{NAME}"; } pidl "ZERO_STRUCT(r.out);" if ($hasout); @@ -141,7 +140,7 @@ sub ParseFunction($$) pidl "r.out.$_->{NAME} = r.in.$_->{NAME};"; } elsif (grep(/out/, @dir) and not has_property($_, "represent_as")) { - AllocOutVar($_, "mem_ctx", "r.out.$_->{NAME}", \%env); + AllocOutVar($_, "mem_ctx", "r.out.$_->{NAME}", $env); } } $ret .= ")"; -- cgit From 42ded6d10bd3e2efa472f99d607284996d581f27 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 16 Aug 2007 10:07:19 +0000 Subject: r24482: white space cleanup only... metze (This used to be commit 8a23db61e425d10a6f9710a277497d60b114a753) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 207 ++++++++++++++------------- 1 file changed, 104 insertions(+), 103 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 2eddf22b05..3cf86f769e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -30,10 +30,10 @@ sub tabs() # parse a properties list sub HeaderProperties($$) { - my($props,$ignores) = @_; + my($props,$ignores) = @_; my $ret = ""; - foreach my $d (keys %{$props}) { + foreach my $d (keys %{$props}) { next if (grep(/^$d$/, @$ignores)); if($props->{$d} ne "1") { $ret.= "$d($props->{$d}),"; @@ -93,22 +93,22 @@ sub HeaderElement($) # parse a struct sub HeaderStruct($$) { - my($struct,$name) = @_; + my($struct,$name) = @_; pidl "struct $name"; - return if (not defined($struct->{ELEMENTS})); + return if (not defined($struct->{ELEMENTS})); pidl " {\n"; - $tab_depth++; - my $el_count=0; + $tab_depth++; + my $el_count=0; foreach (@{$struct->{ELEMENTS}}) { HeaderElement($_); $el_count++; - } - if ($el_count == 0) { - # some compilers can't handle empty structures - pidl tabs()."char _empty_;\n"; - } - $tab_depth--; - pidl tabs()."}"; + } + if ($el_count == 0) { + # some compilers can't handle empty structures + pidl tabs()."char _empty_;\n"; + } + $tab_depth--; + pidl tabs()."}"; if (defined $struct->{PROPERTIES}) { HeaderProperties($struct->{PROPERTIES}, []); } @@ -118,17 +118,17 @@ sub HeaderStruct($$) # parse a enum sub HeaderEnum($$) { - my($enum,$name) = @_; - my $first = 1; + my($enum,$name) = @_; + my $first = 1; pidl "#ifndef USE_UINT_ENUMS\n"; pidl "enum $name {\n"; $tab_depth++; foreach my $e (@{$enum->{ELEMENTS}}) { - unless ($first) { pidl ",\n"; } - $first = 0; - pidl tabs(); - pidl $e; + unless ($first) { pidl ",\n"; } + $first = 0; + pidl tabs(); + pidl $e; } pidl "\n"; $tab_depth--; @@ -139,23 +139,23 @@ sub HeaderEnum($$) my $with_val = 0; my $without_val = 0; foreach my $e (@{$enum->{ELEMENTS}}) { - my $t = "$e"; - my $name; - my $value; - if ($t =~ /(.*)=(.*)/) { - $name = $1; - $value = $2; - $with_val = 1; - die ("you can't mix enum member with values and without values when using --uint-enums!") - unless ($without_val == 0); - } else { - $name = $t; - $value = $count++; - $without_val = 1; - die ("you can't mix enum member with values and without values when using --uint-enums!") - unless ($with_val == 0); - } - pidl "#define $name ( $value )\n"; + my $t = "$e"; + my $name; + my $value; + if ($t =~ /(.*)=(.*)/) { + $name = $1; + $value = $2; + $with_val = 1; + die ("you can't mix enum member with values and without values when using --uint-enums!") + unless ($without_val == 0); + } else { + $name = $t; + $value = $count++; + $without_val = 1; + die ("you can't mix enum member with values and without values when using --uint-enums!") + unless ($with_val == 0); + } + pidl "#define $name ( $value )\n"; } pidl "#endif\n"; } @@ -164,11 +164,11 @@ sub HeaderEnum($$) # parse a bitmap sub HeaderBitmap($$) { - my($bitmap,$name) = @_; + my($bitmap,$name) = @_; - pidl "/* bitmap $name */\n"; - pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}}); - pidl "\n"; + pidl "/* bitmap $name */\n"; + pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}}); + pidl "\n"; } ##################################################################### @@ -222,20 +222,20 @@ sub HeaderType($$$) # parse a typedef sub HeaderTypedef($) { - my($typedef) = shift; - HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); + my($typedef) = shift; + HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); } ##################################################################### # parse a const sub HeaderConst($) { - my($const) = shift; - if (!defined($const->{ARRAY_LEN}[0])) { - pidl "#define $const->{NAME}\t( $const->{VALUE} )\n"; - } else { - pidl "#define $const->{NAME}\t $const->{VALUE}\n"; - } + my($const) = shift; + if (!defined($const->{ARRAY_LEN}[0])) { + pidl "#define $const->{NAME}\t( $const->{VALUE} )\n"; + } else { + pidl "#define $const->{NAME}\t $const->{VALUE}\n"; + } } sub ElementDirection($) @@ -252,7 +252,7 @@ sub ElementDirection($) # parse a function sub HeaderFunctionInOut($$) { - my($fn,$prop) = @_; + my($fn,$prop) = @_; foreach (@{$fn->{ELEMENTS}}) { HeaderElement($_) if (ElementDirection($_) eq $prop); @@ -263,15 +263,15 @@ sub HeaderFunctionInOut($$) # determine if we need an "in" or "out" section sub HeaderFunctionInOut_needed($$) { - my($fn,$prop) = @_; + my($fn,$prop) = @_; - return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void"); + return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void"); foreach (@{$fn->{ELEMENTS}}) { return 1 if (ElementDirection($_) eq $prop); - } + } - return undef; + return undef; } my %headerstructs; @@ -280,48 +280,48 @@ my %headerstructs; # parse a function sub HeaderFunction($) { - my($fn) = shift; + my($fn) = shift; - return if ($headerstructs{$fn->{NAME}}); + return if ($headerstructs{$fn->{NAME}}); - $headerstructs{$fn->{NAME}} = 1; + $headerstructs{$fn->{NAME}} = 1; - pidl "\nstruct $fn->{NAME} {\n"; - $tab_depth++; - my $needed = 0; + pidl "\nstruct $fn->{NAME} {\n"; + $tab_depth++; + my $needed = 0; - if (HeaderFunctionInOut_needed($fn, "in") or + if (HeaderFunctionInOut_needed($fn, "in") or HeaderFunctionInOut_needed($fn, "inout")) { - pidl tabs()."struct {\n"; - $tab_depth++; - HeaderFunctionInOut($fn, "in"); - HeaderFunctionInOut($fn, "inout"); - $tab_depth--; - pidl tabs()."} in;\n\n"; - $needed++; - } - - if (HeaderFunctionInOut_needed($fn, "out") or + pidl tabs()."struct {\n"; + $tab_depth++; + HeaderFunctionInOut($fn, "in"); + HeaderFunctionInOut($fn, "inout"); + $tab_depth--; + pidl tabs()."} in;\n\n"; + $needed++; + } + + if (HeaderFunctionInOut_needed($fn, "out") or HeaderFunctionInOut_needed($fn, "inout")) { - pidl tabs()."struct {\n"; - $tab_depth++; - HeaderFunctionInOut($fn, "out"); - HeaderFunctionInOut($fn, "inout"); - if ($fn->{RETURN_TYPE} ne "void") { - pidl tabs().mapTypeName($fn->{RETURN_TYPE}) . " result;\n"; - } - $tab_depth--; - pidl tabs()."} out;\n\n"; - $needed++; - } - - if (!$needed) { - # sigh - some compilers don't like empty structures - pidl tabs()."int _dummy_element;\n"; - } - - $tab_depth--; - pidl "};\n\n"; + pidl tabs()."struct {\n"; + $tab_depth++; + HeaderFunctionInOut($fn, "out"); + HeaderFunctionInOut($fn, "inout"); + if ($fn->{RETURN_TYPE} ne "void") { + pidl tabs().mapTypeName($fn->{RETURN_TYPE}) . " result;\n"; + } + $tab_depth--; + pidl tabs()."} out;\n\n"; + $needed++; + } + + if (!$needed) { + # sigh - some compilers don't like empty structures + pidl tabs()."int _dummy_element;\n"; + } + + $tab_depth--; + pidl "};\n\n"; } sub HeaderImport @@ -363,10 +363,10 @@ sub HeaderInterface($) HeaderEnum($d, $d->{NAME}) if ($d->{TYPE} eq "ENUM"); HeaderBitmap($d, $d->{NAME}) if ($d->{TYPE} eq "BITMAP"); pidl ";\n\n" if ($d->{TYPE} eq "BITMAP" or - $d->{TYPE} eq "STRUCT" or - $d->{TYPE} eq "TYPEDEF" or - $d->{TYPE} eq "UNION" or - $d->{TYPE} eq "ENUM"); + $d->{TYPE} eq "STRUCT" or + $d->{TYPE} eq "TYPEDEF" or + $d->{TYPE} eq "UNION" or + $d->{TYPE} eq "ENUM"); } foreach my $d (@{$interface->{DATA}}) { @@ -382,24 +382,25 @@ sub HeaderInterface($) # parse a parsed IDL into a C header sub Parse($) { - my($idl) = shift; - $tab_depth = 0; + my($idl) = shift; + $tab_depth = 0; $res = ""; %headerstructs = (); - pidl "/* header auto-generated by pidl */\n\n"; + pidl "/* header auto-generated by pidl */\n\n"; if (!is_intree()) { pidl "#include \n"; } pidl "#include \n"; pidl "\n"; - - foreach (@{$idl}) { - ($_->{TYPE} eq "INTERFACE") && HeaderInterface($_); - ($_->{TYPE} eq "IMPORT") && HeaderImport(@{$_->{PATHS}}); - ($_->{TYPE} eq "INCLUDE") && HeaderInclude(@{$_->{PATHS}}); - } - return $res; + + foreach (@{$idl}) { + ($_->{TYPE} eq "INTERFACE") && HeaderInterface($_); + ($_->{TYPE} eq "IMPORT") && HeaderImport(@{$_->{PATHS}}); + ($_->{TYPE} eq "INCLUDE") && HeaderInclude(@{$_->{PATHS}}); + } + + return $res; } 1; -- cgit From e87adacc43eb1f68d0d32b03ced62ae0caabebc9 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 16 Aug 2007 10:54:11 +0000 Subject: r24484: pass down $ndr tree instead of the $pidl tree to Samba4/Header.pm metze (This used to be commit 212e8ec8d51b75fdfed5ae1ea228133811186a72) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 3cf86f769e..650b6f51ab 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -351,17 +351,16 @@ sub HeaderInterface($) pidl "#ifndef _HEADER_$interface->{NAME}\n"; pidl "#define _HEADER_$interface->{NAME}\n\n"; - foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "CONST"); + foreach my $d (@{$interface->{CONSTS}}) { HeaderConst($d); } - foreach my $d (@{$interface->{DATA}}) { - HeaderTypedef($d) if ($d->{TYPE} eq "TYPEDEF"); - HeaderStruct($d, $d->{NAME}) if ($d->{TYPE} eq "STRUCT"); - HeaderUnion($d, $d->{NAME}) if ($d->{TYPE} eq "UNION"); - HeaderEnum($d, $d->{NAME}) if ($d->{TYPE} eq "ENUM"); - HeaderBitmap($d, $d->{NAME}) if ($d->{TYPE} eq "BITMAP"); + foreach my $d (@{$interface->{TYPES}}) { + HeaderTypedef($d->{ORIGINAL}) if ($d->{TYPE} eq "TYPEDEF"); + HeaderStruct($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "STRUCT"); + HeaderUnion($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "UNION"); + HeaderEnum($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "ENUM"); + HeaderBitmap($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "BITMAP"); pidl ";\n\n" if ($d->{TYPE} eq "BITMAP" or $d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "TYPEDEF" or @@ -369,10 +368,8 @@ sub HeaderInterface($) $d->{TYPE} eq "ENUM"); } - foreach my $d (@{$interface->{DATA}}) { - next if ($d->{TYPE} ne "FUNCTION"); - - HeaderFunction($d); + foreach my $d (@{$interface->{FUNCTIONS}}) { + HeaderFunction($d->{ORIGINAL}); } pidl "#endif /* _HEADER_$interface->{NAME} */\n"; @@ -382,7 +379,7 @@ sub HeaderInterface($) # parse a parsed IDL into a C header sub Parse($) { - my($idl) = shift; + my($ndr) = shift; $tab_depth = 0; $res = ""; @@ -394,7 +391,7 @@ sub Parse($) pidl "#include \n"; pidl "\n"; - foreach (@{$idl}) { + foreach (@{$ndr}) { ($_->{TYPE} eq "INTERFACE") && HeaderInterface($_); ($_->{TYPE} eq "IMPORT") && HeaderImport(@{$_->{PATHS}}); ($_->{TYPE} eq "INCLUDE") && HeaderInclude(@{$_->{PATHS}}); -- cgit From 53cd0b017a559ba11dcb3f6193858bba81165390 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 16 Aug 2007 13:29:38 +0000 Subject: r24488: enum's and bitmap's not have nested types metze (This used to be commit 47fb2d42dfa917f5aca4daaacf53134afc22d288) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index a3282226a1..e9c4b59358 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -602,6 +602,8 @@ sub FindNestedTypes($$) my ($l, $t) = @_; return if not defined($t->{ELEMENTS}); + return if ($t->{TYPE} eq "ENUM"); + return if ($t->{TYPE} eq "BITMAP"); foreach (@{$t->{ELEMENTS}}) { if (ref($_->{TYPE}) eq "HASH") { -- cgit From e3162d376cf5eb7086f8398c347420b077a2202a Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 16 Aug 2007 13:34:54 +0000 Subject: r24489: only typedef enum { ... } foo; enum's should look for has_properties() of $enum->{PARENT} metze (This used to be commit 65f3bb8c19971c605fb81fa66317e2ee99132edc) --- source4/pidl/lib/Parse/Pidl/Typelist.pm | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index e635411f3c..b2069c784b 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -174,8 +174,18 @@ sub enum_type_fn($) { my $enum = shift; $enum->{TYPE} eq "ENUM" or die("not an enum"); - if (has_property($enum->{PARENT}, "enum8bit")) { + + # for typedef enum { } we need to check $enum->{PARENT} + if (has_property($enum, "enum8bit")) { return "uint8"; + } elsif (has_property($enum, "enum16bit")) { + return "uint16"; + } elsif (has_property($enum, "v1_enum")) { + return "uint32"; + } elsif (has_property($enum->{PARENT}, "enum8bit")) { + return "uint8"; + } elsif (has_property($enum->{PARENT}, "enum16bit")) { + return "uint16"; } elsif (has_property($enum->{PARENT}, "v1_enum")) { return "uint32"; } -- cgit From 2cbbb00a6cf695d605ede8720d0870d67a5ca9af Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 16 Aug 2007 13:39:30 +0000 Subject: r24490: For ParseBitmap() we use Parse::Pidl::Typelist::bitmap_type_fn() so for ParseEnum() we should also use Parse::Pidl::Typelist::enum_type_fn(). Also the base_type() property isn't standard IDL and we should not support it. This changes TDR enum to also to default to uint16 (as with NDR enums). metze (This used to be commit 13144bdea914f92b5e15fa807fa7ef7c4d6510a2) --- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index a3cb4f3016..832a2c5463 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -194,8 +194,8 @@ sub ParserBitmap($$$$) sub ParserEnum($$$$) { my ($self,$e,$t,$p) = @_; - my $bt = ($e->{PROPERTIES}->{base_type} or "uint8"); - + my $bt = Parse::Pidl::Typelist::enum_type_fn($e); + $self->fn_declare($p, "NTSTATUS tdr_$t\_$e->{NAME} (struct tdr_$t *tdr".typearg($t).", enum $e->{NAME} *v)"); $self->pidl("{"); if ($t eq "pull") { -- cgit From 575c8709262bb97ef1b14d128058620a9200e447 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 16 Aug 2007 14:42:22 +0000 Subject: r24493: - it turns out that foreach my $e (@{$union->{ELEMENTS}}) { changes $union->{ELEMENTS} from undef into an empty array. this removes the difference between struct foo { }; and struct foo; So we need to explicit return before. - we should return the same element for layout for structs and unions with no elements. - fix the testsuite to match metze (This used to be commit 5f1f50cd27e3702b79a19dbe1079498cbfc4842b) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 44 +++++++++++++++++++++++++++++--------- 1 file changed, 34 insertions(+), 10 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index e9c4b59358..e950591cb7 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -392,6 +392,18 @@ sub ParseStruct($$) my @elements = (); my $surrounding = undef; + return { + TYPE => "STRUCT", + NAME => $struct->{NAME}, + SURROUNDING_ELEMENT => undef, + ELEMENTS => undef, + PROPERTIES => $struct->{PROPERTIES}, + ORIGINAL => $struct, + ALIGN => undef + } unless defined($struct->{ELEMENTS}); + + CheckPointerTypes($struct, $pointer_default); + foreach my $x (@{$struct->{ELEMENTS}}) { my $e = ParseElement($x, $pointer_default); @@ -433,12 +445,23 @@ sub ParseUnion($$) { my ($e, $pointer_default) = @_; my @elements = (); + my $hasdefault = 0; my $switch_type = has_property($e, "switch_type"); unless (defined($switch_type)) { $switch_type = "uint32"; } - if (has_property($e, "nodiscriminant")) { $switch_type = undef; } - - my $hasdefault = 0; + + return { + TYPE => "UNION", + NAME => $e->{NAME}, + SWITCH_TYPE => $switch_type, + ELEMENTS => undef, + PROPERTIES => $e->{PROPERTIES}, + HAS_DEFAULT => $hasdefault, + ORIGINAL => $e + } unless defined($e->{ELEMENTS}); + + CheckPointerTypes($e, $pointer_default); + foreach my $x (@{$e->{ELEMENTS}}) { my $t; @@ -501,11 +524,6 @@ sub ParseType($$) { my ($d, $pointer_default) = @_; - if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "UNION") { - return $d if (not defined($d->{ELEMENTS})); - CheckPointerTypes($d, $pointer_default); - } - my $data = { STRUCT => \&ParseStruct, UNION => \&ParseUnion, @@ -589,6 +607,8 @@ sub CheckPointerTypes($$) { my ($s,$default) = @_; + return unless defined($s->{ELEMENTS}); + foreach my $e (@{$s->{ELEMENTS}}) { if ($e->{POINTERS} and not defined(pointer_type($e))) { $e->{PROPERTIES}->{$default} = 1; @@ -1005,6 +1025,8 @@ sub ValidStruct($) ValidProperties($struct, "STRUCT"); + return unless defined($struct->{ELEMENTS}); + foreach my $e (@{$struct->{ELEMENTS}}) { $e->{PARENT} = $struct; ValidElement($e); @@ -1022,7 +1044,9 @@ sub ValidUnion($) if (has_property($union->{PARENT}, "nodiscriminant") and has_property($union->{PARENT}, "switch_type")) { fatal($union->{PARENT}, $union->{PARENT}->{NAME} . ": switch_type() on union without discriminant"); } - + + return unless defined($union->{ELEMENTS}); + foreach my $e (@{$union->{ELEMENTS}}) { $e->{PARENT} = $union; @@ -1129,7 +1153,7 @@ sub ValidInterface($) $d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "UNION" or $d->{TYPE} eq "ENUM" or - $d->{TYPE} eq "BITMAP") && ValidType($d); + $d->{TYPE} eq "BITMAP") && ValidType($d); } } -- cgit From f9bca9e9acc3188f9c8449b2505c0c723dd516af Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 07:06:02 +0000 Subject: r24505: pass down $fn one level metze (This used to be commit 0bad3f06199341aeacef228e482ab755e2e48306) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 650b6f51ab..3c0a7bc24e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -290,24 +290,24 @@ sub HeaderFunction($) $tab_depth++; my $needed = 0; - if (HeaderFunctionInOut_needed($fn, "in") or - HeaderFunctionInOut_needed($fn, "inout")) { + if (HeaderFunctionInOut_needed($fn->{ORIGINAL}, "in") or + HeaderFunctionInOut_needed($fn->{ORIGINAL}, "inout")) { pidl tabs()."struct {\n"; $tab_depth++; - HeaderFunctionInOut($fn, "in"); - HeaderFunctionInOut($fn, "inout"); + HeaderFunctionInOut($fn->{ORIGINAL}, "in"); + HeaderFunctionInOut($fn->{ORIGINAL}, "inout"); $tab_depth--; pidl tabs()."} in;\n\n"; $needed++; } - if (HeaderFunctionInOut_needed($fn, "out") or - HeaderFunctionInOut_needed($fn, "inout")) { + if (HeaderFunctionInOut_needed($fn->{ORIGINAL}, "out") or + HeaderFunctionInOut_needed($fn->{ORIGINAL}, "inout")) { pidl tabs()."struct {\n"; $tab_depth++; - HeaderFunctionInOut($fn, "out"); - HeaderFunctionInOut($fn, "inout"); - if ($fn->{RETURN_TYPE} ne "void") { + HeaderFunctionInOut($fn->{ORIGINAL}, "out"); + HeaderFunctionInOut($fn->{ORIGINAL}, "inout"); + if (defined($fn->{RETURN_TYPE})) { pidl tabs().mapTypeName($fn->{RETURN_TYPE}) . " result;\n"; } $tab_depth--; @@ -368,8 +368,8 @@ sub HeaderInterface($) $d->{TYPE} eq "ENUM"); } - foreach my $d (@{$interface->{FUNCTIONS}}) { - HeaderFunction($d->{ORIGINAL}); + foreach my $fn (@{$interface->{FUNCTIONS}}) { + HeaderFunction($fn); } pidl "#endif /* _HEADER_$interface->{NAME} */\n"; -- cgit From 9785c25519c412670ee6fc7e39828e6744e66e14 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 07:46:34 +0000 Subject: r24506: pass $fn down one more layer metze (This used to be commit 8cc3fd09ffce6f389d979ec0a49d2ecefda70dd1) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 30 ++++++++++++++++------------ 1 file changed, 17 insertions(+), 13 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 3c0a7bc24e..e10f647635 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -254,8 +254,10 @@ sub HeaderFunctionInOut($$) { my($fn,$prop) = @_; - foreach (@{$fn->{ELEMENTS}}) { - HeaderElement($_) if (ElementDirection($_) eq $prop); + return unless defined($fn->{ELEMENTS}); + + foreach my $e (@{$fn->{ELEMENTS}}) { + HeaderElement($e->{ORIGINAL}) if (ElementDirection($e) eq $prop); } } @@ -265,10 +267,12 @@ sub HeaderFunctionInOut_needed($$) { my($fn,$prop) = @_; - return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void"); + return 1 if ($prop eq "out" && defined($fn->{RETURN_TYPE})); + + return undef unless defined($fn->{ELEMENTS}); - foreach (@{$fn->{ELEMENTS}}) { - return 1 if (ElementDirection($_) eq $prop); + foreach my $e (@{$fn->{ELEMENTS}}) { + return 1 if (ElementDirection($e) eq $prop); } return undef; @@ -290,23 +294,23 @@ sub HeaderFunction($) $tab_depth++; my $needed = 0; - if (HeaderFunctionInOut_needed($fn->{ORIGINAL}, "in") or - HeaderFunctionInOut_needed($fn->{ORIGINAL}, "inout")) { + if (HeaderFunctionInOut_needed($fn, "in") or + HeaderFunctionInOut_needed($fn, "inout")) { pidl tabs()."struct {\n"; $tab_depth++; - HeaderFunctionInOut($fn->{ORIGINAL}, "in"); - HeaderFunctionInOut($fn->{ORIGINAL}, "inout"); + HeaderFunctionInOut($fn, "in"); + HeaderFunctionInOut($fn, "inout"); $tab_depth--; pidl tabs()."} in;\n\n"; $needed++; } - if (HeaderFunctionInOut_needed($fn->{ORIGINAL}, "out") or - HeaderFunctionInOut_needed($fn->{ORIGINAL}, "inout")) { + if (HeaderFunctionInOut_needed($fn, "out") or + HeaderFunctionInOut_needed($fn, "inout")) { pidl tabs()."struct {\n"; $tab_depth++; - HeaderFunctionInOut($fn->{ORIGINAL}, "out"); - HeaderFunctionInOut($fn->{ORIGINAL}, "inout"); + HeaderFunctionInOut($fn, "out"); + HeaderFunctionInOut($fn, "inout"); if (defined($fn->{RETURN_TYPE})) { pidl tabs().mapTypeName($fn->{RETURN_TYPE}) . " result;\n"; } -- cgit From 3d753b59a95fdb04c26e349c93fddab485beab0f Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 08:05:57 +0000 Subject: r24507: pass $d down to HeaderTypedef metze (This used to be commit 0edec25af84744074aeeb5f8f7b61a6c78ef35b7) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index e10f647635..76034109b7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -223,7 +223,7 @@ sub HeaderType($$$) sub HeaderTypedef($) { my($typedef) = shift; - HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); + HeaderType($typedef, $typedef->{DATA}->{ORIGINAL}, $typedef->{NAME}); } ##################################################################### @@ -360,7 +360,7 @@ sub HeaderInterface($) } foreach my $d (@{$interface->{TYPES}}) { - HeaderTypedef($d->{ORIGINAL}) if ($d->{TYPE} eq "TYPEDEF"); + HeaderTypedef($d) if ($d->{TYPE} eq "TYPEDEF"); HeaderStruct($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "STRUCT"); HeaderUnion($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "UNION"); HeaderEnum($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "ENUM"); -- cgit From de512e88a905a7075e876127c252c010319d47d3 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 08:47:38 +0000 Subject: r24508: add HeaderTypeNew() which will go if everything is converted metze (This used to be commit 0eba05b6a67eb5b119e9054af3fe9db855cb9fbe) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 76034109b7..d7cfdd8e9f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -217,13 +217,30 @@ sub HeaderType($$$) pidl mapTypeName($e->{TYPE}); } } +sub HeaderTypeNew($$$) +{ + my($e,$data,$name) = @_; + if (ref($data) eq "HASH") { + ($data->{TYPE} eq "ENUM") && HeaderEnum($data->{ORIGINAL}, $name); + ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data->{ORIGINAL}, $name); + ($data->{TYPE} eq "STRUCT") && HeaderStruct($data->{ORIGINAL}, $name); + ($data->{TYPE} eq "UNION") && HeaderUnion($data->{ORIGINAL}, $name); + return; + } + + if (has_property($e, "charset")) { + pidl "const char"; + } else { + pidl mapTypeName($e->{TYPE}); + } +} ##################################################################### # parse a typedef sub HeaderTypedef($) { my($typedef) = shift; - HeaderType($typedef, $typedef->{DATA}->{ORIGINAL}, $typedef->{NAME}); + HeaderTypeNew($typedef, $typedef->{DATA}, $typedef->{NAME}); } ##################################################################### -- cgit From 1aa024dfbb1912054571de04e31cf0be7b1d2a27 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 09:01:19 +0000 Subject: r24509: pass down the full ndr elements instead of the old pidl elements from ->{ORIGINAL} metze (This used to be commit e8ebee2698d7d91d8cf25b3017f3414578607ff5) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 103 ++++++++++++--------------- 1 file changed, 46 insertions(+), 57 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index d7cfdd8e9f..bcf3693573 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -63,11 +63,11 @@ sub HeaderElement($) HeaderType($element, $element->{TYPE}, ""); } pidl " "; - my $numstar = $element->{POINTERS}; + my $numstar = $element->{ORIGINAL}->{POINTERS}; if ($numstar >= 1) { $numstar-- if (scalar_is_reference($element->{TYPE})); } - foreach (@{$element->{ARRAY_LEN}}) + foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) { next if is_constant($_) and not has_property($element, "charset"); @@ -76,7 +76,7 @@ sub HeaderElement($) pidl "*" foreach (1..$numstar); } pidl $element->{NAME}; - foreach (@{$element->{ARRAY_LEN}}) { + foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) { next unless (is_constant($_) and not has_property($element, "charset")); pidl "[$_]"; @@ -124,11 +124,13 @@ sub HeaderEnum($$) pidl "#ifndef USE_UINT_ENUMS\n"; pidl "enum $name {\n"; $tab_depth++; - foreach my $e (@{$enum->{ELEMENTS}}) { - unless ($first) { pidl ",\n"; } - $first = 0; - pidl tabs(); - pidl $e; + if (defined($enum->{ELEMENTS})) { + foreach my $e (@{$enum->{ELEMENTS}}) { + unless ($first) { pidl ",\n"; } + $first = 0; + pidl tabs(); + pidl $e; + } } pidl "\n"; $tab_depth--; @@ -138,24 +140,26 @@ sub HeaderEnum($$) pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF}\n"; my $with_val = 0; my $without_val = 0; - foreach my $e (@{$enum->{ELEMENTS}}) { - my $t = "$e"; - my $name; - my $value; - if ($t =~ /(.*)=(.*)/) { - $name = $1; - $value = $2; - $with_val = 1; - die ("you can't mix enum member with values and without values when using --uint-enums!") - unless ($without_val == 0); - } else { - $name = $t; - $value = $count++; - $without_val = 1; - die ("you can't mix enum member with values and without values when using --uint-enums!") - unless ($with_val == 0); + if (defined($enum->{ELEMENTS})) { + foreach my $e (@{$enum->{ELEMENTS}}) { + my $t = "$e"; + my $name; + my $value; + if ($t =~ /(.*)=(.*)/) { + $name = $1; + $value = $2; + $with_val = 1; + die ("you can't mix enum member with values and without values!") + unless ($without_val == 0); + } else { + $name = $t; + $value = $count++; + $without_val = 1; + die ("you can't mix enum member with values and without values!") + unless ($with_val == 0); + } + pidl "#define $name ( $value )\n"; } - pidl "#define $name ( $value )\n"; } pidl "#endif\n"; } @@ -166,6 +170,8 @@ sub HeaderBitmap($$) { my($bitmap,$name) = @_; + return unless defined($bitmap->{ELEMENTS}); + pidl "/* bitmap $name */\n"; pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}}); pidl "\n"; @@ -217,30 +223,13 @@ sub HeaderType($$$) pidl mapTypeName($e->{TYPE}); } } -sub HeaderTypeNew($$$) -{ - my($e,$data,$name) = @_; - if (ref($data) eq "HASH") { - ($data->{TYPE} eq "ENUM") && HeaderEnum($data->{ORIGINAL}, $name); - ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data->{ORIGINAL}, $name); - ($data->{TYPE} eq "STRUCT") && HeaderStruct($data->{ORIGINAL}, $name); - ($data->{TYPE} eq "UNION") && HeaderUnion($data->{ORIGINAL}, $name); - return; - } - - if (has_property($e, "charset")) { - pidl "const char"; - } else { - pidl mapTypeName($e->{TYPE}); - } -} ##################################################################### # parse a typedef sub HeaderTypedef($) { my($typedef) = shift; - HeaderTypeNew($typedef, $typedef->{DATA}, $typedef->{NAME}); + HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); } ##################################################################### @@ -274,7 +263,7 @@ sub HeaderFunctionInOut($$) return unless defined($fn->{ELEMENTS}); foreach my $e (@{$fn->{ELEMENTS}}) { - HeaderElement($e->{ORIGINAL}) if (ElementDirection($e) eq $prop); + HeaderElement($e) if (ElementDirection($e) eq $prop); } } @@ -372,21 +361,21 @@ sub HeaderInterface($) pidl "#ifndef _HEADER_$interface->{NAME}\n"; pidl "#define _HEADER_$interface->{NAME}\n\n"; - foreach my $d (@{$interface->{CONSTS}}) { - HeaderConst($d); + foreach my $c (@{$interface->{CONSTS}}) { + HeaderConst($c); } - foreach my $d (@{$interface->{TYPES}}) { - HeaderTypedef($d) if ($d->{TYPE} eq "TYPEDEF"); - HeaderStruct($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "STRUCT"); - HeaderUnion($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "UNION"); - HeaderEnum($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "ENUM"); - HeaderBitmap($d->{ORIGINAL}, $d->{NAME}) if ($d->{TYPE} eq "BITMAP"); - pidl ";\n\n" if ($d->{TYPE} eq "BITMAP" or - $d->{TYPE} eq "STRUCT" or - $d->{TYPE} eq "TYPEDEF" or - $d->{TYPE} eq "UNION" or - $d->{TYPE} eq "ENUM"); + foreach my $t (@{$interface->{TYPES}}) { + HeaderTypedef($t) if ($t->{TYPE} eq "TYPEDEF"); + HeaderStruct($t, $t->{NAME}) if ($t->{TYPE} eq "STRUCT"); + HeaderUnion($t, $t->{NAME}) if ($t->{TYPE} eq "UNION"); + HeaderEnum($t, $t->{NAME}) if ($t->{TYPE} eq "ENUM"); + HeaderBitmap($t, $t->{NAME}) if ($t->{TYPE} eq "BITMAP"); + pidl ";\n\n" if ($t->{TYPE} eq "BITMAP" or + $t->{TYPE} eq "STRUCT" or + $t->{TYPE} eq "TYPEDEF" or + $t->{TYPE} eq "UNION" or + $t->{TYPE} eq "ENUM"); } foreach my $fn (@{$interface->{FUNCTIONS}}) { -- cgit From a1707f2689448125abbde7efc4c86f5518ebe718 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 09:12:13 +0000 Subject: r24511: pass the correct thing to fatal() metze (This used to be commit 82cc41c5589899552256b06a3b1ae84e24d3b71f) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 42120bec78..3f9d1f0464 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -85,7 +85,7 @@ sub ParseFunction($$$) next unless (grep(/out/, @{$e->{DIRECTION}})); my $level = 0; - fatal($e, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); + fatal($e->{ORIGINAL}, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { $level = 1; -- cgit From 53cdb93fb73b9ac2414286849f696378fd859523 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 11:09:46 +0000 Subject: r24514: IS_* elemements sound be perl integers consistantly... metze (This used to be commit b7d6ac5215c27f7eb4ae16e3a68b7f7fc32dcb72) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index e950591cb7..31b70e5bdc 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -113,6 +113,8 @@ sub GetElementLevelTable($) my $is_varying = 0; my $is_conformant = 0; my $is_string = 0; + my $is_fixed = 0; + my $is_inline = 0; if ($d eq "*") { $is_conformant = 1; @@ -136,17 +138,20 @@ sub GetElementLevelTable($) } } + $is_fixed = 1 if (not $is_conformant and Parse::Pidl::Util::is_constant($size)); + $is_inline = 1 if (not $is_conformant and not Parse::Pidl::Util::is_constant($size)); + push (@$order, { TYPE => "ARRAY", SIZE_IS => $size, LENGTH_IS => $length, - IS_DEFERRED => "$is_deferred", - IS_SURROUNDING => "$is_surrounding", - IS_ZERO_TERMINATED => "$is_string", - IS_VARYING => "$is_varying", - IS_CONFORMANT => "$is_conformant", - IS_FIXED => (not $is_conformant and Parse::Pidl::Util::is_constant($size)), - IS_INLINE => (not $is_conformant and not Parse::Pidl::Util::is_constant($size)) + IS_DEFERRED => $is_deferred, + IS_SURROUNDING => $is_surrounding, + IS_ZERO_TERMINATED => $is_string, + IS_VARYING => $is_varying, + IS_CONFORMANT => $is_conformant, + IS_FIXED => $is_fixed, + IS_INLINE => $is_inline }); } @@ -204,15 +209,15 @@ sub GetElementLevelTable($) if ($array_size or $is_string) { push (@$order, { TYPE => "ARRAY", - IS_ZERO_TERMINATED => "$is_string", SIZE_IS => $array_size, LENGTH_IS => $array_length, - IS_DEFERRED => "$is_deferred", + IS_DEFERRED => $is_deferred, IS_SURROUNDING => 0, - IS_VARYING => "$is_varying", - IS_CONFORMANT => "$is_conformant", + IS_ZERO_TERMINATED => $is_string, + IS_VARYING => $is_varying, + IS_CONFORMANT => $is_conformant, IS_FIXED => 0, - IS_INLINE => 0, + IS_INLINE => 0 }); $is_deferred = 0; -- cgit From 60501f20a72c3c9739184f768899a0132eb765d9 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 11:24:25 +0000 Subject: r24515: use fatal() wrapper instead of die() directly metze (This used to be commit d90a0d3ba1ac18caee08ab3f621b742229a41e45) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index bcf3693573..52263e848a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -7,6 +7,7 @@ package Parse::Pidl::Samba4::Header; use strict; +use Parse::Pidl qw(fatal); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::Samba4 qw(is_intree); @@ -149,13 +150,13 @@ sub HeaderEnum($$) $name = $1; $value = $2; $with_val = 1; - die ("you can't mix enum member with values and without values!") + fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") unless ($without_val == 0); } else { $name = $t; $value = $count++; $without_val = 1; - die ("you can't mix enum member with values and without values!") + fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") unless ($with_val == 0); } pidl "#define $name ( $value )\n"; -- cgit From 70b525a546da5deb8dbc2eff8c5334f9ec57497a Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 12:04:41 +0000 Subject: r24516: don't use ->{ORIGINAL} metze (This used to be commit 98d8753d37e5ac6273316c83bf6f0e6851afd30a) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 52263e848a..f03f7c0c43 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -10,6 +10,7 @@ use strict; use Parse::Pidl qw(fatal); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant); +use Parse::Pidl::NDR qw(GetPrevLevel); use Parse::Pidl::Samba4 qw(is_intree); use vars qw($VERSION); @@ -64,23 +65,30 @@ sub HeaderElement($) HeaderType($element, $element->{TYPE}, ""); } pidl " "; - my $numstar = $element->{ORIGINAL}->{POINTERS}; + my $numstar = 0; + foreach my $l (@{$element->{LEVELS}}) { + next unless ($l->{TYPE} eq "POINTER"); + $numstar++; + } if ($numstar >= 1) { $numstar-- if (scalar_is_reference($element->{TYPE})); } - foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) - { - next if is_constant($_) and + foreach my $l (@{$element->{LEVELS}}) { + next unless ($l->{TYPE} eq "ARRAY"); + next if ($l->{IS_FIXED}) and not has_property($element, "charset"); + my $pl = GetPrevLevel($element, $l); + next if (defined($pl) and $pl->{TYPE} eq "POINTER"); $numstar++; } pidl "*" foreach (1..$numstar); } pidl $element->{NAME}; - foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) { - next unless (is_constant($_) and + foreach my $l (@{$element->{LEVELS}}) { + next unless ($l->{TYPE} eq "ARRAY"); + next unless ($l->{IS_FIXED} and not has_property($element, "charset")); - pidl "[$_]"; + pidl "[$l->{SIZE_IS}]"; } pidl ";"; -- cgit From a9531c0e23b622cb96c6c4a61a0df43d12a3cee8 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 12:55:47 +0000 Subject: r24517: move skipping pointer before an array logic into the pointer loop as we do in other places metze (This used to be commit ee92d47b538e2f92e4c342893f04c598311e1021) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index f03f7c0c43..9d8b521a49 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -10,7 +10,7 @@ use strict; use Parse::Pidl qw(fatal); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant); -use Parse::Pidl::NDR qw(GetPrevLevel); +use Parse::Pidl::NDR qw(GetNextLevel); use Parse::Pidl::Samba4 qw(is_intree); use vars qw($VERSION); @@ -68,6 +68,10 @@ sub HeaderElement($) my $numstar = 0; foreach my $l (@{$element->{LEVELS}}) { next unless ($l->{TYPE} eq "POINTER"); + + my $nl = GetNextLevel($element, $l); + next if (defined($nl) and $nl->{TYPE} eq "ARRAY"); + $numstar++; } if ($numstar >= 1) { @@ -77,8 +81,6 @@ sub HeaderElement($) next unless ($l->{TYPE} eq "ARRAY"); next if ($l->{IS_FIXED}) and not has_property($element, "charset"); - my $pl = GetPrevLevel($element, $l); - next if (defined($pl) and $pl->{TYPE} eq "POINTER"); $numstar++; } pidl "*" foreach (1..$numstar); -- cgit From 3e3e5f85ddb407615e5d6a73fc5ec11acac4108e Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 13:01:51 +0000 Subject: r24518: get rid of using ->{ORIGINAL} and move stuff into subfunctions metze (This used to be commit ff7fa11e70018e9691441d824483b803781943a7) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 95 ++++++++++++++++++++++++++--------- 1 file changed, 70 insertions(+), 25 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index 326ac83751..ebe74d488d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -10,6 +10,7 @@ require Exporter; @EXPORT = qw(is_intree choose_header DeclLong); use Parse::Pidl::Util qw(has_property is_constant); +use Parse::Pidl::NDR qw(GetNextLevel); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use strict; @@ -34,40 +35,84 @@ sub choose_header($$) return "#include <$out>"; } +sub NumStars($;$) +{ + my ($e, $d) = @_; + $d = 0 unless defined($d); + my $n = 0; + + foreach my $l (@{$e->{LEVELS}}) { + next unless ($l->{TYPE} eq "POINTER"); + + my $nl = GetNextLevel($e, $l); + next if (defined($nl) and $nl->{TYPE} eq "ARRAY"); + + $n++; + } + + if ($n >= 1) { + $n-- if (scalar_is_reference($e->{TYPE})); + } + + foreach my $l (@{$e->{LEVELS}}) { + next unless ($l->{TYPE} eq "ARRAY"); + next if ($l->{IS_FIXED}) and not has_property($e, "charset"); + $n++; + } + + fatal($e->{ORIGINAL}, "Too few pointers $n < $d") if ($n < $d); + + $n -= $d; + + return $n; +} + +sub ElementStars($;$) +{ + my ($e, $d) = @_; + my $res = ""; + my $n = 0; + + $n = NumStars($e, $d); + $res .= "*" foreach (1..$n); + + return $res; +} + +sub ArrayBrackets($) +{ + my ($e) = @_; + my $res = ""; + + foreach my $l (@{$e->{LEVELS}}) { + next unless ($l->{TYPE} eq "ARRAY"); + next unless ($l->{IS_FIXED}) and not has_property($e, "charset"); + $res .= "[$l->{SIZE_IS}]"; + } + + return $res; +} + sub DeclLong($) { - my($element) = shift; - my $ret = ""; + my ($e, $d) = shift; + my $res = ""; - if (has_property($element, "represent_as")) { - $ret.=mapTypeName($element->{PROPERTIES}->{represent_as})." "; + if (has_property($e, "represent_as")) { + $res .= mapTypeName($e->{PROPERTIES}->{represent_as})." "; } else { - if (has_property($element, "charset")) { - $ret.="const char"; + if (has_property($e, "charset")) { + $res .= "const char "; } else { - $ret.=mapTypeName($element->{TYPE}); + $res .= mapTypeName($e->{TYPE})." "; } - $ret.=" "; - my $numstar = $element->{ORIGINAL}->{POINTERS}; - if ($numstar >= 1) { - $numstar-- if scalar_is_reference($element->{TYPE}); - } - foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) - { - next if is_constant($_) and - not has_property($element, "charset"); - $numstar++; - } - $ret.="*" foreach (1..$numstar); - } - $ret.=$element->{NAME}; - foreach (@{$element->{ORIGINAL}->{ARRAY_LEN}}) { - next unless (is_constant($_) and not has_property($element, "charset")); - $ret.="[$_]"; + $res .= ElementStars($e); } + $res .= $e->{NAME}; + $res .= ArrayBrackets($e); - return $ret; + return $res; } 1; -- cgit From 95d4e550bd66cefe19396387ad52fb3cec5d0b64 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 13:08:00 +0000 Subject: r24520: make use of the new ElementStars() and ArrayBrackets() functions metze (This used to be commit fad5af2f2069993b7284e74a177b78a4b4798383) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 31 +++------------------------- 2 files changed, 4 insertions(+), 29 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index ebe74d488d..347d288cee 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Samba4; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(is_intree choose_header DeclLong); +@EXPORT = qw(is_intree choose_header NumStars ElementStars ArrayBrackets DeclLong); use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::NDR qw(GetNextLevel); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 9d8b521a49..7deb3ca331 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -10,8 +10,7 @@ use strict; use Parse::Pidl qw(fatal); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant); -use Parse::Pidl::NDR qw(GetNextLevel); -use Parse::Pidl::Samba4 qw(is_intree); +use Parse::Pidl::Samba4 qw(is_intree ElementStars ArrayBrackets); use vars qw($VERSION); $VERSION = '0.01'; @@ -64,34 +63,10 @@ sub HeaderElement($) } else { HeaderType($element, $element->{TYPE}, ""); } - pidl " "; - my $numstar = 0; - foreach my $l (@{$element->{LEVELS}}) { - next unless ($l->{TYPE} eq "POINTER"); - - my $nl = GetNextLevel($element, $l); - next if (defined($nl) and $nl->{TYPE} eq "ARRAY"); - - $numstar++; - } - if ($numstar >= 1) { - $numstar-- if (scalar_is_reference($element->{TYPE})); - } - foreach my $l (@{$element->{LEVELS}}) { - next unless ($l->{TYPE} eq "ARRAY"); - next if ($l->{IS_FIXED}) and - not has_property($element, "charset"); - $numstar++; - } - pidl "*" foreach (1..$numstar); + pidl " ".ElementStars($element); } pidl $element->{NAME}; - foreach my $l (@{$element->{LEVELS}}) { - next unless ($l->{TYPE} eq "ARRAY"); - next unless ($l->{IS_FIXED} and - not has_property($element, "charset")); - pidl "[$l->{SIZE_IS}]"; - } + pidl ArrayBrackets($element); pidl ";"; if (defined $element->{PROPERTIES}) { -- cgit From 25dbce70b74cb6a17a80a0ea0cc0646fca975658 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 13:42:09 +0000 Subject: r24521: we don't yet have optional args to DeclLong() metze (This used to be commit 66d4d6f19643454fb781cebbca2c4f4dbb94e90b) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index 347d288cee..5848543a60 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -95,7 +95,7 @@ sub ArrayBrackets($) sub DeclLong($) { - my ($e, $d) = shift; + my ($e) = shift; my $res = ""; if (has_property($e, "represent_as")) { -- cgit From 456f3b378d79a32b3092a0f8e11c81ed29f89ddd Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 13:45:18 +0000 Subject: r24522: make the "skip pointer to an array" logic a bit easier metze (This used to be commit a698fb18573baf016009bdd2d02aaf336dc92a63) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index d6311ed360..cc5057aef4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -65,18 +65,16 @@ sub AllocOutVar($$$$) my ($e, $mem_ctx, $name, $env) = @_; my $l = $e->{LEVELS}[0]; - my $nl = $l; + # we skip pointer to arrays if ($l->{TYPE} eq "POINTER") { - $nl = GetNextLevel($e, $l); + my $nl = GetNextLevel($e, $l); + $l = $nl if ($nl->{TYPE} eq "ARRAY"); } if ($l->{TYPE} eq "ARRAY") { my $size = ParseExpr($l->{SIZE_IS}, $env, $e); pidl "$name = talloc_zero_array($mem_ctx, " . DeclLevel($e, 1) . ", $size);"; - } elsif ($l->{TYPE} eq "POINTER" and $nl->{TYPE} eq "ARRAY") { - my $size = ParseExpr($nl->{SIZE_IS}, $env, $e); - pidl "$name = talloc_zero_array($mem_ctx, " . DeclLevel($e, 1) . ", $size);"; } else { pidl "$name = talloc_zero($mem_ctx, " . DeclLevel($e, 1) . ");"; } -- cgit From b379e50351c7cd7069ab75115a39749d6eba60ac Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 13:47:03 +0000 Subject: r24523: we don't support multi-dimentional [out] arrays for the samba3 server stubs yet, so bail out. metze (This used to be commit ff11f2ce0c3f9c882d93bda0c89577adaf8c2a41) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index cc5057aef4..a8e7c347b3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -72,6 +72,14 @@ sub AllocOutVar($$$$) $l = $nl if ($nl->{TYPE} eq "ARRAY"); } + # we don't support multi-dimentional arrays yet + if ($l->{TYPE} eq "ARRAY") { + my $nl = GetNextLevel($e, $l); + if ($nl->{TYPE} eq "ARRAY") { + fatal($e->{ORIGINAL},"multi-dimentional [out] arrays are not supported!"); + } + } + if ($l->{TYPE} eq "ARRAY") { my $size = ParseExpr($l->{SIZE_IS}, $env, $e); pidl "$name = talloc_zero_array($mem_ctx, " . DeclLevel($e, 1) . ", $size);"; -- cgit From 75564a9d0ece0c050923339b09457bc3dd1a5f5d Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 17 Aug 2007 13:53:12 +0000 Subject: r24524: make use of ElementStars() metze (This used to be commit 701aa31d14cde412c1fecef694d851882be8d17f) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 32 +++++++------------------ 1 file changed, 8 insertions(+), 24 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index a8e7c347b3..071163c300 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -11,7 +11,7 @@ use Parse::Pidl qw(warning fatal); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(ParseExpr has_property is_constant); use Parse::Pidl::NDR qw(GetNextLevel); -use Parse::Pidl::Samba4 qw(DeclLong); +use Parse::Pidl::Samba4 qw(ElementStars DeclLong); use Parse::Pidl::Samba4::NDR::Parser qw(GenerateFunctionOutEnv); use vars qw($VERSION); @@ -28,36 +28,20 @@ sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } sub DeclLevel($$) { - sub DeclLevel($$); my ($e, $l) = @_; - - my $ret = ""; + my $res = ""; if (has_property($e, "charset")) { - $ret.="const char"; + $res .= "const char"; } else { - $ret.=mapTypeName($e->{TYPE}); + $res .= mapTypeName($e->{TYPE}); } - my $numstar = $e->{ORIGINAL}->{POINTERS}; - if ($numstar >= 1) { - $numstar-- if scalar_is_reference($e->{TYPE}); - } - foreach (@{$e->{ORIGINAL}->{ARRAY_LEN}}) - { - next if is_constant($_) and - not has_property($e, "charset"); - $numstar++; - } - $numstar -= $l; - die ("Too few pointers") if $numstar < 0; - if ($numstar > 0) - { - $ret.=" "; - $ret.="*" foreach (1..$numstar); - } + my $stars = ElementStars($e, $l); + + $res .= " ".$stars unless ($stars eq ""); - return $ret; + return $res; } sub AllocOutVar($$$$) -- cgit From 698e7c5f2ae23656c50b95b5ca7151396d215ffb Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sat, 18 Aug 2007 10:30:40 +0000 Subject: r24535: rename struct dcerpc_interface_call -> struct ndr_interface_call and move it to librpc/ndr/libndr.h metze (This used to be commit abd5551aabae1820baaa52a963e8c7aa9605914e) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 73ff28eed0..51273104aa 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2281,7 +2281,7 @@ sub FunctionTable($$) return if ($#{$interface->{FUNCTIONS}}+1 == 0); return unless defined ($interface->{PROPERTIES}->{uuid}); - $self->pidl("static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {"); + $self->pidl("static const struct ndr_interface_call $interface->{NAME}\_calls[] = {"); foreach my $d (@{$interface->{FUNCTIONS}}) { next if not defined($d->{OPNUM}); $self->pidl("\t{"); -- cgit From 6b62f15ce7ffc6f47bf61a9b87b2b892da3c3f2b Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sat, 18 Aug 2007 12:25:37 +0000 Subject: r24540: rename struct dcerpc_endpoint_list/struct dcerpc_authservice_list into ndr_interface_string_array and move it to libndr.h metze (This used to be commit 473bca74dc9d9dc54a239c9b5d3dc5fcf5a117a9) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 51273104aa..1e701b9a0e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2307,7 +2307,7 @@ sub FunctionTable($$) $self->pidl("};"); $self->pidl(""); - $self->pidl("static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {"); + $self->pidl("static const struct ndr_interface_string_array $interface->{NAME}\_endpoints = {"); $self->pidl("\t.count\t= $endpoint_count,"); $self->pidl("\t.names\t= $interface->{NAME}\_endpoint_strings"); $self->pidl("};"); @@ -2327,7 +2327,7 @@ sub FunctionTable($$) $self->pidl("};"); $self->pidl(""); - $self->pidl("static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {"); + $self->pidl("static const struct ndr_interface_string_array $interface->{NAME}\_authservices = {"); $self->pidl("\t.count\t= $endpoint_count,"); $self->pidl("\t.names\t= $interface->{NAME}\_authservice_strings"); $self->pidl("};"); -- cgit From b8cdadced4d2a26a63b8bbe397c12df949783ed4 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sun, 19 Aug 2007 20:46:45 +0000 Subject: r24551: rename dcerpc_interface_table -> ndr_interface_table rename dcerpc_interface_list -> ndr_interface_list and move them to libndr.h metze (This used to be commit 4adbebef5df2f833d2d4bfcdda72a34179d52f5c) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index 3b12c8f173..bf8ac300ac 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -74,7 +74,7 @@ sub ParseInterface($) $res_hdr .= "#define _HEADER_RPC_$interface->{NAME}\n\n"; if (defined $interface->{PROPERTIES}->{uuid}) { - $res_hdr .= "extern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n"; + $res_hdr .= "extern const struct ndr_interface_table dcerpc_table_$interface->{NAME};\n"; } $res .= "/* $interface->{NAME} - client functions generated by pidl */\n\n"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 1e701b9a0e..91ceed1e62 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2333,7 +2333,7 @@ sub FunctionTable($$) $self->pidl("};"); $self->pidl(""); - $self->pidl("\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {"); + $self->pidl("\nconst struct ndr_interface_table dcerpc_table_$interface->{NAME} = {"); $self->pidl("\t.name\t\t= \"$interface->{NAME}\","); $self->pidl("\t.syntax_id\t= {"); $self->pidl("\t\t" . print_uuid($interface->{UUID}) .","); @@ -2406,7 +2406,7 @@ sub HeaderInterface($$) if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; } $self->pidl_hdr("#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}"); - $self->pidl_hdr("extern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};"); + $self->pidl_hdr("extern const struct ndr_interface_table dcerpc_table_$interface->{NAME};"); $self->pidl_hdr("NTSTATUS dcerpc_server_$interface->{NAME}_init(void);"); } -- cgit From f14bd1a90ab47a418c0ec2492990a417a0bb3bf6 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sun, 19 Aug 2007 21:23:03 +0000 Subject: r24557: rename 'dcerpc_table_' -> 'ndr_table_' metze (This used to be commit 84651aee81aaabbebf52ffc3fbcbabb2eec6eed5) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 18 +++++++++--------- source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 2 +- 5 files changed, 15 insertions(+), 15 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 0473341db3..4f4a49c1d4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -690,7 +690,7 @@ sub EjsFunction($$$) my ($self, $d, $iface) = @_; my $name = $d->{NAME}; my $callnum = uc("DCERPC_$name"); - my $table = "&dcerpc_table_$iface"; + my $table = "&ndr_table_$iface"; $self->pidl("static int ejs_$name(int eid, int argc, struct MprVar **argv)"); $self->pidl("{"); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index bf8ac300ac..97d0e6dccb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -34,7 +34,7 @@ struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ct NDR_PRINT_IN_DEBUG($name, r); } - return dcerpc_ndr_request_send(p, NULL, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, r); + return dcerpc_ndr_request_send(p, NULL, &ndr_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, r); } NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) @@ -74,7 +74,7 @@ sub ParseInterface($) $res_hdr .= "#define _HEADER_RPC_$interface->{NAME}\n\n"; if (defined $interface->{PROPERTIES}->{uuid}) { - $res_hdr .= "extern const struct ndr_interface_table dcerpc_table_$interface->{NAME};\n"; + $res_hdr .= "extern const struct ndr_interface_table ndr_table_$interface->{NAME};\n"; } $res .= "/* $interface->{NAME} - client functions generated by pidl */\n\n"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 91ceed1e62..5916cd1bf0 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2333,7 +2333,7 @@ sub FunctionTable($$) $self->pidl("};"); $self->pidl(""); - $self->pidl("\nconst struct ndr_interface_table dcerpc_table_$interface->{NAME} = {"); + $self->pidl("\nconst struct ndr_interface_table ndr_table_$interface->{NAME} = {"); $self->pidl("\t.name\t\t= \"$interface->{NAME}\","); $self->pidl("\t.syntax_id\t= {"); $self->pidl("\t\t" . print_uuid($interface->{UUID}) .","); @@ -2406,7 +2406,7 @@ sub HeaderInterface($$) if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; } $self->pidl_hdr("#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}"); - $self->pidl_hdr("extern const struct ndr_interface_table dcerpc_table_$interface->{NAME};"); + $self->pidl_hdr("extern const struct ndr_interface_table ndr_table_$interface->{NAME};"); $self->pidl_hdr("NTSTATUS dcerpc_server_$interface->{NAME}_init(void);"); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index bd58342189..269ccdded3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -106,18 +106,18 @@ static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_C dce_call->fault_code = 0; - if (opnum >= dcerpc_table_$name.num_calls) { + if (opnum >= ndr_table_$name.num_calls) { dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; return NT_STATUS_NET_WRITE_FAULT; } - *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size); + *r = talloc_size(mem_ctx, ndr_table_$name.calls[opnum].struct_size); NT_STATUS_HAVE_NO_MEMORY(*r); /* unravel the NDR for the packet */ - status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); + status = ndr_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); if (!NT_STATUS_IS_OK(status)) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + dcerpc_log_packet(&ndr_table_$name, opnum, NDR_IN, &dce_call->pkt.u.request.stub_and_verifier); dce_call->fault_code = DCERPC_FAULT_NDR; return NT_STATUS_NET_WRITE_FAULT; @@ -141,7 +141,7 @@ pidl " } if (dce_call->fault_code != 0) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + dcerpc_log_packet(&ndr_table_$name, opnum, NDR_IN, &dce_call->pkt.u.request.stub_and_verifier); return NT_STATUS_NET_WRITE_FAULT; } @@ -164,7 +164,7 @@ pidl " } if (dce_call->fault_code != 0) { - dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN, + dcerpc_log_packet(&ndr_table_$name, opnum, NDR_IN, &dce_call->pkt.u.request.stub_and_verifier); return NT_STATUS_NET_WRITE_FAULT; } @@ -177,7 +177,7 @@ static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_C NTSTATUS status; uint16_t opnum = dce_call->pkt.u.request.opnum; - status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); + status = ndr_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); if (!NT_STATUS_IS_OK(status)) { dce_call->fault_code = DCERPC_FAULT_NDR; return NT_STATUS_NET_WRITE_FAULT; @@ -213,9 +213,9 @@ static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const str { int i; - for (i=0;icount;i++) { + for (i=0;icount;i++) { NTSTATUS ret; - const char *name = dcerpc_table_$name.endpoints->names[i]; + const char *name = ndr_table_$name.endpoints->names[i]; ret = dcesrv_interface_register(dce_ctx, name, &dcesrv_$name\_interface, NULL); if (!NT_STATUS_IS_OK(ret)) { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm index d541f318ee..df960d8de8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -52,7 +52,7 @@ sub ParseInterface($$) pidl "struct $if->{NAME} *ret = talloc(mem_ctx, struct $if->{NAME});"; pidl "NTSTATUS status;"; pidl ""; - pidl "status = dcerpc_pipe_connect(mem_ctx, &ret->pipe, binding, &dcerpc_table_$if->{NAME}, cred, event);"; + pidl "status = dcerpc_pipe_connect(mem_ctx, &ret->pipe, binding, &ndr_table_$if->{NAME}, cred, event);"; pidl "if (NT_STATUS_IS_ERR(status)) {"; pidl "\tntstatus_exception(status);"; pidl "\treturn NULL;"; -- cgit From 0d7d5a6d492253f184ac58fe45ca22af5a3731de Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sun, 19 Aug 2007 22:09:21 +0000 Subject: r24560: rename some DCERPC_ prefixes into NDR_ metze (This used to be commit f874eca5dab74e930d0ec52abeb06295d2d90476) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 20 ++++++++++---------- 5 files changed, 14 insertions(+), 14 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 3f9d1f0464..b4e635f0db 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -40,7 +40,7 @@ sub ParseFunction($$$) my $inargs = ""; my $defargs = ""; - my $ufn = "DCERPC_".uc($fn->{NAME}); + my $ufn = "NDR_".uc($fn->{NAME}); foreach (@{$fn->{ELEMENTS}}) { $defargs .= ", " . DeclLong($_); diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 071163c300..f7acddc7c4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -199,7 +199,7 @@ sub ParseInterface($) indent; foreach (@{$if->{FUNCTIONS}}) { - pidl "{\"" . uc($_->{NAME}) . "\", DCERPC_" . uc($_->{NAME}) . ", api_$_->{NAME}},"; + pidl "{\"" . uc($_->{NAME}) . "\", NDR_" . uc($_->{NAME}) . ", api_$_->{NAME}},"; } deindent; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 4f4a49c1d4..13e38545a7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -689,7 +689,7 @@ sub EjsFunction($$$) { my ($self, $d, $iface) = @_; my $name = $d->{NAME}; - my $callnum = uc("DCERPC_$name"); + my $callnum = uc("NDR_$name"); my $table = "&ndr_table_$iface"; $self->pidl("static int ejs_$name(int eid, int argc, struct MprVar **argv)"); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index 97d0e6dccb..cf14b645a9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -34,7 +34,7 @@ struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ct NDR_PRINT_IN_DEBUG($name, r); } - return dcerpc_ndr_request_send(p, NULL, &ndr_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, r); + return dcerpc_ndr_request_send(p, NULL, &ndr_table_$interface->{NAME}, NDR_$uname, mem_ctx, r); } NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 5916cd1bf0..7c9e9382af 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2337,9 +2337,9 @@ sub FunctionTable($$) $self->pidl("\t.name\t\t= \"$interface->{NAME}\","); $self->pidl("\t.syntax_id\t= {"); $self->pidl("\t\t" . print_uuid($interface->{UUID}) .","); - $self->pidl("\t\tDCERPC_$uname\_VERSION"); + $self->pidl("\t\tNDR_$uname\_VERSION"); $self->pidl("\t},"); - $self->pidl("\t.helpstring\t= DCERPC_$uname\_HELPSTRING,"); + $self->pidl("\t.helpstring\t= NDR_$uname\_HELPSTRING,"); $self->pidl("\t.num_calls\t= $count,"); $self->pidl("\t.calls\t\t= $interface->{NAME}\_calls,"); $self->pidl("\t.endpoints\t= &$interface->{NAME}\_endpoints,"); @@ -2395,16 +2395,16 @@ sub HeaderInterface($$) if (defined $interface->{PROPERTIES}->{uuid}) { my $name = uc $interface->{NAME}; - $self->pidl_hdr("#define DCERPC_$name\_UUID " . + $self->pidl_hdr("#define NDR_$name\_UUID " . Parse::Pidl::Util::make_str(lc($interface->{PROPERTIES}->{uuid}))); if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; } - $self->pidl_hdr("#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}"); + $self->pidl_hdr("#define NDR_$name\_VERSION $interface->{PROPERTIES}->{version}"); - $self->pidl_hdr("#define DCERPC_$name\_NAME \"$interface->{NAME}\""); + $self->pidl_hdr("#define NDR_$name\_NAME \"$interface->{NAME}\""); if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; } - $self->pidl_hdr("#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}"); + $self->pidl_hdr("#define NDR_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}"); $self->pidl_hdr("extern const struct ndr_interface_table ndr_table_$interface->{NAME};"); $self->pidl_hdr("NTSTATUS dcerpc_server_$interface->{NAME}_init(void);"); @@ -2417,10 +2417,10 @@ sub HeaderInterface($$) my $val = sprintf("0x%02x", $count); if (defined($interface->{BASE})) { - $val .= " + DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT"; + $val .= " + NDR_" . uc $interface->{BASE} . "_CALL_COUNT"; } - $self->pidl_hdr("#define DCERPC_$u_name ($val)"); + $self->pidl_hdr("#define NDR_$u_name ($val)"); $self->pidl_hdr(""); $count++; @@ -2429,10 +2429,10 @@ sub HeaderInterface($$) my $val = $count; if (defined($interface->{BASE})) { - $val .= " + DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT"; + $val .= " + NDR_" . uc $interface->{BASE} . "_CALL_COUNT"; } - $self->pidl_hdr("#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT ($val)"); + $self->pidl_hdr("#define NDR_" . uc $interface->{NAME} . "_CALL_COUNT ($val)"); } -- cgit From 97a118ded314b2f8f7e4a68cb77c41e3668203d0 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sun, 19 Aug 2007 22:23:17 +0000 Subject: r24563: remove unused DCERPC specific stuff from the generated NDR code metze (This used to be commit 2dbf89e22352dcb36c7246671ccc9cd55d9f6a57) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 3 --- 1 file changed, 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 7c9e9382af..166a3a6b59 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2407,7 +2407,6 @@ sub HeaderInterface($$) $self->pidl_hdr("#define NDR_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}"); $self->pidl_hdr("extern const struct ndr_interface_table ndr_table_$interface->{NAME};"); - $self->pidl_hdr("NTSTATUS dcerpc_server_$interface->{NAME}_init(void);"); } foreach (@{$interface->{FUNCTIONS}}) { @@ -2600,8 +2599,6 @@ sub GenerateIncludes($) if (is_intree() != 3) { $self->pidl(choose_header("libcli/util/nterr.h", "core/nterr.h")); $self->pidl(choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h")); - $self->pidl(choose_header("librpc/gen_ndr/ndr_dcerpc.h", "gen_ndr/ndr_dcerpc.h")); - $self->pidl(choose_header("librpc/rpc/dcerpc.h", "dcerpc.h")); #FIXME: This shouldn't be here! } } -- cgit From 02467edf5cc3dbaac8bec15deff4fb606ab76f75 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 21 Aug 2007 12:19:56 +0000 Subject: r24592: pass down the ndr_interface_table in the samba3 client bindings instead of the pull and push functions metze (This used to be commit 9b59534a14700f7bfe56cae448030df59ced0ba5) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index b4e635f0db..9c3f01ad93 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -36,10 +36,11 @@ sub new($) sub ParseFunction($$$) { - my ($self, $uif, $fn) = @_; + my ($self, $if, $fn) = @_; my $inargs = ""; my $defargs = ""; + my $uif = uc($if); my $ufn = "NDR_".uc($fn->{NAME}); foreach (@{$fn->{ELEMENTS}}) { @@ -63,7 +64,7 @@ sub ParseFunction($$$) $self->pidl("if (DEBUGLEVEL >= 10)"); $self->pidl("\tNDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"); $self->pidl(""); - $self->pidl("status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, $ufn, &r, (ndr_pull_flags_fn_t)ndr_pull_$fn->{NAME}, (ndr_push_flags_fn_t)ndr_push_$fn->{NAME});"); + $self->pidl("status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, &ndr_table_$if, $ufn, &r);"); $self->pidl(""); $self->pidl("if (!NT_STATUS_IS_OK(status)) {"); @@ -141,7 +142,7 @@ sub ParseInterface($$) $self->pidl_hdr("#ifndef __CLI_$uif\__"); $self->pidl_hdr("#define __CLI_$uif\__"); - $self->ParseFunction(uc($if->{NAME}), $_) foreach (@{$if->{FUNCTIONS}}); + $self->ParseFunction($if->{NAME}, $_) foreach (@{$if->{FUNCTIONS}}); $self->pidl_hdr("#endif /* __CLI_$uif\__ */"); } -- cgit From edb4fefeb74cd7a2390cbf962048c320d21b7d8c Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 21 Aug 2007 14:06:33 +0000 Subject: r24596: - talloc request structure for the samba3 server bindings and make that the primary context for the request which the implementations can also use. - go via functions pointers in the ndr_interface_table instead of calling functions directly. metze (This used to be commit fa577a12940d2df9d5ea9e3e0fed40021d59647d) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 57 ++++++++++++++----------- 1 file changed, 33 insertions(+), 24 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index f7acddc7c4..b3aa98ee0a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -72,7 +72,7 @@ sub AllocOutVar($$$$) } pidl "if ($name == NULL) {"; - pidl "\ttalloc_free(mem_ctx);"; + pidl "\ttalloc_free($mem_ctx);"; pidl "\treturn False;"; pidl "}"; pidl ""; @@ -82,62 +82,71 @@ sub ParseFunction($$) { my ($if,$fn) = @_; + my $op = "NDR_".uc($fn->{NAME}); + pidl "static BOOL api_$fn->{NAME}(pipes_struct *p)"; pidl "{"; indent; + pidl "const struct ndr_interface_call *call;"; pidl "struct ndr_pull *pull;"; pidl "struct ndr_push *push;"; pidl "NTSTATUS status;"; pidl "DATA_BLOB blob;"; - pidl "struct $fn->{NAME} r;"; - pidl "TALLOC_CTX *mem_ctx = talloc_init(\"api_$fn->{NAME}\");"; + pidl "struct $fn->{NAME} *r;"; + pidl ""; + pidl "call = &ndr_table_$if->{NAME}.calls[$op];"; + pidl ""; + pidl "r = talloc(NULL, struct $fn->{NAME});"; + pidl "if (r == NULL) {"; + pidl "\treturn False;"; + pidl "}"; pidl ""; - pidl "if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {"; - pidl "\ttalloc_free(mem_ctx);"; + pidl "if (!prs_data_blob(&p->in_data.data, &blob, r)) {"; + pidl "\ttalloc_free(r);"; pidl "\treturn False;"; pidl "}"; pidl ""; - pidl "pull = ndr_pull_init_blob(&blob, mem_ctx);"; + pidl "pull = ndr_pull_init_blob(&blob, r);"; pidl "if (pull == NULL) {"; - pidl "\ttalloc_free(mem_ctx);"; + pidl "\ttalloc_free(r);"; pidl "\treturn False;"; pidl "}"; pidl ""; pidl "pull->flags |= LIBNDR_FLAG_REF_ALLOC;"; - pidl "status = ndr_pull_$fn->{NAME}(pull, NDR_IN, &r);"; + pidl "status = call->ndr_pull(pull, NDR_IN, r);"; pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\ttalloc_free(mem_ctx);"; + pidl "\ttalloc_free(r);"; pidl "\treturn False;"; pidl "}"; pidl ""; pidl "if (DEBUGLEVEL >= 10)"; - pidl "\tNDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"; + pidl "\tNDR_PRINT_IN_DEBUG($fn->{NAME}, r);"; pidl ""; - my $env = GenerateFunctionOutEnv($fn, "r."); + my $env = GenerateFunctionOutEnv($fn); my $hasout = 0; foreach (@{$fn->{ELEMENTS}}) { if (grep(/out/, @{$_->{DIRECTION}})) { $hasout = 1; } } - pidl "ZERO_STRUCT(r.out);" if ($hasout); + pidl "ZERO_STRUCT(r->out);" if ($hasout); my $proto = "_$fn->{NAME}(pipes_struct *p, struct $fn->{NAME} *r"; - my $ret = "_$fn->{NAME}(p, &r"; + my $ret = "_$fn->{NAME}(p, r"; foreach (@{$fn->{ELEMENTS}}) { my @dir = @{$_->{DIRECTION}}; if (grep(/in/, @dir) and grep(/out/, @dir)) { - pidl "r.out.$_->{NAME} = r.in.$_->{NAME};"; + pidl "r->out.$_->{NAME} = r->in.$_->{NAME};"; } elsif (grep(/out/, @dir) and not has_property($_, "represent_as")) { - AllocOutVar($_, "mem_ctx", "r.out.$_->{NAME}", $env); + AllocOutVar($_, "r", "r->out.$_->{NAME}", $env); } } $ret .= ")"; $proto .= ");"; if ($fn->{RETURN_TYPE}) { - $ret = "r.out.result = $ret"; + $ret = "r->out.result = $ret"; $proto = "$fn->{RETURN_TYPE} $proto"; } else { $proto = "void $proto"; @@ -148,33 +157,33 @@ sub ParseFunction($$) pidl ""; pidl "if (p->rng_fault_state) {"; - pidl "\ttalloc_free(mem_ctx);"; + pidl "\ttalloc_free(r);"; pidl "\t/* Return True here, srv_pipe_hnd.c will take care */"; pidl "\treturn True;"; pidl "}"; pidl ""; pidl "if (DEBUGLEVEL >= 10)"; - pidl "\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);"; + pidl "\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, r);"; pidl ""; - pidl "push = ndr_push_init_ctx(mem_ctx);"; + pidl "push = ndr_push_init_ctx(r);"; pidl "if (push == NULL) {"; - pidl "\ttalloc_free(mem_ctx);"; + pidl "\ttalloc_free(r);"; pidl "\treturn False;"; pidl "}"; pidl ""; - pidl "status = ndr_push_$fn->{NAME}(push, NDR_OUT, &r);"; + pidl "status = call->ndr_push(push, NDR_OUT, r);"; pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\ttalloc_free(mem_ctx);"; + pidl "\ttalloc_free(r);"; pidl "\treturn False;"; pidl "}"; pidl ""; pidl "blob = ndr_push_blob(push);"; pidl "if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {"; - pidl "\ttalloc_free(mem_ctx);"; + pidl "\ttalloc_free(r);"; pidl "\treturn False;"; pidl "}"; pidl ""; - pidl "talloc_free(mem_ctx);"; + pidl "talloc_free(r);"; pidl ""; pidl "return True;"; deindent; -- cgit From ed8d04ead92839d54ca67f55a8e2be9723dc6b0d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 27 Aug 2007 18:43:18 +0000 Subject: r24717: Some more easy bool conversions, update TODO for registry (This used to be commit fc8771fb6aab815e63334da0159032f7ecd0a931) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index 269ccdded3..f5ff15dabf 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -227,7 +227,7 @@ static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const str return NT_STATUS_OK; } -static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version) +static bool $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version) { if (dcesrv_$name\_interface.syntax_id.if_version == if_version && GUID_equal(\&dcesrv\_$name\_interface.syntax_id.uuid, uuid)) { @@ -238,7 +238,7 @@ static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const s return False; } -static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) +static bool $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) { if (strcmp(dcesrv_$name\_interface.name, name)==0) { memcpy(iface, &dcesrv_$name\_interface, sizeof(*iface)); -- cgit From 7f0f39aa230489977655f8ad6999942788a473b4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 27 Aug 2007 19:47:23 +0000 Subject: r24721: Avoid True and False because they are only available within Samba. (This used to be commit 2d049c8d30876075b03ff74f7ba6d0c57bfb5c45) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 166a3a6b59..9a29b72c1d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2290,11 +2290,11 @@ sub FunctionTable($$) $self->pidl("\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},"); $self->pidl("\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},"); $self->pidl("\t\t(ndr_print_function_t) ndr_print_$d->{NAME},"); - $self->pidl("\t\t".($d->{ASYNC}?"True":"False").","); + $self->pidl("\t\t".($d->{ASYNC}?"true":"false").","); $self->pidl("\t},"); $count++; } - $self->pidl("\t{ NULL, 0, NULL, NULL, NULL, False }"); + $self->pidl("\t{ NULL, 0, NULL, NULL, NULL, false }"); $self->pidl("};"); $self->pidl(""); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index f5ff15dabf..b6980acc0f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -232,20 +232,20 @@ static bool $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const s if (dcesrv_$name\_interface.syntax_id.if_version == if_version && GUID_equal(\&dcesrv\_$name\_interface.syntax_id.uuid, uuid)) { memcpy(iface,&dcesrv\_$name\_interface, sizeof(*iface)); - return True; + return true; } - return False; + return false; } static bool $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name) { if (strcmp(dcesrv_$name\_interface.name, name)==0) { memcpy(iface, &dcesrv_$name\_interface, sizeof(*iface)); - return True; + return true; } - return False; + return false; } NTSTATUS dcerpc_server_$name\_init(void) -- cgit From 09c188e7353a74d05a674935c85e548bd09073ae Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 30 Aug 2007 22:25:59 +0000 Subject: r24812: Fix headers for external users. (This used to be commit ff6684adfd96b59381dd941e54070ab9f8984912) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 7deb3ca331..31145e9fb3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -382,7 +382,7 @@ sub Parse($) %headerstructs = (); pidl "/* header auto-generated by pidl */\n\n"; if (!is_intree()) { - pidl "#include \n"; + pidl "#include \n"; } pidl "#include \n"; pidl "\n"; -- cgit From 7acc0e77a6f6d74d1ccfcf04424a63b224b292a5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 31 Aug 2007 00:03:54 +0000 Subject: r24815: Support cpp_quote(). (This used to be commit 30c1de30bb4ded16e79316c0ab43809e0e19f75d) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 2587 +++++++++++++------------- source4/pidl/lib/Parse/Pidl/NDR.pm | 1 + source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 8 + 3 files changed, 1324 insertions(+), 1272 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index d1bde8483d..e9155e4e00 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -33,18 +33,20 @@ sub new { {#State 1 ACTIONS => { '' => 2, - "importlib" => 3, - "import" => 6, - "include" => 11 + "cpp_quote" => 3, + "importlib" => 4, + "import" => 7, + "include" => 13 }, - DEFAULT => -89, + DEFAULT => -91, GOTOS => { - 'importlib' => 9, - 'interface' => 8, - 'include' => 4, - 'coclass' => 10, - 'import' => 7, - 'property_list' => 5 + 'cpp_quote' => 11, + 'importlib' => 10, + 'interface' => 9, + 'include' => 5, + 'coclass' => 12, + 'import' => 8, + 'property_list' => 6 } }, {#State 2 @@ -52,1718 +54,1742 @@ sub new { }, {#State 3 ACTIONS => { - 'TEXT' => 13 + "(" => 14 + } + }, + {#State 4 + ACTIONS => { + 'TEXT' => 16 }, GOTOS => { - 'commalist' => 12, - 'text' => 14 + 'commalist' => 15, + 'text' => 17 } }, - {#State 4 + {#State 5 DEFAULT => -5 }, - {#State 5 + {#State 6 ACTIONS => { - "coclass" => 15, - "[" => 17, - "interface" => 16 + "coclass" => 18, + "[" => 20, + "interface" => 19 } }, - {#State 6 + {#State 7 ACTIONS => { - 'TEXT' => 13 + 'TEXT' => 16 }, GOTOS => { - 'commalist' => 18, - 'text' => 14 + 'commalist' => 21, + 'text' => 17 } }, - {#State 7 - DEFAULT => -4 - }, {#State 8 - DEFAULT => -2 + DEFAULT => -4 }, {#State 9 - DEFAULT => -6 + DEFAULT => -2 }, {#State 10 - DEFAULT => -3 + DEFAULT => -6 }, {#State 11 - ACTIONS => { - 'TEXT' => 13 - }, - GOTOS => { - 'commalist' => 19, - 'text' => 14 - } + DEFAULT => -7 }, {#State 12 - ACTIONS => { - ";" => 20, - "," => 21 - } + DEFAULT => -3 }, {#State 13 - DEFAULT => -122 - }, - {#State 14 - DEFAULT => -10 - }, - {#State 15 ACTIONS => { - 'IDENTIFIER' => 22 + 'TEXT' => 16 }, GOTOS => { - 'identifier' => 23 + 'commalist' => 22, + 'text' => 17 } }, - {#State 16 + {#State 14 ACTIONS => { - 'IDENTIFIER' => 22 + 'TEXT' => 16 }, GOTOS => { - 'identifier' => 24 + 'text' => 23 } }, - {#State 17 + {#State 15 ACTIONS => { - 'IDENTIFIER' => 22 - }, - GOTOS => { - 'identifier' => 26, - 'property' => 27, - 'properties' => 25 + ";" => 24, + "," => 25 } }, + {#State 16 + DEFAULT => -124 + }, + {#State 17 + DEFAULT => -11 + }, {#State 18 ACTIONS => { - ";" => 28, - "," => 21 + 'IDENTIFIER' => 26 + }, + GOTOS => { + 'identifier' => 27 } }, {#State 19 ACTIONS => { - ";" => 29, - "," => 21 + 'IDENTIFIER' => 26 + }, + GOTOS => { + 'identifier' => 28 } }, {#State 20 - DEFAULT => -9 - }, - {#State 21 ACTIONS => { - 'TEXT' => 13 + 'IDENTIFIER' => 26 }, GOTOS => { - 'text' => 30 + 'identifier' => 30, + 'property' => 31, + 'properties' => 29 + } + }, + {#State 21 + ACTIONS => { + ";" => 32, + "," => 25 } }, {#State 22 - DEFAULT => -118 + ACTIONS => { + ";" => 33, + "," => 25 + } }, {#State 23 ACTIONS => { - "{" => 31 + ")" => 34 } }, {#State 24 - ACTIONS => { - "{" => 32 - } + DEFAULT => -10 }, {#State 25 ACTIONS => { - "," => 33, - "]" => 34 + 'TEXT' => 16 + }, + GOTOS => { + 'text' => 35 } }, {#State 26 - ACTIONS => { - "(" => 35 - }, - DEFAULT => -93 + DEFAULT => -120 }, {#State 27 - DEFAULT => -91 + ACTIONS => { + "{" => 36 + } }, {#State 28 - DEFAULT => -7 + ACTIONS => { + "{" => 37 + } }, {#State 29 - DEFAULT => -8 + ACTIONS => { + "," => 38, + "]" => 39 + } }, {#State 30 - DEFAULT => -11 + ACTIONS => { + "(" => 40 + }, + DEFAULT => -95 }, {#State 31 - DEFAULT => -13, - GOTOS => { - 'interface_names' => 36 - } + DEFAULT => -93 }, {#State 32 - ACTIONS => { - "declare" => 44, - "const" => 48 - }, - DEFAULT => -89, - GOTOS => { - 'typedecl' => 37, - 'function' => 38, - 'definitions' => 40, - 'bitmap' => 39, - 'definition' => 43, - 'property_list' => 42, - 'usertype' => 41, - 'const' => 47, - 'declare' => 46, - 'struct' => 45, - 'typedef' => 50, - 'enum' => 49, - 'union' => 51 - } + DEFAULT => -8 }, {#State 33 - ACTIONS => { - 'IDENTIFIER' => 22 - }, - GOTOS => { - 'identifier' => 26, - 'property' => 52 - } + DEFAULT => -9 }, {#State 34 - DEFAULT => -90 + DEFAULT => -17 }, {#State 35 - ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -99, - GOTOS => { - 'identifier' => 57, - 'text' => 58, - 'listtext' => 54, - 'anytext' => 53, - 'constant' => 55 - } + DEFAULT => -12 }, {#State 36 - ACTIONS => { - "}" => 59, - "interface" => 60 + DEFAULT => -14, + GOTOS => { + 'interface_names' => 41 } }, {#State 37 - DEFAULT => -22 + ACTIONS => { + "declare" => 49, + "const" => 53 + }, + DEFAULT => -91, + GOTOS => { + 'typedecl' => 42, + 'function' => 43, + 'definitions' => 45, + 'bitmap' => 44, + 'definition' => 48, + 'property_list' => 47, + 'usertype' => 46, + 'const' => 52, + 'declare' => 51, + 'struct' => 50, + 'typedef' => 55, + 'enum' => 54, + 'union' => 56 + } }, {#State 38 - DEFAULT => -18 + ACTIONS => { + 'IDENTIFIER' => 26 + }, + GOTOS => { + 'identifier' => 30, + 'property' => 57 + } }, {#State 39 - DEFAULT => -37 + DEFAULT => -92 }, {#State 40 ACTIONS => { - "}" => 61, - "declare" => 44, - "const" => 48 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -89, + DEFAULT => -101, GOTOS => { - 'typedecl' => 37, - 'function' => 38, - 'bitmap' => 39, - 'definition' => 62, - 'property_list' => 42, - 'usertype' => 41, - 'const' => 47, - 'struct' => 45, - 'declare' => 46, - 'typedef' => 50, - 'enum' => 49, - 'union' => 51 + 'identifier' => 62, + 'text' => 63, + 'listtext' => 59, + 'anytext' => 58, + 'constant' => 60 } }, {#State 41 ACTIONS => { - ";" => 63 + "}" => 64, + "interface" => 65 } }, {#State 42 - ACTIONS => { - "typedef" => 64, - 'IDENTIFIER' => 22, - "signed" => 72, - "union" => 65, - "enum" => 74, - "bitmap" => 75, - 'void' => 66, - "unsigned" => 76, - "[" => 17, - "struct" => 71 - }, - GOTOS => { - 'existingtype' => 73, - 'bitmap' => 39, - 'usertype' => 68, - 'property_list' => 67, - 'identifier' => 69, - 'struct' => 45, - 'enum' => 49, - 'type' => 77, - 'union' => 51, - 'sign' => 70 - } + DEFAULT => -24 }, {#State 43 - DEFAULT => -16 + DEFAULT => -20 }, {#State 44 - DEFAULT => -89, - GOTOS => { - 'decl_enum' => 79, - 'decl_bitmap' => 80, - 'decl_type' => 82, - 'decl_union' => 81, - 'property_list' => 78 - } + DEFAULT => -39 }, {#State 45 - DEFAULT => -34 + ACTIONS => { + "}" => 66, + "declare" => 49, + "const" => 53 + }, + DEFAULT => -91, + GOTOS => { + 'typedecl' => 42, + 'function' => 43, + 'bitmap' => 44, + 'definition' => 67, + 'property_list' => 47, + 'usertype' => 46, + 'const' => 52, + 'struct' => 50, + 'declare' => 51, + 'typedef' => 55, + 'enum' => 54, + 'union' => 56 + } }, {#State 46 - DEFAULT => -21 + ACTIONS => { + ";" => 68 + } }, {#State 47 - DEFAULT => -19 - }, - {#State 48 ACTIONS => { - 'IDENTIFIER' => 22 - }, - GOTOS => { - 'identifier' => 83 + "typedef" => 69, + 'IDENTIFIER' => 26, + "signed" => 77, + "union" => 70, + "enum" => 79, + "bitmap" => 80, + 'void' => 71, + "unsigned" => 81, + "[" => 20, + "struct" => 76 + }, + GOTOS => { + 'existingtype' => 78, + 'bitmap' => 44, + 'usertype' => 73, + 'property_list' => 72, + 'identifier' => 74, + 'struct' => 50, + 'enum' => 54, + 'type' => 82, + 'union' => 56, + 'sign' => 75 } }, + {#State 48 + DEFAULT => -18 + }, {#State 49 - DEFAULT => -36 + DEFAULT => -91, + GOTOS => { + 'decl_enum' => 84, + 'decl_bitmap' => 85, + 'decl_type' => 87, + 'decl_union' => 86, + 'property_list' => 83 + } }, {#State 50 - DEFAULT => -20 + DEFAULT => -36 }, {#State 51 - DEFAULT => -35 + DEFAULT => -23 }, {#State 52 - DEFAULT => -92 + DEFAULT => -21 }, {#State 53 ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 + 'IDENTIFIER' => 26 }, - DEFAULT => -95 + GOTOS => { + 'identifier' => 88 + } }, {#State 54 - ACTIONS => { - "," => 99, - ")" => 100 - } + DEFAULT => -38 }, {#State 55 - DEFAULT => -101 + DEFAULT => -22 }, {#State 56 - DEFAULT => -121 + DEFAULT => -37 }, {#State 57 - DEFAULT => -100 + DEFAULT => -94 }, {#State 58 - DEFAULT => -102 + ACTIONS => { + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 + }, + DEFAULT => -97 }, {#State 59 ACTIONS => { - ";" => 101 - }, - DEFAULT => -123, - GOTOS => { - 'optional_semicolon' => 102 + "," => 104, + ")" => 105 } }, {#State 60 - ACTIONS => { - 'IDENTIFIER' => 22 - }, - GOTOS => { - 'identifier' => 103 - } + DEFAULT => -103 }, {#State 61 - ACTIONS => { - ";" => 101 - }, - DEFAULT => -123, - GOTOS => { - 'optional_semicolon' => 104 - } + DEFAULT => -123 }, {#State 62 - DEFAULT => -17 + DEFAULT => -102 }, {#State 63 - DEFAULT => -38 + DEFAULT => -104 }, {#State 64 ACTIONS => { - 'IDENTIFIER' => 22, - "signed" => 72, - 'void' => 66, - "unsigned" => 76 + ";" => 106 }, - DEFAULT => -89, + DEFAULT => -125, GOTOS => { - 'existingtype' => 73, - 'bitmap' => 39, - 'usertype' => 68, - 'property_list' => 67, - 'identifier' => 69, - 'struct' => 45, - 'enum' => 49, - 'type' => 105, - 'union' => 51, - 'sign' => 70 + 'optional_semicolon' => 107 } }, {#State 65 ACTIONS => { - 'IDENTIFIER' => 106 + 'IDENTIFIER' => 26 }, - DEFAULT => -120, GOTOS => { - 'optional_identifier' => 107 + 'identifier' => 108 } }, {#State 66 - DEFAULT => -45 - }, - {#State 67 ACTIONS => { - "union" => 65, - "enum" => 74, - "bitmap" => 75, - "[" => 17, - "struct" => 71 + ";" => 106 + }, + DEFAULT => -125, + GOTOS => { + 'optional_semicolon' => 109 } }, + {#State 67 + DEFAULT => -19 + }, {#State 68 - DEFAULT => -43 + DEFAULT => -40 }, {#State 69 - DEFAULT => -42 - }, - {#State 70 ACTIONS => { - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 26, + "signed" => 77, + 'void' => 71, + "unsigned" => 81 }, + DEFAULT => -91, GOTOS => { - 'identifier' => 108 + 'existingtype' => 78, + 'bitmap' => 44, + 'usertype' => 73, + 'property_list' => 72, + 'identifier' => 74, + 'struct' => 50, + 'enum' => 54, + 'type' => 110, + 'union' => 56, + 'sign' => 75 } }, - {#State 71 + {#State 70 ACTIONS => { - 'IDENTIFIER' => 106 + 'IDENTIFIER' => 111 }, - DEFAULT => -120, + DEFAULT => -122, GOTOS => { - 'optional_identifier' => 109 + 'optional_identifier' => 112 } }, + {#State 71 + DEFAULT => -47 + }, {#State 72 - DEFAULT => -39 + ACTIONS => { + "union" => 70, + "enum" => 79, + "bitmap" => 80, + "[" => 20, + "struct" => 76 + } }, {#State 73 - DEFAULT => -44 + DEFAULT => -45 }, {#State 74 - ACTIONS => { - 'IDENTIFIER' => 106 - }, - DEFAULT => -120, - GOTOS => { - 'optional_identifier' => 110 - } + DEFAULT => -44 }, {#State 75 ACTIONS => { - 'IDENTIFIER' => 106 + 'IDENTIFIER' => 26 }, - DEFAULT => -120, GOTOS => { - 'optional_identifier' => 111 + 'identifier' => 113 } }, {#State 76 - DEFAULT => -40 - }, - {#State 77 ACTIONS => { - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 111 }, + DEFAULT => -122, GOTOS => { - 'identifier' => 112 + 'optional_identifier' => 114 } }, + {#State 77 + DEFAULT => -41 + }, {#State 78 - ACTIONS => { - "union" => 113, - "enum" => 114, - "bitmap" => 115, - "[" => 17 - } + DEFAULT => -46 }, {#State 79 - DEFAULT => -27 + ACTIONS => { + 'IDENTIFIER' => 111 + }, + DEFAULT => -122, + GOTOS => { + 'optional_identifier' => 115 + } }, {#State 80 - DEFAULT => -28 + ACTIONS => { + 'IDENTIFIER' => 111 + }, + DEFAULT => -122, + GOTOS => { + 'optional_identifier' => 116 + } }, {#State 81 - DEFAULT => -29 + DEFAULT => -42 }, {#State 82 ACTIONS => { - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 116 + 'identifier' => 117 } }, {#State 83 - DEFAULT => -78, - GOTOS => { - 'pointers' => 117 + ACTIONS => { + "union" => 118, + "enum" => 119, + "bitmap" => 120, + "[" => 20 } }, {#State 84 - ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -99, - GOTOS => { - 'identifier' => 57, - 'anytext' => 118, - 'text' => 58, - 'constant' => 55 - } + DEFAULT => -29 }, {#State 85 - ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -99, - GOTOS => { - 'identifier' => 57, - 'anytext' => 119, - 'text' => 58, - 'constant' => 55 - } + DEFAULT => -30 }, {#State 86 - ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -99, - GOTOS => { - 'identifier' => 57, - 'anytext' => 120, - 'text' => 58, - 'constant' => 55 - } + DEFAULT => -31 }, {#State 87 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 26 }, - DEFAULT => -99, GOTOS => { - 'identifier' => 57, - 'anytext' => 121, - 'text' => 58, - 'constant' => 55 + 'identifier' => 121 } }, {#State 88 - ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -99, + DEFAULT => -80, GOTOS => { - 'identifier' => 57, - 'anytext' => 122, - 'text' => 58, - 'constant' => 55 + 'pointers' => 122 } }, {#State 89 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, + 'identifier' => 62, 'anytext' => 123, - 'text' => 58, - 'constant' => 55 + 'text' => 63, + 'constant' => 60 } }, {#State 90 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, + 'identifier' => 62, 'anytext' => 124, - 'text' => 58, - 'constant' => 55 + 'text' => 63, + 'constant' => 60 } }, {#State 91 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, + 'identifier' => 62, 'anytext' => 125, - 'text' => 58, - 'constant' => 55, - 'commalisttext' => 126 + 'text' => 63, + 'constant' => 60 } }, {#State 92 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, - 'anytext' => 127, - 'text' => 58, - 'constant' => 55 + 'identifier' => 62, + 'anytext' => 126, + 'text' => 63, + 'constant' => 60 } }, {#State 93 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, - 'anytext' => 128, - 'text' => 58, - 'constant' => 55 + 'identifier' => 62, + 'anytext' => 127, + 'text' => 63, + 'constant' => 60 } }, {#State 94 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, - 'anytext' => 129, - 'text' => 58, - 'constant' => 55 + 'identifier' => 62, + 'anytext' => 128, + 'text' => 63, + 'constant' => 60 } }, {#State 95 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, - 'anytext' => 125, - 'text' => 58, - 'constant' => 55, - 'commalisttext' => 130 + 'identifier' => 62, + 'anytext' => 129, + 'text' => 63, + 'constant' => 60 } }, {#State 96 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, - 'anytext' => 131, - 'text' => 58, - 'constant' => 55 + 'identifier' => 62, + 'anytext' => 130, + 'text' => 63, + 'constant' => 60, + 'commalisttext' => 131 } }, {#State 97 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, + 'identifier' => 62, 'anytext' => 132, - 'text' => 58, - 'constant' => 55 + 'text' => 63, + 'constant' => 60 } }, {#State 98 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, + 'identifier' => 62, 'anytext' => 133, - 'text' => 58, - 'constant' => 55 + 'text' => 63, + 'constant' => 60 } }, {#State 99 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, + 'identifier' => 62, 'anytext' => 134, - 'text' => 58, - 'constant' => 55 + 'text' => 63, + 'constant' => 60 } }, {#State 100 - DEFAULT => -94 - }, - {#State 101 - DEFAULT => -124 + ACTIONS => { + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 62, + 'anytext' => 130, + 'text' => 63, + 'constant' => 60, + 'commalisttext' => 135 + } + }, + {#State 101 + ACTIONS => { + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 62, + 'anytext' => 136, + 'text' => 63, + 'constant' => 60 + } }, {#State 102 - DEFAULT => -12 + ACTIONS => { + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 62, + 'anytext' => 137, + 'text' => 63, + 'constant' => 60 + } }, {#State 103 ACTIONS => { - ";" => 135 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 62, + 'anytext' => 138, + 'text' => 63, + 'constant' => 60 } }, {#State 104 - DEFAULT => -15 - }, - {#State 105 ACTIONS => { - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, + DEFAULT => -101, GOTOS => { - 'identifier' => 136 + 'identifier' => 62, + 'anytext' => 139, + 'text' => 63, + 'constant' => 60 } }, + {#State 105 + DEFAULT => -96 + }, {#State 106 - DEFAULT => -119 + DEFAULT => -126 }, {#State 107 - ACTIONS => { - "{" => 138 - }, - DEFAULT => -74, - GOTOS => { - 'union_body' => 139, - 'opt_union_body' => 137 - } + DEFAULT => -13 }, {#State 108 - DEFAULT => -41 - }, - {#State 109 ACTIONS => { - "{" => 141 - }, - DEFAULT => -64, - GOTOS => { - 'struct_body' => 140, - 'opt_struct_body' => 142 + ";" => 140 } }, + {#State 109 + DEFAULT => -16 + }, {#State 110 ACTIONS => { - "{" => 143 + 'IDENTIFIER' => 26 }, - DEFAULT => -47, GOTOS => { - 'opt_enum_body' => 145, - 'enum_body' => 144 + 'identifier' => 141 } }, {#State 111 - ACTIONS => { - "{" => 147 - }, - DEFAULT => -55, - GOTOS => { - 'bitmap_body' => 148, - 'opt_bitmap_body' => 146 - } + DEFAULT => -121 }, {#State 112 ACTIONS => { - "(" => 149 + "{" => 143 + }, + DEFAULT => -76, + GOTOS => { + 'union_body' => 144, + 'opt_union_body' => 142 } }, {#State 113 - DEFAULT => -32 + DEFAULT => -43 }, {#State 114 - DEFAULT => -30 + ACTIONS => { + "{" => 146 + }, + DEFAULT => -66, + GOTOS => { + 'struct_body' => 145, + 'opt_struct_body' => 147 + } }, {#State 115 - DEFAULT => -31 + ACTIONS => { + "{" => 148 + }, + DEFAULT => -49, + GOTOS => { + 'opt_enum_body' => 150, + 'enum_body' => 149 + } }, {#State 116 ACTIONS => { - ";" => 150 + "{" => 152 + }, + DEFAULT => -57, + GOTOS => { + 'bitmap_body' => 153, + 'opt_bitmap_body' => 151 } }, {#State 117 ACTIONS => { - 'IDENTIFIER' => 22, - "*" => 152 - }, - GOTOS => { - 'identifier' => 151 + "(" => 154 } }, {#State 118 - ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 - }, - DEFAULT => -112 + DEFAULT => -34 }, {#State 119 - ACTIONS => { - ":" => 84, - "<" => 86, - "~" => 87, - "?" => 90, - "{" => 91, - "=" => 94 - }, - DEFAULT => -103 + DEFAULT => -32 }, {#State 120 - ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 - }, - DEFAULT => -107 + DEFAULT => -33 }, {#State 121 ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 - }, - DEFAULT => -115 + ";" => 155 + } }, {#State 122 ACTIONS => { - ":" => 84, - "<" => 86, - "~" => 87, - "?" => 90, - "{" => 91, - "=" => 94 + 'IDENTIFIER' => 26, + "*" => 157 }, - DEFAULT => -114 + GOTOS => { + 'identifier' => 156 + } }, {#State 123 ACTIONS => { - ":" => 84, - "<" => 86, - "~" => 87, - "?" => 90, - "{" => 91, - "=" => 94 + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 }, - DEFAULT => -105 + DEFAULT => -114 }, {#State 124 ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 + ":" => 89, + "<" => 91, + "~" => 92, + "?" => 95, + "{" => 96, + "=" => 99 }, - DEFAULT => -111 + DEFAULT => -105 }, {#State 125 ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 }, - DEFAULT => -97 + DEFAULT => -109 }, {#State 126 ACTIONS => { - "}" => 153, - "," => 154 - } + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 + }, + DEFAULT => -117 }, {#State 127 ACTIONS => { - ":" => 84, - "<" => 86, - "~" => 87, - "?" => 90, - "{" => 91, - "=" => 94 + ":" => 89, + "<" => 91, + "~" => 92, + "?" => 95, + "{" => 96, + "=" => 99 }, - DEFAULT => -109 + DEFAULT => -116 }, {#State 128 ACTIONS => { - ":" => 84, - "<" => 86, - "~" => 87, - "?" => 90, - "{" => 91, - "=" => 94 + ":" => 89, + "<" => 91, + "~" => 92, + "?" => 95, + "{" => 96, + "=" => 99 }, - DEFAULT => -110 + DEFAULT => -107 }, {#State 129 ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 }, DEFAULT => -113 }, {#State 130 ACTIONS => { - "," => 154, - ")" => 155 - } + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 + }, + DEFAULT => -99 }, {#State 131 ACTIONS => { - ":" => 84, - "<" => 86, - "~" => 87, - "?" => 90, - "{" => 91, - "=" => 94 - }, - DEFAULT => -108 + "}" => 158, + "," => 159 + } }, {#State 132 ACTIONS => { - ":" => 84, - "<" => 86, - "~" => 87, - "?" => 90, - "{" => 91, - "=" => 94 + ":" => 89, + "<" => 91, + "~" => 92, + "?" => 95, + "{" => 96, + "=" => 99 }, - DEFAULT => -104 + DEFAULT => -111 }, {#State 133 ACTIONS => { - ":" => 84, - "<" => 86, - "~" => 87, - "?" => 90, - "{" => 91, - "=" => 94 + ":" => 89, + "<" => 91, + "~" => 92, + "?" => 95, + "{" => 96, + "=" => 99 }, - DEFAULT => -106 + DEFAULT => -112 }, {#State 134 ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 }, - DEFAULT => -96 + DEFAULT => -115 }, {#State 135 - DEFAULT => -14 + ACTIONS => { + "," => 159, + ")" => 160 + } }, {#State 136 ACTIONS => { - "[" => 156 + ":" => 89, + "<" => 91, + "~" => 92, + "?" => 95, + "{" => 96, + "=" => 99 }, - DEFAULT => -86, - GOTOS => { - 'array_len' => 157 - } + DEFAULT => -110 }, {#State 137 - DEFAULT => -76 + ACTIONS => { + ":" => 89, + "<" => 91, + "~" => 92, + "?" => 95, + "{" => 96, + "=" => 99 + }, + DEFAULT => -106 }, {#State 138 - DEFAULT => -71, - GOTOS => { - 'union_elements' => 158 - } + ACTIONS => { + ":" => 89, + "<" => 91, + "~" => 92, + "?" => 95, + "{" => 96, + "=" => 99 + }, + DEFAULT => -108 }, {#State 139 - DEFAULT => -75 + ACTIONS => { + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 + }, + DEFAULT => -98 }, {#State 140 - DEFAULT => -65 + DEFAULT => -15 }, {#State 141 - DEFAULT => -80, + ACTIONS => { + "[" => 161 + }, + DEFAULT => -88, GOTOS => { - 'element_list1' => 159 + 'array_len' => 162 } }, {#State 142 - DEFAULT => -66 + DEFAULT => -78 }, {#State 143 - ACTIONS => { - 'IDENTIFIER' => 22 - }, + DEFAULT => -73, GOTOS => { - 'identifier' => 160, - 'enum_element' => 161, - 'enum_elements' => 162 + 'union_elements' => 163 } }, {#State 144 - DEFAULT => -48 + DEFAULT => -77 }, {#State 145 - DEFAULT => -49 + DEFAULT => -67 }, {#State 146 - DEFAULT => -57 + DEFAULT => -82, + GOTOS => { + 'element_list1' => 164 + } }, {#State 147 + DEFAULT => -68 + }, + {#State 148 ACTIONS => { - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 26 }, - DEFAULT => -60, GOTOS => { 'identifier' => 165, - 'bitmap_element' => 164, - 'bitmap_elements' => 163, - 'opt_bitmap_elements' => 166 + 'enum_element' => 166, + 'enum_elements' => 167 } }, - {#State 148 - DEFAULT => -56 - }, {#State 149 - ACTIONS => { - "," => -82, - "void" => 170, - ")" => -82 - }, - DEFAULT => -89, - GOTOS => { - 'base_element' => 167, - 'element_list2' => 169, - 'property_list' => 168 - } + DEFAULT => -50 }, {#State 150 - DEFAULT => -26 + DEFAULT => -51 }, {#State 151 - ACTIONS => { - "[" => 156, - "=" => 172 - }, - GOTOS => { - 'array_len' => 171 - } + DEFAULT => -59 }, {#State 152 - DEFAULT => -79 - }, - {#State 153 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -62, GOTOS => { - 'identifier' => 57, - 'anytext' => 173, - 'text' => 58, - 'constant' => 55 + 'identifier' => 170, + 'bitmap_element' => 169, + 'bitmap_elements' => 168, + 'opt_bitmap_elements' => 171 } }, + {#State 153 + DEFAULT => -58 + }, {#State 154 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + "," => -84, + "void" => 175, + ")" => -84 }, - DEFAULT => -99, + DEFAULT => -91, GOTOS => { - 'identifier' => 57, - 'anytext' => 174, - 'text' => 58, - 'constant' => 55 + 'base_element' => 172, + 'element_list2' => 174, + 'property_list' => 173 } }, {#State 155 - ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -99, - GOTOS => { - 'identifier' => 57, - 'anytext' => 175, - 'text' => 58, - 'constant' => 55 - } + DEFAULT => -28 }, {#State 156 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - "]" => 176, - 'IDENTIFIER' => 22 + "[" => 161, + "=" => 177 }, - DEFAULT => -99, GOTOS => { - 'identifier' => 57, - 'anytext' => 177, - 'text' => 58, - 'constant' => 55 + 'array_len' => 176 } }, {#State 157 - ACTIONS => { - ";" => 178 - } + DEFAULT => -81 }, {#State 158 ACTIONS => { - "}" => 179 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -89, + DEFAULT => -101, GOTOS => { - 'optional_base_element' => 181, - 'property_list' => 180 + 'identifier' => 62, + 'anytext' => 178, + 'text' => 63, + 'constant' => 60 } }, {#State 159 ACTIONS => { - "}" => 182 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -89, + DEFAULT => -101, GOTOS => { - 'base_element' => 183, - 'property_list' => 168 + 'identifier' => 62, + 'anytext' => 179, + 'text' => 63, + 'constant' => 60 } }, {#State 160 ACTIONS => { - "=" => 184 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -52 + DEFAULT => -101, + GOTOS => { + 'identifier' => 62, + 'anytext' => 180, + 'text' => 63, + 'constant' => 60 + } }, {#State 161 - DEFAULT => -50 + ACTIONS => { + 'CONSTANT' => 61, + 'TEXT' => 16, + "]" => 181, + 'IDENTIFIER' => 26 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 62, + 'anytext' => 182, + 'text' => 63, + 'constant' => 60 + } }, {#State 162 ACTIONS => { - "}" => 185, - "," => 186 + ";" => 183 } }, {#State 163 ACTIONS => { - "," => 187 + "}" => 184 }, - DEFAULT => -61 + DEFAULT => -91, + GOTOS => { + 'optional_base_element' => 186, + 'property_list' => 185 + } }, {#State 164 - DEFAULT => -58 + ACTIONS => { + "}" => 187 + }, + DEFAULT => -91, + GOTOS => { + 'base_element' => 188, + 'property_list' => 173 + } }, {#State 165 ACTIONS => { - "=" => 188 - } + "=" => 189 + }, + DEFAULT => -54 }, {#State 166 - ACTIONS => { - "}" => 189 - } + DEFAULT => -52 }, {#State 167 - DEFAULT => -84 + ACTIONS => { + "}" => 190, + "," => 191 + } }, {#State 168 ACTIONS => { - 'IDENTIFIER' => 22, - "signed" => 72, - 'void' => 66, - "unsigned" => 76, - "[" => 17 + "," => 192 }, - DEFAULT => -89, - GOTOS => { - 'existingtype' => 73, - 'bitmap' => 39, - 'usertype' => 68, - 'property_list' => 67, - 'identifier' => 69, - 'struct' => 45, - 'enum' => 49, - 'type' => 190, - 'union' => 51, - 'sign' => 70 - } + DEFAULT => -63 }, {#State 169 - ACTIONS => { - "," => 191, - ")" => 192 - } + DEFAULT => -60 }, {#State 170 - DEFAULT => -83 - }, - {#State 171 ACTIONS => { "=" => 193 } }, - {#State 172 + {#State 171 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -99, - GOTOS => { - 'identifier' => 57, - 'anytext' => 194, - 'text' => 58, - 'constant' => 55 + "}" => 194 } }, + {#State 172 + DEFAULT => -86 + }, {#State 173 ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 + 'IDENTIFIER' => 26, + "signed" => 77, + 'void' => 71, + "unsigned" => 81, + "[" => 20 }, - DEFAULT => -117 + DEFAULT => -91, + GOTOS => { + 'existingtype' => 78, + 'bitmap' => 44, + 'usertype' => 73, + 'property_list' => 72, + 'identifier' => 74, + 'struct' => 50, + 'enum' => 54, + 'type' => 195, + 'union' => 56, + 'sign' => 75 + } }, {#State 174 ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 - }, - DEFAULT => -98 + "," => 196, + ")" => 197 + } }, {#State 175 - ACTIONS => { - ":" => 84, - "<" => 86, - "~" => 87, - "?" => 90, - "{" => 91, - "=" => 94 - }, - DEFAULT => -116 + DEFAULT => -85 }, {#State 176 ACTIONS => { - "[" => 156 - }, - DEFAULT => -86, - GOTOS => { - 'array_len' => 195 + "=" => 198 } }, {#State 177 ACTIONS => { - "-" => 85, - ":" => 84, - "?" => 90, - "<" => 86, - "+" => 88, - "~" => 87, - "&" => 92, - "{" => 91, - "/" => 93, - "=" => 94, - "|" => 96, - "(" => 95, - "*" => 89, - "." => 97, - "]" => 196, - ">" => 98 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 62, + 'anytext' => 199, + 'text' => 63, + 'constant' => 60 } }, {#State 178 - DEFAULT => -33 + ACTIONS => { + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 + }, + DEFAULT => -119 }, {#State 179 - DEFAULT => -73 + ACTIONS => { + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 + }, + DEFAULT => -100 }, {#State 180 ACTIONS => { - "[" => 17 + ":" => 89, + "<" => 91, + "~" => 92, + "?" => 95, + "{" => 96, + "=" => 99 }, - DEFAULT => -89, - GOTOS => { - 'base_or_empty' => 197, - 'base_element' => 198, - 'empty_element' => 199, - 'property_list' => 200 - } + DEFAULT => -118 }, {#State 181 - DEFAULT => -72 + ACTIONS => { + "[" => 161 + }, + DEFAULT => -88, + GOTOS => { + 'array_len' => 200 + } }, {#State 182 - DEFAULT => -63 - }, - {#State 183 ACTIONS => { - ";" => 201 + "-" => 90, + ":" => 89, + "?" => 95, + "<" => 91, + "+" => 93, + "~" => 92, + "&" => 97, + "{" => 96, + "/" => 98, + "=" => 99, + "|" => 101, + "(" => 100, + "*" => 94, + "." => 102, + "]" => 201, + ">" => 103 } }, + {#State 183 + DEFAULT => -35 + }, {#State 184 - ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 - }, - DEFAULT => -99, - GOTOS => { - 'identifier' => 57, - 'anytext' => 202, - 'text' => 58, - 'constant' => 55 - } + DEFAULT => -75 }, {#State 185 - DEFAULT => -46 - }, - {#State 186 ACTIONS => { - 'IDENTIFIER' => 22 + "[" => 20 }, + DEFAULT => -91, GOTOS => { - 'identifier' => 160, - 'enum_element' => 203 + 'base_or_empty' => 202, + 'base_element' => 203, + 'empty_element' => 204, + 'property_list' => 205 } }, + {#State 186 + DEFAULT => -74 + }, {#State 187 + DEFAULT => -65 + }, + {#State 188 ACTIONS => { - 'IDENTIFIER' => 22 - }, - GOTOS => { - 'identifier' => 165, - 'bitmap_element' => 204 + ";" => 206 } }, - {#State 188 + {#State 189 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, - 'anytext' => 205, - 'text' => 58, - 'constant' => 55 + 'identifier' => 62, + 'anytext' => 207, + 'text' => 63, + 'constant' => 60 } }, - {#State 189 - DEFAULT => -54 - }, {#State 190 - DEFAULT => -78, - GOTOS => { - 'pointers' => 206 - } + DEFAULT => -48 }, {#State 191 - DEFAULT => -89, + ACTIONS => { + 'IDENTIFIER' => 26 + }, GOTOS => { - 'base_element' => 207, - 'property_list' => 168 + 'identifier' => 165, + 'enum_element' => 208 } }, {#State 192 ACTIONS => { - ";" => 208 + 'IDENTIFIER' => 26 + }, + GOTOS => { + 'identifier' => 170, + 'bitmap_element' => 209 } }, {#State 193 ACTIONS => { - 'CONSTANT' => 56, - 'TEXT' => 13, - 'IDENTIFIER' => 22 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 }, - DEFAULT => -99, + DEFAULT => -101, GOTOS => { - 'identifier' => 57, - 'anytext' => 209, - 'text' => 58, - 'constant' => 55 + 'identifier' => 62, + 'anytext' => 210, + 'text' => 63, + 'constant' => 60 } }, {#State 194 - ACTIONS => { - "-" => 85, - ":" => 84, - "?" => 90, - "<" => 86, - ";" => 210, - "+" => 88, - "~" => 87, - "&" => 92, - "{" => 91, - "/" => 93, - "=" => 94, - "|" => 96, - "(" => 95, - "*" => 89, - "." => 97, - ">" => 98 - } + DEFAULT => -56 }, {#State 195 - DEFAULT => -87 + DEFAULT => -80, + GOTOS => { + 'pointers' => 211 + } }, {#State 196 - ACTIONS => { - "[" => 156 - }, - DEFAULT => -86, + DEFAULT => -91, GOTOS => { - 'array_len' => 211 + 'base_element' => 212, + 'property_list' => 173 } }, {#State 197 - DEFAULT => -70 + ACTIONS => { + ";" => 213 + } }, {#State 198 ACTIONS => { - ";" => 212 + 'CONSTANT' => 61, + 'TEXT' => 16, + 'IDENTIFIER' => 26 + }, + DEFAULT => -101, + GOTOS => { + 'identifier' => 62, + 'anytext' => 214, + 'text' => 63, + 'constant' => 60 } }, {#State 199 - DEFAULT => -69 + ACTIONS => { + "-" => 90, + ":" => 89, + "?" => 95, + "<" => 91, + ";" => 215, + "+" => 93, + "~" => 92, + "&" => 97, + "{" => 96, + "/" => 98, + "=" => 99, + "|" => 101, + "(" => 100, + "*" => 94, + "." => 102, + ">" => 103 + } }, {#State 200 + DEFAULT => -89 + }, + {#State 201 ACTIONS => { - 'IDENTIFIER' => 22, - "signed" => 72, - ";" => 213, - 'void' => 66, - "unsigned" => 76, - "[" => 17 + "[" => 161 }, - DEFAULT => -89, + DEFAULT => -88, GOTOS => { - 'existingtype' => 73, - 'bitmap' => 39, - 'usertype' => 68, - 'property_list' => 67, - 'identifier' => 69, - 'struct' => 45, - 'enum' => 49, - 'type' => 190, - 'union' => 51, - 'sign' => 70 + 'array_len' => 216 } }, - {#State 201 - DEFAULT => -81 - }, {#State 202 - ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 - }, - DEFAULT => -53 + DEFAULT => -72 }, {#State 203 - DEFAULT => -51 + ACTIONS => { + ";" => 217 + } }, {#State 204 - DEFAULT => -59 + DEFAULT => -71 }, {#State 205 ACTIONS => { - "-" => 85, - ":" => 84, - "<" => 86, - "+" => 88, - "~" => 87, - "*" => 89, - "?" => 90, - "{" => 91, - "&" => 92, - "/" => 93, - "=" => 94, - "(" => 95, - "|" => 96, - "." => 97, - ">" => 98 - }, - DEFAULT => -62 - }, - {#State 206 - ACTIONS => { - 'IDENTIFIER' => 22, - "*" => 152 + 'IDENTIFIER' => 26, + "signed" => 77, + ";" => 218, + 'void' => 71, + "unsigned" => 81, + "[" => 20 }, + DEFAULT => -91, GOTOS => { - 'identifier' => 214 + 'existingtype' => 78, + 'bitmap' => 44, + 'usertype' => 73, + 'property_list' => 72, + 'identifier' => 74, + 'struct' => 50, + 'enum' => 54, + 'type' => 195, + 'union' => 56, + 'sign' => 75 } }, + {#State 206 + DEFAULT => -83 + }, {#State 207 - DEFAULT => -85 + ACTIONS => { + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 + }, + DEFAULT => -55 }, {#State 208 - DEFAULT => -25 + DEFAULT => -53 }, {#State 209 + DEFAULT => -61 + }, + {#State 210 + ACTIONS => { + "-" => 90, + ":" => 89, + "<" => 91, + "+" => 93, + "~" => 92, + "*" => 94, + "?" => 95, + "{" => 96, + "&" => 97, + "/" => 98, + "=" => 99, + "(" => 100, + "|" => 101, + "." => 102, + ">" => 103 + }, + DEFAULT => -64 + }, + {#State 211 + ACTIONS => { + 'IDENTIFIER' => 26, + "*" => 157 + }, + GOTOS => { + 'identifier' => 219 + } + }, + {#State 212 + DEFAULT => -87 + }, + {#State 213 + DEFAULT => -27 + }, + {#State 214 ACTIONS => { - "-" => 85, - ":" => 84, - "?" => 90, - "<" => 86, - ";" => 215, - "+" => 88, - "~" => 87, - "&" => 92, - "{" => 91, - "/" => 93, - "=" => 94, - "|" => 96, - "(" => 95, - "*" => 89, - "." => 97, - ">" => 98 + "-" => 90, + ":" => 89, + "?" => 95, + "<" => 91, + ";" => 220, + "+" => 93, + "~" => 92, + "&" => 97, + "{" => 96, + "/" => 98, + "=" => 99, + "|" => 101, + "(" => 100, + "*" => 94, + "." => 102, + ">" => 103 } }, - {#State 210 - DEFAULT => -23 + {#State 215 + DEFAULT => -25 }, - {#State 211 - DEFAULT => -88 + {#State 216 + DEFAULT => -90 }, - {#State 212 - DEFAULT => -68 + {#State 217 + DEFAULT => -70 }, - {#State 213 - DEFAULT => -67 + {#State 218 + DEFAULT => -69 }, - {#State 214 + {#State 219 ACTIONS => { - "[" => 156 + "[" => 161 }, - DEFAULT => -86, + DEFAULT => -88, GOTOS => { - 'array_len' => 216 + 'array_len' => 221 } }, - {#State 215 - DEFAULT => -24 + {#State 220 + DEFAULT => -26 }, - {#State 216 - DEFAULT => -77 + {#State 221 + DEFAULT => -79 } ], yyrules => @@ -1777,37 +1803,43 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "pidl/idl.yp" +#line 19 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "pidl/idl.yp" +#line 20 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'idl', 2, sub -#line 21 "pidl/idl.yp" +#line 21 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 5 'idl', 2, sub -#line 22 "pidl/idl.yp" +#line 22 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 6 'idl', 2, sub -#line 23 "pidl/idl.yp" +#line 23 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 + 'idl', 2, +sub +#line 24 "idl.yp" +{ push(@{$_[1]}, $_[2]); $_[1] } + ], + [#Rule 8 'import', 3, sub -#line 26 "pidl/idl.yp" +#line 27 "idl.yp" {{ "TYPE" => "IMPORT", "PATHS" => $_[2], @@ -1815,10 +1847,10 @@ sub "LINE" => $_[0]->YYData->{LINE} }} ], - [#Rule 8 + [#Rule 9 'include', 3, sub -#line 33 "pidl/idl.yp" +#line 34 "idl.yp" {{ "TYPE" => "INCLUDE", "PATHS" => $_[2], @@ -1826,10 +1858,10 @@ sub "LINE" => $_[0]->YYData->{LINE} }} ], - [#Rule 9 + [#Rule 10 'importlib', 3, sub -#line 40 "pidl/idl.yp" +#line 41 "idl.yp" {{ "TYPE" => "IMPORTLIB", "PATHS" => $_[2], @@ -1837,22 +1869,22 @@ sub "LINE" => $_[0]->YYData->{LINE} }} ], - [#Rule 10 + [#Rule 11 'commalist', 1, sub -#line 49 "pidl/idl.yp" +#line 50 "idl.yp" { [ $_[1] ] } ], - [#Rule 11 + [#Rule 12 'commalist', 3, sub -#line 50 "pidl/idl.yp" +#line 51 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 12 + [#Rule 13 'coclass', 7, sub -#line 54 "pidl/idl.yp" +#line 55 "idl.yp" {{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -1862,19 +1894,19 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 13 + [#Rule 14 'interface_names', 0, undef ], - [#Rule 14 + [#Rule 15 'interface_names', 4, sub -#line 66 "pidl/idl.yp" +#line 67 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 15 + [#Rule 16 'interface', 7, sub -#line 70 "pidl/idl.yp" +#line 71 "idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -1884,24 +1916,29 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 16 + [#Rule 17 + 'cpp_quote', 4, +sub +#line 82 "idl.yp" +{{ + "TYPE" => "CPP_QUOTE", + "FILE" => $_[0]->YYData->{FILE}, + "LINE" => $_[0]->YYData->{LINE}, + "DATA" => $_[3] + }} + ], + [#Rule 18 'definitions', 1, sub -#line 81 "pidl/idl.yp" +#line 91 "idl.yp" { [ $_[1] ] } ], - [#Rule 17 + [#Rule 19 'definitions', 2, sub -#line 82 "pidl/idl.yp" +#line 92 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 18 - 'definition', 1, undef - ], - [#Rule 19 - 'definition', 1, undef - ], [#Rule 20 'definition', 1, undef ], @@ -1912,9 +1949,15 @@ sub 'definition', 1, undef ], [#Rule 23 + 'definition', 1, undef + ], + [#Rule 24 + 'definition', 1, undef + ], + [#Rule 25 'const', 7, sub -#line 90 "pidl/idl.yp" +#line 100 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1925,10 +1968,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 24 + [#Rule 26 'const', 8, sub -#line 100 "pidl/idl.yp" +#line 110 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1940,10 +1983,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 25 + [#Rule 27 'function', 7, sub -#line 114 "pidl/idl.yp" +#line 124 "idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -1954,10 +1997,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 26 + [#Rule 28 'declare', 4, sub -#line 126 "pidl/idl.yp" +#line 136 "idl.yp" {{ "TYPE" => "DECLARE", "NAME" => $_[3], @@ -1966,46 +2009,46 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 27 + [#Rule 29 'decl_type', 1, undef ], - [#Rule 28 + [#Rule 30 'decl_type', 1, undef ], - [#Rule 29 + [#Rule 31 'decl_type', 1, undef ], - [#Rule 30 + [#Rule 32 'decl_enum', 2, sub -#line 139 "pidl/idl.yp" +#line 149 "idl.yp" {{ "TYPE" => "ENUM", "PROPERTIES" => $_[1] }} ], - [#Rule 31 + [#Rule 33 'decl_bitmap', 2, sub -#line 146 "pidl/idl.yp" +#line 156 "idl.yp" {{ "TYPE" => "BITMAP", "PROPERTIES" => $_[1] }} ], - [#Rule 32 + [#Rule 34 'decl_union', 2, sub -#line 153 "pidl/idl.yp" +#line 163 "idl.yp" {{ "TYPE" => "UNION", "PROPERTIES" => $_[1] }} ], - [#Rule 33 + [#Rule 35 'typedef', 6, sub -#line 160 "pidl/idl.yp" +#line 170 "idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[1], @@ -2016,67 +2059,67 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 34 + [#Rule 36 'usertype', 1, undef ], - [#Rule 35 + [#Rule 37 'usertype', 1, undef ], - [#Rule 36 + [#Rule 38 'usertype', 1, undef ], - [#Rule 37 + [#Rule 39 'usertype', 1, undef ], - [#Rule 38 + [#Rule 40 'typedecl', 2, sub -#line 173 "pidl/idl.yp" +#line 183 "idl.yp" { $_[1] } ], - [#Rule 39 + [#Rule 41 'sign', 1, undef ], - [#Rule 40 + [#Rule 42 'sign', 1, undef ], - [#Rule 41 + [#Rule 43 'existingtype', 2, sub -#line 178 "pidl/idl.yp" +#line 188 "idl.yp" { ($_[1]?$_[1]:"signed") ." $_[2]" } ], - [#Rule 42 + [#Rule 44 'existingtype', 1, undef ], - [#Rule 43 + [#Rule 45 'type', 1, undef ], - [#Rule 44 + [#Rule 46 'type', 1, undef ], - [#Rule 45 + [#Rule 47 'type', 1, sub -#line 182 "pidl/idl.yp" +#line 192 "idl.yp" { "void" } ], - [#Rule 46 + [#Rule 48 'enum_body', 3, sub -#line 184 "pidl/idl.yp" +#line 194 "idl.yp" { $_[2] } ], - [#Rule 47 + [#Rule 49 'opt_enum_body', 0, undef ], - [#Rule 48 + [#Rule 50 'opt_enum_body', 1, undef ], - [#Rule 49 + [#Rule 51 'enum', 4, sub -#line 187 "pidl/idl.yp" +#line 197 "idl.yp" {{ "TYPE" => "ENUM", "PROPERTIES" => $_[1], @@ -2084,43 +2127,43 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 50 + [#Rule 52 'enum_elements', 1, sub -#line 196 "pidl/idl.yp" +#line 206 "idl.yp" { [ $_[1] ] } ], - [#Rule 51 + [#Rule 53 'enum_elements', 3, sub -#line 197 "pidl/idl.yp" +#line 207 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 52 + [#Rule 54 'enum_element', 1, undef ], - [#Rule 53 + [#Rule 55 'enum_element', 3, sub -#line 201 "pidl/idl.yp" +#line 211 "idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 54 + [#Rule 56 'bitmap_body', 3, sub -#line 204 "pidl/idl.yp" +#line 214 "idl.yp" { $_[2] } ], - [#Rule 55 + [#Rule 57 'opt_bitmap_body', 0, undef ], - [#Rule 56 + [#Rule 58 'opt_bitmap_body', 1, undef ], - [#Rule 57 + [#Rule 59 'bitmap', 4, sub -#line 207 "pidl/idl.yp" +#line 217 "idl.yp" {{ "TYPE" => "BITMAP", "PROPERTIES" => $_[1], @@ -2128,46 +2171,46 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 58 + [#Rule 60 'bitmap_elements', 1, sub -#line 216 "pidl/idl.yp" +#line 226 "idl.yp" { [ $_[1] ] } ], - [#Rule 59 + [#Rule 61 'bitmap_elements', 3, sub -#line 217 "pidl/idl.yp" +#line 227 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 60 + [#Rule 62 'opt_bitmap_elements', 0, undef ], - [#Rule 61 + [#Rule 63 'opt_bitmap_elements', 1, undef ], - [#Rule 62 + [#Rule 64 'bitmap_element', 3, sub -#line 222 "pidl/idl.yp" +#line 232 "idl.yp" { "$_[1] ( $_[3] )" } ], - [#Rule 63 + [#Rule 65 'struct_body', 3, sub -#line 225 "pidl/idl.yp" +#line 235 "idl.yp" { $_[2] } ], - [#Rule 64 + [#Rule 66 'opt_struct_body', 0, undef ], - [#Rule 65 + [#Rule 67 'opt_struct_body', 1, undef ], - [#Rule 66 + [#Rule 68 'struct', 4, sub -#line 229 "pidl/idl.yp" +#line 239 "idl.yp" {{ "TYPE" => "STRUCT", "PROPERTIES" => $_[1], @@ -2175,10 +2218,10 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 67 + [#Rule 69 'empty_element', 2, sub -#line 238 "pidl/idl.yp" +#line 248 "idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2189,43 +2232,43 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 68 + [#Rule 70 'base_or_empty', 2, undef ], - [#Rule 69 + [#Rule 71 'base_or_empty', 1, undef ], - [#Rule 70 + [#Rule 72 'optional_base_element', 2, sub -#line 252 "pidl/idl.yp" +#line 262 "idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], - [#Rule 71 + [#Rule 73 'union_elements', 0, undef ], - [#Rule 72 + [#Rule 74 'union_elements', 2, sub -#line 257 "pidl/idl.yp" +#line 267 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 73 + [#Rule 75 'union_body', 3, sub -#line 260 "pidl/idl.yp" +#line 270 "idl.yp" { $_[2] } ], - [#Rule 74 + [#Rule 76 'opt_union_body', 0, undef ], - [#Rule 75 + [#Rule 77 'opt_union_body', 1, undef ], - [#Rule 76 + [#Rule 78 'union', 4, sub -#line 264 "pidl/idl.yp" +#line 274 "idl.yp" {{ "TYPE" => "UNION", "PROPERTIES" => $_[1], @@ -2233,10 +2276,10 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 77 + [#Rule 79 'base_element', 5, sub -#line 273 "pidl/idl.yp" +#line 283 "idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2247,241 +2290,241 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 78 + [#Rule 80 'pointers', 0, sub -#line 287 "pidl/idl.yp" +#line 297 "idl.yp" { 0 } ], - [#Rule 79 + [#Rule 81 'pointers', 2, sub -#line 288 "pidl/idl.yp" +#line 298 "idl.yp" { $_[1]+1 } ], - [#Rule 80 + [#Rule 82 'element_list1', 0, sub -#line 292 "pidl/idl.yp" +#line 302 "idl.yp" { [] } ], - [#Rule 81 + [#Rule 83 'element_list1', 3, sub -#line 293 "pidl/idl.yp" +#line 303 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 82 + [#Rule 84 'element_list2', 0, undef ], - [#Rule 83 + [#Rule 85 'element_list2', 1, undef ], - [#Rule 84 + [#Rule 86 'element_list2', 1, sub -#line 299 "pidl/idl.yp" +#line 309 "idl.yp" { [ $_[1] ] } ], - [#Rule 85 + [#Rule 87 'element_list2', 3, sub -#line 300 "pidl/idl.yp" +#line 310 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 86 + [#Rule 88 'array_len', 0, undef ], - [#Rule 87 + [#Rule 89 'array_len', 3, sub -#line 305 "pidl/idl.yp" +#line 315 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], - [#Rule 88 + [#Rule 90 'array_len', 4, sub -#line 306 "pidl/idl.yp" +#line 316 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], - [#Rule 89 + [#Rule 91 'property_list', 0, undef ], - [#Rule 90 + [#Rule 92 'property_list', 4, sub -#line 312 "pidl/idl.yp" +#line 322 "idl.yp" { FlattenHash([$_[1],$_[3]]); } ], - [#Rule 91 + [#Rule 93 'properties', 1, sub -#line 315 "pidl/idl.yp" +#line 325 "idl.yp" { $_[1] } ], - [#Rule 92 + [#Rule 94 'properties', 3, sub -#line 316 "pidl/idl.yp" +#line 326 "idl.yp" { FlattenHash([$_[1], $_[3]]); } ], - [#Rule 93 + [#Rule 95 'property', 1, sub -#line 319 "pidl/idl.yp" +#line 329 "idl.yp" {{ "$_[1]" => "1" }} ], - [#Rule 94 + [#Rule 96 'property', 4, sub -#line 320 "pidl/idl.yp" +#line 330 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], - [#Rule 95 + [#Rule 97 'listtext', 1, undef ], - [#Rule 96 + [#Rule 98 'listtext', 3, sub -#line 325 "pidl/idl.yp" +#line 335 "idl.yp" { "$_[1] $_[3]" } ], - [#Rule 97 + [#Rule 99 'commalisttext', 1, undef ], - [#Rule 98 + [#Rule 100 'commalisttext', 3, sub -#line 330 "pidl/idl.yp" +#line 340 "idl.yp" { "$_[1],$_[3]" } ], - [#Rule 99 + [#Rule 101 'anytext', 0, sub -#line 334 "pidl/idl.yp" +#line 344 "idl.yp" { "" } ], - [#Rule 100 - 'anytext', 1, undef - ], - [#Rule 101 - 'anytext', 1, undef - ], [#Rule 102 'anytext', 1, undef ], [#Rule 103 - 'anytext', 3, -sub -#line 336 "pidl/idl.yp" -{ "$_[1]$_[2]$_[3]" } + 'anytext', 1, undef ], [#Rule 104 - 'anytext', 3, -sub -#line 337 "pidl/idl.yp" -{ "$_[1]$_[2]$_[3]" } + 'anytext', 1, undef ], [#Rule 105 'anytext', 3, sub -#line 338 "pidl/idl.yp" +#line 346 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 106 'anytext', 3, sub -#line 339 "pidl/idl.yp" +#line 347 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 340 "pidl/idl.yp" +#line 348 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 'anytext', 3, sub -#line 341 "pidl/idl.yp" +#line 349 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 109 'anytext', 3, sub -#line 342 "pidl/idl.yp" +#line 350 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 110 'anytext', 3, sub -#line 343 "pidl/idl.yp" +#line 351 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 111 'anytext', 3, sub -#line 344 "pidl/idl.yp" +#line 352 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 112 'anytext', 3, sub -#line 345 "pidl/idl.yp" +#line 353 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 113 'anytext', 3, sub -#line 346 "pidl/idl.yp" +#line 354 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 114 'anytext', 3, sub -#line 347 "pidl/idl.yp" +#line 355 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 115 'anytext', 3, sub -#line 348 "pidl/idl.yp" +#line 356 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 116 + 'anytext', 3, +sub +#line 357 "idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 117 + 'anytext', 3, +sub +#line 358 "idl.yp" +{ "$_[1]$_[2]$_[3]" } + ], + [#Rule 118 'anytext', 5, sub -#line 349 "pidl/idl.yp" +#line 359 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 117 + [#Rule 119 'anytext', 5, sub -#line 350 "pidl/idl.yp" +#line 360 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 118 + [#Rule 120 'identifier', 1, undef ], - [#Rule 119 + [#Rule 121 'optional_identifier', 1, undef ], - [#Rule 120 + [#Rule 122 'optional_identifier', 0, undef ], - [#Rule 121 + [#Rule 123 'constant', 1, undef ], - [#Rule 122 + [#Rule 124 'text', 1, sub -#line 364 "pidl/idl.yp" +#line 374 "idl.yp" { "\"$_[1]\"" } ], - [#Rule 123 + [#Rule 125 'optional_semicolon', 0, undef ], - [#Rule 124 + [#Rule 126 'optional_semicolon', 1, undef ] ], @@ -2489,7 +2532,7 @@ sub bless($self,$class); } -#line 375 "pidl/idl.yp" +#line 385 "idl.yp" use Parse::Pidl qw(error); @@ -2584,7 +2627,7 @@ again: if (s/^([\w_]+)//) { $parser->YYData->{LAST_TOKEN} = $1; if ($1 =~ - /^(coclass|interface|const|typedef|declare|union + /^(coclass|interface|const|typedef|declare|union|cpp_quote |struct|enum|bitmap|void|unsigned|signed|import|include |importlib)$/x) { return $1; diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 31b70e5bdc..11fdbb2390 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -715,6 +715,7 @@ sub Parse($) my @ndr = (); foreach (@{$idl}) { + ($_->{TYPE} eq "CPP_QUOTE") && push(@ndr, $_); ($_->{TYPE} eq "INTERFACE") && push(@ndr, ParseInterface($_)); ($_->{TYPE} eq "IMPORT") && push(@ndr, $_); } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 31145e9fb3..40fb1d3579 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -371,6 +371,13 @@ sub HeaderInterface($) pidl "#endif /* _HEADER_$interface->{NAME} */\n"; } +sub HeaderQuote($) +{ + my($quote) = shift; + + pidl $quote->{DATA}; +} + ##################################################################### # parse a parsed IDL into a C header sub Parse($) @@ -388,6 +395,7 @@ sub Parse($) pidl "\n"; foreach (@{$ndr}) { + ($_->{TYPE} eq "CPP_QUOTE") && HeaderQuote($_); ($_->{TYPE} eq "INTERFACE") && HeaderInterface($_); ($_->{TYPE} eq "IMPORT") && HeaderImport(@{$_->{PATHS}}); ($_->{TYPE} eq "INCLUDE") && HeaderInclude(@{$_->{PATHS}}); -- cgit From 8d182d881d189e9855165b3a423f2d545a97fae8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 31 Aug 2007 00:31:32 +0000 Subject: r24816: Move the rest of the contents of core.h to more appropriate places. include/ now only contains build system related headers, all other headers are now near the source code they're related to. (This used to be commit 6890a01dbfc6d8041a88ef5c6be52dfcd046fe80) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 4 ++-- source4/pidl/lib/Parse/Pidl/Util.pm | 15 ++++++++++++++- 2 files changed, 16 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 40fb1d3579..75d4c235cb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -9,7 +9,7 @@ package Parse::Pidl::Samba4::Header; use strict; use Parse::Pidl qw(fatal); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); -use Parse::Pidl::Util qw(has_property is_constant); +use Parse::Pidl::Util qw(has_property is_constant unmake_str); use Parse::Pidl::Samba4 qw(is_intree ElementStars ArrayBrackets); use vars qw($VERSION); @@ -375,7 +375,7 @@ sub HeaderQuote($) { my($quote) = shift; - pidl $quote->{DATA}; + pidl unmake_str($quote->{DATA}) . "\n"; } ##################################################################### diff --git a/source4/pidl/lib/Parse/Pidl/Util.pm b/source4/pidl/lib/Parse/Pidl/Util.pm index 8716094abd..006718d139 100644 --- a/source4/pidl/lib/Parse/Pidl/Util.pm +++ b/source4/pidl/lib/Parse/Pidl/Util.pm @@ -6,7 +6,7 @@ package Parse::Pidl::Util; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(has_property property_matches ParseExpr ParseExprExt is_constant make_str print_uuid MyDumper); +@EXPORT = qw(has_property property_matches ParseExpr ParseExprExt is_constant make_str unmake_str print_uuid MyDumper); use vars qw($VERSION); $VERSION = '0.01'; @@ -104,6 +104,19 @@ sub make_str($) return "\"$str\""; } +=item B +unquote a "" quoted string + +=cut +sub unmake_str($) +{ + my $str = shift; + + $str =~ s/^\"(.*)\"$/$1/; + + return $str; +} + =item B Print C representation of a UUID. -- cgit From 8f3ab786f03e1bb5bf73fe9d7264b1b0bbb90a75 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 6 Sep 2007 13:48:01 +0000 Subject: r24983: setup the correct talloc name for structures used in the generated server stubs metze (This used to be commit 678de9ce6022040403a1afb9157b7ae3af1b027c) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index b6980acc0f..ed17fcc0da 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -111,7 +111,10 @@ static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_C return NT_STATUS_NET_WRITE_FAULT; } - *r = talloc_size(mem_ctx, ndr_table_$name.calls[opnum].struct_size); + *r = talloc_named(mem_ctx, + ndr_table_$name.calls[opnum].struct_size, + \"struct %s\", + ndr_table_$name.calls[opnum].name); NT_STATUS_HAVE_NO_MEMORY(*r); /* unravel the NDR for the packet */ -- cgit From e8712bebae30f4f041643ce36177a321f12c23e5 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 12 Sep 2007 12:31:19 +0000 Subject: r25114: handle structs and unions without typedefs better in can_contain_deffered() jelmer: we need to handle this more genericly, I assume we have a lot of other related bugs metze (This used to be commit 3e0f22c85769cac7a5f439836be7b692259ddd81) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 11fdbb2390..0ec4e6523b 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -288,9 +288,20 @@ sub can_contain_deferred($) return 1 if ($type->{TYPE} eq "DECLARE"); # assume the worst - foreach my $x (@{$type->{DATA}->{ELEMENTS}}) { - return 1 if ($x->{POINTERS}); - return 1 if (can_contain_deferred ($x)); + if ($type->{TYPE} eq "TYPEDEF") { + return 0 unless defined($type->{DATA}->{ELEMENTS}); + + foreach my $x (@{$type->{DATA}->{ELEMENTS}}) { + return 1 if ($x->{POINTERS}); + return 1 if (can_contain_deferred ($x)); + } + } else { + return 0 unless defined($type->{ELEMENTS}); + + foreach my $x (@{$type->{ELEMENTS}}) { + return 1 if ($x->{POINTERS}); + return 1 if (can_contain_deferred ($x)); + } } return 0; -- cgit From d222c5e7ae8b9b422ad551d379636f62e3d2041f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 14 Sep 2007 18:06:51 +0000 Subject: r25166: Simplify can_contain_deferred and add tests for it. (This used to be commit 1afc7dd4d33f05d58121defed88faf8fcee3df8f) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 30 +++++++++++++----------------- 1 file changed, 13 insertions(+), 17 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 0ec4e6523b..033217c8bf 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -35,7 +35,7 @@ use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); -@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType); +@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType can_contain_deferred); use strict; use Parse::Pidl qw(warning fatal); @@ -264,7 +264,7 @@ sub GetElementLevelTable($) TYPE => "DATA", DATA_TYPE => $e->{TYPE}, IS_DEFERRED => $is_deferred, - CONTAINS_DEFERRED => can_contain_deferred($e), + CONTAINS_DEFERRED => can_contain_deferred($e->{TYPE}), IS_SURROUNDING => 0 #FIXME }); @@ -279,29 +279,25 @@ sub GetElementLevelTable($) sub can_contain_deferred($) { sub can_contain_deferred($); - my $e = shift; + my ($type) = @_; + + return 1 unless (hasType($type)); # assume the worst - return 0 if (Parse::Pidl::Typelist::is_scalar($e->{TYPE})); - return 1 unless (hasType($e->{TYPE})); # assume the worst + $type = getType($type); - my $type = getType($e->{TYPE}); + return 0 if (Parse::Pidl::Typelist::is_scalar($type)); return 1 if ($type->{TYPE} eq "DECLARE"); # assume the worst if ($type->{TYPE} eq "TYPEDEF") { - return 0 unless defined($type->{DATA}->{ELEMENTS}); + return can_contain_deferred($type->{DATA}); + } - foreach my $x (@{$type->{DATA}->{ELEMENTS}}) { - return 1 if ($x->{POINTERS}); - return 1 if (can_contain_deferred ($x)); - } - } else { - return 0 unless defined($type->{ELEMENTS}); + return 0 unless defined($type->{ELEMENTS}); - foreach my $x (@{$type->{ELEMENTS}}) { - return 1 if ($x->{POINTERS}); - return 1 if (can_contain_deferred ($x)); - } + foreach my $x (@{$type->{ELEMENTS}}) { + return 1 if ($x->{POINTERS}); + return 1 if (can_contain_deferred ($x)); } return 0; -- cgit From cc17260f5d1fe5f0f3b46514f6e53f2aebd352ab Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 14 Sep 2007 18:26:23 +0000 Subject: r25168: Fix include for gen_ndr/misc.h. Patch by Julien Kerihuel. (This used to be commit 160c0013dc02165ed1787291937b641b6cef5a2b) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 75d4c235cb..071bec297c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -390,6 +390,7 @@ sub Parse($) pidl "/* header auto-generated by pidl */\n\n"; if (!is_intree()) { pidl "#include \n"; + pidl "#include \n"; } pidl "#include \n"; pidl "\n"; -- cgit From 2e3768843ae8a202e0a3a60224f6717fc34499ab Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 15 Sep 2007 23:03:34 +0000 Subject: r25185: Check that can_contain_deferred returns true if one of the members of a type can contain deferred data. (This used to be commit 9e804e0c21f09b699707bb88d534bde55d265087) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 033217c8bf..f624d2bdc0 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -289,15 +289,13 @@ sub can_contain_deferred($) return 1 if ($type->{TYPE} eq "DECLARE"); # assume the worst - if ($type->{TYPE} eq "TYPEDEF") { - return can_contain_deferred($type->{DATA}); - } + return can_contain_deferred($type->{DATA}) if ($type->{TYPE} eq "TYPEDEF"); return 0 unless defined($type->{ELEMENTS}); - foreach my $x (@{$type->{ELEMENTS}}) { - return 1 if ($x->{POINTERS}); - return 1 if (can_contain_deferred ($x)); + foreach (@{$type->{ELEMENTS}}) { + return 1 if ($_->{POINTERS}); + return 1 if (can_contain_deferred ($_->{TYPE})); } return 0; -- cgit From 9b009c900987517359485799be8be4167494b376 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 23 Sep 2007 21:35:03 +0000 Subject: r25301: Merge my includes.h cleanups. (This used to be commit 37425495f392a2d0122a93aa2c42758eab7dab5a) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 1 - source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 071bec297c..75d4c235cb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -390,7 +390,6 @@ sub Parse($) pidl "/* header auto-generated by pidl */\n\n"; if (!is_intree()) { pidl "#include \n"; - pidl "#include \n"; } pidl "#include \n"; pidl "\n"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 9a29b72c1d..cd3981bb28 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2597,7 +2597,7 @@ sub GenerateIncludes($) # Samba3 has everything in include/includes.h if (is_intree() != 3) { - $self->pidl(choose_header("libcli/util/nterr.h", "core/nterr.h")); + $self->pidl(choose_header("libcli/util/ntstatus.h", "core/ntstatus.h")); $self->pidl(choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h")); } } -- cgit From 621fcfcd1c8dc4ccbe8f3d58d988b9ce40b3fad3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 1 Oct 2007 21:38:15 +0000 Subject: r25453: Fix include for NTSTATUS. (This used to be commit 3c2d06d8fc8783362a6ff934e86ea4a4da2c6906) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index cf14b645a9..e9c158e933 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -109,7 +109,7 @@ sub Parse($$$$) $res .= "#include \n"; $res .= "#include \n"; $res .= "#include \n"; - $res .= "#include \n"; + $res .= "#include \n"; } $res .= "#include \"$ndr_header\"\n"; $res .= "#include \"$client_header\"\n"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm index 832a2c5463..568dff5adf 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/TDR.pm @@ -265,7 +265,7 @@ sub Parser($$$$) $self->pidl("#include "); $self->pidl("#include "); $self->pidl("#include "); - $self->pidl("#include "); + $self->pidl("#include "); } $self->pidl("#include \"$hdrname\""); $self->pidl(""); -- cgit From fd6288c584085663d16c8dad8eade4b33608ae93 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 2 Oct 2007 04:45:25 +0000 Subject: r25457: use different location for out-of-tree builds (This used to be commit aa089378a04f84c507a7c31f96499a88de963d06) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 75d4c235cb..7a6ffa46d6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -10,7 +10,7 @@ use strict; use Parse::Pidl qw(fatal); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant unmake_str); -use Parse::Pidl::Samba4 qw(is_intree ElementStars ArrayBrackets); +use Parse::Pidl::Samba4 qw(is_intree ElementStars ArrayBrackets choose_header); use vars qw($VERSION); $VERSION = '0.01'; @@ -326,7 +326,7 @@ sub HeaderImport foreach (@imports) { s/\.idl\"$//; s/^\"//; - pidl "#include \"librpc/gen_ndr/$_\.h\"\n"; + pidl choose_header("librpc/gen_ndr/$_\.h", "gen_ndr/$_.h") . "\n"; } } -- cgit From c28074da329d7370e978df65e899c8cf834307eb Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 17 Oct 2007 08:26:55 +0200 Subject: r25674: fix crash bug in pidl generated client code, this could have happend with [in,out,unique] pointers when the clients sends a valid pointer, but the server reponse with a NULL pointer (as samba-3.0.26a do for some calls). I've tested with midl to see how windows handles this situation and also the reverse case where the client sends NULL and the server reposnse with non-NULL. It appears that midl generated code just ignores this and only copies the result if both pointers are non-NULL. metze (This used to be commit 7203f717a676a741e49f96f2d477f4f459575caf) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 9c3f01ad93..f6c9a04a8e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -91,7 +91,7 @@ sub ParseFunction($$$) if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { $level = 1; if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") { - $self->pidl("if ( $e->{NAME} ) {"); + $self->pidl("if ($e->{NAME} && r.out.$e->{NAME}) {"); $self->indent; } } -- cgit From c940bec8d7ba06773c22fa3e73f873360ee23adb Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 19 Oct 2007 00:40:51 +0200 Subject: r25700: Now BOOL no longer exists in Samba 3.2, use bool instead. Jeremy. (This used to be commit ad0b9792f2dc91208a199060585c83ed7f622451) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index b3aa98ee0a..82cadd9bcc 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -84,7 +84,7 @@ sub ParseFunction($$) my $op = "NDR_".uc($fn->{NAME}); - pidl "static BOOL api_$fn->{NAME}(pipes_struct *p)"; + pidl "static bool api_$fn->{NAME}(pipes_struct *p)"; pidl "{"; indent; pidl "const struct ndr_interface_call *call;"; -- cgit From e63df41e743ba9323ad2a563f042d227a0f55b8f Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sat, 27 Oct 2007 09:57:09 +0200 Subject: r25745: [pidl] ndr_pull/push_error(ndr, NDR_ERR_INVALID_POINTER,..) instead NT_STATUS_INVALID_PARAMETER_MIX metze (This used to be commit 76b628df53d6cf028fb9f22df003ac87fe3b3c56) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 33 +++++++++++++++++------- 1 file changed, 24 insertions(+), 9 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index cd3981bb28..002e49c8b1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -423,8 +423,10 @@ sub ParseArrayPullHeader($$$$$$) } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))"; } else { - $length = $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); + $length = $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, + check_null_pointer($e, $env, sub { $self->pidl(shift); }, + "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"), + check_fully_dereferenced($e, $env)); } if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { @@ -447,7 +449,10 @@ sub ParseArrayPullHeader($$$$$$) if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) { $self->defer("if ($var_name) {"); $self->defer_indent; - my $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->defer(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); + my $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, + check_null_pointer($e, $env, sub { $self->defer(shift); }, + "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"), + check_fully_dereferenced($e, $env)); $self->defer("NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"); $self->defer_deindent; $self->defer("}"); @@ -457,7 +462,8 @@ sub ParseArrayPullHeader($$$$$$) $self->defer("if ($var_name) {"); $self->defer_indent; my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, sub { $self->defer(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), + check_null_pointer($e, $env, sub { $self->defer(shift); }, + "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for length_is()\");"), check_fully_dereferenced($e, $env)); $self->defer("NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"); $self->defer_deindent; @@ -740,7 +746,11 @@ sub ParsePtrPush($$$$) my ($self,$e,$l,$var_name) = @_; if ($l->{POINTER_TYPE} eq "ref") { - $self->pidl("if ($var_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;"); + $self->pidl("if ($var_name == NULL) {"); + $self->indent; + $self->pidl("return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL [ref] pointer\");"); + $self->deindent; + $self->pidl("}"); if ($l->{LEVEL} eq "EMBEDDED") { $self->pidl("NDR_CHECK(ndr_push_ref_ptr(ndr));"); } @@ -875,7 +885,9 @@ sub ParseSwitchPull($$$$$$) { my($self,$e,$l,$ndr,$var_name,$env) = @_; my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); + check_null_pointer($e, $env, sub { $self->pidl(shift); }, + "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for switch_is()\");"), + check_fully_dereferenced($e, $env)); $var_name = get_pointer_to($var_name); $self->pidl("NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));"); @@ -887,7 +899,9 @@ sub ParseSwitchPush($$$$$$) { my($self,$e,$l,$ndr,$var_name,$env) = @_; my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, - check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), check_fully_dereferenced($e, $env)); + check_null_pointer($e, $env, sub { $self->pidl(shift); }, + "return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for switch_is()\");"), + check_fully_dereferenced($e, $env)); $var_name = get_pointer_to($var_name); $self->pidl("NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));"); @@ -2222,9 +2236,10 @@ sub ParseFunctionPull($$) and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}); if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { - my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return NT_STATUS_INVALID_PARAMETER_MIX;"), + my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e->{ORIGINAL}, + check_null_pointer($e, $env, sub { $self->pidl(shift); }, + "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"), check_fully_dereferenced($e, $env)); - $self->pidl("NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"); if (grep(/in/, @{$e->{DIRECTION}})) { -- cgit From 0fc96c416ed96cbe060961ea603f93fd4129b3eb Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 30 Oct 2007 06:24:43 +0100 Subject: r25751: use EJS_CHECK() instead of NDR_CHECK() in ejs code metze (This used to be commit 14ca6a8bf90bc73e1fdb0f510be795e28977601e) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 32 +++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 13e38545a7..2e9bc0953c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -128,7 +128,7 @@ sub EjsPullScalar($$$$$$$) } else { $t = $e->{TYPE}; } - $self->pidl("NDR_CHECK(ejs_pull_$t(ejs, v, $name, $var));"); + $self->pidl("EJS_CHECK(ejs_pull_$t(ejs, v, $name, $var));"); } } @@ -164,7 +164,7 @@ sub EjsPullString($$$$$$) if (defined($pl) and $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); } - $self->pidl("NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));"); + $self->pidl("EJS_CHECK(ejs_pull_string(ejs, v, $name, $var));"); } ########################### @@ -255,7 +255,7 @@ sub EjsStructPull($$$) { my ($self, $d, $varname) = @_; my $env = GenerateStructEnv($d, $varname); - $self->pidl("NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"); + $self->pidl("EJS_CHECK(ejs_pull_struct_start(ejs, &v, name));"); foreach my $e (@{$d->{ELEMENTS}}) { $self->EjsPullElementTop($e, $env); } @@ -267,7 +267,7 @@ sub EjsUnionPull($$$) { my ($self, $d, $varname) = @_; my $have_default = 0; - $self->pidl("NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));"); + $self->pidl("EJS_CHECK(ejs_pull_struct_start(ejs, &v, name));"); $self->pidl("switch (ejs->switch_var) {"); $self->indent; foreach my $e (@{$d->{ELEMENTS}}) { @@ -317,7 +317,7 @@ sub EjsEnumPull($$$) my ($self, $d, $varname) = @_; $self->EjsEnumConstant($d); $self->pidl("unsigned e;"); - $self->pidl("NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));"); + $self->pidl("EJS_CHECK(ejs_pull_enum(ejs, v, name, &e));"); $self->pidl("*$varname = e;"); } @@ -327,7 +327,7 @@ sub EjsBitmapPull($$$) { my ($self, $d, $varname) = @_; my $type_fn = $d->{BASE_TYPE}; - $self->pidl("NDR_CHECK(ejs_pull_$type_fn(ejs, v, name, $varname));"); + $self->pidl("EJS_CHECK(ejs_pull_$type_fn(ejs, v, name, $varname));"); } sub EjsTypePullFunction($$$) @@ -388,7 +388,7 @@ sub EjsPullFunction($$) $self->pidl("\nstatic NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, struct $name *r)"); $self->pidl("{"); $self->indent; - $self->pidl("NDR_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));"); + $self->pidl("EJS_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));"); # we pull non-array elements before array elements as arrays # may have length_is() or size_is() properties that depend @@ -427,7 +427,7 @@ sub EjsPushScalar($$$$$$) $var = get_pointer_to($var); } - $self->pidl("NDR_CHECK(".TypeFunctionName("ejs_push", $e->{TYPE})."(ejs, v, $name, $var));"); + $self->pidl("EJS_CHECK(".TypeFunctionName("ejs_push", $e->{TYPE})."(ejs, v, $name, $var));"); } } @@ -440,7 +440,7 @@ sub EjsPushString($$$$$$) if (defined($pl) and $pl->{TYPE} eq "POINTER") { $var = get_pointer_to($var); } - $self->pidl("NDR_CHECK(ejs_push_string(ejs, v, $name, $var));"); + $self->pidl("EJS_CHECK(ejs_push_string(ejs, v, $name, $var));"); } ########################### @@ -453,7 +453,7 @@ sub EjsPushPointer($$$$$$) if ($l->{POINTER_TYPE} eq "ref") { $self->pidl("return NT_STATUS_INVALID_PARAMETER_MIX;"); } else { - $self->pidl("NDR_CHECK(ejs_push_null(ejs, v, $name));"); + $self->pidl("EJS_CHECK(ejs_push_null(ejs, v, $name));"); } $self->deindent; $self->pidl("} else {"); @@ -543,7 +543,7 @@ sub EjsStructPush($$$) { my ($self, $d, $varname) = @_; my $env = GenerateStructEnv($d, $varname); - $self->pidl("NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"); + $self->pidl("EJS_CHECK(ejs_push_struct_start(ejs, &v, name));"); foreach my $e (@{$d->{ELEMENTS}}) { $self->EjsPushElementTop($e, $env); } @@ -555,7 +555,7 @@ sub EjsUnionPush($$$) { my ($self, $d, $varname) = @_; my $have_default = 0; - $self->pidl("NDR_CHECK(ejs_push_struct_start(ejs, &v, name));"); + $self->pidl("EJS_CHECK(ejs_push_struct_start(ejs, &v, name));"); $self->pidl("switch (ejs->switch_var) {"); $self->indent; foreach my $e (@{$d->{ELEMENTS}}) { @@ -587,7 +587,7 @@ sub EjsEnumPush($$$) my ($self, $d, $varname) = @_; $self->EjsEnumConstant($d); $self->pidl("unsigned e = ".get_value_of($varname).";"); - $self->pidl("NDR_CHECK(ejs_push_enum(ejs, v, name, &e));"); + $self->pidl("EJS_CHECK(ejs_push_enum(ejs, v, name, &e));"); } ########################### @@ -604,7 +604,7 @@ sub EjsBitmapPush($$$) $self->{constants}->{$bname} = $v; } } - $self->pidl("NDR_CHECK(ejs_push_$type_fn(ejs, v, name, $varname));"); + $self->pidl("EJS_CHECK(ejs_push_$type_fn(ejs, v, name, $varname));"); } sub EjsTypePushFunction($$$) @@ -667,7 +667,7 @@ sub EjsPushFunction($$) $self->pidl("\nstatic NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const struct $d->{NAME} *r)"); $self->pidl("{"); $self->indent; - $self->pidl("NDR_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));"); + $self->pidl("EJS_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));"); foreach my $e (@{$d->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); @@ -675,7 +675,7 @@ sub EjsPushFunction($$) } if ($d->{RETURN_TYPE}) { - $self->pidl("NDR_CHECK(".TypeFunctionName("ejs_push", $d->{RETURN_TYPE})."(ejs, v, \"result\", &r->out.result));"); + $self->pidl("EJS_CHECK(".TypeFunctionName("ejs_push", $d->{RETURN_TYPE})."(ejs, v, \"result\", &r->out.result));"); } $self->pidl("return NT_STATUS_OK;"); -- cgit From 5dc1f49d5fa78ccf042584c1add9d6094fcaa0b4 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 2 Nov 2007 13:02:25 +0100 Subject: r25804: move including ndr_compression.h into HeaderInterface() metze (This used to be commit 2aecc1e9fd19d4e176f5475c8ee0b292d68c85f9) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 002e49c8b1..7941b65141 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2392,14 +2392,18 @@ sub HeaderInclude # generate prototypes and defines for the interface definitions # FIXME: these prototypes are for the DCE/RPC client functions, not the # NDR parser and so do not belong here, technically speaking -sub HeaderInterface($$) +sub HeaderInterface($$$) { - my($self,$interface) = @_; + my($self,$interface,$needed) = @_; my $count = 0; $self->pidl_hdr(choose_header("librpc/ndr/libndr.h", "ndr.h")); + if ($needed->{"compression"}) { + $self->pidl(choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h")); + } + if (has_property($interface, "object")) { $self->pidl(choose_header("librpc/gen_ndr/ndr_orpc.h", "ndr/orpc.h")); } @@ -2559,11 +2563,7 @@ sub ParseInterface($$$) $self->pidl_hdr(""); - if ($needed->{"compression"}) { - $self->pidl(choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h")); - } - - $self->HeaderInterface($interface); + $self->HeaderInterface($interface, $needed); # Typedefs foreach my $d (@{$interface->{TYPES}}) { -- cgit From b42cc4afd32c524aee18f46d0a779835b98b9457 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 2 Nov 2007 13:05:43 +0100 Subject: r25805: pidl: include libndr.h as first header in ndr_foo.h metze (This used to be commit 18fce1174199d67d822ea92e048443b60dd3dfa5) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 7941b65141..69e5b0d5a1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2398,8 +2398,6 @@ sub HeaderInterface($$$) my $count = 0; - $self->pidl_hdr(choose_header("librpc/ndr/libndr.h", "ndr.h")); - if ($needed->{"compression"}) { $self->pidl(choose_header("librpc/ndr/ndr_compression.h", "ndr/compression.h")); } @@ -2625,6 +2623,7 @@ sub Parse($$$$) $self->pidl_hdr("/* header auto-generated by pidl */"); $self->pidl_hdr(""); + $self->pidl_hdr(choose_header("librpc/ndr/libndr.h", "ndr.h")); $self->pidl_hdr("#include \"$gen_header\"") if ($gen_header); $self->pidl_hdr(""); -- cgit From ecbc2cdd7a2b742515046fa0cdbccec0f4be9a2a Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 2 Nov 2007 13:48:11 +0100 Subject: r25806: let libndr.h include needed stuff and remove pidl magic for choosing common required headers metze (This used to be commit c97fe5b54c0da68c7e71ea79678fa6348ecdaab9) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 6 ------ 1 file changed, 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 69e5b0d5a1..3ad9231740 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2607,12 +2607,6 @@ sub GenerateIncludes($) $self->pidl("#include "); $self->pidl("#include "); } - - # Samba3 has everything in include/includes.h - if (is_intree() != 3) { - $self->pidl(choose_header("libcli/util/ntstatus.h", "core/ntstatus.h")); - $self->pidl(choose_header("librpc/gen_ndr/ndr_misc.h", "gen_ndr/ndr_misc.h")); - } } ##################################################################### -- cgit From 3e1fb13024eec442bfdd0335bc03689f64d50c0e Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 9 Nov 2007 19:23:25 +0100 Subject: r25915: ndr/pidl: change NTSTAUS into enum ndr_err_code (pidl code) Samba4/NDR/Parser.pm Samba4/NDR/Server.pm Samba3/ServerNDR.pm tests/ metze (This used to be commit 7106f21de8dfc472aa0846b49bfdb7543c63b310) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 10 +++++----- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 16 ++++++++-------- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm | 12 ++++++------ 3 files changed, 19 insertions(+), 19 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 82cadd9bcc..a07d0ddc6c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -90,7 +90,7 @@ sub ParseFunction($$) pidl "const struct ndr_interface_call *call;"; pidl "struct ndr_pull *pull;"; pidl "struct ndr_push *push;"; - pidl "NTSTATUS status;"; + pidl "enum ndr_err_code ndr_err;"; pidl "DATA_BLOB blob;"; pidl "struct $fn->{NAME} *r;"; pidl ""; @@ -113,8 +113,8 @@ sub ParseFunction($$) pidl "}"; pidl ""; pidl "pull->flags |= LIBNDR_FLAG_REF_ALLOC;"; - pidl "status = call->ndr_pull(pull, NDR_IN, r);"; - pidl "if (NT_STATUS_IS_ERR(status)) {"; + pidl "ndr_err = call->ndr_pull(pull, NDR_IN, r);"; + pidl "if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {"; pidl "\ttalloc_free(r);"; pidl "\treturn False;"; pidl "}"; @@ -171,8 +171,8 @@ sub ParseFunction($$) pidl "\treturn False;"; pidl "}"; pidl ""; - pidl "status = call->ndr_push(push, NDR_OUT, r);"; - pidl "if (NT_STATUS_IS_ERR(status)) {"; + pidl "ndr_err = call->ndr_push(push, NDR_OUT, r);"; + pidl "if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {"; pidl "\ttalloc_free(r);"; pidl "\treturn False;"; pidl "}"; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 3ad9231740..1a84ee4f0b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2103,7 +2103,7 @@ sub ParseFunctionPush($$) { my($self, $fn) = @_; - $self->fn_declare("push", $fn, "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)") or return; + $self->fn_declare("push", $fn, "enum ndr_err_code ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)") or return; return if has_property($fn, "nopush"); @@ -2146,7 +2146,7 @@ sub ParseFunctionPush($$) $self->deindent; $self->pidl("}"); - $self->pidl("return NT_STATUS_OK;"); + $self->pidl("return NDR_ERR_SUCCESS;"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -2183,7 +2183,7 @@ sub ParseFunctionPull($$) my($self,$fn) = @_; # pull function args - $self->fn_declare("pull", $fn, "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)") or return; + $self->fn_declare("pull", $fn, "enum ndr_err_code ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)") or return; $self->pidl("{"); $self->indent; @@ -2279,7 +2279,7 @@ sub ParseFunctionPull($$) $self->deindent; $self->pidl("}"); - $self->pidl("return NT_STATUS_OK;"); + $self->pidl("return NDR_ERR_SUCCESS;"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -2468,12 +2468,12 @@ sub ParseTypePushFunction($$$) my ($self, $e, $varname) = @_; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}, $varname); - $self->fn_declare("push", $e, "NTSTATUS ".TypeFunctionName("ndr_push", $e)."(struct ndr_push *ndr, int ndr_flags, $args)") or return; + $self->fn_declare("push", $e, "enum ndr_err_code ".TypeFunctionName("ndr_push", $e)."(struct ndr_push *ndr, int ndr_flags, $args)") or return; $self->pidl("{"); $self->indent; $self->ParseTypePush($e, $varname, 1, 1); - $self->pidl("return NT_STATUS_OK;"); + $self->pidl("return NDR_ERR_SUCCESS;"); $self->deindent; $self->pidl("}"); $self->pidl("");; @@ -2496,12 +2496,12 @@ sub ParseTypePullFunction($$) my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "pull", $e->{NAME}, $varname); - $self->fn_declare("pull", $e, "NTSTATUS ".TypeFunctionName("ndr_pull", $e)."(struct ndr_pull *ndr, int ndr_flags, $args)") or return; + $self->fn_declare("pull", $e, "enum ndr_err_code ".TypeFunctionName("ndr_pull", $e)."(struct ndr_pull *ndr, int ndr_flags, $args)") or return; $self->pidl("{"); $self->indent; $self->ParseTypePull($e, $varname, 1, 1); - $self->pidl("return NT_STATUS_OK;"); + $self->pidl("return NDR_ERR_SUCCESS;"); $self->deindent; $self->pidl("}"); $self->pidl(""); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm index ed17fcc0da..e30102b4e1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Server.pm @@ -101,7 +101,7 @@ static void $name\__op_unbind(struct dcesrv_connection_context *context, const s static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r) { - NTSTATUS status; + enum ndr_err_code ndr_err; uint16_t opnum = dce_call->pkt.u.request.opnum; dce_call->fault_code = 0; @@ -118,8 +118,8 @@ static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_C NT_STATUS_HAVE_NO_MEMORY(*r); /* unravel the NDR for the packet */ - status = ndr_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); - if (!NT_STATUS_IS_OK(status)) { + ndr_err = ndr_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { dcerpc_log_packet(&ndr_table_$name, opnum, NDR_IN, &dce_call->pkt.u.request.stub_and_verifier); dce_call->fault_code = DCERPC_FAULT_NDR; @@ -177,11 +177,11 @@ pidl " static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r) { - NTSTATUS status; + enum ndr_err_code ndr_err; uint16_t opnum = dce_call->pkt.u.request.opnum; - status = ndr_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); - if (!NT_STATUS_IS_OK(status)) { + ndr_err = ndr_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { dce_call->fault_code = DCERPC_FAULT_NDR; return NT_STATUS_NET_WRITE_FAULT; } -- cgit From 8267a7a64bb9ff7d5a6594491eda6cc22a86701f Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 20 Nov 2007 11:07:50 +0100 Subject: r26049: pidl: don't use ndr_pull_save anymore metze (This used to be commit d361bb174131227c426a247ca0262930a714c37a) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 1a84ee4f0b..c9b48b017c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1095,8 +1095,8 @@ sub ParseElementPullLevel $self->indent; if ($l->{POINTER_TYPE} eq "relative") { - $self->pidl("struct ndr_pull_save _relative_save;"); - $self->pidl("ndr_pull_save(ndr, &_relative_save);"); + $self->pidl("uint32_t _relative_save_offset;"); + $self->pidl("_relative_save_offset = ndr->offset;"); $self->pidl("NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));"); } } @@ -1110,7 +1110,7 @@ sub ParseElementPullLevel if ($l->{POINTER_TYPE} ne "ref") { if ($l->{POINTER_TYPE} eq "relative") { - $self->pidl("ndr_pull_restore(ndr, &_relative_save);"); + $self->pidl("ndr->offset = _relative_save_offset;"); } $self->deindent; $self->pidl("}"); -- cgit From 0cc955f958cdc722e2b0b6b68d0cd37f541e9d96 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 Nov 2007 03:50:05 +0100 Subject: r26109: Use new SWIG helpers in autogenerated DCE/RPC SWIG files. (This used to be commit 3e04846b3f663b1012a077c7a2dd20abaa78400b) --- source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 46 +++++++++--------------------- 1 file changed, 14 insertions(+), 32 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm index df960d8de8..1eea561c7a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -23,8 +23,8 @@ sub pidl($) $ret .= $tabs. $p . "\n"; } -sub indent() { $tabs.="\t"; } -sub deindent() { $tabs = substr($tabs,0,-1); } +sub indent() { $tabs.=" "; } +sub deindent() { $tabs = substr($tabs,0,-2); } sub IgnoreInterface($$) { @@ -41,29 +41,22 @@ sub ParseInterface($$) my ($basename,$if) = @_; pidl "\%inline {"; - pidl "struct $if->{NAME} { struct dcerpc_pipe *pipe; };"; + pidl "typedef struct $if->{NAME} { struct dcerpc_pipe *pipe; } $if->{NAME};"; pidl "}"; pidl ""; pidl "\%extend $if->{NAME} {"; indent(); - pidl "$if->{NAME} (const char *binding, struct cli_credentials *cred = NULL, TALLOC_CTX *mem_ctx = NULL, struct event_context *event = NULL)"; + pidl "NTSTATUS $if->{NAME} (const char *binding, struct cli_credentials *cred, TALLOC_CTX *mem_ctx, struct event_context *event, struct $if->{NAME} **result)"; pidl "{"; indent; - pidl "struct $if->{NAME} *ret = talloc(mem_ctx, struct $if->{NAME});"; - pidl "NTSTATUS status;"; + pidl "*result = talloc(mem_ctx, struct $if->{NAME});"; pidl ""; - pidl "status = dcerpc_pipe_connect(mem_ctx, &ret->pipe, binding, &ndr_table_$if->{NAME}, cred, event);"; - pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\tntstatus_exception(status);"; - pidl "\treturn NULL;"; - pidl "}"; - pidl ""; - pidl "return ret;"; + pidl "return dcerpc_pipe_connect(mem_ctx, &(*result)->pipe, binding, &ndr_table_$if->{NAME}, cred, event);"; deindent; pidl "}"; pidl ""; pidl "~$if->{NAME}() {"; - pidl "\ttalloc_free(self);"; + pidl "\ttalloc_free(\$self);"; pidl "}"; pidl ""; @@ -76,8 +69,8 @@ sub ParseInterface($$) my $name = $fn->{NAME}; $name =~ s/^$if->{NAME}_//g; $name =~ s/^$basename\_//g; - $args .= "TALLOC_CTX *mem_ctx = NULL"; - pidl mapTypeName($fn->{RETURN_TYPE}) . " $name($args)"; + $args .= "TALLOC_CTX *mem_ctx, " . mapTypeName($fn->{RETURN_TYPE}) . " *result"; + pidl "NTSTATUS $name($args)"; pidl "{"; indent; pidl "struct $fn->{NAME} r;"; @@ -94,12 +87,7 @@ sub ParseInterface($$) pidl ""; pidl "status = dcerpc_$fn->{NAME}(self->pipe, mem_ctx, &r);"; pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\tntstatus_exception(status);"; - if (defined($fn->{RETURN_TYPE})) { - pidl "\treturn r.out.result;"; - } else { - pidl "\treturn;"; - } + pidl "\treturn status;"; pidl "}"; pidl ""; pidl "/* Set out arguments */"; @@ -112,8 +100,9 @@ sub ParseInterface($$) } if (defined($fn->{RETURN_TYPE})) { - pidl "return r.out.result;"; + pidl "*result = r.out.result;"; } + pidl "return NT_STATUS_OK;"; deindent; pidl "}"; pidl ""; @@ -144,18 +133,11 @@ sub Parse($$$$) pidl "\%{"; pidl "#include \"includes.h\""; - pidl "#include \"auth/credentials/credentials.h\""; pidl "#include \"$header\""; pidl "#include \"$gen_header\""; pidl "%}"; - pidl "\%import \"samba.i\""; - pidl ""; - pidl "\%inline {"; - pidl "void ntstatus_exception(NTSTATUS status)"; - pidl "{"; - pidl "\t/* FIXME */"; - pidl "}"; - pidl "}"; + pidl "\%import \"../rpc/dcerpc.i\""; + pidl "\%import \"../../libcli/util/errors.i\""; pidl ""; foreach (@$ndr) { IgnoreInterface($basename, $_) if ($_->{TYPE} eq "INTERFACE"); -- cgit From c0a37093547a76c3a292c5a01250b9711a415ff3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 Nov 2007 04:53:54 +0100 Subject: r26110: Create separate function for connecting, add helper for creating result typemaps. (This used to be commit 9b5b77c399894fc7fdf0d61a14cfbcef6dbf678c) --- source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm index 1eea561c7a..29f7835949 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -36,6 +36,22 @@ sub IgnoreInterface($$) } } +sub GenerateResultTypemap($) +{ + my $name = shift; + pidl "%typemap(in,numinputs=0) $name*result ($name tmp) {"; + indent; + pidl "\$1 = &tmp;"; + deindent; + pidl "}"; + pidl ""; + pidl "%typemap(argout) $name*result {"; + indent; + pidl "\$result = SWIG_NewPointerObj(*\$1, \$1_descriptor, 0);"; + deindent; + pidl "}"; +} + sub ParseInterface($$) { my ($basename,$if) = @_; @@ -46,12 +62,16 @@ sub ParseInterface($$) pidl ""; pidl "\%extend $if->{NAME} {"; indent(); - pidl "NTSTATUS $if->{NAME} (const char *binding, struct cli_credentials *cred, TALLOC_CTX *mem_ctx, struct event_context *event, struct $if->{NAME} **result)"; - pidl "{"; + pidl "$if->{NAME} () {"; indent; - pidl "*result = talloc(mem_ctx, struct $if->{NAME});"; + pidl "return talloc(NULL, struct $if->{NAME});"; + deindent; + pidl "}"; pidl ""; - pidl "return dcerpc_pipe_connect(mem_ctx, &(*result)->pipe, binding, &ndr_table_$if->{NAME}, cred, event);"; + pidl "NTSTATUS connect (const char *binding, struct cli_credentials *cred, struct event_context *event)"; + pidl "{"; + indent; + pidl "return dcerpc_pipe_connect(\$self, &\$self->pipe, binding, &ndr_table_$if->{NAME}, cred, event);"; deindent; pidl "}"; pidl ""; @@ -85,7 +105,7 @@ sub ParseInterface($$) } pidl ""; - pidl "status = dcerpc_$fn->{NAME}(self->pipe, mem_ctx, &r);"; + pidl "status = dcerpc_$fn->{NAME}(\$self->pipe, mem_ctx, &r);"; pidl "if (NT_STATUS_IS_ERR(status)) {"; pidl "\treturn status;"; pidl "}"; -- cgit From ef792cc8a54d99d8c32251fbae9e2178f5838576 Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Mon, 3 Dec 2007 16:49:45 +0100 Subject: r26256: When generating Samba3 pidl output for WERROR based functions, make sure the client caller can retrieve the WERROR. Jelmer, no idea how to add a test for that... Guenther (This used to be commit cf55365177e2d9ca64a80bbeafeb91deb7e2c8b3) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 11 +++++++++++ 1 file changed, 11 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index f6c9a04a8e..d77a166445 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -46,6 +46,11 @@ sub ParseFunction($$$) foreach (@{$fn->{ELEMENTS}}) { $defargs .= ", " . DeclLong($_); } + + if ($fn->{RETURN_TYPE} eq "WERROR") { + $defargs .= ", WERROR *werror"; + } + $self->fn_declare("NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"); $self->pidl("{"); $self->indent; @@ -123,6 +128,12 @@ sub ParseFunction($$$) } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") { $self->pidl("return r.out.result;"); } elsif ($fn->{RETURN_TYPE} eq "WERROR") { + $self->pidl("if (werror) {"); + $self->indent; + $self->pidl("*werror = r.out.result;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); $self->pidl("return werror_to_ntstatus(r.out.result);"); } else { warning($fn->{ORIGINAL}, "Unable to convert $fn->{RETURN_TYPE} to NTSTATUS"); -- cgit From 133ee7014caecbe2236fa5bf2292a5f8c71e58ef Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Mon, 3 Dec 2007 17:00:10 +0100 Subject: r26257: Get rid of "uninitialized value" warning in the samba3 pidl generator. Jelmer, please check. Guenther (This used to be commit 2f693292882f2929ff5d23e4009dabbb0443f891) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index d77a166445..e174f77542 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -47,7 +47,7 @@ sub ParseFunction($$$) $defargs .= ", " . DeclLong($_); } - if ($fn->{RETURN_TYPE} eq "WERROR") { + if (defined($fn->{RETURN_TYPE}) && ($fn->{RETURN_TYPE} eq "WERROR")) { $defargs .= ", WERROR *werror"; } -- cgit From d1807aa9c538e43b0567968fb6334d7e26f84cdf Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 14 Dec 2007 14:28:16 +0100 Subject: r26455: Use new talloctype macro in generated SWIG code as well. (This used to be commit 77748c6a9f118c1a2fb9dbc76546d767f1cc27eb) --- source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm index 29f7835949..58b52df8d3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -60,6 +60,8 @@ sub ParseInterface($$) pidl "typedef struct $if->{NAME} { struct dcerpc_pipe *pipe; } $if->{NAME};"; pidl "}"; pidl ""; + pidl "%talloctype($if->{NAME});"; + pidl ""; pidl "\%extend $if->{NAME} {"; indent(); pidl "$if->{NAME} () {"; @@ -75,10 +77,6 @@ sub ParseInterface($$) deindent; pidl "}"; pidl ""; - pidl "~$if->{NAME}() {"; - pidl "\ttalloc_free(\$self);"; - pidl "}"; - pidl ""; foreach my $fn (@{$if->{FUNCTIONS}}) { pidl "/* $fn->{NAME} */"; @@ -158,6 +156,7 @@ sub Parse($$$$) pidl "%}"; pidl "\%import \"../rpc/dcerpc.i\""; pidl "\%import \"../../libcli/util/errors.i\""; + pidl "\%import \"../../lib/talloc/talloc.i\""; pidl ""; foreach (@$ndr) { IgnoreInterface($basename, $_) if ($_->{TYPE} eq "INTERFACE"); -- cgit From 9faf93c7b0e00edcdc3f535ea69fc2c1bb6eeeb3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 24 Dec 2007 11:02:32 -0600 Subject: r26583: Throw a proper exception in the python code when tdb_open() fails, fix indentation in generated SWIG code from pidl. (This used to be commit 4ff8f4e370d30bf6b0b2f548bca14a9b7e1317f6) --- source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm index 58b52df8d3..14424cf260 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/SWIG.pm @@ -105,7 +105,7 @@ sub ParseInterface($$) pidl ""; pidl "status = dcerpc_$fn->{NAME}(\$self->pipe, mem_ctx, &r);"; pidl "if (NT_STATUS_IS_ERR(status)) {"; - pidl "\treturn status;"; + indent; pidl "return status;"; deindent; pidl "}"; pidl ""; pidl "/* Set out arguments */"; -- cgit From 0dbdfc2218c801b973a34fc810e5bb1b4509dd3c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 3 Jan 2008 21:21:16 -0600 Subject: r26657: pidl: Add basics for generating Python modules. (This used to be commit f1960ca7c4d1b75d64192efdd446482c6bbebcd9) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 79 ++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 source4/pidl/lib/Parse/Pidl/Samba4/Python.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm new file mode 100644 index 0000000000..4110a94dfd --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -0,0 +1,79 @@ +################################################### +# Python function wrapper generator +# Copyright jelmer@samba.org 2007 +# released under the GNU GPL + +package Parse::Pidl::Samba4::Python; + +use Exporter; +@ISA = qw(Exporter); + +use strict; +use Parse::Pidl::Typelist; +use Parse::Pidl::Util qw(has_property ParseExpr); + +use vars qw($VERSION); +$VERSION = '0.01'; + +sub new($) { + my ($class) = @_; + my $self = { res => "", res_hdr => "", tabs => "", constants => {}}; + bless($self, $class); +} + +sub pidl_hdr ($$) +{ + my $self = shift; + $self->{res_hdr} .= shift; +} + +sub pidl($$) +{ + my ($self, $d) = @_; + if ($d) { + $self->{res} .= $self->{tabs}; + $self->{res} .= $d; + } + $self->{res} .= "\n"; +} + +sub indent($) +{ + my ($self) = @_; + $self->{tabs} .= "\t"; +} + +sub deindent($) +{ + my ($self) = @_; + $self->{tabs} = substr($self->{tabs}, 0, -1); +} + +sub Parse($$$$) +{ + my($self,$basename,$ndr,$hdr) = @_; + + my $py_hdr = $hdr; + $py_hdr =~ s/^/py_/g; + + $self->pidl_hdr("/* header auto-generated by pidl */\n\n"); + + $self->pidl(" +/* Python wrapper functions auto-generated by pidl */ +#include \"includes.h\" +#include +#include \"$hdr\" +#include \"$py_hdr\" + +"); + + $self->pidl("void init$basename(void)"); + $self->pidl("{"); + $self->indent; + # FIXME + $self->deindent; + $self->pidl("}"); + return ($self->{res_hdr}, $self->{res}); +} + +1; -- cgit From 1548d8d2be2a1012549f626d504070272bb51c9e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 3 Jan 2008 21:45:18 -0600 Subject: r26658: pidl: Register Python modules. (This used to be commit f47044aacc8eb6df856524744ab87bee997bae6d) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 4110a94dfd..68e35a8532 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -54,7 +54,7 @@ sub Parse($$$$) my($self,$basename,$ndr,$hdr) = @_; my $py_hdr = $hdr; - $py_hdr =~ s/^/py_/g; + $py_hdr =~ s/ndr_([^\/]+)$/py_$1/g; $self->pidl_hdr("/* header auto-generated by pidl */\n\n"); @@ -66,10 +66,20 @@ sub Parse($$$$) #include \"$py_hdr\" "); + + $self->pidl("static PyMethodDef $basename\_methods[] = {"); + $self->indent; + $self->pidl("{ NULL, NULL, 0, NULL }"); + $self->deindent; + $self->pidl("};"); + + $self->pidl(""); $self->pidl("void init$basename(void)"); $self->pidl("{"); $self->indent; + $self->pidl("PyObject *m;"); + $self->pidl("m = Py_InitModule((char *)\"$basename\", $basename\_methods);"); # FIXME $self->deindent; $self->pidl("}"); -- cgit From 935031309ac2f7a174c39caef5bc7b3d2f2508e2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 3 Jan 2008 21:57:44 -0600 Subject: r26659: pidl/python: Support string constants and handle modules. (This used to be commit 885e5980d7d7fbafdcf308b8ba6f2560c5b467ec) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 45 ++++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 68e35a8532..7c2c2c06c6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -49,6 +49,38 @@ sub deindent($) $self->{tabs} = substr($self->{tabs}, 0, -1); } +sub Import +{ + my $self = shift; + my @imports = @_; + foreach (@imports) { + s/\.idl\"$//; + s/^\"//; + $self->pidl_hdr("#include \"librpc/gen_ndr/py_$_\.h\"\n"); + } +} + +sub Const($$) +{ + my ($self, $const) = @_; + $self->{constants}->{$const->{NAME}} = [$const->{DATA}->{TYPE}, $const->{VALUE}]; +} + +sub Interface($$) +{ + my($self,$interface) = @_; + + $self->pidl_hdr("#ifndef _HEADER_PYTHON_$interface->{NAME}\n"); + $self->pidl_hdr("#define _HEADER_PYTHON_$interface->{NAME}\n\n"); + + $self->pidl_hdr("\n"); + + $self->Const($_) foreach (@{$interface->{CONSTS}}); + + $self->pidl_hdr("\n"); + $self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n"); +} + sub Parse($$$$) { my($self,$basename,$ndr,$hdr) = @_; @@ -66,6 +98,11 @@ sub Parse($$$$) #include \"$py_hdr\" "); + + foreach my $x (@$ndr) { + ($x->{TYPE} eq "INTERFACE") && $self->Interface($x); + ($x->{TYPE} eq "IMPORT") && $self->Import(@{$x->{PATHS}}); + } $self->pidl("static PyMethodDef $basename\_methods[] = {"); $self->indent; @@ -78,9 +115,13 @@ sub Parse($$$$) $self->pidl("void init$basename(void)"); $self->pidl("{"); $self->indent; - $self->pidl("PyObject *m;"); + $self->pidl("PyObject *m, *d;"); $self->pidl("m = Py_InitModule((char *)\"$basename\", $basename\_methods);"); - # FIXME + $self->pidl("d = PyModule_GetDict(m);"); + foreach (keys %{$self->{constants}}) { + # FIXME: Handle non-string constants + $self->pidl("PyDict_SetItemString(d, \"$_\", PyString_FromString(" . $self->{constants}->{$_}->[1] . "));"); + } $self->deindent; $self->pidl("}"); return ($self->{res_hdr}, $self->{res}); -- cgit From 0d6dbcabe9c90f211c356155d21f9d3d630333a6 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 3 Jan 2008 23:58:38 -0600 Subject: r26660: pidl/python: Generate stub functions for DCE/RPC client functions, constructor for interface objects. (This used to be commit 0ee0581f052d0b90b2697841aaa09e0955aff65a) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 147 ++++++++++++++++++++++++++- 1 file changed, 144 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 7c2c2c06c6..0a2fb0b0f3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -66,6 +66,41 @@ sub Const($$) $self->{constants}->{$const->{NAME}} = [$const->{DATA}->{TYPE}, $const->{VALUE}]; } +sub FromTypeToPythonFunction($$) +{ + my ($self, $type) = @_; + + #FIXME +} + +sub FromPythonToTypeFunction($$) +{ + my ($self, $type) = @_; + + #FIXME +} + +sub TypeConstructor($$) +{ + my ($self, $type) = @_; + + #FIXME +} + +sub PythonFunction($$) +{ + my ($self, $fn) = @_; + + $self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args)"); + $self->pidl("{"); + $self->indent; + # FIXME + $self->pidl("return Py_None;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); +} + sub Interface($$) { my($self,$interface) = @_; @@ -77,6 +112,107 @@ sub Interface($$) $self->Const($_) foreach (@{$interface->{CONSTS}}); + foreach (@{$interface->{TYPES}}) { + $self->FromTypeToPythonFunction($_); + $self->FromPythonToTypeFunction($_); + $self->TypeConstructor($_); + } + + $self->pidl("staticforward PyTypeObject $interface->{NAME}_InterfaceType;"); + $self->pidl("typedef struct {"); + $self->indent; + $self->pidl("PyObject_HEAD"); + $self->pidl("struct dcerpc_pipe *pipe;"); + $self->deindent; + $self->pidl("} $interface->{NAME}_InterfaceObject;"); + + $self->pidl(""); + + foreach my $d (@{$interface->{FUNCTIONS}}) { + next if not defined($d->{OPNUM}); + next if has_property($d, "nopython"); + + $self->PythonFunction($d, $interface->{NAME}); + } + + $self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {"); + $self->indent; + foreach my $d (@{$interface->{FUNCTIONS}}) { + next if not defined($d->{OPNUM}); + next if has_property($d, "nopython"); + + my $fn_name = $d->{NAME}; + + $fn_name =~ s/^$interface->{NAME}_//; + + $self->pidl("{ (char *)\"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); + } + $self->pidl("{ NULL, NULL, 0, NULL }"); + $self->deindent; + $self->pidl("};"); + $self->pidl(""); + + $self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$interface->{NAME}_InterfaceObject *interface;"); + $self->pidl("talloc_free(interface->pipe);"); + $self->pidl("PyObject_Del(self);"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + + $self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyTypeObject *obj, char *name)"); + $self->pidl("{"); + $self->indent; + $self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, (PyObject *)obj, name);"); + $self->deindent; + $self->pidl("}"); + + $self->pidl(""); + + $self->pidl("static PyTypeObject $interface->{NAME}_InterfaceType = {"); + $self->indent; + $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); + $self->pidl(".tp_name = \"$interface->{NAME}\","); + $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); + $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); + $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); + $self->deindent; + $self->pidl("};"); + + $self->pidl(""); + + $self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$interface->{NAME}_InterfaceObject *ret;"); + $self->pidl("const char *binding_string;"); + $self->pidl("struct cli_credentials *credentials;"); + $self->pidl("struct loadparm_context *lp_ctx;"); + $self->pidl("NTSTATUS status;"); + $self->pidl(""); + + # FIXME: Arguments: binding string, credentials, loadparm context + $self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);"); + $self->pidl(""); + + $self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, "); + $self->pidl(" &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);"); + $self->pidl("if (NT_STATUS_IS_ERR(status)) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + + $self->pidl("return (PyObject *)ret;"); + $self->deindent; + $self->pidl("}"); + + $self->pidl(""); + $self->pidl_hdr("\n"); $self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n"); } @@ -94,6 +230,7 @@ sub Parse($$$$) /* Python wrapper functions auto-generated by pidl */ #include \"includes.h\" #include +#include \"librpc/rpc/dcerpc.h\" #include \"$hdr\" #include \"$py_hdr\" @@ -106,6 +243,11 @@ sub Parse($$$$) $self->pidl("static PyMethodDef $basename\_methods[] = {"); $self->indent; + foreach my $x (@$ndr) { + next if ($x->{TYPE} ne "INTERFACE"); + $self->pidl("{ (char *)\"$x->{NAME}\", (PyCFunction)interface_$x->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); + } + $self->pidl("{ NULL, NULL, 0, NULL }"); $self->deindent; $self->pidl("};"); @@ -115,12 +257,11 @@ sub Parse($$$$) $self->pidl("void init$basename(void)"); $self->pidl("{"); $self->indent; - $self->pidl("PyObject *m, *d;"); + $self->pidl("PyObject *m;"); $self->pidl("m = Py_InitModule((char *)\"$basename\", $basename\_methods);"); - $self->pidl("d = PyModule_GetDict(m);"); foreach (keys %{$self->{constants}}) { # FIXME: Handle non-string constants - $self->pidl("PyDict_SetItemString(d, \"$_\", PyString_FromString(" . $self->{constants}->{$_}->[1] . "));"); + $self->pidl("PyModule_AddObject(m, \"$_\", PyString_FromString(" . $self->{constants}->{$_}->[1] . "));"); } $self->deindent; $self->pidl("}"); -- cgit From c9afddd42c916328980390251938508165ad130f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 4 Jan 2008 03:44:32 -0600 Subject: r26661: pidl/python: More generic handling of NTSTATUS, add stubs for types. (This used to be commit 336dae6d429f122f7f38a6c78d28b848ebfa3c67) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 51 ++++++++++++++++++++++------ 1 file changed, 41 insertions(+), 10 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 0a2fb0b0f3..7e2ded1ff7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -84,23 +84,48 @@ sub TypeConstructor($$) { my ($self, $type) = @_; + $self->pidl("static PyObject *py_$type->{NAME}(PyObject *self, PyObject *args)"); + $self->pidl("{"); + $self->indent; #FIXME + + $self->pidl("return Py_None;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); } -sub PythonFunction($$) +sub PythonFunction($$$) { - my ($self, $fn) = @_; + my ($self, $fn, $iface) = @_; $self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args)"); $self->pidl("{"); $self->indent; + $self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;"); + $self->pidl("NTSTATUS status;"); + $self->pidl(""); # FIXME + $self->handle_ntstatus("status", "NULL"); $self->pidl("return Py_None;"); $self->deindent; $self->pidl("}"); $self->pidl(""); } +sub handle_ntstatus($$$) +{ + my ($self, $var, $retval) = @_; + + $self->pidl("if (NT_STATUS_IS_ERR($var)) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_RuntimeError, nt_errstr($var));"); + $self->pidl("return $retval;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); +} + sub Interface($$) { my($self,$interface) = @_; @@ -155,7 +180,7 @@ sub Interface($$) $self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)"); $self->pidl("{"); $self->indent; - $self->pidl("$interface->{NAME}_InterfaceObject *interface;"); + $self->pidl("$interface->{NAME}_InterfaceObject *interface = ($interface->{NAME}_InterfaceObject *)self;"); $self->pidl("talloc_free(interface->pipe);"); $self->pidl("PyObject_Del(self);"); $self->deindent; @@ -199,13 +224,7 @@ sub Interface($$) $self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, "); $self->pidl(" &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);"); - $self->pidl("if (NT_STATUS_IS_ERR(status)) {"); - $self->indent; - $self->pidl("PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));"); - $self->pidl("return NULL;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); + $self->handle_ntstatus("status", "NULL"); $self->pidl("return (PyObject *)ret;"); $self->deindent; @@ -246,6 +265,18 @@ sub Parse($$$$) foreach my $x (@$ndr) { next if ($x->{TYPE} ne "INTERFACE"); $self->pidl("{ (char *)\"$x->{NAME}\", (PyCFunction)interface_$x->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); + + foreach my $d (@{$x->{TYPES}}) { + next if has_property($d, "nopython"); + next if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP"); + + my $fn_name = $d->{NAME}; + + $fn_name =~ s/^$x->{NAME}_//; + $fn_name =~ s/^$basename\_//; + + $self->pidl("{ (char *)\"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); + } } $self->pidl("{ NULL, NULL, 0, NULL }"); -- cgit From 4ba6e6c1593bc7a9e1bd9b891a325a842e93d951 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 4 Jan 2008 03:44:38 -0600 Subject: r26662: pidl/python: Add constructors for struct/union types. (This used to be commit bc6aa49d8e33add2efa6f66630029f5305b56280) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 55 ++++++++++++++++++++++++++-- 1 file changed, 52 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 7e2ded1ff7..874e7f8346 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -84,15 +84,64 @@ sub TypeConstructor($$) { my ($self, $type) = @_; - $self->pidl("static PyObject *py_$type->{NAME}(PyObject *self, PyObject *args)"); + $self->pidl("staticforward PyTypeObject $type->{NAME}_ObjectType;"); + $self->pidl("typedef struct {"); + $self->indent; + $self->pidl("PyObject_HEAD"); + $self->pidl("void *object;"); # FIXME: Use real type rather than void + $self->deindent; + $self->pidl("} $type->{NAME}_Object;"); + + $self->pidl(""); + + $self->pidl("static PyObject *py_$type->{NAME}_getattr(PyTypeObject *obj, char *name)"); $self->pidl("{"); $self->indent; - #FIXME + $self->pidl("return Py_None;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + + $self->pidl("static void py_$type->{NAME}_dealloc(PyObject* self)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$type->{NAME}_Object *obj = ($type->{NAME}_Object *)self;"); + $self->pidl("talloc_free(obj->object);"); + $self->pidl("PyObject_Del(self);"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $self->pidl("static PyObject *py_$type->{NAME}_setattr(PyTypeObject *obj, char *name, PyObject *value)"); + $self->pidl("{"); + $self->indent; $self->pidl("return Py_None;"); $self->deindent; $self->pidl("}"); $self->pidl(""); + + $self->pidl("static PyTypeObject $type->{NAME}_ObjectType = {"); + $self->indent; + $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); + $self->pidl(".tp_name = (char *)\"$type->{NAME}\","); + $self->pidl(".tp_basicsize = sizeof($type->{NAME}_Object),"); + $self->pidl(".tp_dealloc = py_$type->{NAME}_dealloc,"); + $self->pidl(".tp_getattr = py_$type->{NAME}_getattr,"); + $self->pidl(".tp_setattr = py_$type->{NAME}_setattr,"); + $self->deindent; + $self->pidl("};"); + + $self->pidl(""); + + $self->pidl("static PyObject *py_$type->{NAME}(PyObject *self, PyObject *args)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$type->{NAME}\_Object *ret;"); + $self->pidl("ret = PyObject_New($type->{NAME}_Object, &$type->{NAME}_ObjectType);"); + $self->pidl("return (PyObject *) ret;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); } sub PythonFunction($$$) @@ -199,7 +248,7 @@ sub Interface($$) $self->pidl("static PyTypeObject $interface->{NAME}_InterfaceType = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); - $self->pidl(".tp_name = \"$interface->{NAME}\","); + $self->pidl(".tp_name = (char *)\"$interface->{NAME}\","); $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); -- cgit From d0e9c92e57915920a77496e828c9da6cd87f0a8d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 5 Jan 2008 14:00:12 -0600 Subject: r26667: pidl/python: Don't generate casts anymore; this will generate warnings with older Pythons, but will be a lot cleaner with newer versions. (This used to be commit 7db3222dace7071e3d74fc34b86d571a0f3badea) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 874e7f8346..8effff9d5e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -123,11 +123,11 @@ sub TypeConstructor($$) $self->pidl("static PyTypeObject $type->{NAME}_ObjectType = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); - $self->pidl(".tp_name = (char *)\"$type->{NAME}\","); + $self->pidl(".tp_name = \"$type->{NAME}\","); $self->pidl(".tp_basicsize = sizeof($type->{NAME}_Object),"); - $self->pidl(".tp_dealloc = py_$type->{NAME}_dealloc,"); - $self->pidl(".tp_getattr = py_$type->{NAME}_getattr,"); - $self->pidl(".tp_setattr = py_$type->{NAME}_setattr,"); + $self->pidl(".tp_dealloc = (destructor)py_$type->{NAME}_dealloc,"); + $self->pidl(".tp_getattr = (getattrfunc)py_$type->{NAME}_getattr,"); + $self->pidl(".tp_setattr = (setattrfunc)py_$type->{NAME}_setattr,"); $self->deindent; $self->pidl("};"); @@ -219,7 +219,7 @@ sub Interface($$) $fn_name =~ s/^$interface->{NAME}_//; - $self->pidl("{ (char *)\"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); + $self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); } $self->pidl("{ NULL, NULL, 0, NULL }"); $self->deindent; @@ -248,7 +248,7 @@ sub Interface($$) $self->pidl("static PyTypeObject $interface->{NAME}_InterfaceType = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); - $self->pidl(".tp_name = (char *)\"$interface->{NAME}\","); + $self->pidl(".tp_name = \"$interface->{NAME}\","); $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); @@ -313,7 +313,7 @@ sub Parse($$$$) $self->indent; foreach my $x (@$ndr) { next if ($x->{TYPE} ne "INTERFACE"); - $self->pidl("{ (char *)\"$x->{NAME}\", (PyCFunction)interface_$x->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); + $self->pidl("{ \"$x->{NAME}\", (PyCFunction)interface_$x->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); foreach my $d (@{$x->{TYPES}}) { next if has_property($d, "nopython"); @@ -324,7 +324,7 @@ sub Parse($$$$) $fn_name =~ s/^$x->{NAME}_//; $fn_name =~ s/^$basename\_//; - $self->pidl("{ (char *)\"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); + $self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); } } @@ -338,7 +338,7 @@ sub Parse($$$$) $self->pidl("{"); $self->indent; $self->pidl("PyObject *m;"); - $self->pidl("m = Py_InitModule((char *)\"$basename\", $basename\_methods);"); + $self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);"); foreach (keys %{$self->{constants}}) { # FIXME: Handle non-string constants $self->pidl("PyModule_AddObject(m, \"$_\", PyString_FromString(" . $self->{constants}->{$_}->[1] . "));"); -- cgit From 0f32132b884fa56fde806ba33d082456b53e0df9 Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Tue, 8 Jan 2008 17:02:53 -0600 Subject: r26695: Cosmetic fix for pidl generated samba3 client code. Guenther (This used to be commit c52d9e6e60e0765e4f793d64e94571b6f6c3f9c7) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index e174f77542..d6b6296bd8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -23,7 +23,7 @@ $VERSION = '0.01'; sub indent($) { my ($self) = @_; $self->{tabs}.="\t"; } sub deindent($) { my ($self) = @_; $self->{tabs} = substr($self->{tabs}, 1); } -sub pidl($$) { my ($self,$txt) = @_; $self->{res} .= "$self->{tabs}$txt\n"; } +sub pidl($$) { my ($self,$txt) = @_; $self->{res} .= $txt ? "$self->{tabs}$txt\n" : "\n"; } sub pidl_hdr($$) { my ($self, $txt) = @_; $self->{res_hdr} .= "$txt\n"; } sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); } -- cgit From e3f0e64ef083cbad37c0e967e5ab3de6a840b7f9 Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Tue, 8 Jan 2008 22:56:44 -0600 Subject: r26696: Some more minor pidl samba3 client cosmetics. Guenther (This used to be commit 7ee3fd43f964d3161c075dae8de73c77de146538) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index d6b6296bd8..01b77c0c9f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -66,8 +66,11 @@ sub ParseFunction($$$) } $self->pidl(""); - $self->pidl("if (DEBUGLEVEL >= 10)"); - $self->pidl("\tNDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"); + $self->pidl("if (DEBUGLEVEL >= 10) {"); + $self->indent; + $self->pidl("NDR_PRINT_IN_DEBUG($fn->{NAME}, &r);"); + $self->deindent; + $self->pidl("}"); $self->pidl(""); $self->pidl("status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, &ndr_table_$if, $ufn, &r);"); $self->pidl(""); @@ -79,11 +82,16 @@ sub ParseFunction($$$) $self->pidl("}"); $self->pidl(""); - $self->pidl("if (DEBUGLEVEL >= 10)"); - $self->pidl("\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);"); + $self->pidl("if (DEBUGLEVEL >= 10) {"); + $self->indent; + $self->pidl("NDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);"); + $self->deindent; + $self->pidl("}"); $self->pidl(""); $self->pidl("if (NT_STATUS_IS_ERR(status)) {"); - $self->pidl("\treturn status;"); + $self->indent; + $self->pidl("return status;"); + $self->deindent; $self->pidl("}"); $self->pidl(""); $self->pidl("/* Return variables */"); -- cgit From e6968df1e57e1c09bee21019fc1eec15e7a06005 Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Wed, 9 Jan 2008 10:56:07 -0600 Subject: r26698: Prettify samba3 client code a little more. Guenther (This used to be commit 6ac36d6a4b83b9ef794a2022c4d46ed0b69758e9) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 32 +++++++++++++++++++------ 1 file changed, 25 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 01b77c0c9f..b7372a802a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -2,6 +2,7 @@ # Samba3 client generator for IDL structures # on top of Samba4 style NDR functions # Copyright jelmer@samba.org 2005-2006 +# Copyright gd@samba.org 2008 # released under the GNU GPL package Parse::Pidl::Samba3::ClientNDR; @@ -27,6 +28,15 @@ sub pidl($$) { my ($self,$txt) = @_; $self->{res} .= $txt ? "$self->{tabs}$txt\n sub pidl_hdr($$) { my ($self, $txt) = @_; $self->{res_hdr} .= "$txt\n"; } sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); } +sub genpad($) +{ + my ($s) = @_; + my $nt = int((length($s)+1)/8); + my $lt = ($nt*8)-1; + my $ns = (length($s)-$lt); + return "\t"x($nt)." "x($ns); +} + sub new($) { my ($class) = shift; @@ -38,20 +48,23 @@ sub ParseFunction($$$) { my ($self, $if, $fn) = @_; - my $inargs = ""; - my $defargs = ""; + my $fn_args = ""; my $uif = uc($if); my $ufn = "NDR_".uc($fn->{NAME}); + my $fn_str = "NTSTATUS rpccli_$fn->{NAME}"; + my $pad = genpad($fn_str); + + $fn_args .= "struct rpc_pipe_client *cli,\n" . $pad . "TALLOC_CTX *mem_ctx"; foreach (@{$fn->{ELEMENTS}}) { - $defargs .= ", " . DeclLong($_); + $fn_args .= ",\n" . $pad . DeclLong($_); } if (defined($fn->{RETURN_TYPE}) && ($fn->{RETURN_TYPE} eq "WERROR")) { - $defargs .= ", WERROR *werror"; + $fn_args .= ",\n" . $pad . "WERROR *werror"; } - $self->fn_declare("NTSTATUS rpccli_$fn->{NAME}(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx$defargs)"); + $self->fn_declare("$fn_str($fn_args)"); $self->pidl("{"); $self->indent; $self->pidl("struct $fn->{NAME} r;"); @@ -62,7 +75,7 @@ sub ParseFunction($$$) foreach (@{$fn->{ELEMENTS}}) { if (grep(/in/, @{$_->{DIRECTION}})) { $self->pidl("r.in.$_->{NAME} = $_->{NAME};"); - } + } } $self->pidl(""); @@ -72,7 +85,12 @@ sub ParseFunction($$$) $self->deindent; $self->pidl("}"); $self->pidl(""); - $self->pidl("status = cli_do_rpc_ndr(cli, mem_ctx, PI_$uif, &ndr_table_$if, $ufn, &r);"); + $self->pidl("status = cli_do_rpc_ndr(cli,"); + $self->pidl("\t\t\tmem_ctx,"); + $self->pidl("\t\t\tPI_$uif,"); + $self->pidl("\t\t\t&ndr_table_$if,"); + $self->pidl("\t\t\t$ufn,"); + $self->pidl("\t\t\t&r);"); $self->pidl(""); $self->pidl("if (!NT_STATUS_IS_OK(status)) {"); -- cgit From c781879e35b5ff29a21ab9ea4f0ca3b7c53280f7 Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Wed, 9 Jan 2008 11:28:53 -0600 Subject: r26699: Some minor cosmetics for pidl samba3 server code. Guenther (This used to be commit 81fa63dfe6004d916bbe653cbb1b4cbdf5d3d97d) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 38 +++++++++++++------------ 1 file changed, 20 insertions(+), 18 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index a07d0ddc6c..47312bc83d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -22,11 +22,11 @@ my $res_hdr; my $tabs = ""; sub indent() { $tabs.="\t"; } sub deindent() { $tabs = substr($tabs, 1); } -sub pidl($) { $res .= $tabs.(shift)."\n"; } +sub pidl($) { my ($txt) = @_; $res .= $txt?$tabs.(shift)."\n":"\n"; } sub pidl_hdr($) { $res_hdr .= (shift)."\n"; } sub fn_declare($) { my ($n) = @_; pidl $n; pidl_hdr "$n;"; } -sub DeclLevel($$) +sub DeclLevel($$) { my ($e, $l) = @_; my $res = ""; @@ -73,7 +73,7 @@ sub AllocOutVar($$$$) pidl "if ($name == NULL) {"; pidl "\ttalloc_free($mem_ctx);"; - pidl "\treturn False;"; + pidl "\treturn false;"; pidl "}"; pidl ""; } @@ -98,29 +98,30 @@ sub ParseFunction($$) pidl ""; pidl "r = talloc(NULL, struct $fn->{NAME});"; pidl "if (r == NULL) {"; - pidl "\treturn False;"; + pidl "\treturn false;"; pidl "}"; pidl ""; pidl "if (!prs_data_blob(&p->in_data.data, &blob, r)) {"; pidl "\ttalloc_free(r);"; - pidl "\treturn False;"; + pidl "\treturn false;"; pidl "}"; pidl ""; pidl "pull = ndr_pull_init_blob(&blob, r);"; pidl "if (pull == NULL) {"; pidl "\ttalloc_free(r);"; - pidl "\treturn False;"; + pidl "\treturn false;"; pidl "}"; pidl ""; pidl "pull->flags |= LIBNDR_FLAG_REF_ALLOC;"; pidl "ndr_err = call->ndr_pull(pull, NDR_IN, r);"; pidl "if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {"; pidl "\ttalloc_free(r);"; - pidl "\treturn False;"; + pidl "\treturn false;"; pidl "}"; pidl ""; - pidl "if (DEBUGLEVEL >= 10)"; + pidl "if (DEBUGLEVEL >= 10) {"; pidl "\tNDR_PRINT_IN_DEBUG($fn->{NAME}, r);"; + pidl "}"; pidl ""; my $env = GenerateFunctionOutEnv($fn); @@ -137,7 +138,7 @@ sub ParseFunction($$) my @dir = @{$_->{DIRECTION}}; if (grep(/in/, @dir) and grep(/out/, @dir)) { pidl "r->out.$_->{NAME} = r->in.$_->{NAME};"; - } elsif (grep(/out/, @dir) and not + } elsif (grep(/out/, @dir) and not has_property($_, "represent_as")) { AllocOutVar($_, "r", "r->out.$_->{NAME}", $env); } @@ -158,34 +159,35 @@ sub ParseFunction($$) pidl ""; pidl "if (p->rng_fault_state) {"; pidl "\ttalloc_free(r);"; - pidl "\t/* Return True here, srv_pipe_hnd.c will take care */"; - pidl "\treturn True;"; + pidl "\t/* Return true here, srv_pipe_hnd.c will take care */"; + pidl "\treturn true;"; pidl "}"; pidl ""; - pidl "if (DEBUGLEVEL >= 10)"; + pidl "if (DEBUGLEVEL >= 10) {"; pidl "\tNDR_PRINT_OUT_DEBUG($fn->{NAME}, r);"; + pidl "}"; pidl ""; pidl "push = ndr_push_init_ctx(r);"; pidl "if (push == NULL) {"; pidl "\ttalloc_free(r);"; - pidl "\treturn False;"; + pidl "\treturn false;"; pidl "}"; pidl ""; pidl "ndr_err = call->ndr_push(push, NDR_OUT, r);"; pidl "if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {"; pidl "\ttalloc_free(r);"; - pidl "\treturn False;"; + pidl "\treturn false;"; pidl "}"; pidl ""; pidl "blob = ndr_push_blob(push);"; - pidl "if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {"; + pidl "if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {"; pidl "\ttalloc_free(r);"; - pidl "\treturn False;"; + pidl "\treturn false;"; pidl "}"; pidl ""; pidl "talloc_free(r);"; pidl ""; - pidl "return True;"; + pidl "return true;"; deindent; pidl "}"; pidl ""; @@ -251,7 +253,7 @@ sub Parse($$$) pidl "#include \"$header\""; pidl_hdr "#include \"$ndr_header\""; pidl ""; - + foreach (@$ndr) { ParseInterface($_) if ($_->{TYPE} eq "INTERFACE"); } -- cgit From 47fff7a1b91c3ae89b8c1c1713366d74ac3497bb Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 20:19:47 +0100 Subject: pidl: Remove multiple copies of get_pointer_of and get_value_of. (This used to be commit 79344c9c5e0e38155facb0c7b16e84a0dca3d2eb) --- source4/pidl/lib/Parse/Pidl/CUtil.pm | 39 ++++++++++++++++++++++++ source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 27 ++-------------- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 24 +-------------- 3 files changed, 42 insertions(+), 48 deletions(-) create mode 100644 source4/pidl/lib/Parse/Pidl/CUtil.pm (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/CUtil.pm b/source4/pidl/lib/Parse/Pidl/CUtil.pm new file mode 100644 index 0000000000..bd7b16812c --- /dev/null +++ b/source4/pidl/lib/Parse/Pidl/CUtil.pm @@ -0,0 +1,39 @@ +################################################### +# C utility functions for pidl +# Copyright jelmer@samba.org 2005-2007 +# released under the GNU GPL +package Parse::Pidl::CUtil; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(get_pointer_to get_value_of); +use vars qw($VERSION); +$VERSION = '0.01'; + +use strict; + +sub get_pointer_to($) +{ + my $var_name = shift; + + if ($var_name =~ /^\*(.*)$/) { + return $1; + } elsif ($var_name =~ /^\&(.*)$/) { + return "&($var_name)"; + } else { + return "&$var_name"; + } +} + +sub get_value_of($) +{ + my $var_name = shift; + + if ($var_name =~ /^\&(.*)$/) { + return $1; + } else { + return "*$var_name"; + } +} + +1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 2e9bc0953c..36cc469ff6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -8,10 +8,11 @@ package Parse::Pidl::Samba4::EJS; use Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(get_pointer_to get_value_of check_null_pointer fn_declare TypeFunctionName); +@EXPORT_OK = qw(check_null_pointer fn_declare TypeFunctionName); use strict; use Parse::Pidl::Typelist; +use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel); use Parse::Pidl::Samba4::NDR::Parser qw(GenerateStructEnv GenerateFunctionInEnv @@ -54,30 +55,6 @@ sub deindent($) $self->{tabs} = substr($self->{tabs}, 0, -1); } -sub get_pointer_to($) -{ - my $var_name = shift; - - if ($var_name =~ /^\*(.*)$/) { - return $1; - } elsif ($var_name =~ /^\&(.*)$/) { - return "&($var_name)"; - } else { - return "&$var_name"; - } -} - -sub get_value_of($) -{ - my $var_name = shift; - - if ($var_name =~ /^\&(.*)$/) { - return $1; - } else { - return "*$var_name"; - } -} - ##################################################################### # check that a variable we get from ParseExpr isn't a null pointer sub check_null_pointer($$) diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index c9b48b017c..a261910c17 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -14,6 +14,7 @@ require Exporter; use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName); use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid); +use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::Samba4 qw(is_intree choose_header); use Parse::Pidl qw(warning); @@ -89,29 +90,6 @@ sub is_charset_array($$) return has_property($e, "charset"); } -sub get_pointer_to($) -{ - my $var_name = shift; - - if ($var_name =~ /^\*(.*)$/) { - return $1; - } elsif ($var_name =~ /^\&(.*)$/) { - return "&($var_name)"; - } else { - return "&$var_name"; - } -} - -sub get_value_of($) -{ - my $var_name = shift; - - if ($var_name =~ /^\&(.*)$/) { - return $1; - } else { - return "*$var_name"; - } -} #################################### # pidl() is our basic output routine -- cgit From 92950a9f2f300292c237a78b308d9e95fba2bed2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 12 Jan 2008 01:10:59 +0100 Subject: pidl: Remove support for the "declare" keyword in the parser. (This used to be commit ea3371389226a756ba641a7fc02cfbee78663411) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 2226 +++++++++++++++++------------------- 1 file changed, 1058 insertions(+), 1168 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index e9155e4e00..5956c43e43 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -38,7 +38,7 @@ sub new { "import" => 7, "include" => 13 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { 'cpp_quote' => 11, 'importlib' => 10, @@ -124,7 +124,7 @@ sub new { } }, {#State 16 - DEFAULT => -124 + DEFAULT => -116 }, {#State 17 DEFAULT => -11 @@ -184,7 +184,7 @@ sub new { } }, {#State 26 - DEFAULT => -120 + DEFAULT => -112 }, {#State 27 ACTIONS => { @@ -206,10 +206,10 @@ sub new { ACTIONS => { "(" => 40 }, - DEFAULT => -95 + DEFAULT => -87 }, {#State 31 - DEFAULT => -93 + DEFAULT => -85 }, {#State 32 DEFAULT => -8 @@ -231,10 +231,9 @@ sub new { }, {#State 37 ACTIONS => { - "declare" => 49, - "const" => 53 + "const" => 51 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { 'typedecl' => 42, 'function' => 43, @@ -243,12 +242,11 @@ sub new { 'definition' => 48, 'property_list' => 47, 'usertype' => 46, - 'const' => 52, - 'declare' => 51, - 'struct' => 50, - 'typedef' => 55, - 'enum' => 54, - 'union' => 56 + 'const' => 50, + 'struct' => 49, + 'typedef' => 53, + 'enum' => 52, + 'union' => 54 } }, {#State 38 @@ -257,1539 +255,1482 @@ sub new { }, GOTOS => { 'identifier' => 30, - 'property' => 57 + 'property' => 55 } }, {#State 39 - DEFAULT => -92 + DEFAULT => -84 }, {#State 40 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'text' => 63, - 'listtext' => 59, - 'anytext' => 58, - 'constant' => 60 + 'identifier' => 60, + 'text' => 61, + 'listtext' => 57, + 'anytext' => 56, + 'constant' => 58 } }, {#State 41 ACTIONS => { - "}" => 64, - "interface" => 65 + "}" => 62, + "interface" => 63 } }, {#State 42 - DEFAULT => -24 + DEFAULT => -23 }, {#State 43 DEFAULT => -20 }, {#State 44 - DEFAULT => -39 + DEFAULT => -31 }, {#State 45 ACTIONS => { - "}" => 66, - "declare" => 49, - "const" => 53 + "}" => 64, + "const" => 51 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { 'typedecl' => 42, 'function' => 43, 'bitmap' => 44, - 'definition' => 67, + 'definition' => 65, 'property_list' => 47, 'usertype' => 46, - 'const' => 52, - 'struct' => 50, - 'declare' => 51, - 'typedef' => 55, - 'enum' => 54, - 'union' => 56 + 'struct' => 49, + 'const' => 50, + 'typedef' => 53, + 'enum' => 52, + 'union' => 54 } }, {#State 46 ACTIONS => { - ";" => 68 + ";" => 66 } }, {#State 47 ACTIONS => { - "typedef" => 69, + "typedef" => 67, 'IDENTIFIER' => 26, - "signed" => 77, - "union" => 70, - "enum" => 79, - "bitmap" => 80, - 'void' => 71, - "unsigned" => 81, + "signed" => 75, + "union" => 68, + "enum" => 77, + "bitmap" => 78, + 'void' => 69, + "unsigned" => 79, "[" => 20, - "struct" => 76 + "struct" => 74 }, GOTOS => { - 'existingtype' => 78, + 'existingtype' => 76, 'bitmap' => 44, - 'usertype' => 73, - 'property_list' => 72, - 'identifier' => 74, - 'struct' => 50, - 'enum' => 54, - 'type' => 82, - 'union' => 56, - 'sign' => 75 + 'usertype' => 71, + 'property_list' => 70, + 'identifier' => 72, + 'struct' => 49, + 'enum' => 52, + 'type' => 80, + 'union' => 54, + 'sign' => 73 } }, {#State 48 DEFAULT => -18 }, {#State 49 - DEFAULT => -91, - GOTOS => { - 'decl_enum' => 84, - 'decl_bitmap' => 85, - 'decl_type' => 87, - 'decl_union' => 86, - 'property_list' => 83 - } + DEFAULT => -28 }, {#State 50 - DEFAULT => -36 - }, - {#State 51 - DEFAULT => -23 - }, - {#State 52 DEFAULT => -21 }, - {#State 53 + {#State 51 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 88 + 'identifier' => 81 } }, + {#State 52 + DEFAULT => -30 + }, + {#State 53 + DEFAULT => -22 + }, {#State 54 - DEFAULT => -38 + DEFAULT => -29 }, {#State 55 - DEFAULT => -22 + DEFAULT => -86 }, {#State 56 - DEFAULT => -37 + ACTIONS => { + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 + }, + DEFAULT => -89 }, {#State 57 - DEFAULT => -94 + ACTIONS => { + "," => 97, + ")" => 98 + } }, {#State 58 - ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 - }, - DEFAULT => -97 + DEFAULT => -95 }, {#State 59 - ACTIONS => { - "," => 104, - ")" => 105 - } + DEFAULT => -115 }, {#State 60 - DEFAULT => -103 + DEFAULT => -94 }, {#State 61 - DEFAULT => -123 + DEFAULT => -96 }, {#State 62 - DEFAULT => -102 - }, - {#State 63 - DEFAULT => -104 - }, - {#State 64 ACTIONS => { - ";" => 106 + ";" => 99 }, - DEFAULT => -125, + DEFAULT => -117, GOTOS => { - 'optional_semicolon' => 107 + 'optional_semicolon' => 100 } }, - {#State 65 + {#State 63 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 108 + 'identifier' => 101 } }, - {#State 66 + {#State 64 ACTIONS => { - ";" => 106 + ";" => 99 }, - DEFAULT => -125, + DEFAULT => -117, GOTOS => { - 'optional_semicolon' => 109 + 'optional_semicolon' => 102 } }, - {#State 67 + {#State 65 DEFAULT => -19 }, - {#State 68 - DEFAULT => -40 + {#State 66 + DEFAULT => -32 }, - {#State 69 + {#State 67 ACTIONS => { 'IDENTIFIER' => 26, - "signed" => 77, - 'void' => 71, - "unsigned" => 81 + "signed" => 75, + 'void' => 69, + "unsigned" => 79 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { - 'existingtype' => 78, + 'existingtype' => 76, 'bitmap' => 44, - 'usertype' => 73, - 'property_list' => 72, - 'identifier' => 74, - 'struct' => 50, - 'enum' => 54, - 'type' => 110, - 'union' => 56, - 'sign' => 75 + 'usertype' => 71, + 'property_list' => 70, + 'identifier' => 72, + 'struct' => 49, + 'enum' => 52, + 'type' => 103, + 'union' => 54, + 'sign' => 73 } }, - {#State 70 + {#State 68 ACTIONS => { - 'IDENTIFIER' => 111 + 'IDENTIFIER' => 104 }, - DEFAULT => -122, + DEFAULT => -114, GOTOS => { - 'optional_identifier' => 112 + 'optional_identifier' => 105 } }, - {#State 71 - DEFAULT => -47 + {#State 69 + DEFAULT => -39 }, - {#State 72 + {#State 70 ACTIONS => { - "union" => 70, - "enum" => 79, - "bitmap" => 80, + "union" => 68, + "enum" => 77, + "bitmap" => 78, "[" => 20, - "struct" => 76 + "struct" => 74 } }, - {#State 73 - DEFAULT => -45 + {#State 71 + DEFAULT => -37 }, - {#State 74 - DEFAULT => -44 + {#State 72 + DEFAULT => -36 }, - {#State 75 + {#State 73 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 113 + 'identifier' => 106 } }, - {#State 76 + {#State 74 ACTIONS => { - 'IDENTIFIER' => 111 + 'IDENTIFIER' => 104 }, - DEFAULT => -122, + DEFAULT => -114, GOTOS => { - 'optional_identifier' => 114 + 'optional_identifier' => 107 } }, - {#State 77 - DEFAULT => -41 - }, - {#State 78 - DEFAULT => -46 + {#State 75 + DEFAULT => -33 }, - {#State 79 - ACTIONS => { - 'IDENTIFIER' => 111 - }, - DEFAULT => -122, - GOTOS => { - 'optional_identifier' => 115 - } + {#State 76 + DEFAULT => -38 }, - {#State 80 + {#State 77 ACTIONS => { - 'IDENTIFIER' => 111 + 'IDENTIFIER' => 104 }, - DEFAULT => -122, + DEFAULT => -114, GOTOS => { - 'optional_identifier' => 116 + 'optional_identifier' => 108 } }, - {#State 81 - DEFAULT => -42 - }, - {#State 82 + {#State 78 ACTIONS => { - 'IDENTIFIER' => 26 + 'IDENTIFIER' => 104 }, + DEFAULT => -114, GOTOS => { - 'identifier' => 117 - } - }, - {#State 83 - ACTIONS => { - "union" => 118, - "enum" => 119, - "bitmap" => 120, - "[" => 20 + 'optional_identifier' => 109 } }, - {#State 84 - DEFAULT => -29 - }, - {#State 85 - DEFAULT => -30 - }, - {#State 86 - DEFAULT => -31 + {#State 79 + DEFAULT => -34 }, - {#State 87 + {#State 80 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 121 + 'identifier' => 110 } }, - {#State 88 - DEFAULT => -80, + {#State 81 + DEFAULT => -72, GOTOS => { - 'pointers' => 122 + 'pointers' => 111 } }, - {#State 89 + {#State 82 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 123, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 112, + 'text' => 61, + 'constant' => 58 } }, - {#State 90 + {#State 83 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 124, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 113, + 'text' => 61, + 'constant' => 58 } }, - {#State 91 + {#State 84 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 125, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 114, + 'text' => 61, + 'constant' => 58 } }, - {#State 92 + {#State 85 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 126, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 115, + 'text' => 61, + 'constant' => 58 } }, - {#State 93 + {#State 86 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 127, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 116, + 'text' => 61, + 'constant' => 58 } }, - {#State 94 + {#State 87 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 128, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 117, + 'text' => 61, + 'constant' => 58 } }, - {#State 95 + {#State 88 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 129, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 118, + 'text' => 61, + 'constant' => 58 } }, - {#State 96 + {#State 89 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 130, - 'text' => 63, - 'constant' => 60, - 'commalisttext' => 131 + 'identifier' => 60, + 'anytext' => 119, + 'text' => 61, + 'constant' => 58, + 'commalisttext' => 120 } }, - {#State 97 + {#State 90 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 132, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 121, + 'text' => 61, + 'constant' => 58 } }, - {#State 98 + {#State 91 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 133, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 122, + 'text' => 61, + 'constant' => 58 } }, - {#State 99 + {#State 92 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 134, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 123, + 'text' => 61, + 'constant' => 58 } }, - {#State 100 + {#State 93 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 130, - 'text' => 63, - 'constant' => 60, - 'commalisttext' => 135 + 'identifier' => 60, + 'anytext' => 119, + 'text' => 61, + 'constant' => 58, + 'commalisttext' => 124 } }, - {#State 101 + {#State 94 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 136, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 125, + 'text' => 61, + 'constant' => 58 } }, - {#State 102 + {#State 95 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 137, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 126, + 'text' => 61, + 'constant' => 58 } }, - {#State 103 + {#State 96 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 138, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 127, + 'text' => 61, + 'constant' => 58 } }, - {#State 104 + {#State 97 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 139, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 128, + 'text' => 61, + 'constant' => 58 } }, - {#State 105 - DEFAULT => -96 + {#State 98 + DEFAULT => -88 }, - {#State 106 - DEFAULT => -126 + {#State 99 + DEFAULT => -118 }, - {#State 107 + {#State 100 DEFAULT => -13 }, - {#State 108 + {#State 101 ACTIONS => { - ";" => 140 + ";" => 129 } }, - {#State 109 + {#State 102 DEFAULT => -16 }, - {#State 110 + {#State 103 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 141 + 'identifier' => 130 } }, - {#State 111 - DEFAULT => -121 + {#State 104 + DEFAULT => -113 }, - {#State 112 + {#State 105 ACTIONS => { - "{" => 143 + "{" => 132 }, - DEFAULT => -76, + DEFAULT => -68, GOTOS => { - 'union_body' => 144, - 'opt_union_body' => 142 + 'union_body' => 133, + 'opt_union_body' => 131 } }, - {#State 113 - DEFAULT => -43 + {#State 106 + DEFAULT => -35 }, - {#State 114 + {#State 107 ACTIONS => { - "{" => 146 + "{" => 135 }, - DEFAULT => -66, + DEFAULT => -58, GOTOS => { - 'struct_body' => 145, - 'opt_struct_body' => 147 + 'struct_body' => 134, + 'opt_struct_body' => 136 } }, - {#State 115 + {#State 108 ACTIONS => { - "{" => 148 + "{" => 137 }, - DEFAULT => -49, + DEFAULT => -41, GOTOS => { - 'opt_enum_body' => 150, - 'enum_body' => 149 + 'opt_enum_body' => 139, + 'enum_body' => 138 } }, - {#State 116 + {#State 109 ACTIONS => { - "{" => 152 + "{" => 141 }, - DEFAULT => -57, + DEFAULT => -49, GOTOS => { - 'bitmap_body' => 153, - 'opt_bitmap_body' => 151 + 'bitmap_body' => 142, + 'opt_bitmap_body' => 140 } }, - {#State 117 - ACTIONS => { - "(" => 154 - } - }, - {#State 118 - DEFAULT => -34 - }, - {#State 119 - DEFAULT => -32 - }, - {#State 120 - DEFAULT => -33 - }, - {#State 121 + {#State 110 ACTIONS => { - ";" => 155 + "(" => 143 } }, - {#State 122 + {#State 111 ACTIONS => { 'IDENTIFIER' => 26, - "*" => 157 + "*" => 145 }, GOTOS => { - 'identifier' => 156 + 'identifier' => 144 } }, - {#State 123 - ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 - }, - DEFAULT => -114 - }, - {#State 124 + {#State 112 ACTIONS => { - ":" => 89, - "<" => 91, - "~" => 92, - "?" => 95, - "{" => 96, - "=" => 99 + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 }, - DEFAULT => -105 + DEFAULT => -106 }, - {#State 125 + {#State 113 ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 + ":" => 82, + "<" => 84, + "~" => 85, + "?" => 88, + "{" => 89, + "=" => 92 }, - DEFAULT => -109 + DEFAULT => -97 }, - {#State 126 + {#State 114 ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 - }, - DEFAULT => -117 + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 + }, + DEFAULT => -101 }, - {#State 127 + {#State 115 ACTIONS => { - ":" => 89, - "<" => 91, - "~" => 92, - "?" => 95, - "{" => 96, - "=" => 99 + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 }, - DEFAULT => -116 + DEFAULT => -109 }, - {#State 128 + {#State 116 ACTIONS => { - ":" => 89, - "<" => 91, - "~" => 92, - "?" => 95, - "{" => 96, - "=" => 99 + ":" => 82, + "<" => 84, + "~" => 85, + "?" => 88, + "{" => 89, + "=" => 92 }, - DEFAULT => -107 + DEFAULT => -108 }, - {#State 129 + {#State 117 ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 + ":" => 82, + "<" => 84, + "~" => 85, + "?" => 88, + "{" => 89, + "=" => 92 }, - DEFAULT => -113 + DEFAULT => -99 }, - {#State 130 + {#State 118 ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 }, - DEFAULT => -99 + DEFAULT => -105 }, - {#State 131 + {#State 119 + ACTIONS => { + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 + }, + DEFAULT => -91 + }, + {#State 120 ACTIONS => { - "}" => 158, - "," => 159 + "}" => 146, + "," => 147 } }, - {#State 132 + {#State 121 ACTIONS => { - ":" => 89, - "<" => 91, - "~" => 92, - "?" => 95, - "{" => 96, - "=" => 99 + ":" => 82, + "<" => 84, + "~" => 85, + "?" => 88, + "{" => 89, + "=" => 92 }, - DEFAULT => -111 + DEFAULT => -103 }, - {#State 133 + {#State 122 ACTIONS => { - ":" => 89, - "<" => 91, - "~" => 92, - "?" => 95, - "{" => 96, - "=" => 99 + ":" => 82, + "<" => 84, + "~" => 85, + "?" => 88, + "{" => 89, + "=" => 92 }, - DEFAULT => -112 + DEFAULT => -104 }, - {#State 134 + {#State 123 ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 }, - DEFAULT => -115 + DEFAULT => -107 }, - {#State 135 + {#State 124 ACTIONS => { - "," => 159, - ")" => 160 + "," => 147, + ")" => 148 } }, - {#State 136 + {#State 125 ACTIONS => { - ":" => 89, - "<" => 91, - "~" => 92, - "?" => 95, - "{" => 96, - "=" => 99 + ":" => 82, + "<" => 84, + "~" => 85, + "?" => 88, + "{" => 89, + "=" => 92 }, - DEFAULT => -110 + DEFAULT => -102 }, - {#State 137 + {#State 126 ACTIONS => { - ":" => 89, - "<" => 91, - "~" => 92, - "?" => 95, - "{" => 96, - "=" => 99 + ":" => 82, + "<" => 84, + "~" => 85, + "?" => 88, + "{" => 89, + "=" => 92 }, - DEFAULT => -106 + DEFAULT => -98 }, - {#State 138 + {#State 127 ACTIONS => { - ":" => 89, - "<" => 91, - "~" => 92, - "?" => 95, - "{" => 96, - "=" => 99 + ":" => 82, + "<" => 84, + "~" => 85, + "?" => 88, + "{" => 89, + "=" => 92 }, - DEFAULT => -108 + DEFAULT => -100 }, - {#State 139 + {#State 128 ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 }, - DEFAULT => -98 + DEFAULT => -90 }, - {#State 140 + {#State 129 DEFAULT => -15 }, - {#State 141 + {#State 130 ACTIONS => { - "[" => 161 + "[" => 149 }, - DEFAULT => -88, + DEFAULT => -80, GOTOS => { - 'array_len' => 162 + 'array_len' => 150 } }, - {#State 142 - DEFAULT => -78 + {#State 131 + DEFAULT => -70 }, - {#State 143 - DEFAULT => -73, + {#State 132 + DEFAULT => -65, GOTOS => { - 'union_elements' => 163 + 'union_elements' => 151 } }, - {#State 144 - DEFAULT => -77 + {#State 133 + DEFAULT => -69 }, - {#State 145 - DEFAULT => -67 + {#State 134 + DEFAULT => -59 }, - {#State 146 - DEFAULT => -82, + {#State 135 + DEFAULT => -74, GOTOS => { - 'element_list1' => 164 + 'element_list1' => 152 } }, - {#State 147 - DEFAULT => -68 + {#State 136 + DEFAULT => -60 }, - {#State 148 + {#State 137 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 165, - 'enum_element' => 166, - 'enum_elements' => 167 + 'identifier' => 153, + 'enum_element' => 154, + 'enum_elements' => 155 } }, - {#State 149 - DEFAULT => -50 + {#State 138 + DEFAULT => -42 }, - {#State 150 - DEFAULT => -51 + {#State 139 + DEFAULT => -43 }, - {#State 151 - DEFAULT => -59 + {#State 140 + DEFAULT => -51 }, - {#State 152 + {#State 141 ACTIONS => { 'IDENTIFIER' => 26 }, - DEFAULT => -62, + DEFAULT => -54, GOTOS => { - 'identifier' => 170, - 'bitmap_element' => 169, - 'bitmap_elements' => 168, - 'opt_bitmap_elements' => 171 + 'identifier' => 158, + 'bitmap_element' => 157, + 'bitmap_elements' => 156, + 'opt_bitmap_elements' => 159 } }, - {#State 153 - DEFAULT => -58 + {#State 142 + DEFAULT => -50 }, - {#State 154 + {#State 143 ACTIONS => { - "," => -84, - "void" => 175, - ")" => -84 + "," => -76, + "void" => 163, + ")" => -76 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { - 'base_element' => 172, - 'element_list2' => 174, - 'property_list' => 173 + 'base_element' => 160, + 'element_list2' => 162, + 'property_list' => 161 } }, - {#State 155 - DEFAULT => -28 - }, - {#State 156 + {#State 144 ACTIONS => { - "[" => 161, - "=" => 177 + "[" => 149, + "=" => 165 }, GOTOS => { - 'array_len' => 176 + 'array_len' => 164 } }, - {#State 157 - DEFAULT => -81 + {#State 145 + DEFAULT => -73 }, - {#State 158 + {#State 146 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 178, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 166, + 'text' => 61, + 'constant' => 58 } }, - {#State 159 + {#State 147 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 179, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 167, + 'text' => 61, + 'constant' => 58 } }, - {#State 160 + {#State 148 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 180, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 168, + 'text' => 61, + 'constant' => 58 } }, - {#State 161 + {#State 149 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, - "]" => 181, + "]" => 169, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 182, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 170, + 'text' => 61, + 'constant' => 58 } }, - {#State 162 + {#State 150 ACTIONS => { - ";" => 183 + ";" => 171 } }, - {#State 163 + {#State 151 ACTIONS => { - "}" => 184 + "}" => 172 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { - 'optional_base_element' => 186, - 'property_list' => 185 + 'optional_base_element' => 174, + 'property_list' => 173 } }, - {#State 164 + {#State 152 ACTIONS => { - "}" => 187 + "}" => 175 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { - 'base_element' => 188, - 'property_list' => 173 + 'base_element' => 176, + 'property_list' => 161 } }, - {#State 165 + {#State 153 ACTIONS => { - "=" => 189 + "=" => 177 }, - DEFAULT => -54 + DEFAULT => -46 }, - {#State 166 - DEFAULT => -52 + {#State 154 + DEFAULT => -44 }, - {#State 167 + {#State 155 ACTIONS => { - "}" => 190, - "," => 191 + "}" => 178, + "," => 179 } }, - {#State 168 + {#State 156 ACTIONS => { - "," => 192 + "," => 180 }, - DEFAULT => -63 + DEFAULT => -55 }, - {#State 169 - DEFAULT => -60 + {#State 157 + DEFAULT => -52 }, - {#State 170 + {#State 158 ACTIONS => { - "=" => 193 + "=" => 181 } }, - {#State 171 + {#State 159 ACTIONS => { - "}" => 194 + "}" => 182 } }, - {#State 172 - DEFAULT => -86 + {#State 160 + DEFAULT => -78 }, - {#State 173 + {#State 161 ACTIONS => { 'IDENTIFIER' => 26, - "signed" => 77, - 'void' => 71, - "unsigned" => 81, + "signed" => 75, + 'void' => 69, + "unsigned" => 79, "[" => 20 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { - 'existingtype' => 78, + 'existingtype' => 76, 'bitmap' => 44, - 'usertype' => 73, - 'property_list' => 72, - 'identifier' => 74, - 'struct' => 50, - 'enum' => 54, - 'type' => 195, - 'union' => 56, - 'sign' => 75 + 'usertype' => 71, + 'property_list' => 70, + 'identifier' => 72, + 'struct' => 49, + 'enum' => 52, + 'type' => 183, + 'union' => 54, + 'sign' => 73 } }, - {#State 174 + {#State 162 ACTIONS => { - "," => 196, - ")" => 197 + "," => 184, + ")" => 185 } }, - {#State 175 - DEFAULT => -85 + {#State 163 + DEFAULT => -77 }, - {#State 176 + {#State 164 ACTIONS => { - "=" => 198 + "=" => 186 } }, - {#State 177 + {#State 165 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 199, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 187, + 'text' => 61, + 'constant' => 58 } }, - {#State 178 + {#State 166 ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 - }, - DEFAULT => -119 + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 + }, + DEFAULT => -111 }, - {#State 179 + {#State 167 ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 }, - DEFAULT => -100 + DEFAULT => -92 }, - {#State 180 + {#State 168 ACTIONS => { - ":" => 89, - "<" => 91, - "~" => 92, - "?" => 95, - "{" => 96, - "=" => 99 + ":" => 82, + "<" => 84, + "~" => 85, + "?" => 88, + "{" => 89, + "=" => 92 }, - DEFAULT => -118 + DEFAULT => -110 }, - {#State 181 + {#State 169 ACTIONS => { - "[" => 161 + "[" => 149 }, - DEFAULT => -88, + DEFAULT => -80, GOTOS => { - 'array_len' => 200 + 'array_len' => 188 } }, - {#State 182 + {#State 170 ACTIONS => { - "-" => 90, - ":" => 89, - "?" => 95, - "<" => 91, - "+" => 93, - "~" => 92, - "&" => 97, - "{" => 96, - "/" => 98, - "=" => 99, - "|" => 101, - "(" => 100, - "*" => 94, - "." => 102, - "]" => 201, - ">" => 103 + "-" => 83, + ":" => 82, + "?" => 88, + "<" => 84, + "+" => 86, + "~" => 85, + "&" => 90, + "{" => 89, + "/" => 91, + "=" => 92, + "|" => 94, + "(" => 93, + "*" => 87, + "." => 95, + "]" => 189, + ">" => 96 } }, - {#State 183 - DEFAULT => -35 + {#State 171 + DEFAULT => -27 }, - {#State 184 - DEFAULT => -75 + {#State 172 + DEFAULT => -67 }, - {#State 185 + {#State 173 ACTIONS => { "[" => 20 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { - 'base_or_empty' => 202, - 'base_element' => 203, - 'empty_element' => 204, - 'property_list' => 205 + 'base_or_empty' => 190, + 'base_element' => 191, + 'empty_element' => 192, + 'property_list' => 193 } }, - {#State 186 - DEFAULT => -74 + {#State 174 + DEFAULT => -66 }, - {#State 187 - DEFAULT => -65 + {#State 175 + DEFAULT => -57 }, - {#State 188 + {#State 176 ACTIONS => { - ";" => 206 + ";" => 194 } }, - {#State 189 + {#State 177 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 207, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 195, + 'text' => 61, + 'constant' => 58 } }, - {#State 190 - DEFAULT => -48 + {#State 178 + DEFAULT => -40 }, - {#State 191 + {#State 179 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 165, - 'enum_element' => 208 + 'identifier' => 153, + 'enum_element' => 196 } }, - {#State 192 + {#State 180 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 170, - 'bitmap_element' => 209 + 'identifier' => 158, + 'bitmap_element' => 197 } }, - {#State 193 + {#State 181 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 210, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 198, + 'text' => 61, + 'constant' => 58 } }, - {#State 194 - DEFAULT => -56 + {#State 182 + DEFAULT => -48 }, - {#State 195 - DEFAULT => -80, + {#State 183 + DEFAULT => -72, GOTOS => { - 'pointers' => 211 + 'pointers' => 199 } }, - {#State 196 - DEFAULT => -91, + {#State 184 + DEFAULT => -83, GOTOS => { - 'base_element' => 212, - 'property_list' => 173 + 'base_element' => 200, + 'property_list' => 161 } }, - {#State 197 + {#State 185 ACTIONS => { - ";" => 213 + ";" => 201 } }, - {#State 198 + {#State 186 ACTIONS => { - 'CONSTANT' => 61, + 'CONSTANT' => 59, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -101, + DEFAULT => -93, GOTOS => { - 'identifier' => 62, - 'anytext' => 214, - 'text' => 63, - 'constant' => 60 + 'identifier' => 60, + 'anytext' => 202, + 'text' => 61, + 'constant' => 58 } }, - {#State 199 + {#State 187 ACTIONS => { - "-" => 90, - ":" => 89, - "?" => 95, - "<" => 91, - ";" => 215, - "+" => 93, - "~" => 92, - "&" => 97, - "{" => 96, - "/" => 98, - "=" => 99, - "|" => 101, - "(" => 100, - "*" => 94, - "." => 102, - ">" => 103 + "-" => 83, + ":" => 82, + "?" => 88, + "<" => 84, + ";" => 203, + "+" => 86, + "~" => 85, + "&" => 90, + "{" => 89, + "/" => 91, + "=" => 92, + "|" => 94, + "(" => 93, + "*" => 87, + "." => 95, + ">" => 96 } }, - {#State 200 - DEFAULT => -89 + {#State 188 + DEFAULT => -81 }, - {#State 201 + {#State 189 ACTIONS => { - "[" => 161 + "[" => 149 }, - DEFAULT => -88, + DEFAULT => -80, GOTOS => { - 'array_len' => 216 + 'array_len' => 204 } }, - {#State 202 - DEFAULT => -72 + {#State 190 + DEFAULT => -64 }, - {#State 203 + {#State 191 ACTIONS => { - ";" => 217 + ";" => 205 } }, - {#State 204 - DEFAULT => -71 + {#State 192 + DEFAULT => -63 }, - {#State 205 + {#State 193 ACTIONS => { 'IDENTIFIER' => 26, - "signed" => 77, - ";" => 218, - 'void' => 71, - "unsigned" => 81, + "signed" => 75, + ";" => 206, + 'void' => 69, + "unsigned" => 79, "[" => 20 }, - DEFAULT => -91, + DEFAULT => -83, GOTOS => { - 'existingtype' => 78, + 'existingtype' => 76, 'bitmap' => 44, - 'usertype' => 73, - 'property_list' => 72, - 'identifier' => 74, - 'struct' => 50, - 'enum' => 54, - 'type' => 195, - 'union' => 56, - 'sign' => 75 + 'usertype' => 71, + 'property_list' => 70, + 'identifier' => 72, + 'struct' => 49, + 'enum' => 52, + 'type' => 183, + 'union' => 54, + 'sign' => 73 } }, - {#State 206 - DEFAULT => -83 + {#State 194 + DEFAULT => -75 }, - {#State 207 + {#State 195 ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 }, - DEFAULT => -55 + DEFAULT => -47 }, - {#State 208 - DEFAULT => -53 + {#State 196 + DEFAULT => -45 }, - {#State 209 - DEFAULT => -61 + {#State 197 + DEFAULT => -53 }, - {#State 210 - ACTIONS => { - "-" => 90, - ":" => 89, - "<" => 91, - "+" => 93, - "~" => 92, - "*" => 94, - "?" => 95, - "{" => 96, - "&" => 97, - "/" => 98, - "=" => 99, - "(" => 100, - "|" => 101, - "." => 102, - ">" => 103 + {#State 198 + ACTIONS => { + "-" => 83, + ":" => 82, + "<" => 84, + "+" => 86, + "~" => 85, + "*" => 87, + "?" => 88, + "{" => 89, + "&" => 90, + "/" => 91, + "=" => 92, + "(" => 93, + "|" => 94, + "." => 95, + ">" => 96 }, - DEFAULT => -64 + DEFAULT => -56 }, - {#State 211 + {#State 199 ACTIONS => { 'IDENTIFIER' => 26, - "*" => 157 + "*" => 145 }, GOTOS => { - 'identifier' => 219 + 'identifier' => 207 } }, - {#State 212 - DEFAULT => -87 + {#State 200 + DEFAULT => -79 }, - {#State 213 - DEFAULT => -27 + {#State 201 + DEFAULT => -26 }, - {#State 214 - ACTIONS => { - "-" => 90, - ":" => 89, - "?" => 95, - "<" => 91, - ";" => 220, - "+" => 93, - "~" => 92, - "&" => 97, - "{" => 96, - "/" => 98, - "=" => 99, - "|" => 101, - "(" => 100, - "*" => 94, - "." => 102, - ">" => 103 - } - }, - {#State 215 - DEFAULT => -25 + {#State 202 + ACTIONS => { + "-" => 83, + ":" => 82, + "?" => 88, + "<" => 84, + ";" => 208, + "+" => 86, + "~" => 85, + "&" => 90, + "{" => 89, + "/" => 91, + "=" => 92, + "|" => 94, + "(" => 93, + "*" => 87, + "." => 95, + ">" => 96 + } }, - {#State 216 - DEFAULT => -90 + {#State 203 + DEFAULT => -24 }, - {#State 217 - DEFAULT => -70 + {#State 204 + DEFAULT => -82 }, - {#State 218 - DEFAULT => -69 + {#State 205 + DEFAULT => -62 + }, + {#State 206 + DEFAULT => -61 }, - {#State 219 + {#State 207 ACTIONS => { - "[" => 161 + "[" => 149 }, - DEFAULT => -88, + DEFAULT => -80, GOTOS => { - 'array_len' => 221 + 'array_len' => 209 } }, - {#State 220 - DEFAULT => -26 + {#State 208 + DEFAULT => -25 }, - {#State 221 - DEFAULT => -79 + {#State 209 + DEFAULT => -71 } ], yyrules => @@ -1803,43 +1744,43 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "idl.yp" +#line 19 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "idl.yp" +#line 20 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'idl', 2, sub -#line 21 "idl.yp" +#line 21 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 5 'idl', 2, sub -#line 22 "idl.yp" +#line 22 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 6 'idl', 2, sub -#line 23 "idl.yp" +#line 23 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'idl', 2, sub -#line 24 "idl.yp" +#line 24 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 8 'import', 3, sub -#line 27 "idl.yp" +#line 27 "pidl/idl.yp" {{ "TYPE" => "IMPORT", "PATHS" => $_[2], @@ -1850,7 +1791,7 @@ sub [#Rule 9 'include', 3, sub -#line 34 "idl.yp" +#line 34 "pidl/idl.yp" {{ "TYPE" => "INCLUDE", "PATHS" => $_[2], @@ -1861,7 +1802,7 @@ sub [#Rule 10 'importlib', 3, sub -#line 41 "idl.yp" +#line 41 "pidl/idl.yp" {{ "TYPE" => "IMPORTLIB", "PATHS" => $_[2], @@ -1872,19 +1813,19 @@ sub [#Rule 11 'commalist', 1, sub -#line 50 "idl.yp" +#line 50 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 12 'commalist', 3, sub -#line 51 "idl.yp" +#line 51 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 13 'coclass', 7, sub -#line 55 "idl.yp" +#line 55 "pidl/idl.yp" {{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -1900,13 +1841,13 @@ sub [#Rule 15 'interface_names', 4, sub -#line 67 "idl.yp" +#line 67 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 16 'interface', 7, sub -#line 71 "idl.yp" +#line 71 "pidl/idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -1919,7 +1860,7 @@ sub [#Rule 17 'cpp_quote', 4, sub -#line 82 "idl.yp" +#line 82 "pidl/idl.yp" {{ "TYPE" => "CPP_QUOTE", "FILE" => $_[0]->YYData->{FILE}, @@ -1930,13 +1871,13 @@ sub [#Rule 18 'definitions', 1, sub -#line 91 "idl.yp" +#line 91 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 19 'definitions', 2, sub -#line 92 "idl.yp" +#line 92 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 20 @@ -1952,12 +1893,9 @@ sub 'definition', 1, undef ], [#Rule 24 - 'definition', 1, undef - ], - [#Rule 25 'const', 7, sub -#line 100 "idl.yp" +#line 100 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1968,10 +1906,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 26 + [#Rule 25 'const', 8, sub -#line 110 "idl.yp" +#line 110 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1983,10 +1921,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 27 + [#Rule 26 'function', 7, sub -#line 124 "idl.yp" +#line 124 "pidl/idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -1997,58 +1935,10 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 28 - 'declare', 4, -sub -#line 136 "idl.yp" -{{ - "TYPE" => "DECLARE", - "NAME" => $_[3], - "DATA" => $_[2], - "FILE" => $_[0]->YYData->{FILE}, - "LINE" => $_[0]->YYData->{LINE}, - }} - ], - [#Rule 29 - 'decl_type', 1, undef - ], - [#Rule 30 - 'decl_type', 1, undef - ], - [#Rule 31 - 'decl_type', 1, undef - ], - [#Rule 32 - 'decl_enum', 2, -sub -#line 149 "idl.yp" -{{ - "TYPE" => "ENUM", - "PROPERTIES" => $_[1] - }} - ], - [#Rule 33 - 'decl_bitmap', 2, -sub -#line 156 "idl.yp" -{{ - "TYPE" => "BITMAP", - "PROPERTIES" => $_[1] - }} - ], - [#Rule 34 - 'decl_union', 2, -sub -#line 163 "idl.yp" -{{ - "TYPE" => "UNION", - "PROPERTIES" => $_[1] - }} - ], - [#Rule 35 + [#Rule 27 'typedef', 6, sub -#line 170 "idl.yp" +#line 136 "pidl/idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[1], @@ -2059,67 +1949,67 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 36 + [#Rule 28 'usertype', 1, undef ], - [#Rule 37 + [#Rule 29 'usertype', 1, undef ], - [#Rule 38 + [#Rule 30 'usertype', 1, undef ], - [#Rule 39 + [#Rule 31 'usertype', 1, undef ], - [#Rule 40 + [#Rule 32 'typedecl', 2, sub -#line 183 "idl.yp" +#line 149 "pidl/idl.yp" { $_[1] } ], - [#Rule 41 + [#Rule 33 'sign', 1, undef ], - [#Rule 42 + [#Rule 34 'sign', 1, undef ], - [#Rule 43 + [#Rule 35 'existingtype', 2, sub -#line 188 "idl.yp" +#line 154 "pidl/idl.yp" { ($_[1]?$_[1]:"signed") ." $_[2]" } ], - [#Rule 44 + [#Rule 36 'existingtype', 1, undef ], - [#Rule 45 + [#Rule 37 'type', 1, undef ], - [#Rule 46 + [#Rule 38 'type', 1, undef ], - [#Rule 47 + [#Rule 39 'type', 1, sub -#line 192 "idl.yp" +#line 158 "pidl/idl.yp" { "void" } ], - [#Rule 48 + [#Rule 40 'enum_body', 3, sub -#line 194 "idl.yp" +#line 160 "pidl/idl.yp" { $_[2] } ], - [#Rule 49 + [#Rule 41 'opt_enum_body', 0, undef ], - [#Rule 50 + [#Rule 42 'opt_enum_body', 1, undef ], - [#Rule 51 + [#Rule 43 'enum', 4, sub -#line 197 "idl.yp" +#line 163 "pidl/idl.yp" {{ "TYPE" => "ENUM", "PROPERTIES" => $_[1], @@ -2127,43 +2017,43 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 52 + [#Rule 44 'enum_elements', 1, sub -#line 206 "idl.yp" +#line 172 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 53 + [#Rule 45 'enum_elements', 3, sub -#line 207 "idl.yp" +#line 173 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 54 + [#Rule 46 'enum_element', 1, undef ], - [#Rule 55 + [#Rule 47 'enum_element', 3, sub -#line 211 "idl.yp" +#line 177 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 56 + [#Rule 48 'bitmap_body', 3, sub -#line 214 "idl.yp" +#line 180 "pidl/idl.yp" { $_[2] } ], - [#Rule 57 + [#Rule 49 'opt_bitmap_body', 0, undef ], - [#Rule 58 + [#Rule 50 'opt_bitmap_body', 1, undef ], - [#Rule 59 + [#Rule 51 'bitmap', 4, sub -#line 217 "idl.yp" +#line 183 "pidl/idl.yp" {{ "TYPE" => "BITMAP", "PROPERTIES" => $_[1], @@ -2171,46 +2061,46 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 60 + [#Rule 52 'bitmap_elements', 1, sub -#line 226 "idl.yp" +#line 192 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 61 + [#Rule 53 'bitmap_elements', 3, sub -#line 227 "idl.yp" +#line 193 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 62 + [#Rule 54 'opt_bitmap_elements', 0, undef ], - [#Rule 63 + [#Rule 55 'opt_bitmap_elements', 1, undef ], - [#Rule 64 + [#Rule 56 'bitmap_element', 3, sub -#line 232 "idl.yp" +#line 198 "pidl/idl.yp" { "$_[1] ( $_[3] )" } ], - [#Rule 65 + [#Rule 57 'struct_body', 3, sub -#line 235 "idl.yp" +#line 201 "pidl/idl.yp" { $_[2] } ], - [#Rule 66 + [#Rule 58 'opt_struct_body', 0, undef ], - [#Rule 67 + [#Rule 59 'opt_struct_body', 1, undef ], - [#Rule 68 + [#Rule 60 'struct', 4, sub -#line 239 "idl.yp" +#line 205 "pidl/idl.yp" {{ "TYPE" => "STRUCT", "PROPERTIES" => $_[1], @@ -2218,10 +2108,10 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 69 + [#Rule 61 'empty_element', 2, sub -#line 248 "idl.yp" +#line 214 "pidl/idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2232,43 +2122,43 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 70 + [#Rule 62 'base_or_empty', 2, undef ], - [#Rule 71 + [#Rule 63 'base_or_empty', 1, undef ], - [#Rule 72 + [#Rule 64 'optional_base_element', 2, sub -#line 262 "idl.yp" +#line 228 "pidl/idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], - [#Rule 73 + [#Rule 65 'union_elements', 0, undef ], - [#Rule 74 + [#Rule 66 'union_elements', 2, sub -#line 267 "idl.yp" +#line 233 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 75 + [#Rule 67 'union_body', 3, sub -#line 270 "idl.yp" +#line 236 "pidl/idl.yp" { $_[2] } ], - [#Rule 76 + [#Rule 68 'opt_union_body', 0, undef ], - [#Rule 77 + [#Rule 69 'opt_union_body', 1, undef ], - [#Rule 78 + [#Rule 70 'union', 4, sub -#line 274 "idl.yp" +#line 240 "pidl/idl.yp" {{ "TYPE" => "UNION", "PROPERTIES" => $_[1], @@ -2276,10 +2166,10 @@ sub "ELEMENTS" => $_[4] }} ], - [#Rule 79 + [#Rule 71 'base_element', 5, sub -#line 283 "idl.yp" +#line 249 "pidl/idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2290,241 +2180,241 @@ sub "LINE" => $_[0]->YYData->{LINE}, }} ], - [#Rule 80 + [#Rule 72 'pointers', 0, sub -#line 297 "idl.yp" +#line 263 "pidl/idl.yp" { 0 } ], - [#Rule 81 + [#Rule 73 'pointers', 2, sub -#line 298 "idl.yp" +#line 264 "pidl/idl.yp" { $_[1]+1 } ], - [#Rule 82 + [#Rule 74 'element_list1', 0, sub -#line 302 "idl.yp" +#line 268 "pidl/idl.yp" { [] } ], - [#Rule 83 + [#Rule 75 'element_list1', 3, sub -#line 303 "idl.yp" +#line 269 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], - [#Rule 84 + [#Rule 76 'element_list2', 0, undef ], - [#Rule 85 + [#Rule 77 'element_list2', 1, undef ], - [#Rule 86 + [#Rule 78 'element_list2', 1, sub -#line 309 "idl.yp" +#line 275 "pidl/idl.yp" { [ $_[1] ] } ], - [#Rule 87 + [#Rule 79 'element_list2', 3, sub -#line 310 "idl.yp" +#line 276 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], - [#Rule 88 + [#Rule 80 'array_len', 0, undef ], - [#Rule 89 + [#Rule 81 'array_len', 3, sub -#line 315 "idl.yp" +#line 281 "pidl/idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], - [#Rule 90 + [#Rule 82 'array_len', 4, sub -#line 316 "idl.yp" +#line 282 "pidl/idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], - [#Rule 91 + [#Rule 83 'property_list', 0, undef ], - [#Rule 92 + [#Rule 84 'property_list', 4, sub -#line 322 "idl.yp" +#line 288 "pidl/idl.yp" { FlattenHash([$_[1],$_[3]]); } ], - [#Rule 93 + [#Rule 85 'properties', 1, sub -#line 325 "idl.yp" +#line 291 "pidl/idl.yp" { $_[1] } ], - [#Rule 94 + [#Rule 86 'properties', 3, sub -#line 326 "idl.yp" +#line 292 "pidl/idl.yp" { FlattenHash([$_[1], $_[3]]); } ], - [#Rule 95 + [#Rule 87 'property', 1, sub -#line 329 "idl.yp" +#line 295 "pidl/idl.yp" {{ "$_[1]" => "1" }} ], - [#Rule 96 + [#Rule 88 'property', 4, sub -#line 330 "idl.yp" +#line 296 "pidl/idl.yp" {{ "$_[1]" => "$_[3]" }} ], - [#Rule 97 + [#Rule 89 'listtext', 1, undef ], - [#Rule 98 + [#Rule 90 'listtext', 3, sub -#line 335 "idl.yp" +#line 301 "pidl/idl.yp" { "$_[1] $_[3]" } ], - [#Rule 99 + [#Rule 91 'commalisttext', 1, undef ], - [#Rule 100 + [#Rule 92 'commalisttext', 3, sub -#line 340 "idl.yp" +#line 306 "pidl/idl.yp" { "$_[1],$_[3]" } ], - [#Rule 101 + [#Rule 93 'anytext', 0, sub -#line 344 "idl.yp" +#line 310 "pidl/idl.yp" { "" } ], - [#Rule 102 + [#Rule 94 'anytext', 1, undef ], - [#Rule 103 + [#Rule 95 'anytext', 1, undef ], - [#Rule 104 + [#Rule 96 'anytext', 1, undef ], - [#Rule 105 + [#Rule 97 'anytext', 3, sub -#line 346 "idl.yp" +#line 312 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 106 + [#Rule 98 'anytext', 3, sub -#line 347 "idl.yp" +#line 313 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 107 + [#Rule 99 'anytext', 3, sub -#line 348 "idl.yp" +#line 314 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 108 + [#Rule 100 'anytext', 3, sub -#line 349 "idl.yp" +#line 315 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 109 + [#Rule 101 'anytext', 3, sub -#line 350 "idl.yp" +#line 316 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 110 + [#Rule 102 'anytext', 3, sub -#line 351 "idl.yp" +#line 317 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 111 + [#Rule 103 'anytext', 3, sub -#line 352 "idl.yp" +#line 318 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 112 + [#Rule 104 'anytext', 3, sub -#line 353 "idl.yp" +#line 319 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 113 + [#Rule 105 'anytext', 3, sub -#line 354 "idl.yp" +#line 320 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 114 + [#Rule 106 'anytext', 3, sub -#line 355 "idl.yp" +#line 321 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 115 + [#Rule 107 'anytext', 3, sub -#line 356 "idl.yp" +#line 322 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 116 + [#Rule 108 'anytext', 3, sub -#line 357 "idl.yp" +#line 323 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 117 + [#Rule 109 'anytext', 3, sub -#line 358 "idl.yp" +#line 324 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], - [#Rule 118 + [#Rule 110 'anytext', 5, sub -#line 359 "idl.yp" +#line 325 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 119 + [#Rule 111 'anytext', 5, sub -#line 360 "idl.yp" +#line 326 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 120 + [#Rule 112 'identifier', 1, undef ], - [#Rule 121 + [#Rule 113 'optional_identifier', 1, undef ], - [#Rule 122 + [#Rule 114 'optional_identifier', 0, undef ], - [#Rule 123 + [#Rule 115 'constant', 1, undef ], - [#Rule 124 + [#Rule 116 'text', 1, sub -#line 374 "idl.yp" +#line 340 "pidl/idl.yp" { "\"$_[1]\"" } ], - [#Rule 125 + [#Rule 117 'optional_semicolon', 0, undef ], - [#Rule 126 + [#Rule 118 'optional_semicolon', 1, undef ] ], @@ -2532,7 +2422,7 @@ sub bless($self,$class); } -#line 385 "idl.yp" +#line 351 "pidl/idl.yp" use Parse::Pidl qw(error); @@ -2627,7 +2517,7 @@ again: if (s/^([\w_]+)//) { $parser->YYData->{LAST_TOKEN} = $1; if ($1 =~ - /^(coclass|interface|const|typedef|declare|union|cpp_quote + /^(coclass|interface|const|typedef|union|cpp_quote |struct|enum|bitmap|void|unsigned|signed|import|include |importlib)$/x) { return $1; -- cgit From 87fc0a43915fcdce3ac8deea50f3fafffaa42c37 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 12 Jan 2008 01:22:23 +0100 Subject: pidl: Remove support for the declare keyword in other parts of the pidl code. (This used to be commit 2fe013f715bdee6c01a833bc6c883e830bdc5dfd) --- source4/pidl/lib/Parse/Pidl/Compat.pm | 7 ------- source4/pidl/lib/Parse/Pidl/NDR.pm | 10 ++-------- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 2 +- source4/pidl/lib/Parse/Pidl/Typelist.pm | 5 +---- 5 files changed, 5 insertions(+), 21 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Compat.pm b/source4/pidl/lib/Parse/Pidl/Compat.pm index f1241ef341..7939bb2df2 100644 --- a/source4/pidl/lib/Parse/Pidl/Compat.pm +++ b/source4/pidl/lib/Parse/Pidl/Compat.pm @@ -152,13 +152,6 @@ sub CheckInterface($) $if->{PROPERTIES}->{pointer_default_top} ne "ref") { warning($if, "pointer_default_top() is pidl-specific"); } - - foreach my $x (@{$if->{DATA}}) { - if ($x->{TYPE} eq "DECLARE") { - warning($if, "the declare keyword is pidl-specific"); - next; - } - } } sub Check($) diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index f624d2bdc0..8e7cf40d90 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -287,8 +287,6 @@ sub can_contain_deferred($) return 0 if (Parse::Pidl::Typelist::is_scalar($type)); - return 1 if ($type->{TYPE} eq "DECLARE"); # assume the worst - return can_contain_deferred($type->{DATA}) if ($type->{TYPE} eq "TYPEDEF"); return 0 unless defined($type->{ELEMENTS}); @@ -362,7 +360,7 @@ sub align_type($) my $dt = getType($e); - if ($dt->{TYPE} eq "TYPEDEF" or $dt->{TYPE} eq "DECLARE") { + if ($dt->{TYPE} eq "TYPEDEF") { return align_type($dt->{DATA}); } elsif ($dt->{TYPE} eq "ENUM") { return align_type(Parse::Pidl::Typelist::enum_type_fn($dt)); @@ -650,7 +648,6 @@ sub ParseInterface($) my @consts = (); my @functions = (); my @endpoints; - my @declares = (); my $opnum = 0; my $version; @@ -667,9 +664,7 @@ sub ParseInterface($) } foreach my $d (@{$idl->{DATA}}) { - if ($d->{TYPE} eq "DECLARE") { - push (@declares, $d); - } elsif ($d->{TYPE} eq "FUNCTION") { + if ($d->{TYPE} eq "FUNCTION") { push (@functions, ParseFunction($idl, $d, \$opnum)); } elsif ($d->{TYPE} eq "CONST") { push (@consts, ParseConst($idl, $d)); @@ -701,7 +696,6 @@ sub ParseInterface($) FUNCTIONS => \@functions, CONSTS => \@consts, TYPES => \@types, - DECLARES => \@declares, ENDPOINTS => \@endpoints }; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 36cc469ff6..fa0c97961c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -860,7 +860,7 @@ sub TypeFunctionName($$) my ($prefix, $t) = @_; return "$prefix\_$t->{NAME}" if (ref($t) eq "HASH" and - ($t->{TYPE} eq "TYPEDEF" or $t->{TYPE} eq "DECLARE")); + $t->{TYPE} eq "TYPEDEF"); return "$prefix\_$t->{TYPE}_$t->{NAME}" if (ref($t) eq "HASH"); return "$prefix\_$t"; } diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index a261910c17..abbfe2259b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2723,7 +2723,7 @@ sub TypeFunctionName($$) my ($prefix, $t) = @_; return "$prefix\_$t->{NAME}" if (ref($t) eq "HASH" and - ($t->{TYPE} eq "TYPEDEF" or $t->{TYPE} eq "DECLARE")); + $t->{TYPE} eq "TYPEDEF"); return "$prefix\_$t->{TYPE}_$t->{NAME}" if (ref($t) eq "HASH"); return "$prefix\_$t"; } diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index b2069c784b..8fb7448070 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -138,8 +138,7 @@ sub is_scalar($) return 1 if (ref($type) eq "HASH" and $type->{TYPE} eq "SCALAR"); if (my $dt = getType($type)) { - return is_scalar($dt->{DATA}) if ($dt->{TYPE} eq "TYPEDEF" or - $dt->{TYPE} eq "DECLARE"); + return is_scalar($dt->{DATA}) if ($dt->{TYPE} eq "TYPEDEF"); return 1 if ($dt->{TYPE} eq "SCALAR" or $dt->{TYPE} eq "ENUM" or $dt->{TYPE} eq "BITMAP"); } @@ -214,7 +213,6 @@ sub mapType($$) my ($t, $n) = @_; return mapType($t->{DATA}, $n) if ($t->{TYPE} eq "TYPEDEF"); - return mapType($t->{DATA}, $n) if ($t->{TYPE} eq "DECLARE"); return mapScalarType($n) if ($t->{TYPE} eq "SCALAR"); return "enum $n" if ($t->{TYPE} eq "ENUM"); return "struct $n" if ($t->{TYPE} eq "STRUCT"); @@ -248,7 +246,6 @@ sub LoadIdl($) foreach my $y (@{$x->{DATA}}) { addType($y) if ( $y->{TYPE} eq "TYPEDEF" - or $y->{TYPE} eq "DECLARE" or $y->{TYPE} eq "UNION" or $y->{TYPE} eq "STRUCT" or $y->{TYPE} eq "ENUM" -- cgit From 1b906190091718eb16ea3754c671ebccb78a0b33 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 12 Jan 2008 21:21:14 +0100 Subject: pidl: Remove declare tests, add more tests for typedef. (This used to be commit 254bf85c2eb69fc2ee22d3a92a6b027a25594250) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 150 ++++++++++++++++++------------------- source4/pidl/lib/Parse/Pidl/NDR.pm | 6 +- 2 files changed, 80 insertions(+), 76 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 5956c43e43..35e1d7bcd7 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -1744,43 +1744,43 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "pidl/idl.yp" +#line 19 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "pidl/idl.yp" +#line 20 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'idl', 2, sub -#line 21 "pidl/idl.yp" +#line 21 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 5 'idl', 2, sub -#line 22 "pidl/idl.yp" +#line 22 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 6 'idl', 2, sub -#line 23 "pidl/idl.yp" +#line 23 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'idl', 2, sub -#line 24 "pidl/idl.yp" +#line 24 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 8 'import', 3, sub -#line 27 "pidl/idl.yp" +#line 27 "idl.yp" {{ "TYPE" => "IMPORT", "PATHS" => $_[2], @@ -1791,7 +1791,7 @@ sub [#Rule 9 'include', 3, sub -#line 34 "pidl/idl.yp" +#line 34 "idl.yp" {{ "TYPE" => "INCLUDE", "PATHS" => $_[2], @@ -1802,7 +1802,7 @@ sub [#Rule 10 'importlib', 3, sub -#line 41 "pidl/idl.yp" +#line 41 "idl.yp" {{ "TYPE" => "IMPORTLIB", "PATHS" => $_[2], @@ -1813,19 +1813,19 @@ sub [#Rule 11 'commalist', 1, sub -#line 50 "pidl/idl.yp" +#line 50 "idl.yp" { [ $_[1] ] } ], [#Rule 12 'commalist', 3, sub -#line 51 "pidl/idl.yp" +#line 51 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 13 'coclass', 7, sub -#line 55 "pidl/idl.yp" +#line 55 "idl.yp" {{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -1841,13 +1841,13 @@ sub [#Rule 15 'interface_names', 4, sub -#line 67 "pidl/idl.yp" +#line 67 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 16 'interface', 7, sub -#line 71 "pidl/idl.yp" +#line 71 "idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -1860,7 +1860,7 @@ sub [#Rule 17 'cpp_quote', 4, sub -#line 82 "pidl/idl.yp" +#line 82 "idl.yp" {{ "TYPE" => "CPP_QUOTE", "FILE" => $_[0]->YYData->{FILE}, @@ -1871,13 +1871,13 @@ sub [#Rule 18 'definitions', 1, sub -#line 91 "pidl/idl.yp" +#line 91 "idl.yp" { [ $_[1] ] } ], [#Rule 19 'definitions', 2, sub -#line 92 "pidl/idl.yp" +#line 92 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 20 @@ -1895,7 +1895,7 @@ sub [#Rule 24 'const', 7, sub -#line 100 "pidl/idl.yp" +#line 100 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1909,7 +1909,7 @@ sub [#Rule 25 'const', 8, sub -#line 110 "pidl/idl.yp" +#line 110 "idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1924,7 +1924,7 @@ sub [#Rule 26 'function', 7, sub -#line 124 "pidl/idl.yp" +#line 124 "idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -1938,7 +1938,7 @@ sub [#Rule 27 'typedef', 6, sub -#line 136 "pidl/idl.yp" +#line 136 "idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[1], @@ -1964,7 +1964,7 @@ sub [#Rule 32 'typedecl', 2, sub -#line 149 "pidl/idl.yp" +#line 149 "idl.yp" { $_[1] } ], [#Rule 33 @@ -1976,7 +1976,7 @@ sub [#Rule 35 'existingtype', 2, sub -#line 154 "pidl/idl.yp" +#line 154 "idl.yp" { ($_[1]?$_[1]:"signed") ." $_[2]" } ], [#Rule 36 @@ -1991,13 +1991,13 @@ sub [#Rule 39 'type', 1, sub -#line 158 "pidl/idl.yp" +#line 158 "idl.yp" { "void" } ], [#Rule 40 'enum_body', 3, sub -#line 160 "pidl/idl.yp" +#line 160 "idl.yp" { $_[2] } ], [#Rule 41 @@ -2009,7 +2009,7 @@ sub [#Rule 43 'enum', 4, sub -#line 163 "pidl/idl.yp" +#line 163 "idl.yp" {{ "TYPE" => "ENUM", "PROPERTIES" => $_[1], @@ -2020,13 +2020,13 @@ sub [#Rule 44 'enum_elements', 1, sub -#line 172 "pidl/idl.yp" +#line 172 "idl.yp" { [ $_[1] ] } ], [#Rule 45 'enum_elements', 3, sub -#line 173 "pidl/idl.yp" +#line 173 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 46 @@ -2035,13 +2035,13 @@ sub [#Rule 47 'enum_element', 3, sub -#line 177 "pidl/idl.yp" +#line 177 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 48 'bitmap_body', 3, sub -#line 180 "pidl/idl.yp" +#line 180 "idl.yp" { $_[2] } ], [#Rule 49 @@ -2053,7 +2053,7 @@ sub [#Rule 51 'bitmap', 4, sub -#line 183 "pidl/idl.yp" +#line 183 "idl.yp" {{ "TYPE" => "BITMAP", "PROPERTIES" => $_[1], @@ -2064,13 +2064,13 @@ sub [#Rule 52 'bitmap_elements', 1, sub -#line 192 "pidl/idl.yp" +#line 192 "idl.yp" { [ $_[1] ] } ], [#Rule 53 'bitmap_elements', 3, sub -#line 193 "pidl/idl.yp" +#line 193 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 54 @@ -2082,13 +2082,13 @@ sub [#Rule 56 'bitmap_element', 3, sub -#line 198 "pidl/idl.yp" +#line 198 "idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 57 'struct_body', 3, sub -#line 201 "pidl/idl.yp" +#line 201 "idl.yp" { $_[2] } ], [#Rule 58 @@ -2100,7 +2100,7 @@ sub [#Rule 60 'struct', 4, sub -#line 205 "pidl/idl.yp" +#line 205 "idl.yp" {{ "TYPE" => "STRUCT", "PROPERTIES" => $_[1], @@ -2111,7 +2111,7 @@ sub [#Rule 61 'empty_element', 2, sub -#line 214 "pidl/idl.yp" +#line 214 "idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2131,7 +2131,7 @@ sub [#Rule 64 'optional_base_element', 2, sub -#line 228 "pidl/idl.yp" +#line 228 "idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 65 @@ -2140,13 +2140,13 @@ sub [#Rule 66 'union_elements', 2, sub -#line 233 "pidl/idl.yp" +#line 233 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 67 'union_body', 3, sub -#line 236 "pidl/idl.yp" +#line 236 "idl.yp" { $_[2] } ], [#Rule 68 @@ -2158,7 +2158,7 @@ sub [#Rule 70 'union', 4, sub -#line 240 "pidl/idl.yp" +#line 240 "idl.yp" {{ "TYPE" => "UNION", "PROPERTIES" => $_[1], @@ -2169,7 +2169,7 @@ sub [#Rule 71 'base_element', 5, sub -#line 249 "pidl/idl.yp" +#line 249 "idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2183,25 +2183,25 @@ sub [#Rule 72 'pointers', 0, sub -#line 263 "pidl/idl.yp" +#line 263 "idl.yp" { 0 } ], [#Rule 73 'pointers', 2, sub -#line 264 "pidl/idl.yp" +#line 264 "idl.yp" { $_[1]+1 } ], [#Rule 74 'element_list1', 0, sub -#line 268 "pidl/idl.yp" +#line 268 "idl.yp" { [] } ], [#Rule 75 'element_list1', 3, sub -#line 269 "pidl/idl.yp" +#line 269 "idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 76 @@ -2213,13 +2213,13 @@ sub [#Rule 78 'element_list2', 1, sub -#line 275 "pidl/idl.yp" +#line 275 "idl.yp" { [ $_[1] ] } ], [#Rule 79 'element_list2', 3, sub -#line 276 "pidl/idl.yp" +#line 276 "idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 80 @@ -2228,13 +2228,13 @@ sub [#Rule 81 'array_len', 3, sub -#line 281 "pidl/idl.yp" +#line 281 "idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 82 'array_len', 4, sub -#line 282 "pidl/idl.yp" +#line 282 "idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 83 @@ -2243,31 +2243,31 @@ sub [#Rule 84 'property_list', 4, sub -#line 288 "pidl/idl.yp" +#line 288 "idl.yp" { FlattenHash([$_[1],$_[3]]); } ], [#Rule 85 'properties', 1, sub -#line 291 "pidl/idl.yp" +#line 291 "idl.yp" { $_[1] } ], [#Rule 86 'properties', 3, sub -#line 292 "pidl/idl.yp" +#line 292 "idl.yp" { FlattenHash([$_[1], $_[3]]); } ], [#Rule 87 'property', 1, sub -#line 295 "pidl/idl.yp" +#line 295 "idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 88 'property', 4, sub -#line 296 "pidl/idl.yp" +#line 296 "idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 89 @@ -2276,7 +2276,7 @@ sub [#Rule 90 'listtext', 3, sub -#line 301 "pidl/idl.yp" +#line 301 "idl.yp" { "$_[1] $_[3]" } ], [#Rule 91 @@ -2285,13 +2285,13 @@ sub [#Rule 92 'commalisttext', 3, sub -#line 306 "pidl/idl.yp" +#line 306 "idl.yp" { "$_[1],$_[3]" } ], [#Rule 93 'anytext', 0, sub -#line 310 "pidl/idl.yp" +#line 310 "idl.yp" { "" } ], [#Rule 94 @@ -2306,91 +2306,91 @@ sub [#Rule 97 'anytext', 3, sub -#line 312 "pidl/idl.yp" +#line 312 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 98 'anytext', 3, sub -#line 313 "pidl/idl.yp" +#line 313 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 99 'anytext', 3, sub -#line 314 "pidl/idl.yp" +#line 314 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 100 'anytext', 3, sub -#line 315 "pidl/idl.yp" +#line 315 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 101 'anytext', 3, sub -#line 316 "pidl/idl.yp" +#line 316 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 102 'anytext', 3, sub -#line 317 "pidl/idl.yp" +#line 317 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 103 'anytext', 3, sub -#line 318 "pidl/idl.yp" +#line 318 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 104 'anytext', 3, sub -#line 319 "pidl/idl.yp" +#line 319 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 105 'anytext', 3, sub -#line 320 "pidl/idl.yp" +#line 320 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 106 'anytext', 3, sub -#line 321 "pidl/idl.yp" +#line 321 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 322 "pidl/idl.yp" +#line 322 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 'anytext', 3, sub -#line 323 "pidl/idl.yp" +#line 323 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 109 'anytext', 3, sub -#line 324 "pidl/idl.yp" +#line 324 "idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 110 'anytext', 5, sub -#line 325 "pidl/idl.yp" +#line 325 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 111 'anytext', 5, sub -#line 326 "pidl/idl.yp" +#line 326 "idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], [#Rule 112 @@ -2408,7 +2408,7 @@ sub [#Rule 116 'text', 1, sub -#line 340 "pidl/idl.yp" +#line 340 "idl.yp" { "\"$_[1]\"" } ], [#Rule 117 @@ -2422,7 +2422,7 @@ sub bless($self,$class); } -#line 351 "pidl/idl.yp" +#line 351 "idl.yp" use Parse::Pidl qw(error); diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 8e7cf40d90..80ecec938a 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -352,9 +352,11 @@ sub align_type($) return $scalar_alignment->{$e->{NAME}}; } + return 0 if ($e eq "EMPTY"); + unless (hasType($e)) { # it must be an external type - all we can do is guess - # print "Warning: assuming alignment of unknown type '$e' is 4\n"; + # warning($e, "assuming alignment of unknown type '$e' is 4"); return 4; } @@ -367,6 +369,8 @@ sub align_type($) } elsif ($dt->{TYPE} eq "BITMAP") { return align_type(Parse::Pidl::Typelist::bitmap_type_fn($dt)); } elsif (($dt->{TYPE} eq "STRUCT") or ($dt->{TYPE} eq "UNION")) { + # Struct/union without body: assume 4 + return 4 unless (defined($dt->{ELEMENTS})); return find_largest_alignment($dt); } -- cgit From 97ad5d5d80d0967c3ca7dbcd424883d3ad613138 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 12 Jan 2008 22:15:12 +0100 Subject: pidl: Add ability to write type metadata to a file. (This used to be commit e8ab241ff47f2c3e6f80f9c62373139e4c9f5a1e) --- source4/pidl/lib/Parse/Pidl/Typelist.pm | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 8fb7448070..3721800b97 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -238,7 +238,7 @@ sub mapTypeName($) sub LoadIdl($) { - my $idl = shift; + my ($idl) = @_; foreach my $x (@{$idl}) { next if $x->{TYPE} ne "INTERFACE"; @@ -254,6 +254,11 @@ sub LoadIdl($) } } +sub GenerateTypeLib() +{ + return Parse::Pidl::Util::MyDumper(\%types); +} + RegisterScalars(); 1; -- cgit From 90198fa7ca83b41516ac5bea014ae0396a1d128f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 12 Jan 2008 22:35:28 +0100 Subject: pidl: Prevent empty declarations for enums without body. (This used to be commit c1e0570506d7c77112065a03a876cda4e4db7769) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 7a6ffa46d6..9e27719d51 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -108,25 +108,28 @@ sub HeaderEnum($$) my $first = 1; pidl "#ifndef USE_UINT_ENUMS\n"; - pidl "enum $name {\n"; - $tab_depth++; + pidl "enum $name"; if (defined($enum->{ELEMENTS})) { + pidl " {\n"; + $tab_depth++; foreach my $e (@{$enum->{ELEMENTS}}) { unless ($first) { pidl ",\n"; } $first = 0; pidl tabs(); pidl $e; } + pidl "\n"; + $tab_depth--; + pidl "}"; } pidl "\n"; - $tab_depth--; - pidl "}\n"; pidl "#else\n"; my $count = 0; - pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF}\n"; + pidl "enum $name"; my $with_val = 0; my $without_val = 0; if (defined($enum->{ELEMENTS})) { + pidl " { __donnot_use_enum_$name=0x7FFFFFFF}"; foreach my $e (@{$enum->{ELEMENTS}}) { my $t = "$e"; my $name; @@ -144,9 +147,10 @@ sub HeaderEnum($$) fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") unless ($with_val == 0); } - pidl "#define $name ( $value )\n"; + pidl "\n#define $name ( $value )"; } } + pidl "\n"; pidl "#endif\n"; } @@ -215,7 +219,7 @@ sub HeaderType($$$) sub HeaderTypedef($) { my($typedef) = shift; - HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}); + HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}) if defined ($typedef->{DATA}); } ##################################################################### -- cgit From 532154af9bebbdf76b2f62ee2b0810e66bc431c7 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 12 Jan 2008 23:06:00 +0100 Subject: pidl: Move more stuff outside ifdef when defining enums and generate pretty code for enums without body. (This used to be commit d91af936ae51e33c8598d88c77575abbeb0e556b) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 56 ++++++++++++++-------------- 1 file changed, 27 insertions(+), 29 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 9e27719d51..b96a58783c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -107,9 +107,9 @@ sub HeaderEnum($$) my($enum,$name) = @_; my $first = 1; - pidl "#ifndef USE_UINT_ENUMS\n"; pidl "enum $name"; if (defined($enum->{ELEMENTS})) { + pidl "\n#ifndef USE_UINT_ENUMS\n"; pidl " {\n"; $tab_depth++; foreach my $e (@{$enum->{ELEMENTS}}) { @@ -121,37 +121,35 @@ sub HeaderEnum($$) pidl "\n"; $tab_depth--; pidl "}"; - } - pidl "\n"; - pidl "#else\n"; - my $count = 0; - pidl "enum $name"; - my $with_val = 0; - my $without_val = 0; - if (defined($enum->{ELEMENTS})) { - pidl " { __donnot_use_enum_$name=0x7FFFFFFF}"; - foreach my $e (@{$enum->{ELEMENTS}}) { - my $t = "$e"; - my $name; - my $value; - if ($t =~ /(.*)=(.*)/) { - $name = $1; - $value = $2; - $with_val = 1; - fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") - unless ($without_val == 0); - } else { - $name = $t; - $value = $count++; - $without_val = 1; - fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") - unless ($with_val == 0); + pidl "\n"; + pidl "#else\n"; + my $count = 0; + my $with_val = 0; + my $without_val = 0; + if (defined($enum->{ELEMENTS})) { + pidl " { __donnot_use_enum_$name=0x7FFFFFFF}\n"; + foreach my $e (@{$enum->{ELEMENTS}}) { + my $t = "$e"; + my $name; + my $value; + if ($t =~ /(.*)=(.*)/) { + $name = $1; + $value = $2; + $with_val = 1; + fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") + unless ($without_val == 0); + } else { + $name = $t; + $value = $count++; + $without_val = 1; + fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") + unless ($with_val == 0); + } + pidl "#define $name ( $value )\n"; } - pidl "\n#define $name ( $value )"; } + pidl "#endif\n"; } - pidl "\n"; - pidl "#endif\n"; } ##################################################################### -- cgit From ad559581406313741276e39cf0d28b4d3acdaab1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 12 Jan 2008 23:10:28 +0100 Subject: pidl: Add function for determining whether a type has a body. (This used to be commit 893f4102c93c1c2cd6b836f12644d06d9e31800c) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 3 ++- source4/pidl/lib/Parse/Pidl/Typelist.pm | 15 ++++++++++++++- 3 files changed, 17 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 80ecec938a..1d059ebdf7 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -633,7 +633,7 @@ sub FindNestedTypes($$) sub FindNestedTypes($$); my ($l, $t) = @_; - return if not defined($t->{ELEMENTS}); + return unless defined($t->{ELEMENTS}); return if ($t->{TYPE} eq "ENUM"); return if ($t->{TYPE} eq "BITMAP"); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index abbfe2259b..cfd16c7b40 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -12,7 +12,7 @@ require Exporter; @EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint); use strict; -use Parse::Pidl::Typelist qw(hasType getType mapTypeName); +use Parse::Pidl::Typelist qw(hasType getType mapTypeName typeHasBody); use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid); use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); @@ -2543,6 +2543,7 @@ sub ParseInterface($$$) # Typedefs foreach my $d (@{$interface->{TYPES}}) { + next unless typeHasBody($d); ($needed->{TypeFunctionName("ndr_push", $d)}) && $self->ParseTypePushFunction($d, "r"); ($needed->{TypeFunctionName("ndr_pull", $d)}) && $self->ParseTypePullFunction($d, "r"); ($needed->{TypeFunctionName("ndr_print", $d)}) && $self->ParseTypePrintFunction($d, "r"); diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 3721800b97..aad0cf426c 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -9,7 +9,7 @@ require Exporter; @ISA = qw(Exporter); @EXPORT_OK = qw(hasType getType mapTypeName scalar_is_reference expandAlias mapScalarType addType typeIs is_scalar enum_type_fn - bitmap_type_fn mapType + bitmap_type_fn mapType typeHasBody ); use vars qw($VERSION); $VERSION = '0.01'; @@ -207,6 +207,19 @@ sub bitmap_type_fn($) return "uint32"; } +sub typeHasBody($) +{ + sub typeHasBody($); + my ($e) = @_; + + if ($e->{TYPE} eq "TYPEDEF") { + return 0 unless(defined($e->{DATA})); + return typeHasBody($e->{DATA}); + } + + return defined($e->{ELEMENTS}); +} + sub mapType($$) { sub mapType($$); -- cgit From 3f9812f951bb110700077503a96b9d7d8cfdb2dc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 12 Jan 2008 23:38:05 +0100 Subject: pidl/ejs: Fix bug that filled in the body for types without body. (This used to be commit 4f4dfa6042178c157a09df61d72a42af7aa5c67b) --- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 10 +++++++--- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 3 ++- 2 files changed, 9 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index fa0c97961c..24270340b9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -11,7 +11,7 @@ use Exporter; @EXPORT_OK = qw(check_null_pointer fn_declare TypeFunctionName); use strict; -use Parse::Pidl::Typelist; +use Parse::Pidl::Typelist qw(typeHasBody); use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel); @@ -274,6 +274,7 @@ sub EjsUnionPull($$$) sub EjsEnumConstant($$) { my ($self, $d) = @_; + return unless (defined($d->{ELEMENTS})); my $v = 0; foreach my $e (@{$d->{ELEMENTS}}) { my $el = $e; @@ -572,6 +573,7 @@ sub EjsEnumPush($$$) sub EjsBitmapPush($$$) { my ($self, $d, $varname) = @_; + return unless (defined($d->{ELEMENTS})); my $type_fn = $d->{BASE_TYPE}; # put the bitmap elements in the constants array foreach my $e (@{$d->{ELEMENTS}}) { @@ -710,6 +712,7 @@ sub EjsInterface($$$) $self->pidl_hdr("\n"); foreach my $d (@{$interface->{TYPES}}) { + next unless (typeHasBody($d)); ($needed->{TypeFunctionName("ejs_push", $d)}) && $self->EjsTypePushFunction($d, $d->{NAME}); ($needed->{TypeFunctionName("ejs_pull", $d)}) && $self->EjsTypePullFunction($d, $d->{NAME}); } @@ -823,8 +826,9 @@ sub NeededType($$$) NeededType($t->{DATA}, $needed, $req) if ($t->{TYPE} eq "TYPEDEF"); - return if (($t->{TYPE} ne "STRUCT") and - ($t->{TYPE} ne "UNION")); + return unless (($t->{TYPE} eq "STRUCT") or ($t->{TYPE} eq "UNION")); + + return unless(typeHasBody($t)); foreach (@{$t->{ELEMENTS}}) { next if (has_property($_, "subcontext")); #FIXME: Support subcontexts diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index cfd16c7b40..451e899ffb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2543,7 +2543,8 @@ sub ParseInterface($$$) # Typedefs foreach my $d (@{$interface->{TYPES}}) { - next unless typeHasBody($d); + next unless(typeHasBody($d)); + ($needed->{TypeFunctionName("ndr_push", $d)}) && $self->ParseTypePushFunction($d, "r"); ($needed->{TypeFunctionName("ndr_pull", $d)}) && $self->ParseTypePullFunction($d, "r"); ($needed->{TypeFunctionName("ndr_print", $d)}) && $self->ParseTypePrintFunction($d, "r"); -- cgit From b36a0aedd2dbe47429bfc2dda6ea802a92efb526 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 00:05:24 +0100 Subject: pidl: Avoid accidently filling in empty body for types without body. (This used to be commit 1fe5c1ad07c574dc094f59f728025dfcafa0cf22) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 1 + source4/pidl/lib/Parse/Pidl/Typelist.pm | 6 ++++-- 2 files changed, 5 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 451e899ffb..8eb2f9ad15 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2688,6 +2688,7 @@ sub NeededType($$$) NeededType($t->{DATA}, $needed, $req) if ($t->{TYPE} eq "TYPEDEF"); if ($t->{TYPE} eq "STRUCT" or $t->{TYPE} eq "UNION") { + return unless defined($t->{ELEMENTS}); for my $e (@{$t->{ELEMENTS}}) { $e->{PARENT} = $t; if (has_property($e, "compression")) { diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index aad0cf426c..e54ef11b88 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -135,7 +135,9 @@ sub is_scalar($) sub is_scalar($); my $type = shift; - return 1 if (ref($type) eq "HASH" and $type->{TYPE} eq "SCALAR"); + return 1 if (ref($type) eq "HASH" and + ($type->{TYPE} eq "SCALAR" or $type->{TYPE} eq "ENUM" or + $type->{TYPE} eq "BITMAP")); if (my $dt = getType($type)) { return is_scalar($dt->{DATA}) if ($dt->{TYPE} eq "TYPEDEF"); @@ -149,7 +151,7 @@ sub is_scalar($) sub scalar_is_reference($) { my $name = shift; - + return 1 if (grep(/^$name$/, @reference_scalars)); return 0; } -- cgit From 83c56f2118393e142021e232f7731e4622d2dfb3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 18:11:45 +0100 Subject: python/pidl: More work on wrapping enums, bitmaps and structs. (This used to be commit 732c3453f0784d5052705b00735b750809afce61) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 102 ++++++++++++++++++++------- 1 file changed, 76 insertions(+), 26 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 8effff9d5e..7c379548ed 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -9,7 +9,7 @@ use Exporter; @ISA = qw(Exporter); use strict; -use Parse::Pidl::Typelist; +use Parse::Pidl::Typelist qw(hasType getType mapTypeName); use Parse::Pidl::Util qw(has_property ParseExpr); use vars qw($VERSION); @@ -17,7 +17,8 @@ $VERSION = '0.01'; sub new($) { my ($class) = @_; - my $self = { res => "", res_hdr => "", tabs => "", constants => {}}; + my $self = { res => "", res_hdr => "", tabs => "", constants => {}, + module_methods => []}; bless($self, $class); } @@ -63,7 +64,26 @@ sub Import sub Const($$) { my ($self, $const) = @_; - $self->{constants}->{$const->{NAME}} = [$const->{DATA}->{TYPE}, $const->{VALUE}]; + $self->register_constant($const->{NAME}, $const->{DATA}->{TYPE}, $const->{VALUE}); +} + +sub register_constant($$$$) +{ + my ($self, $name, $type, $value) = @_; + + $self->{constants}->{$name} = [$type, $value]; +} + +sub EnumAndBitmapConsts($$$) +{ + my ($self, $name, $d) = @_; + + foreach my $e (@{$d->{ELEMENTS}}) { + $e =~ /^([A-Za-z0-9_]+)=(.*)$/; + my $cname = $1; + + $self->register_constant($cname, $d, $cname); + } } sub FromTypeToPythonFunction($$) @@ -97,6 +117,8 @@ sub TypeConstructor($$) $self->pidl("static PyObject *py_$type->{NAME}_getattr(PyTypeObject *obj, char *name)"); $self->pidl("{"); $self->indent; + $self->pidl("$type->{NAME}_Object *py_object = ($type->{NAME}_Object *)obj;"); + $self->pidl(mapTypeName($type) . " *object = talloc_get_type(py_object->object, ".mapTypeName($type).");"); $self->pidl("return Py_None;"); $self->deindent; $self->pidl("}"); @@ -115,6 +137,8 @@ sub TypeConstructor($$) $self->pidl("static PyObject *py_$type->{NAME}_setattr(PyTypeObject *obj, char *name, PyObject *value)"); $self->pidl("{"); $self->indent; + $self->pidl("$type->{NAME}_Object *py_object = ($type->{NAME}_Object *)obj;"); + $self->pidl(mapTypeName($type) . " *object = talloc_get_type(py_object->object, ".mapTypeName($type).");"); $self->pidl("return Py_None;"); $self->deindent; $self->pidl("}"); @@ -133,7 +157,8 @@ sub TypeConstructor($$) $self->pidl(""); - $self->pidl("static PyObject *py_$type->{NAME}(PyObject *self, PyObject *args)"); + my $py_fnname = "py_$type->{NAME}"; + $self->pidl("static PyObject *$py_fnname(PyObject *self, PyObject *args)"); $self->pidl("{"); $self->indent; $self->pidl("$type->{NAME}\_Object *ret;"); @@ -142,6 +167,8 @@ sub TypeConstructor($$) $self->deindent; $self->pidl("}"); $self->pidl(""); + + return $py_fnname; } sub PythonFunction($$$) @@ -175,9 +202,36 @@ sub handle_ntstatus($$$) $self->pidl(""); } -sub Interface($$) +sub PythonType($$$) { - my($self,$interface) = @_; + my ($self, $d, $interface, $basename) = @_; + + if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "TYPEDEF" and + $d->{DATA}->{TYPE} eq "STRUCT") { + $self->FromTypeToPythonFunction($d); + $self->FromPythonToTypeFunction($d); + my $py_fnname = $self->TypeConstructor($d); + + my $fn_name = $d->{NAME}; + + $fn_name =~ s/^$interface->{NAME}_//; + $fn_name =~ s/^$basename\_//; + + $self->register_module_method($fn_name, $py_fnname, "METH_VARARGS|METH_KEYWORDS", "NULL"); + } + + if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") { + $self->EnumAndBitmapConsts($d->{NAME}, $d); + } + + if ($d->{TYPE} eq "TYPEDEF" and ($d->{DATA}->{TYPE} eq "ENUM" or $d->{DATA}->{TYPE} eq "BITMAP")) { + $self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA}); + } +} + +sub Interface($$$) +{ + my($self,$interface,$basename) = @_; $self->pidl_hdr("#ifndef _HEADER_PYTHON_$interface->{NAME}\n"); $self->pidl_hdr("#define _HEADER_PYTHON_$interface->{NAME}\n\n"); @@ -186,10 +240,10 @@ sub Interface($$) $self->Const($_) foreach (@{$interface->{CONSTS}}); - foreach (@{$interface->{TYPES}}) { - $self->FromTypeToPythonFunction($_); - $self->FromPythonToTypeFunction($_); - $self->TypeConstructor($_); + foreach my $d (@{$interface->{TYPES}}) { + next if has_property($d, "nopython"); + + $self->PythonType($d, $interface, $basename); } $self->pidl("staticforward PyTypeObject $interface->{NAME}_InterfaceType;"); @@ -257,6 +311,7 @@ sub Interface($$) $self->pidl(""); + $self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL"); $self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args)"); $self->pidl("{"); $self->indent; @@ -285,6 +340,13 @@ sub Interface($$) $self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n"); } +sub register_module_method($$$$$) +{ + my ($self, $fn_name, $pyfn_name, $flags, $doc) = @_; + + push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) +} + sub Parse($$$$) { my($self,$basename,$ndr,$hdr) = @_; @@ -305,27 +367,15 @@ sub Parse($$$$) "); foreach my $x (@$ndr) { - ($x->{TYPE} eq "INTERFACE") && $self->Interface($x); + ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename); ($x->{TYPE} eq "IMPORT") && $self->Import(@{$x->{PATHS}}); } $self->pidl("static PyMethodDef $basename\_methods[] = {"); $self->indent; - foreach my $x (@$ndr) { - next if ($x->{TYPE} ne "INTERFACE"); - $self->pidl("{ \"$x->{NAME}\", (PyCFunction)interface_$x->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); - - foreach my $d (@{$x->{TYPES}}) { - next if has_property($d, "nopython"); - next if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP"); - - my $fn_name = $d->{NAME}; - - $fn_name =~ s/^$x->{NAME}_//; - $fn_name =~ s/^$basename\_//; - - $self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); - } + foreach (@{$self->{module_methods}}) { + my ($fn_name, $pyfn_name, $flags, $doc) = @$_; + $self->pidl("{ \"$fn_name\", (PyCFunction)$pyfn_name, $flags, $doc },"); } $self->pidl("{ NULL, NULL, 0, NULL }"); -- cgit From 7aa0f25d7f0a8a1eac19c886477b13ab00bd76fe Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 18:27:47 +0100 Subject: python/pidl: Handle non-string types. (This used to be commit 02dd02c529d578ad7fa4a6b825097685555604fe) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 7c379548ed..5077102fc7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -347,6 +347,24 @@ sub register_module_method($$$$$) push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) } +sub ConvertObjectToPython($$$) +{ + my ($self, $ctype, $cvar) = @_; + + if ($cvar =~ /^".*"$/) { + return "PyString_FromString($cvar)"; + } + + if ($cvar =~ /^[0-9]+$/ or + $ctype->{TYPE} eq "ENUM" or $ctype->{TYPE} eq "BITMAP" or + $ctype->{TYPE} eq "TYPEDEF" and + ($ctype->{TYPE} eq "ENUM" or $ctype->{TYPE} eq "BITMAP")) { + return "PyInt_FromLong($cvar)"; + } + + die("Unknown type for ".mapTypeName($ctype).": $cvar"); +} + sub Parse($$$$) { my($self,$basename,$ndr,$hdr) = @_; @@ -391,7 +409,7 @@ sub Parse($$$$) $self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);"); foreach (keys %{$self->{constants}}) { # FIXME: Handle non-string constants - $self->pidl("PyModule_AddObject(m, \"$_\", PyString_FromString(" . $self->{constants}->{$_}->[1] . "));"); + $self->pidl("PyModule_AddObject(m, \"$_\", " . $self->ConvertObjectToPython($self->{constants}->{$_}->[0], $self->{constants}->{$_}->[1]) . ");"); } $self->deindent; $self->pidl("}"); -- cgit From f71df735556947f70c6a14bf9588988d0f6adfe3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 20:00:46 +0100 Subject: python/pidl: Start wrapping function arguments. (This used to be commit c2595d3754db4d03bafd53b6f62158516493657e) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 198 ++++++++++++++++++++++----- 1 file changed, 160 insertions(+), 38 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 5077102fc7..6b4b41f74f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -86,83 +86,121 @@ sub EnumAndBitmapConsts($$$) } } -sub FromTypeToPythonFunction($$) +sub FromUnionToPythonFunction($$) { my ($self, $type) = @_; #FIXME + + $self->pidl("return NULL;"); } -sub FromPythonToTypeFunction($$) +sub FromStructToPythonFunction($$) { my ($self, $type) = @_; #FIXME + $self->pidl("return NULL;"); } -sub TypeConstructor($$) +sub FromPythonToUnionFunction($$) { my ($self, $type) = @_; - $self->pidl("staticforward PyTypeObject $type->{NAME}_ObjectType;"); + #FIXME + $self->pidl("return NULL;"); +} + +sub FromPythonToStructFunction($$) +{ + my ($self, $type) = @_; + + #FIXME + $self->pidl("return NULL;"); +} + +sub PythonStruct($$$$) +{ + my ($self, $name, $cname, $d) = @_; + + $self->pidl("staticforward PyTypeObject $name\_ObjectType;"); $self->pidl("typedef struct {"); $self->indent; $self->pidl("PyObject_HEAD"); - $self->pidl("void *object;"); # FIXME: Use real type rather than void + $self->pidl("$cname *object;"); $self->deindent; - $self->pidl("} $type->{NAME}_Object;"); + $self->pidl("} $name\_Object;"); $self->pidl(""); - $self->pidl("static PyObject *py_$type->{NAME}_getattr(PyTypeObject *obj, char *name)"); + $self->pidl("static PyObject *py_$name\_getattr(PyTypeObject *obj, char *name)"); $self->pidl("{"); $self->indent; - $self->pidl("$type->{NAME}_Object *py_object = ($type->{NAME}_Object *)obj;"); - $self->pidl(mapTypeName($type) . " *object = talloc_get_type(py_object->object, ".mapTypeName($type).");"); - $self->pidl("return Py_None;"); + $self->pidl("$name\_Object *py_object = ($name\_Object *)obj;"); + $self->pidl("$cname *object = talloc_get_type(py_object->object, $cname);"); + foreach my $e (@{$d->{ELEMENTS}}) { + $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); + my $varname = "object->$e->{NAME}"; + $self->indent; + $self->pidl("return ".$self->ConvertObjectToPython($e->{TYPE}, $varname) . ";"); + $self->deindent; + $self->pidl("}"); + } + $self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");"); + $self->pidl("return NULL;"); $self->deindent; $self->pidl("}"); $self->pidl(""); - $self->pidl("static void py_$type->{NAME}_dealloc(PyObject* self)"); + $self->pidl("static void py_$name\_dealloc(PyObject* self)"); $self->pidl("{"); $self->indent; - $self->pidl("$type->{NAME}_Object *obj = ($type->{NAME}_Object *)self;"); + $self->pidl("$name\_Object *obj = ($name\_Object *)self;"); $self->pidl("talloc_free(obj->object);"); $self->pidl("PyObject_Del(self);"); $self->deindent; $self->pidl("}"); $self->pidl(""); - $self->pidl("static PyObject *py_$type->{NAME}_setattr(PyTypeObject *obj, char *name, PyObject *value)"); + $self->pidl("static PyObject *py_$name\_setattr(PyTypeObject *obj, char *name, PyObject *value)"); $self->pidl("{"); $self->indent; - $self->pidl("$type->{NAME}_Object *py_object = ($type->{NAME}_Object *)obj;"); - $self->pidl(mapTypeName($type) . " *object = talloc_get_type(py_object->object, ".mapTypeName($type).");"); - $self->pidl("return Py_None;"); + $self->pidl("$name\_Object *py_object = ($name\_Object *)obj;"); + $self->pidl("$cname *object = talloc_get_type(py_object->object, $cname);"); + foreach my $e (@{$d->{ELEMENTS}}) { + $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); + my $varname = "object->$e->{NAME}"; + $self->indent; + $self->pidl("/* FIXME: talloc_free($varname) if necessary */"); + $self->pidl("$varname = " . $self->ConvertObjectFromPython($e->{TYPE}, "value") . ";"); + $self->deindent; + $self->pidl("}"); + } + $self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");"); + $self->pidl("return NULL;"); $self->deindent; $self->pidl("}"); $self->pidl(""); - $self->pidl("static PyTypeObject $type->{NAME}_ObjectType = {"); + $self->pidl("static PyTypeObject $name\_ObjectType = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); - $self->pidl(".tp_name = \"$type->{NAME}\","); - $self->pidl(".tp_basicsize = sizeof($type->{NAME}_Object),"); - $self->pidl(".tp_dealloc = (destructor)py_$type->{NAME}_dealloc,"); - $self->pidl(".tp_getattr = (getattrfunc)py_$type->{NAME}_getattr,"); - $self->pidl(".tp_setattr = (setattrfunc)py_$type->{NAME}_setattr,"); + $self->pidl(".tp_name = \"$name\","); + $self->pidl(".tp_basicsize = sizeof($name\_Object),"); + $self->pidl(".tp_dealloc = (destructor)py_$name\_dealloc,"); + $self->pidl(".tp_getattr = (getattrfunc)py_$name\_getattr,"); + $self->pidl(".tp_setattr = (setattrfunc)py_$name\_setattr,"); $self->deindent; $self->pidl("};"); $self->pidl(""); - my $py_fnname = "py_$type->{NAME}"; + my $py_fnname = "py_$name"; $self->pidl("static PyObject *$py_fnname(PyObject *self, PyObject *args)"); $self->pidl("{"); $self->indent; - $self->pidl("$type->{NAME}\_Object *ret;"); - $self->pidl("ret = PyObject_New($type->{NAME}_Object, &$type->{NAME}_ObjectType);"); + $self->pidl("$name\_Object *ret;"); + $self->pidl("ret = PyObject_New($name\_Object, &$name\_ObjectType);"); $self->pidl("return (PyObject *) ret;"); $self->deindent; $self->pidl("}"); @@ -180,22 +218,51 @@ sub PythonFunction($$$) $self->indent; $self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;"); $self->pidl("NTSTATUS status;"); + $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); + $self->pidl("struct dcerpc_$fn->{NAME} r;"); + $self->pidl("PyObject *result = Py_None;"); + foreach my $e (@{$fn->{ELEMENTS}}) { + $self->pidl("PyObject *py_$e->{NAME};"); + } + if ($fn->{RETURN_TYPE}) { + $self->pidl("PyObject *py_result;"); + } $self->pidl(""); - # FIXME - $self->handle_ntstatus("status", "NULL"); - $self->pidl("return Py_None;"); + $self->pidl("ZERO_STRUCT(r.out);"); + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/in/,@{$e->{DIRECTION}})) { + $self->pidl("r.in.$e->{NAME} = " . $self->ConvertObjectFromPython($e->{TYPE}, "py_$e->{NAME}") . ";"); + } + } + $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);"); + $self->handle_ntstatus("status", "NULL", "mem_ctx"); + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep(/out/,@{$e->{DIRECTION}})) { + $self->pidl("py_$e->{NAME} = " . $self->ConvertObjectToPython($e->{TYPE}, "r.out.$e->{NAME}") . ";"); + } + } + + if ($fn->{RETURN_TYPE}) { + $self->pidl("py_result = " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ";"); + } + + $self->pidl("talloc_free(mem_ctx);"); + $self->pidl("return result;"); $self->deindent; $self->pidl("}"); $self->pidl(""); } -sub handle_ntstatus($$$) +sub handle_ntstatus($$$$) { - my ($self, $var, $retval) = @_; + my ($self, $var, $retval, $mem_ctx) = @_; $self->pidl("if (NT_STATUS_IS_ERR($var)) {"); $self->indent; $self->pidl("PyErr_SetString(PyExc_RuntimeError, nt_errstr($var));"); + $self->pidl("talloc_free($mem_ctx);") if ($mem_ctx); $self->pidl("return $retval;"); $self->deindent; $self->pidl("}"); @@ -206,11 +273,19 @@ sub PythonType($$$) { my ($self, $d, $interface, $basename) = @_; + my $actual_ctype = $d; + if ($actual_ctype->{TYPE} eq "TYPEDEF") { + $actual_ctype = $actual_ctype->{DATA}; + } + if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "TYPEDEF" and $d->{DATA}->{TYPE} eq "STRUCT") { - $self->FromTypeToPythonFunction($d); - $self->FromPythonToTypeFunction($d); - my $py_fnname = $self->TypeConstructor($d); + my $py_fnname; + if ($d->{TYPE} eq "STRUCT") { + $py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d); + } else { + $py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d->{DATA}); + } my $fn_name = $d->{NAME}; @@ -227,6 +302,26 @@ sub PythonType($$$) if ($d->{TYPE} eq "TYPEDEF" and ($d->{DATA}->{TYPE} eq "ENUM" or $d->{DATA}->{TYPE} eq "BITMAP")) { $self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA}); } + + if ($actual_ctype->{TYPE} eq "UNION" or $actual_ctype->{TYPE} eq "STRUCT") { + $self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . "*in)"); + $self->pidl("{"); + $self->indent; + $self->FromStructToPythonFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT"); + $self->FromUnionToPythonFunction($d) if ($actual_ctype->{TYPE} eq "UNION"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + + $self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)"); + $self->pidl("{"); + $self->indent; + $self->FromPythonToStructFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT"); + $self->FromPythonToUnionFunction($d) if ($actual_ctype->{TYPE} eq "UNION"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + } } sub Interface($$$) @@ -319,6 +414,7 @@ sub Interface($$$) $self->pidl("const char *binding_string;"); $self->pidl("struct cli_credentials *credentials;"); $self->pidl("struct loadparm_context *lp_ctx;"); + $self->pidl("TALLOC_CTX *mem_ctx = NULL;"); $self->pidl("NTSTATUS status;"); $self->pidl(""); @@ -328,7 +424,7 @@ sub Interface($$$) $self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, "); $self->pidl(" &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);"); - $self->handle_ntstatus("status", "NULL"); + $self->handle_ntstatus("status", "NULL", "mem_ctx"); $self->pidl("return (PyObject *)ret;"); $self->deindent; @@ -347,6 +443,13 @@ sub register_module_method($$$$$) push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) } +sub ConvertObjectFromPython($$$) +{ + my ($self, $ctype, $cvar) = @_; + + return "FIXME($cvar)"; +} + sub ConvertObjectToPython($$$) { my ($self, $ctype, $cvar) = @_; @@ -355,14 +458,33 @@ sub ConvertObjectToPython($$$) return "PyString_FromString($cvar)"; } + if (ref($ctype) ne "HASH") { + $ctype = getType($ctype); + } + + my $actual_ctype = $ctype; + if ($ctype->{TYPE} eq "TYPEDEF") { + $actual_ctype = $ctype->{DATA}; + } + if ($cvar =~ /^[0-9]+$/ or - $ctype->{TYPE} eq "ENUM" or $ctype->{TYPE} eq "BITMAP" or - $ctype->{TYPE} eq "TYPEDEF" and - ($ctype->{TYPE} eq "ENUM" or $ctype->{TYPE} eq "BITMAP")) { + $actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or + $actual_ctype->{TYPE} eq "SCALAR" and ( + $actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper)$/)) { return "PyInt_FromLong($cvar)"; } - die("Unknown type for ".mapTypeName($ctype).": $cvar"); + if ($ctype->{TYPE} eq "TYPEDEF" and ( + $actual_ctype->{TYPE} eq "STRUCT" or + $actual_ctype->{TYPE} eq "UNION")) { + return "py_import_$ctype->{NAME}($cvar)"; + } + + if ($ctype->{TYPE} eq "STRUCT" or $ctype->{TYPE} eq "UNION") { + return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)"; + } + + die("unknown type ".mapTypeName($ctype) . ": $cvar"); } sub Parse($$$$) -- cgit From 8986f3ee6f46c354fed2cce5e434dda060e6318b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 11 Jan 2008 20:37:08 +0100 Subject: pidl/python: Convert some Python objects back to C, return proper tuples in client calls. (This used to be commit 1ab617296943dc1d270cbf999dedcfb3073d3d20) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 47 +++++++++++++++++++++++----- 1 file changed, 40 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 6b4b41f74f..4454eeefd7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -1,6 +1,6 @@ ################################################### # Python function wrapper generator -# Copyright jelmer@samba.org 2007 +# Copyright jelmer@samba.org 2007-2008 # released under the GNU GPL package Parse::Pidl::Samba4::Python; @@ -11,6 +11,7 @@ use Exporter; use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName); use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::CUtil qw(get_value_of get_pointer_of); use vars qw($VERSION); $VERSION = '0.01'; @@ -220,12 +221,19 @@ sub PythonFunction($$$) $self->pidl("NTSTATUS status;"); $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); $self->pidl("struct dcerpc_$fn->{NAME} r;"); - $self->pidl("PyObject *result = Py_None;"); + $self->pidl("PyObject *result;"); + my $result_size = 0; + foreach my $e (@{$fn->{ELEMENTS}}) { - $self->pidl("PyObject *py_$e->{NAME};"); + if (grep(/in/,@{$e->{DIRECTION}})) { + $self->pidl("PyObject *py_$e->{NAME};"); + } + if (grep(/out/,@{$e->{DIRECTION}})) { + $result_size++; + } } if ($fn->{RETURN_TYPE}) { - $self->pidl("PyObject *py_result;"); + $result_size++; } $self->pidl(""); $self->pidl("ZERO_STRUCT(r.out);"); @@ -238,14 +246,20 @@ sub PythonFunction($$$) $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);"); $self->handle_ntstatus("status", "NULL", "mem_ctx"); + $self->pidl("result = PyTuple_New($result_size);"); + + my $i = 0; + foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - $self->pidl("py_$e->{NAME} = " . $self->ConvertObjectToPython($e->{TYPE}, "r.out.$e->{NAME}") . ";"); + $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($e->{TYPE}, "r.out.$e->{NAME}") . ");"); + + $i++; } } if ($fn->{RETURN_TYPE}) { - $self->pidl("py_result = " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ";"); + $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ");"); } $self->pidl("talloc_free(mem_ctx);"); @@ -304,7 +318,7 @@ sub PythonType($$$) } if ($actual_ctype->{TYPE} eq "UNION" or $actual_ctype->{TYPE} eq "STRUCT") { - $self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . "*in)"); + $self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)"); $self->pidl("{"); $self->indent; $self->FromStructToPythonFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT"); @@ -447,6 +461,21 @@ sub ConvertObjectFromPython($$$) { my ($self, $ctype, $cvar) = @_; + if (ref($ctype) ne "HASH") { + $ctype = getType($ctype); + } + + my $actual_ctype = $ctype; + if ($ctype->{TYPE} eq "TYPEDEF") { + $actual_ctype = $ctype->{DATA}; + } + + if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or + $actual_ctype->{TYPE} eq "SCALAR" and ( + $actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper)$/)) { + return "PyInt_AsLong($cvar)"; + } + return "FIXME($cvar)"; } @@ -484,6 +513,10 @@ sub ConvertObjectToPython($$$) return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)"; } + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") { + return "PyInt_FromLong($cvar->v)"; + } + die("unknown type ".mapTypeName($ctype) . ": $cvar"); } -- cgit From 375624ecf95a0aac6e29ce0c7dca35f239c9dd12 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 12 Jan 2008 01:09:28 +0100 Subject: pidl/python: Some more support for special case types. (This used to be commit 991aa950a377bbc07e0bf05758574f850a6d0ff7) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 48 ++++++++++++++++++++++------ 1 file changed, 39 insertions(+), 9 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 4454eeefd7..2bf5f1528a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -11,7 +11,7 @@ use Exporter; use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName); use Parse::Pidl::Util qw(has_property ParseExpr); -use Parse::Pidl::CUtil qw(get_value_of get_pointer_of); +use Parse::Pidl::CUtil qw(get_value_of get_pointer_to); use vars qw($VERSION); $VERSION = '0.01'; @@ -288,12 +288,11 @@ sub PythonType($$$) my ($self, $d, $interface, $basename) = @_; my $actual_ctype = $d; - if ($actual_ctype->{TYPE} eq "TYPEDEF") { + if ($actual_ctype->{TYPE} eq "TYPEDEF" or $actual_ctype->{TYPE} eq "DECLARE") { $actual_ctype = $actual_ctype->{DATA}; } - if ($d->{TYPE} eq "STRUCT" or $d->{TYPE} eq "TYPEDEF" and - $d->{DATA}->{TYPE} eq "STRUCT") { + if ($actual_ctype->{TYPE} eq "STRUCT") { my $py_fnname; if ($d->{TYPE} eq "STRUCT") { $py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d); @@ -466,13 +465,13 @@ sub ConvertObjectFromPython($$$) } my $actual_ctype = $ctype; - if ($ctype->{TYPE} eq "TYPEDEF") { + if ($ctype->{TYPE} eq "TYPEDEF" or $ctype->{TYPE} eq "DECLARE") { $actual_ctype = $ctype->{DATA}; } if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or $actual_ctype->{TYPE} eq "SCALAR" and ( - $actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper)$/)) { + $actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong)$/)) { return "PyInt_AsLong($cvar)"; } @@ -488,18 +487,22 @@ sub ConvertObjectToPython($$$) } if (ref($ctype) ne "HASH") { + if (not hasType($ctype)) { + return "py_import_$ctype($cvar)"; # best bet + } + $ctype = getType($ctype); } my $actual_ctype = $ctype; - if ($ctype->{TYPE} eq "TYPEDEF") { + if ($ctype->{TYPE} eq "TYPEDEF" or $ctype->{TYPE} eq "DECLARE") { $actual_ctype = $ctype->{DATA}; } if ($cvar =~ /^[0-9]+$/ or $actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or - $actual_ctype->{TYPE} eq "SCALAR" and ( - $actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper)$/)) { + ($actual_ctype->{TYPE} eq "SCALAR" and + $actual_ctype->{NAME} =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) { return "PyInt_FromLong($cvar)"; } @@ -509,6 +512,11 @@ sub ConvertObjectToPython($$$) return "py_import_$ctype->{NAME}($cvar)"; } + if ($actual_ctype->{TYPE} eq "SCALAR" and + $actual_ctype->{NAME} eq "DATA_BLOB") { + return "PyString_FromStringAndSize($cvar->data, $cvar->length)"; + } + if ($ctype->{TYPE} eq "STRUCT" or $ctype->{TYPE} eq "UNION") { return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)"; } @@ -517,6 +525,28 @@ sub ConvertObjectToPython($$$) return "PyInt_FromLong($cvar->v)"; } + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") { + return "PyInt_FromLong($cvar->v)"; + } + + if ($actual_ctype->{TYPE} eq "SCALAR" and + ($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string")) { + return "PyString_FromString($cvar)"; + } + + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") { + return "FIXME($cvar)"; + } + + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") { + return "FIXME($cvar)"; + } + + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") { + return "PyCObject_FromVoidPtr($cvar, talloc_free)"; + } + + die("unknown type ".mapTypeName($ctype) . ": $cvar"); } -- cgit From f0916ef230b48e3140a4fca68f96ab33350bee93 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 01:35:06 +0100 Subject: pidl/python: Remove references to DECLARE, which has been removed. (This used to be commit 9a907567c8e0836b731e0ef01f8d097a33de21b0) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 2bf5f1528a..98e9ee9ec2 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -288,7 +288,7 @@ sub PythonType($$$) my ($self, $d, $interface, $basename) = @_; my $actual_ctype = $d; - if ($actual_ctype->{TYPE} eq "TYPEDEF" or $actual_ctype->{TYPE} eq "DECLARE") { + if ($actual_ctype->{TYPE} eq "TYPEDEF") { $actual_ctype = $actual_ctype->{DATA}; } @@ -465,7 +465,7 @@ sub ConvertObjectFromPython($$$) } my $actual_ctype = $ctype; - if ($ctype->{TYPE} eq "TYPEDEF" or $ctype->{TYPE} eq "DECLARE") { + if ($ctype->{TYPE} eq "TYPEDEF") { $actual_ctype = $ctype->{DATA}; } @@ -495,7 +495,7 @@ sub ConvertObjectToPython($$$) } my $actual_ctype = $ctype; - if ($ctype->{TYPE} eq "TYPEDEF" or $ctype->{TYPE} eq "DECLARE") { + if ($ctype->{TYPE} eq "TYPEDEF") { $actual_ctype = $ctype->{DATA}; } -- cgit From 4ba71079272b1231c457112ac2d90f1f920cf5c8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 01:50:31 +0100 Subject: pidl/python: Fix conversion of last few non-standard types. (This used to be commit b8bdbc38c15598e34c55fb9e3ee1f6894964d2c6) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 98e9ee9ec2..4ae647aa0a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -9,7 +9,7 @@ use Exporter; @ISA = qw(Exporter); use strict; -use Parse::Pidl::Typelist qw(hasType getType mapTypeName); +use Parse::Pidl::Typelist qw(hasType getType mapTypeName expandAlias); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::CUtil qw(get_value_of get_pointer_to); @@ -471,7 +471,7 @@ sub ConvertObjectFromPython($$$) if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or $actual_ctype->{TYPE} eq "SCALAR" and ( - $actual_ctype->{NAME} =~ /^(uint[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong)$/)) { + expandAlias($actual_ctype->{NAME}) =~ /^(uint[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong)$/)) { return "PyInt_AsLong($cvar)"; } @@ -502,7 +502,7 @@ sub ConvertObjectToPython($$$) if ($cvar =~ /^[0-9]+$/ or $actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or ($actual_ctype->{TYPE} eq "SCALAR" and - $actual_ctype->{NAME} =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) { + expandAlias($actual_ctype->{NAME}) =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) { return "PyInt_FromLong($cvar)"; } @@ -513,7 +513,7 @@ sub ConvertObjectToPython($$$) } if ($actual_ctype->{TYPE} eq "SCALAR" and - $actual_ctype->{NAME} eq "DATA_BLOB") { + expandAlias($actual_ctype->{NAME}) eq "DATA_BLOB") { return "PyString_FromStringAndSize($cvar->data, $cvar->length)"; } @@ -530,7 +530,7 @@ sub ConvertObjectToPython($$$) } if ($actual_ctype->{TYPE} eq "SCALAR" and - ($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string")) { + ($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) { return "PyString_FromString($cvar)"; } -- cgit From d814f3ce1c58be53886deab31a815e444ca6c5d5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 03:15:55 +0100 Subject: pidl/python: Fix const type wrapping. (This used to be commit 35a4843f9c75a59ab98e785520114809903575cf) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 4ae647aa0a..ae4931571a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -65,7 +65,7 @@ sub Import sub Const($$) { my ($self, $const) = @_; - $self->register_constant($const->{NAME}, $const->{DATA}->{TYPE}, $const->{VALUE}); + $self->register_constant($const->{NAME}, $const->{DTYPE}, $const->{VALUE}); } sub register_constant($$$$) @@ -258,7 +258,7 @@ sub PythonFunction($$$) } } - if ($fn->{RETURN_TYPE}) { + if (defined($fn->{RETURN_TYPE})) { $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ");"); } @@ -460,10 +460,16 @@ sub ConvertObjectFromPython($$$) { my ($self, $ctype, $cvar) = @_; + die("undef type for $cvar") unless(defined($ctype)); + if (ref($ctype) ne "HASH") { $ctype = getType($ctype); } + if (ref($ctype) ne "HASH") { + return "FIXME($cvar)"; + } + my $actual_ctype = $ctype; if ($ctype->{TYPE} eq "TYPEDEF") { $actual_ctype = $ctype->{DATA}; @@ -482,13 +488,23 @@ sub ConvertObjectToPython($$$) { my ($self, $ctype, $cvar) = @_; + if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) { + return "PyInt_FromLong($cvar)"; + } + + die("undef type for $cvar") unless(defined($ctype)); + if ($cvar =~ /^".*"$/) { return "PyString_FromString($cvar)"; } if (ref($ctype) ne "HASH") { if (not hasType($ctype)) { - return "py_import_$ctype($cvar)"; # best bet + if (ref($ctype) eq "HASH") { + return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)"; + } else { + return "py_import_$ctype($cvar)"; # best bet + } } $ctype = getType($ctype); @@ -499,8 +515,7 @@ sub ConvertObjectToPython($$$) $actual_ctype = $ctype->{DATA}; } - if ($cvar =~ /^[0-9]+$/ or - $actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or + if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or ($actual_ctype->{TYPE} eq "SCALAR" and expandAlias($actual_ctype->{NAME}) =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) { return "PyInt_FromLong($cvar)"; -- cgit From 4a8ceb8c56c66059791e4ef74ef3cbef4259f961 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 15:11:28 +0100 Subject: pidl/python: Fix bug accidently filling in the body of enums/bitmaps without body. (This used to be commit 97971f0d8080f3934ea5940cc0f230004afb94a1) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index ae4931571a..d0a5bbd7e3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -79,6 +79,8 @@ sub EnumAndBitmapConsts($$$) { my ($self, $name, $d) = @_; + return unless (defined($d->{ELEMENTS})); + foreach my $e (@{$d->{ELEMENTS}}) { $e =~ /^([A-Za-z0-9_]+)=(.*)$/; my $cname = $1; -- cgit From c660845737f454713f60f01d015125b053435b2c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 15:29:56 +0100 Subject: pidl/python: Fix more warnings in the generated code. (This used to be commit 23add37b729aaa85b83cbf6ba98e7042c01f6472) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 51 +++++++++++++++------------- 1 file changed, 28 insertions(+), 23 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index d0a5bbd7e3..fc5480b661 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -89,37 +89,39 @@ sub EnumAndBitmapConsts($$$) } } -sub FromUnionToPythonFunction($$) +sub FromUnionToPythonFunction($$$) { - my ($self, $type) = @_; + my ($self, $type, $name) = @_; #FIXME $self->pidl("return NULL;"); } -sub FromStructToPythonFunction($$) +sub FromStructToPythonFunction($$$) { - my ($self, $type) = @_; + my ($self, $type, $name) = @_; - #FIXME - $self->pidl("return NULL;"); + $self->pidl("$type->{NAME}\_Object *ret;"); + $self->pidl("ret = PyObject_New($type->{NAME}\_Object, &$type->{NAME}\_ObjectType);"); + $self->pidl("ret->object = talloc_reference(NULL, $name);"); + $self->pidl("return (PyObject *) ret;"); } -sub FromPythonToUnionFunction($$) +sub FromPythonToUnionFunction($$$$) { - my ($self, $type) = @_; + my ($self, $type, $mem_ctx, $name) = @_; #FIXME $self->pidl("return NULL;"); } -sub FromPythonToStructFunction($$) +sub FromPythonToStructFunction($$$$) { - my ($self, $type) = @_; + my ($self, $type, $mem_ctx, $name) = @_; - #FIXME - $self->pidl("return NULL;"); + $self->pidl("$type->{NAME}\_Object *py_object = ($type->{NAME}_Object *)$name;"); + $self->pidl("return talloc_reference($mem_ctx, py_object->object);"); } sub PythonStruct($$$$) @@ -222,7 +224,7 @@ sub PythonFunction($$$) $self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;"); $self->pidl("NTSTATUS status;"); $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); - $self->pidl("struct dcerpc_$fn->{NAME} r;"); + $self->pidl("struct $fn->{NAME} r;"); $self->pidl("PyObject *result;"); my $result_size = 0; @@ -234,11 +236,13 @@ sub PythonFunction($$$) $result_size++; } } + if ($result_size > 0) { + $self->pidl(""); + $self->pidl("ZERO_STRUCT(r.out);"); + } if ($fn->{RETURN_TYPE}) { $result_size++; } - $self->pidl(""); - $self->pidl("ZERO_STRUCT(r.out);"); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { @@ -322,8 +326,8 @@ sub PythonType($$$) $self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)"); $self->pidl("{"); $self->indent; - $self->FromStructToPythonFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT"); - $self->FromUnionToPythonFunction($d) if ($actual_ctype->{TYPE} eq "UNION"); + $self->FromStructToPythonFunction($d, "in") if ($actual_ctype->{TYPE} eq "STRUCT"); + $self->FromUnionToPythonFunction($d, "in") if ($actual_ctype->{TYPE} eq "UNION"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -331,8 +335,8 @@ sub PythonType($$$) $self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)"); $self->pidl("{"); $self->indent; - $self->FromPythonToStructFunction($d) if ($actual_ctype->{TYPE} eq "STRUCT"); - $self->FromPythonToUnionFunction($d) if ($actual_ctype->{TYPE} eq "UNION"); + $self->FromPythonToStructFunction($d, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "STRUCT"); + $self->FromPythonToUnionFunction($d, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -414,8 +418,8 @@ sub Interface($$$) $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); $self->pidl(".tp_name = \"$interface->{NAME}\","); $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); - $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); - $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); + $self->pidl(".tp_dealloc = (destructor)interface_$interface->{NAME}_dealloc,"); + $self->pidl(".tp_getattr = (getattrfunc)interface_$interface->{NAME}_getattr,"); $self->deindent; $self->pidl("};"); @@ -567,9 +571,9 @@ sub ConvertObjectToPython($$$) die("unknown type ".mapTypeName($ctype) . ": $cvar"); } -sub Parse($$$$) +sub Parse($$$$$) { - my($self,$basename,$ndr,$hdr) = @_; + my($self,$basename,$ndr,$ndr_hdr,$hdr) = @_; my $py_hdr = $hdr; $py_hdr =~ s/ndr_([^\/]+)$/py_$1/g; @@ -582,6 +586,7 @@ sub Parse($$$$) #include #include \"librpc/rpc/dcerpc.h\" #include \"$hdr\" +#include \"$ndr_hdr\" #include \"$py_hdr\" "); -- cgit From ce874c0b898eee3dfa8439424350579bf974e98f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 15:51:15 +0100 Subject: pidl/python: Convert unions. (This used to be commit e9037d0f5d222efd4ca04a0f8ce5c39cb3bb6997) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 57 +++++++++++++++++++++------- 1 file changed, 43 insertions(+), 14 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index fc5480b661..8720421088 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -91,36 +91,65 @@ sub EnumAndBitmapConsts($$$) sub FromUnionToPythonFunction($$$) { - my ($self, $type, $name) = @_; + my ($self, $type, $switch, $name) = @_; - #FIXME + $self->pidl("switch ($switch) {"); + $self->indent; + + foreach my $e (@{$type->{ELEMENTS}}) { + my $conv = $self->ConvertObjectToPython($e->{TYPE}, "$name->$e->{NAME}"); + if (defined($e->{CASE})) { + $self->pidl("$e->{CASE}: return $conv;"); + } else { + $self->pidl("default: return $conv;"); + } + } + $self->deindent; + $self->pidl("}"); + + $self->pidl("PyErr_SetString(PyExc_TypeError, \"unknown union level\");"); $self->pidl("return NULL;"); } sub FromStructToPythonFunction($$$) { - my ($self, $type, $name) = @_; + my ($self, $type, $typename, $name) = @_; - $self->pidl("$type->{NAME}\_Object *ret;"); - $self->pidl("ret = PyObject_New($type->{NAME}\_Object, &$type->{NAME}\_ObjectType);"); + $self->pidl("$typename\_Object *ret;"); + $self->pidl("ret = PyObject_New($typename\_Object, &$typename\_ObjectType);"); $self->pidl("ret->object = talloc_reference(NULL, $name);"); $self->pidl("return (PyObject *) ret;"); } sub FromPythonToUnionFunction($$$$) { - my ($self, $type, $mem_ctx, $name) = @_; + my ($self, $type, $switch, $mem_ctx, $name) = @_; - #FIXME + $self->pidl("switch ($switch) {"); + $self->indent; + + foreach my $e (@{$type->{ELEMENTS}}) { + my $conv = $self->ConvertObjectFromPython($e->{TYPE}, "$name"); + if (defined($e->{CASE})) { + $self->pidl("$e->{CASE}: return $conv;"); + } else { + $self->pidl("default: return $conv;"); + } + } + + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $self->pidl("PyErr_SetString(PyExc_TypeError, \"invalid union level value\");"); $self->pidl("return NULL;"); } -sub FromPythonToStructFunction($$$$) +sub FromPythonToStructFunction($$$$$) { - my ($self, $type, $mem_ctx, $name) = @_; + my ($self, $type, $typename, $mem_ctx, $name) = @_; - $self->pidl("$type->{NAME}\_Object *py_object = ($type->{NAME}_Object *)$name;"); + $self->pidl("$typename\_Object *py_object = ($typename\_Object *)$name;"); $self->pidl("return talloc_reference($mem_ctx, py_object->object);"); } @@ -326,8 +355,8 @@ sub PythonType($$$) $self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)"); $self->pidl("{"); $self->indent; - $self->FromStructToPythonFunction($d, "in") if ($actual_ctype->{TYPE} eq "STRUCT"); - $self->FromUnionToPythonFunction($d, "in") if ($actual_ctype->{TYPE} eq "UNION"); + $self->FromStructToPythonFunction($actual_ctype, $d->{NAME}, "in") if ($actual_ctype->{TYPE} eq "STRUCT"); + $self->FromUnionToPythonFunction($actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -335,8 +364,8 @@ sub PythonType($$$) $self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)"); $self->pidl("{"); $self->indent; - $self->FromPythonToStructFunction($d, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "STRUCT"); - $self->FromPythonToUnionFunction($d, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION"); + $self->FromPythonToStructFunction($actual_ctype, $d->{NAME}, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "STRUCT"); + $self->FromPythonToUnionFunction($actual_ctype, "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION"); $self->deindent; $self->pidl("}"); $self->pidl(""); -- cgit From d06c990dbe89cb3b5996b3470a36de1b821bcdfc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 16:59:15 +0100 Subject: pidl/python: Use new talloc utility functions. (This used to be commit 48cfd44dc088717c0282436148888e45b2632946) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 73 +++++++++------------------- 1 file changed, 24 insertions(+), 49 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 8720421088..4b552a9ba9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -112,16 +112,6 @@ sub FromUnionToPythonFunction($$$) $self->pidl("return NULL;"); } -sub FromStructToPythonFunction($$$) -{ - my ($self, $type, $typename, $name) = @_; - - $self->pidl("$typename\_Object *ret;"); - $self->pidl("ret = PyObject_New($typename\_Object, &$typename\_ObjectType);"); - $self->pidl("ret->object = talloc_reference(NULL, $name);"); - $self->pidl("return (PyObject *) ret;"); -} - sub FromPythonToUnionFunction($$$$) { my ($self, $type, $switch, $mem_ctx, $name) = @_; @@ -145,33 +135,19 @@ sub FromPythonToUnionFunction($$$$) $self->pidl("return NULL;"); } -sub FromPythonToStructFunction($$$$$) -{ - my ($self, $type, $typename, $mem_ctx, $name) = @_; - - $self->pidl("$typename\_Object *py_object = ($typename\_Object *)$name;"); - $self->pidl("return talloc_reference($mem_ctx, py_object->object);"); -} - sub PythonStruct($$$$) { my ($self, $name, $cname, $d) = @_; $self->pidl("staticforward PyTypeObject $name\_ObjectType;"); - $self->pidl("typedef struct {"); - $self->indent; - $self->pidl("PyObject_HEAD"); - $self->pidl("$cname *object;"); - $self->deindent; - $self->pidl("} $name\_Object;"); $self->pidl(""); $self->pidl("static PyObject *py_$name\_getattr(PyTypeObject *obj, char *name)"); $self->pidl("{"); $self->indent; - $self->pidl("$name\_Object *py_object = ($name\_Object *)obj;"); - $self->pidl("$cname *object = talloc_get_type(py_object->object, $cname);"); + $self->pidl("py_talloc_Object *py_object = (py_talloc_Object *)obj;"); + $self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);"); foreach my $e (@{$d->{ELEMENTS}}) { $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; @@ -186,21 +162,11 @@ sub PythonStruct($$$$) $self->pidl("}"); $self->pidl(""); - $self->pidl("static void py_$name\_dealloc(PyObject* self)"); - $self->pidl("{"); - $self->indent; - $self->pidl("$name\_Object *obj = ($name\_Object *)self;"); - $self->pidl("talloc_free(obj->object);"); - $self->pidl("PyObject_Del(self);"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - $self->pidl("static PyObject *py_$name\_setattr(PyTypeObject *obj, char *name, PyObject *value)"); $self->pidl("{"); $self->indent; - $self->pidl("$name\_Object *py_object = ($name\_Object *)obj;"); - $self->pidl("$cname *object = talloc_get_type(py_object->object, $cname);"); + $self->pidl("py_talloc_Object *py_object = (py_talloc_Object *)obj;"); + $self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);"); foreach my $e (@{$d->{ELEMENTS}}) { $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; @@ -220,8 +186,8 @@ sub PythonStruct($$$$) $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); $self->pidl(".tp_name = \"$name\","); - $self->pidl(".tp_basicsize = sizeof($name\_Object),"); - $self->pidl(".tp_dealloc = (destructor)py_$name\_dealloc,"); + $self->pidl(".tp_basicsize = sizeof(py_talloc_Object),"); + $self->pidl(".tp_dealloc = (destructor)py_talloc_dealloc,"); $self->pidl(".tp_getattr = (getattrfunc)py_$name\_getattr,"); $self->pidl(".tp_setattr = (setattrfunc)py_$name\_setattr,"); $self->deindent; @@ -233,9 +199,8 @@ sub PythonStruct($$$$) $self->pidl("static PyObject *$py_fnname(PyObject *self, PyObject *args)"); $self->pidl("{"); $self->indent; - $self->pidl("$name\_Object *ret;"); - $self->pidl("ret = PyObject_New($name\_Object, &$name\_ObjectType);"); - $self->pidl("return (PyObject *) ret;"); + $self->pidl("$cname *ret = talloc_zero(NULL, $cname);"); + $self->pidl("return py_talloc_import(&$name\_ObjectType, ret);"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -351,11 +316,10 @@ sub PythonType($$$) $self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA}); } - if ($actual_ctype->{TYPE} eq "UNION" or $actual_ctype->{TYPE} eq "STRUCT") { + if ($actual_ctype->{TYPE} eq "UNION") { $self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)"); $self->pidl("{"); $self->indent; - $self->FromStructToPythonFunction($actual_ctype, $d->{NAME}, "in") if ($actual_ctype->{TYPE} eq "STRUCT"); $self->FromUnionToPythonFunction($actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION"); $self->deindent; $self->pidl("}"); @@ -364,7 +328,6 @@ sub PythonType($$$) $self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)"); $self->pidl("{"); $self->indent; - $self->FromPythonToStructFunction($actual_ctype, $d->{NAME}, "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "STRUCT"); $self->FromPythonToUnionFunction($actual_ctype, "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION"); $self->deindent; $self->pidl("}"); @@ -516,6 +479,14 @@ sub ConvertObjectFromPython($$$) return "PyInt_AsLong($cvar)"; } + if ($actual_ctype->{TYPE} eq "STRUCT") { + return "py_talloc_get_type($cvar, " . mapTypeName($ctype) . ")"; + } + + if ($actual_ctype->{TYPE} eq "UNION") { + return "py_export_$ctype->{NAME}($cvar)"; + } + return "FIXME($cvar)"; } @@ -556,12 +527,15 @@ sub ConvertObjectToPython($$$) return "PyInt_FromLong($cvar)"; } - if ($ctype->{TYPE} eq "TYPEDEF" and ( - $actual_ctype->{TYPE} eq "STRUCT" or - $actual_ctype->{TYPE} eq "UNION")) { + if ($ctype->{TYPE} eq "TYPEDEF" and $actual_ctype->{TYPE} eq "UNION") { return "py_import_$ctype->{NAME}($cvar)"; } + if ($ctype->{TYPE} eq "TYPEDEF" and $actual_ctype->{TYPE} eq "STRUCT") { + # FIXME: if $cvar is not a pointer, do a talloc_dup() + return "py_talloc_import(&$ctype->{NAME}_ObjectType, $cvar)"; + } + if ($actual_ctype->{TYPE} eq "SCALAR" and expandAlias($actual_ctype->{NAME}) eq "DATA_BLOB") { return "PyString_FromStringAndSize($cvar->data, $cvar->length)"; @@ -614,6 +588,7 @@ sub Parse($$$$$) #include \"includes.h\" #include #include \"librpc/rpc/dcerpc.h\" +#include \"scripting/python/pytalloc.h\" #include \"$hdr\" #include \"$ndr_hdr\" #include \"$py_hdr\" -- cgit From 915f1589252be8cb9fb86eed479e328371e355e1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 17:15:56 +0100 Subject: pidl/python: Support more scalar types when converting from Python. (This used to be commit 1f3bbb65e5a46715c49225eecc760faaf5dbb9d7) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 67 +++++++++++++++++++--------- 1 file changed, 47 insertions(+), 20 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 4b552a9ba9..1c0cafc050 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -120,7 +120,7 @@ sub FromPythonToUnionFunction($$$$) $self->indent; foreach my $e (@{$type->{ELEMENTS}}) { - my $conv = $self->ConvertObjectFromPython($e->{TYPE}, "$name"); + my $conv = $self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, "$name"); if (defined($e->{CASE})) { $self->pidl("$e->{CASE}: return $conv;"); } else { @@ -143,11 +143,10 @@ sub PythonStruct($$$$) $self->pidl(""); - $self->pidl("static PyObject *py_$name\_getattr(PyTypeObject *obj, char *name)"); + $self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)"); $self->pidl("{"); $self->indent; - $self->pidl("py_talloc_Object *py_object = (py_talloc_Object *)obj;"); - $self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);"); + $self->pidl("$cname *object = py_talloc_get_type(obj, $cname);"); foreach my $e (@{$d->{ELEMENTS}}) { $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; @@ -162,17 +161,16 @@ sub PythonStruct($$$$) $self->pidl("}"); $self->pidl(""); - $self->pidl("static PyObject *py_$name\_setattr(PyTypeObject *obj, char *name, PyObject *value)"); + $self->pidl("static PyObject *py_$name\_setattr(PyObject *obj, char *name, PyObject *value)"); $self->pidl("{"); $self->indent; - $self->pidl("py_talloc_Object *py_object = (py_talloc_Object *)obj;"); $self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);"); foreach my $e (@{$d->{ELEMENTS}}) { $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; $self->indent; $self->pidl("/* FIXME: talloc_free($varname) if necessary */"); - $self->pidl("$varname = " . $self->ConvertObjectFromPython($e->{TYPE}, "value") . ";"); + $self->pidl("$varname = " . $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value") . ";"); $self->deindent; $self->pidl("}"); } @@ -187,9 +185,9 @@ sub PythonStruct($$$$) $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); $self->pidl(".tp_name = \"$name\","); $self->pidl(".tp_basicsize = sizeof(py_talloc_Object),"); - $self->pidl(".tp_dealloc = (destructor)py_talloc_dealloc,"); - $self->pidl(".tp_getattr = (getattrfunc)py_$name\_getattr,"); - $self->pidl(".tp_setattr = (setattrfunc)py_$name\_setattr,"); + $self->pidl(".tp_dealloc = py_talloc_dealloc,"); + $self->pidl(".tp_getattr = py_$name\_getattr,"); + $self->pidl(".tp_setattr = py_$name\_setattr,"); $self->deindent; $self->pidl("};"); @@ -240,7 +238,7 @@ sub PythonFunction($$$) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - $self->pidl("r.in.$e->{NAME} = " . $self->ConvertObjectFromPython($e->{TYPE}, "py_$e->{NAME}") . ";"); + $self->pidl("r.in.$e->{NAME} = " . $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}") . ";"); } } $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);"); @@ -396,10 +394,10 @@ sub Interface($$$) $self->pidl("}"); $self->pidl(""); - $self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyTypeObject *obj, char *name)"); + $self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyObject *obj, char *name)"); $self->pidl("{"); $self->indent; - $self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, (PyObject *)obj, name);"); + $self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, obj, name);"); $self->deindent; $self->pidl("}"); @@ -454,9 +452,9 @@ sub register_module_method($$$$$) push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) } -sub ConvertObjectFromPython($$$) +sub ConvertObjectFromPython($$$$) { - my ($self, $ctype, $cvar) = @_; + my ($self, $mem_ctx, $ctype, $cvar) = @_; die("undef type for $cvar") unless(defined($ctype)); @@ -475,7 +473,7 @@ sub ConvertObjectFromPython($$$) if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or $actual_ctype->{TYPE} eq "SCALAR" and ( - expandAlias($actual_ctype->{NAME}) =~ /^(uint[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong)$/)) { + expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) { return "PyInt_AsLong($cvar)"; } @@ -487,7 +485,37 @@ sub ConvertObjectFromPython($$$) return "py_export_$ctype->{NAME}($cvar)"; } - return "FIXME($cvar)"; + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") { + return "data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar))"; + } + + if ($actual_ctype->{TYPE} eq "SCALAR" and + ($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) { + return "talloc_strdup($mem_ctx, PyString_AsString($cvar))"; + } + + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") { + return "FIXME($cvar)"; + } + + + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") { + return "PyInt_AsLong($cvar)"; + } + + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") { + return "PyInt_AsLong($cvar)"; + } + + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") { + return "FIXME($cvar)"; + } + + if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") { + return "PyCObject_AsVoidPtr($cvar)"; + } + + die("unknown type ".mapTypeName($ctype) . ": $cvar"); } sub ConvertObjectToPython($$$) @@ -546,11 +574,11 @@ sub ConvertObjectToPython($$$) } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") { - return "PyInt_FromLong($cvar->v)"; + return "PyInt_FromLong(NT_STATUS_V($cvar))"; } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") { - return "PyInt_FromLong($cvar->v)"; + return "PyInt_FromLong(W_ERROR_V($cvar))"; } if ($actual_ctype->{TYPE} eq "SCALAR" and @@ -570,7 +598,6 @@ sub ConvertObjectToPython($$$) return "PyCObject_FromVoidPtr($cvar, talloc_free)"; } - die("unknown type ".mapTypeName($ctype) . ": $cvar"); } -- cgit From be01d080247c70ec260763adc7711976c8ee19fc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 18:05:43 +0100 Subject: pidl/python: Work towards supporting more complex types (arrays, etc). (This used to be commit 49d91a1a92e226c015db86ddc9ef772030415d76) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 191 ++++++++++++++++----------- 1 file changed, 115 insertions(+), 76 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 1c0cafc050..545d233d08 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -97,7 +97,13 @@ sub FromUnionToPythonFunction($$$) $self->indent; foreach my $e (@{$type->{ELEMENTS}}) { - my $conv = $self->ConvertObjectToPython($e->{TYPE}, "$name->$e->{NAME}"); + my $conv; + + if ($e->{NAME}) { + $conv = $self->ConvertObjectToPython($e->{TYPE}, "$name->$e->{NAME}"); + } else { + $conv = "Py_None"; + } if (defined($e->{CASE})) { $self->pidl("$e->{CASE}: return $conv;"); } else { @@ -112,27 +118,46 @@ sub FromUnionToPythonFunction($$$) $self->pidl("return NULL;"); } -sub FromPythonToUnionFunction($$$$) +sub FromPythonToUnionFunction($$$$$) { - my ($self, $type, $switch, $mem_ctx, $name) = @_; + my ($self, $type, $typename, $switch, $mem_ctx, $name) = @_; + + my $has_default = 0; + + $self->pidl("$typename *ret = talloc_zero($mem_ctx, $typename);"); $self->pidl("switch ($switch) {"); $self->indent; foreach my $e (@{$type->{ELEMENTS}}) { - my $conv = $self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, "$name"); if (defined($e->{CASE})) { - $self->pidl("$e->{CASE}: return $conv;"); + $self->pidl("$e->{CASE}:"); } else { - $self->pidl("default: return $conv;"); + $has_default = 1; + $self->pidl("default:"); } + $self->indent; + if ($e->{NAME}) { + $self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, $name, "ret->$e->{NAME}"); + } + $self->pidl("break;"); + $self->deindent; + $self->pidl(""); + } + + if (!$has_default) { + $self->pidl("default:"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_TypeError, \"invalid union level value\");"); + $self->pidl("talloc_free(ret);"); + $self->pidl("ret = NULL;"); + $self->deindent; } $self->deindent; $self->pidl("}"); $self->pidl(""); - $self->pidl("PyErr_SetString(PyExc_TypeError, \"invalid union level value\");"); - $self->pidl("return NULL;"); + $self->pidl("return ret;"); } sub PythonStruct($$$$) @@ -161,21 +186,22 @@ sub PythonStruct($$$$) $self->pidl("}"); $self->pidl(""); - $self->pidl("static PyObject *py_$name\_setattr(PyObject *obj, char *name, PyObject *value)"); + $self->pidl("static int py_$name\_setattr(PyObject *py_obj, char *name, PyObject *value)"); $self->pidl("{"); $self->indent; - $self->pidl("$cname *object = py_talloc_get_type(py_object, $cname);"); + $self->pidl("$cname *object = py_talloc_get_type(py_obj, $cname);"); foreach my $e (@{$d->{ELEMENTS}}) { $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; $self->indent; $self->pidl("/* FIXME: talloc_free($varname) if necessary */"); - $self->pidl("$varname = " . $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value") . ";"); + $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname); + $self->pidl("return 0;"); $self->deindent; $self->pidl("}"); } $self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");"); - $self->pidl("return NULL;"); + $self->pidl("return -1;"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -238,7 +264,7 @@ sub PythonFunction($$$) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - $self->pidl("r.in.$e->{NAME} = " . $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}") . ";"); + $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}", "r.in.$e->{NAME}"); } } $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);"); @@ -303,7 +329,7 @@ sub PythonType($$$) $fn_name =~ s/^$interface->{NAME}_//; $fn_name =~ s/^$basename\_//; - $self->register_module_method($fn_name, $py_fnname, "METH_VARARGS|METH_KEYWORDS", "NULL"); + $self->register_module_method($fn_name, $py_fnname, "METH_NOARGS", "NULL"); } if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") { @@ -315,7 +341,7 @@ sub PythonType($$$) } if ($actual_ctype->{TYPE} eq "UNION") { - $self->pidl("PyObject *py_import_$d->{NAME}(" .mapTypeName($d) . " *in)"); + $self->pidl("PyObject *py_import_$d->{NAME}(int level, " .mapTypeName($d) . " *in)"); $self->pidl("{"); $self->indent; $self->FromUnionToPythonFunction($actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION"); @@ -323,10 +349,10 @@ sub PythonType($$$) $self->pidl("}"); $self->pidl(""); - $self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, PyObject *in)"); + $self->pidl(mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in)"); $self->pidl("{"); $self->indent; - $self->FromPythonToUnionFunction($actual_ctype, "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION"); + $self->FromPythonToUnionFunction($actual_ctype, mapTypeName($d), "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -452,9 +478,9 @@ sub register_module_method($$$$$) push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) } -sub ConvertObjectFromPython($$$$) +sub ConvertObjectFromPython($$$$$) { - my ($self, $mem_ctx, $ctype, $cvar) = @_; + my ($self, $mem_ctx, $ctype, $cvar, $target) = @_; die("undef type for $cvar") unless(defined($ctype)); @@ -463,7 +489,8 @@ sub ConvertObjectFromPython($$$$) } if (ref($ctype) ne "HASH") { - return "FIXME($cvar)"; + $self->pidl("$target = FIXME($cvar);"); + return; } my $actual_ctype = $ctype; @@ -474,64 +501,102 @@ sub ConvertObjectFromPython($$$$) if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or $actual_ctype->{TYPE} eq "SCALAR" and ( expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) { - return "PyInt_AsLong($cvar)"; + $self->pidl("$target = PyInt_AsLong($cvar);"); + return; } if ($actual_ctype->{TYPE} eq "STRUCT") { - return "py_talloc_get_type($cvar, " . mapTypeName($ctype) . ")"; + $self->pidl("$target = py_talloc_get_type($cvar, " . mapTypeName($ctype) . ");"); + return; } if ($actual_ctype->{TYPE} eq "UNION") { - return "py_export_$ctype->{NAME}($cvar)"; + $self->pidl("$target = py_export_$ctype->{NAME}($cvar);"); + return; } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") { - return "data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar))"; + $self->pidl("$target = data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar));"); + return; } if ($actual_ctype->{TYPE} eq "SCALAR" and ($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) { - return "talloc_strdup($mem_ctx, PyString_AsString($cvar))"; + $self->pidl("$target = talloc_strdup($mem_ctx, PyString_AsString($cvar));"); + return; } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") { - return "FIXME($cvar)"; + $self->pidl("$target = FIXME($cvar);"); + return; } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") { - return "PyInt_AsLong($cvar)"; + $self->pidl("$target = PyInt_AsLong($cvar);"); + return; } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") { - return "PyInt_AsLong($cvar)"; + $self->pidl("$target = PyInt_AsLong($cvar);"); + return; } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") { - return "FIXME($cvar)"; + $self->pidl("$target = FIXME($cvar);"); + return; } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") { - return "PyCObject_AsVoidPtr($cvar)"; + $self->pidl("$target = PyCObject_AsVoidPtr($cvar);"); + return; } die("unknown type ".mapTypeName($ctype) . ": $cvar"); } -sub ConvertObjectToPython($$$) +sub ConvertScalarToPython($$$) { - my ($self, $ctype, $cvar) = @_; + my ($self, $ctypename, $cvar) = @_; - if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) { + $ctypename = expandAlias($ctypename); + + if ($ctypename =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) { return "PyInt_FromLong($cvar)"; } - die("undef type for $cvar") unless(defined($ctype)); + if ($ctypename eq "DATA_BLOB") { + return "PyString_FromStringAndSize($cvar->data, $cvar->length)"; + } + + if ($ctypename eq "NTSTATUS") { + return "PyInt_FromLong(NT_STATUS_V($cvar))"; + } + + if ($ctypename eq "WERROR") { + return "PyInt_FromLong(W_ERROR_V($cvar))"; + } - if ($cvar =~ /^".*"$/) { + if (($ctypename eq "string" or $ctypename eq "nbt_string" or $ctypename eq "nbt_name" or $ctypename eq "wrepl_nbt_name")) { return "PyString_FromString($cvar)"; } + if ($ctypename eq "string_array") { return "FIXME($cvar)"; } + + if ($$ctypename eq "ipv4address") { return "FIXME($cvar)"; } + if ($ctypename eq "pointer") { + return "PyCObject_FromVoidPtr($cvar, talloc_free)"; + } + + die("Unknown scalar type $ctypename"); +} + +sub ConvertObjectToPython($$$) +{ + my ($self, $ctype, $cvar) = @_; + + die("undef type for $cvar") unless(defined($ctype)); + if (ref($ctype) ne "HASH") { if (not hasType($ctype)) { if (ref($ctype) eq "HASH") { @@ -550,54 +615,19 @@ sub ConvertObjectToPython($$$) } if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or - ($actual_ctype->{TYPE} eq "SCALAR" and - expandAlias($actual_ctype->{NAME}) =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/)) { - return "PyInt_FromLong($cvar)"; + ($actual_ctype->{TYPE} eq "SCALAR") { + return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar); } - if ($ctype->{TYPE} eq "TYPEDEF" and $actual_ctype->{TYPE} eq "UNION") { + if ($actual_ctype->{TYPE} eq "UNION") { return "py_import_$ctype->{NAME}($cvar)"; } - if ($ctype->{TYPE} eq "TYPEDEF" and $actual_ctype->{TYPE} eq "STRUCT") { + if ($actual_ctype->{TYPE} eq "STRUCT") { # FIXME: if $cvar is not a pointer, do a talloc_dup() return "py_talloc_import(&$ctype->{NAME}_ObjectType, $cvar)"; } - if ($actual_ctype->{TYPE} eq "SCALAR" and - expandAlias($actual_ctype->{NAME}) eq "DATA_BLOB") { - return "PyString_FromStringAndSize($cvar->data, $cvar->length)"; - } - - if ($ctype->{TYPE} eq "STRUCT" or $ctype->{TYPE} eq "UNION") { - return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)"; - } - - if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") { - return "PyInt_FromLong(NT_STATUS_V($cvar))"; - } - - if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") { - return "PyInt_FromLong(W_ERROR_V($cvar))"; - } - - if ($actual_ctype->{TYPE} eq "SCALAR" and - ($actual_ctype->{NAME} eq "string" or $actual_ctype->{NAME} eq "nbt_string" or $actual_ctype->{NAME} eq "nbt_name" or $actual_ctype->{NAME} eq "wrepl_nbt_name")) { - return "PyString_FromString($cvar)"; - } - - if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") { - return "FIXME($cvar)"; - } - - if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") { - return "FIXME($cvar)"; - } - - if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") { - return "PyCObject_FromVoidPtr($cvar, talloc_free)"; - } - die("unknown type ".mapTypeName($ctype) . ": $cvar"); } @@ -646,8 +676,17 @@ sub Parse($$$$$) $self->pidl("PyObject *m;"); $self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);"); foreach (keys %{$self->{constants}}) { - # FIXME: Handle non-string constants - $self->pidl("PyModule_AddObject(m, \"$_\", " . $self->ConvertObjectToPython($self->{constants}->{$_}->[0], $self->{constants}->{$_}->[1]) . ");"); + my $py_obj; + my ($ctype, $cvar) = @{$self->{constants}->{$_}}; + if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) { + $py_obj = "PyInt_FromLong($cvar)"; + } elsif ($cvar =~ /^".*"$/) { + $py_obj = "PyString_FromString($cvar)"; + } else { + $py_obj = $self->ConvertScalarToPython($ctype, $cvar); + } + + $self->pidl("PyModule_AddObject(m, \"$_\", $py_obj);"); } $self->deindent; $self->pidl("}"); -- cgit From a99dff8660ca2d168523b7264d9208a8a12ca5cc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 18:15:12 +0100 Subject: pidl: Move Generate*Env functions to Parse::Pidl::Samba4::Header because they only work with the structures generated by that file. (This used to be commit 9aeb7f31b0fc3b9679e5af07e65e79bc8073c4e1) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 4 +- source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 71 +++++++++++++++++++++++- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 65 +--------------------- 4 files changed, 75 insertions(+), 67 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index b7372a802a..86b8951026 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -9,7 +9,7 @@ package Parse::Pidl::Samba3::ClientNDR; use Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(GenerateFunctionInEnv ParseFunction $res $res_hdr); +@EXPORT_OK = qw(ParseFunction $res $res_hdr); use strict; use Parse::Pidl qw(fatal warning); @@ -17,7 +17,7 @@ use Parse::Pidl::Typelist qw(hasType getType mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(has_property is_constant ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::Samba4 qw(DeclLong); -use Parse::Pidl::Samba4::NDR::Parser qw(GenerateFunctionInEnv); +use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv); use vars qw($VERSION); $VERSION = '0.01'; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm index 24270340b9..efb3f2858d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/EJS.pm @@ -15,7 +15,7 @@ use Parse::Pidl::Typelist qw(typeHasBody); use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel); -use Parse::Pidl::Samba4::NDR::Parser qw(GenerateStructEnv GenerateFunctionInEnv +use Parse::Pidl::Samba4::Header qw(GenerateStructEnv GenerateFunctionInEnv GenerateFunctionOutEnv); use vars qw($VERSION); diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index b96a58783c..06e9ec4b9f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -6,10 +6,15 @@ package Parse::Pidl::Samba4::Header; +require Exporter; + +@ISA = qw(Exporter); +@EXPORT_OK = qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv); + use strict; use Parse::Pidl qw(fatal); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); -use Parse::Pidl::Util qw(has_property is_constant unmake_str); +use Parse::Pidl::Util qw(has_property is_constant unmake_str ParseExpr); use Parse::Pidl::Samba4 qw(is_intree ElementStars ArrayBrackets choose_header); use vars qw($VERSION); @@ -406,4 +411,68 @@ sub Parse($) return $res; } +sub GenerateStructEnv($$) +{ + my ($x, $v) = @_; + my %env; + + foreach my $e (@{$x->{ELEMENTS}}) { + $env{$e->{NAME}} = "$v->$e->{NAME}"; + } + + $env{"this"} = $v; + + return \%env; +} + +sub EnvSubstituteValue($$) +{ + my ($env,$s) = @_; + + # Substitute the value() values in the env + foreach my $e (@{$s->{ELEMENTS}}) { + next unless (defined(my $v = has_property($e, "value"))); + + $env->{$e->{NAME}} = ParseExpr($v, $env, $e); + } + + return $env; +} + +sub GenerateFunctionInEnv($;$) +{ + my ($fn, $base) = @_; + my %env; + + $base = "r->" unless defined($base); + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = $base."in.$e->{NAME}"; + } + } + + return \%env; +} + +sub GenerateFunctionOutEnv($;$) +{ + my ($fn, $base) = @_; + my %env; + + $base = "r->" unless defined($base); + + foreach my $e (@{$fn->{ELEMENTS}}) { + if (grep (/out/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = $base."out.$e->{NAME}"; + } elsif (grep (/in/, @{$e->{DIRECTION}})) { + $env{$e->{NAME}} = $base."in.$e->{NAME}"; + } + } + + return \%env; +} + + + 1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 8eb2f9ad15..0800a19fab 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -9,7 +9,7 @@ package Parse::Pidl::Samba4::NDR::Parser; require Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(check_null_pointer GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv NeededFunction NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint); +@EXPORT_OK = qw(check_null_pointer NeededFunction NeededElement NeededType $res NeededInterface TypeFunctionName ParseElementPrint); use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName typeHasBody); @@ -17,6 +17,7 @@ use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid); use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::Samba4 qw(is_intree choose_header); +use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv); use Parse::Pidl qw(warning); use vars qw($VERSION); @@ -193,68 +194,6 @@ sub end_flags($$) } } -sub GenerateStructEnv($$) -{ - my ($x, $v) = @_; - my %env; - - foreach my $e (@{$x->{ELEMENTS}}) { - $env{$e->{NAME}} = "$v->$e->{NAME}"; - } - - $env{"this"} = $v; - - return \%env; -} - -sub EnvSubstituteValue($$) -{ - my ($env,$s) = @_; - - # Substitute the value() values in the env - foreach my $e (@{$s->{ELEMENTS}}) { - next unless (defined(my $v = has_property($e, "value"))); - - $env->{$e->{NAME}} = ParseExpr($v, $env, $e); - } - - return $env; -} - -sub GenerateFunctionInEnv($;$) -{ - my ($fn, $base) = @_; - my %env; - - $base = "r->" unless defined($base); - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = $base."in.$e->{NAME}"; - } - } - - return \%env; -} - -sub GenerateFunctionOutEnv($;$) -{ - my ($fn, $base) = @_; - my %env; - - $base = "r->" unless defined($base); - - foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep (/out/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = $base."out.$e->{NAME}"; - } elsif (grep (/in/, @{$e->{DIRECTION}})) { - $env{$e->{NAME}} = $base."in.$e->{NAME}"; - } - } - - return \%env; -} - ##################################################################### # parse the data of an array - push side sub ParseArrayPushHeader($$$$$$) -- cgit From f7a0ef04f00cd44845bcee0a171e4cc05a545350 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 18:38:12 +0100 Subject: pidl/python: Support repr() for python types. (This used to be commit cf3664594d3540db20d32bc844f18e20abfa0d96) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 545d233d08..a5f8053834 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -214,6 +214,7 @@ sub PythonStruct($$$$) $self->pidl(".tp_dealloc = py_talloc_dealloc,"); $self->pidl(".tp_getattr = py_$name\_getattr,"); $self->pidl(".tp_setattr = py_$name\_setattr,"); + $self->pidl(".tp_repr = py_talloc_default_repr,"); $self->deindent; $self->pidl("};"); @@ -559,6 +560,8 @@ sub ConvertScalarToPython($$$) { my ($self, $ctypename, $cvar) = @_; + die("expected string for $cvar, not $ctypename") if (ref($ctypename) eq "HASH"); + $ctypename = expandAlias($ctypename); if ($ctypename =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) { @@ -583,7 +586,7 @@ sub ConvertScalarToPython($$$) if ($ctypename eq "string_array") { return "FIXME($cvar)"; } - if ($$ctypename eq "ipv4address") { return "FIXME($cvar)"; } + if ($ctypename eq "ipv4address") { return "FIXME($cvar)"; } if ($ctypename eq "pointer") { return "PyCObject_FromVoidPtr($cvar, talloc_free)"; } @@ -614,8 +617,15 @@ sub ConvertObjectToPython($$$) $actual_ctype = $ctype->{DATA}; } - if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or - ($actual_ctype->{TYPE} eq "SCALAR") { + if ($actual_ctype->{TYPE} eq "ENUM") { + return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar); + } + + if ($actual_ctype->{TYPE} eq "BITMAP") { + return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar); + } + + if ($actual_ctype->{TYPE} eq "SCALAR") { return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar); } @@ -675,18 +685,18 @@ sub Parse($$$$$) $self->indent; $self->pidl("PyObject *m;"); $self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);"); - foreach (keys %{$self->{constants}}) { + foreach my $name (keys %{$self->{constants}}) { my $py_obj; - my ($ctype, $cvar) = @{$self->{constants}->{$_}}; + my ($ctype, $cvar) = @{$self->{constants}->{$name}}; if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) { $py_obj = "PyInt_FromLong($cvar)"; } elsif ($cvar =~ /^".*"$/) { $py_obj = "PyString_FromString($cvar)"; } else { - $py_obj = $self->ConvertScalarToPython($ctype, $cvar); + $py_obj = $self->ConvertObjectToPython($ctype, $cvar); } - $self->pidl("PyModule_AddObject(m, \"$_\", $py_obj);"); + $self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);"); } $self->deindent; $self->pidl("}"); -- cgit From bfab9862fcdd657a1bddafde49cdd182f89fcf8b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 20:41:34 +0100 Subject: python: Allow wrapping pointers within talloc'ed memory that are not talloc contexts. (This used to be commit 9c038a74113fb55ed5eb12a7d0ae4a46bad9050c) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 44 ++++++++++++++++++---------- 1 file changed, 28 insertions(+), 16 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index a5f8053834..cea3889938 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -138,7 +138,7 @@ sub FromPythonToUnionFunction($$$$$) } $self->indent; if ($e->{NAME}) { - $self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, $name, "ret->$e->{NAME}"); + $self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;"); } $self->pidl("break;"); $self->deindent; @@ -164,8 +164,6 @@ sub PythonStruct($$$$) { my ($self, $name, $cname, $d) = @_; - $self->pidl("staticforward PyTypeObject $name\_ObjectType;"); - $self->pidl(""); $self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)"); @@ -190,12 +188,15 @@ sub PythonStruct($$$$) $self->pidl("{"); $self->indent; $self->pidl("$cname *object = py_talloc_get_type(py_obj, $cname);"); + $self->pidl("TALLOC_CTX *mem_ctx = py_talloc_get_mem_ctx(py_obj);"); foreach my $e (@{$d->{ELEMENTS}}) { $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; $self->indent; - $self->pidl("/* FIXME: talloc_free($varname) if necessary */"); - $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname); + if ($e->{ORIGINAL}->{POINTERS} > 0) { + $self->pidl("talloc_free($varname);"); + } + $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname, "talloc_free(mem_ctx); return -1;"); $self->pidl("return 0;"); $self->deindent; $self->pidl("}"); @@ -206,7 +207,11 @@ sub PythonStruct($$$$) $self->pidl("}"); $self->pidl(""); - $self->pidl("static PyTypeObject $name\_ObjectType = {"); + $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $name\_Type;\n"); + $self->pidl_hdr("#define $name\_Check(op) PyObject_TypeCheck(op, &$name\_Type)\n"); + $self->pidl_hdr("#define $name\_CheckExact(op) ((op)->ob_type == &$name\_Type)\n"); + $self->pidl_hdr("\n"); + $self->pidl("PyTypeObject $name\_Type = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); $self->pidl(".tp_name = \"$name\","); @@ -225,7 +230,7 @@ sub PythonStruct($$$$) $self->pidl("{"); $self->indent; $self->pidl("$cname *ret = talloc_zero(NULL, $cname);"); - $self->pidl("return py_talloc_import(&$name\_ObjectType, ret);"); + $self->pidl("return py_talloc_import(&$name\_Type, ret);"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -265,7 +270,7 @@ sub PythonFunction($$$) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}", "r.in.$e->{NAME}"); + $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;"); } } $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);"); @@ -377,7 +382,7 @@ sub Interface($$$) $self->PythonType($d, $interface, $basename); } - $self->pidl("staticforward PyTypeObject $interface->{NAME}_InterfaceType;"); + $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n"); $self->pidl("typedef struct {"); $self->indent; $self->pidl("PyObject_HEAD"); @@ -430,13 +435,13 @@ sub Interface($$$) $self->pidl(""); - $self->pidl("static PyTypeObject $interface->{NAME}_InterfaceType = {"); + $self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); $self->pidl(".tp_name = \"$interface->{NAME}\","); $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); - $self->pidl(".tp_dealloc = (destructor)interface_$interface->{NAME}_dealloc,"); - $self->pidl(".tp_getattr = (getattrfunc)interface_$interface->{NAME}_getattr,"); + $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); + $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); $self->deindent; $self->pidl("};"); @@ -479,9 +484,9 @@ sub register_module_method($$$$$) push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) } -sub ConvertObjectFromPython($$$$$) +sub ConvertObjectFromPython($$$$$$) { - my ($self, $mem_ctx, $ctype, $cvar, $target) = @_; + my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_; die("undef type for $cvar") unless(defined($ctype)); @@ -502,12 +507,14 @@ sub ConvertObjectFromPython($$$$$) if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or $actual_ctype->{TYPE} eq "SCALAR" and ( expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) { + $self->pidl("PY_CHECK_TYPE(PyInt, $cvar, $fail);"); $self->pidl("$target = PyInt_AsLong($cvar);"); return; } if ($actual_ctype->{TYPE} eq "STRUCT") { - $self->pidl("$target = py_talloc_get_type($cvar, " . mapTypeName($ctype) . ");"); + $self->pidl("PY_CHECK_TYPE($ctype->{NAME}, $cvar, $fail);"); + $self->pidl("$target = py_talloc_get_ptr($cvar);"); return; } @@ -635,7 +642,7 @@ sub ConvertObjectToPython($$$) if ($actual_ctype->{TYPE} eq "STRUCT") { # FIXME: if $cvar is not a pointer, do a talloc_dup() - return "py_talloc_import(&$ctype->{NAME}_ObjectType, $cvar)"; + return "py_talloc_import(&$ctype->{NAME}_Type, $cvar)"; } die("unknown type ".mapTypeName($ctype) . ": $cvar"); @@ -660,6 +667,11 @@ sub Parse($$$$$) #include \"$ndr_hdr\" #include \"$py_hdr\" +#define PY_CHECK_TYPE(type, var, fail) \\ + if (!type ## _Check(var)) {\\ + PyErr_Format(PyExc_TypeError, \"Expected type %s\", type ## _Type.tp_name); \\ + fail; \\ + } "); foreach my $x (@$ndr) { -- cgit From 41057618f890b9053dce9cd671d11db7af7d3612 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 21:23:12 +0100 Subject: pidl/python: Remove unnecessary talloc_free(). (This used to be commit a099d30067a4d965a283f52e56ffd1897137bf1a) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index cea3889938..93a6161ce4 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -196,7 +196,7 @@ sub PythonStruct($$$$) if ($e->{ORIGINAL}->{POINTERS} > 0) { $self->pidl("talloc_free($varname);"); } - $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname, "talloc_free(mem_ctx); return -1;"); + $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname, "return -1;"); $self->pidl("return 0;"); $self->deindent; $self->pidl("}"); -- cgit From d8b21ae2534d5b51c1dc5a4c50b3de5ddb32af80 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 13 Jan 2008 23:13:30 +0100 Subject: pidl/python: Fix use of pointers. (This used to be commit 13f2b0380f310b101975d709361a29d4032c3689) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 81 ++++++++++++++++++++++++---- 1 file changed, 70 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 93a6161ce4..2d6ec50d39 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -11,6 +11,7 @@ use Exporter; use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName expandAlias); use Parse::Pidl::Util qw(has_property ParseExpr); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); use Parse::Pidl::CUtil qw(get_value_of get_pointer_to); use vars qw($VERSION); @@ -100,7 +101,7 @@ sub FromUnionToPythonFunction($$$) my $conv; if ($e->{NAME}) { - $conv = $self->ConvertObjectToPython($e->{TYPE}, "$name->$e->{NAME}"); + $conv = $self->ConvertObjectToPython($e, "$name->$e->{NAME}"); } else { $conv = "Py_None"; } @@ -138,7 +139,7 @@ sub FromPythonToUnionFunction($$$$$) } $self->indent; if ($e->{NAME}) { - $self->ConvertObjectFromPython($mem_ctx, $e->{TYPE}, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;"); + $self->ConvertObjectFromPython($mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;"); } $self->pidl("break;"); $self->deindent; @@ -174,7 +175,7 @@ sub PythonStruct($$$$) $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; $self->indent; - $self->pidl("return ".$self->ConvertObjectToPython($e->{TYPE}, $varname) . ";"); + $self->pidl("return ".$self->ConvertObjectToPython($e, $varname) . ";"); $self->deindent; $self->pidl("}"); } @@ -188,7 +189,7 @@ sub PythonStruct($$$$) $self->pidl("{"); $self->indent; $self->pidl("$cname *object = py_talloc_get_type(py_obj, $cname);"); - $self->pidl("TALLOC_CTX *mem_ctx = py_talloc_get_mem_ctx(py_obj);"); + my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)"; foreach my $e (@{$d->{ELEMENTS}}) { $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; @@ -196,7 +197,7 @@ sub PythonStruct($$$$) if ($e->{ORIGINAL}->{POINTERS} > 0) { $self->pidl("talloc_free($varname);"); } - $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "value", $varname, "return -1;"); + $self->ConvertObjectFromPython($mem_ctx, $e, "value", $varname, "return -1;"); $self->pidl("return 0;"); $self->deindent; $self->pidl("}"); @@ -270,7 +271,7 @@ sub PythonFunction($$$) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - $self->ConvertObjectFromPython("mem_ctx", $e->{TYPE}, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;"); + $self->ConvertObjectFromPython("mem_ctx", $e, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;"); } } $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);"); @@ -282,14 +283,14 @@ sub PythonFunction($$$) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($e->{TYPE}, "r.out.$e->{NAME}") . ");"); + $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($e, "r.out.$e->{NAME}") . ");"); $i++; } } if (defined($fn->{RETURN_TYPE})) { - $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($fn->{RETURN_TYPE}, "r.out.result") . ");"); + $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPythonData($fn->{RETURN_TYPE}, "r.out.result") . ");"); } $self->pidl("talloc_free(mem_ctx);"); @@ -484,7 +485,7 @@ sub register_module_method($$$$$) push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) } -sub ConvertObjectFromPython($$$$$$) +sub convertObjectFromPythonData($$$$$$) { my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_; @@ -561,6 +562,36 @@ sub ConvertObjectFromPython($$$$$$) } die("unknown type ".mapTypeName($ctype) . ": $cvar"); + +} + +sub ConvertObjectFromPythonLevel($$$$$$$) +{ + my ($self, $mem_ctx, $e, $l, $var_name, $target, $fail) = @_; + + if ($l->{TYPE} eq "POINTER") { + $self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail); + } elsif ($l->{TYPE} eq "ARRAY") { + $self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), $var_name."[i]", $target, $fail); + } elsif ($l->{TYPE} eq "DATA") { + if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or + Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + $var_name = get_pointer_to($var_name); + } + $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name, $target, $fail); + } elsif ($l->{TYPE} eq "SWITCH") { + $self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail); + } else { + die("unknown level type $l->{TYPE}"); + } +} + +sub ConvertObjectFromPython($$$$$$) +{ + my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_; + + $self->ConvertObjectFromPythonLevel($mem_ctx, $ctype, $ctype->{LEVELS}[0], + $cvar, $target, $fail); } sub ConvertScalarToPython($$$) @@ -601,7 +632,7 @@ sub ConvertScalarToPython($$$) die("Unknown scalar type $ctypename"); } -sub ConvertObjectToPython($$$) +sub ConvertObjectToPythonData($$$) { my ($self, $ctype, $cvar) = @_; @@ -648,6 +679,34 @@ sub ConvertObjectToPython($$$) die("unknown type ".mapTypeName($ctype) . ": $cvar"); } +sub ConvertObjectToPythonLevel($$$$) +{ + my ($self, $e, $l, $var_name) = @_; + + if ($l->{TYPE} eq "POINTER") { + $self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), get_value_of($var_name)); + } elsif ($l->{TYPE} eq "ARRAY") { + $self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name."[i]"); + } elsif ($l->{TYPE} eq "SWITCH") { + $self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name); + } elsif ($l->{TYPE} eq "DATA") { + if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or + Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + $var_name = get_pointer_to($var_name); + } + $self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name); + } else { + die("Unknown level type $l->{TYPE} $var_name"); + } +} + +sub ConvertObjectToPython($$$) +{ + my ($self, $ctype, $cvar) = @_; + + $self->ConvertObjectToPythonLevel($ctype, $ctype->{LEVELS}[0], $cvar); +} + sub Parse($$$$$) { my($self,$basename,$ndr,$ndr_hdr,$hdr) = @_; @@ -705,7 +764,7 @@ sub Parse($$$$$) } elsif ($cvar =~ /^".*"$/) { $py_obj = "PyString_FromString($cvar)"; } else { - $py_obj = $self->ConvertObjectToPython($ctype, $cvar); + $py_obj = $self->ConvertObjectToPythonData($ctype, $cvar); } $self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);"); -- cgit From 5d60cb6ef1c63ce771ab44b6831147568061aa50 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 01:30:44 +0100 Subject: pidl/python: Fix parsing arguments, fix more pointer issues. (This used to be commit b00c1a072457e5083ffc24a8b74b3793d0b44eee) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 17 ++- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 2 - source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 15 +-- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 162 ++++++++++++++++++----- 4 files changed, 146 insertions(+), 50 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 1d059ebdf7..fc6bfe4c96 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -35,7 +35,7 @@ use vars qw($VERSION); $VERSION = '0.01'; @ISA = qw(Exporter); @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString); -@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType can_contain_deferred); +@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType can_contain_deferred is_charset_array); use strict; use Parse::Pidl qw(warning fatal); @@ -1181,4 +1181,19 @@ sub Validate($) } } +sub is_charset_array($$) +{ + my ($e,$l) = @_; + + return 0 if ($l->{TYPE} ne "ARRAY"); + + my $nl = GetNextLevel($e,$l); + + return 0 unless ($nl->{TYPE} eq "DATA"); + + return has_property($e, "charset"); +} + + + 1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 06e9ec4b9f..2b3a9df80f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -473,6 +473,4 @@ sub GenerateFunctionOutEnv($;$) return \%env; } - - 1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 0800a19fab..02d3a80992 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -15,7 +15,7 @@ use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName typeHasBody); use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid); use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array); use Parse::Pidl::Samba4 qw(is_intree choose_header); use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv); use Parse::Pidl qw(warning); @@ -78,19 +78,6 @@ sub has_fast_array($$) return ($t->{NAME} eq "uint8") or ($t->{NAME} eq "string"); } -sub is_charset_array($$) -{ - my ($e,$l) = @_; - - return 0 if ($l->{TYPE} ne "ARRAY"); - - my $nl = GetNextLevel($e,$l); - - return 0 unless ($nl->{TYPE} eq "DATA"); - - return has_property($e, "charset"); -} - #################################### # pidl() is our basic output routine diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 2d6ec50d39..9a3e82a94b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -11,8 +11,9 @@ use Exporter; use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName expandAlias); use Parse::Pidl::Util qw(has_property ParseExpr); -use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred); +use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array); use Parse::Pidl::CUtil qw(get_value_of get_pointer_to); +use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv); use vars qw($VERSION); $VERSION = '0.01'; @@ -94,22 +95,31 @@ sub FromUnionToPythonFunction($$$) { my ($self, $type, $switch, $name) = @_; + $self->pidl("PyObject *ret;"); + $self->pidl(""); + $self->pidl("switch ($switch) {"); $self->indent; foreach my $e (@{$type->{ELEMENTS}}) { - my $conv; - - if ($e->{NAME}) { - $conv = $self->ConvertObjectToPython($e, "$name->$e->{NAME}"); + if (defined($e->{CASE})) { + $self->pidl("$e->{CASE}:"); } else { - $conv = "Py_None"; + $self->pidl("default:"); } - if (defined($e->{CASE})) { - $self->pidl("$e->{CASE}: return $conv;"); + + $self->indent; + + if ($e->{NAME}) { + $self->ConvertObjectToPython({}, $e, "$name->$e->{NAME}", "ret"); } else { - $self->pidl("default: return $conv;"); + $self->pidl("ret = Py_None;"); } + + $self->pidl("return ret;"); + $self->pidl(""); + + $self->deindent; } $self->deindent; @@ -165,6 +175,8 @@ sub PythonStruct($$$$) { my ($self, $name, $cname, $d) = @_; + my $env = GenerateStructEnv($d, "object"); + $self->pidl(""); $self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)"); @@ -175,7 +187,9 @@ sub PythonStruct($$$$) $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; $self->indent; - $self->pidl("return ".$self->ConvertObjectToPython($e, $varname) . ";"); + $self->pidl("PyObject *py_$e->{NAME};"); + $self->ConvertObjectToPython($env, $e, $varname, "py_$e->{NAME}"); + $self->pidl("return py_$e->{NAME};"); $self->deindent; $self->pidl("}"); } @@ -243,7 +257,7 @@ sub PythonFunction($$$) { my ($self, $fn, $iface) = @_; - $self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args)"); + $self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)"); $self->pidl("{"); $self->indent; $self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;"); @@ -251,16 +265,38 @@ sub PythonFunction($$$) $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); $self->pidl("struct $fn->{NAME} r;"); $self->pidl("PyObject *result;"); + + my $env = GenerateFunctionInEnv($fn, "r."); my $result_size = 0; + my $args_format = ""; + my $args_string = ""; + my $args_names = ""; + foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep(/in/,@{$e->{DIRECTION}})) { - $self->pidl("PyObject *py_$e->{NAME};"); - } + $self->pidl("PyObject *py_$e->{NAME};"); if (grep(/out/,@{$e->{DIRECTION}})) { $result_size++; } + if (grep(/in/,@{$e->{DIRECTION}})) { + $args_format .= "O"; + $args_string .= ", &py_$e->{NAME}"; + $args_names .= "\"$e->{NAME}\", "; + } } + $self->pidl("const char *kwnames[] = {"); + $self->indent; + $self->pidl($args_names . "NULL"); + $self->deindent; + $self->pidl("};"); + + $self->pidl(""); + $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"$args_format:$fn->{NAME}\", discard_const_p(char *, kwnames)$args_string)) {"); + $self->indent; + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + if ($result_size > 0) { $self->pidl(""); $self->pidl("ZERO_STRUCT(r.out);"); @@ -279,11 +315,13 @@ sub PythonFunction($$$) $self->pidl("result = PyTuple_New($result_size);"); + $env = GenerateFunctionOutEnv($fn, "r."); my $i = 0; foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPython($e, "r.out.$e->{NAME}") . ");"); + $self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", "py_$e->{NAME}"); + $self->pidl("PyTuple_SetItem(result, $i, py_$e->{NAME});"); $i++; } @@ -485,9 +523,9 @@ sub register_module_method($$$$$) push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) } -sub convertObjectFromPythonData($$$$$$) +sub ConvertObjectFromPythonData($$$$$$) { - my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_; + my ($self, $mem_ctx, $cvar, $ctype, $target, $fail) = @_; die("undef type for $cvar") unless(defined($ctype)); @@ -567,20 +605,45 @@ sub convertObjectFromPythonData($$$$$$) sub ConvertObjectFromPythonLevel($$$$$$$) { - my ($self, $mem_ctx, $e, $l, $var_name, $target, $fail) = @_; + my ($self, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_; if ($l->{TYPE} eq "POINTER") { - $self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail); + if ($l->{POINTER_TYPE} ne "ref") { + $self->pidl("if ($py_var == Py_None) {"); + $self->indent; + $self->pidl("$var_name = NULL;"); + $self->deindent; + $self->pidl("} else {"); + $self->indent; + } + $self->ConvertObjectFromPythonLevel($mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail); + if ($l->{POINTER_TYPE} ne "ref") { + $self->deindent; + $self->pidl("}"); + } } elsif ($l->{TYPE} eq "ARRAY") { - $self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), $var_name."[i]", $target, $fail); + if (is_charset_array($e, $l)) { + $self->pidl("$var_name = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));"); + } else { + my $counter = "i"; + $self->pidl("$var_name = talloc_array($mem_ctx, FIXME, PyList_Length($py_var));"); + $self->pidl("for ($counter = 0; $counter < PyList_Length($py_var); $counter++) {"); + $self->indent; + $self->ConvertObjectFromPythonLevel($var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail); + $self->deindent; + $self->pidl("}"); + } } elsif ($l->{TYPE} eq "DATA") { + if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); } - $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name, $target, $fail); + $self->ConvertObjectFromPythonData($mem_ctx, $py_var, $l->{DATA_TYPE}, $var_name, $fail); } elsif ($l->{TYPE} eq "SWITCH") { - $self->ConvertObjectFromPythonLevel($mem_ctx, $e, GetNextLevel($e, $l), get_value_of($var_name), $target, $fail); + $self->ConvertObjectFromPythonLevel($mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail); + } elsif ($l->{TYPE} eq "SUBCONTEXT") { + $self->pidl("FIXME"); } else { die("unknown level type $l->{TYPE}"); } @@ -590,8 +653,7 @@ sub ConvertObjectFromPython($$$$$$) { my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_; - $self->ConvertObjectFromPythonLevel($mem_ctx, $ctype, $ctype->{LEVELS}[0], - $cvar, $target, $fail); + $self->ConvertObjectFromPythonLevel($mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail); } sub ConvertScalarToPython($$$) @@ -632,7 +694,7 @@ sub ConvertScalarToPython($$$) die("Unknown scalar type $ctypename"); } -sub ConvertObjectToPythonData($$$) +sub ConvertObjectToPythonData($$$$) { my ($self, $ctype, $cvar) = @_; @@ -681,30 +743,64 @@ sub ConvertObjectToPythonData($$$) sub ConvertObjectToPythonLevel($$$$) { - my ($self, $e, $l, $var_name) = @_; + my ($self, $env, $e, $l, $var_name, $py_var) = @_; if ($l->{TYPE} eq "POINTER") { - $self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), get_value_of($var_name)); + if ($l->{POINTER_TYPE} ne "ref") { + $self->pidl("if ($var_name == NULL) {"); + $self->indent; + $self->pidl("$py_var = Py_None;"); + $self->deindent; + $self->pidl("} else {"); + $self->indent; + } + $self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), get_value_of($var_name), $py_var); + if ($l->{POINTER_TYPE} ne "ref") { + $self->deindent; + $self->pidl("}"); + } } elsif ($l->{TYPE} eq "ARRAY") { - $self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name."[i]"); + if (is_charset_array($e, $l)) { + $self->pidl("$py_var = PyUnicode_Decode($var_name, strlen($var_name), \"utf-8\", \"ignore\");"); + } else { + die("No SIZE_IS for array $var_name") unless (defined($l->{SIZE_IS})); + my $length = $l->{SIZE_IS}; + if (defined($l->{LENGTH_IS})) { + $length = $l->{LENGTH_IS}; + } + + $length = ParseExpr($length, $env, $e); + $self->pidl("$py_var = PyList_New($length);"); + my $counter = "i"; + $self->pidl("for ($counter = 0; $counter < $length; $counter++) {"); + $self->indent; + my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}"; + $self->pidl("PyObject *$member_var;"); + $self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), $var_name."[$counter]", $member_var); + $self->pidl("PyList_SetItem($py_var, $counter, $member_var);"); + $self->deindent; + $self->pidl("}"); + } } elsif ($l->{TYPE} eq "SWITCH") { - $self->ConvertObjectToPythonLevel($e, GetNextLevel($e, $l), $var_name); + $self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), $var_name, $py_var); } elsif ($l->{TYPE} eq "DATA") { if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); } - $self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name); + $self->pidl("$py_var = ".$self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name) . ";"); + } elsif ($l->{TYPE} eq "SUBCONTEXT") { + $self->pidl("FIXME"); } else { die("Unknown level type $l->{TYPE} $var_name"); } } -sub ConvertObjectToPython($$$) +sub ConvertObjectToPython($$$$$) { - my ($self, $ctype, $cvar) = @_; + my ($self, $env, $ctype, $cvar, $py_var) = @_; - $self->ConvertObjectToPythonLevel($ctype, $ctype->{LEVELS}[0], $cvar); + $self->ConvertObjectToPythonLevel($env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var); } sub Parse($$$$$) -- cgit From 657e0cc4d09a89944445b17fd3fdc56e777917d0 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 02:04:06 +0100 Subject: pidl/python: Fix more compile errors. (This used to be commit 2eb4526599ec6d3c604dd9b1f258496c82288284) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 58 +++++++++++++++------------- 1 file changed, 32 insertions(+), 26 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 9a3e82a94b..a2ad3c6508 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -149,7 +149,7 @@ sub FromPythonToUnionFunction($$$$$) } $self->indent; if ($e->{NAME}) { - $self->ConvertObjectFromPython($mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;"); + $self->ConvertObjectFromPython({}, $mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;"); } $self->pidl("break;"); $self->deindent; @@ -211,7 +211,7 @@ sub PythonStruct($$$$) if ($e->{ORIGINAL}->{POINTERS} > 0) { $self->pidl("talloc_free($varname);"); } - $self->ConvertObjectFromPython($mem_ctx, $e, "value", $varname, "return -1;"); + $self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;"); $self->pidl("return 0;"); $self->deindent; $self->pidl("}"); @@ -307,7 +307,7 @@ sub PythonFunction($$$) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - $self->ConvertObjectFromPython("mem_ctx", $e, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;"); + $self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;"); } } $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);"); @@ -557,11 +557,6 @@ sub ConvertObjectFromPythonData($$$$$$) return; } - if ($actual_ctype->{TYPE} eq "UNION") { - $self->pidl("$target = py_export_$ctype->{NAME}($cvar);"); - return; - } - if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") { $self->pidl("$target = data_blob_talloc($mem_ctx, PyString_AsString($cvar), PyString_Size($cvar));"); return; @@ -603,9 +598,9 @@ sub ConvertObjectFromPythonData($$$$$$) } -sub ConvertObjectFromPythonLevel($$$$$$$) +sub ConvertObjectFromPythonLevel($$$$$$$$) { - my ($self, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_; + my ($self, $env, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_; if ($l->{TYPE} eq "POINTER") { if ($l->{POINTER_TYPE} ne "ref") { @@ -616,20 +611,25 @@ sub ConvertObjectFromPythonLevel($$$$$$$) $self->pidl("} else {"); $self->indent; } - $self->ConvertObjectFromPythonLevel($mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail); + $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail); if ($l->{POINTER_TYPE} ne "ref") { $self->deindent; $self->pidl("}"); } } elsif ($l->{TYPE} eq "ARRAY") { if (is_charset_array($e, $l)) { - $self->pidl("$var_name = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));"); + $self->pidl(get_pointer_to($var_name) . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));"); } else { - my $counter = "i"; - $self->pidl("$var_name = talloc_array($mem_ctx, FIXME, PyList_Length($py_var));"); - $self->pidl("for ($counter = 0; $counter < PyList_Length($py_var); $counter++) {"); + my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}"; + $self->pidl("{"); $self->indent; - $self->ConvertObjectFromPythonLevel($var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail); + $self->pidl("int $counter;"); + $self->pidl("$var_name = talloc_array($mem_ctx, FIXME, PyList_Size($py_var));"); + $self->pidl("for ($counter = 0; $counter < PyList_Size($py_var); $counter++) {"); + $self->indent; + $self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail); + $self->deindent; + $self->pidl("}"); $self->deindent; $self->pidl("}"); } @@ -641,7 +641,9 @@ sub ConvertObjectFromPythonLevel($$$$$$$) } $self->ConvertObjectFromPythonData($mem_ctx, $py_var, $l->{DATA_TYPE}, $var_name, $fail); } elsif ($l->{TYPE} eq "SWITCH") { - $self->ConvertObjectFromPythonLevel($mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail); + $var_name = get_pointer_to($var_name); + my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e); + $self->pidl("$var_name = py_export_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $py_var);"); } elsif ($l->{TYPE} eq "SUBCONTEXT") { $self->pidl("FIXME"); } else { @@ -649,11 +651,11 @@ sub ConvertObjectFromPythonLevel($$$$$$$) } } -sub ConvertObjectFromPython($$$$$$) +sub ConvertObjectFromPython($$$$$$$) { - my ($self, $mem_ctx, $ctype, $cvar, $target, $fail) = @_; + my ($self, $env, $mem_ctx, $ctype, $cvar, $target, $fail) = @_; - $self->ConvertObjectFromPythonLevel($mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail); + $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail); } sub ConvertScalarToPython($$$) @@ -729,10 +731,6 @@ sub ConvertObjectToPythonData($$$$) return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar); } - if ($actual_ctype->{TYPE} eq "UNION") { - return "py_import_$ctype->{NAME}($cvar)"; - } - if ($actual_ctype->{TYPE} eq "STRUCT") { # FIXME: if $cvar is not a pointer, do a talloc_dup() return "py_talloc_import(&$ctype->{NAME}_Type, $cvar)"; @@ -761,6 +759,7 @@ sub ConvertObjectToPythonLevel($$$$) } } elsif ($l->{TYPE} eq "ARRAY") { if (is_charset_array($e, $l)) { + $var_name = get_pointer_to($var_name); $self->pidl("$py_var = PyUnicode_Decode($var_name, strlen($var_name), \"utf-8\", \"ignore\");"); } else { die("No SIZE_IS for array $var_name") unless (defined($l->{SIZE_IS})); @@ -771,7 +770,10 @@ sub ConvertObjectToPythonLevel($$$$) $length = ParseExpr($length, $env, $e); $self->pidl("$py_var = PyList_New($length);"); - my $counter = "i"; + $self->pidl("{"); + $self->indent; + my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}"; + $self->pidl("int $counter;"); $self->pidl("for ($counter = 0; $counter < $length; $counter++) {"); $self->indent; my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}"; @@ -780,9 +782,13 @@ sub ConvertObjectToPythonLevel($$$$) $self->pidl("PyList_SetItem($py_var, $counter, $member_var);"); $self->deindent; $self->pidl("}"); + $self->deindent; + $self->pidl("}"); } } elsif ($l->{TYPE} eq "SWITCH") { - $self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), $var_name, $py_var); + $var_name = get_pointer_to($var_name); + my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e); + $self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($switch, $var_name);"); } elsif ($l->{TYPE} eq "DATA") { if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { -- cgit From 2afa1bee549ae119b1088c1e6affaec6f1997887 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 02:27:40 +0100 Subject: python/pidl: Fix assignment. (This used to be commit 2d2cb6486e6e1a31ae94223784e49fb4eea8bb26) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index a2ad3c6508..a7e1791793 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -322,7 +322,6 @@ sub PythonFunction($$$) if (grep(/out/,@{$e->{DIRECTION}})) { $self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", "py_$e->{NAME}"); $self->pidl("PyTuple_SetItem(result, $i, py_$e->{NAME});"); - $i++; } } @@ -523,6 +522,16 @@ sub register_module_method($$$$$) push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) } +sub assign($$$) +{ + my ($self, $dest, $src) = @_; + if ($dest =~ /^\&/) { + $self->pidl("memcpy($dest, $src, sizeof(*$dest));"); + } else { + $self->pidl("$dest = $src;"); + } +} + sub ConvertObjectFromPythonData($$$$$$) { my ($self, $mem_ctx, $cvar, $ctype, $target, $fail) = @_; @@ -553,7 +562,7 @@ sub ConvertObjectFromPythonData($$$$$$) if ($actual_ctype->{TYPE} eq "STRUCT") { $self->pidl("PY_CHECK_TYPE($ctype->{NAME}, $cvar, $fail);"); - $self->pidl("$target = py_talloc_get_ptr($cvar);"); + $self->assign($target, "py_talloc_get_ptr($cvar)"); return; } @@ -590,7 +599,7 @@ sub ConvertObjectFromPythonData($$$$$$) } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") { - $self->pidl("$target = PyCObject_AsVoidPtr($cvar);"); + $self->assign($target, "PyCObject_AsVoidPtr($cvar)"); return; } @@ -624,7 +633,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) $self->pidl("{"); $self->indent; $self->pidl("int $counter;"); - $self->pidl("$var_name = talloc_array($mem_ctx, FIXME, PyList_Size($py_var));"); + $self->pidl("$var_name = talloc_array_ptrtype($mem_ctx, $var_name, PyList_Size($py_var));"); $self->pidl("for ($counter = 0; $counter < PyList_Size($py_var); $counter++) {"); $self->indent; $self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail); @@ -645,7 +654,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e); $self->pidl("$var_name = py_export_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $py_var);"); } elsif ($l->{TYPE} eq "SUBCONTEXT") { - $self->pidl("FIXME"); + $self->pidl("#error Subcontext not yet supported"); } else { die("unknown level type $l->{TYPE}"); } @@ -686,9 +695,9 @@ sub ConvertScalarToPython($$$) return "PyString_FromString($cvar)"; } - if ($ctypename eq "string_array") { return "FIXME($cvar)"; } - - if ($ctypename eq "ipv4address") { return "FIXME($cvar)"; } + # Not yet supported + if ($ctypename eq "string_array") { return "PyCObject_FromVoidPtr($cvar)"; } + if ($ctypename eq "ipv4address") { return "PyCObject_FromVoidPtr($cvar)"; } if ($ctypename eq "pointer") { return "PyCObject_FromVoidPtr($cvar, talloc_free)"; } @@ -794,7 +803,8 @@ sub ConvertObjectToPythonLevel($$$$) Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); } - $self->pidl("$py_var = ".$self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name) . ";"); + my $conv = $self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name); + $self->pidl("$py_var = $conv;"); } elsif ($l->{TYPE} eq "SUBCONTEXT") { $self->pidl("FIXME"); } else { -- cgit From d5903fd75e9640831f0e78fc04d3ffa5ea3b1b4a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 02:48:50 +0100 Subject: pidl/python: Fix compilation of py_echo. (This used to be commit 5ee99ff31c80ece6861b2a0323d71170ef9346b9) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index a7e1791793..f569f013dc 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -384,7 +384,7 @@ sub PythonType($$$) $self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA}); } - if ($actual_ctype->{TYPE} eq "UNION") { + if ($actual_ctype->{TYPE} eq "UNION" and defined($actual_ctype->{ELEMENTS})) { $self->pidl("PyObject *py_import_$d->{NAME}(int level, " .mapTypeName($d) . " *in)"); $self->pidl("{"); $self->indent; @@ -486,7 +486,7 @@ sub Interface($$$) $self->pidl(""); $self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL"); - $self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args)"); + $self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)"); $self->pidl("{"); $self->indent; $self->pidl("$interface->{NAME}_InterfaceObject *ret;"); @@ -496,6 +496,18 @@ sub Interface($$$) $self->pidl("TALLOC_CTX *mem_ctx = NULL;"); $self->pidl("NTSTATUS status;"); $self->pidl(""); + $self->pidl("const char *kwnames[] = {"); + $self->indent; + $self->pidl("\"binding\", NULL"); + $self->deindent; + $self->pidl("};"); + $self->pidl(""); + $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string)) {"); + $self->indent; + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); # FIXME: Arguments: binding string, credentials, loadparm context $self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);"); -- cgit From db4ee4cce5f1fd84f3f0a331e769a70394126ca5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 03:59:36 +0100 Subject: python: Fix rpcecho tests. (This used to be commit ebb78ea4232c1614755844849580e3697b0a53fa) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index f569f013dc..266a092788 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -491,8 +491,8 @@ sub Interface($$$) $self->indent; $self->pidl("$interface->{NAME}_InterfaceObject *ret;"); $self->pidl("const char *binding_string;"); - $self->pidl("struct cli_credentials *credentials;"); - $self->pidl("struct loadparm_context *lp_ctx;"); + $self->pidl("struct cli_credentials *credentials = NULL;"); + $self->pidl("struct loadparm_context *lp_ctx = NULL;"); $self->pidl("TALLOC_CTX *mem_ctx = NULL;"); $self->pidl("NTSTATUS status;"); $self->pidl(""); -- cgit From 3b16c532f21202696d54ef87f8fa74d066812898 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 05:16:51 +0100 Subject: pidl/python: Pass credentials and loadparm context when connecting using DCE/RPC. (This used to be commit 4c87af95310e4aaee3f2e2da02d0ea70ed1ec25b) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 59 ++++++++++++++++++++++------ 1 file changed, 48 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 266a092788..04649d3668 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -264,7 +264,7 @@ sub PythonFunction($$$) $self->pidl("NTSTATUS status;"); $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); $self->pidl("struct $fn->{NAME} r;"); - $self->pidl("PyObject *result;"); + $self->pidl("PyObject *result = Py_None;"); my $env = GenerateFunctionInEnv($fn, "r."); my $result_size = 0; @@ -313,21 +313,33 @@ sub PythonFunction($$$) $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);"); $self->handle_ntstatus("status", "NULL", "mem_ctx"); - $self->pidl("result = PyTuple_New($result_size);"); - $env = GenerateFunctionOutEnv($fn, "r."); my $i = 0; + if ($result_size > 1) { + $self->pidl("result = PyTuple_New($result_size);"); + } + foreach my $e (@{$fn->{ELEMENTS}}) { + my $py_name = "py_$e->{NAME}"; if (grep(/out/,@{$e->{DIRECTION}})) { - $self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", "py_$e->{NAME}"); - $self->pidl("PyTuple_SetItem(result, $i, py_$e->{NAME});"); - $i++; + $self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", $py_name); + if ($result_size > 1) { + $self->pidl("PyTuple_SetItem(result, $i, $py_name);"); + $i++; + } else { + $self->pidl("result = $py_name;"); + } } } if (defined($fn->{RETURN_TYPE})) { - $self->pidl("PyTuple_SetItem(result, $i, " . $self->ConvertObjectToPythonData($fn->{RETURN_TYPE}, "r.out.result") . ");"); + my $conv = $self->ConvertObjectToPythonData($fn->{RETURN_TYPE}, "r.out.result"); + if ($result_size > 1) { + $self->pidl("PyTuple_SetItem(result, $i, $conv);"); + } else { + $self->pidl("result = $conv;"); + } } $self->pidl("talloc_free(mem_ctx);"); @@ -446,6 +458,7 @@ sub Interface($$$) my $fn_name = $d->{NAME}; $fn_name =~ s/^$interface->{NAME}_//; + $fn_name =~ s/^$basename\_//; $self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); } @@ -491,25 +504,47 @@ sub Interface($$$) $self->indent; $self->pidl("$interface->{NAME}_InterfaceObject *ret;"); $self->pidl("const char *binding_string;"); - $self->pidl("struct cli_credentials *credentials = NULL;"); + $self->pidl("struct cli_credentials *credentials;"); $self->pidl("struct loadparm_context *lp_ctx = NULL;"); + $self->pidl("PyObject *py_lp_ctx = NULL, *py_credentials = Py_None;"); $self->pidl("TALLOC_CTX *mem_ctx = NULL;"); $self->pidl("NTSTATUS status;"); $self->pidl(""); $self->pidl("const char *kwnames[] = {"); $self->indent; - $self->pidl("\"binding\", NULL"); + $self->pidl("\"binding\", \"lp_ctx\", \"credentials\", NULL"); $self->deindent; $self->pidl("};"); + $self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);"); + $self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);"); + $self->pidl(""); + $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"sO|O:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {"); + $self->indent; + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); $self->pidl(""); - $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string)) {"); + $self->pidl("if (py_lp_ctx != NULL) {"); + $self->indent; + $self->pidl("lp_ctx = lp_from_py_object(py_lp_ctx);"); + $self->pidl("if (lp_ctx == NULL) {"); $self->indent; + $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected loadparm context\");"); $self->pidl("return NULL;"); $self->deindent; $self->pidl("}"); + $self->deindent; + $self->pidl("}"); $self->pidl(""); - # FIXME: Arguments: binding string, credentials, loadparm context + $self->pidl("credentials = cli_credentials_from_py_object(py_credentials);"); + $self->pidl("if (credentials == NULL) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected credentials\");"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);"); $self->pidl(""); @@ -517,6 +552,8 @@ sub Interface($$$) $self->pidl(" &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);"); $self->handle_ntstatus("status", "NULL", "mem_ctx"); + $self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;"); + $self->pidl("return (PyObject *)ret;"); $self->deindent; $self->pidl("}"); -- cgit From 4cfd90308c4dffebf7cebdcd8c11a7aa836ce23e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 06:05:12 +0100 Subject: pidl/python: Specify memory context explicitly when returning Python objects. (This used to be commit 9c72f652e0d3f14d5db4d3930f0d1f9a1875e93f) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 62 ++++++++++++++-------------- 1 file changed, 30 insertions(+), 32 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 04649d3668..e0751d0c72 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -91,9 +91,9 @@ sub EnumAndBitmapConsts($$$) } } -sub FromUnionToPythonFunction($$$) +sub FromUnionToPythonFunction($$$$) { - my ($self, $type, $switch, $name) = @_; + my ($self, $mem_ctx, $type, $switch, $name) = @_; $self->pidl("PyObject *ret;"); $self->pidl(""); @@ -111,7 +111,7 @@ sub FromUnionToPythonFunction($$$) $self->indent; if ($e->{NAME}) { - $self->ConvertObjectToPython({}, $e, "$name->$e->{NAME}", "ret"); + $self->ConvertObjectToPython($mem_ctx, {}, $e, "$name->$e->{NAME}", "ret"); } else { $self->pidl("ret = Py_None;"); } @@ -182,13 +182,13 @@ sub PythonStruct($$$$) $self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)"); $self->pidl("{"); $self->indent; - $self->pidl("$cname *object = py_talloc_get_type(obj, $cname);"); + $self->pidl("$cname *object = py_talloc_get_ptr(obj);"); foreach my $e (@{$d->{ELEMENTS}}) { $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; $self->indent; $self->pidl("PyObject *py_$e->{NAME};"); - $self->ConvertObjectToPython($env, $e, $varname, "py_$e->{NAME}"); + $self->ConvertObjectToPython("py_talloc_get_talloc_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}"); $self->pidl("return py_$e->{NAME};"); $self->deindent; $self->pidl("}"); @@ -202,7 +202,7 @@ sub PythonStruct($$$$) $self->pidl("static int py_$name\_setattr(PyObject *py_obj, char *name, PyObject *value)"); $self->pidl("{"); $self->indent; - $self->pidl("$cname *object = py_talloc_get_type(py_obj, $cname);"); + $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)"; foreach my $e (@{$d->{ELEMENTS}}) { $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); @@ -263,10 +263,10 @@ sub PythonFunction($$$) $self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;"); $self->pidl("NTSTATUS status;"); $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); - $self->pidl("struct $fn->{NAME} r;"); + $self->pidl("struct $fn->{NAME} *r = talloc_zero(mem_ctx, struct $fn->{NAME});"); $self->pidl("PyObject *result = Py_None;"); - - my $env = GenerateFunctionInEnv($fn, "r."); + + my $env = GenerateFunctionInEnv($fn, "r->"); my $result_size = 0; my $args_format = ""; @@ -297,23 +297,19 @@ sub PythonFunction($$$) $self->deindent; $self->pidl("}"); - if ($result_size > 0) { - $self->pidl(""); - $self->pidl("ZERO_STRUCT(r.out);"); - } if ($fn->{RETURN_TYPE}) { $result_size++; } foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - $self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r.in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;"); + $self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r->in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;"); } } - $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, &r);"); + $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, r);"); $self->handle_ntstatus("status", "NULL", "mem_ctx"); - $env = GenerateFunctionOutEnv($fn, "r."); + $env = GenerateFunctionOutEnv($fn, "r->"); my $i = 0; if ($result_size > 1) { @@ -323,7 +319,7 @@ sub PythonFunction($$$) foreach my $e (@{$fn->{ELEMENTS}}) { my $py_name = "py_$e->{NAME}"; if (grep(/out/,@{$e->{DIRECTION}})) { - $self->ConvertObjectToPython($env, $e, "r.out.$e->{NAME}", $py_name); + $self->ConvertObjectToPython("r", $env, $e, "r->out.$e->{NAME}", $py_name); if ($result_size > 1) { $self->pidl("PyTuple_SetItem(result, $i, $py_name);"); $i++; @@ -334,7 +330,7 @@ sub PythonFunction($$$) } if (defined($fn->{RETURN_TYPE})) { - my $conv = $self->ConvertObjectToPythonData($fn->{RETURN_TYPE}, "r.out.result"); + my $conv = $self->ConvertObjectToPythonData("r", $fn->{RETURN_TYPE}, "r->out.result"); if ($result_size > 1) { $self->pidl("PyTuple_SetItem(result, $i, $conv);"); } else { @@ -397,10 +393,10 @@ sub PythonType($$$) } if ($actual_ctype->{TYPE} eq "UNION" and defined($actual_ctype->{ELEMENTS})) { - $self->pidl("PyObject *py_import_$d->{NAME}(int level, " .mapTypeName($d) . " *in)"); + $self->pidl("PyObject *py_import_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, " .mapTypeName($d) . " *in)"); $self->pidl("{"); $self->indent; - $self->FromUnionToPythonFunction($actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION"); + $self->FromUnionToPythonFunction("mem_ctx", $actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -676,9 +672,11 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) } } elsif ($l->{TYPE} eq "ARRAY") { if (is_charset_array($e, $l)) { + $self->pidl("PY_CHECK_TYPE(PyUnicode, $py_var, $fail);"); $self->pidl(get_pointer_to($var_name) . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));"); } else { my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}"; + $self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);"); $self->pidl("{"); $self->indent; $self->pidl("int $counter;"); @@ -754,9 +752,9 @@ sub ConvertScalarToPython($$$) die("Unknown scalar type $ctypename"); } -sub ConvertObjectToPythonData($$$$) +sub ConvertObjectToPythonData($$$$$) { - my ($self, $ctype, $cvar) = @_; + my ($self, $mem_ctx, $ctype, $cvar) = @_; die("undef type for $cvar") unless(defined($ctype)); @@ -797,9 +795,9 @@ sub ConvertObjectToPythonData($$$$) die("unknown type ".mapTypeName($ctype) . ": $cvar"); } -sub ConvertObjectToPythonLevel($$$$) +sub ConvertObjectToPythonLevel($$$$$) { - my ($self, $env, $e, $l, $var_name, $py_var) = @_; + my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var) = @_; if ($l->{TYPE} eq "POINTER") { if ($l->{POINTER_TYPE} ne "ref") { @@ -810,7 +808,7 @@ sub ConvertObjectToPythonLevel($$$$) $self->pidl("} else {"); $self->indent; } - $self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), get_value_of($var_name), $py_var); + $self->ConvertObjectToPythonLevel($var_name, $env, $e, GetNextLevel($e, $l), get_value_of($var_name), $py_var); if ($l->{POINTER_TYPE} ne "ref") { $self->deindent; $self->pidl("}"); @@ -836,7 +834,7 @@ sub ConvertObjectToPythonLevel($$$$) $self->indent; my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}"; $self->pidl("PyObject *$member_var;"); - $self->ConvertObjectToPythonLevel($env, $e, GetNextLevel($e, $l), $var_name."[$counter]", $member_var); + $self->ConvertObjectToPythonLevel($var_name, $env, $e, GetNextLevel($e, $l), $var_name."[$counter]", $member_var); $self->pidl("PyList_SetItem($py_var, $counter, $member_var);"); $self->deindent; $self->pidl("}"); @@ -846,13 +844,13 @@ sub ConvertObjectToPythonLevel($$$$) } elsif ($l->{TYPE} eq "SWITCH") { $var_name = get_pointer_to($var_name); my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e); - $self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($switch, $var_name);"); + $self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $var_name);"); } elsif ($l->{TYPE} eq "DATA") { if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); } - my $conv = $self->ConvertObjectToPythonData($l->{DATA_TYPE}, $var_name); + my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name); $self->pidl("$py_var = $conv;"); } elsif ($l->{TYPE} eq "SUBCONTEXT") { $self->pidl("FIXME"); @@ -861,11 +859,11 @@ sub ConvertObjectToPythonLevel($$$$) } } -sub ConvertObjectToPython($$$$$) +sub ConvertObjectToPython($$$$$$) { - my ($self, $env, $ctype, $cvar, $py_var) = @_; + my ($self, $mem_ctx, $env, $ctype, $cvar, $py_var) = @_; - $self->ConvertObjectToPythonLevel($env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var); + $self->ConvertObjectToPythonLevel($mem_ctx, $env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var); } sub Parse($$$$$) @@ -925,7 +923,7 @@ sub Parse($$$$$) } elsif ($cvar =~ /^".*"$/) { $py_obj = "PyString_FromString($cvar)"; } else { - $py_obj = $self->ConvertObjectToPythonData($ctype, $cvar); + $py_obj = $self->ConvertObjectToPythonData("NULL", $ctype, $cvar); } $self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);"); -- cgit From e231e24d89dfe3faaf0f791dc5e0df5fa9c21590 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 06:23:13 +0100 Subject: pidl/python: Deal with arrays that are not pointers. (This used to be commit 7516af7c7262240df3b804dda962194a811d4e96) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 12 ++++++++++++ 1 file changed, 12 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index e0751d0c72..1483083e22 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -673,8 +673,14 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) } elsif ($l->{TYPE} eq "ARRAY") { if (is_charset_array($e, $l)) { $self->pidl("PY_CHECK_TYPE(PyUnicode, $py_var, $fail);"); + # FIXME: Use Unix charset setting rather than utf-8 $self->pidl(get_pointer_to($var_name) . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));"); } else { + my $pl = GetPrevLevel($e, $l); + if ($pl && $pl->{TYPE} eq "POINTER") { + $var_name = get_pointer_to($var_name); + } + my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}"; $self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);"); $self->pidl("{"); @@ -816,8 +822,14 @@ sub ConvertObjectToPythonLevel($$$$$) } elsif ($l->{TYPE} eq "ARRAY") { if (is_charset_array($e, $l)) { $var_name = get_pointer_to($var_name); + # FIXME: Use Unix charset setting rather than utf-8 $self->pidl("$py_var = PyUnicode_Decode($var_name, strlen($var_name), \"utf-8\", \"ignore\");"); } else { + my $pl = GetPrevLevel($e, $l); + if ($pl && $pl->{TYPE} eq "POINTER") { + $var_name = get_pointer_to($var_name); + } + die("No SIZE_IS for array $var_name") unless (defined($l->{SIZE_IS})); my $length = $l->{SIZE_IS}; if (defined($l->{LENGTH_IS})) { -- cgit From 30a2a43a7546b5336058559f5ffd74b1f799c05b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 13:26:01 +0100 Subject: pidl/python: Fix processing UUID-less interfaces, external typedefs and certain bitmap elements. (This used to be commit e65618fff3299193c27959e2cc5a3937837e1422) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 261 +++++++++++++-------------- source4/pidl/lib/Parse/Pidl/Typelist.pm | 16 +- 2 files changed, 137 insertions(+), 140 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 1483083e22..e538771624 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -9,7 +9,7 @@ use Exporter; @ISA = qw(Exporter); use strict; -use Parse::Pidl::Typelist qw(hasType getType mapTypeName expandAlias); +use Parse::Pidl::Typelist qw(hasType resolveType getType mapTypeName expandAlias); use Parse::Pidl::Util qw(has_property ParseExpr); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array); use Parse::Pidl::CUtil qw(get_value_of get_pointer_to); @@ -84,7 +84,7 @@ sub EnumAndBitmapConsts($$$) return unless (defined($d->{ELEMENTS})); foreach my $e (@{$d->{ELEMENTS}}) { - $e =~ /^([A-Za-z0-9_]+)=(.*)$/; + $e =~ /^([A-Za-z0-9_]+)/; my $cname = $1; $self->register_constant($cname, $d, $cname); @@ -188,7 +188,7 @@ sub PythonStruct($$$$) my $varname = "object->$e->{NAME}"; $self->indent; $self->pidl("PyObject *py_$e->{NAME};"); - $self->ConvertObjectToPython("py_talloc_get_talloc_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}"); + $self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}"); $self->pidl("return py_$e->{NAME};"); $self->deindent; $self->pidl("}"); @@ -428,133 +428,135 @@ sub Interface($$$) $self->PythonType($d, $interface, $basename); } - $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n"); - $self->pidl("typedef struct {"); - $self->indent; - $self->pidl("PyObject_HEAD"); - $self->pidl("struct dcerpc_pipe *pipe;"); - $self->deindent; - $self->pidl("} $interface->{NAME}_InterfaceObject;"); + if (defined $interface->{PROPERTIES}->{uuid}) { + $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n"); + $self->pidl("typedef struct {"); + $self->indent; + $self->pidl("PyObject_HEAD"); + $self->pidl("struct dcerpc_pipe *pipe;"); + $self->deindent; + $self->pidl("} $interface->{NAME}_InterfaceObject;"); - $self->pidl(""); + $self->pidl(""); - foreach my $d (@{$interface->{FUNCTIONS}}) { - next if not defined($d->{OPNUM}); - next if has_property($d, "nopython"); + foreach my $d (@{$interface->{FUNCTIONS}}) { + next if not defined($d->{OPNUM}); + next if has_property($d, "nopython"); - $self->PythonFunction($d, $interface->{NAME}); - } + $self->PythonFunction($d, $interface->{NAME}); + } - $self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {"); - $self->indent; - foreach my $d (@{$interface->{FUNCTIONS}}) { - next if not defined($d->{OPNUM}); - next if has_property($d, "nopython"); + $self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {"); + $self->indent; + foreach my $d (@{$interface->{FUNCTIONS}}) { + next if not defined($d->{OPNUM}); + next if has_property($d, "nopython"); - my $fn_name = $d->{NAME}; + my $fn_name = $d->{NAME}; - $fn_name =~ s/^$interface->{NAME}_//; - $fn_name =~ s/^$basename\_//; + $fn_name =~ s/^$interface->{NAME}_//; + $fn_name =~ s/^$basename\_//; - $self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); - } - $self->pidl("{ NULL, NULL, 0, NULL }"); - $self->deindent; - $self->pidl("};"); - $self->pidl(""); + $self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); + } + $self->pidl("{ NULL, NULL, 0, NULL }"); + $self->deindent; + $self->pidl("};"); + $self->pidl(""); - $self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)"); - $self->pidl("{"); - $self->indent; - $self->pidl("$interface->{NAME}_InterfaceObject *interface = ($interface->{NAME}_InterfaceObject *)self;"); - $self->pidl("talloc_free(interface->pipe);"); - $self->pidl("PyObject_Del(self);"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); + $self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$interface->{NAME}_InterfaceObject *interface = ($interface->{NAME}_InterfaceObject *)self;"); + $self->pidl("talloc_free(interface->pipe);"); + $self->pidl("PyObject_Del(self);"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); - $self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyObject *obj, char *name)"); - $self->pidl("{"); - $self->indent; - $self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, obj, name);"); - $self->deindent; - $self->pidl("}"); + $self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyObject *obj, char *name)"); + $self->pidl("{"); + $self->indent; + $self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, obj, name);"); + $self->deindent; + $self->pidl("}"); - $self->pidl(""); + $self->pidl(""); - $self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {"); - $self->indent; - $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); - $self->pidl(".tp_name = \"$interface->{NAME}\","); - $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); - $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); - $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); - $self->deindent; - $self->pidl("};"); + $self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {"); + $self->indent; + $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); + $self->pidl(".tp_name = \"$interface->{NAME}\","); + $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); + $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); + $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); + $self->deindent; + $self->pidl("};"); - $self->pidl(""); + $self->pidl(""); - $self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL"); - $self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)"); - $self->pidl("{"); - $self->indent; - $self->pidl("$interface->{NAME}_InterfaceObject *ret;"); - $self->pidl("const char *binding_string;"); - $self->pidl("struct cli_credentials *credentials;"); - $self->pidl("struct loadparm_context *lp_ctx = NULL;"); - $self->pidl("PyObject *py_lp_ctx = NULL, *py_credentials = Py_None;"); - $self->pidl("TALLOC_CTX *mem_ctx = NULL;"); - $self->pidl("NTSTATUS status;"); - $self->pidl(""); - $self->pidl("const char *kwnames[] = {"); - $self->indent; - $self->pidl("\"binding\", \"lp_ctx\", \"credentials\", NULL"); - $self->deindent; - $self->pidl("};"); - $self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);"); - $self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);"); - $self->pidl(""); - $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"sO|O:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {"); - $self->indent; - $self->pidl("return NULL;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - $self->pidl("if (py_lp_ctx != NULL) {"); - $self->indent; - $self->pidl("lp_ctx = lp_from_py_object(py_lp_ctx);"); - $self->pidl("if (lp_ctx == NULL) {"); - $self->indent; - $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected loadparm context\");"); - $self->pidl("return NULL;"); - $self->deindent; - $self->pidl("}"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); + $self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL"); + $self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$interface->{NAME}_InterfaceObject *ret;"); + $self->pidl("const char *binding_string;"); + $self->pidl("struct cli_credentials *credentials;"); + $self->pidl("struct loadparm_context *lp_ctx = NULL;"); + $self->pidl("PyObject *py_lp_ctx = NULL, *py_credentials = Py_None;"); + $self->pidl("TALLOC_CTX *mem_ctx = NULL;"); + $self->pidl("NTSTATUS status;"); + $self->pidl(""); + $self->pidl("const char *kwnames[] = {"); + $self->indent; + $self->pidl("\"binding\", \"lp_ctx\", \"credentials\", NULL"); + $self->deindent; + $self->pidl("};"); + $self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);"); + $self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);"); + $self->pidl(""); + $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"sO|O:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {"); + $self->indent; + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $self->pidl("if (py_lp_ctx != NULL) {"); + $self->indent; + $self->pidl("lp_ctx = lp_from_py_object(py_lp_ctx);"); + $self->pidl("if (lp_ctx == NULL) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected loadparm context\");"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); - $self->pidl("credentials = cli_credentials_from_py_object(py_credentials);"); - $self->pidl("if (credentials == NULL) {"); - $self->indent; - $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected credentials\");"); - $self->pidl("return NULL;"); - $self->deindent; - $self->pidl("}"); + $self->pidl("credentials = cli_credentials_from_py_object(py_credentials);"); + $self->pidl("if (credentials == NULL) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected credentials\");"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); - $self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);"); - $self->pidl(""); + $self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);"); + $self->pidl(""); - $self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, "); - $self->pidl(" &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);"); - $self->handle_ntstatus("status", "NULL", "mem_ctx"); + $self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, "); + $self->pidl(" &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);"); + $self->handle_ntstatus("status", "NULL", "mem_ctx"); - $self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;"); + $self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;"); - $self->pidl("return (PyObject *)ret;"); - $self->deindent; - $self->pidl("}"); - - $self->pidl(""); + $self->pidl("return (PyObject *)ret;"); + $self->deindent; + $self->pidl("}"); + + $self->pidl(""); + } $self->pidl_hdr("\n"); $self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n"); @@ -583,9 +585,7 @@ sub ConvertObjectFromPythonData($$$$$$) die("undef type for $cvar") unless(defined($ctype)); - if (ref($ctype) ne "HASH") { - $ctype = getType($ctype); - } + $ctype = resolveType($ctype); if (ref($ctype) ne "HASH") { $self->pidl("$target = FIXME($cvar);"); @@ -764,38 +764,21 @@ sub ConvertObjectToPythonData($$$$$) die("undef type for $cvar") unless(defined($ctype)); - if (ref($ctype) ne "HASH") { - if (not hasType($ctype)) { - if (ref($ctype) eq "HASH") { - return "py_import_$ctype->{TYPE}_$ctype->{NAME}($cvar)"; - } else { - return "py_import_$ctype($cvar)"; # best bet - } - } - - $ctype = getType($ctype); - } + $ctype = resolveType($ctype); my $actual_ctype = $ctype; if ($ctype->{TYPE} eq "TYPEDEF") { $actual_ctype = $ctype->{DATA}; - } - + } + if ($actual_ctype->{TYPE} eq "ENUM") { return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar); - } - - if ($actual_ctype->{TYPE} eq "BITMAP") { + } elsif ($actual_ctype->{TYPE} eq "BITMAP") { return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar); - } - - if ($actual_ctype->{TYPE} eq "SCALAR") { + } elsif ($actual_ctype->{TYPE} eq "SCALAR") { return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar); - } - - if ($actual_ctype->{TYPE} eq "STRUCT") { - # FIXME: if $cvar is not a pointer, do a talloc_dup() - return "py_talloc_import(&$ctype->{NAME}_Type, $cvar)"; + } elsif ($actual_ctype->{TYPE} eq "STRUCT") { + return "py_talloc_import_ex(&$ctype->{NAME}_Type, $mem_ctx, $cvar)"; } die("unknown type ".mapTypeName($ctype) . ": $cvar"); diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index e54ef11b88..9e6c683f82 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -7,7 +7,7 @@ package Parse::Pidl::Typelist; require Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(hasType getType mapTypeName scalar_is_reference expandAlias +@EXPORT_OK = qw(hasType getType resolveType mapTypeName scalar_is_reference expandAlias mapScalarType addType typeIs is_scalar enum_type_fn bitmap_type_fn mapType typeHasBody ); @@ -95,6 +95,20 @@ sub addType($) $types{$t->{NAME}} = $t; } +sub resolveType($) +{ + my ($ctype) = @_; + + if (not hasType($ctype)) { + # assume struct typedef + return { TYPE => "TYPEDEF", NAME => $ctype, DATA => { TYPE => "STRUCT" } }; + } else { + return getType($ctype); + } + + return $ctype; +} + sub getType($) { my $t = shift; -- cgit From 7dd468ff2e5a4c4ce503e1b8e024bf91dcf7a412 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 14:48:59 +0100 Subject: python: Fix python code for winreg, add test. (This used to be commit bd3e6c41c42738fcfcc5cef4e65f0e219d358260) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index e538771624..c8505e9904 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -665,6 +665,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) $self->pidl("} else {"); $self->indent; } + $self->pidl("$var_name = talloc_ptrtype($mem_ctx, $var_name);"); $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail); if ($l->{POINTER_TYPE} ne "ref") { $self->deindent; @@ -686,7 +687,9 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) $self->pidl("{"); $self->indent; $self->pidl("int $counter;"); - $self->pidl("$var_name = talloc_array_ptrtype($mem_ctx, $var_name, PyList_Size($py_var));"); + if (!$l->{IS_FIXED}) { + $self->pidl("$var_name = talloc_array_ptrtype($mem_ctx, $var_name, PyList_Size($py_var));"); + } $self->pidl("for ($counter = 0; $counter < PyList_Size($py_var); $counter++) {"); $self->indent; $self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GetItem($py_var, $counter)", $e, GetNextLevel($e, $l), $var_name."[$counter]", $fail); @@ -697,8 +700,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) } } elsif ($l->{TYPE} eq "DATA") { - if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or - Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); } $self->ConvertObjectFromPythonData($mem_ctx, $py_var, $l->{DATA_TYPE}, $var_name, $fail); @@ -841,8 +843,7 @@ sub ConvertObjectToPythonLevel($$$$$) my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e); $self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $var_name);"); } elsif ($l->{TYPE} eq "DATA") { - if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or - Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); } my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name); -- cgit From 035599fa651409502a6894179d5cd8a026110ba1 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 15:25:09 +0100 Subject: python: Be more pythonic - turn WERROR and NTSTATUS return codes into exceptions. (This used to be commit 16fc69b843e92ae62b15caf927335cc117156499) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index c8505e9904..9f6a7847b1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -298,7 +298,7 @@ sub PythonFunction($$$) $self->pidl("}"); if ($fn->{RETURN_TYPE}) { - $result_size++; + $result_size++ unless ($fn->{RETURN_TYPE} eq "WERROR" or $fn->{RETURN_TYPE} eq "NTSTATUS"); } foreach my $e (@{$fn->{ELEMENTS}}) { @@ -329,7 +329,11 @@ sub PythonFunction($$$) } } - if (defined($fn->{RETURN_TYPE})) { + if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") { + $self->handle_ntstatus("r->out.result", "NULL", "mem_ctx"); + } elsif (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "WERROR") { + $self->handle_werror("r->out.result", "NULL", "mem_ctx"); + } elsif (defined($fn->{RETURN_TYPE})) { my $conv = $self->ConvertObjectToPythonData("r", $fn->{RETURN_TYPE}, "r->out.result"); if ($result_size > 1) { $self->pidl("PyTuple_SetItem(result, $i, $conv);"); @@ -345,6 +349,20 @@ sub PythonFunction($$$) $self->pidl(""); } +sub handle_werror($$$$) +{ + my ($self, $var, $retval, $mem_ctx) = @_; + + $self->pidl("if (!W_ERROR_IS_OK($var)) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_RuntimeError, win_errstr($var));"); + $self->pidl("talloc_free($mem_ctx);") if ($mem_ctx); + $self->pidl("return $retval;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); +} + sub handle_ntstatus($$$$) { my ($self, $var, $retval, $mem_ctx) = @_; -- cgit From fa5397fbeda759ac66fc5d0a6bdfb60a070a7962 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 16:11:58 +0100 Subject: python: Build epmapper module. (This used to be commit 6cb78c7634de0f9ab327583844d7860d384356eb) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 83 +++++++++++++--------------- 1 file changed, 37 insertions(+), 46 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 9f6a7847b1..0d5237022a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -102,11 +102,7 @@ sub FromUnionToPythonFunction($$$$) $self->indent; foreach my $e (@{$type->{ELEMENTS}}) { - if (defined($e->{CASE})) { - $self->pidl("$e->{CASE}:"); - } else { - $self->pidl("default:"); - } + $self->pidl("$e->{CASE}:"); $self->indent; @@ -141,12 +137,8 @@ sub FromPythonToUnionFunction($$$$$) $self->indent; foreach my $e (@{$type->{ELEMENTS}}) { - if (defined($e->{CASE})) { - $self->pidl("$e->{CASE}:"); - } else { - $has_default = 1; - $self->pidl("default:"); - } + $self->pidl("$e->{CASE}:"); + if ($e->{CASE} eq "default") { $has_default = 1; } $self->indent; if ($e->{NAME}) { $self->ConvertObjectFromPython({}, $mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;"); @@ -182,16 +174,18 @@ sub PythonStruct($$$$) $self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)"); $self->pidl("{"); $self->indent; - $self->pidl("$cname *object = py_talloc_get_ptr(obj);"); - foreach my $e (@{$d->{ELEMENTS}}) { - $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); - my $varname = "object->$e->{NAME}"; - $self->indent; - $self->pidl("PyObject *py_$e->{NAME};"); - $self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}"); - $self->pidl("return py_$e->{NAME};"); - $self->deindent; - $self->pidl("}"); + if ($#{$d->{ELEMENTS}} > -1) { + $self->pidl("$cname *object = py_talloc_get_ptr(obj);"); + foreach my $e (@{$d->{ELEMENTS}}) { + $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); + my $varname = "object->$e->{NAME}"; + $self->indent; + $self->pidl("PyObject *py_$e->{NAME};"); + $self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}"); + $self->pidl("return py_$e->{NAME};"); + $self->deindent; + $self->pidl("}"); + } } $self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");"); $self->pidl("return NULL;"); @@ -202,19 +196,21 @@ sub PythonStruct($$$$) $self->pidl("static int py_$name\_setattr(PyObject *py_obj, char *name, PyObject *value)"); $self->pidl("{"); $self->indent; - $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); - my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)"; - foreach my $e (@{$d->{ELEMENTS}}) { - $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); - my $varname = "object->$e->{NAME}"; - $self->indent; - if ($e->{ORIGINAL}->{POINTERS} > 0) { - $self->pidl("talloc_free($varname);"); + if ($#{$d->{ELEMENTS}} > -1) { + $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); + my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)"; + foreach my $e (@{$d->{ELEMENTS}}) { + $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); + my $varname = "object->$e->{NAME}"; + $self->indent; + if ($e->{ORIGINAL}->{POINTERS} > 0) { + $self->pidl("talloc_free($varname);"); + } + $self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;"); + $self->pidl("return 0;"); + $self->deindent; + $self->pidl("}"); } - $self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;"); - $self->pidl("return 0;"); - $self->deindent; - $self->pidl("}"); } $self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");"); $self->pidl("return -1;"); @@ -591,7 +587,7 @@ sub assign($$$) { my ($self, $dest, $src) = @_; if ($dest =~ /^\&/) { - $self->pidl("memcpy($dest, $src, sizeof(*$dest));"); + $self->pidl("memcpy($dest, $src, sizeof(" . get_value_of($dest) . "));"); } else { $self->pidl("$dest = $src;"); } @@ -605,11 +601,6 @@ sub ConvertObjectFromPythonData($$$$$$) $ctype = resolveType($ctype); - if (ref($ctype) ne "HASH") { - $self->pidl("$target = FIXME($cvar);"); - return; - } - my $actual_ctype = $ctype; if ($ctype->{TYPE} eq "TYPEDEF") { $actual_ctype = $ctype->{DATA}; @@ -641,7 +632,7 @@ sub ConvertObjectFromPythonData($$$$$$) } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "ipv4address") { - $self->pidl("$target = FIXME($cvar);"); + $self->pidl("$target = PyString_AsString($cvar);"); return; } @@ -657,7 +648,7 @@ sub ConvertObjectFromPythonData($$$$$$) } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") { - $self->pidl("$target = FIXME($cvar);"); + $self->pidl("$target = PyCObject_AsVoidPtr($cvar);"); return; } @@ -725,9 +716,9 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) } elsif ($l->{TYPE} eq "SWITCH") { $var_name = get_pointer_to($var_name); my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e); - $self->pidl("$var_name = py_export_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $py_var);"); + $self->assign($var_name, "py_export_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $py_var)"); } elsif ($l->{TYPE} eq "SUBCONTEXT") { - $self->pidl("#error Subcontext not yet supported"); + $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, GetNextLevel($e, $l), $var_name, $fail); } else { die("unknown level type $l->{TYPE}"); } @@ -753,7 +744,7 @@ sub ConvertScalarToPython($$$) } if ($ctypename eq "DATA_BLOB") { - return "PyString_FromStringAndSize($cvar->data, $cvar->length)"; + return "PyString_FromStringAndSize((char *)($cvar).data, ($cvar).length)"; } if ($ctypename eq "NTSTATUS") { @@ -770,7 +761,7 @@ sub ConvertScalarToPython($$$) # Not yet supported if ($ctypename eq "string_array") { return "PyCObject_FromVoidPtr($cvar)"; } - if ($ctypename eq "ipv4address") { return "PyCObject_FromVoidPtr($cvar)"; } + if ($ctypename eq "ipv4address") { return "PyString_FromString($cvar)"; } if ($ctypename eq "pointer") { return "PyCObject_FromVoidPtr($cvar, talloc_free)"; } @@ -867,7 +858,7 @@ sub ConvertObjectToPythonLevel($$$$$) my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name); $self->pidl("$py_var = $conv;"); } elsif ($l->{TYPE} eq "SUBCONTEXT") { - $self->pidl("FIXME"); + $self->ConvertObjectToPythonLevel($mem_ctx, $env, $e, GetNextLevel($e, $l), $var_name, $py_var); } else { die("Unknown level type $l->{TYPE} $var_name"); } -- cgit From 860106b3f426a06eed6a681fa839dd89f339ba9a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 16:49:19 +0100 Subject: python: Move some convenience macros to a separate header rather than putting them in every generated py_* file. (This used to be commit 712274b9bdf524da125cbbe6e4bb475b21b1da66) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 0d5237022a..84b3405bb9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -886,20 +886,16 @@ sub Parse($$$$$) #include #include \"librpc/rpc/dcerpc.h\" #include \"scripting/python/pytalloc.h\" +#include \"scripting/python/pyrpc.h\" #include \"$hdr\" #include \"$ndr_hdr\" #include \"$py_hdr\" -#define PY_CHECK_TYPE(type, var, fail) \\ - if (!type ## _Check(var)) {\\ - PyErr_Format(PyExc_TypeError, \"Expected type %s\", type ## _Type.tp_name); \\ - fail; \\ - } "); foreach my $x (@$ndr) { - ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename); ($x->{TYPE} eq "IMPORT") && $self->Import(@{$x->{PATHS}}); + ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename); } $self->pidl("static PyMethodDef $basename\_methods[] = {"); -- cgit From 994e43e9ebd3922f2c3378edf0e73e912815230a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 18:01:54 +0100 Subject: python: Don't try to free const pointers. (This used to be commit b4754f4683e67a940f18a88e45c0878259f45b97) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 84b3405bb9..73442be59d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -203,7 +203,11 @@ sub PythonStruct($$$$) $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; $self->indent; - if ($e->{ORIGINAL}->{POINTERS} > 0) { + my $l = $e->{LEVELS}[0]; + my $nl = GetNextLevel($e, $l); + if ($l->{TYPE} eq "POINTER" and + not ($nl->{TYPE} eq "ARRAY" and ($nl->{IS_FIXED} or is_charset_array($e, $nl))) and + not ($nl->{TYPE} eq "SCALAR" and $nl->{TYPE} eq "string")) { $self->pidl("talloc_free($varname);"); } $self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;"); -- cgit From 134e38ac28b30b7fb3f4efcf9985c17ff2f070ad Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 18:24:10 +0100 Subject: python: Fix some corner cases handling scalars. (This used to be commit b662c98a9ad461a33a27a918c0d544a96433e48c) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 73442be59d..8ff909a455 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -207,7 +207,7 @@ sub PythonStruct($$$$) my $nl = GetNextLevel($e, $l); if ($l->{TYPE} eq "POINTER" and not ($nl->{TYPE} eq "ARRAY" and ($nl->{IS_FIXED} or is_charset_array($e, $nl))) and - not ($nl->{TYPE} eq "SCALAR" and $nl->{TYPE} eq "string")) { + not ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE}))) { $self->pidl("talloc_free($varname);"); } $self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;"); @@ -668,8 +668,13 @@ sub ConvertObjectFromPythonData($$$$$$) sub ConvertObjectFromPythonLevel($$$$$$$$) { my ($self, $env, $mem_ctx, $py_var, $e, $l, $var_name, $fail) = @_; + my $nl = GetNextLevel($e, $l); if ($l->{TYPE} eq "POINTER") { + if ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) { + $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, $var_name, $fail); + return; + } if ($l->{POINTER_TYPE} ne "ref") { $self->pidl("if ($py_var == Py_None) {"); $self->indent; @@ -679,7 +684,7 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) $self->indent; } $self->pidl("$var_name = talloc_ptrtype($mem_ctx, $var_name);"); - $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, GetNextLevel($e, $l), get_value_of($var_name), $fail); + $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, get_value_of($var_name), $fail); if ($l->{POINTER_TYPE} ne "ref") { $self->deindent; $self->pidl("}"); @@ -802,8 +807,13 @@ sub ConvertObjectToPythonData($$$$$) sub ConvertObjectToPythonLevel($$$$$) { my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var) = @_; + my $nl = GetNextLevel($e, $l); if ($l->{TYPE} eq "POINTER") { + if ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) { + $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name, $py_var); + return; + } if ($l->{POINTER_TYPE} ne "ref") { $self->pidl("if ($var_name == NULL) {"); $self->indent; @@ -812,7 +822,7 @@ sub ConvertObjectToPythonLevel($$$$$) $self->pidl("} else {"); $self->indent; } - $self->ConvertObjectToPythonLevel($var_name, $env, $e, GetNextLevel($e, $l), get_value_of($var_name), $py_var); + $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, get_value_of($var_name), $py_var); if ($l->{POINTER_TYPE} ne "ref") { $self->deindent; $self->pidl("}"); -- cgit From d28eb21a984a733e8f1de51170e41ae7c879f7e9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 18:59:11 +0100 Subject: python: Compile security module, handle uint. (This used to be commit dee64344fb13aaed38a550ebb4048d0fa526d5b6) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 6 +++--- source4/pidl/lib/Parse/Pidl/Typelist.pm | 1 + 2 files changed, 4 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 8ff909a455..31b06d16b8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -612,7 +612,7 @@ sub ConvertObjectFromPythonData($$$$$$) if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or $actual_ctype->{TYPE} eq "SCALAR" and ( - expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]+|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) { + expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]*|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) { $self->pidl("PY_CHECK_TYPE(PyInt, $cvar, $fail);"); $self->pidl("$target = PyInt_AsLong($cvar);"); return; @@ -748,7 +748,7 @@ sub ConvertScalarToPython($$$) $ctypename = expandAlias($ctypename); - if ($ctypename =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) { + if ($ctypename =~ /^(char|u?int[0-9]*|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) { return "PyInt_FromLong($cvar)"; } @@ -938,7 +938,7 @@ sub Parse($$$$$) } elsif ($cvar =~ /^".*"$/) { $py_obj = "PyString_FromString($cvar)"; } else { - $py_obj = $self->ConvertObjectToPythonData("NULL", $ctype, $cvar); + $py_obj = $self->ConvertObjectToPythonData("NULL", expandAlias($ctype), $cvar); } $self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);"); diff --git a/source4/pidl/lib/Parse/Pidl/Typelist.pm b/source4/pidl/lib/Parse/Pidl/Typelist.pm index 9e6c683f82..8ba1ae47af 100644 --- a/source4/pidl/lib/Parse/Pidl/Typelist.pm +++ b/source4/pidl/lib/Parse/Pidl/Typelist.pm @@ -59,6 +59,7 @@ my %aliases = ( "boolean8" => "uint8", "boolean32" => "uint32", "DWORD" => "uint32", + "uint" => "uint32", "int" => "int32", "WORD" => "uint16", "char" => "uint8", -- cgit From 1530d7c3b0d02a2b75c1ee393209f69473f3c4af Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 14 Jan 2008 20:09:18 +0100 Subject: python: Fix handling of pointer-less strings in function arguments. (This used to be commit cb2700094fc1fc3887d5254e5d42e035deefa5b9) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 31b06d16b8..2475925377 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -642,12 +642,12 @@ sub ConvertObjectFromPythonData($$$$$$) if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") { - $self->pidl("$target = PyInt_AsLong($cvar);"); + $self->pidl("$target = NT_STATUS(PyInt_AsLong($cvar));"); return; } if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") { - $self->pidl("$target = PyInt_AsLong($cvar);"); + $self->pidl("$target = W_ERROR(PyInt_AsLong($cvar));"); return; } @@ -690,16 +690,16 @@ sub ConvertObjectFromPythonLevel($$$$$$$$) $self->pidl("}"); } } elsif ($l->{TYPE} eq "ARRAY") { + my $pl = GetPrevLevel($e, $l); + if ($pl && $pl->{TYPE} eq "POINTER") { + $var_name = get_pointer_to($var_name); + } + if (is_charset_array($e, $l)) { $self->pidl("PY_CHECK_TYPE(PyUnicode, $py_var, $fail);"); # FIXME: Use Unix charset setting rather than utf-8 - $self->pidl(get_pointer_to($var_name) . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));"); + $self->pidl($var_name . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));"); } else { - my $pl = GetPrevLevel($e, $l); - if ($pl && $pl->{TYPE} eq "POINTER") { - $var_name = get_pointer_to($var_name); - } - my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}"; $self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);"); $self->pidl("{"); -- cgit From 39cc507d1b7b0454d8f380fc3127fa966a0f972c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 16 Jan 2008 14:54:29 +0100 Subject: pidl: Fix imported function for ServerNDR and add test to make sure it doesn't regress again. (This used to be commit 0e036948307c8ca5013e20a17a10d109830e4df1) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 47312bc83d..ecc43ab896 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -12,7 +12,7 @@ use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); use Parse::Pidl::Util qw(ParseExpr has_property is_constant); use Parse::Pidl::NDR qw(GetNextLevel); use Parse::Pidl::Samba4 qw(ElementStars DeclLong); -use Parse::Pidl::Samba4::NDR::Parser qw(GenerateFunctionOutEnv); +use Parse::Pidl::Samba4::Header qw(GenerateFunctionOutEnv); use vars qw($VERSION); $VERSION = '0.01'; -- cgit From af163d258cfeee2a908e297256570a2bfcc8b651 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 16 Jan 2008 15:06:46 +0100 Subject: pidl: Fix missing import for fatal(). (This used to be commit 6a9827454aaf4279ee85dc5d99d10f14e4c09eae) --- source4/pidl/lib/Parse/Pidl/Samba4.pm | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4.pm b/source4/pidl/lib/Parse/Pidl/Samba4.pm index 5848543a60..d42e01cdb0 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4.pm @@ -12,6 +12,7 @@ require Exporter; use Parse::Pidl::Util qw(has_property is_constant); use Parse::Pidl::NDR qw(GetNextLevel); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); +use Parse::Pidl qw(fatal); use strict; use vars qw($VERSION); -- cgit From 3e53ad6f4a5767fd1a26a35a0060b03a6e77161c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 16 Jan 2008 15:07:00 +0100 Subject: pidl: Add simple test for ServerNDR. (This used to be commit 5b2ea43ed8613ac10ebe7feda0cf070c8079137a) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index ecc43ab896..ca9e7d15db 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -6,6 +6,10 @@ package Parse::Pidl::Samba3::ServerNDR; +use Exporter; +@ISA = qw(Exporter); +@EXPORT_OK = qw(DeclLevel); + use strict; use Parse::Pidl qw(warning fatal); use Parse::Pidl::Typelist qw(mapTypeName scalar_is_reference); -- cgit From 4d656cb5a52bb48fb29b8c546bd33f7a446b0fbf Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 24 Jan 2008 14:57:30 +0100 Subject: pidl/Samba4::Header: we don't need to check if (defined($enum->{ELEMENTS})) twice metze (This used to be commit c1ac13ee12d6d7e41b3700f207c9a8811bb05cd4) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 38 +++++++++++++--------------- 1 file changed, 18 insertions(+), 20 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 2b3a9df80f..b2d5126d1d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -131,27 +131,25 @@ sub HeaderEnum($$) my $count = 0; my $with_val = 0; my $without_val = 0; - if (defined($enum->{ELEMENTS})) { - pidl " { __donnot_use_enum_$name=0x7FFFFFFF}\n"; - foreach my $e (@{$enum->{ELEMENTS}}) { - my $t = "$e"; - my $name; - my $value; - if ($t =~ /(.*)=(.*)/) { - $name = $1; - $value = $2; - $with_val = 1; - fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") - unless ($without_val == 0); - } else { - $name = $t; - $value = $count++; - $without_val = 1; - fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") - unless ($with_val == 0); - } - pidl "#define $name ( $value )\n"; + pidl " { __donnot_use_enum_$name=0x7FFFFFFF}\n"; + foreach my $e (@{$enum->{ELEMENTS}}) { + my $t = "$e"; + my $name; + my $value; + if ($t =~ /(.*)=(.*)/) { + $name = $1; + $value = $2; + $with_val = 1; + fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") + unless ($without_val == 0); + } else { + $name = $t; + $value = $count++; + $without_val = 1; + fatal($e->{ORIGINAL}, "you can't mix enum member with values and without values!") + unless ($with_val == 0); } + pidl "#define $name ( $value )\n"; } pidl "#endif\n"; } -- cgit From 43040be5b9c959c2f9c305eec9d66c103edc14af Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 24 Jan 2008 15:04:58 +0100 Subject: pidl: get rid of stupid ';' char to terminate bitmap defines metze (This used to be commit dd77fc45eee2dde7bdd31a2e39387e94cec158aa) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 45 ++++++++++++++-------------- 1 file changed, 22 insertions(+), 23 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index b2d5126d1d..14f472340c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -82,9 +82,9 @@ sub HeaderElement($) ##################################################################### # parse a struct -sub HeaderStruct($$) +sub HeaderStruct($$;$) { - my($struct,$name) = @_; + my($struct,$name,$tail) = @_; pidl "struct $name"; return if (not defined($struct->{ELEMENTS})); pidl " {\n"; @@ -103,13 +103,14 @@ sub HeaderStruct($$) if (defined $struct->{PROPERTIES}) { HeaderProperties($struct->{PROPERTIES}, []); } + pidl $tail if defined($tail); } ##################################################################### # parse a enum -sub HeaderEnum($$) +sub HeaderEnum($$;$) { - my($enum,$name) = @_; + my($enum,$name,$tail) = @_; my $first = 1; pidl "enum $name"; @@ -153,6 +154,7 @@ sub HeaderEnum($$) } pidl "#endif\n"; } + pidl $tail if defined($tail); } ##################################################################### @@ -170,9 +172,9 @@ sub HeaderBitmap($$) ##################################################################### # parse a union -sub HeaderUnion($$) +sub HeaderUnion($$;$) { - my($union,$name) = @_; + my($union,$name,$tail) = @_; my %done = (); pidl "union $name"; @@ -193,18 +195,19 @@ sub HeaderUnion($$) if (defined $union->{PROPERTIES}) { HeaderProperties($union->{PROPERTIES}, []); } + pidl $tail if defined($tail); } ##################################################################### # parse a type -sub HeaderType($$$) +sub HeaderType($$$;$) { - my($e,$data,$name) = @_; + my($e,$data,$name,$tail) = @_; if (ref($data) eq "HASH") { - ($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name); + ($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name, $tail); ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data, $name); - ($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name); - ($data->{TYPE} eq "UNION") && HeaderUnion($data, $name); + ($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name, $tail); + ($data->{TYPE} eq "UNION") && HeaderUnion($data, $name, $tail); return; } @@ -213,14 +216,15 @@ sub HeaderType($$$) } else { pidl mapTypeName($e->{TYPE}); } + pidl $tail if defined($tail); } ##################################################################### # parse a typedef -sub HeaderTypedef($) +sub HeaderTypedef($;$) { - my($typedef) = shift; - HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}) if defined ($typedef->{DATA}); + my($typedef,$tail) = @_; + HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME}, $tail) if defined ($typedef->{DATA}); } ##################################################################### @@ -357,16 +361,11 @@ sub HeaderInterface($) } foreach my $t (@{$interface->{TYPES}}) { - HeaderTypedef($t) if ($t->{TYPE} eq "TYPEDEF"); - HeaderStruct($t, $t->{NAME}) if ($t->{TYPE} eq "STRUCT"); - HeaderUnion($t, $t->{NAME}) if ($t->{TYPE} eq "UNION"); - HeaderEnum($t, $t->{NAME}) if ($t->{TYPE} eq "ENUM"); + HeaderTypedef($t, ";\n\n") if ($t->{TYPE} eq "TYPEDEF"); + HeaderStruct($t, $t->{NAME}, ";\n\n") if ($t->{TYPE} eq "STRUCT"); + HeaderUnion($t, $t->{NAME}, ";\n\n") if ($t->{TYPE} eq "UNION"); + HeaderEnum($t, $t->{NAME}, ";\n\n") if ($t->{TYPE} eq "ENUM"); HeaderBitmap($t, $t->{NAME}) if ($t->{TYPE} eq "BITMAP"); - pidl ";\n\n" if ($t->{TYPE} eq "BITMAP" or - $t->{TYPE} eq "STRUCT" or - $t->{TYPE} eq "TYPEDEF" or - $t->{TYPE} eq "UNION" or - $t->{TYPE} eq "ENUM"); } foreach my $fn (@{$interface->{FUNCTIONS}}) { -- cgit From 5d55aa99e6488244208d7d84b188f92306c083f6 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 25 Jan 2008 10:07:43 +0100 Subject: pidl/Samba4::Header: fix typedefs of unions and structs without elements metze (This used to be commit 3131847cb67dadd8ee6fcbca5055927b8ba8a219) --- source4/pidl/lib/Parse/Pidl/Samba4/Header.pm | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm index 14f472340c..2e77ff01b8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Header.pm @@ -86,6 +86,7 @@ sub HeaderStruct($$;$) { my($struct,$name,$tail) = @_; pidl "struct $name"; + pidl $tail if defined($tail) and not defined($struct->{ELEMENTS}); return if (not defined($struct->{ELEMENTS})); pidl " {\n"; $tab_depth++; @@ -178,6 +179,7 @@ sub HeaderUnion($$;$) my %done = (); pidl "union $name"; + pidl $tail if defined($tail) and not defined($union->{ELEMENTS}); return if (not defined($union->{ELEMENTS})); pidl " {\n"; $tab_depth++; -- cgit From e6362c4d8c287af7a884d6b7f66b86106d6b5ee7 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 31 Jan 2008 14:48:15 +0100 Subject: pidl/Samba4::NDR::Parser: pass down the correct $var_name to AllocateArrayLevel() metze (This used to be commit c630bece38eed3278466c2934763fcd8dcfb0610) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 02d3a80992..9350a1087d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -375,7 +375,7 @@ sub ParseArrayPullHeader($$$$$$) } if (not $l->{IS_FIXED} and not is_charset_array($e, $l)) { - $self->AllocateArrayLevel($e,$l,$ndr,$env,$size); + $self->AllocateArrayLevel($e,$l,$ndr,$var_name,$size); } return $length; @@ -2058,9 +2058,7 @@ sub ParseFunctionPush($$) sub AllocateArrayLevel($$$$$$) { - my ($self,$e,$l,$ndr,$env,$size) = @_; - - my $var = ParseExpr($e->{NAME}, $env, $e->{ORIGINAL}); + my ($self,$e,$l,$ndr,$var,$size) = @_; my $pl = GetPrevLevel($e, $l); if (defined($pl) and -- cgit From 95c5de1828aaf8692647544768afc8bfae1fab96 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 07:00:50 +0100 Subject: pidl/Samba4::NDR::Parse: move the calculation of NDR_PULL_SET_MEM_CTX() flags into one function metze (This used to be commit 74bf021aa7016ace02a0238e71573f18016e3722) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 70 +++++++++--------------- 1 file changed, 27 insertions(+), 43 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 9350a1087d..2415b516c8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -890,15 +890,17 @@ sub CalcNdrFlags($$$) return undef; } -sub ParseMemCtxPullStart($$$$) +sub ParseMemCtxPullFlags($$$$) { - my ($self, $e, $l, $ptr_name) = @_; + my ($self, $e, $l) = @_; - my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; - my $mem_c_ctx = $ptr_name; - my $mem_c_flags = "0"; + return undef unless ($l->{TYPE} eq "POINTER" or $l->{TYPE} eq "ARRAY"); - return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}); + return undef if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}); + return undef if has_fast_array($e, $l); + return undef if is_charset_array($e, $l); + + my $mem_flags = "0"; if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { my $nl = GetNextLevel($e, $l); @@ -906,12 +908,25 @@ sub ParseMemCtxPullStart($$$$) my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); if ($next_is_array or $next_is_string) { - return; + return undef; } else { - $mem_c_flags = "LIBNDR_FLAG_REF_ALLOC"; + $mem_flags = "LIBNDR_FLAG_REF_ALLOC"; } } + return $mem_flags; +} + +sub ParseMemCtxPullStart($$$$) +{ + my ($self, $e, $l, $ptr_name) = @_; + + my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; + my $mem_c_ctx = $ptr_name; + my $mem_c_flags = $self->ParseMemCtxPullFlags($e, $l); + + return unless defined($mem_c_flags); + $self->pidl("$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);"); $self->pidl("NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);"); } @@ -921,21 +936,9 @@ sub ParseMemCtxPullEnd($$$) my ($self, $e, $l) = @_; my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; - my $mem_r_flags = "0"; + my $mem_r_flags = $self->ParseMemCtxPullFlags($e, $l); - return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED}); - - if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { - my $nl = GetNextLevel($e, $l); - my $next_is_array = ($nl->{TYPE} eq "ARRAY"); - my $next_is_string = (($nl->{TYPE} eq "DATA") and - ($nl->{DATA_TYPE} eq "string")); - if ($next_is_array or $next_is_string) { - return; - } else { - $mem_r_flags = "LIBNDR_FLAG_REF_ALLOC"; - } - } + return unless defined($mem_r_flags); $self->pidl("NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);"); } @@ -1441,31 +1444,12 @@ sub DeclareArrayVariables($$) } } -sub need_decl_mem_ctx($$) -{ - my ($e,$l) = @_; - - return 0 if has_fast_array($e,$l); - return 0 if is_charset_array($e,$l); - return 1 if (($l->{TYPE} eq "ARRAY") and not $l->{IS_FIXED}); - - if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) { - my $nl = GetNextLevel($e, $l); - my $next_is_array = ($nl->{TYPE} eq "ARRAY"); - my $next_is_string = (($nl->{TYPE} eq "DATA") and - ($nl->{DATA_TYPE} eq "string")); - return 0 if ($next_is_array or $next_is_string); - } - return 1 if ($l->{TYPE} eq "POINTER"); - - return 0; -} - sub DeclareMemCtxVariables($$) { my ($self,$e) = @_; foreach my $l (@{$e->{LEVELS}}) { - if (need_decl_mem_ctx($e, $l)) { + my $mem_flags = $self->ParseMemCtxPullFlags($e, $l); + if (defined($mem_flags)) { $self->pidl("TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};"); } } -- cgit From 0f9c453e12ffb03fc8359f726b1e93f3c7d17671 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 31 Jan 2008 15:30:50 +0100 Subject: pidl/IDL: don't strip ',' from the properties content metze (This used to be commit fdf9bcb163516f7d96675ae0dce2917afb8f86d3) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 845 +++++++++++------------ source4/pidl/lib/Parse/Pidl/NDR.pm | 2 +- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 12 +- 3 files changed, 398 insertions(+), 461 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index 35e1d7bcd7..aeee69e306 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -124,7 +124,7 @@ sub new { } }, {#State 16 - DEFAULT => -116 + DEFAULT => -114 }, {#State 17 DEFAULT => -11 @@ -184,7 +184,7 @@ sub new { } }, {#State 26 - DEFAULT => -112 + DEFAULT => -110 }, {#State 27 ACTIONS => { @@ -263,17 +263,17 @@ sub new { }, {#State 40 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, 'text' => 61, - 'listtext' => 57, 'anytext' => 56, - 'constant' => 58 + 'constant' => 57, + 'commalisttext' => 59 } }, {#State 41 @@ -392,28 +392,28 @@ sub new { DEFAULT => -89 }, {#State 57 - ACTIONS => { - "," => 97, - ")" => 98 - } + DEFAULT => -93 }, {#State 58 - DEFAULT => -95 + DEFAULT => -113 }, {#State 59 - DEFAULT => -115 + ACTIONS => { + "," => 97, + ")" => 98 + } }, {#State 60 - DEFAULT => -94 + DEFAULT => -92 }, {#State 61 - DEFAULT => -96 + DEFAULT => -94 }, {#State 62 ACTIONS => { ";" => 99 }, - DEFAULT => -117, + DEFAULT => -115, GOTOS => { 'optional_semicolon' => 100 } @@ -430,7 +430,7 @@ sub new { ACTIONS => { ";" => 99 }, - DEFAULT => -117, + DEFAULT => -115, GOTOS => { 'optional_semicolon' => 102 } @@ -466,7 +466,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 104 }, - DEFAULT => -114, + DEFAULT => -112, GOTOS => { 'optional_identifier' => 105 } @@ -501,7 +501,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 104 }, - DEFAULT => -114, + DEFAULT => -112, GOTOS => { 'optional_identifier' => 107 } @@ -516,7 +516,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 104 }, - DEFAULT => -114, + DEFAULT => -112, GOTOS => { 'optional_identifier' => 108 } @@ -525,7 +525,7 @@ sub new { ACTIONS => { 'IDENTIFIER' => 104 }, - DEFAULT => -114, + DEFAULT => -112, GOTOS => { 'optional_identifier' => 109 } @@ -549,242 +549,242 @@ sub new { }, {#State 82 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, 'anytext' => 112, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 83 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, 'anytext' => 113, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 84 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, 'anytext' => 114, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 85 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, 'anytext' => 115, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 86 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, 'anytext' => 116, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 87 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, 'anytext' => 117, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 88 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, 'anytext' => 118, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 89 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 119, + 'anytext' => 56, 'text' => 61, - 'constant' => 58, - 'commalisttext' => 120 + 'constant' => 57, + 'commalisttext' => 119 } }, {#State 90 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 121, + 'anytext' => 120, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 91 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 122, + 'anytext' => 121, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 92 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 123, + 'anytext' => 122, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 93 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 119, + 'anytext' => 56, 'text' => 61, - 'constant' => 58, - 'commalisttext' => 124 + 'constant' => 57, + 'commalisttext' => 123 } }, {#State 94 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 125, + 'anytext' => 124, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 95 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 126, + 'anytext' => 125, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 96 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 127, + 'anytext' => 126, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 97 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 128, + 'anytext' => 127, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, {#State 98 DEFAULT => -88 }, {#State 99 - DEFAULT => -118 + DEFAULT => -116 }, {#State 100 DEFAULT => -13 }, {#State 101 ACTIONS => { - ";" => 129 + ";" => 128 } }, {#State 102 @@ -795,20 +795,20 @@ sub new { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 130 + 'identifier' => 129 } }, {#State 104 - DEFAULT => -113 + DEFAULT => -111 }, {#State 105 ACTIONS => { - "{" => 132 + "{" => 131 }, DEFAULT => -68, GOTOS => { - 'union_body' => 133, - 'opt_union_body' => 131 + 'union_body' => 132, + 'opt_union_body' => 130 } }, {#State 106 @@ -816,46 +816,46 @@ sub new { }, {#State 107 ACTIONS => { - "{" => 135 + "{" => 134 }, DEFAULT => -58, GOTOS => { - 'struct_body' => 134, - 'opt_struct_body' => 136 + 'struct_body' => 133, + 'opt_struct_body' => 135 } }, {#State 108 ACTIONS => { - "{" => 137 + "{" => 136 }, DEFAULT => -41, GOTOS => { - 'opt_enum_body' => 139, - 'enum_body' => 138 + 'opt_enum_body' => 138, + 'enum_body' => 137 } }, {#State 109 ACTIONS => { - "{" => 141 + "{" => 140 }, DEFAULT => -49, GOTOS => { - 'bitmap_body' => 142, - 'opt_bitmap_body' => 140 + 'bitmap_body' => 141, + 'opt_bitmap_body' => 139 } }, {#State 110 ACTIONS => { - "(" => 143 + "(" => 142 } }, {#State 111 ACTIONS => { 'IDENTIFIER' => 26, - "*" => 145 + "*" => 144 }, GOTOS => { - 'identifier' => 144 + 'identifier' => 143 } }, {#State 112 @@ -876,7 +876,7 @@ sub new { "." => 95, ">" => 96 }, - DEFAULT => -106 + DEFAULT => -104 }, {#State 113 ACTIONS => { @@ -887,7 +887,7 @@ sub new { "{" => 89, "=" => 92 }, - DEFAULT => -97 + DEFAULT => -95 }, {#State 114 ACTIONS => { @@ -907,7 +907,7 @@ sub new { "." => 95, ">" => 96 }, - DEFAULT => -101 + DEFAULT => -99 }, {#State 115 ACTIONS => { @@ -927,7 +927,7 @@ sub new { "." => 95, ">" => 96 }, - DEFAULT => -109 + DEFAULT => -107 }, {#State 116 ACTIONS => { @@ -938,7 +938,7 @@ sub new { "{" => 89, "=" => 92 }, - DEFAULT => -108 + DEFAULT => -106 }, {#State 117 ACTIONS => { @@ -949,7 +949,7 @@ sub new { "{" => 89, "=" => 92 }, - DEFAULT => -99 + DEFAULT => -97 }, {#State 118 ACTIONS => { @@ -969,35 +969,15 @@ sub new { "." => 95, ">" => 96 }, - DEFAULT => -105 + DEFAULT => -103 }, {#State 119 ACTIONS => { - "-" => 83, - ":" => 82, - "<" => 84, - "+" => 86, - "~" => 85, - "*" => 87, - "?" => 88, - "{" => 89, - "&" => 90, - "/" => 91, - "=" => 92, - "(" => 93, - "|" => 94, - "." => 95, - ">" => 96 - }, - DEFAULT => -91 - }, - {#State 120 - ACTIONS => { - "}" => 146, - "," => 147 + "}" => 145, + "," => 97 } }, - {#State 121 + {#State 120 ACTIONS => { ":" => 82, "<" => 84, @@ -1006,9 +986,9 @@ sub new { "{" => 89, "=" => 92 }, - DEFAULT => -103 + DEFAULT => -101 }, - {#State 122 + {#State 121 ACTIONS => { ":" => 82, "<" => 84, @@ -1017,9 +997,9 @@ sub new { "{" => 89, "=" => 92 }, - DEFAULT => -104 + DEFAULT => -102 }, - {#State 123 + {#State 122 ACTIONS => { "-" => 83, ":" => 82, @@ -1037,15 +1017,15 @@ sub new { "." => 95, ">" => 96 }, - DEFAULT => -107 + DEFAULT => -105 }, - {#State 124 + {#State 123 ACTIONS => { - "," => 147, - ")" => 148 + "," => 97, + ")" => 146 } }, - {#State 125 + {#State 124 ACTIONS => { ":" => 82, "<" => 84, @@ -1054,9 +1034,9 @@ sub new { "{" => 89, "=" => 92 }, - DEFAULT => -102 + DEFAULT => -100 }, - {#State 126 + {#State 125 ACTIONS => { ":" => 82, "<" => 84, @@ -1065,9 +1045,9 @@ sub new { "{" => 89, "=" => 92 }, - DEFAULT => -98 + DEFAULT => -96 }, - {#State 127 + {#State 126 ACTIONS => { ":" => 82, "<" => 84, @@ -1076,9 +1056,9 @@ sub new { "{" => 89, "=" => 92 }, - DEFAULT => -100 + DEFAULT => -98 }, - {#State 128 + {#State 127 ACTIONS => { "-" => 83, ":" => 82, @@ -1098,221 +1078,207 @@ sub new { }, DEFAULT => -90 }, - {#State 129 + {#State 128 DEFAULT => -15 }, - {#State 130 + {#State 129 ACTIONS => { - "[" => 149 + "[" => 147 }, DEFAULT => -80, GOTOS => { - 'array_len' => 150 + 'array_len' => 148 } }, - {#State 131 + {#State 130 DEFAULT => -70 }, - {#State 132 + {#State 131 DEFAULT => -65, GOTOS => { - 'union_elements' => 151 + 'union_elements' => 149 } }, - {#State 133 + {#State 132 DEFAULT => -69 }, - {#State 134 + {#State 133 DEFAULT => -59 }, - {#State 135 + {#State 134 DEFAULT => -74, GOTOS => { - 'element_list1' => 152 + 'element_list1' => 150 } }, - {#State 136 + {#State 135 DEFAULT => -60 }, - {#State 137 + {#State 136 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 153, - 'enum_element' => 154, - 'enum_elements' => 155 + 'identifier' => 151, + 'enum_element' => 152, + 'enum_elements' => 153 } }, - {#State 138 + {#State 137 DEFAULT => -42 }, - {#State 139 + {#State 138 DEFAULT => -43 }, - {#State 140 + {#State 139 DEFAULT => -51 }, - {#State 141 + {#State 140 ACTIONS => { 'IDENTIFIER' => 26 }, DEFAULT => -54, GOTOS => { - 'identifier' => 158, - 'bitmap_element' => 157, - 'bitmap_elements' => 156, - 'opt_bitmap_elements' => 159 + 'identifier' => 156, + 'bitmap_element' => 155, + 'bitmap_elements' => 154, + 'opt_bitmap_elements' => 157 } }, - {#State 142 + {#State 141 DEFAULT => -50 }, - {#State 143 + {#State 142 ACTIONS => { "," => -76, - "void" => 163, + "void" => 161, ")" => -76 }, DEFAULT => -83, GOTOS => { - 'base_element' => 160, - 'element_list2' => 162, - 'property_list' => 161 + 'base_element' => 158, + 'element_list2' => 160, + 'property_list' => 159 } }, - {#State 144 + {#State 143 ACTIONS => { - "[" => 149, - "=" => 165 + "[" => 147, + "=" => 163 }, GOTOS => { - 'array_len' => 164 + 'array_len' => 162 } }, - {#State 145 + {#State 144 DEFAULT => -73 }, - {#State 146 - ACTIONS => { - 'CONSTANT' => 59, - 'TEXT' => 16, - 'IDENTIFIER' => 26 - }, - DEFAULT => -93, - GOTOS => { - 'identifier' => 60, - 'anytext' => 166, - 'text' => 61, - 'constant' => 58 - } - }, - {#State 147 + {#State 145 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 167, + 'anytext' => 164, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, - {#State 148 + {#State 146 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 168, + 'anytext' => 165, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, - {#State 149 + {#State 147 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, - "]" => 169, + "]" => 166, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 170, + 'anytext' => 167, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, - {#State 150 + {#State 148 ACTIONS => { - ";" => 171 + ";" => 168 } }, - {#State 151 + {#State 149 ACTIONS => { - "}" => 172 + "}" => 169 }, DEFAULT => -83, GOTOS => { - 'optional_base_element' => 174, - 'property_list' => 173 + 'optional_base_element' => 171, + 'property_list' => 170 } }, - {#State 152 + {#State 150 ACTIONS => { - "}" => 175 + "}" => 172 }, DEFAULT => -83, GOTOS => { - 'base_element' => 176, - 'property_list' => 161 + 'base_element' => 173, + 'property_list' => 159 } }, - {#State 153 + {#State 151 ACTIONS => { - "=" => 177 + "=" => 174 }, DEFAULT => -46 }, - {#State 154 + {#State 152 DEFAULT => -44 }, - {#State 155 + {#State 153 ACTIONS => { - "}" => 178, - "," => 179 + "}" => 175, + "," => 176 } }, - {#State 156 + {#State 154 ACTIONS => { - "," => 180 + "," => 177 }, DEFAULT => -55 }, - {#State 157 + {#State 155 DEFAULT => -52 }, - {#State 158 + {#State 156 ACTIONS => { - "=" => 181 + "=" => 178 } }, - {#State 159 + {#State 157 ACTIONS => { - "}" => 182 + "}" => 179 } }, - {#State 160 + {#State 158 DEFAULT => -78 }, - {#State 161 + {#State 159 ACTIONS => { 'IDENTIFIER' => 26, "signed" => 75, @@ -1329,60 +1295,40 @@ sub new { 'identifier' => 72, 'struct' => 49, 'enum' => 52, - 'type' => 183, + 'type' => 180, 'union' => 54, 'sign' => 73 } }, - {#State 162 + {#State 160 ACTIONS => { - "," => 184, - ")" => 185 + "," => 181, + ")" => 182 } }, - {#State 163 + {#State 161 DEFAULT => -77 }, - {#State 164 + {#State 162 ACTIONS => { - "=" => 186 + "=" => 183 } }, - {#State 165 + {#State 163 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 187, + 'anytext' => 184, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, - {#State 166 - ACTIONS => { - "-" => 83, - ":" => 82, - "<" => 84, - "+" => 86, - "~" => 85, - "*" => 87, - "?" => 88, - "{" => 89, - "&" => 90, - "/" => 91, - "=" => 92, - "(" => 93, - "|" => 94, - "." => 95, - ">" => 96 - }, - DEFAULT => -111 - }, - {#State 167 + {#State 164 ACTIONS => { "-" => 83, ":" => 82, @@ -1400,9 +1346,9 @@ sub new { "." => 95, ">" => 96 }, - DEFAULT => -92 + DEFAULT => -109 }, - {#State 168 + {#State 165 ACTIONS => { ":" => 82, "<" => 84, @@ -1411,18 +1357,18 @@ sub new { "{" => 89, "=" => 92 }, - DEFAULT => -110 + DEFAULT => -108 }, - {#State 169 + {#State 166 ACTIONS => { - "[" => 149 + "[" => 147 }, DEFAULT => -80, GOTOS => { - 'array_len' => 188 + 'array_len' => 185 } }, - {#State 170 + {#State 167 ACTIONS => { "-" => 83, ":" => 82, @@ -1438,130 +1384,130 @@ sub new { "(" => 93, "*" => 87, "." => 95, - "]" => 189, + "]" => 186, ">" => 96 } }, - {#State 171 + {#State 168 DEFAULT => -27 }, - {#State 172 + {#State 169 DEFAULT => -67 }, - {#State 173 + {#State 170 ACTIONS => { "[" => 20 }, DEFAULT => -83, GOTOS => { - 'base_or_empty' => 190, - 'base_element' => 191, - 'empty_element' => 192, - 'property_list' => 193 + 'base_or_empty' => 187, + 'base_element' => 188, + 'empty_element' => 189, + 'property_list' => 190 } }, - {#State 174 + {#State 171 DEFAULT => -66 }, - {#State 175 + {#State 172 DEFAULT => -57 }, - {#State 176 + {#State 173 ACTIONS => { - ";" => 194 + ";" => 191 } }, - {#State 177 + {#State 174 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 195, + 'anytext' => 192, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, - {#State 178 + {#State 175 DEFAULT => -40 }, - {#State 179 + {#State 176 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 153, - 'enum_element' => 196 + 'identifier' => 151, + 'enum_element' => 193 } }, - {#State 180 + {#State 177 ACTIONS => { 'IDENTIFIER' => 26 }, GOTOS => { - 'identifier' => 158, - 'bitmap_element' => 197 + 'identifier' => 156, + 'bitmap_element' => 194 } }, - {#State 181 + {#State 178 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 198, + 'anytext' => 195, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, - {#State 182 + {#State 179 DEFAULT => -48 }, - {#State 183 + {#State 180 DEFAULT => -72, GOTOS => { - 'pointers' => 199 + 'pointers' => 196 } }, - {#State 184 + {#State 181 DEFAULT => -83, GOTOS => { - 'base_element' => 200, - 'property_list' => 161 + 'base_element' => 197, + 'property_list' => 159 } }, - {#State 185 + {#State 182 ACTIONS => { - ";" => 201 + ";" => 198 } }, - {#State 186 + {#State 183 ACTIONS => { - 'CONSTANT' => 59, + 'CONSTANT' => 58, 'TEXT' => 16, 'IDENTIFIER' => 26 }, - DEFAULT => -93, + DEFAULT => -91, GOTOS => { 'identifier' => 60, - 'anytext' => 202, + 'anytext' => 199, 'text' => 61, - 'constant' => 58 + 'constant' => 57 } }, - {#State 187 + {#State 184 ACTIONS => { "-" => 83, ":" => 82, "?" => 88, "<" => 84, - ";" => 203, + ";" => 200, "+" => 86, "~" => 85, "&" => 90, @@ -1575,34 +1521,34 @@ sub new { ">" => 96 } }, - {#State 188 + {#State 185 DEFAULT => -81 }, - {#State 189 + {#State 186 ACTIONS => { - "[" => 149 + "[" => 147 }, DEFAULT => -80, GOTOS => { - 'array_len' => 204 + 'array_len' => 201 } }, - {#State 190 + {#State 187 DEFAULT => -64 }, - {#State 191 + {#State 188 ACTIONS => { - ";" => 205 + ";" => 202 } }, - {#State 192 + {#State 189 DEFAULT => -63 }, - {#State 193 + {#State 190 ACTIONS => { 'IDENTIFIER' => 26, "signed" => 75, - ";" => 206, + ";" => 203, 'void' => 69, "unsigned" => 79, "[" => 20 @@ -1616,15 +1562,15 @@ sub new { 'identifier' => 72, 'struct' => 49, 'enum' => 52, - 'type' => 183, + 'type' => 180, 'union' => 54, 'sign' => 73 } }, - {#State 194 + {#State 191 DEFAULT => -75 }, - {#State 195 + {#State 192 ACTIONS => { "-" => 83, ":" => 82, @@ -1644,13 +1590,13 @@ sub new { }, DEFAULT => -47 }, - {#State 196 + {#State 193 DEFAULT => -45 }, - {#State 197 + {#State 194 DEFAULT => -53 }, - {#State 198 + {#State 195 ACTIONS => { "-" => 83, ":" => 82, @@ -1670,28 +1616,28 @@ sub new { }, DEFAULT => -56 }, - {#State 199 + {#State 196 ACTIONS => { 'IDENTIFIER' => 26, - "*" => 145 + "*" => 144 }, GOTOS => { - 'identifier' => 207 + 'identifier' => 204 } }, - {#State 200 + {#State 197 DEFAULT => -79 }, - {#State 201 + {#State 198 DEFAULT => -26 }, - {#State 202 + {#State 199 ACTIONS => { "-" => 83, ":" => 82, "?" => 88, "<" => 84, - ";" => 208, + ";" => 205, "+" => 86, "~" => 85, "&" => 90, @@ -1705,31 +1651,31 @@ sub new { ">" => 96 } }, - {#State 203 + {#State 200 DEFAULT => -24 }, - {#State 204 + {#State 201 DEFAULT => -82 }, - {#State 205 + {#State 202 DEFAULT => -62 }, - {#State 206 + {#State 203 DEFAULT => -61 }, - {#State 207 + {#State 204 ACTIONS => { - "[" => 149 + "[" => 147 }, DEFAULT => -80, GOTOS => { - 'array_len' => 209 + 'array_len' => 206 } }, - {#State 208 + {#State 205 DEFAULT => -25 }, - {#State 209 + {#State 206 DEFAULT => -71 } ], @@ -1744,43 +1690,43 @@ sub new { [#Rule 2 'idl', 2, sub -#line 19 "idl.yp" +#line 19 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 3 'idl', 2, sub -#line 20 "idl.yp" +#line 20 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 4 'idl', 2, sub -#line 21 "idl.yp" +#line 21 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 5 'idl', 2, sub -#line 22 "idl.yp" +#line 22 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 6 'idl', 2, sub -#line 23 "idl.yp" +#line 23 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 7 'idl', 2, sub -#line 24 "idl.yp" +#line 24 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 8 'import', 3, sub -#line 27 "idl.yp" +#line 27 "pidl/idl.yp" {{ "TYPE" => "IMPORT", "PATHS" => $_[2], @@ -1791,7 +1737,7 @@ sub [#Rule 9 'include', 3, sub -#line 34 "idl.yp" +#line 34 "pidl/idl.yp" {{ "TYPE" => "INCLUDE", "PATHS" => $_[2], @@ -1802,7 +1748,7 @@ sub [#Rule 10 'importlib', 3, sub -#line 41 "idl.yp" +#line 41 "pidl/idl.yp" {{ "TYPE" => "IMPORTLIB", "PATHS" => $_[2], @@ -1813,19 +1759,19 @@ sub [#Rule 11 'commalist', 1, sub -#line 50 "idl.yp" +#line 50 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 12 'commalist', 3, sub -#line 51 "idl.yp" +#line 51 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 13 'coclass', 7, sub -#line 55 "idl.yp" +#line 55 "pidl/idl.yp" {{ "TYPE" => "COCLASS", "PROPERTIES" => $_[1], @@ -1841,13 +1787,13 @@ sub [#Rule 15 'interface_names', 4, sub -#line 67 "idl.yp" +#line 67 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 16 'interface', 7, sub -#line 71 "idl.yp" +#line 71 "pidl/idl.yp" {{ "TYPE" => "INTERFACE", "PROPERTIES" => $_[1], @@ -1860,7 +1806,7 @@ sub [#Rule 17 'cpp_quote', 4, sub -#line 82 "idl.yp" +#line 82 "pidl/idl.yp" {{ "TYPE" => "CPP_QUOTE", "FILE" => $_[0]->YYData->{FILE}, @@ -1871,13 +1817,13 @@ sub [#Rule 18 'definitions', 1, sub -#line 91 "idl.yp" +#line 91 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 19 'definitions', 2, sub -#line 92 "idl.yp" +#line 92 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 20 @@ -1895,7 +1841,7 @@ sub [#Rule 24 'const', 7, sub -#line 100 "idl.yp" +#line 100 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1909,7 +1855,7 @@ sub [#Rule 25 'const', 8, sub -#line 110 "idl.yp" +#line 110 "pidl/idl.yp" {{ "TYPE" => "CONST", "DTYPE" => $_[2], @@ -1924,7 +1870,7 @@ sub [#Rule 26 'function', 7, sub -#line 124 "idl.yp" +#line 124 "pidl/idl.yp" {{ "TYPE" => "FUNCTION", "NAME" => $_[3], @@ -1938,7 +1884,7 @@ sub [#Rule 27 'typedef', 6, sub -#line 136 "idl.yp" +#line 136 "pidl/idl.yp" {{ "TYPE" => "TYPEDEF", "PROPERTIES" => $_[1], @@ -1964,7 +1910,7 @@ sub [#Rule 32 'typedecl', 2, sub -#line 149 "idl.yp" +#line 149 "pidl/idl.yp" { $_[1] } ], [#Rule 33 @@ -1976,7 +1922,7 @@ sub [#Rule 35 'existingtype', 2, sub -#line 154 "idl.yp" +#line 154 "pidl/idl.yp" { ($_[1]?$_[1]:"signed") ." $_[2]" } ], [#Rule 36 @@ -1991,13 +1937,13 @@ sub [#Rule 39 'type', 1, sub -#line 158 "idl.yp" +#line 158 "pidl/idl.yp" { "void" } ], [#Rule 40 'enum_body', 3, sub -#line 160 "idl.yp" +#line 160 "pidl/idl.yp" { $_[2] } ], [#Rule 41 @@ -2009,7 +1955,7 @@ sub [#Rule 43 'enum', 4, sub -#line 163 "idl.yp" +#line 163 "pidl/idl.yp" {{ "TYPE" => "ENUM", "PROPERTIES" => $_[1], @@ -2020,13 +1966,13 @@ sub [#Rule 44 'enum_elements', 1, sub -#line 172 "idl.yp" +#line 172 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 45 'enum_elements', 3, sub -#line 173 "idl.yp" +#line 173 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 46 @@ -2035,13 +1981,13 @@ sub [#Rule 47 'enum_element', 3, sub -#line 177 "idl.yp" +#line 177 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 48 'bitmap_body', 3, sub -#line 180 "idl.yp" +#line 180 "pidl/idl.yp" { $_[2] } ], [#Rule 49 @@ -2053,7 +1999,7 @@ sub [#Rule 51 'bitmap', 4, sub -#line 183 "idl.yp" +#line 183 "pidl/idl.yp" {{ "TYPE" => "BITMAP", "PROPERTIES" => $_[1], @@ -2064,13 +2010,13 @@ sub [#Rule 52 'bitmap_elements', 1, sub -#line 192 "idl.yp" +#line 192 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 53 'bitmap_elements', 3, sub -#line 193 "idl.yp" +#line 193 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 54 @@ -2082,13 +2028,13 @@ sub [#Rule 56 'bitmap_element', 3, sub -#line 198 "idl.yp" +#line 198 "pidl/idl.yp" { "$_[1] ( $_[3] )" } ], [#Rule 57 'struct_body', 3, sub -#line 201 "idl.yp" +#line 201 "pidl/idl.yp" { $_[2] } ], [#Rule 58 @@ -2100,7 +2046,7 @@ sub [#Rule 60 'struct', 4, sub -#line 205 "idl.yp" +#line 205 "pidl/idl.yp" {{ "TYPE" => "STRUCT", "PROPERTIES" => $_[1], @@ -2111,7 +2057,7 @@ sub [#Rule 61 'empty_element', 2, sub -#line 214 "idl.yp" +#line 214 "pidl/idl.yp" {{ "NAME" => "", "TYPE" => "EMPTY", @@ -2131,7 +2077,7 @@ sub [#Rule 64 'optional_base_element', 2, sub -#line 228 "idl.yp" +#line 228 "pidl/idl.yp" { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] } ], [#Rule 65 @@ -2140,13 +2086,13 @@ sub [#Rule 66 'union_elements', 2, sub -#line 233 "idl.yp" +#line 233 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 67 'union_body', 3, sub -#line 236 "idl.yp" +#line 236 "pidl/idl.yp" { $_[2] } ], [#Rule 68 @@ -2158,7 +2104,7 @@ sub [#Rule 70 'union', 4, sub -#line 240 "idl.yp" +#line 240 "pidl/idl.yp" {{ "TYPE" => "UNION", "PROPERTIES" => $_[1], @@ -2169,7 +2115,7 @@ sub [#Rule 71 'base_element', 5, sub -#line 249 "idl.yp" +#line 249 "pidl/idl.yp" {{ "NAME" => $_[4], "TYPE" => $_[2], @@ -2183,25 +2129,25 @@ sub [#Rule 72 'pointers', 0, sub -#line 263 "idl.yp" +#line 263 "pidl/idl.yp" { 0 } ], [#Rule 73 'pointers', 2, sub -#line 264 "idl.yp" +#line 264 "pidl/idl.yp" { $_[1]+1 } ], [#Rule 74 'element_list1', 0, sub -#line 268 "idl.yp" +#line 268 "pidl/idl.yp" { [] } ], [#Rule 75 'element_list1', 3, sub -#line 269 "idl.yp" +#line 269 "pidl/idl.yp" { push(@{$_[1]}, $_[2]); $_[1] } ], [#Rule 76 @@ -2213,13 +2159,13 @@ sub [#Rule 78 'element_list2', 1, sub -#line 275 "idl.yp" +#line 275 "pidl/idl.yp" { [ $_[1] ] } ], [#Rule 79 'element_list2', 3, sub -#line 276 "idl.yp" +#line 276 "pidl/idl.yp" { push(@{$_[1]}, $_[3]); $_[1] } ], [#Rule 80 @@ -2228,13 +2174,13 @@ sub [#Rule 81 'array_len', 3, sub -#line 281 "idl.yp" +#line 281 "pidl/idl.yp" { push(@{$_[3]}, "*"); $_[3] } ], [#Rule 82 'array_len', 4, sub -#line 282 "idl.yp" +#line 282 "pidl/idl.yp" { push(@{$_[4]}, "$_[2]"); $_[4] } ], [#Rule 83 @@ -2243,178 +2189,169 @@ sub [#Rule 84 'property_list', 4, sub -#line 288 "idl.yp" +#line 288 "pidl/idl.yp" { FlattenHash([$_[1],$_[3]]); } ], [#Rule 85 'properties', 1, sub -#line 291 "idl.yp" +#line 291 "pidl/idl.yp" { $_[1] } ], [#Rule 86 'properties', 3, sub -#line 292 "idl.yp" +#line 292 "pidl/idl.yp" { FlattenHash([$_[1], $_[3]]); } ], [#Rule 87 'property', 1, sub -#line 295 "idl.yp" +#line 295 "pidl/idl.yp" {{ "$_[1]" => "1" }} ], [#Rule 88 'property', 4, sub -#line 296 "idl.yp" +#line 296 "pidl/idl.yp" {{ "$_[1]" => "$_[3]" }} ], [#Rule 89 - 'listtext', 1, undef - ], - [#Rule 90 - 'listtext', 3, -sub -#line 301 "idl.yp" -{ "$_[1] $_[3]" } - ], - [#Rule 91 'commalisttext', 1, undef ], - [#Rule 92 + [#Rule 90 'commalisttext', 3, sub -#line 306 "idl.yp" +#line 301 "pidl/idl.yp" { "$_[1],$_[3]" } ], - [#Rule 93 + [#Rule 91 'anytext', 0, sub -#line 310 "idl.yp" +#line 305 "pidl/idl.yp" { "" } ], + [#Rule 92 + 'anytext', 1, undef + ], + [#Rule 93 + 'anytext', 1, undef + ], [#Rule 94 'anytext', 1, undef ], [#Rule 95 - 'anytext', 1, undef + 'anytext', 3, +sub +#line 307 "pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } ], [#Rule 96 - 'anytext', 1, undef + 'anytext', 3, +sub +#line 308 "pidl/idl.yp" +{ "$_[1]$_[2]$_[3]" } ], [#Rule 97 'anytext', 3, sub -#line 312 "idl.yp" +#line 309 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 98 'anytext', 3, sub -#line 313 "idl.yp" +#line 310 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 99 'anytext', 3, sub -#line 314 "idl.yp" +#line 311 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 100 'anytext', 3, sub -#line 315 "idl.yp" +#line 312 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 101 'anytext', 3, sub -#line 316 "idl.yp" +#line 313 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 102 'anytext', 3, sub -#line 317 "idl.yp" +#line 314 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 103 'anytext', 3, sub -#line 318 "idl.yp" +#line 315 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 104 'anytext', 3, sub -#line 319 "idl.yp" +#line 316 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 105 'anytext', 3, sub -#line 320 "idl.yp" +#line 317 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 106 'anytext', 3, sub -#line 321 "idl.yp" +#line 318 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 107 'anytext', 3, sub -#line 322 "idl.yp" +#line 319 "pidl/idl.yp" { "$_[1]$_[2]$_[3]" } ], [#Rule 108 - 'anytext', 3, -sub -#line 323 "idl.yp" -{ "$_[1]$_[2]$_[3]" } - ], - [#Rule 109 - 'anytext', 3, -sub -#line 324 "idl.yp" -{ "$_[1]$_[2]$_[3]" } - ], - [#Rule 110 'anytext', 5, sub -#line 325 "idl.yp" +#line 320 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 111 + [#Rule 109 'anytext', 5, sub -#line 326 "idl.yp" +#line 321 "pidl/idl.yp" { "$_[1]$_[2]$_[3]$_[4]$_[5]" } ], - [#Rule 112 + [#Rule 110 'identifier', 1, undef ], - [#Rule 113 + [#Rule 111 'optional_identifier', 1, undef ], - [#Rule 114 + [#Rule 112 'optional_identifier', 0, undef ], - [#Rule 115 + [#Rule 113 'constant', 1, undef ], - [#Rule 116 + [#Rule 114 'text', 1, sub -#line 340 "idl.yp" +#line 335 "pidl/idl.yp" { "\"$_[1]\"" } ], - [#Rule 117 + [#Rule 115 'optional_semicolon', 0, undef ], - [#Rule 118 + [#Rule 116 'optional_semicolon', 1, undef ] ], @@ -2422,7 +2359,7 @@ sub bless($self,$class); } -#line 351 "idl.yp" +#line 346 "pidl/idl.yp" use Parse::Pidl qw(error); diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index fc6bfe4c96..5a34c5f94f 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -688,7 +688,7 @@ sub ParseInterface($) if (!defined $idl->{PROPERTIES}->{endpoint}) { push @endpoints, "\"ncacn_np:[\\\\pipe\\\\" . $idl->{NAME} . "]\""; } else { - @endpoints = split / /, $idl->{PROPERTIES}->{endpoint}; + @endpoints = split /,/, $idl->{PROPERTIES}->{endpoint}; } return { diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 2415b516c8..8326ce5fb6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -384,7 +384,7 @@ sub ParseArrayPullHeader($$$$$$) sub compression_alg($$) { my ($e, $l) = @_; - my ($alg, $clen, $dlen) = split(/ /, $l->{COMPRESSION}); + my ($alg, $clen, $dlen) = split(/,/, $l->{COMPRESSION}); return $alg; } @@ -392,7 +392,7 @@ sub compression_alg($$) sub compression_clen($$$) { my ($e, $l, $env) = @_; - my ($alg, $clen, $dlen) = split(/ /, $l->{COMPRESSION}); + my ($alg, $clen, $dlen) = split(/,/, $l->{COMPRESSION}); return ParseExpr($clen, $env, $e->{ORIGINAL}); } @@ -400,7 +400,7 @@ sub compression_clen($$$) sub compression_dlen($$$) { my ($e,$l,$env) = @_; - my ($alg, $clen, $dlen) = split(/ /, $l->{COMPRESSION}); + my ($alg, $clen, $dlen) = split(/,/, $l->{COMPRESSION}); return ParseExpr($dlen, $env, $e->{ORIGINAL}); } @@ -830,7 +830,7 @@ sub ParseDataPull($$$$$$$) if (my $range = has_property($e, "range")) { $var_name = get_value_of($var_name); - my ($low, $high) = split(/ /, $range, 2); + my ($low, $high) = split(/,/, $range, 2); $self->pidl("if ($var_name < $low || $var_name > $high) {"); $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");"); $self->pidl("}"); @@ -2218,7 +2218,7 @@ sub FunctionTable($$) $interface->{PROPERTIES}->{authservice} = "\"host\""; } - my @a = split / /, $interface->{PROPERTIES}->{authservice}; + my @a = split /,/, $interface->{PROPERTIES}->{authservice}; my $authservice_count = $#a + 1; $self->pidl("static const char * const $interface->{NAME}\_authservice_strings[] = {"); @@ -2293,7 +2293,7 @@ sub HeaderInterface($$$) } if (defined $interface->{PROPERTIES}->{helper}) { - $self->HeaderInclude(split / /, $interface->{PROPERTIES}->{helper}); + $self->HeaderInclude(split /,/, $interface->{PROPERTIES}->{helper}); } if (defined $interface->{PROPERTIES}->{uuid}) { -- cgit From a4571e661f662eabf4ab15d5302b576333fd6371 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 18:20:32 +0100 Subject: pidl: cosmetic fix to use the same value everywhere metze (This used to be commit 3c191981436ab3f7dd166a87875ffbac127fbdf5) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 5a34c5f94f..98e8f183a2 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -623,7 +623,7 @@ sub CheckPointerTypes($$) foreach my $e (@{$s->{ELEMENTS}}) { if ($e->{POINTERS} and not defined(pointer_type($e))) { - $e->{PROPERTIES}->{$default} = 1; + $e->{PROPERTIES}->{$default} = '1'; } } } -- cgit From c94ee074998a623dd9e47ca35b73ba2a83fbfeca Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 09:49:54 +0100 Subject: CHECKED... pidl/Samba4::NDR::Parser: move logic for extra get_pointer_of() into a function metze (This used to be commit 3369015f5d8c425e1a9f9d861471028f03f163bb) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 59 ++++++++++++++---------- 1 file changed, 34 insertions(+), 25 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 8326ce5fb6..81e8a21625 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -669,23 +669,39 @@ sub ParsePtrPush($$$$) } } +sub need_pointer_to($$$) +{ + my ($e, $l, $scalar_only) = @_; + + my $t; + if (ref($l->{DATA_TYPE})) { + $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; + } else { + $t = $l->{DATA_TYPE}; + } + + if (not Parse::Pidl::Typelist::is_scalar($t)) { + return 1 if $scalar_only; + } + + if (Parse::Pidl::Typelist::scalar_is_reference($t)) { + return 1; + } + + return 0; +} + sub ParseDataPrint($$$$) { my ($self, $e, $l, $var_name) = @_; - if (not ref($l->{DATA_TYPE}) or - defined($l->{DATA_TYPE}->{NAME})) { - my $t; - if (ref($l->{DATA_TYPE})) { - $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; - } else { - $t = $l->{DATA_TYPE}; - } - if (not Parse::Pidl::Typelist::is_scalar($t) or - Parse::Pidl::Typelist::scalar_is_reference($t)) { + if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { + + if (need_pointer_to($e, $l, 1)) { $var_name = get_pointer_to($var_name); } - $self->pidl("ndr_print_$t(ndr, \"$e->{NAME}\", $var_name);"); + + $self->pidl(TypeFunctionName("ndr_print", $l->{DATA_TYPE})."(ndr, \"$e->{NAME}\", $var_name);"); } else { $self->ParseTypePrint($l->{DATA_TYPE}, $var_name); } @@ -815,12 +831,11 @@ sub ParseDataPull($$$$$$$) { my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_; - if (not ref($l->{DATA_TYPE}) or - defined($l->{DATA_TYPE}->{NAME})) { + if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + if (need_pointer_to($e, $l, 0)) { $var_name = get_pointer_to($var_name); } @@ -845,21 +860,15 @@ sub ParseDataPush($$$$$$$) my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_; if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { - my $t; - if (ref($l->{DATA_TYPE}) eq "HASH") { - $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; - } else { - $t = $l->{DATA_TYPE}; - } - + + my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); + # strings are passed by value rather than reference - if (not Parse::Pidl::Typelist::is_scalar($t) or - Parse::Pidl::Typelist::scalar_is_reference($t)) { + if (need_pointer_to($e, $l, 1)) { $var_name = get_pointer_to($var_name); } - my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - $self->pidl("NDR_CHECK(ndr_push_$t($ndr, $ndr_flags, $var_name));"); + $self->pidl("NDR_CHECK(".TypeFunctionName("ndr_push", $l->{DATA_TYPE})."($ndr, $ndr_flags, $var_name));"); } else { $self->ParseTypePush($l->{DATA_TYPE}, $var_name, $primitives, $deferred); } -- cgit From a0c83e990f6dfda809600a0160e383f89bfe2f6c Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 09:54:25 +0100 Subject: CHECKED... TODO:MSG pidl/Samba4::NDR::Parser: fix ... metze (This used to be commit 29c104944bcad30c6a2a3fa70d527bf0ee8969de) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 81e8a21625..281018d4cc 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -42,19 +42,21 @@ sub append_prefix($$) { my ($e, $var_name) = @_; my $pointers = 0; + my $arrays = 0; foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { $pointers++; } elsif ($l->{TYPE} eq "ARRAY") { + $arrays++; if (($pointers == 0) and (not $l->{IS_FIXED}) and (not $l->{IS_INLINE})) { - return get_value_of($var_name); + return get_value_of($var_name); } } elsif ($l->{TYPE} eq "DATA") { if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - return get_value_of($var_name) unless ($pointers); + return get_value_of($var_name) unless ($pointers or $arrays); } } } @@ -684,8 +686,17 @@ sub need_pointer_to($$$) return 1 if $scalar_only; } + my $arrays = 0; + + foreach my $tl (@{$e->{LEVELS}}) { + last if $l == $tl; + if ($tl->{TYPE} eq "ARRAY") { + $arrays++; + } + } + if (Parse::Pidl::Typelist::scalar_is_reference($t)) { - return 1; + return 1 unless $arrays; } return 0; -- cgit From 9e999a67a7d3ff6172a7bb5db28c2f528d74f87f Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 31 Jan 2008 14:57:35 +0100 Subject: CHECKED... pidl/Samba4::NDR::Parser: correctly get the name of an array element When we have "*r->out.ous" (char ***ous, a pointer to a pointer to an array). we need to use "(*r->out.ous)[3]" to access the 3rd element of the array "*r->out.ous[3]" was generated before, but that's the same as "*(r->out.ous[3])". metze (This used to be commit 13afc89a87716063180723f0e9cb4f76daca837e) --- source4/pidl/lib/Parse/Pidl/CUtil.pm | 15 ++++++++++++++- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 8 ++++---- 2 files changed, 18 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/CUtil.pm b/source4/pidl/lib/Parse/Pidl/CUtil.pm index bd7b16812c..9deb6ee177 100644 --- a/source4/pidl/lib/Parse/Pidl/CUtil.pm +++ b/source4/pidl/lib/Parse/Pidl/CUtil.pm @@ -6,7 +6,7 @@ package Parse::Pidl::CUtil; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(get_pointer_to get_value_of); +@EXPORT = qw(get_pointer_to get_value_of get_array_element); use vars qw($VERSION); $VERSION = '0.01'; @@ -36,4 +36,17 @@ sub get_value_of($) } } +sub get_array_element($$) +{ + my ($var_name, $idx) = @_; + + if ($var_name =~ /^\*.*$/) { + $var_name = "($var_name)"; + } elsif ($var_name =~ /^\&.*$/) { + $var_name = "($var_name)"; + } + + return "$var_name"."[$idx]"; +} + 1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 281018d4cc..81a8bf88cd 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -14,7 +14,7 @@ require Exporter; use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName typeHasBody); use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid); -use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); +use Parse::Pidl::CUtil qw(get_pointer_to get_value_of get_array_element); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array); use Parse::Pidl::Samba4 qw(is_intree choose_header); use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv); @@ -584,7 +584,7 @@ sub ParseElementPushLevel my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL}); my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; - $var_name = $var_name . "[$counter]"; + $var_name = get_array_element($var_name, $counter); if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { $self->pidl("for ($counter = 0; $counter < $length; $counter++) {"); @@ -779,7 +779,7 @@ sub ParseElementPrint($$$$) $self->pidl("if (idx_$l->{LEVEL_INDEX}) {"); $self->indent; - $var_name = $var_name . "[$counter]"; + $var_name = get_array_element($var_name, $counter); } } elsif ($l->{TYPE} eq "DATA") { $self->ParseDataPrint($e, $l, $var_name); @@ -1048,7 +1048,7 @@ sub ParseElementPullLevel my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; my $array_name = $var_name; - $var_name = $var_name . "[$counter]"; + $var_name = get_array_element($var_name, $counter); $self->ParseMemCtxPullStart($e, $l, $array_name); -- cgit From 19898379bd23e4df1249aa78f50a2947ab63c7cf Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 10:30:47 +0100 Subject: LOOKS OK... pidl: get the pointer types correct when an element has multiple pointers Only the first level gets the pointer type from the pointer property, the others get them from the pointer_default() interface property see http://msdn2.microsoft.com/en-us/library/aa378984(VS.85).aspx (Here they talk about the rightmost pointer, but testing shows they mean the leftmost pointer.) metze (This used to be commit 0569139ca2960ec5478829c3e66f7ff69bdb55cd) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 35 ++++++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 98e8f183a2..7d8907c6b5 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -72,9 +72,9 @@ my $scalar_alignment = { 'ipv4address' => 4 }; -sub GetElementLevelTable($) +sub GetElementLevelTable($$) { - my $e = shift; + my ($e, $pointer_default) = @_; my $order = []; my $is_deferred = 0; @@ -157,25 +157,38 @@ sub GetElementLevelTable($) # Next, all the pointers foreach my $i (1..$e->{POINTERS}) { - my $pt = pointer_type($e); - my $level = "EMBEDDED"; # Top level "ref" pointers do not have a referrent identifier - $level = "TOP" if ( defined($pt) - and $i == 1 - and $e->{PARENT}->{TYPE} eq "FUNCTION"); + $level = "TOP" if ($i == 1 and $e->{PARENT}->{TYPE} eq "FUNCTION"); + + my $pt; + # + # Only the first level gets the pointer type from the + # pointer property, the others get them from + # the pointer_default() interface property + # + # see http://msdn2.microsoft.com/en-us/library/aa378984(VS.85).aspx + # (Here they talk about the rightmost pointer, but testing shows + # they mean the leftmost pointer.) + # + # --metze + # + if ($i == 1) { + $pt = pointer_type($e); + } else { + $pt = $pointer_default; + } push (@$order, { TYPE => "POINTER", - # for now, there can only be one pointer type per element - POINTER_TYPE => pointer_type($e), + POINTER_TYPE => $pt, POINTER_INDEX => $pointer_idx, IS_DEFERRED => "$is_deferred", LEVEL => $level }); warning($e, "top-level \[out\] pointer `$e->{NAME}' is not a \[ref\] pointer") - if ($i == 1 and pointer_type($e) ne "ref" and + if ($i == 1 and $pt ne "ref" and $e->{PARENT}->{TYPE} eq "FUNCTION" and not has_property($e, "in")); @@ -391,7 +404,7 @@ sub ParseElement($$) NAME => $e->{NAME}, TYPE => $e->{TYPE}, PROPERTIES => $e->{PROPERTIES}, - LEVELS => GetElementLevelTable($e), + LEVELS => GetElementLevelTable($e, $pointer_default), REPRESENTATION_TYPE => ($e->{PROPERTIES}->{represent_as} or $e->{TYPE}), ALIGN => align_type($e->{TYPE}), ORIGINAL => $e -- cgit From 2670c954466683bc3769fae4505baa78ec43a253 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 23:09:37 +0100 Subject: WORKS!!!...pidl/NDR: fix handling of multilevel pointers in function elements The 2nd or higher level of wire pointers needs to be marked as deferred. metze (This used to be commit 6fcf2456d0e81898b5779ef1650f38b4c5363a80) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 7d8907c6b5..003eaf0ba7 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -173,9 +173,9 @@ sub GetElementLevelTable($$) # # --metze # - if ($i == 1) { - $pt = pointer_type($e); - } else { + $pt = pointer_type($e); + if ($i > 1) { + $is_deferred = 1 if ($pt ne "ref" and $e->{PARENT}->{TYPE} eq "FUNCTION"); $pt = $pointer_default; } @@ -195,7 +195,7 @@ sub GetElementLevelTable($$) $pointer_idx++; # everything that follows will be deferred - $is_deferred = 1 if ($e->{PARENT}->{TYPE} ne "FUNCTION"); + $is_deferred = 1 if ($level ne "TOP"); my $array_size = shift @size_is; my $array_length; -- cgit From 4117839d7725a814c76c3869a23b6bd65cedf079 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 31 Jan 2008 15:04:22 +0100 Subject: Works!!!...pidl/Samba4::NDR::Parser: fix support for embedded "ref" pointers The memory allocation of embedded "ref" pointers needs to be the same as for all other embedded pointers. metze (This used to be commit 8ebf16c0741085fa769fcc2929f275ab49b1ea5d) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 81a8bf88cd..6e6d227681 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -929,7 +929,7 @@ sub ParseMemCtxPullFlags($$$$) ($nl->{DATA_TYPE} eq "string")); if ($next_is_array or $next_is_string) { return undef; - } else { + } elsif ($l->{LEVEL} eq "TOP") { $mem_flags = "LIBNDR_FLAG_REF_ALLOC"; } } @@ -1129,10 +1129,7 @@ sub ParsePtrPull($$$$$) my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); - if ($l->{POINTER_TYPE} eq "ref") { - if ($l->{LEVEL} eq "EMBEDDED") { - $self->pidl("NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"); - } + if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP") { if (!$next_is_array and !$next_is_string) { $self->pidl("if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"); @@ -1141,16 +1138,19 @@ sub ParsePtrPull($$$$$) } return; + } elsif ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "EMBEDDED") { + $self->pidl("NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"); } elsif (($l->{POINTER_TYPE} eq "unique") or ($l->{POINTER_TYPE} eq "relative") or ($l->{POINTER_TYPE} eq "full")) { $self->pidl("NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));"); - $self->pidl("if (_ptr_$e->{NAME}) {"); - $self->indent; } else { die("Unhandled pointer type $l->{POINTER_TYPE}"); } + $self->pidl("if (_ptr_$e->{NAME}) {"); + $self->indent; + # Don't do this for arrays, they're allocated at the actual level # of the array unless ($next_is_array or $next_is_string) { -- cgit From e22c627ea1e700c30568399cf94df5b88b05f216 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sat, 2 Feb 2008 11:13:03 +0100 Subject: pidl: revert changes it didn't want to push...sorry! 8ebf16c0741085fa769fcc2929f275ab49b1ea5d Works!!!...pidl/Samba4::NDR::Parser: fix support for embedded "ref" pointers 6fcf2456d0e81898b5779ef1650f38b4c5363a80 WORKS!!!...pidl/NDR: fix handling of multilevel pointers in function elements 0569139ca2960ec5478829c3e66f7ff69bdb55cd LOOKS OK... pidl: get the pointer types correct when an element has multiple pointe rs 13afc89a87716063180723f0e9cb4f76daca837e CHECKED... pidl/Samba4::NDR::Parser: correctly get the name of an array element 29c104944bcad30c6a2a3fa70d527bf0ee8969de CHECKED... TODO:MSG pidl/Samba4::NDR::Parser: fix ... 3369015f5d8c425e1a9f9d861471028f03f163bb CHECKED... pidl/Samba4::NDR::Parser: move logic for extra get_pointer_of() into a f unction metze (This used to be commit 0bcc8e53d1470ba9dfe93e5d6925b8f4c20c7c66) --- source4/pidl/lib/Parse/Pidl/CUtil.pm | 15 +--- source4/pidl/lib/Parse/Pidl/NDR.pm | 37 +++------ source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 96 ++++++++++-------------- 3 files changed, 51 insertions(+), 97 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/CUtil.pm b/source4/pidl/lib/Parse/Pidl/CUtil.pm index 9deb6ee177..bd7b16812c 100644 --- a/source4/pidl/lib/Parse/Pidl/CUtil.pm +++ b/source4/pidl/lib/Parse/Pidl/CUtil.pm @@ -6,7 +6,7 @@ package Parse::Pidl::CUtil; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(get_pointer_to get_value_of get_array_element); +@EXPORT = qw(get_pointer_to get_value_of); use vars qw($VERSION); $VERSION = '0.01'; @@ -36,17 +36,4 @@ sub get_value_of($) } } -sub get_array_element($$) -{ - my ($var_name, $idx) = @_; - - if ($var_name =~ /^\*.*$/) { - $var_name = "($var_name)"; - } elsif ($var_name =~ /^\&.*$/) { - $var_name = "($var_name)"; - } - - return "$var_name"."[$idx]"; -} - 1; diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 003eaf0ba7..98e8f183a2 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -72,9 +72,9 @@ my $scalar_alignment = { 'ipv4address' => 4 }; -sub GetElementLevelTable($$) +sub GetElementLevelTable($) { - my ($e, $pointer_default) = @_; + my $e = shift; my $order = []; my $is_deferred = 0; @@ -157,45 +157,32 @@ sub GetElementLevelTable($$) # Next, all the pointers foreach my $i (1..$e->{POINTERS}) { + my $pt = pointer_type($e); + my $level = "EMBEDDED"; # Top level "ref" pointers do not have a referrent identifier - $level = "TOP" if ($i == 1 and $e->{PARENT}->{TYPE} eq "FUNCTION"); - - my $pt; - # - # Only the first level gets the pointer type from the - # pointer property, the others get them from - # the pointer_default() interface property - # - # see http://msdn2.microsoft.com/en-us/library/aa378984(VS.85).aspx - # (Here they talk about the rightmost pointer, but testing shows - # they mean the leftmost pointer.) - # - # --metze - # - $pt = pointer_type($e); - if ($i > 1) { - $is_deferred = 1 if ($pt ne "ref" and $e->{PARENT}->{TYPE} eq "FUNCTION"); - $pt = $pointer_default; - } + $level = "TOP" if ( defined($pt) + and $i == 1 + and $e->{PARENT}->{TYPE} eq "FUNCTION"); push (@$order, { TYPE => "POINTER", - POINTER_TYPE => $pt, + # for now, there can only be one pointer type per element + POINTER_TYPE => pointer_type($e), POINTER_INDEX => $pointer_idx, IS_DEFERRED => "$is_deferred", LEVEL => $level }); warning($e, "top-level \[out\] pointer `$e->{NAME}' is not a \[ref\] pointer") - if ($i == 1 and $pt ne "ref" and + if ($i == 1 and pointer_type($e) ne "ref" and $e->{PARENT}->{TYPE} eq "FUNCTION" and not has_property($e, "in")); $pointer_idx++; # everything that follows will be deferred - $is_deferred = 1 if ($level ne "TOP"); + $is_deferred = 1 if ($e->{PARENT}->{TYPE} ne "FUNCTION"); my $array_size = shift @size_is; my $array_length; @@ -404,7 +391,7 @@ sub ParseElement($$) NAME => $e->{NAME}, TYPE => $e->{TYPE}, PROPERTIES => $e->{PROPERTIES}, - LEVELS => GetElementLevelTable($e, $pointer_default), + LEVELS => GetElementLevelTable($e), REPRESENTATION_TYPE => ($e->{PROPERTIES}->{represent_as} or $e->{TYPE}), ALIGN => align_type($e->{TYPE}), ORIGINAL => $e diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 6e6d227681..8326ce5fb6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -14,7 +14,7 @@ require Exporter; use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName typeHasBody); use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid); -use Parse::Pidl::CUtil qw(get_pointer_to get_value_of get_array_element); +use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array); use Parse::Pidl::Samba4 qw(is_intree choose_header); use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv); @@ -42,21 +42,19 @@ sub append_prefix($$) { my ($e, $var_name) = @_; my $pointers = 0; - my $arrays = 0; foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { $pointers++; } elsif ($l->{TYPE} eq "ARRAY") { - $arrays++; if (($pointers == 0) and (not $l->{IS_FIXED}) and (not $l->{IS_INLINE})) { - return get_value_of($var_name); + return get_value_of($var_name); } } elsif ($l->{TYPE} eq "DATA") { if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - return get_value_of($var_name) unless ($pointers or $arrays); + return get_value_of($var_name) unless ($pointers); } } } @@ -584,7 +582,7 @@ sub ParseElementPushLevel my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL}); my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; - $var_name = get_array_element($var_name, $counter); + $var_name = $var_name . "[$counter]"; if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { $self->pidl("for ($counter = 0; $counter < $length; $counter++) {"); @@ -671,48 +669,23 @@ sub ParsePtrPush($$$$) } } -sub need_pointer_to($$$) -{ - my ($e, $l, $scalar_only) = @_; - - my $t; - if (ref($l->{DATA_TYPE})) { - $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; - } else { - $t = $l->{DATA_TYPE}; - } - - if (not Parse::Pidl::Typelist::is_scalar($t)) { - return 1 if $scalar_only; - } - - my $arrays = 0; - - foreach my $tl (@{$e->{LEVELS}}) { - last if $l == $tl; - if ($tl->{TYPE} eq "ARRAY") { - $arrays++; - } - } - - if (Parse::Pidl::Typelist::scalar_is_reference($t)) { - return 1 unless $arrays; - } - - return 0; -} - sub ParseDataPrint($$$$) { my ($self, $e, $l, $var_name) = @_; - if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { - - if (need_pointer_to($e, $l, 1)) { + if (not ref($l->{DATA_TYPE}) or + defined($l->{DATA_TYPE}->{NAME})) { + my $t; + if (ref($l->{DATA_TYPE})) { + $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; + } else { + $t = $l->{DATA_TYPE}; + } + if (not Parse::Pidl::Typelist::is_scalar($t) or + Parse::Pidl::Typelist::scalar_is_reference($t)) { $var_name = get_pointer_to($var_name); } - - $self->pidl(TypeFunctionName("ndr_print", $l->{DATA_TYPE})."(ndr, \"$e->{NAME}\", $var_name);"); + $self->pidl("ndr_print_$t(ndr, \"$e->{NAME}\", $var_name);"); } else { $self->ParseTypePrint($l->{DATA_TYPE}, $var_name); } @@ -779,7 +752,7 @@ sub ParseElementPrint($$$$) $self->pidl("if (idx_$l->{LEVEL_INDEX}) {"); $self->indent; - $var_name = get_array_element($var_name, $counter); + $var_name = $var_name . "[$counter]"; } } elsif ($l->{TYPE} eq "DATA") { $self->ParseDataPrint($e, $l, $var_name); @@ -842,11 +815,12 @@ sub ParseDataPull($$$$$$$) { my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_; - if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { + if (not ref($l->{DATA_TYPE}) or + defined($l->{DATA_TYPE}->{NAME})) { my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - if (need_pointer_to($e, $l, 0)) { + if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); } @@ -871,15 +845,21 @@ sub ParseDataPush($$$$$$$) my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_; if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { - - my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - + my $t; + if (ref($l->{DATA_TYPE}) eq "HASH") { + $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; + } else { + $t = $l->{DATA_TYPE}; + } + # strings are passed by value rather than reference - if (need_pointer_to($e, $l, 1)) { + if (not Parse::Pidl::Typelist::is_scalar($t) or + Parse::Pidl::Typelist::scalar_is_reference($t)) { $var_name = get_pointer_to($var_name); } - $self->pidl("NDR_CHECK(".TypeFunctionName("ndr_push", $l->{DATA_TYPE})."($ndr, $ndr_flags, $var_name));"); + my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); + $self->pidl("NDR_CHECK(ndr_push_$t($ndr, $ndr_flags, $var_name));"); } else { $self->ParseTypePush($l->{DATA_TYPE}, $var_name, $primitives, $deferred); } @@ -929,7 +909,7 @@ sub ParseMemCtxPullFlags($$$$) ($nl->{DATA_TYPE} eq "string")); if ($next_is_array or $next_is_string) { return undef; - } elsif ($l->{LEVEL} eq "TOP") { + } else { $mem_flags = "LIBNDR_FLAG_REF_ALLOC"; } } @@ -1048,7 +1028,7 @@ sub ParseElementPullLevel my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; my $array_name = $var_name; - $var_name = get_array_element($var_name, $counter); + $var_name = $var_name . "[$counter]"; $self->ParseMemCtxPullStart($e, $l, $array_name); @@ -1129,7 +1109,10 @@ sub ParsePtrPull($$$$$) my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); - if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP") { + if ($l->{POINTER_TYPE} eq "ref") { + if ($l->{LEVEL} eq "EMBEDDED") { + $self->pidl("NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"); + } if (!$next_is_array and !$next_is_string) { $self->pidl("if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"); @@ -1138,19 +1121,16 @@ sub ParsePtrPull($$$$$) } return; - } elsif ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "EMBEDDED") { - $self->pidl("NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"); } elsif (($l->{POINTER_TYPE} eq "unique") or ($l->{POINTER_TYPE} eq "relative") or ($l->{POINTER_TYPE} eq "full")) { $self->pidl("NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));"); + $self->pidl("if (_ptr_$e->{NAME}) {"); + $self->indent; } else { die("Unhandled pointer type $l->{POINTER_TYPE}"); } - $self->pidl("if (_ptr_$e->{NAME}) {"); - $self->indent; - # Don't do this for arrays, they're allocated at the actual level # of the array unless ($next_is_array or $next_is_string) { -- cgit From 9475a76afc41675a9c6a9b42d618a49821a8a5b4 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 09:49:54 +0100 Subject: pidl/Samba4::NDR::Parser: move logic for extra get_pointer_of() into a function metze (This used to be commit 26d7f5bf96cd7e950ceb532402afd6b8a58871ea) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 59 ++++++++++++++---------- 1 file changed, 34 insertions(+), 25 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 8326ce5fb6..81e8a21625 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -669,23 +669,39 @@ sub ParsePtrPush($$$$) } } +sub need_pointer_to($$$) +{ + my ($e, $l, $scalar_only) = @_; + + my $t; + if (ref($l->{DATA_TYPE})) { + $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; + } else { + $t = $l->{DATA_TYPE}; + } + + if (not Parse::Pidl::Typelist::is_scalar($t)) { + return 1 if $scalar_only; + } + + if (Parse::Pidl::Typelist::scalar_is_reference($t)) { + return 1; + } + + return 0; +} + sub ParseDataPrint($$$$) { my ($self, $e, $l, $var_name) = @_; - if (not ref($l->{DATA_TYPE}) or - defined($l->{DATA_TYPE}->{NAME})) { - my $t; - if (ref($l->{DATA_TYPE})) { - $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; - } else { - $t = $l->{DATA_TYPE}; - } - if (not Parse::Pidl::Typelist::is_scalar($t) or - Parse::Pidl::Typelist::scalar_is_reference($t)) { + if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { + + if (need_pointer_to($e, $l, 1)) { $var_name = get_pointer_to($var_name); } - $self->pidl("ndr_print_$t(ndr, \"$e->{NAME}\", $var_name);"); + + $self->pidl(TypeFunctionName("ndr_print", $l->{DATA_TYPE})."(ndr, \"$e->{NAME}\", $var_name);"); } else { $self->ParseTypePrint($l->{DATA_TYPE}, $var_name); } @@ -815,12 +831,11 @@ sub ParseDataPull($$$$$$$) { my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_; - if (not ref($l->{DATA_TYPE}) or - defined($l->{DATA_TYPE}->{NAME})) { + if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { + if (need_pointer_to($e, $l, 0)) { $var_name = get_pointer_to($var_name); } @@ -845,21 +860,15 @@ sub ParseDataPush($$$$$$$) my ($self,$e,$l,$ndr,$var_name,$primitives,$deferred) = @_; if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { - my $t; - if (ref($l->{DATA_TYPE}) eq "HASH") { - $t = "$l->{DATA_TYPE}->{TYPE}_$l->{DATA_TYPE}->{NAME}"; - } else { - $t = $l->{DATA_TYPE}; - } - + + my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); + # strings are passed by value rather than reference - if (not Parse::Pidl::Typelist::is_scalar($t) or - Parse::Pidl::Typelist::scalar_is_reference($t)) { + if (need_pointer_to($e, $l, 1)) { $var_name = get_pointer_to($var_name); } - my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred); - $self->pidl("NDR_CHECK(ndr_push_$t($ndr, $ndr_flags, $var_name));"); + $self->pidl("NDR_CHECK(".TypeFunctionName("ndr_push", $l->{DATA_TYPE})."($ndr, $ndr_flags, $var_name));"); } else { $self->ParseTypePush($l->{DATA_TYPE}, $var_name, $primitives, $deferred); } -- cgit From b3d4f22b30b98d16d9a779e26cd9555fe18a67e4 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 09:54:25 +0100 Subject: pidl/Samba4::NDR::Parser: fix $var_name for arrays of scalar reference types uint32 num; nstring strings[num]; this should use 'r->strings' instead of '*r->strings' as the pointer to the array. metze (This used to be commit 7c7acae817cd00ab5c915742338b019af79e9193) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 81e8a21625..281018d4cc 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -42,19 +42,21 @@ sub append_prefix($$) { my ($e, $var_name) = @_; my $pointers = 0; + my $arrays = 0; foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { $pointers++; } elsif ($l->{TYPE} eq "ARRAY") { + $arrays++; if (($pointers == 0) and (not $l->{IS_FIXED}) and (not $l->{IS_INLINE})) { - return get_value_of($var_name); + return get_value_of($var_name); } } elsif ($l->{TYPE} eq "DATA") { if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) { - return get_value_of($var_name) unless ($pointers); + return get_value_of($var_name) unless ($pointers or $arrays); } } } @@ -684,8 +686,17 @@ sub need_pointer_to($$$) return 1 if $scalar_only; } + my $arrays = 0; + + foreach my $tl (@{$e->{LEVELS}}) { + last if $l == $tl; + if ($tl->{TYPE} eq "ARRAY") { + $arrays++; + } + } + if (Parse::Pidl::Typelist::scalar_is_reference($t)) { - return 1; + return 1 unless $arrays; } return 0; -- cgit From c3008e086b1a87c5f4add2a7d1474c2f9a34bfd2 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 31 Jan 2008 14:57:35 +0100 Subject: pidl/Samba4::NDR::Parser: correctly get the name of an array element When we have "*r->out.ous" (char ***ous, a pointer to a pointer to an array of pointers). we need to use "(*r->out.ous)[3]" to access the 3rd element of the array "*r->out.ous[3]" was generated before, but that's the same as "*(r->out.ous[3])" which would mean the array would apply to a different level. This patch prepares support for: [out,ref,size_is(,num)] [string,charset(UTF16)] uint16 ***names; It means a [ref] pointer to a [unique] pointer to an array of [unique] pointers which point to an UTF16 string. metze (This used to be commit ec0ee2aa5f4bef32f09a426d91c28c985f843038) --- source4/pidl/lib/Parse/Pidl/CUtil.pm | 15 ++++++++++++++- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 8 ++++---- 2 files changed, 18 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/CUtil.pm b/source4/pidl/lib/Parse/Pidl/CUtil.pm index bd7b16812c..9deb6ee177 100644 --- a/source4/pidl/lib/Parse/Pidl/CUtil.pm +++ b/source4/pidl/lib/Parse/Pidl/CUtil.pm @@ -6,7 +6,7 @@ package Parse::Pidl::CUtil; require Exporter; @ISA = qw(Exporter); -@EXPORT = qw(get_pointer_to get_value_of); +@EXPORT = qw(get_pointer_to get_value_of get_array_element); use vars qw($VERSION); $VERSION = '0.01'; @@ -36,4 +36,17 @@ sub get_value_of($) } } +sub get_array_element($$) +{ + my ($var_name, $idx) = @_; + + if ($var_name =~ /^\*.*$/) { + $var_name = "($var_name)"; + } elsif ($var_name =~ /^\&.*$/) { + $var_name = "($var_name)"; + } + + return "$var_name"."[$idx]"; +} + 1; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 281018d4cc..81a8bf88cd 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -14,7 +14,7 @@ require Exporter; use strict; use Parse::Pidl::Typelist qw(hasType getType mapTypeName typeHasBody); use Parse::Pidl::Util qw(has_property ParseExpr ParseExprExt print_uuid); -use Parse::Pidl::CUtil qw(get_pointer_to get_value_of); +use Parse::Pidl::CUtil qw(get_pointer_to get_value_of get_array_element); use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array); use Parse::Pidl::Samba4 qw(is_intree choose_header); use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv); @@ -584,7 +584,7 @@ sub ParseElementPushLevel my $length = ParseExpr($l->{LENGTH_IS}, $env, $e->{ORIGINAL}); my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; - $var_name = $var_name . "[$counter]"; + $var_name = get_array_element($var_name, $counter); if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { $self->pidl("for ($counter = 0; $counter < $length; $counter++) {"); @@ -779,7 +779,7 @@ sub ParseElementPrint($$$$) $self->pidl("if (idx_$l->{LEVEL_INDEX}) {"); $self->indent; - $var_name = $var_name . "[$counter]"; + $var_name = get_array_element($var_name, $counter); } } elsif ($l->{TYPE} eq "DATA") { $self->ParseDataPrint($e, $l, $var_name); @@ -1048,7 +1048,7 @@ sub ParseElementPullLevel my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; my $array_name = $var_name; - $var_name = $var_name . "[$counter]"; + $var_name = get_array_element($var_name, $counter); $self->ParseMemCtxPullStart($e, $l, $array_name); -- cgit From 31fac9d66b0cba7a00b0887715cf7b7104108180 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sat, 2 Feb 2008 10:18:33 +0100 Subject: pidl: remove 'pointer_default_top()' support metze (This used to be commit 145d6c8ea0eafc69cdeca45fbf296148b890133d) --- source4/pidl/lib/Parse/Pidl/Compat.pm | 4 ---- source4/pidl/lib/Parse/Pidl/NDR.pm | 9 +-------- 2 files changed, 1 insertion(+), 12 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Compat.pm b/source4/pidl/lib/Parse/Pidl/Compat.pm index 7939bb2df2..7519021144 100644 --- a/source4/pidl/lib/Parse/Pidl/Compat.pm +++ b/source4/pidl/lib/Parse/Pidl/Compat.pm @@ -148,10 +148,6 @@ sub CheckInterface($) { my $if = shift; - if (has_property($if, "pointer_default_top") and - $if->{PROPERTIES}->{pointer_default_top} ne "ref") { - warning($if, "pointer_default_top() is pidl-specific"); - } } sub Check($) diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 98e8f183a2..fb1e65854c 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -581,7 +581,7 @@ sub ParseFunction($$$) my $rettype = undef; my $thisopnum = undef; - CheckPointerTypes($d, $ndr->{PROPERTIES}->{pointer_default_top}); + CheckPointerTypes($d, "ref"); if (not defined($d->{PROPERTIES}{noopnum})) { $thisopnum = ${$opnum}; @@ -661,12 +661,6 @@ sub ParseInterface($) $idl->{PROPERTIES}->{pointer_default} = "unique"; } - if (not has_property($idl, "pointer_default_top")) { - $idl->{PROPERTIES}->{pointer_default_top} = "ref"; - } else { - warning($idl, "pointer_default_top() is a pidl extension and should not be used"); - } - foreach my $d (@{$idl->{DATA}}) { if ($d->{TYPE} eq "FUNCTION") { push (@functions, ParseFunction($idl, $d, \$opnum)); @@ -824,7 +818,6 @@ my %property_list = ( "uuid" => ["INTERFACE"], "endpoint" => ["INTERFACE"], "pointer_default" => ["INTERFACE"], - "pointer_default_top" => ["INTERFACE"], "helper" => ["INTERFACE"], "authservice" => ["INTERFACE"], -- cgit From 1ea5b06307b6057297700ce2b65b2055994869e2 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 10:30:47 +0100 Subject: pidl: get the pointer types correct when an element has multiple pointers Only the first level gets the pointer type from the pointer property, the others get them from the pointer_default() interface property see http://msdn2.microsoft.com/en-us/library/aa378984(VS.85).aspx (Here they talk about the rightmost pointer, but testing shows they mean the leftmost pointer.) metze (This used to be commit aa8518521b2a6a7110c84c4981c53acce7389ee9) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 35 ++++++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index fb1e65854c..1106247355 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -72,9 +72,9 @@ my $scalar_alignment = { 'ipv4address' => 4 }; -sub GetElementLevelTable($) +sub GetElementLevelTable($$) { - my $e = shift; + my ($e, $pointer_default) = @_; my $order = []; my $is_deferred = 0; @@ -157,25 +157,38 @@ sub GetElementLevelTable($) # Next, all the pointers foreach my $i (1..$e->{POINTERS}) { - my $pt = pointer_type($e); - my $level = "EMBEDDED"; # Top level "ref" pointers do not have a referrent identifier - $level = "TOP" if ( defined($pt) - and $i == 1 - and $e->{PARENT}->{TYPE} eq "FUNCTION"); + $level = "TOP" if ($i == 1 and $e->{PARENT}->{TYPE} eq "FUNCTION"); + + my $pt; + # + # Only the first level gets the pointer type from the + # pointer property, the others get them from + # the pointer_default() interface property + # + # see http://msdn2.microsoft.com/en-us/library/aa378984(VS.85).aspx + # (Here they talk about the rightmost pointer, but testing shows + # they mean the leftmost pointer.) + # + # --metze + # + if ($i == 1) { + $pt = pointer_type($e); + } else { + $pt = $pointer_default; + } push (@$order, { TYPE => "POINTER", - # for now, there can only be one pointer type per element - POINTER_TYPE => pointer_type($e), + POINTER_TYPE => $pt, POINTER_INDEX => $pointer_idx, IS_DEFERRED => "$is_deferred", LEVEL => $level }); warning($e, "top-level \[out\] pointer `$e->{NAME}' is not a \[ref\] pointer") - if ($i == 1 and pointer_type($e) ne "ref" and + if ($i == 1 and $pt ne "ref" and $e->{PARENT}->{TYPE} eq "FUNCTION" and not has_property($e, "in")); @@ -391,7 +404,7 @@ sub ParseElement($$) NAME => $e->{NAME}, TYPE => $e->{TYPE}, PROPERTIES => $e->{PROPERTIES}, - LEVELS => GetElementLevelTable($e), + LEVELS => GetElementLevelTable($e, $pointer_default), REPRESENTATION_TYPE => ($e->{PROPERTIES}->{represent_as} or $e->{TYPE}), ALIGN => align_type($e->{TYPE}), ORIGINAL => $e -- cgit From c713b58a00b7cb5ef34b101ba5b74c8d9ec505ba Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 1 Feb 2008 23:09:37 +0100 Subject: pidl/NDR: fix handling of multilevel pointers in function elements The 2nd or higher level of wire pointers needs to be marked as deferred. metze (This used to be commit d7970d70329e0d4f9de30ccfcedd03e583817fa2) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 1106247355..86ed1a8d10 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -173,9 +173,9 @@ sub GetElementLevelTable($$) # # --metze # - if ($i == 1) { - $pt = pointer_type($e); - } else { + $pt = pointer_type($e); + if ($i > 1) { + $is_deferred = 1 if ($pt ne "ref" and $e->{PARENT}->{TYPE} eq "FUNCTION"); $pt = $pointer_default; } @@ -195,7 +195,7 @@ sub GetElementLevelTable($$) $pointer_idx++; # everything that follows will be deferred - $is_deferred = 1 if ($e->{PARENT}->{TYPE} ne "FUNCTION"); + $is_deferred = 1 if ($level ne "TOP"); my $array_size = shift @size_is; my $array_length; -- cgit From e7c178629fcf13fc5e008ebb98ca55583aa65ffe Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 31 Jan 2008 15:04:22 +0100 Subject: pidl/Samba4::NDR::Parser: fix support for embedded "ref" pointers The memory allocation of embedded "ref" pointers needs to be the same as for all other embedded pointers. metze (This used to be commit 6b3817c2250b94307ffcbd9f8eeb9a593eb7a82d) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 81a8bf88cd..6e6d227681 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -929,7 +929,7 @@ sub ParseMemCtxPullFlags($$$$) ($nl->{DATA_TYPE} eq "string")); if ($next_is_array or $next_is_string) { return undef; - } else { + } elsif ($l->{LEVEL} eq "TOP") { $mem_flags = "LIBNDR_FLAG_REF_ALLOC"; } } @@ -1129,10 +1129,7 @@ sub ParsePtrPull($$$$$) my $next_is_string = (($nl->{TYPE} eq "DATA") and ($nl->{DATA_TYPE} eq "string")); - if ($l->{POINTER_TYPE} eq "ref") { - if ($l->{LEVEL} eq "EMBEDDED") { - $self->pidl("NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"); - } + if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP") { if (!$next_is_array and !$next_is_string) { $self->pidl("if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"); @@ -1141,16 +1138,19 @@ sub ParsePtrPull($$$$$) } return; + } elsif ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "EMBEDDED") { + $self->pidl("NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));"); } elsif (($l->{POINTER_TYPE} eq "unique") or ($l->{POINTER_TYPE} eq "relative") or ($l->{POINTER_TYPE} eq "full")) { $self->pidl("NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));"); - $self->pidl("if (_ptr_$e->{NAME}) {"); - $self->indent; } else { die("Unhandled pointer type $l->{POINTER_TYPE}"); } + $self->pidl("if (_ptr_$e->{NAME}) {"); + $self->indent; + # Don't do this for arrays, they're allocated at the actual level # of the array unless ($next_is_array or $next_is_string) { -- cgit From c60d0a10ea9086dc58aa70386860ead0522c1c68 Mon Sep 17 00:00:00 2001 From: Julien Kerihuel Date: Sat, 9 Feb 2008 16:26:16 +0100 Subject: pidl: Allow fixed size arrays inside unions. (This used to be commit c9c115647893478e21134f8c703e0f52e2478882) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 6e6d227681..60d5bf8781 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1611,7 +1611,7 @@ sub ParseUnionPushPrimitives($$$) if ($el->{CASE} eq "default") { $have_default = 1; } - $self->pidl("$el->{CASE}:"); + $self->pidl("$el->{CASE}: {"); if ($el->{TYPE} ne "EMPTY") { $self->indent; @@ -1625,7 +1625,7 @@ sub ParseUnionPushPrimitives($$$) $self->ParseElementPush($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); $self->deindent; } - $self->pidl("break;"); + $self->pidl("break; }"); $self->pidl(""); } if (! $have_default) { -- cgit From dbba1925d15046dbb837b6e2d48ca38cbd4ed426 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 11 Feb 2008 08:44:56 +0100 Subject: pidl/Samba3::ServerNDR: use talloc_tos() instead of NULL metze (This used to be commit 99d6f49340d6f190ac318af939eeec17c29f1bbd) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index ca9e7d15db..4af9da0f52 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -100,7 +100,7 @@ sub ParseFunction($$) pidl ""; pidl "call = &ndr_table_$if->{NAME}.calls[$op];"; pidl ""; - pidl "r = talloc(NULL, struct $fn->{NAME});"; + pidl "r = talloc(talloc_tos(), struct $fn->{NAME});"; pidl "if (r == NULL) {"; pidl "\treturn false;"; pidl "}"; -- cgit From d4006e799ac1305092c2d292c9237f58938268a2 Mon Sep 17 00:00:00 2001 From: Julien Kerihuel Date: Wed, 13 Feb 2008 02:24:11 +0100 Subject: Support ETT_FIELD keyword. (This used to be commit ec8bd3991f76cf8746cf77c277c3491725711f9d) --- source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm | 19 +++++++++++++++++++ source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm | 4 ++++ 2 files changed, 23 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm index b53c56e741..a240bbf9cd 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm @@ -52,6 +52,10 @@ use old_hf_name. This can be used in conjunction with HF_FIELD in order to make more than one element use the same filter name. +=item I ett + +Register a custom ett field + =item I prefix Remove the specified prefix from all function names (if present). @@ -313,6 +317,20 @@ sub handle_import }; } +sub handle_ett_field +{ + my $pos = shift @_; + my $data = shift @_; + my $ett = shift @_; + + unless(defined($ett)) { + error($pos, "incomplete ETT_FIELD command"); + return; + }; + + push (@{$data->{ett}}, $ett); +} + my %field_handlers = ( TYPE => \&handle_type, NOEMIT => \&handle_noemit, @@ -320,6 +338,7 @@ my %field_handlers = ( PARAM_VALUE => \&handle_param_value, HF_FIELD => \&handle_hf_field, HF_RENAME => \&handle_hf_rename, + ETT_FIELD => \&handle_ett_field, TFS => \&handle_tfs, STRIP_PREFIX => \&handle_strip_prefix, PROTOCOL => \&handle_protocol, diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm index ffe104c941..8846b740ab 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/NDR.pm @@ -940,6 +940,10 @@ sub Parse($$$$$) $self->{res}->{headers} .= "#include \"$h_basename\"\n"; $self->pidl_code(""); + if (defined($self->{conformance}->{ett})) { + register_ett($self,$_) foreach(@{$self->{conformance}->{ett}}) + } + # Wireshark protocol registration foreach (@$ndr) { -- cgit From 4218856ba908e793c7e5e1edb9153c9036c843a4 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 13 Feb 2008 13:04:54 +0100 Subject: pidl: $size can be 'foo / 2' so we need to add '(' and ')' 'foo / 5 * sizeof(bar)' isn't the same as '(foo / 2) * sizeof(bar)'. metze (This used to be commit a496abc4042a98835d485769e0972826da161984) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 60d5bf8781..ef3eb3dbcf 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2149,9 +2149,9 @@ sub ParseFunctionPull($$) $self->pidl("NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"); if (grep(/in/, @{$e->{DIRECTION}})) { - $self->pidl("memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));"); + $self->pidl("memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, ($size) * sizeof(*r->in.$e->{NAME}));"); } else { - $self->pidl("memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));"); + $self->pidl("memset(r->out.$e->{NAME}, 0, ($size) * sizeof(*r->out.$e->{NAME}));"); } } else { $self->pidl("NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});"); -- cgit From c455774d9330fc1903a701a2042e29f68b8227f8 Mon Sep 17 00:00:00 2001 From: Julien Kerihuel Date: Tue, 19 Feb 2008 01:55:01 +0100 Subject: Add INCLUDE command to pidl. (This used to be commit 8a8ed4fae849a2cc565a1ff77b2208a4cd6b1edb) --- .../pidl/lib/Parse/Pidl/Wireshark/Conformance.pm | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm index a240bbf9cd..43604cb51a 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm @@ -74,6 +74,10 @@ Change description for the specified header field. `field' is the hf name of the Code to insert when generating the specified dissector. @HF@ and @PARAM@ will be substituted. +=item I filename + +Include conformance data from the specified filename in the dissector. + =item I hf_name "true string" "false string" Override the text shown when a bitmap boolean value is enabled or disabled. @@ -331,6 +335,20 @@ sub handle_ett_field push (@{$data->{ett}}, $ett); } +sub handle_include +{ + my $pos = shift @_; + my $data = shift @_; + my $fn = shift @_; + + unless(defined($fn)) { + error($pos, "incomplete INCLUDE command"); + return; + }; + + ReadConformance($fn, $data); +} + my %field_handlers = ( TYPE => \&handle_type, NOEMIT => \&handle_noemit, @@ -343,7 +361,8 @@ my %field_handlers = ( STRIP_PREFIX => \&handle_strip_prefix, PROTOCOL => \&handle_protocol, FIELD_DESCRIPTION => \&handle_fielddescription, - IMPORT => \&handle_import + IMPORT => \&handle_import, + INCLUDE => \&handle_include ); sub ReadConformance($$) -- cgit From 35dd0b0f4ad6ab0d9365d2858b60bf82e4877bda Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 19 Feb 2008 02:02:48 +0100 Subject: Add test for INCLUDE command. (This used to be commit d1aa25249d64513f785430cab7437b5c7ca8db27) --- source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm index 43604cb51a..5c37b4a0c4 100644 --- a/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm +++ b/source4/pidl/lib/Parse/Pidl/Wireshark/Conformance.pm @@ -330,7 +330,7 @@ sub handle_ett_field unless(defined($ett)) { error($pos, "incomplete ETT_FIELD command"); return; - }; + } push (@{$data->{ett}}, $ett); } @@ -344,7 +344,7 @@ sub handle_include unless(defined($fn)) { error($pos, "incomplete INCLUDE command"); return; - }; + } ReadConformance($fn, $data); } -- cgit From bd95d6d5dbd27e2b904f7907ef39766159d0afcf Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Sat, 23 Feb 2008 10:26:52 +0100 Subject: Respect the return value of asprintf This removes tons of warnings warning: ignoring return value of 'fwrite', declared with attribute warn_unused_result for me. Lots of that kind left though :-) (This used to be commit ba29219ea243cc217ab3522b036a82ff8dfeedc8) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index ef3eb3dbcf..a959dc84f6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -775,8 +775,7 @@ sub ParseElementPrint($$$$) $self->pidl("for ($counter=0;$counter<$length;$counter++) {"); $self->indent; $self->pidl("char *idx_$l->{LEVEL_INDEX}=NULL;"); - $self->pidl("asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);"); - $self->pidl("if (idx_$l->{LEVEL_INDEX}) {"); + $self->pidl("if (asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter) != -1) {"); $self->indent; $var_name = get_array_element($var_name, $counter); -- cgit From bcca7d43c8dc1c96f060a3daff8f0e43c43129c2 Mon Sep 17 00:00:00 2001 From: Michael Adam Date: Tue, 26 Feb 2008 15:38:45 +0100 Subject: pidl: Remove superfluous semicolon in perl code. Michael (This used to be commit 85f707c6abc48739c0c3b423ac0b196d2b75e40c) --- source4/pidl/lib/Parse/Pidl/IDL.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/IDL.pm b/source4/pidl/lib/Parse/Pidl/IDL.pm index aeee69e306..4adb4dcea8 100644 --- a/source4/pidl/lib/Parse/Pidl/IDL.pm +++ b/source4/pidl/lib/Parse/Pidl/IDL.pm @@ -2408,7 +2408,7 @@ sub _Error { error($_[0]->YYData, $_[0]->YYData->{ERRMSG}); delete $_[0]->YYData->{ERRMSG}; return; - }; + } my $last_token = $_[0]->YYData->{LAST_TOKEN}; error($_[0]->YYData, "Syntax error near '$last_token'"); -- cgit From 07251792d4e020217ba23896dc65702853f31939 Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Tue, 25 Mar 2008 17:38:27 +0100 Subject: Add some more header properties as inline comments to the generated samba3 client. Guenther (This used to be commit 8ca4b0b0942564afa70b2e8a6d67d65ea8b75e43) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 34 ++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 86b8951026..7a2575b897 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -44,6 +44,36 @@ sub new($) bless($self, $class); } +sub ElementDirection($) +{ + my ($e) = @_; + + return "[in,out]" if (has_property($e, "in") and has_property($e, "out")); + return "[in]" if (has_property($e, "in")); + return "[out]" if (has_property($e, "out")); + return "[in,out]"; +} + +sub HeaderProperties($$) +{ + my($props,$ignores) = @_; + my $ret = ""; + + foreach my $d (keys %{$props}) { + next if (grep(/^$d$/, @$ignores)); + if($props->{$d} ne "1") { + $ret.= "$d($props->{$d}),"; + } else { + $ret.="$d,"; + } + } + + if ($ret) { + return "[" . substr($ret, 0, -1) . "]"; + } +} + + sub ParseFunction($$$) { my ($self, $if, $fn) = @_; @@ -57,7 +87,9 @@ sub ParseFunction($$$) $fn_args .= "struct rpc_pipe_client *cli,\n" . $pad . "TALLOC_CTX *mem_ctx"; foreach (@{$fn->{ELEMENTS}}) { - $fn_args .= ",\n" . $pad . DeclLong($_); + my $dir = ElementDirection($_); + my $prop = HeaderProperties($_->{PROPERTIES}, ["in", "out"]); + $fn_args .= ",\n" . $pad . DeclLong($_) . " /* $dir $prop */"; } if (defined($fn->{RETURN_TYPE}) && ($fn->{RETURN_TYPE} eq "WERROR")) { -- cgit From f5e6534ee7934c12eb19dca307f1732d73c86ec5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 6 Apr 2008 00:42:27 +0200 Subject: Fix authservice count. (This used to be commit 761536a5e4dd3dbfacf1576d7092827cdeda897b) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index a959dc84f6..9fb5a6a597 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2248,7 +2248,7 @@ sub FunctionTable($$) $self->pidl(""); $self->pidl("static const struct ndr_interface_string_array $interface->{NAME}\_authservices = {"); - $self->pidl("\t.count\t= $endpoint_count,"); + $self->pidl("\t.count\t= $authservice_count,"); $self->pidl("\t.names\t= $interface->{NAME}\_authservice_strings"); $self->pidl("};"); $self->pidl(""); -- cgit From c30f9add8cc5b060b73381f53671ecd01c31cdd8 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 6 Apr 2008 00:57:14 +0200 Subject: Add test for authservice struct. (This used to be commit da8b8364b06a79a10d4ebdc0e451463b3105730e) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 37 ++++++++++++++---------- 1 file changed, 22 insertions(+), 15 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 9fb5a6a597..0d1806a0fa 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -2190,6 +2190,26 @@ sub ParseFunctionPull($$) $self->pidl(""); } +sub AuthServiceStruct($$$) +{ + my ($self, $ifacename, $authservice) = @_; + my @a = split /,/, $authservice; + my $authservice_count = $#a + 1; + + $self->pidl("static const char * const $ifacename\_authservice_strings[] = {"); + foreach my $ap (@a) { + $self->pidl("\t$ap, "); + } + $self->pidl("};"); + $self->pidl(""); + + $self->pidl("static const struct ndr_interface_string_array $ifacename\_authservices = {"); + $self->pidl("\t.count\t= $authservice_count,"); + $self->pidl("\t.names\t= $ifacename\_authservice_strings"); + $self->pidl("};"); + $self->pidl(""); +} + ##################################################################### # produce a function call table sub FunctionTable($$) @@ -2237,21 +2257,8 @@ sub FunctionTable($$) $interface->{PROPERTIES}->{authservice} = "\"host\""; } - my @a = split /,/, $interface->{PROPERTIES}->{authservice}; - my $authservice_count = $#a + 1; - - $self->pidl("static const char * const $interface->{NAME}\_authservice_strings[] = {"); - foreach my $ap (@a) { - $self->pidl("\t$ap, "); - } - $self->pidl("};"); - $self->pidl(""); - - $self->pidl("static const struct ndr_interface_string_array $interface->{NAME}\_authservices = {"); - $self->pidl("\t.count\t= $authservice_count,"); - $self->pidl("\t.names\t= $interface->{NAME}\_authservice_strings"); - $self->pidl("};"); - $self->pidl(""); + $self->AuthServiceStruct($interface->{NAME}, + $interface->{PROPERTIES}->{authservice}); $self->pidl("\nconst struct ndr_interface_table ndr_table_$interface->{NAME} = {"); $self->pidl("\t.name\t\t= \"$interface->{NAME}\","); -- cgit From f07ded6d8921a4a2572d07af2b10aede0b4ce0cb Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 7 Apr 2008 23:21:38 +0200 Subject: Add simple docstring for Python modules. (This used to be commit 57c7b4e896116f06b39e0040ad386c561d76bd3d) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 2475925377..6d51d8ec56 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -929,7 +929,7 @@ sub Parse($$$$$) $self->pidl("{"); $self->indent; $self->pidl("PyObject *m;"); - $self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);"); + $self->pidl("m = Py_InitModule3(\"$basename\", $basename\_methods, \"$basename DCE/RPC interface\");"); foreach my $name (keys %{$self->{constants}}) { my $py_obj; my ($ctype, $cvar) = @{$self->{constants}->{$name}}; -- cgit From a057c7369ae756f67aed107613dec69008c0e78f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 00:10:24 +0200 Subject: Set docstrings from helpstring attribute where possible. (This used to be commit 07f52ca51c008a6b80fed5b03935e1c3241d08d5) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 52 ++++++++++++++++++++-------- 1 file changed, 38 insertions(+), 14 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 6d51d8ec56..26ef6ae0c9 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -226,6 +226,7 @@ sub PythonStruct($$$$) $self->pidl_hdr("#define $name\_Check(op) PyObject_TypeCheck(op, &$name\_Type)\n"); $self->pidl_hdr("#define $name\_CheckExact(op) ((op)->ob_type == &$name\_Type)\n"); $self->pidl_hdr("\n"); + my $docstring = $self->DocString($d, $name); $self->pidl("PyTypeObject $name\_Type = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); @@ -235,6 +236,7 @@ sub PythonStruct($$$$) $self->pidl(".tp_getattr = py_$name\_getattr,"); $self->pidl(".tp_setattr = py_$name\_setattr,"); $self->pidl(".tp_repr = py_talloc_default_repr,"); + $self->pidl(".tp_doc = $docstring,"); $self->deindent; $self->pidl("};"); @@ -250,14 +252,18 @@ sub PythonStruct($$$$) $self->pidl("}"); $self->pidl(""); - return $py_fnname; + return ($py_fnname, "NULL"); } sub PythonFunction($$$) { my ($self, $fn, $iface) = @_; - $self->pidl("static PyObject *py_$fn->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)"); + my $docstring = $self->DocString($fn, $fn->{NAME}); + + my $fnname = "py_$fn->{NAME}"; + + $self->pidl("static PyObject *$fnname(PyObject *self, PyObject *args, PyObject *kwargs)"); $self->pidl("{"); $self->indent; $self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;"); @@ -347,6 +353,8 @@ sub PythonFunction($$$) $self->deindent; $self->pidl("}"); $self->pidl(""); + + return ($fnname, $docstring); } sub handle_werror($$$$) @@ -387,11 +395,11 @@ sub PythonType($$$) } if ($actual_ctype->{TYPE} eq "STRUCT") { - my $py_fnname; + my ($py_fnname, $py_fndocstring); if ($d->{TYPE} eq "STRUCT") { - $py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d); + ($py_fnname, $py_fndocstring) = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d); } else { - $py_fnname = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d->{DATA}); + ($py_fnname, $py_fndocstring) = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d->{DATA}); } my $fn_name = $d->{NAME}; @@ -399,7 +407,7 @@ sub PythonType($$$) $fn_name =~ s/^$interface->{NAME}_//; $fn_name =~ s/^$basename\_//; - $self->register_module_method($fn_name, $py_fnname, "METH_NOARGS", "NULL"); + $self->register_module_method($fn_name, $py_fnname, "METH_NOARGS", $py_fndocstring); } if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") { @@ -429,6 +437,18 @@ sub PythonType($$$) } } +sub DocString($$$) +{ + my ($self, $d, $name) = @_; + if (has_property($d, "helpstring")) { + my $docstring = "py_doc_$name"; + $self->pidl("static const char ".$docstring."[] = ".has_property($d, "helpstring").";"); + return $docstring; + } + + return "NULL"; +} + sub Interface($$$) { my($self,$interface,$basename) = @_; @@ -457,25 +477,27 @@ sub Interface($$$) $self->pidl(""); + my @fns = (); + foreach my $d (@{$interface->{FUNCTIONS}}) { next if not defined($d->{OPNUM}); next if has_property($d, "nopython"); - $self->PythonFunction($d, $interface->{NAME}); + my ($fnname, $fndocstring) = $self->PythonFunction($d, $interface->{NAME}); + + push (@fns, [$fnname, $fndocstring]); } $self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {"); $self->indent; - foreach my $d (@{$interface->{FUNCTIONS}}) { - next if not defined($d->{OPNUM}); - next if has_property($d, "nopython"); - - my $fn_name = $d->{NAME}; + foreach my $d (@fns) { + my ($c_fn, $docstring) = @$d; + my $fn_name = $c_fn; $fn_name =~ s/^$interface->{NAME}_//; $fn_name =~ s/^$basename\_//; - $self->pidl("{ \"$fn_name\", (PyCFunction)py_$d->{NAME}, METH_VARARGS|METH_KEYWORDS, NULL },"); + $self->pidl("{ \"$fn_name\", (PyCFunction)$c_fn, METH_VARARGS|METH_KEYWORDS, $docstring },"); } $self->pidl("{ NULL, NULL, 0, NULL }"); $self->deindent; @@ -501,6 +523,7 @@ sub Interface($$$) $self->pidl(""); + my $docstring = $self->DocString($interface, $interface->{NAME}); $self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); @@ -508,12 +531,13 @@ sub Interface($$$) $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); + $self->pidl(".tp_doc = $docstring,"); $self->deindent; $self->pidl("};"); $self->pidl(""); - $self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "NULL"); + $self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "\"$interface->{NAME}(binding, lp_ctx, credentials)\\nConnect to the $interface->{NAME} interface\""); $self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)"); $self->pidl("{"); $self->indent; -- cgit From a3bfabefd71c88a651ae153ce6482313d7f9e405 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 00:13:09 +0200 Subject: Set tp_flags for Python types. (This used to be commit f214206a36d8822e485f6f076c9f3f0bfc1e1df4) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 26ef6ae0c9..2191bc0fbb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -237,6 +237,7 @@ sub PythonStruct($$$$) $self->pidl(".tp_setattr = py_$name\_setattr,"); $self->pidl(".tp_repr = py_talloc_default_repr,"); $self->pidl(".tp_doc = $docstring,"); + $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT,"); $self->deindent; $self->pidl("};"); @@ -532,6 +533,7 @@ sub Interface($$$) $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); $self->pidl(".tp_doc = $docstring,"); + $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT,"); $self->deindent; $self->pidl("};"); -- cgit From 6f02fdea23b97204db3f1ac7a266cbde657371ff Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 00:59:27 +0200 Subject: Register types rather than constructors, display structs as classes. (This used to be commit aad07f482544107dbeb4c3c468ce7dd78c151849) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 159 ++++++++++++++++----------- 1 file changed, 96 insertions(+), 63 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 2191bc0fbb..efec2cae1f 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -21,7 +21,7 @@ $VERSION = '0.01'; sub new($) { my ($class) = @_; my $self = { res => "", res_hdr => "", tabs => "", constants => {}, - module_methods => []}; + module_methods => [], module_objects => [], module_types => []}; bless($self, $class); } @@ -163,9 +163,9 @@ sub FromPythonToUnionFunction($$$$$) $self->pidl("return ret;"); } -sub PythonStruct($$$$) +sub PythonStruct($$$$$$) { - my ($self, $name, $cname, $d) = @_; + my ($self, $modulename, $prettyname, $name, $cname, $d) = @_; my $env = GenerateStructEnv($d, "object"); @@ -222,38 +222,40 @@ sub PythonStruct($$$$) $self->pidl("}"); $self->pidl(""); + $self->pidl("static PyObject *py_$name\_new(PyTypeObject *self, PyObject *args, PyObject *kwargs)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$cname *ret = talloc_zero(NULL, $cname);"); + $self->pidl("return py_talloc_import(&$name\_Type, ret);"); + $self->deindent; + $self->pidl("}"); + + $self->pidl(""); + $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $name\_Type;\n"); $self->pidl_hdr("#define $name\_Check(op) PyObject_TypeCheck(op, &$name\_Type)\n"); $self->pidl_hdr("#define $name\_CheckExact(op) ((op)->ob_type == &$name\_Type)\n"); $self->pidl_hdr("\n"); my $docstring = $self->DocString($d, $name); - $self->pidl("PyTypeObject $name\_Type = {"); + my $typeobject = "$name\_Type"; + $self->pidl("PyTypeObject $typeobject = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); - $self->pidl(".tp_name = \"$name\","); + $self->pidl(".tp_name = \"$modulename.$prettyname\","); $self->pidl(".tp_basicsize = sizeof(py_talloc_Object),"); $self->pidl(".tp_dealloc = py_talloc_dealloc,"); $self->pidl(".tp_getattr = py_$name\_getattr,"); $self->pidl(".tp_setattr = py_$name\_setattr,"); $self->pidl(".tp_repr = py_talloc_default_repr,"); $self->pidl(".tp_doc = $docstring,"); - $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT,"); + $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,"); + $self->pidl(".tp_new = py_$name\_new,"); $self->deindent; $self->pidl("};"); $self->pidl(""); - my $py_fnname = "py_$name"; - $self->pidl("static PyObject *$py_fnname(PyObject *self, PyObject *args)"); - $self->pidl("{"); - $self->indent; - $self->pidl("$cname *ret = talloc_zero(NULL, $cname);"); - $self->pidl("return py_talloc_import(&$name\_Type, ret);"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - - return ($py_fnname, "NULL"); + return "&$typeobject"; } sub PythonFunction($$$) @@ -386,9 +388,9 @@ sub handle_ntstatus($$$$) $self->pidl(""); } -sub PythonType($$$) +sub PythonType($$$$) { - my ($self, $d, $interface, $basename) = @_; + my ($self, $modulename, $d, $interface, $basename) = @_; my $actual_ctype = $d; if ($actual_ctype->{TYPE} eq "TYPEDEF") { @@ -396,19 +398,20 @@ sub PythonType($$$) } if ($actual_ctype->{TYPE} eq "STRUCT") { - my ($py_fnname, $py_fndocstring); - if ($d->{TYPE} eq "STRUCT") { - ($py_fnname, $py_fndocstring) = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d); - } else { - ($py_fnname, $py_fndocstring) = $self->PythonStruct($d->{NAME}, mapTypeName($d), $d->{DATA}); - } - + my $typeobject; my $fn_name = $d->{NAME}; $fn_name =~ s/^$interface->{NAME}_//; $fn_name =~ s/^$basename\_//; - $self->register_module_method($fn_name, $py_fnname, "METH_NOARGS", $py_fndocstring); + + if ($d->{TYPE} eq "STRUCT") { + $typeobject = $self->PythonStruct($modulename, $fn_name, $d->{NAME}, mapTypeName($d), $d); + } else { + $typeobject = $self->PythonStruct($modulename, $fn_name, $d->{NAME}, mapTypeName($d), $d->{DATA}); + } + + $self->register_module_typeobject($fn_name, $typeobject); } if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") { @@ -464,7 +467,7 @@ sub Interface($$$) foreach my $d (@{$interface->{TYPES}}) { next if has_property($d, "nopython"); - $self->PythonType($d, $interface, $basename); + $self->PythonType($basename, $d, $interface, $basename); } if (defined $interface->{PROPERTIES}->{uuid}) { @@ -486,19 +489,19 @@ sub Interface($$$) my ($fnname, $fndocstring) = $self->PythonFunction($d, $interface->{NAME}); - push (@fns, [$fnname, $fndocstring]); + my $prettyname = $d->{NAME}; + + $prettyname =~ s/^$interface->{NAME}_//; + $prettyname =~ s/^$basename\_//; + + push (@fns, [$fnname, $prettyname, $fndocstring]); } $self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {"); $self->indent; foreach my $d (@fns) { - my ($c_fn, $docstring) = @$d; - my $fn_name = $c_fn; - - $fn_name =~ s/^$interface->{NAME}_//; - $fn_name =~ s/^$basename\_//; - - $self->pidl("{ \"$fn_name\", (PyCFunction)$c_fn, METH_VARARGS|METH_KEYWORDS, $docstring },"); + my ($c_fn, $prettyname, $docstring) = @$d; + $self->pidl("{ \"$prettyname\", (PyCFunction)$c_fn, METH_VARARGS|METH_KEYWORDS, $docstring },"); } $self->pidl("{ NULL, NULL, 0, NULL }"); $self->deindent; @@ -515,32 +518,7 @@ sub Interface($$$) $self->pidl("}"); $self->pidl(""); - $self->pidl("static PyObject *interface_$interface->{NAME}_getattr(PyObject *obj, char *name)"); - $self->pidl("{"); - $self->indent; - $self->pidl("return Py_FindMethod(interface_$interface->{NAME}\_methods, obj, name);"); - $self->deindent; - $self->pidl("}"); - - $self->pidl(""); - - my $docstring = $self->DocString($interface, $interface->{NAME}); - $self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {"); - $self->indent; - $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); - $self->pidl(".tp_name = \"$interface->{NAME}\","); - $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); - $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); - $self->pidl(".tp_getattr = interface_$interface->{NAME}_getattr,"); - $self->pidl(".tp_doc = $docstring,"); - $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT,"); - $self->deindent; - $self->pidl("};"); - - $self->pidl(""); - - $self->register_module_method($interface->{NAME}, "interface_$interface->{NAME}", "METH_VARARGS|METH_KEYWORDS", "\"$interface->{NAME}(binding, lp_ctx, credentials)\\nConnect to the $interface->{NAME} interface\""); - $self->pidl("static PyObject *interface_$interface->{NAME}(PyObject *self, PyObject *args, PyObject *kwargs)"); + $self->pidl("static PyObject *interface_$interface->{NAME}_new(PyTypeObject *self, PyObject *args, PyObject *kwargs)"); $self->pidl("{"); $self->indent; $self->pidl("$interface->{NAME}_InterfaceObject *ret;"); @@ -600,6 +578,25 @@ sub Interface($$$) $self->pidl("}"); $self->pidl(""); + + + my $docstring = $self->DocString($interface, $interface->{NAME}); + $self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {"); + $self->indent; + $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); + $self->pidl(".tp_name = \"$basename.$interface->{NAME}\","); + $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); + $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); + $self->pidl(".tp_methods = interface_$interface->{NAME}_methods,"); + $self->pidl(".tp_doc = $docstring,"); + $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,"); + $self->pidl(".tp_new = interface_$interface->{NAME}_new,"); + $self->deindent; + $self->pidl("};"); + + $self->pidl(""); + + $self->register_module_typeobject($interface->{NAME}, "&$interface->{NAME}_InterfaceType"); } $self->pidl_hdr("\n"); @@ -613,6 +610,22 @@ sub register_module_method($$$$$) push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc]) } +sub register_module_typeobject($$$) +{ + my ($self, $name, $py_name) = @_; + + $self->register_module_object($name, "(PyObject *)$py_name"); + + push (@{$self->{module_types}}, [$name, $py_name]) +} + +sub register_module_object($$$) +{ + my ($self, $name, $py_name) = @_; + + push (@{$self->{module_objects}}, [$name, $py_name]) +} + sub assign($$$) { my ($self, $dest, $src) = @_; @@ -955,7 +968,20 @@ sub Parse($$$$$) $self->pidl("{"); $self->indent; $self->pidl("PyObject *m;"); - $self->pidl("m = Py_InitModule3(\"$basename\", $basename\_methods, \"$basename DCE/RPC interface\");"); + $self->pidl(""); + + foreach (@{$self->{module_types}}) { + my ($object_name, $c_name) = @$_; + $self->pidl("if (PyType_Ready($c_name) < 0)"); + $self->pidl("\treturn;"); + } + + $self->pidl(""); + + $self->pidl("m = Py_InitModule3(\"$basename\", $basename\_methods, \"$basename DCE/RPC\");"); + $self->pidl("if (m == NULL)"); + $self->pidl("\treturn;"); + $self->pidl(""); foreach my $name (keys %{$self->{constants}}) { my $py_obj; my ($ctype, $cvar) = @{$self->{constants}->{$name}}; @@ -969,6 +995,13 @@ sub Parse($$$$$) $self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);"); } + + foreach (@{$self->{module_objects}}) { + my ($object_name, $c_name) = @$_; + $self->pidl("Py_INCREF($c_name);"); + $self->pidl("PyModule_AddObject(m, \"$object_name\", $c_name);"); + } + $self->deindent; $self->pidl("}"); return ($self->{res_hdr}, $self->{res}); -- cgit From a5d51180baf302ff109b9985b74d7a60b21ee73c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 01:23:19 +0200 Subject: Add function signature to docstrings in python. (This used to be commit 61f331e9748bf5b3a1120ef19f93790facf9f64c) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 34 +++++++++++++++++++++++++--- 1 file changed, 31 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index efec2cae1f..3043430b68 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -260,7 +260,7 @@ sub PythonStruct($$$$$$) sub PythonFunction($$$) { - my ($self, $fn, $iface) = @_; + my ($self, $fn, $iface, $prettyname) = @_; my $docstring = $self->DocString($fn, $fn->{NAME}); @@ -282,6 +282,8 @@ sub PythonFunction($$$) my $args_string = ""; my $args_names = ""; + my $signature = "S.$prettyname("; + foreach my $e (@{$fn->{ELEMENTS}}) { $self->pidl("PyObject *py_$e->{NAME};"); if (grep(/out/,@{$e->{DIRECTION}})) { @@ -291,8 +293,14 @@ sub PythonFunction($$$) $args_format .= "O"; $args_string .= ", &py_$e->{NAME}"; $args_names .= "\"$e->{NAME}\", "; + $signature .= "$e->{NAME}, "; } } + if (substr($signature, -2) eq ", ") { + $signature = substr($signature, 0, -2); + } + $signature.= ") -> "; + $self->pidl("const char *kwnames[] = {"); $self->indent; $self->pidl($args_names . "NULL"); @@ -323,6 +331,9 @@ sub PythonFunction($$$) if ($result_size > 1) { $self->pidl("result = PyTuple_New($result_size);"); + $signature .= "("; + } elsif ($result_size == 0) { + $signature .= "None"; } foreach my $e (@{$fn->{ELEMENTS}}) { @@ -332,8 +343,10 @@ sub PythonFunction($$$) if ($result_size > 1) { $self->pidl("PyTuple_SetItem(result, $i, $py_name);"); $i++; + $signature .= "$e->{NAME}, "; } else { $self->pidl("result = $py_name;"); + $signature .= "result"; } } } @@ -346,17 +359,32 @@ sub PythonFunction($$$) my $conv = $self->ConvertObjectToPythonData("r", $fn->{RETURN_TYPE}, "r->out.result"); if ($result_size > 1) { $self->pidl("PyTuple_SetItem(result, $i, $conv);"); + $signature .= "result"; } else { $self->pidl("result = $conv;"); + $signature .= "result"; } } + if (substr($signature, -2) eq ", ") { + $signature = substr($signature, 0, -2); + } + if ($result_size > 1) { + $signature .= ")"; + } + $self->pidl("talloc_free(mem_ctx);"); $self->pidl("return result;"); $self->deindent; $self->pidl("}"); $self->pidl(""); + if ($docstring eq "NULL") { + $docstring = "\"$signature\""; + } else { + $docstring = "\"$signature\\n\\n\"$docstring"; + } + return ($fnname, $docstring); } @@ -487,13 +515,13 @@ sub Interface($$$) next if not defined($d->{OPNUM}); next if has_property($d, "nopython"); - my ($fnname, $fndocstring) = $self->PythonFunction($d, $interface->{NAME}); - my $prettyname = $d->{NAME}; $prettyname =~ s/^$interface->{NAME}_//; $prettyname =~ s/^$basename\_//; + my ($fnname, $fndocstring) = $self->PythonFunction($d, $interface->{NAME}, $prettyname); + push (@fns, [$fnname, $prettyname, $fndocstring]); } -- cgit From 0bea00f481ffa0fd20457fbe4c448bfac93940b5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 01:42:27 +0200 Subject: use builtin getset stuff rather than custom getattr/setattr implementation. (This used to be commit bb59f3084ff8ff99e5bd72abfaadcbb68110f9fa) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 51 +++++++++++++--------------- 1 file changed, 23 insertions(+), 28 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 3043430b68..bd124e79e5 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -171,38 +171,27 @@ sub PythonStruct($$$$$$) $self->pidl(""); - $self->pidl("static PyObject *py_$name\_getattr(PyObject *obj, char *name)"); - $self->pidl("{"); - $self->indent; + my $getsetters = "NULL"; + if ($#{$d->{ELEMENTS}} > -1) { - $self->pidl("$cname *object = py_talloc_get_ptr(obj);"); foreach my $e (@{$d->{ELEMENTS}}) { - $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); my $varname = "object->$e->{NAME}"; + $self->pidl("static PyObject *py_$name\_get_$e->{NAME}(PyObject *obj, void *closure)"); + $self->pidl("{"); $self->indent; + $self->pidl("$cname *object = py_talloc_get_ptr(obj);"); $self->pidl("PyObject *py_$e->{NAME};"); $self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}"); $self->pidl("return py_$e->{NAME};"); $self->deindent; $self->pidl("}"); - } - } - $self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");"); - $self->pidl("return NULL;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); + $self->pidl(""); - $self->pidl("static int py_$name\_setattr(PyObject *py_obj, char *name, PyObject *value)"); - $self->pidl("{"); - $self->indent; - if ($#{$d->{ELEMENTS}} > -1) { - $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); - my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)"; - foreach my $e (@{$d->{ELEMENTS}}) { - $self->pidl("if (!strcmp(name, \"$e->{NAME}\")) {"); - my $varname = "object->$e->{NAME}"; + $self->pidl("static int py_$name\_set_$e->{NAME}(PyObject *py_obj, PyObject *value, void *closure)"); + $self->pidl("{"); $self->indent; + $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); + my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)"; my $l = $e->{LEVELS}[0]; my $nl = GetNextLevel($e, $l); if ($l->{TYPE} eq "POINTER" and @@ -214,13 +203,20 @@ sub PythonStruct($$$$$$) $self->pidl("return 0;"); $self->deindent; $self->pidl("}"); + $self->pidl(""); + } + + $getsetters = "py_$name\_getsetters"; + $self->pidl("static PyGetSetDef ".$getsetters."[] = {"); + $self->indent; + foreach my $e (@{$d->{ELEMENTS}}) { + $self->pidl("{ discard_const_p(char, \"$e->{NAME}\"), py_$name\_get_$e->{NAME}, py_$name\_set_$e->{NAME} },"); } + $self->pidl("{ NULL }"); + $self->deindent; + $self->pidl("};"); + $self->pidl(""); } - $self->pidl("PyErr_SetString(PyExc_AttributeError, \"no such attribute\");"); - $self->pidl("return -1;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); $self->pidl("static PyObject *py_$name\_new(PyTypeObject *self, PyObject *args, PyObject *kwargs)"); $self->pidl("{"); @@ -244,8 +240,7 @@ sub PythonStruct($$$$$$) $self->pidl(".tp_name = \"$modulename.$prettyname\","); $self->pidl(".tp_basicsize = sizeof(py_talloc_Object),"); $self->pidl(".tp_dealloc = py_talloc_dealloc,"); - $self->pidl(".tp_getattr = py_$name\_getattr,"); - $self->pidl(".tp_setattr = py_$name\_setattr,"); + $self->pidl(".tp_getset = $getsetters,"); $self->pidl(".tp_repr = py_talloc_default_repr,"); $self->pidl(".tp_doc = $docstring,"); $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,"); -- cgit From b99d24419f9934ab5467f11a5f59d34618686c91 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 02:08:31 +0200 Subject: Add signature of connect function to docstrings. (This used to be commit 51441376d37de01f7f4bd795947fc2c46c38e3f1) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index bd124e79e5..40c0cd51cb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -232,7 +232,7 @@ sub PythonStruct($$$$$$) $self->pidl_hdr("#define $name\_Check(op) PyObject_TypeCheck(op, &$name\_Type)\n"); $self->pidl_hdr("#define $name\_CheckExact(op) ((op)->ob_type == &$name\_Type)\n"); $self->pidl_hdr("\n"); - my $docstring = $self->DocString($d, $name); + my $docstring = ($self->DocString($d, $name) or "NULL"); my $typeobject = "$name\_Type"; $self->pidl("PyTypeObject $typeobject = {"); $self->indent; @@ -374,10 +374,10 @@ sub PythonFunction($$$) $self->pidl("}"); $self->pidl(""); - if ($docstring eq "NULL") { - $docstring = "\"$signature\""; - } else { + if ($docstring) { $docstring = "\"$signature\\n\\n\"$docstring"; + } else { + $docstring = "\"$signature\""; } return ($fnname, $docstring); @@ -468,12 +468,12 @@ sub DocString($$$) { my ($self, $d, $name) = @_; if (has_property($d, "helpstring")) { - my $docstring = "py_doc_$name"; - $self->pidl("static const char ".$docstring."[] = ".has_property($d, "helpstring").";"); + my $docstring = uc("py_doc_$name"); + $self->pidl("#define $docstring ".has_property($d, "helpstring")); return $docstring; } - return "NULL"; + return undef; } sub Interface($$$) @@ -602,8 +602,21 @@ sub Interface($$$) $self->pidl(""); + my $signature = +"\"$interface->{NAME}(binding, lp_ctx=None, credentials=None) -> Connection to DCE/RPC interface.\\n\" +\"\\n\" +\"binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\\n\" +\"lp_ctx should be a path to a smb.conf file or a param.LoadParm object\\n\" +\"credentials should be a credentials.Credentials object.\\n\\n\""; my $docstring = $self->DocString($interface, $interface->{NAME}); + + if ($docstring) { + $docstring = "$signature$docstring"; + } else { + $docstring = $signature; + } + $self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {"); $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); -- cgit From ab27e718fd88dde3c8ad716042f5c37a8e4ecab3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 02:57:59 +0200 Subject: Support [todo] attribute on functions. (This used to be commit a3e22bbcea27580c31d44dfaae04c9eef83389d4) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 86ed1a8d10..33e5ad3196 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -866,6 +866,7 @@ my %property_list = ( "nosize" => ["FUNCTION", "TYPEDEF"], "noprint" => ["FUNCTION", "TYPEDEF"], "noejs" => ["FUNCTION", "TYPEDEF"], + "todo" => ["FUNCTION"], # union "switch_is" => ["ELEMENT"], -- cgit From e5aa9f7e8dbb5b66a5ce25f50ed67dfcae7a1809 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 02:58:18 +0200 Subject: Raise NotImplementedError from functions that don't have complete IDL. (This used to be commit 685aab0c99c87386fee64c07d8b68c75652713c6) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 43 +++++++++++++++++++--------- 1 file changed, 29 insertions(+), 14 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 40c0cd51cb..c04324e992 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -253,17 +253,10 @@ sub PythonStruct($$$$$$) return "&$typeobject"; } -sub PythonFunction($$$) +sub PythonFunctionBody($$$) { my ($self, $fn, $iface, $prettyname) = @_; - my $docstring = $self->DocString($fn, $fn->{NAME}); - - my $fnname = "py_$fn->{NAME}"; - - $self->pidl("static PyObject *$fnname(PyObject *self, PyObject *args, PyObject *kwargs)"); - $self->pidl("{"); - $self->indent; $self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;"); $self->pidl("NTSTATUS status;"); $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); @@ -370,16 +363,38 @@ sub PythonFunction($$$) $self->pidl("talloc_free(mem_ctx);"); $self->pidl("return result;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - if ($docstring) { - $docstring = "\"$signature\\n\\n\"$docstring"; + return $signature; +} + +sub PythonFunction($$$) +{ + my ($self, $fn, $iface, $prettyname) = @_; + + my $fnname = "py_$fn->{NAME}"; + my $docstring = $self->DocString($fn, $fn->{NAME}); + + $self->pidl("static PyObject *$fnname(PyObject *self, PyObject *args, PyObject *kwargs)"); + $self->pidl("{"); + $self->indent; + if (has_property($fn, "todo")) { + $self->pidl("PyErr_SetString(PyExc_NotImplementedError, \"No marshalling code available yet for $prettyname\");"); + $self->pidl("return NULL;"); + unless ($docstring) { $docstring = "NULL"; } } else { - $docstring = "\"$signature\""; + my $signature = $self->PythonFunctionBody($fn, $iface, $prettyname); + + if ($docstring) { + $docstring = "\"$signature\\n\\n\"$docstring"; + } else { + $docstring = "\"$signature\""; + } } + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + return ($fnname, $docstring); } -- cgit From 5db62a16ff9b784c11c704b8083da9bf6e736f08 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 14:19:26 +0200 Subject: Array lengths can be obtained from Python objects so remove them from the Python API. (This used to be commit 652810ff46c6db9034e930d0fb018a02ee385f15) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index c04324e992..5d514c5f09 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -272,7 +272,21 @@ sub PythonFunctionBody($$$) my $signature = "S.$prettyname("; + my %metadata_args = (); + + sub get_var($) { my $x = shift; $x =~ s/\*//g; return $x; } + + # Determine arguments that are metadata for other arguments (size_is/length_is) + foreach my $e (@{$fn->{ELEMENTS}}) { + if (has_property($e, "length_is")) { + $metadata_args{get_var($e->{PROPERTIES}->{length_is})} = $e->{NAME}; + } elsif (has_property($e, "size_is")) { + $metadata_args{get_var($e->{PROPERTIES}->{size_is})} = $e->{NAME}; + } + } + foreach my $e (@{$fn->{ELEMENTS}}) { + next if ($metadata_args{$e->{NAME}}); $self->pidl("PyObject *py_$e->{NAME};"); if (grep(/out/,@{$e->{DIRECTION}})) { $result_size++; @@ -307,7 +321,16 @@ sub PythonFunctionBody($$$) } foreach my $e (@{$fn->{ELEMENTS}}) { - if (grep(/in/,@{$e->{DIRECTION}})) { + next unless (grep(/in/,@{$e->{DIRECTION}})); + if ($metadata_args{$e->{NAME}}) { + my $val = "PyList_Size(py_".$metadata_args{$e->{NAME}}.")"; + if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { + $self->pidl("r->in.$e->{NAME} = talloc_ptrtype(mem_ctx, r->in.$e->{NAME});"); + $self->pidl("*r->in.$e->{NAME} = $val;"); + } else { + $self->pidl("r->in.$e->{NAME} = PyList_Size(py_".$metadata_args{$e->{NAME}}.");"); + } + } else { $self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r->in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;"); } } @@ -325,6 +348,7 @@ sub PythonFunctionBody($$$) } foreach my $e (@{$fn->{ELEMENTS}}) { + next if ($metadata_args{$e->{NAME}}); my $py_name = "py_$e->{NAME}"; if (grep(/out/,@{$e->{DIRECTION}})) { $self->ConvertObjectToPython("r", $env, $e, "r->out.$e->{NAME}", $py_name); -- cgit From 90c8841beff1fe8c492670811aacd3b92e296912 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 14:56:09 +0200 Subject: Fix bug handling size arguments in a direction without actual data. (This used to be commit 169d505e9e2285aedc21547e44986b8b841b8e37) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 33 ++++++++++++++++++---------- 1 file changed, 22 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 5d514c5f09..2ab61e3246 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -272,21 +272,28 @@ sub PythonFunctionBody($$$) my $signature = "S.$prettyname("; - my %metadata_args = (); + my $metadata_args = { in => {}, out => {} }; sub get_var($) { my $x = shift; $x =~ s/\*//g; return $x; } # Determine arguments that are metadata for other arguments (size_is/length_is) foreach my $e (@{$fn->{ELEMENTS}}) { - if (has_property($e, "length_is")) { - $metadata_args{get_var($e->{PROPERTIES}->{length_is})} = $e->{NAME}; - } elsif (has_property($e, "size_is")) { - $metadata_args{get_var($e->{PROPERTIES}->{size_is})} = $e->{NAME}; + foreach my $dir (@{$e->{DIRECTION}}) { + my $main = undef; + if (has_property($e, "length_is")) { + $main = get_var($e->{PROPERTIES}->{length_is}); + } elsif (has_property($e, "size_is")) { + $main = get_var($e->{PROPERTIES}->{size_is}); + } + if ($main) { + $metadata_args->{$dir}->{$main} = $e->{NAME}; + } } } foreach my $e (@{$fn->{ELEMENTS}}) { - next if ($metadata_args{$e->{NAME}}); + next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or + ($metadata_args->{out}->{$e->{NAME}}) and grep(/out/, @{$e->{DIRECTION}})); $self->pidl("PyObject *py_$e->{NAME};"); if (grep(/out/,@{$e->{DIRECTION}})) { $result_size++; @@ -315,23 +322,27 @@ sub PythonFunctionBody($$$) $self->pidl("return NULL;"); $self->deindent; $self->pidl("}"); + $self->pidl(""); if ($fn->{RETURN_TYPE}) { $result_size++ unless ($fn->{RETURN_TYPE} eq "WERROR" or $fn->{RETURN_TYPE} eq "NTSTATUS"); } + my $fail = "talloc_free(mem_ctx); return NULL;"; foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/in/,@{$e->{DIRECTION}})); - if ($metadata_args{$e->{NAME}}) { - my $val = "PyList_Size(py_".$metadata_args{$e->{NAME}}.")"; + if ($metadata_args->{in}->{$e->{NAME}}) { + my $py_var = "py_".$metadata_args->{in}->{$e->{NAME}}; + $self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);"); + my $val = "PyList_Size($py_var)"; if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { $self->pidl("r->in.$e->{NAME} = talloc_ptrtype(mem_ctx, r->in.$e->{NAME});"); $self->pidl("*r->in.$e->{NAME} = $val;"); } else { - $self->pidl("r->in.$e->{NAME} = PyList_Size(py_".$metadata_args{$e->{NAME}}.");"); + $self->pidl("r->in.$e->{NAME} = $val;"); } } else { - $self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r->in.$e->{NAME}", "talloc_free(mem_ctx); return NULL;"); + $self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r->in.$e->{NAME}", $fail); } } $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, r);"); @@ -348,7 +359,7 @@ sub PythonFunctionBody($$$) } foreach my $e (@{$fn->{ELEMENTS}}) { - next if ($metadata_args{$e->{NAME}}); + next if ($metadata_args->{out}->{$e->{NAME}}); my $py_name = "py_$e->{NAME}"; if (grep(/out/,@{$e->{DIRECTION}})) { $self->ConvertObjectToPython("r", $env, $e, "r->out.$e->{NAME}", $py_name); -- cgit From 66b529029a6d15d9d2f8cac8f863de618509a95e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 Apr 2008 15:18:24 +0200 Subject: Clearer names for singleton return types. (This used to be commit 19d0560464304f79224a946278105edafb285453) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 2ab61e3246..acaea99f6d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -369,7 +369,7 @@ sub PythonFunctionBody($$$) $signature .= "$e->{NAME}, "; } else { $self->pidl("result = $py_name;"); - $signature .= "result"; + $signature .= $e->{NAME}; } } } @@ -382,11 +382,10 @@ sub PythonFunctionBody($$$) my $conv = $self->ConvertObjectToPythonData("r", $fn->{RETURN_TYPE}, "r->out.result"); if ($result_size > 1) { $self->pidl("PyTuple_SetItem(result, $i, $conv);"); - $signature .= "result"; } else { $self->pidl("result = $conv;"); - $signature .= "result"; } + $signature .= "result"; } if (substr($signature, -2) eq ", ") { -- cgit From fd52fe86169ddc0adda2d1cd97215c58d06f93c4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 15 Apr 2008 14:32:13 +0200 Subject: Fix pointers when pushing strings to python during pidl generation. (This used to be commit ca72187b3e71a037780d42a57e46b60e75f724f6) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index acaea99f6d..2d12da358c 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -952,16 +952,15 @@ sub ConvertObjectToPythonLevel($$$$$) $self->pidl("}"); } } elsif ($l->{TYPE} eq "ARRAY") { - if (is_charset_array($e, $l)) { + my $pl = GetPrevLevel($e, $l); + if ($pl && $pl->{TYPE} eq "POINTER") { $var_name = get_pointer_to($var_name); + } + + if (is_charset_array($e, $l)) { # FIXME: Use Unix charset setting rather than utf-8 $self->pidl("$py_var = PyUnicode_Decode($var_name, strlen($var_name), \"utf-8\", \"ignore\");"); } else { - my $pl = GetPrevLevel($e, $l); - if ($pl && $pl->{TYPE} eq "POINTER") { - $var_name = get_pointer_to($var_name); - } - die("No SIZE_IS for array $var_name") unless (defined($l->{SIZE_IS})); my $length = $l->{SIZE_IS}; if (defined($l->{LENGTH_IS})) { -- cgit From 7bb2ebb884c35676a6cf03efe6ecc15b3e232a43 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 15 Apr 2008 16:00:07 +0200 Subject: Fix size to memcpy call in generated Samba 3 client code. Reported-By: vl (This used to be commit a28807569d0cf32968bacdc0bd88197b19fbae49) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 65 ++++++++++++++----------- 1 file changed, 36 insertions(+), 29 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 7a2575b897..87ed29b54e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -9,7 +9,7 @@ package Parse::Pidl::Samba3::ClientNDR; use Exporter; @ISA = qw(Exporter); -@EXPORT_OK = qw(ParseFunction $res $res_hdr); +@EXPORT_OK = qw(ParseFunction $res $res_hdr ParseOutputArgument); use strict; use Parse::Pidl qw(fatal warning); @@ -73,6 +73,40 @@ sub HeaderProperties($$) } } +sub ParseOutputArgument($$$) +{ + my ($self, $fn, $e) = @_; + my $level = 0; + + fatal($e->{ORIGINAL}, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); + + if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { + $level = 1; + if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") { + $self->pidl("if ($e->{NAME} && r.out.$e->{NAME}) {"); + $self->indent; + } + } + + if ($e->{LEVELS}[$level]->{TYPE} eq "ARRAY") { + # This is a call to GenerateFunctionInEnv intentionally. + # Since the data is being copied into a user-provided data + # structure, the user should be able to know the size beforehand + # to allocate a structure of the right size. + my $env = GenerateFunctionInEnv($fn, "r."); + my $size_is = ParseExpr($e->{LEVELS}[$level]->{SIZE_IS}, $env, $e->{ORIGINAL}); + $self->pidl("memcpy($e->{NAME}, r.out.$e->{NAME}, $size_is * sizeof(*$e->{NAME}));"); + } else { + $self->pidl("*$e->{NAME} = *r.out.$e->{NAME};"); + } + + if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { + if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") { + $self->deindent; + $self->pidl("}"); + } + } +} sub ParseFunction($$$) { @@ -147,36 +181,9 @@ sub ParseFunction($$$) $self->pidl("/* Return variables */"); foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/out/, @{$e->{DIRECTION}})); - my $level = 0; - fatal($e->{ORIGINAL}, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY"); - - if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { - $level = 1; - if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") { - $self->pidl("if ($e->{NAME} && r.out.$e->{NAME}) {"); - $self->indent; - } - } + $self->ParseOutputArgument($fn, $e); - if ($e->{LEVELS}[$level]->{TYPE} eq "ARRAY") { - # This is a call to GenerateFunctionInEnv intentionally. - # Since the data is being copied into a user-provided data - # structure, the user should be able to know the size beforehand - # to allocate a structure of the right size. - my $env = GenerateFunctionInEnv($fn, "r."); - my $size_is = ParseExpr($e->{LEVELS}[$level]->{SIZE_IS}, $env, $e->{ORIGINAL}); - $self->pidl("memcpy($e->{NAME}, r.out.$e->{NAME}, $size_is);"); - } else { - $self->pidl("*$e->{NAME} = *r.out.$e->{NAME};"); - } - - if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { - if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") { - $self->deindent; - $self->pidl("}"); - } - } } $self->pidl(""); -- cgit From d49f94621bd1d18437d5846d61b84054f35d39e4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 16 Apr 2008 17:21:48 +0200 Subject: Provide stubs when the [todo] attribute is set. (This used to be commit 356a5d24747bb5e1ef9774c690a5ec386a4a165e) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm | 54 ++++++++++++++++++------ 1 file changed, 41 insertions(+), 13 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm index e9c158e933..f8209be654 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Client.pm @@ -7,6 +7,7 @@ package Parse::Pidl::Samba4::NDR::Client; use Parse::Pidl::Samba4 qw(choose_header is_intree); +use Parse::Pidl::Util qw(has_property); use vars qw($VERSION); $VERSION = '0.01'; @@ -15,30 +16,45 @@ use strict; my($res,$res_hdr); -##################################################################### -# parse a function -sub ParseFunction($$) +sub ParseFunctionSend($$$) { - my ($interface, $fn) = @_; - my $name = $fn->{NAME}; + my ($interface, $fn, $name) = @_; my $uname = uc $name; - $res_hdr .= "\nstruct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r); -NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r); -"; + my $proto = "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r)"; - $res .= " -struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) -{ + $res_hdr .= "\n$proto;\n"; + + $res .= "$proto\n{\n"; + + if (has_property($fn, "todo")) { + $res .= "\treturn NULL;\n"; + } else { + $res .= " if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) { NDR_PRINT_IN_DEBUG($name, r); } return dcerpc_ndr_request_send(p, NULL, &ndr_table_$interface->{NAME}, NDR_$uname, mem_ctx, r); +"; + } + + $res .= "}\n\n"; } -NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r) +sub ParseFunctionSync($$$) { + my ($interface, $fn, $name) = @_; + + my $proto = "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r)"; + + $res_hdr .= "\n$proto;\n"; + $res .= "$proto\n{\n"; + + if (has_property($fn, "todo")) { + $res .= "\treturn NT_STATUS_NOT_IMPLEMENTED;\n"; + } else { + $res .= " struct rpc_request *req; NTSTATUS status; @@ -58,8 +74,20 @@ NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name * $res .= " return status; -} "; + } + + $res .= "}\n\n"; +} + +##################################################################### +# parse a function +sub ParseFunction($$) +{ + my ($interface, $fn) = @_; + + ParseFunctionSend($interface, $fn, $fn->{NAME}); + ParseFunctionSync($interface, $fn, $fn->{NAME}); } my %done; -- cgit From db30ff4bea11f6612bd68c934ba31387ad99cefc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 21 Apr 2008 17:59:08 +0200 Subject: Load default smb.conf file if none was specified explicitly. (This used to be commit 8fa23fac516dbf4c8245c1d009e81f02a6341775) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 2d12da358c..e344589f8e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -597,7 +597,7 @@ sub Interface($$$) $self->pidl("const char *binding_string;"); $self->pidl("struct cli_credentials *credentials;"); $self->pidl("struct loadparm_context *lp_ctx = NULL;"); - $self->pidl("PyObject *py_lp_ctx = NULL, *py_credentials = Py_None;"); + $self->pidl("PyObject *py_lp_ctx = Py_None, *py_credentials = Py_None;"); $self->pidl("TALLOC_CTX *mem_ctx = NULL;"); $self->pidl("NTSTATUS status;"); $self->pidl(""); @@ -609,14 +609,12 @@ sub Interface($$$) $self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);"); $self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);"); $self->pidl(""); - $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"sO|O:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {"); + $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s|OO:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {"); $self->indent; $self->pidl("return NULL;"); $self->deindent; $self->pidl("}"); $self->pidl(""); - $self->pidl("if (py_lp_ctx != NULL) {"); - $self->indent; $self->pidl("lp_ctx = lp_from_py_object(py_lp_ctx);"); $self->pidl("if (lp_ctx == NULL) {"); $self->indent; @@ -624,8 +622,6 @@ sub Interface($$$) $self->pidl("return NULL;"); $self->deindent; $self->pidl("}"); - $self->deindent; - $self->pidl("}"); $self->pidl(""); $self->pidl("credentials = cli_credentials_from_py_object(py_credentials);"); -- cgit From f1b76952c035ca6341e67d0ef1a14b655c4652a2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 22 Apr 2008 22:33:34 +0200 Subject: Fix event context initialization for Python bindings. (This used to be commit 132efc779ede27898765320a13bdde0b5256102b) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index e344589f8e..884ee1d822 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -599,6 +599,7 @@ sub Interface($$$) $self->pidl("struct loadparm_context *lp_ctx = NULL;"); $self->pidl("PyObject *py_lp_ctx = Py_None, *py_credentials = Py_None;"); $self->pidl("TALLOC_CTX *mem_ctx = NULL;"); + $self->pidl("struct event_context *event_ctx;"); $self->pidl("NTSTATUS status;"); $self->pidl(""); $self->pidl("const char *kwnames[] = {"); @@ -634,9 +635,11 @@ sub Interface($$$) $self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);"); $self->pidl(""); + $self->pidl("event_ctx = event_context_init(mem_ctx);"); + $self->pidl(""); $self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, "); - $self->pidl(" &ndr_table_$interface->{NAME}, credentials, NULL, lp_ctx);"); + $self->pidl(" &ndr_table_$interface->{NAME}, credentials, event_ctx, lp_ctx);"); $self->handle_ntstatus("status", "NULL", "mem_ctx"); $self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;"); @@ -1020,6 +1023,7 @@ sub Parse($$$$$) #include \"librpc/rpc/dcerpc.h\" #include \"scripting/python/pytalloc.h\" #include \"scripting/python/pyrpc.h\" +#include \"lib/events/events.h\" #include \"$hdr\" #include \"$ndr_hdr\" #include \"$py_hdr\" -- cgit From a9c96b2e7b9d7d894b194d520e4925e772ca0247 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 22 May 2008 13:00:04 +0200 Subject: Fix indentation. (This used to be commit 5c3d4fce06ae07663632cc50d9703ddbc728c737) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 884ee1d822..88f2daa3b8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -203,7 +203,7 @@ sub PythonStruct($$$$$$) $self->pidl("return 0;"); $self->deindent; $self->pidl("}"); - $self->pidl(""); + $self->pidl(""); } $getsetters = "py_$name\_getsetters"; @@ -253,6 +253,20 @@ sub PythonStruct($$$$$$) return "&$typeobject"; } +sub get_metadata_var($) +{ + my ($e) = @_; + sub get_var($) { my $x = shift; $x =~ s/\*//g; return $x; } + + if (has_property($e, "length_is")) { + return get_var($e->{PROPERTIES}->{length_is}); + } elsif (has_property($e, "size_is")) { + return get_var($e->{PROPERTIES}->{size_is}); + } + + return undef; +} + sub PythonFunctionBody($$$) { my ($self, $fn, $iface, $prettyname) = @_; @@ -274,17 +288,10 @@ sub PythonFunctionBody($$$) my $metadata_args = { in => {}, out => {} }; - sub get_var($) { my $x = shift; $x =~ s/\*//g; return $x; } - # Determine arguments that are metadata for other arguments (size_is/length_is) foreach my $e (@{$fn->{ELEMENTS}}) { foreach my $dir (@{$e->{DIRECTION}}) { - my $main = undef; - if (has_property($e, "length_is")) { - $main = get_var($e->{PROPERTIES}->{length_is}); - } elsif (has_property($e, "size_is")) { - $main = get_var($e->{PROPERTIES}->{size_is}); - } + my $main = get_metadata_var($e); if ($main) { $metadata_args->{$dir}->{$main} = $e->{NAME}; } -- cgit From 97cac27b334350f4452a7fe60658f533d851bbb9 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 23 May 2008 12:45:05 +0200 Subject: Fix syntax for return type in DCE/RPC interface python bindings. (This used to be commit 40652801fce937b37a43d37db9892821572cd6fd) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 88f2daa3b8..440b1bff97 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -658,7 +658,7 @@ sub Interface($$$) $self->pidl(""); my $signature = -"\"$interface->{NAME}(binding, lp_ctx=None, credentials=None) -> Connection to DCE/RPC interface.\\n\" +"\"$interface->{NAME}(binding, lp_ctx=None, credentials=None) -> connection\\n\" \"\\n\" \"binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\\n\" \"lp_ctx should be a path to a smb.conf file or a param.LoadParm object\\n\" -- cgit From 1cd3a2be3199b7e1a3aa2ef29234255b8c1675ba Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 May 2008 18:46:32 +0200 Subject: Add __ndr_pack__ method to all DCE/RPC structures. (This used to be commit 06d272b42f59d0a785697d207e6d7dbbcf355175) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 440b1bff97..ad3cab6ffb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -225,7 +225,33 @@ sub PythonStruct($$$$$$) $self->pidl("return py_talloc_import(&$name\_Type, ret);"); $self->deindent; $self->pidl("}"); + $self->pidl(""); + + $self->pidl("static PyObject *py_$name\_ndr_pack(PyObject *py_obj)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); + $self->pidl("DATA_BLOB blob;"); + $self->pidl("enum ndr_err_code err;"); + $self->pidl("err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, ndr_push_$name);"); + $self->pidl("if (err != NDR_ERR_SUCCESS) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_RuntimeError, \"Unable to ndr pack\");"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $self->pidl("return PyString_FromStringAndSize((char *)blob.data, blob.length);"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $self->pidl("static PyMethodDef py_$name\_methods[] = {"); + $self->indent; + $self->pidl("{ \"__ndr_pack__\", (PyCFunction)py_$name\_ndr_pack, METH_O|METH_NOARGS, \"NDR pack\" },"); + $self->pidl("{ NULL, NULL, 0, NULL }"); + $self->deindent; + $self->pidl("};"); $self->pidl(""); $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $name\_Type;\n"); @@ -243,6 +269,7 @@ sub PythonStruct($$$$$$) $self->pidl(".tp_getset = $getsetters,"); $self->pidl(".tp_repr = py_talloc_default_repr,"); $self->pidl(".tp_doc = $docstring,"); + $self->pidl(".tp_methods = py_$name\_methods,"); $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,"); $self->pidl(".tp_new = py_$name\_new,"); $self->deindent; -- cgit From 14c4028f261cbbdba03cc8b3f0ec6e32a390c79e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 May 2008 18:55:46 +0200 Subject: Support __ndr_unpack__ on DCE/RPC structures in Python. (This used to be commit 3b2bd4d849946aaff2b0adfbacdc15284670b916) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index ad3cab6ffb..56d54d3d36 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -244,11 +244,33 @@ sub PythonStruct($$$$$$) $self->pidl("return PyString_FromStringAndSize((char *)blob.data, blob.length);"); $self->deindent; $self->pidl("}"); + $self->pidl(""); + $self->pidl("static PyObject *py_$name\_ndr_unpack(PyObject *py_obj, PyObject *args)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); + $self->pidl("DATA_BLOB blob;"); + $self->pidl("enum ndr_err_code err;"); + $self->pidl("if (!PyArg_ParseTuple(args, \"s#\", &blob.data, &blob.length))"); + $self->pidl("\treturn NULL;"); + $self->pidl(""); + $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, ndr_pull_$name);"); + $self->pidl("if (err != NDR_ERR_SUCCESS) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_RuntimeError, \"Unable to ndr unpack\");"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $self->pidl("return Py_None;"); + $self->deindent; + $self->pidl("}"); $self->pidl(""); $self->pidl("static PyMethodDef py_$name\_methods[] = {"); $self->indent; - $self->pidl("{ \"__ndr_pack__\", (PyCFunction)py_$name\_ndr_pack, METH_O|METH_NOARGS, \"NDR pack\" },"); + $self->pidl("{ \"__ndr_pack__\", (PyCFunction)py_$name\_ndr_pack, METH_O|METH_NOARGS, \"S.pack() -> blob\\nNDR pack\" },"); + $self->pidl("{ \"__ndr_unpack__\", (PyCFunction)py_$name\_ndr_pack, METH_O|METH_VARARGS, \"S.unpack(blob) -> None\\nNDR unpack\" },"); $self->pidl("{ NULL, NULL, 0, NULL }"); $self->deindent; $self->pidl("};"); -- cgit From e3bbe61d8162ebb5bf4ef2d3702587b39b0c4284 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 May 2008 19:49:54 +0200 Subject: Only provide __ndr_pack__ / __ndr_unpack__ if the push/pull functions are public. (This used to be commit dd43bdcb880d08013a600f81d40e5280db74c534) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 103 ++++++++++++++------------- 1 file changed, 55 insertions(+), 48 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 56d54d3d36..b83f9a5360 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -227,54 +227,61 @@ sub PythonStruct($$$$$$) $self->pidl("}"); $self->pidl(""); - $self->pidl("static PyObject *py_$name\_ndr_pack(PyObject *py_obj)"); - $self->pidl("{"); - $self->indent; - $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); - $self->pidl("DATA_BLOB blob;"); - $self->pidl("enum ndr_err_code err;"); - $self->pidl("err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, ndr_push_$name);"); - $self->pidl("if (err != NDR_ERR_SUCCESS) {"); - $self->indent; - $self->pidl("PyErr_SetString(PyExc_RuntimeError, \"Unable to ndr pack\");"); - $self->pidl("return NULL;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - $self->pidl("return PyString_FromStringAndSize((char *)blob.data, blob.length);"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); + my $py_methods = "NULL"; - $self->pidl("static PyObject *py_$name\_ndr_unpack(PyObject *py_obj, PyObject *args)"); - $self->pidl("{"); - $self->indent; - $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); - $self->pidl("DATA_BLOB blob;"); - $self->pidl("enum ndr_err_code err;"); - $self->pidl("if (!PyArg_ParseTuple(args, \"s#\", &blob.data, &blob.length))"); - $self->pidl("\treturn NULL;"); - $self->pidl(""); - $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, ndr_pull_$name);"); - $self->pidl("if (err != NDR_ERR_SUCCESS) {"); - $self->indent; - $self->pidl("PyErr_SetString(PyExc_RuntimeError, \"Unable to ndr unpack\");"); - $self->pidl("return NULL;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - $self->pidl("return Py_None;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - $self->pidl("static PyMethodDef py_$name\_methods[] = {"); - $self->indent; - $self->pidl("{ \"__ndr_pack__\", (PyCFunction)py_$name\_ndr_pack, METH_O|METH_NOARGS, \"S.pack() -> blob\\nNDR pack\" },"); - $self->pidl("{ \"__ndr_unpack__\", (PyCFunction)py_$name\_ndr_pack, METH_O|METH_VARARGS, \"S.unpack(blob) -> None\\nNDR unpack\" },"); - $self->pidl("{ NULL, NULL, 0, NULL }"); - $self->deindent; - $self->pidl("};"); - $self->pidl(""); + # If the struct is not public there ndr_pull/ndr_push functions will + # be static so not callable from here + if (has_property($d, "public")) { + $self->pidl("static PyObject *py_$name\_ndr_pack(PyObject *py_obj)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); + $self->pidl("DATA_BLOB blob;"); + $self->pidl("enum ndr_err_code err;"); + $self->pidl("err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_push_flags_fn_t)ndr_push_$name);"); + $self->pidl("if (err != NDR_ERR_SUCCESS) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_RuntimeError, \"Unable to ndr pack\");"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $self->pidl("return PyString_FromStringAndSize((char *)blob.data, blob.length);"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + + $self->pidl("static PyObject *py_$name\_ndr_unpack(PyObject *py_obj, PyObject *args)"); + $self->pidl("{"); + $self->indent; + $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); + $self->pidl("DATA_BLOB blob;"); + $self->pidl("enum ndr_err_code err;"); + $self->pidl("if (!PyArg_ParseTuple(args, \"(s#):__ndr_unpack__\", &blob.data, &blob.length))"); + $self->pidl("\treturn NULL;"); + $self->pidl(""); + $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_pull_flags_fn_t)ndr_pull_$name);"); + $self->pidl("if (err != NDR_ERR_SUCCESS) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_RuntimeError, \"Unable to ndr unpack\");"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $self->pidl("return Py_None;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $py_methods = "py_$name\_methods"; + $self->pidl("static PyMethodDef $py_methods\[] = {"); + $self->indent; + $self->pidl("{ \"__ndr_pack__\", (PyCFunction)py_$name\_ndr_pack, METH_NOARGS, \"S.pack() -> blob\\nNDR pack\" },"); + $self->pidl("{ \"__ndr_unpack__\", (PyCFunction)py_$name\_ndr_unpack, METH_VARARGS, \"S.unpack(blob) -> None\\nNDR unpack\" },"); + $self->pidl("{ NULL, NULL, 0, NULL }"); + $self->deindent; + $self->pidl("};"); + $self->pidl(""); + } $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $name\_Type;\n"); $self->pidl_hdr("#define $name\_Check(op) PyObject_TypeCheck(op, &$name\_Type)\n"); @@ -291,7 +298,7 @@ sub PythonStruct($$$$$$) $self->pidl(".tp_getset = $getsetters,"); $self->pidl(".tp_repr = py_talloc_default_repr,"); $self->pidl(".tp_doc = $docstring,"); - $self->pidl(".tp_methods = py_$name\_methods,"); + $self->pidl(".tp_methods = $py_methods,"); $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,"); $self->pidl(".tp_new = py_$name\_new,"); $self->deindent; -- cgit From 515b6ed5867bba8180bd0eeadbeab1c52bffc0ab Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 May 2008 20:00:37 +0200 Subject: Share struct used for interfaces in Python code. (This used to be commit 8501a3fc31e688dba696667a187821480e8cb714) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index b83f9a5360..dea8f2c648 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -327,7 +327,7 @@ sub PythonFunctionBody($$$) { my ($self, $fn, $iface, $prettyname) = @_; - $self->pidl("$iface\_InterfaceObject *iface = ($iface\_InterfaceObject *)self;"); + $self->pidl("dcerpc_InterfaceObject *iface = (dcerpc_InterfaceObject *)self;"); $self->pidl("NTSTATUS status;"); $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); $self->pidl("struct $fn->{NAME} *r = talloc_zero(mem_ctx, struct $fn->{NAME});"); @@ -607,13 +607,6 @@ sub Interface($$$) if (defined $interface->{PROPERTIES}->{uuid}) { $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n"); - $self->pidl("typedef struct {"); - $self->indent; - $self->pidl("PyObject_HEAD"); - $self->pidl("struct dcerpc_pipe *pipe;"); - $self->deindent; - $self->pidl("} $interface->{NAME}_InterfaceObject;"); - $self->pidl(""); my @fns = (); @@ -646,7 +639,7 @@ sub Interface($$$) $self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)"); $self->pidl("{"); $self->indent; - $self->pidl("$interface->{NAME}_InterfaceObject *interface = ($interface->{NAME}_InterfaceObject *)self;"); + $self->pidl("dcerpc_InterfaceObject *interface = (dcerpc_InterfaceObject *)self;"); $self->pidl("talloc_free(interface->pipe);"); $self->pidl("PyObject_Del(self);"); $self->deindent; @@ -656,7 +649,7 @@ sub Interface($$$) $self->pidl("static PyObject *interface_$interface->{NAME}_new(PyTypeObject *self, PyObject *args, PyObject *kwargs)"); $self->pidl("{"); $self->indent; - $self->pidl("$interface->{NAME}_InterfaceObject *ret;"); + $self->pidl("dcerpc_InterfaceObject *ret;"); $self->pidl("const char *binding_string;"); $self->pidl("struct cli_credentials *credentials;"); $self->pidl("struct loadparm_context *lp_ctx = NULL;"); @@ -696,7 +689,7 @@ sub Interface($$$) $self->deindent; $self->pidl("}"); - $self->pidl("ret = PyObject_New($interface->{NAME}_InterfaceObject, &$interface->{NAME}_InterfaceType);"); + $self->pidl("ret = PyObject_New(dcerpc_InterfaceObject, &$interface->{NAME}_InterfaceType);"); $self->pidl(""); $self->pidl("event_ctx = event_context_init(mem_ctx);"); $self->pidl(""); @@ -732,7 +725,7 @@ sub Interface($$$) $self->indent; $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); $self->pidl(".tp_name = \"$basename.$interface->{NAME}\","); - $self->pidl(".tp_basicsize = sizeof($interface->{NAME}_InterfaceObject),"); + $self->pidl(".tp_basicsize = sizeof(dcerpc_InterfaceObject),"); $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); $self->pidl(".tp_methods = interface_$interface->{NAME}_methods,"); $self->pidl(".tp_doc = $docstring,"); @@ -1085,7 +1078,7 @@ sub Parse($$$$$) #include #include \"librpc/rpc/dcerpc.h\" #include \"scripting/python/pytalloc.h\" -#include \"scripting/python/pyrpc.h\" +#include \"librpc/rpc/pyrpc.h\" #include \"lib/events/events.h\" #include \"$hdr\" #include \"$ndr_hdr\" -- cgit From 654be49c010949a0420412450971effdbd4ce585 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 May 2008 21:02:56 +0200 Subject: Use manually written Python bindings for DCE/RPC rather than SWIG based. Use base class for pidl-generated DCE/RPC interface Python bindings. (This used to be commit 25e7fc8a2c7a5914c4db4bfe428fd0a8efbf0784) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index dea8f2c648..f252dd4f27 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -636,16 +636,6 @@ sub Interface($$$) $self->pidl("};"); $self->pidl(""); - $self->pidl("static void interface_$interface->{NAME}_dealloc(PyObject* self)"); - $self->pidl("{"); - $self->indent; - $self->pidl("dcerpc_InterfaceObject *interface = (dcerpc_InterfaceObject *)self;"); - $self->pidl("talloc_free(interface->pipe);"); - $self->pidl("PyObject_Del(self);"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - $self->pidl("static PyObject *interface_$interface->{NAME}_new(PyTypeObject *self, PyObject *args, PyObject *kwargs)"); $self->pidl("{"); $self->indent; @@ -726,7 +716,7 @@ sub Interface($$$) $self->pidl("PyObject_HEAD_INIT(NULL) 0,"); $self->pidl(".tp_name = \"$basename.$interface->{NAME}\","); $self->pidl(".tp_basicsize = sizeof(dcerpc_InterfaceObject),"); - $self->pidl(".tp_dealloc = interface_$interface->{NAME}_dealloc,"); + $self->pidl(".tp_base = &dcerpc_InterfaceType,"); $self->pidl(".tp_methods = interface_$interface->{NAME}_methods,"); $self->pidl(".tp_doc = $docstring,"); $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,"); -- cgit From 75e7962d2efb1aa6e45ca999b1a93829406de540 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 May 2008 22:13:32 +0200 Subject: Add convenience functions for setting Python objects from errors. (This used to be commit f1de723b89251cbc8140b838941f304a34871bf3) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index f252dd4f27..5e76ff027b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -257,7 +257,7 @@ sub PythonStruct($$$$$$) $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);"); $self->pidl("DATA_BLOB blob;"); $self->pidl("enum ndr_err_code err;"); - $self->pidl("if (!PyArg_ParseTuple(args, \"(s#):__ndr_unpack__\", &blob.data, &blob.length))"); + $self->pidl("if (!PyArg_ParseTuple(args, \"s#:__ndr_unpack__\", &blob.data, &blob.length))"); $self->pidl("\treturn NULL;"); $self->pidl(""); $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_pull_flags_fn_t)ndr_pull_$name);"); @@ -501,7 +501,7 @@ sub handle_werror($$$$) $self->pidl("if (!W_ERROR_IS_OK($var)) {"); $self->indent; - $self->pidl("PyErr_SetString(PyExc_RuntimeError, win_errstr($var));"); + $self->pidl("PyErr_SetWERROR($var);"); $self->pidl("talloc_free($mem_ctx);") if ($mem_ctx); $self->pidl("return $retval;"); $self->deindent; @@ -515,7 +515,7 @@ sub handle_ntstatus($$$$) $self->pidl("if (NT_STATUS_IS_ERR($var)) {"); $self->indent; - $self->pidl("PyErr_SetString(PyExc_RuntimeError, nt_errstr($var));"); + $self->pidl("PyErr_SetNTSTATUS($var);"); $self->pidl("talloc_free($mem_ctx);") if ($mem_ctx); $self->pidl("return $retval;"); $self->deindent; @@ -926,11 +926,11 @@ sub ConvertScalarToPython($$$) } if ($ctypename eq "NTSTATUS") { - return "PyInt_FromLong(NT_STATUS_V($cvar))"; + return "PyErr_FromNTSTATUS($cvar)"; } if ($ctypename eq "WERROR") { - return "PyInt_FromLong(W_ERROR_V($cvar))"; + return "PyErr_FromWERROR($cvar)"; } if (($ctypename eq "string" or $ctypename eq "nbt_string" or $ctypename eq "nbt_name" or $ctypename eq "wrepl_nbt_name")) { -- cgit From 21b6e9ec9ea08cc5e19a068d68331c178091caa6 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 May 2008 23:22:49 +0200 Subject: Add convenience function for creating objects with NDR error codes. (This used to be commit 991541a78c2428db89509081cc28072c9b542ffa) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 5e76ff027b..26197365ee 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -241,7 +241,7 @@ sub PythonStruct($$$$$$) $self->pidl("err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_push_flags_fn_t)ndr_push_$name);"); $self->pidl("if (err != NDR_ERR_SUCCESS) {"); $self->indent; - $self->pidl("PyErr_SetString(PyExc_RuntimeError, \"Unable to ndr pack\");"); + $self->pidl("PyErr_SetNdrError(err);"); $self->pidl("return NULL;"); $self->deindent; $self->pidl("}"); @@ -263,7 +263,7 @@ sub PythonStruct($$$$$$) $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_pull_flags_fn_t)ndr_pull_$name);"); $self->pidl("if (err != NDR_ERR_SUCCESS) {"); $self->indent; - $self->pidl("PyErr_SetString(PyExc_RuntimeError, \"Unable to ndr unpack\");"); + $self->pidl("PyErr_SetNdrError(err);"); $self->pidl("return NULL;"); $self->deindent; $self->pidl("}"); -- cgit From 63c2a19e6e9d0e5e9b662fafe9fd531c2c073174 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 24 May 2008 23:39:38 +0200 Subject: Add helper function to return DCE/RPC fault codes. (This used to be commit 4716cdfb5d5abad85cba18be89d72fe8ee18f359) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 26197365ee..2795d987f7 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -409,7 +409,14 @@ sub PythonFunctionBody($$$) } } $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, r);"); - $self->handle_ntstatus("status", "NULL", "mem_ctx"); + $self->pidl("if (NT_STATUS_IS_ERR(status)) {"); + $self->indent; + $self->pidl("PyErr_SetDCERPCStatus(iface->pipe, status);"); + $self->pidl("talloc_free(mem_ctx);"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); $env = GenerateFunctionOutEnv($fn, "r->"); my $i = 0; -- cgit From 928ecbaebbde00515d08fd530db7c99169c905ef Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 May 2008 04:23:03 +0200 Subject: Add support for secondary contexts from Python. (This used to be commit 16d1ad050546ae6500153438db8d3c857e6f3ad5) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 2795d987f7..dbbdb6bca1 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -650,20 +650,20 @@ sub Interface($$$) $self->pidl("const char *binding_string;"); $self->pidl("struct cli_credentials *credentials;"); $self->pidl("struct loadparm_context *lp_ctx = NULL;"); - $self->pidl("PyObject *py_lp_ctx = Py_None, *py_credentials = Py_None;"); + $self->pidl("PyObject *py_lp_ctx = Py_None, *py_credentials = Py_None, *py_basis = Py_None;"); $self->pidl("TALLOC_CTX *mem_ctx = NULL;"); $self->pidl("struct event_context *event_ctx;"); $self->pidl("NTSTATUS status;"); $self->pidl(""); $self->pidl("const char *kwnames[] = {"); $self->indent; - $self->pidl("\"binding\", \"lp_ctx\", \"credentials\", NULL"); + $self->pidl("\"binding\", \"lp_ctx\", \"credentials\", \"basis_connection\", NULL"); $self->deindent; $self->pidl("};"); $self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);"); $self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);"); $self->pidl(""); - $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s|OO:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials)) {"); + $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s|OOO:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials, &py_basis)) {"); $self->indent; $self->pidl("return NULL;"); $self->deindent; @@ -691,8 +691,28 @@ sub Interface($$$) $self->pidl("event_ctx = event_context_init(mem_ctx);"); $self->pidl(""); + $self->pidl("if (py_basis != Py_None) {"); + $self->indent; + $self->pidl("struct dcerpc_pipe *base_pipe;"); + $self->pidl(""); + $self->pidl("if (!PyObject_TypeCheck(py_basis, &dcerpc_InterfaceType)) {"); + $self->indent; + $self->pidl("PyErr_SetString(PyExc_ValueError, \"basis_connection must be a DCE/RPC connection\");"); + $self->pidl("talloc_free(mem_ctx);"); + $self->pidl("return NULL;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + $self->pidl("base_pipe = ((dcerpc_InterfaceObject *)py_basis)->pipe;"); + $self->pidl(""); + $self->pidl("status = dcerpc_secondary_context(base_pipe, &ret->pipe, &ndr_table_$interface->{NAME});"); + $self->deindent; + $self->pidl("} else {"); + $self->indent; $self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, "); $self->pidl(" &ndr_table_$interface->{NAME}, credentials, event_ctx, lp_ctx);"); + $self->deindent; + $self->pidl("}"); $self->handle_ntstatus("status", "NULL", "mem_ctx"); $self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;"); -- cgit From 491f0a8dec0223928f3cb317280a0d7449c025e4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 May 2008 17:53:10 +0200 Subject: Use separate function for in argument parsing. (This used to be commit 737059795ce150066ff775909030eebc54b595d9) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 159 +++++++++++++++++---------- 1 file changed, 102 insertions(+), 57 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index dbbdb6bca1..9cff4cd94b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -323,25 +323,9 @@ sub get_metadata_var($) return undef; } -sub PythonFunctionBody($$$) +sub find_metadata_args($) { - my ($self, $fn, $iface, $prettyname) = @_; - - $self->pidl("dcerpc_InterfaceObject *iface = (dcerpc_InterfaceObject *)self;"); - $self->pidl("NTSTATUS status;"); - $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); - $self->pidl("struct $fn->{NAME} *r = talloc_zero(mem_ctx, struct $fn->{NAME});"); - $self->pidl("PyObject *result = Py_None;"); - - my $env = GenerateFunctionInEnv($fn, "r->"); - my $result_size = 0; - - my $args_format = ""; - my $args_string = ""; - my $args_names = ""; - - my $signature = "S.$prettyname("; - + my ($fn) = @_; my $metadata_args = { in => {}, out => {} }; # Determine arguments that are metadata for other arguments (size_is/length_is) @@ -354,34 +338,37 @@ sub PythonFunctionBody($$$) } } + return $metadata_args; +} + +sub PythonFunctionBody($$$$$) +{ + my ($self, $fn, $iface, $prettyname, $infn, $insignature) = @_; + + $self->pidl("dcerpc_InterfaceObject *iface = (dcerpc_InterfaceObject *)self;"); + $self->pidl("NTSTATUS status;"); + $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); + $self->pidl("struct $fn->{NAME} *r = talloc_zero(mem_ctx, struct $fn->{NAME});"); + $self->pidl("PyObject *result = Py_None;"); + + my $env = GenerateFunctionInEnv($fn, "r->"); + my $result_size = 0; + + my $signature = "S.$prettyname($insignature) -> "; + + my $metadata_args = find_metadata_args($fn); + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/out/,@{$e->{DIRECTION}})); next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or ($metadata_args->{out}->{$e->{NAME}}) and grep(/out/, @{$e->{DIRECTION}})); $self->pidl("PyObject *py_$e->{NAME};"); - if (grep(/out/,@{$e->{DIRECTION}})) { - $result_size++; - } - if (grep(/in/,@{$e->{DIRECTION}})) { - $args_format .= "O"; - $args_string .= ", &py_$e->{NAME}"; - $args_names .= "\"$e->{NAME}\", "; - $signature .= "$e->{NAME}, "; - } - } - if (substr($signature, -2) eq ", ") { - $signature = substr($signature, 0, -2); + $result_size++; } - $signature.= ") -> "; - - $self->pidl("const char *kwnames[] = {"); - $self->indent; - $self->pidl($args_names . "NULL"); - $self->deindent; - $self->pidl("};"); - $self->pidl(""); - $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"$args_format:$fn->{NAME}\", discard_const_p(char *, kwnames)$args_string)) {"); + $self->pidl("if (!$infn(args, kwargs, r)) {"); $self->indent; + $self->pidl("talloc_free(mem_ctx);"); $self->pidl("return NULL;"); $self->deindent; $self->pidl("}"); @@ -391,23 +378,6 @@ sub PythonFunctionBody($$$) $result_size++ unless ($fn->{RETURN_TYPE} eq "WERROR" or $fn->{RETURN_TYPE} eq "NTSTATUS"); } - my $fail = "talloc_free(mem_ctx); return NULL;"; - foreach my $e (@{$fn->{ELEMENTS}}) { - next unless (grep(/in/,@{$e->{DIRECTION}})); - if ($metadata_args->{in}->{$e->{NAME}}) { - my $py_var = "py_".$metadata_args->{in}->{$e->{NAME}}; - $self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);"); - my $val = "PyList_Size($py_var)"; - if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { - $self->pidl("r->in.$e->{NAME} = talloc_ptrtype(mem_ctx, r->in.$e->{NAME});"); - $self->pidl("*r->in.$e->{NAME} = $val;"); - } else { - $self->pidl("r->in.$e->{NAME} = $val;"); - } - } else { - $self->ConvertObjectFromPython($env, "mem_ctx", $e, "py_$e->{NAME}", "r->in.$e->{NAME}", $fail); - } - } $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, r);"); $self->pidl("if (NT_STATUS_IS_ERR(status)) {"); $self->indent; @@ -471,6 +441,74 @@ sub PythonFunctionBody($$$) return $signature; } +sub PythonFunctionParseIn($$$) +{ + my ($self, $fn, $fnname) = @_; + my $metadata_args = find_metadata_args($fn); + + my $infnname = "$fnname\_in"; + + $self->pidl("static bool $infnname(PyObject *args, PyObject *kwargs, struct $fn->{NAME} *r)"); + $self->pidl("{"); + $self->indent; + my $args_format = ""; + my $args_string = ""; + my $args_names = ""; + my $signature = ""; + + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/in/,@{$e->{DIRECTION}})); + next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or + ($metadata_args->{out}->{$e->{NAME}}) and grep(/out/, @{$e->{DIRECTION}})); + $self->pidl("PyObject *py_$e->{NAME};"); + $args_format .= "O"; + $args_string .= ", &py_$e->{NAME}"; + $args_names .= "\"$e->{NAME}\", "; + $signature .= "$e->{NAME}, "; + } + if (substr($signature, -2) eq ", ") { + $signature = substr($signature, 0, -2); + } + $self->pidl("const char *kwnames[] = {"); + $self->indent; + $self->pidl($args_names . "NULL"); + $self->deindent; + $self->pidl("};"); + + $self->pidl(""); + $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"$args_format:$fn->{NAME}\", discard_const_p(char *, kwnames)$args_string)) {"); + $self->indent; + $self->pidl("return false;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + + my $env = GenerateFunctionOutEnv($fn, "r->"); + + my $fail = "return false;"; + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/in/,@{$e->{DIRECTION}})); + if ($metadata_args->{in}->{$e->{NAME}}) { + my $py_var = "py_".$metadata_args->{in}->{$e->{NAME}}; + $self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);"); + my $val = "PyList_Size($py_var)"; + if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") { + $self->pidl("r->in.$e->{NAME} = talloc_ptrtype(r, r->in.$e->{NAME});"); + $self->pidl("*r->in.$e->{NAME} = $val;"); + } else { + $self->pidl("r->in.$e->{NAME} = $val;"); + } + } else { + $self->ConvertObjectFromPython($env, "r", $e, "py_$e->{NAME}", "r->in.$e->{NAME}", $fail); + } + } + $self->pidl("return true;"); + $self->deindent; + $self->pidl("}"); + $self->pidl(""); + return ($infnname, $signature); +} + sub PythonFunction($$$) { my ($self, $fn, $iface, $prettyname) = @_; @@ -478,6 +516,13 @@ sub PythonFunction($$$) my $fnname = "py_$fn->{NAME}"; my $docstring = $self->DocString($fn, $fn->{NAME}); + my $insignature; + my $infn; + + if (not has_property($fn, "todo")) { + ($infn, $insignature) = $self->PythonFunctionParseIn($fn, $fnname); + } + $self->pidl("static PyObject *$fnname(PyObject *self, PyObject *args, PyObject *kwargs)"); $self->pidl("{"); $self->indent; @@ -486,7 +531,7 @@ sub PythonFunction($$$) $self->pidl("return NULL;"); unless ($docstring) { $docstring = "NULL"; } } else { - my $signature = $self->PythonFunctionBody($fn, $iface, $prettyname); + my $signature = $self->PythonFunctionBody($fn, $iface, $prettyname, $infn, $insignature); if ($docstring) { $docstring = "\"$signature\\n\\n\"$docstring"; -- cgit From 3421691e69f84228a9bd149d760e394043db5b5c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 May 2008 18:15:55 +0200 Subject: Move result tuple generation out of main Python function running. (This used to be commit 5f07faf9c954229bf1cf6401eff81bdab4e242ae) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 81 +++++++++++++++++----------- 1 file changed, 49 insertions(+), 32 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 9cff4cd94b..0792e4fea3 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -343,7 +343,7 @@ sub find_metadata_args($) sub PythonFunctionBody($$$$$) { - my ($self, $fn, $iface, $prettyname, $infn, $insignature) = @_; + my ($self, $fn, $iface, $prettyname, $infn, $outfn) = @_; $self->pidl("dcerpc_InterfaceObject *iface = (dcerpc_InterfaceObject *)self;"); $self->pidl("NTSTATUS status;"); @@ -351,21 +351,6 @@ sub PythonFunctionBody($$$$$) $self->pidl("struct $fn->{NAME} *r = talloc_zero(mem_ctx, struct $fn->{NAME});"); $self->pidl("PyObject *result = Py_None;"); - my $env = GenerateFunctionInEnv($fn, "r->"); - my $result_size = 0; - - my $signature = "S.$prettyname($insignature) -> "; - - my $metadata_args = find_metadata_args($fn); - - foreach my $e (@{$fn->{ELEMENTS}}) { - next unless (grep(/out/,@{$e->{DIRECTION}})); - next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or - ($metadata_args->{out}->{$e->{NAME}}) and grep(/out/, @{$e->{DIRECTION}})); - $self->pidl("PyObject *py_$e->{NAME};"); - $result_size++; - } - $self->pidl("if (!$infn(args, kwargs, r)) {"); $self->indent; $self->pidl("talloc_free(mem_ctx);"); @@ -374,10 +359,6 @@ sub PythonFunctionBody($$$$$) $self->pidl("}"); $self->pidl(""); - if ($fn->{RETURN_TYPE}) { - $result_size++ unless ($fn->{RETURN_TYPE} eq "WERROR" or $fn->{RETURN_TYPE} eq "NTSTATUS"); - } - $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, r);"); $self->pidl("if (NT_STATUS_IS_ERR(status)) {"); $self->indent; @@ -388,7 +369,41 @@ sub PythonFunctionBody($$$$$) $self->pidl("}"); $self->pidl(""); - $env = GenerateFunctionOutEnv($fn, "r->"); + $self->pidl("result = $outfn(r);"); + $self->pidl(""); + $self->pidl("talloc_free(mem_ctx);"); + $self->pidl("return result;"); + +} + +sub PythonFunctionUnpackOut($$$) +{ + my ($self, $fn, $fnname) = @_; + + my $outfnname = "unpack_$fnname\_args_out"; + my $signature = ""; + + my $metadata_args = find_metadata_args($fn); + + my $env = GenerateFunctionOutEnv($fn, "r->"); + my $result_size = 0; + + $self->pidl("static PyObject *$outfnname(struct $fn->{NAME} *r)"); + $self->pidl("{"); + $self->indent; + $self->pidl("PyObject *result = Py_None;"); + foreach my $e (@{$fn->{ELEMENTS}}) { + next unless (grep(/out/,@{$e->{DIRECTION}})); + next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or + ($metadata_args->{out}->{$e->{NAME}}) and grep(/out/, @{$e->{DIRECTION}})); + $self->pidl("PyObject *py_$e->{NAME};"); + $result_size++; + } + + if ($fn->{RETURN_TYPE}) { + $result_size++ unless ($fn->{RETURN_TYPE} eq "WERROR" or $fn->{RETURN_TYPE} eq "NTSTATUS"); + } + my $i = 0; if ($result_size > 1) { @@ -415,9 +430,9 @@ sub PythonFunctionBody($$$$$) } if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") { - $self->handle_ntstatus("r->out.result", "NULL", "mem_ctx"); + $self->handle_ntstatus("r->out.result", "NULL", undef); } elsif (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "WERROR") { - $self->handle_werror("r->out.result", "NULL", "mem_ctx"); + $self->handle_werror("r->out.result", "NULL", undef); } elsif (defined($fn->{RETURN_TYPE})) { my $conv = $self->ConvertObjectToPythonData("r", $fn->{RETURN_TYPE}, "r->out.result"); if ($result_size > 1) { @@ -435,18 +450,19 @@ sub PythonFunctionBody($$$$$) $signature .= ")"; } - $self->pidl("talloc_free(mem_ctx);"); $self->pidl("return result;"); + $self->deindent; + $self->pidl("}"); - return $signature; + return ($outfnname, $signature); } -sub PythonFunctionParseIn($$$) +sub PythonFunctionPackIn($$$) { my ($self, $fn, $fnname) = @_; my $metadata_args = find_metadata_args($fn); - my $infnname = "$fnname\_in"; + my $infnname = "pack_$fnname\_args_in"; $self->pidl("static bool $infnname(PyObject *args, PyObject *kwargs, struct $fn->{NAME} *r)"); $self->pidl("{"); @@ -516,11 +532,12 @@ sub PythonFunction($$$) my $fnname = "py_$fn->{NAME}"; my $docstring = $self->DocString($fn, $fn->{NAME}); - my $insignature; - my $infn; + my ($insignature, $outsignature); + my ($infn, $outfn); if (not has_property($fn, "todo")) { - ($infn, $insignature) = $self->PythonFunctionParseIn($fn, $fnname); + ($infn, $insignature) = $self->PythonFunctionPackIn($fn, $fnname); + ($outfn, $outsignature) = $self->PythonFunctionUnpackOut($fn, $fnname); } $self->pidl("static PyObject *$fnname(PyObject *self, PyObject *args, PyObject *kwargs)"); @@ -531,8 +548,8 @@ sub PythonFunction($$$) $self->pidl("return NULL;"); unless ($docstring) { $docstring = "NULL"; } } else { - my $signature = $self->PythonFunctionBody($fn, $iface, $prettyname, $infn, $insignature); - + $self->PythonFunctionBody($fn, $iface, $prettyname, $infn, $outfn); + my $signature = "S.$prettyname($insignature) -> $outsignature"; if ($docstring) { $docstring = "\"$signature\\n\\n\"$docstring"; } else { -- cgit From 01fd6886466f1976d30b4deba4fe224344f760c2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 May 2008 18:27:32 +0200 Subject: Fix environment generation. (This used to be commit 19b46b50c982eb01909fe31d5abd304a1dd13577) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 0792e4fea3..720d066360 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -499,7 +499,7 @@ sub PythonFunctionPackIn($$$) $self->pidl("}"); $self->pidl(""); - my $env = GenerateFunctionOutEnv($fn, "r->"); + my $env = GenerateFunctionInEnv($fn, "r->"); my $fail = "return false;"; foreach my $e (@{$fn->{ELEMENTS}}) { -- cgit From 77acb789e2ea5eca3b0602e6397df76c5af55efe Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 25 May 2008 23:14:48 +0200 Subject: Trim the size of the Python bindings a bit. (This used to be commit 717ce0b640a5c3aa62804b9869ef4dcc0f71b7ba) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 83 ++++++++-------------------- 1 file changed, 24 insertions(+), 59 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 720d066360..0832401d7d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -21,7 +21,8 @@ $VERSION = '0.01'; sub new($) { my ($class) = @_; my $self = { res => "", res_hdr => "", tabs => "", constants => {}, - module_methods => [], module_objects => [], module_types => []}; + module_methods => [], module_objects => [], module_types => [], + readycode => [] }; bless($self, $class); } @@ -341,41 +342,6 @@ sub find_metadata_args($) return $metadata_args; } -sub PythonFunctionBody($$$$$) -{ - my ($self, $fn, $iface, $prettyname, $infn, $outfn) = @_; - - $self->pidl("dcerpc_InterfaceObject *iface = (dcerpc_InterfaceObject *)self;"); - $self->pidl("NTSTATUS status;"); - $self->pidl("TALLOC_CTX *mem_ctx = talloc_new(NULL);"); - $self->pidl("struct $fn->{NAME} *r = talloc_zero(mem_ctx, struct $fn->{NAME});"); - $self->pidl("PyObject *result = Py_None;"); - - $self->pidl("if (!$infn(args, kwargs, r)) {"); - $self->indent; - $self->pidl("talloc_free(mem_ctx);"); - $self->pidl("return NULL;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - - $self->pidl("status = dcerpc_$fn->{NAME}(iface->pipe, mem_ctx, r);"); - $self->pidl("if (NT_STATUS_IS_ERR(status)) {"); - $self->indent; - $self->pidl("PyErr_SetDCERPCStatus(iface->pipe, status);"); - $self->pidl("talloc_free(mem_ctx);"); - $self->pidl("return NULL;"); - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - - $self->pidl("result = $outfn(r);"); - $self->pidl(""); - $self->pidl("talloc_free(mem_ctx);"); - $self->pidl("return result;"); - -} - sub PythonFunctionUnpackOut($$$) { my ($self, $fn, $fnname) = @_; @@ -453,6 +419,7 @@ sub PythonFunctionUnpackOut($$$) $self->pidl("return result;"); $self->deindent; $self->pidl("}"); + $self->pidl(""); return ($outfnname, $signature); } @@ -535,20 +502,13 @@ sub PythonFunction($$$) my ($insignature, $outsignature); my ($infn, $outfn); - if (not has_property($fn, "todo")) { - ($infn, $insignature) = $self->PythonFunctionPackIn($fn, $fnname); - ($outfn, $outsignature) = $self->PythonFunctionUnpackOut($fn, $fnname); - } - - $self->pidl("static PyObject *$fnname(PyObject *self, PyObject *args, PyObject *kwargs)"); - $self->pidl("{"); - $self->indent; if (has_property($fn, "todo")) { - $self->pidl("PyErr_SetString(PyExc_NotImplementedError, \"No marshalling code available yet for $prettyname\");"); - $self->pidl("return NULL;"); unless ($docstring) { $docstring = "NULL"; } + $infn = "NULL"; + $outfn = "NULL"; } else { - $self->PythonFunctionBody($fn, $iface, $prettyname, $infn, $outfn); + ($infn, $insignature) = $self->PythonFunctionPackIn($fn, $fnname); + ($outfn, $outsignature) = $self->PythonFunctionUnpackOut($fn, $fnname); my $signature = "S.$prettyname($insignature) -> $outsignature"; if ($docstring) { $docstring = "\"$signature\\n\\n\"$docstring"; @@ -557,11 +517,7 @@ sub PythonFunction($$$) } } - $self->deindent; - $self->pidl("}"); - $self->pidl(""); - - return ($fnname, $docstring); + return ($infn, $outfn, $docstring); } sub handle_werror($$$$) @@ -689,18 +645,18 @@ sub Interface($$$) $prettyname =~ s/^$interface->{NAME}_//; $prettyname =~ s/^$basename\_//; - my ($fnname, $fndocstring) = $self->PythonFunction($d, $interface->{NAME}, $prettyname); + my ($infn, $outfn, $fndocstring) = $self->PythonFunction($d, $interface->{NAME}, $prettyname); - push (@fns, [$fnname, $prettyname, $fndocstring]); + push (@fns, [$infn, $outfn, "dcerpc_$d->{NAME}", $prettyname, $fndocstring, $d->{OPNUM}]); } - $self->pidl("static PyMethodDef interface_$interface->{NAME}\_methods[] = {"); + $self->pidl("static struct PyNdrRpcMethodDef interface_$interface->{NAME}\_methods[] = {"); $self->indent; foreach my $d (@fns) { - my ($c_fn, $prettyname, $docstring) = @$d; - $self->pidl("{ \"$prettyname\", (PyCFunction)$c_fn, METH_VARARGS|METH_KEYWORDS, $docstring },"); + my ($infn, $outfn, $callfn, $prettyname, $docstring, $opnum) = @$d; + $self->pidl("{ \"$prettyname\", $docstring, (dcerpc_call_fn)$callfn, (py_data_pack_fn)$infn, (py_data_unpack_fn)$outfn, $opnum, &ndr_table_$interface->{NAME} },"); } - $self->pidl("{ NULL, NULL, 0, NULL }"); + $self->pidl("{ NULL }"); $self->deindent; $self->pidl("};"); $self->pidl(""); @@ -806,7 +762,6 @@ sub Interface($$$) $self->pidl(".tp_name = \"$basename.$interface->{NAME}\","); $self->pidl(".tp_basicsize = sizeof(dcerpc_InterfaceObject),"); $self->pidl(".tp_base = &dcerpc_InterfaceType,"); - $self->pidl(".tp_methods = interface_$interface->{NAME}_methods,"); $self->pidl(".tp_doc = $docstring,"); $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,"); $self->pidl(".tp_new = interface_$interface->{NAME}_new,"); @@ -816,6 +771,7 @@ sub Interface($$$) $self->pidl(""); $self->register_module_typeobject($interface->{NAME}, "&$interface->{NAME}_InterfaceType"); + $self->register_module_readycode(["if (!PyInterface_AddNdrRpcMethods(&$interface->{NAME}_InterfaceType, interface_$interface->{NAME}_methods))", "\treturn;", ""]); } $self->pidl_hdr("\n"); @@ -838,6 +794,13 @@ sub register_module_typeobject($$$) push (@{$self->{module_types}}, [$name, $py_name]) } +sub register_module_readycode($$) +{ + my ($self, $code) = @_; + + push (@{$self->{readycode}}, @$code); +} + sub register_module_object($$$) { my ($self, $name, $py_name) = @_; @@ -1195,6 +1158,8 @@ sub Parse($$$$$) $self->pidl("\treturn;"); } + $self->pidl($_) foreach (@{$self->{readycode}}); + $self->pidl(""); $self->pidl("m = Py_InitModule3(\"$basename\", $basename\_methods, \"$basename DCE/RPC\");"); -- cgit From d60d8e57d83acfc94fa36c59fcfb9c6e03ee02b6 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 26 May 2008 03:07:18 +0200 Subject: Implement IRPC calls over the internal messaging bus. (This used to be commit 777dc3a2c7b5bf855344ba3ae8c8b564c48fc0c6) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 0832401d7d..055ee13b10 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -650,7 +650,8 @@ sub Interface($$$) push (@fns, [$infn, $outfn, "dcerpc_$d->{NAME}", $prettyname, $fndocstring, $d->{OPNUM}]); } - $self->pidl("static struct PyNdrRpcMethodDef interface_$interface->{NAME}\_methods[] = {"); + $self->pidl("const struct PyNdrRpcMethodDef py_ndr_$interface->{NAME}\_methods[] = {"); + $self->pidl_hdr("const struct PyNdrRpcMethodDef py_ndr_$interface->{NAME}\_methods[];"); $self->indent; foreach my $d (@fns) { my ($infn, $outfn, $callfn, $prettyname, $docstring, $opnum) = @$d; @@ -771,7 +772,7 @@ sub Interface($$$) $self->pidl(""); $self->register_module_typeobject($interface->{NAME}, "&$interface->{NAME}_InterfaceType"); - $self->register_module_readycode(["if (!PyInterface_AddNdrRpcMethods(&$interface->{NAME}_InterfaceType, interface_$interface->{NAME}_methods))", "\treturn;", ""]); + $self->register_module_readycode(["if (!PyInterface_AddNdrRpcMethods(&$interface->{NAME}_InterfaceType, py_ndr_$interface->{NAME}\_methods))", "\treturn;", ""]); } $self->pidl_hdr("\n"); -- cgit From d5434f0b4bcf744e5a5f0e933bdcf629d42a6478 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 26 May 2008 04:14:28 +0200 Subject: Allow using IRPC functions on the messaging bus from Python. (This used to be commit 6ecf81ae13dffa05356c1177c617206c120fb7d7) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 055ee13b10..b5ae801ff8 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -651,7 +651,7 @@ sub Interface($$$) } $self->pidl("const struct PyNdrRpcMethodDef py_ndr_$interface->{NAME}\_methods[] = {"); - $self->pidl_hdr("const struct PyNdrRpcMethodDef py_ndr_$interface->{NAME}\_methods[];"); + $self->pidl_hdr("extern const struct PyNdrRpcMethodDef py_ndr_$interface->{NAME}\_methods[];"); $self->indent; foreach my $d (@fns) { my ($infn, $outfn, $callfn, $prettyname, $docstring, $opnum) = @$d; -- cgit From 4b3641695ba42d0348e8eceadb02430342c1513c Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 26 May 2008 05:00:45 +0200 Subject: Finish smbstatus in Python. (This used to be commit 988508c2d3269cc88ed38df2fc207a1c0aaccc6b) --- source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 50 +++++++++++++++++++--------- 1 file changed, 34 insertions(+), 16 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index b5ae801ff8..60d0dafc8a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -21,7 +21,7 @@ $VERSION = '0.01'; sub new($) { my ($class) = @_; my $self = { res => "", res_hdr => "", tabs => "", constants => {}, - module_methods => [], module_objects => [], module_types => [], + module_methods => [], module_objects => [], ready_types => [], readycode => [] }; bless($self, $class); } @@ -108,7 +108,7 @@ sub FromUnionToPythonFunction($$$$) $self->indent; if ($e->{NAME}) { - $self->ConvertObjectToPython($mem_ctx, {}, $e, "$name->$e->{NAME}", "ret"); + $self->ConvertObjectToPython($mem_ctx, {}, $e, "$name->$e->{NAME}", "ret", "return NULL;"); } else { $self->pidl("ret = Py_None;"); } @@ -182,7 +182,7 @@ sub PythonStruct($$$$$$) $self->indent; $self->pidl("$cname *object = py_talloc_get_ptr(obj);"); $self->pidl("PyObject *py_$e->{NAME};"); - $self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}"); + $self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}", "return NULL;"); $self->pidl("return py_$e->{NAME};"); $self->deindent; $self->pidl("}"); @@ -383,7 +383,7 @@ sub PythonFunctionUnpackOut($$$) next if ($metadata_args->{out}->{$e->{NAME}}); my $py_name = "py_$e->{NAME}"; if (grep(/out/,@{$e->{DIRECTION}})) { - $self->ConvertObjectToPython("r", $env, $e, "r->out.$e->{NAME}", $py_name); + $self->ConvertObjectToPython("r", $env, $e, "r->out.$e->{NAME}", $py_name, "return NULL;"); if ($result_size > 1) { $self->pidl("PyTuple_SetItem(result, $i, $py_name);"); $i++; @@ -792,7 +792,13 @@ sub register_module_typeobject($$$) $self->register_module_object($name, "(PyObject *)$py_name"); - push (@{$self->{module_types}}, [$name, $py_name]) + $self->check_ready_type($py_name); +} + +sub check_ready_type($$) +{ + my ($self, $py_name) = @_; + push (@{$self->{ready_types}}, $py_name) unless (grep(/^$py_name$/,@{$self->{ready_types}})); } sub register_module_readycode($$) @@ -1026,14 +1032,24 @@ sub ConvertObjectToPythonData($$$$$) die("unknown type ".mapTypeName($ctype) . ": $cvar"); } -sub ConvertObjectToPythonLevel($$$$$) +sub fail_on_null($$$) { - my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var) = @_; + my ($self, $var, $fail) = @_; + $self->pidl("if ($var == NULL) {"); + $self->indent; + $self->pidl($fail); + $self->deindent; + $self->pidl("}"); +} + +sub ConvertObjectToPythonLevel($$$$$$) +{ + my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var, $fail) = @_; my $nl = GetNextLevel($e, $l); if ($l->{TYPE} eq "POINTER") { if ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) { - $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name, $py_var); + $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name, $py_var, $fail); return; } if ($l->{POINTER_TYPE} ne "ref") { @@ -1044,7 +1060,7 @@ sub ConvertObjectToPythonLevel($$$$$) $self->pidl("} else {"); $self->indent; } - $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, get_value_of($var_name), $py_var); + $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, get_value_of($var_name), $py_var, $fail); if ($l->{POINTER_TYPE} ne "ref") { $self->deindent; $self->pidl("}"); @@ -1067,6 +1083,7 @@ sub ConvertObjectToPythonLevel($$$$$) $length = ParseExpr($length, $env, $e); $self->pidl("$py_var = PyList_New($length);"); + $self->fail_on_null($py_var, $fail); $self->pidl("{"); $self->indent; my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}"; @@ -1075,7 +1092,7 @@ sub ConvertObjectToPythonLevel($$$$$) $self->indent; my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}"; $self->pidl("PyObject *$member_var;"); - $self->ConvertObjectToPythonLevel($var_name, $env, $e, GetNextLevel($e, $l), $var_name."[$counter]", $member_var); + $self->ConvertObjectToPythonLevel($var_name, $env, $e, GetNextLevel($e, $l), $var_name."[$counter]", $member_var, $fail); $self->pidl("PyList_SetItem($py_var, $counter, $member_var);"); $self->deindent; $self->pidl("}"); @@ -1086,6 +1103,8 @@ sub ConvertObjectToPythonLevel($$$$$) $var_name = get_pointer_to($var_name); my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e); $self->pidl("$py_var = py_import_" . GetNextLevel($e, $l)->{DATA_TYPE} . "($mem_ctx, $switch, $var_name);"); + $self->fail_on_null($py_var, $fail); + } elsif ($l->{TYPE} eq "DATA") { if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE})) { $var_name = get_pointer_to($var_name); @@ -1093,7 +1112,7 @@ sub ConvertObjectToPythonLevel($$$$$) my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name); $self->pidl("$py_var = $conv;"); } elsif ($l->{TYPE} eq "SUBCONTEXT") { - $self->ConvertObjectToPythonLevel($mem_ctx, $env, $e, GetNextLevel($e, $l), $var_name, $py_var); + $self->ConvertObjectToPythonLevel($mem_ctx, $env, $e, GetNextLevel($e, $l), $var_name, $py_var, $fail); } else { die("Unknown level type $l->{TYPE} $var_name"); } @@ -1101,9 +1120,9 @@ sub ConvertObjectToPythonLevel($$$$$) sub ConvertObjectToPython($$$$$$) { - my ($self, $mem_ctx, $env, $ctype, $cvar, $py_var) = @_; + my ($self, $mem_ctx, $env, $ctype, $cvar, $py_var, $fail) = @_; - $self->ConvertObjectToPythonLevel($mem_ctx, $env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var); + $self->ConvertObjectToPythonLevel($mem_ctx, $env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var, $fail); } sub Parse($$$$$) @@ -1153,9 +1172,8 @@ sub Parse($$$$$) $self->pidl("PyObject *m;"); $self->pidl(""); - foreach (@{$self->{module_types}}) { - my ($object_name, $c_name) = @$_; - $self->pidl("if (PyType_Ready($c_name) < 0)"); + foreach (@{$self->{ready_types}}) { + $self->pidl("if (PyType_Ready($_) < 0)"); $self->pidl("\treturn;"); } -- cgit From 0c6ce977ffb8f53f546596b76c1e0858cc6a88ba Mon Sep 17 00:00:00 2001 From: Julien Kerihuel Date: Sat, 31 May 2008 00:47:14 +0200 Subject: Fix if_version for interfaces with a if_version_minor field different from 0 Signed-off-by: Stefan Metzmacher (This used to be commit 7b6927832a1118b142d0d8a3a5548761f5a04f1a) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 33e5ad3196..1e4504764a 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -688,7 +688,12 @@ sub ParseInterface($) $version = "0.0"; if(defined $idl->{PROPERTIES}->{version}) { - $version = $idl->{PROPERTIES}->{version}; + my @if_version = split(/\./, $idl->{PROPERTIES}->{version}); + if ($if_version[0] == $idl->{PROPERTIES}->{version}) { + $version = $idl->{PROPERTIES}->{version}; + } else { + $version = $if_version[1] << 16 | $if_version[0]; + } } # If no endpoint is set, default to the interface name as a named pipe -- cgit From 8025edf335dbb66c7efa1d51a0e600a9e3c13bba Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Wed, 16 Jul 2008 21:50:25 +0200 Subject: Add the interface ID to the rpc_pipe_register_commands call in s3 srv code (This used to be commit efe249928312f730ee580e72b9c640ef88b0ed5b) --- source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm index 4af9da0f52..b21d3f4bbc 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm @@ -235,7 +235,7 @@ sub ParseInterface($) pidl_hdr "NTSTATUS rpc_$if->{NAME}_init(void);"; pidl "NTSTATUS rpc_$if->{NAME}_init(void)"; pidl "{"; - pidl "\treturn rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, \"$if->{NAME}\", \"$if->{NAME}\", api_$if->{NAME}_cmds, sizeof(api_$if->{NAME}_cmds) / sizeof(struct api_struct));"; + pidl "\treturn rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, \"$if->{NAME}\", \"$if->{NAME}\", \&ndr_table_$if->{NAME}.syntax_id, api_$if->{NAME}_cmds, sizeof(api_$if->{NAME}_cmds) / sizeof(struct api_struct));"; pidl "}"; pidl_hdr "#endif /* __SRV_$uif\__ */"; -- cgit From 24b03e1080b5acbe8086bbc22091ecb1af642619 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 21 Jul 2008 12:47:08 +0200 Subject: Properly cast array length in print functions. (This used to be commit f321240fa91fa19c1131f119c42f64897d220682) --- source4/pidl/lib/Parse/Pidl/Expr.pm | 72 ++++++++++++------------ source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 2 +- 2 files changed, 37 insertions(+), 37 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Expr.pm b/source4/pidl/lib/Parse/Pidl/Expr.pm index 4e02be0575..5524374fae 100644 --- a/source4/pidl/lib/Parse/Pidl/Expr.pm +++ b/source4/pidl/lib/Parse/Pidl/Expr.pm @@ -1127,7 +1127,7 @@ sub new { [#Rule 2 'exp', 1, sub -#line 22 "pidl/expr.yp" +#line 22 "./pidl/expr.yp" { "\"$_[1]\"" } ], [#Rule 3 @@ -1139,199 +1139,199 @@ sub [#Rule 5 'exp', 2, sub -#line 25 "pidl/expr.yp" +#line 25 "./pidl/expr.yp" { "~$_[2]" } ], [#Rule 6 'exp', 3, sub -#line 26 "pidl/expr.yp" +#line 26 "./pidl/expr.yp" { "$_[1] + $_[3]" } ], [#Rule 7 'exp', 3, sub -#line 27 "pidl/expr.yp" +#line 27 "./pidl/expr.yp" { "$_[1] - $_[3]" } ], [#Rule 8 'exp', 3, sub -#line 28 "pidl/expr.yp" +#line 28 "./pidl/expr.yp" { "$_[1] * $_[3]" } ], [#Rule 9 'exp', 3, sub -#line 29 "pidl/expr.yp" +#line 29 "./pidl/expr.yp" { "$_[1] % $_[3]" } ], [#Rule 10 'exp', 3, sub -#line 30 "pidl/expr.yp" +#line 30 "./pidl/expr.yp" { "$_[1] < $_[3]" } ], [#Rule 11 'exp', 3, sub -#line 31 "pidl/expr.yp" +#line 31 "./pidl/expr.yp" { "$_[1] > $_[3]" } ], [#Rule 12 'exp', 3, sub -#line 32 "pidl/expr.yp" +#line 32 "./pidl/expr.yp" { "$_[1] | $_[3]" } ], [#Rule 13 'exp', 3, sub -#line 33 "pidl/expr.yp" +#line 33 "./pidl/expr.yp" { "$_[1] == $_[3]" } ], [#Rule 14 'exp', 3, sub -#line 34 "pidl/expr.yp" +#line 34 "./pidl/expr.yp" { "$_[1] <= $_[3]" } ], [#Rule 15 'exp', 3, sub -#line 35 "pidl/expr.yp" +#line 35 "./pidl/expr.yp" { "$_[1] => $_[3]" } ], [#Rule 16 'exp', 3, sub -#line 36 "pidl/expr.yp" +#line 36 "./pidl/expr.yp" { "$_[1] << $_[3]" } ], [#Rule 17 'exp', 3, sub -#line 37 "pidl/expr.yp" +#line 37 "./pidl/expr.yp" { "$_[1] >> $_[3]" } ], [#Rule 18 'exp', 3, sub -#line 38 "pidl/expr.yp" +#line 38 "./pidl/expr.yp" { "$_[1] != $_[3]" } ], [#Rule 19 'exp', 3, sub -#line 39 "pidl/expr.yp" +#line 39 "./pidl/expr.yp" { "$_[1] || $_[3]" } ], [#Rule 20 'exp', 3, sub -#line 40 "pidl/expr.yp" +#line 40 "./pidl/expr.yp" { "$_[1] && $_[3]" } ], [#Rule 21 'exp', 3, sub -#line 41 "pidl/expr.yp" +#line 41 "./pidl/expr.yp" { "$_[1] & $_[3]" } ], [#Rule 22 'exp', 5, sub -#line 42 "pidl/expr.yp" +#line 42 "./pidl/expr.yp" { "$_[1]?$_[3]:$_[5]" } ], [#Rule 23 'exp', 2, sub -#line 43 "pidl/expr.yp" +#line 43 "./pidl/expr.yp" { "~$_[1]" } ], [#Rule 24 'exp', 2, sub -#line 44 "pidl/expr.yp" +#line 44 "./pidl/expr.yp" { "not $_[1]" } ], [#Rule 25 'exp', 3, sub -#line 45 "pidl/expr.yp" +#line 45 "./pidl/expr.yp" { "$_[1] / $_[3]" } ], [#Rule 26 'exp', 2, sub -#line 46 "pidl/expr.yp" +#line 46 "./pidl/expr.yp" { "-$_[2]" } ], [#Rule 27 'exp', 2, sub -#line 47 "pidl/expr.yp" +#line 47 "./pidl/expr.yp" { "&$_[2]" } ], [#Rule 28 'exp', 3, sub -#line 48 "pidl/expr.yp" +#line 48 "./pidl/expr.yp" { "$_[1]^$_[3]" } ], [#Rule 29 'exp', 3, sub -#line 49 "pidl/expr.yp" +#line 49 "./pidl/expr.yp" { "($_[2])" } ], [#Rule 30 'possible_pointer', 1, sub -#line 53 "pidl/expr.yp" +#line 53 "./pidl/expr.yp" { $_[0]->_Lookup($_[1]) } ], [#Rule 31 'possible_pointer', 2, sub -#line 54 "pidl/expr.yp" +#line 54 "./pidl/expr.yp" { $_[0]->_Dereference($_[2]); "*$_[2]" } ], [#Rule 32 'var', 1, sub -#line 57 "pidl/expr.yp" +#line 57 "./pidl/expr.yp" { $_[0]->_Use($_[1]) } ], [#Rule 33 'var', 3, sub -#line 58 "pidl/expr.yp" +#line 58 "./pidl/expr.yp" { $_[0]->_Use("$_[1].$_[3]") } ], [#Rule 34 'var', 3, sub -#line 59 "pidl/expr.yp" +#line 59 "./pidl/expr.yp" { "($_[2])" } ], [#Rule 35 'var', 3, sub -#line 60 "pidl/expr.yp" +#line 60 "./pidl/expr.yp" { $_[0]->_Use("*$_[1]"); $_[1]."->".$_[3] } ], [#Rule 36 'func', 4, sub -#line 64 "pidl/expr.yp" +#line 64 "./pidl/expr.yp" { "$_[1]($_[3])" } ], [#Rule 37 'opt_args', 0, sub -#line 65 "pidl/expr.yp" +#line 65 "./pidl/expr.yp" { "" } ], [#Rule 38 @@ -1349,7 +1349,7 @@ sub [#Rule 42 'args', 3, sub -#line 68 "pidl/expr.yp" +#line 68 "./pidl/expr.yp" { "$_[1], $_[3]" } ] ], @@ -1357,7 +1357,7 @@ sub bless($self,$class); } -#line 71 "pidl/expr.yp" +#line 71 "./pidl/expr.yp" package Parse::Pidl::Expr; diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 0d1806a0fa..a0de1f127a 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -770,7 +770,7 @@ sub ParseElementPrint($$$$) } else { my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; - $self->pidl("ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);"); + $self->pidl("ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", (int)$length);"); $self->pidl("ndr->depth++;"); $self->pidl("for ($counter=0;$counter<$length;$counter++) {"); $self->indent; -- cgit From a819f4e88c9398dbac17d102ad8b58e1a5f02df3 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 21 Jul 2008 13:05:23 +0200 Subject: s3 cli_do_rpc_ndr does not use PI_* anymore (This used to be commit e625c6b2516111002c99239c1a2188c6d5d87ab6) --- source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm | 1 - 1 file changed, 1 deletion(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm index 87ed29b54e..d2ab407eb0 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm @@ -153,7 +153,6 @@ sub ParseFunction($$$) $self->pidl(""); $self->pidl("status = cli_do_rpc_ndr(cli,"); $self->pidl("\t\t\tmem_ctx,"); - $self->pidl("\t\t\tPI_$uif,"); $self->pidl("\t\t\t&ndr_table_$if,"); $self->pidl("\t\t\t$ufn,"); $self->pidl("\t\t\t&r);"); -- cgit From 47edb623f68e40074aa3b2b3f1669aef48e64727 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 19 Aug 2008 12:34:49 +0200 Subject: pidl/NDR::Parser: use $ndr instead of "ndr" metze (This used to be commit a1cf2289dd4ff9a3f9cf61da680223193235e35f) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 28 ++++++++++++------------ 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index a0de1f127a..a3f4780ced 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -331,12 +331,12 @@ sub ParseArrayPullHeader($$$$$$) } else { $length = $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->pidl(shift); }, - "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"), + "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"), check_fully_dereferenced($e, $env)); } if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) { - $self->pidl("NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));"); + $self->pidl("NDR_CHECK(ndr_pull_array_size($ndr, " . get_pointer_to($var_name) . "));"); } if ($l->{IS_VARYING}) { @@ -357,9 +357,9 @@ sub ParseArrayPullHeader($$$$$$) $self->defer_indent; my $size = ParseExprExt($l->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->defer(shift); }, - "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"), + "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"), check_fully_dereferenced($e, $env)); - $self->defer("NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));"); + $self->defer("NDR_CHECK(ndr_check_array_size($ndr, (void*)" . get_pointer_to($var_name) . ", $size));"); $self->defer_deindent; $self->defer("}"); } @@ -369,9 +369,9 @@ sub ParseArrayPullHeader($$$$$$) $self->defer_indent; my $length = ParseExprExt($l->{LENGTH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->defer(shift); }, - "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for length_is()\");"), + "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for length_is()\");"), check_fully_dereferenced($e, $env)); - $self->defer("NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));"); + $self->defer("NDR_CHECK(ndr_check_array_length($ndr, (void*)" . get_pointer_to($var_name) . ", $length));"); $self->defer_deindent; $self->defer("}"); } @@ -569,7 +569,7 @@ sub ParseElementPushLevel $self->pidl("if ($var_name) {"); $self->indent; if ($l->{POINTER_TYPE} eq "relative") { - $self->pidl("NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));"); + $self->pidl("NDR_CHECK(ndr_push_relative_ptr2($ndr, $var_name));"); } } $var_name = get_value_of($var_name); @@ -816,7 +816,7 @@ sub ParseSwitchPull($$$$$$) my($self,$e,$l,$ndr,$var_name,$env) = @_; my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->pidl(shift); }, - "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for switch_is()\");"), + "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for switch_is()\");"), check_fully_dereferenced($e, $env)); $var_name = get_pointer_to($var_name); @@ -830,7 +830,7 @@ sub ParseSwitchPush($$$$$$) my($self,$e,$l,$ndr,$var_name,$env) = @_; my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->pidl(shift); }, - "return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for switch_is()\");"), + "return ndr_push_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for switch_is()\");"), check_fully_dereferenced($e, $env)); $var_name = get_pointer_to($var_name); @@ -1022,8 +1022,8 @@ sub ParseElementPullLevel if ($l->{POINTER_TYPE} eq "relative") { $self->pidl("uint32_t _relative_save_offset;"); - $self->pidl("_relative_save_offset = ndr->offset;"); - $self->pidl("NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));"); + $self->pidl("_relative_save_offset = $ndr->offset;"); + $self->pidl("NDR_CHECK(ndr_pull_relative_ptr2($ndr, $var_name));"); } } @@ -1036,7 +1036,7 @@ sub ParseElementPullLevel if ($l->{POINTER_TYPE} ne "ref") { if ($l->{POINTER_TYPE} eq "relative") { - $self->pidl("ndr->offset = _relative_save_offset;"); + $self->pidl("$ndr->offset = _relative_save_offset;"); } $self->deindent; $self->pidl("}"); @@ -1131,7 +1131,7 @@ sub ParsePtrPull($$$$$) if ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP") { if (!$next_is_array and !$next_is_string) { - $self->pidl("if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"); + $self->pidl("if ($ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"); $self->pidl("\tNDR_PULL_ALLOC($ndr, $var_name);"); $self->pidl("}"); } @@ -2068,7 +2068,7 @@ sub AllocateArrayLevel($$$$$$) $pl->{TYPE} eq "POINTER" and $pl->{POINTER_TYPE} eq "ref" and not $l->{IS_ZERO_TERMINATED}) { - $self->pidl("if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"); + $self->pidl("if ($ndr->flags & LIBNDR_FLAG_REF_ALLOC) {"); $self->pidl("\tNDR_PULL_ALLOC_N($ndr, $var, $size);"); $self->pidl("}"); if (grep(/in/,@{$e->{DIRECTION}}) and -- cgit From 8554fcbc03f8086bffb3d0bfb5b74a92bb8f9dd3 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 19 Aug 2008 13:04:38 +0200 Subject: pidl/NDR::Parser: pass $ndr to ->PULL_FN_BODY() metze (This used to be commit 38c4b2a3e9b316f390651297854de033ede0d128) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 84 ++++++++++++------------ 1 file changed, 42 insertions(+), 42 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index a3f4780ced..c5253d4e1b 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1271,15 +1271,15 @@ sub ParseEnumPush($$$) ##################################################################### # generate a pull function for an enum -sub ParseEnumPull($$$) +sub ParseEnumPull($$$$) { - my($self,$enum,$varname) = @_; + my($self,$enum,$ndr,$varname) = @_; my($type_fn) = $enum->{BASE_TYPE}; my($type_v_decl) = mapTypeName($type_fn); $self->pidl("$type_v_decl v;"); $self->start_flags($enum); - $self->pidl("NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"); + $self->pidl("NDR_CHECK(ndr_pull_$type_fn($ndr, NDR_SCALARS, &v));"); $self->pidl("*$varname = v;"); $self->end_flags($enum); @@ -1346,15 +1346,15 @@ sub ParseBitmapPush($$$) ##################################################################### # generate a pull function for an bitmap -sub ParseBitmapPull($$$) +sub ParseBitmapPull($$$$) { - my($self,$bitmap,$varname) = @_; + my($self,$bitmap,$ndr,$varname) = @_; my $type_fn = $bitmap->{BASE_TYPE}; my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); $self->pidl("$type_decl v;"); $self->start_flags($bitmap); - $self->pidl("NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));"); + $self->pidl("NDR_CHECK(ndr_pull_$type_fn($ndr, NDR_SCALARS, &v));"); $self->pidl("*$varname = v;"); $self->end_flags($bitmap); @@ -1474,38 +1474,38 @@ sub DeclareMemCtxVariables($$) } } -sub ParseStructPullPrimitives($$$$) +sub ParseStructPullPrimitives($$$$$) { - my($self,$struct,$varname,$env) = @_; + my($self,$struct,$ndr,$varname,$env) = @_; if (defined $struct->{SURROUNDING_ELEMENT}) { - $self->pidl("NDR_CHECK(ndr_pull_array_size(ndr, &$varname->$struct->{SURROUNDING_ELEMENT}->{NAME}));"); + $self->pidl("NDR_CHECK(ndr_pull_array_size($ndr, &$varname->$struct->{SURROUNDING_ELEMENT}->{NAME}));"); } - $self->pidl("NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));"); + $self->pidl("NDR_CHECK(ndr_pull_align($ndr, $struct->{ALIGN}));"); if (defined($struct->{PROPERTIES}{relative_base})) { # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, $varname, ndr->offset));"); + $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset1($ndr, $varname, $ndr->offset));"); } - $self->ParseElementPull($_, "ndr", $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); + $self->ParseElementPull($_, $ndr, $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); $self->add_deferred(); } -sub ParseStructPullDeferred($$$$) +sub ParseStructPullDeferred($$$$$) { - my ($self,$struct,$varname,$env) = @_; + my ($self,$struct,$ndr,$varname,$env) = @_; if (defined($struct->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, $varname));"); + $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset2($ndr, $varname));"); } foreach my $e (@{$struct->{ELEMENTS}}) { - $self->ParseElementPull($e, "ndr", $env, 0, 1); + $self->ParseElementPull($e, $ndr, $env, 0, 1); } $self->add_deferred(); @@ -1513,9 +1513,9 @@ sub ParseStructPullDeferred($$$$) ##################################################################### # parse a struct - pull side -sub ParseStructPull($$$) +sub ParseStructPull($$$$) { - my($self,$struct,$varname) = @_; + my($self,$struct,$ndr,$varname) = @_; return unless defined $struct->{ELEMENTS}; @@ -1532,12 +1532,12 @@ sub ParseStructPull($$$) $self->pidl("if (ndr_flags & NDR_SCALARS) {"); $self->indent; - $self->ParseStructPullPrimitives($struct,$varname,$env); + $self->ParseStructPullPrimitives($struct,$ndr,$varname,$env); $self->deindent; $self->pidl("}"); $self->pidl("if (ndr_flags & NDR_BUFFERS) {"); $self->indent; - $self->ParseStructPullDeferred($struct,$varname,$env); + $self->ParseStructPullDeferred($struct,$ndr,$varname,$env); $self->deindent; $self->pidl("}"); @@ -1736,15 +1736,15 @@ sub ParseUnionPrint($$$$) $self->end_flags($e); } -sub ParseUnionPullPrimitives($$$$) +sub ParseUnionPullPrimitives($$$$$) { - my ($self,$e,$varname,$switch_type) = @_; + my ($self,$e,$ndr,$varname,$switch_type) = @_; my $have_default = 0; if (defined($switch_type)) { - $self->pidl("NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));"); + $self->pidl("NDR_CHECK(ndr_pull_$switch_type($ndr, NDR_SCALARS, &_level));"); $self->pidl("if (_level != level) {"); - $self->pidl("\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $varname\", _level);"); + $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $varname\", _level);"); $self->pidl("}"); } @@ -1761,12 +1761,12 @@ sub ParseUnionPullPrimitives($$$$) $self->DeclarePtrVariables($el); $self->DeclareArrayVariables($el); if (defined($e->{PROPERTIES}{relative_base})) { - $self->pidl("NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));"); + $self->pidl("NDR_CHECK(ndr_pull_align($ndr, $el->{ALIGN}));"); # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, $varname, ndr->offset));"); + $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset1($ndr, $varname, $ndr->offset));"); } - $self->ParseElementPull($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); + $self->ParseElementPull($el, $ndr, {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); $self->deindent; } $self->pidl("break; }"); @@ -1774,21 +1774,21 @@ sub ParseUnionPullPrimitives($$$$) } if (! $have_default) { $self->pidl("default:"); - $self->pidl("\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); + $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); } $self->deindent; $self->pidl("}"); } -sub ParseUnionPullDeferred($$$) +sub ParseUnionPullDeferred($$$$) { - my ($self,$e,$varname) = @_; + my ($self,$e,$ndr,$varname) = @_; my $have_default = 0; if (defined($e->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, $varname));"); + $self->pidl("NDR_CHECK(ndr_pull_setup_relative_base_offset2($ndr, $varname));"); } $self->pidl("switch (level) {"); $self->indent; @@ -1800,7 +1800,7 @@ sub ParseUnionPullDeferred($$$) $self->pidl("$el->{CASE}:"); if ($el->{TYPE} ne "EMPTY") { $self->indent; - $self->ParseElementPull($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); + $self->ParseElementPull($el, $ndr, {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); $self->deindent; } $self->pidl("break;"); @@ -1808,7 +1808,7 @@ sub ParseUnionPullDeferred($$$) } if (! $have_default) { $self->pidl("default:"); - $self->pidl("\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); + $self->pidl("\treturn ndr_pull_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); } $self->deindent; $self->pidl("}"); @@ -1818,9 +1818,9 @@ sub ParseUnionPullDeferred($$$) ##################################################################### # parse a union - pull side -sub ParseUnionPull($$$) +sub ParseUnionPull($$$$) { - my ($self,$e,$varname) = @_; + my ($self,$e,$ndr,$varname) = @_; my $switch_type = $e->{SWITCH_TYPE}; $self->pidl("int level;"); @@ -1841,17 +1841,17 @@ sub ParseUnionPull($$$) $self->start_flags($e); - $self->pidl("level = ndr_pull_get_switch_value(ndr, $varname);"); + $self->pidl("level = ndr_pull_get_switch_value($ndr, $varname);"); $self->pidl("if (ndr_flags & NDR_SCALARS) {"); $self->indent; - $self->ParseUnionPullPrimitives($e,$varname,$switch_type); + $self->ParseUnionPullPrimitives($e,$ndr,$varname,$switch_type); $self->deindent; $self->pidl("}"); $self->pidl("if (ndr_flags & NDR_BUFFERS) {"); $self->indent; - $self->ParseUnionPullDeferred($e,$varname); + $self->ParseUnionPullDeferred($e,$ndr,$varname); $self->deindent; $self->pidl("}"); @@ -1892,11 +1892,11 @@ sub ParseTypedefPush($$$) ##################################################################### # parse a typedef - pull side -sub ParseTypedefPull($$$) +sub ParseTypedefPull($$$$) { - my($self,$e,$varname) = @_; + my($self,$e,$ndr,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($self, $e->{DATA}, $varname); + $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($self, $e->{DATA}, $ndr, $varname); } ##################################################################### @@ -2397,7 +2397,7 @@ sub ParseTypePull($$$$$) # save the old relative_base_offset $self->pidl("uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);") if defined(has_property($e, "relative_base")); - $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($self, $e, $varname); + $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($self, $e, "ndr", $varname); # restore the old relative_base_offset $self->pidl("ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base")); } -- cgit From c8ef2956c62ca6d804db40ac093638d67b479b71 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 19 Aug 2008 13:24:05 +0200 Subject: pidl/NDR::Parser: pass $ndr to ->PUSH_FN_BLOB() metze (This used to be commit 71b0d64866eb1a4f6dc73eeb57b5f0fe5d8a5780) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 86 ++++++++++++------------ 1 file changed, 43 insertions(+), 43 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index c5253d4e1b..3903074dd6 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1172,9 +1172,9 @@ sub ParsePtrPull($$$$$) $self->pidl("}"); } -sub ParseStructPushPrimitives($$$$) +sub ParseStructPushPrimitives($$$$$) { - my ($self, $struct, $varname, $env) = @_; + my ($self, $struct, $ndr, $varname, $env) = @_; # see if the structure contains a conformant array. If it # does, then it must be the last element of the structure, and @@ -1198,39 +1198,39 @@ sub ParseStructPushPrimitives($$$$) $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env, $e->{ORIGINAL}); } - $self->pidl("NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));"); + $self->pidl("NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));"); } else { - $self->pidl("NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, $varname->$e->{NAME})));"); + $self->pidl("NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, ndr_string_array_size($ndr, $varname->$e->{NAME})));"); } } - $self->pidl("NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));"); + $self->pidl("NDR_CHECK(ndr_push_align($ndr, $struct->{ALIGN}));"); if (defined($struct->{PROPERTIES}{relative_base})) { # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"); + $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset1($ndr, $varname, $ndr->offset));"); } - $self->ParseElementPush($_, "ndr", $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); + $self->ParseElementPush($_, $ndr, $env, 1, 0) foreach (@{$struct->{ELEMENTS}}); } -sub ParseStructPushDeferred($$$) +sub ParseStructPushDeferred($$$$) { - my ($self, $struct, $varname, $env) = @_; + my ($self, $struct, $ndr, $varname, $env) = @_; if (defined($struct->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"); + $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset2($ndr, $varname));"); } - $self->ParseElementPush($_, "ndr", $env, 0, 1) foreach (@{$struct->{ELEMENTS}}); + $self->ParseElementPush($_, $ndr, $env, 0, 1) foreach (@{$struct->{ELEMENTS}}); } ##################################################################### # parse a struct -sub ParseStructPush($$$) +sub ParseStructPush($$$$) { - my ($self, $struct, $varname) = @_; + my ($self, $struct, $ndr, $varname) = @_; return unless defined($struct->{ELEMENTS}); @@ -1244,13 +1244,13 @@ sub ParseStructPush($$$) $self->pidl("if (ndr_flags & NDR_SCALARS) {"); $self->indent; - $self->ParseStructPushPrimitives($struct, $varname, $env); + $self->ParseStructPushPrimitives($struct, $ndr, $varname, $env); $self->deindent; $self->pidl("}"); $self->pidl("if (ndr_flags & NDR_BUFFERS) {"); $self->indent; - $self->ParseStructPushDeferred($struct, $varname, $env); + $self->ParseStructPushDeferred($struct, $ndr, $varname, $env); $self->deindent; $self->pidl("}"); @@ -1259,13 +1259,13 @@ sub ParseStructPush($$$) ##################################################################### # generate a push function for an enum -sub ParseEnumPush($$$) +sub ParseEnumPush($$$$) { - my($self,$enum,$varname) = @_; + my($self,$enum,$ndr,$varname) = @_; my($type_fn) = $enum->{BASE_TYPE}; $self->start_flags($enum); - $self->pidl("NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, $varname));"); + $self->pidl("NDR_CHECK(ndr_push_$type_fn($ndr, NDR_SCALARS, $varname));"); $self->end_flags($enum); } @@ -1332,14 +1332,14 @@ $typefamily{ENUM} = { ##################################################################### # generate a push function for a bitmap -sub ParseBitmapPush($$$) +sub ParseBitmapPush($$$$) { - my($self,$bitmap,$varname) = @_; + my($self,$bitmap,$ndr,$varname) = @_; my($type_fn) = $bitmap->{BASE_TYPE}; $self->start_flags($bitmap); - $self->pidl("NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, $varname));"); + $self->pidl("NDR_CHECK(ndr_push_$type_fn($ndr, NDR_SCALARS, $varname));"); $self->end_flags($bitmap); } @@ -1592,16 +1592,16 @@ sub ParseUnionNdrSize($$$) $self->pidl("return ndr_size_union($varname, flags, level, (ndr_push_flags_fn_t)ndr_push_$name);"); } -sub ParseUnionPushPrimitives($$$) +sub ParseUnionPushPrimitives($$$$) { - my ($self, $e, $varname) = @_; + my ($self, $e, $ndr ,$varname) = @_; my $have_default = 0; - $self->pidl("int level = ndr_push_get_switch_value(ndr, $varname);"); + $self->pidl("int level = ndr_push_get_switch_value($ndr, $varname);"); if (defined($e->{SWITCH_TYPE})) { - $self->pidl("NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));"); + $self->pidl("NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}($ndr, NDR_SCALARS, level));"); } $self->pidl("switch (level) {"); @@ -1615,13 +1615,13 @@ sub ParseUnionPushPrimitives($$$) if ($el->{TYPE} ne "EMPTY") { $self->indent; if (defined($e->{PROPERTIES}{relative_base})) { - $self->pidl("NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));"); + $self->pidl("NDR_CHECK(ndr_push_align($ndr, $el->{ALIGN}));"); # set the current offset as base for relative pointers # and store it based on the toplevel struct/union - $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, $varname, ndr->offset));"); + $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset1($ndr, $varname, $ndr->offset));"); } $self->DeclareArrayVariables($el); - $self->ParseElementPush($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); + $self->ParseElementPush($el, $ndr, {$el->{NAME} => "$varname->$el->{NAME}"}, 1, 0); $self->deindent; } $self->pidl("break; }"); @@ -1629,23 +1629,23 @@ sub ParseUnionPushPrimitives($$$) } if (! $have_default) { $self->pidl("default:"); - $self->pidl("\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); + $self->pidl("\treturn ndr_push_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); } $self->deindent; $self->pidl("}"); } -sub ParseUnionPushDeferred($$$) +sub ParseUnionPushDeferred($$$$) { - my ($self,$e,$varname) = @_; + my ($self,$e,$ndr,$varname) = @_; my $have_default = 0; - $self->pidl("int level = ndr_push_get_switch_value(ndr, $varname);"); + $self->pidl("int level = ndr_push_get_switch_value($ndr, $varname);"); if (defined($e->{PROPERTIES}{relative_base})) { # retrieve the current offset as base for relative pointers # based on the toplevel struct/union - $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, $varname));"); + $self->pidl("NDR_CHECK(ndr_push_setup_relative_base_offset2($ndr, $varname));"); } $self->pidl("switch (level) {"); $self->indent; @@ -1657,7 +1657,7 @@ sub ParseUnionPushDeferred($$$) $self->pidl("$el->{CASE}:"); if ($el->{TYPE} ne "EMPTY") { $self->indent; - $self->ParseElementPush($el, "ndr", {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); + $self->ParseElementPush($el, $ndr, {$el->{NAME} => "$varname->$el->{NAME}"}, 0, 1); $self->deindent; } $self->pidl("break;"); @@ -1665,7 +1665,7 @@ sub ParseUnionPushDeferred($$$) } if (! $have_default) { $self->pidl("default:"); - $self->pidl("\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); + $self->pidl("\treturn ndr_push_error($ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);"); } $self->deindent; $self->pidl("}"); @@ -1673,21 +1673,21 @@ sub ParseUnionPushDeferred($$$) ##################################################################### # parse a union - push side -sub ParseUnionPush($$$) +sub ParseUnionPush($$$$) { - my ($self,$e,$varname) = @_; + my ($self,$e,$ndr,$varname) = @_; my $have_default = 0; $self->start_flags($e); $self->pidl("if (ndr_flags & NDR_SCALARS) {"); $self->indent; - $self->ParseUnionPushPrimitives($e, $varname); + $self->ParseUnionPushPrimitives($e, $ndr, $varname); $self->deindent; $self->pidl("}"); $self->pidl("if (ndr_flags & NDR_BUFFERS) {"); $self->indent; - $self->ParseUnionPushDeferred($e, $varname); + $self->ParseUnionPushDeferred($e, $ndr, $varname); $self->deindent; $self->pidl("}"); $self->end_flags($e); @@ -1883,11 +1883,11 @@ $typefamily{UNION} = { ##################################################################### # parse a typedef - push side -sub ParseTypedefPush($$$) +sub ParseTypedefPush($$$$) { - my($self,$e,$varname) = @_; + my($self,$e,$ndr,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($self, $e->{DATA}, $varname); + $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($self, $e->{DATA}, $ndr, $varname); } ##################################################################### @@ -2370,7 +2370,7 @@ sub ParseTypePush($$$$$) # save the old relative_base_offset $self->pidl("uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);") if defined(has_property($e, "relative_base")); - $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($self, $e, $varname); + $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($self, $e, "ndr", $varname); # restore the old relative_base_offset $self->pidl("ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base")); } -- cgit From ef7e12b914f4e4f53a230b96d6a2f9b25c68f961 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 19 Aug 2008 20:12:03 +0200 Subject: pidl/NDR::Parser: pass $ndr to ->PRINT_FN_BLOB() metze (This used to be commit a143806364051141604ebb40eb5a4ef72958b55f) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 86 ++++++++++++------------ 1 file changed, 43 insertions(+), 43 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 3903074dd6..20339e5a7d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -720,27 +720,27 @@ sub ParseDataPrint($$$$) ##################################################################### # print scalars in a structure element -sub ParseElementPrint($$$$) +sub ParseElementPrint($$$$$) { - my($self, $e, $var_name, $env) = @_; + my($self, $e, $ndr, $var_name, $env) = @_; return if (has_property($e, "noprint")); if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { - $self->pidl("ndr_print_$e->{REPRESENTATION_TYPE}(ndr, \"$e->{NAME}\", $var_name);"); + $self->pidl("ndr_print_$e->{REPRESENTATION_TYPE}($ndr, \"$e->{NAME}\", $var_name);"); return; } $var_name = append_prefix($e, $var_name); if (defined(my $value = has_property($e, "value"))) { - $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env, $e->{ORIGINAL}) . ":$var_name"; + $var_name = "($ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env, $e->{ORIGINAL}) . ":$var_name"; } foreach my $l (@{$e->{LEVELS}}) { if ($l->{TYPE} eq "POINTER") { - $self->pidl("ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);"); - $self->pidl("ndr->depth++;"); + $self->pidl("ndr_print_ptr($ndr, \"$e->{NAME}\", $var_name);"); + $self->pidl("$ndr->depth++;"); if ($l->{POINTER_TYPE} ne "ref") { $self->pidl("if ($var_name) {"); $self->indent; @@ -761,17 +761,17 @@ sub ParseElementPrint($$$$) } if (is_charset_array($e,$l)) { - $self->pidl("ndr_print_string(ndr, \"$e->{NAME}\", $var_name);"); + $self->pidl("ndr_print_string($ndr, \"$e->{NAME}\", $var_name);"); last; } elsif (has_fast_array($e, $l)) { my $nl = GetNextLevel($e, $l); - $self->pidl("ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);"); + $self->pidl("ndr_print_array_$nl->{DATA_TYPE}($ndr, \"$e->{NAME}\", $var_name, $length);"); last; } else { my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}"; - $self->pidl("ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", (int)$length);"); - $self->pidl("ndr->depth++;"); + $self->pidl("$ndr->print($ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", (int)$length);"); + $self->pidl("$ndr->depth++;"); $self->pidl("for ($counter=0;$counter<$length;$counter++) {"); $self->indent; $self->pidl("char *idx_$l->{LEVEL_INDEX}=NULL;"); @@ -785,7 +785,7 @@ sub ParseElementPrint($$$$) } elsif ($l->{TYPE} eq "SWITCH") { my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return;"), check_fully_dereferenced($e, $env)); - $self->pidl("ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);"); + $self->pidl("ndr_print_set_switch_value($ndr, " . get_pointer_to($var_name) . ", $switch_var);"); } } @@ -795,7 +795,7 @@ sub ParseElementPrint($$$$) $self->deindent; $self->pidl("}"); } - $self->pidl("ndr->depth--;"); + $self->pidl("$ndr->depth--;"); } elsif (($l->{TYPE} eq "ARRAY") and not is_charset_array($e,$l) and not has_fast_array($e,$l)) { @@ -804,7 +804,7 @@ sub ParseElementPrint($$$$) $self->pidl("}"); $self->deindent; $self->pidl("}"); - $self->pidl("ndr->depth--;"); + $self->pidl("$ndr->depth--;"); } } } @@ -1287,9 +1287,9 @@ sub ParseEnumPull($$$$) ##################################################################### # generate a print function for an enum -sub ParseEnumPrint($$$$) +sub ParseEnumPrint($$$$$) { - my($self,$enum,$name,$varname) = @_; + my($self,$enum,$ndr,$name,$varname) = @_; $self->pidl("const char *val = NULL;"); $self->pidl(""); @@ -1311,7 +1311,7 @@ sub ParseEnumPrint($$$$) $self->deindent; $self->pidl("}"); - $self->pidl("ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, $varname);"); + $self->pidl("ndr_print_enum($ndr, name, \"$enum->{TYPE}\", val, $varname);"); $self->end_flags($enum); } @@ -1362,9 +1362,9 @@ sub ParseBitmapPull($$$$) ##################################################################### # generate a print function for an bitmap -sub ParseBitmapPrintElement($$$$$) +sub ParseBitmapPrintElement($$$$$$) { - my($self,$e,$bitmap,$name,$varname) = @_; + my($self,$e,$bitmap,$ndr,$name,$varname) = @_; my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); my($type_fn) = $bitmap->{BASE_TYPE}; my($flag); @@ -1375,26 +1375,26 @@ sub ParseBitmapPrintElement($$$$$) die "Bitmap: \"$name\" invalid Flag: \"$e\""; } - $self->pidl("ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, $varname);"); + $self->pidl("ndr_print_bitmap_flag($ndr, sizeof($type_decl), \"$flag\", $flag, $varname);"); } ##################################################################### # generate a print function for an bitmap -sub ParseBitmapPrint($$$$) +sub ParseBitmapPrint($$$$$) { - my($self,$bitmap,$name,$varname) = @_; + my($self,$bitmap,$ndr,$name,$varname) = @_; my($type_decl) = mapTypeName($bitmap->{TYPE}); my($type_fn) = $bitmap->{BASE_TYPE}; $self->start_flags($bitmap); - $self->pidl("ndr_print_$type_fn(ndr, name, $varname);"); + $self->pidl("ndr_print_$type_fn($ndr, name, $varname);"); - $self->pidl("ndr->depth++;"); + $self->pidl("$ndr->depth++;"); foreach my $e (@{$bitmap->{ELEMENTS}}) { - $self->ParseBitmapPrintElement($e, $bitmap, $name, $varname); + $self->ParseBitmapPrintElement($e, $bitmap, $ndr, $name, $varname); } - $self->pidl("ndr->depth--;"); + $self->pidl("$ndr->depth--;"); $self->end_flags($bitmap); } @@ -1415,9 +1415,9 @@ $typefamily{BITMAP} = { ##################################################################### # generate a struct print function -sub ParseStructPrint($$$$) +sub ParseStructPrint($$$$$) { - my($self,$struct,$name,$varname) = @_; + my($self,$struct,$ndr,$name,$varname) = @_; return unless defined $struct->{ELEMENTS}; @@ -1425,15 +1425,15 @@ sub ParseStructPrint($$$$) $self->DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}}); - $self->pidl("ndr_print_struct(ndr, name, \"$name\");"); + $self->pidl("ndr_print_struct($ndr, name, \"$name\");"); $self->start_flags($struct); - $self->pidl("ndr->depth++;"); + $self->pidl("$ndr->depth++;"); - $self->ParseElementPrint($_, $env->{$_->{NAME}}, $env) + $self->ParseElementPrint($_, $ndr, $env->{$_->{NAME}}, $env) foreach (@{$struct->{ELEMENTS}}); - $self->pidl("ndr->depth--;"); + $self->pidl("$ndr->depth--;"); $self->end_flags($struct); } @@ -1695,9 +1695,9 @@ sub ParseUnionPush($$$$) ##################################################################### # print a union -sub ParseUnionPrint($$$$) +sub ParseUnionPrint($$$$$) { - my ($self,$e,$name,$varname) = @_; + my ($self,$e,$ndr,$name,$varname) = @_; my $have_default = 0; $self->pidl("int level;"); @@ -1707,9 +1707,9 @@ sub ParseUnionPrint($$$$) $self->start_flags($e); - $self->pidl("level = ndr_print_get_switch_value(ndr, $varname);"); + $self->pidl("level = ndr_print_get_switch_value($ndr, $varname);"); - $self->pidl("ndr_print_union(ndr, name, level, \"$name\");"); + $self->pidl("ndr_print_union($ndr, name, level, \"$name\");"); $self->pidl("switch (level) {"); $self->indent; @@ -1720,7 +1720,7 @@ sub ParseUnionPrint($$$$) $self->pidl("$el->{CASE}:"); if ($el->{TYPE} ne "EMPTY") { $self->indent; - $self->ParseElementPrint($el, "$varname->$el->{NAME}", {}); + $self->ParseElementPrint($el, $ndr, "$varname->$el->{NAME}", {}); $self->deindent; } $self->pidl("break;"); @@ -1728,7 +1728,7 @@ sub ParseUnionPrint($$$$) } if (! $have_default) { $self->pidl("default:"); - $self->pidl("\tndr_print_bad_level(ndr, name, level);"); + $self->pidl("\tndr_print_bad_level($ndr, name, level);"); } $self->deindent; $self->pidl("}"); @@ -1901,11 +1901,11 @@ sub ParseTypedefPull($$$$) ##################################################################### # parse a typedef - print side -sub ParseTypedefPrint($$$$) +sub ParseTypedefPrint($$$$$) { - my($self,$e,$name,$varname) = @_; + my($self,$e,$ndr,$name,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($self, $e->{DATA}, $name, $varname); + $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($self, $e->{DATA}, $ndr, $name, $varname); } ##################################################################### @@ -1973,7 +1973,7 @@ sub ParseFunctionPrint($$) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - $self->ParseElementPrint($e, $env->{$e->{NAME}}, $env); + $self->ParseElementPrint($e, "ndr", $env->{$e->{NAME}}, $env); } } $self->pidl("ndr->depth--;"); @@ -1988,7 +1988,7 @@ sub ParseFunctionPrint($$) $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - $self->ParseElementPrint($e, $env->{$e->{NAME}}, $env); + $self->ParseElementPrint($e, "ndr", $env->{$e->{NAME}}, $env); } } if ($fn->{RETURN_TYPE}) { @@ -2423,7 +2423,7 @@ sub ParseTypePrint($$$) { my ($self, $e, $varname) = @_; - $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($self, $e, $e->{NAME}, $varname); + $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($self, $e, "ndr", $e->{NAME}, $varname); } sub ParseTypePrintFunction($$$) -- cgit From b999de0689c31213c41aeaa531180737788d7283 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 19 Aug 2008 20:27:15 +0200 Subject: pidl/NDR::Parser: pass down $ndr from the top functions metze (This used to be commit b01d7457fa5b3572989b821f04e023fd9abd0d52) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 59 +++++++++++++----------- 1 file changed, 32 insertions(+), 27 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 20339e5a7d..4be12c482d 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -702,19 +702,19 @@ sub need_pointer_to($$$) return 0; } -sub ParseDataPrint($$$$) +sub ParseDataPrint($$$$$) { - my ($self, $e, $l, $var_name) = @_; - + my ($self, $e, $l, $ndr, $var_name) = @_; + if (not ref($l->{DATA_TYPE}) or defined($l->{DATA_TYPE}->{NAME})) { if (need_pointer_to($e, $l, 1)) { $var_name = get_pointer_to($var_name); } - $self->pidl(TypeFunctionName("ndr_print", $l->{DATA_TYPE})."(ndr, \"$e->{NAME}\", $var_name);"); + $self->pidl(TypeFunctionName("ndr_print", $l->{DATA_TYPE})."($ndr, \"$e->{NAME}\", $var_name);"); } else { - $self->ParseTypePrint($l->{DATA_TYPE}, $var_name); + $self->ParseTypePrint($l->{DATA_TYPE}, $ndr, $var_name); } } @@ -781,7 +781,7 @@ sub ParseElementPrint($$$$$) $var_name = get_array_element($var_name, $counter); } } elsif ($l->{TYPE} eq "DATA") { - $self->ParseDataPrint($e, $l, $var_name); + $self->ParseDataPrint($e, $l, $ndr, $var_name); } elsif ($l->{TYPE} eq "SWITCH") { my $switch_var = ParseExprExt($l->{SWITCH_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->pidl(shift); }, "return;"), check_fully_dereferenced($e, $env)); @@ -861,7 +861,7 @@ sub ParseDataPull($$$$$$$) $self->pidl("}"); } } else { - $self->ParseTypePull($l->{DATA_TYPE}, $var_name, $primitives, $deferred); + $self->ParseTypePull($l->{DATA_TYPE}, $ndr, $var_name, $primitives, $deferred); } } @@ -880,7 +880,7 @@ sub ParseDataPush($$$$$$$) $self->pidl("NDR_CHECK(".TypeFunctionName("ndr_push", $l->{DATA_TYPE})."($ndr, $ndr_flags, $var_name));"); } else { - $self->ParseTypePush($l->{DATA_TYPE}, $var_name, $primitives, $deferred); + $self->ParseTypePush($l->{DATA_TYPE}, $ndr, $var_name, $primitives, $deferred); } } @@ -2364,81 +2364,86 @@ sub HeaderInterface($$$) } -sub ParseTypePush($$$$$) +sub ParseTypePush($$$$$$) { - my ($self,$e,$varname, $primitives, $deferred) = @_; + my ($self,$e, $ndr, $varname, $primitives, $deferred) = @_; # save the old relative_base_offset - $self->pidl("uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);") if defined(has_property($e, "relative_base")); - $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($self, $e, "ndr", $varname); + $self->pidl("uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset($ndr);") if defined(has_property($e, "relative_base")); + $typefamily{$e->{TYPE}}->{PUSH_FN_BODY}->($self, $e, $ndr, $varname); # restore the old relative_base_offset - $self->pidl("ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base")); + $self->pidl("ndr_push_restore_relative_base_offset($ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base")); } sub ParseTypePushFunction($$$) { my ($self, $e, $varname) = @_; + my $ndr = "ndr"; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "push", $e->{NAME}, $varname); - $self->fn_declare("push", $e, "enum ndr_err_code ".TypeFunctionName("ndr_push", $e)."(struct ndr_push *ndr, int ndr_flags, $args)") or return; + + $self->fn_declare("push", $e, "enum ndr_err_code ".TypeFunctionName("ndr_push", $e)."(struct ndr_push *$ndr, int ndr_flags, $args)") or return; $self->pidl("{"); $self->indent; - $self->ParseTypePush($e, $varname, 1, 1); + $self->ParseTypePush($e, $ndr, $varname, 1, 1); $self->pidl("return NDR_ERR_SUCCESS;"); $self->deindent; $self->pidl("}"); $self->pidl("");; } -sub ParseTypePull($$$$$) +sub ParseTypePull($$$$$$) { - my ($self, $e, $varname, $primitives, $deferred) = @_; + my ($self, $e, $ndr, $varname, $primitives, $deferred) = @_; # save the old relative_base_offset - $self->pidl("uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);") if defined(has_property($e, "relative_base")); - $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($self, $e, "ndr", $varname); + $self->pidl("uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset($ndr);") if defined(has_property($e, "relative_base")); + $typefamily{$e->{TYPE}}->{PULL_FN_BODY}->($self, $e, $ndr, $varname); # restore the old relative_base_offset - $self->pidl("ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base")); + $self->pidl("ndr_pull_restore_relative_base_offset($ndr, _save_relative_base_offset);") if defined(has_property($e, "relative_base")); } sub ParseTypePullFunction($$) { my ($self, $e, $varname) = @_; + my $ndr = "ndr"; my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "pull", $e->{NAME}, $varname); - $self->fn_declare("pull", $e, "enum ndr_err_code ".TypeFunctionName("ndr_pull", $e)."(struct ndr_pull *ndr, int ndr_flags, $args)") or return; + $self->fn_declare("pull", $e, "enum ndr_err_code ".TypeFunctionName("ndr_pull", $e)."(struct ndr_pull *$ndr, int ndr_flags, $args)") or return; $self->pidl("{"); $self->indent; - $self->ParseTypePull($e, $varname, 1, 1); + $self->ParseTypePull($e, $ndr, $varname, 1, 1); $self->pidl("return NDR_ERR_SUCCESS;"); $self->deindent; $self->pidl("}"); $self->pidl(""); } -sub ParseTypePrint($$$) +sub ParseTypePrint($$$$) { - my ($self, $e, $varname) = @_; + my ($self, $e, $ndr, $varname) = @_; - $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($self, $e, "ndr", $e->{NAME}, $varname); + $typefamily{$e->{TYPE}}->{PRINT_FN_BODY}->($self, $e, $ndr, $e->{NAME}, $varname); } sub ParseTypePrintFunction($$$) { my ($self, $e, $varname) = @_; + my $ndr = "ndr"; + my $args = $typefamily{$e->{TYPE}}->{DECL}->($e, "print", $e->{NAME}, $varname); $self->pidl_hdr("void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *ndr, const char *name, $args);"); return if (has_property($e, "noprint")); - $self->pidl("_PUBLIC_ void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *ndr, const char *name, $args)"); + $self->pidl("_PUBLIC_ void ".TypeFunctionName("ndr_print", $e)."(struct ndr_print *$ndr, const char *name, $args)"); $self->pidl("{"); $self->indent; - $self->ParseTypePrint($e, $varname); + $self->ParseTypePrint($e, $ndr, $varname); $self->deindent; $self->pidl("}"); $self->pidl(""); -- cgit From 85fde41609593ebe9b52063f7612e6a44b762faf Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 19 Aug 2008 20:34:00 +0200 Subject: pidl/NDR::Parser: use my $ndr = "ndr" in the remaining top functions metze (This used to be commit ce83f4bb596fad23000acc1f6691669e2f2cfe1b) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 55 +++++++++++++----------- 1 file changed, 29 insertions(+), 26 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 4be12c482d..bb2c62a895 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -1944,12 +1944,13 @@ $typefamily{TYPEDEF} = { sub ParseFunctionPrint($$) { my($self, $fn) = @_; + my $ndr = "ndr"; - $self->pidl_hdr("void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r);"); + $self->pidl_hdr("void ndr_print_$fn->{NAME}(struct ndr_print *$ndr, const char *name, int flags, const struct $fn->{NAME} *r);"); return if has_property($fn, "noprint"); - $self->pidl("_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)"); + $self->pidl("_PUBLIC_ void ndr_print_$fn->{NAME}(struct ndr_print *$ndr, const char *name, int flags, const struct $fn->{NAME} *r)"); $self->pidl("{"); $self->indent; @@ -1957,48 +1958,48 @@ sub ParseFunctionPrint($$) $self->DeclareArrayVariables($e); } - $self->pidl("ndr_print_struct(ndr, name, \"$fn->{NAME}\");"); - $self->pidl("ndr->depth++;"); + $self->pidl("ndr_print_struct($ndr, name, \"$fn->{NAME}\");"); + $self->pidl("$ndr->depth++;"); $self->pidl("if (flags & NDR_SET_VALUES) {"); - $self->pidl("\tndr->flags |= LIBNDR_PRINT_SET_VALUES;"); + $self->pidl("\t$ndr->flags |= LIBNDR_PRINT_SET_VALUES;"); $self->pidl("}"); $self->pidl("if (flags & NDR_IN) {"); $self->indent; - $self->pidl("ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");"); - $self->pidl("ndr->depth++;"); + $self->pidl("ndr_print_struct($ndr, \"in\", \"$fn->{NAME}\");"); + $self->pidl("$ndr->depth++;"); my $env = GenerateFunctionInEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - $self->ParseElementPrint($e, "ndr", $env->{$e->{NAME}}, $env); + $self->ParseElementPrint($e, $ndr, $env->{$e->{NAME}}, $env); } } - $self->pidl("ndr->depth--;"); + $self->pidl("$ndr->depth--;"); $self->deindent; $self->pidl("}"); $self->pidl("if (flags & NDR_OUT) {"); $self->indent; - $self->pidl("ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");"); - $self->pidl("ndr->depth++;"); + $self->pidl("ndr_print_struct($ndr, \"out\", \"$fn->{NAME}\");"); + $self->pidl("$ndr->depth++;"); $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - $self->ParseElementPrint($e, "ndr", $env->{$e->{NAME}}, $env); + $self->ParseElementPrint($e, $ndr, $env->{$e->{NAME}}, $env); } } if ($fn->{RETURN_TYPE}) { - $self->pidl("ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);"); + $self->pidl("ndr_print_$fn->{RETURN_TYPE}($ndr, \"result\", r->out.result);"); } - $self->pidl("ndr->depth--;"); + $self->pidl("$ndr->depth--;"); $self->deindent; $self->pidl("}"); - $self->pidl("ndr->depth--;"); + $self->pidl("$ndr->depth--;"); $self->deindent; $self->pidl("}"); $self->pidl(""); @@ -2009,8 +2010,9 @@ sub ParseFunctionPrint($$) sub ParseFunctionPush($$) { my($self, $fn) = @_; + my $ndr = "ndr"; - $self->fn_declare("push", $fn, "enum ndr_err_code ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)") or return; + $self->fn_declare("push", $fn, "enum ndr_err_code ndr_push_$fn->{NAME}(struct ndr_push *$ndr, int flags, const struct $fn->{NAME} *r)") or return; return if has_property($fn, "nopush"); @@ -2030,7 +2032,7 @@ sub ParseFunctionPush($$) foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/in/,@{$e->{DIRECTION}})) { - $self->ParseElementPush($e, "ndr", $env, 1, 1); + $self->ParseElementPush($e, $ndr, $env, 1, 1); } } @@ -2043,12 +2045,12 @@ sub ParseFunctionPush($$) $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { if (grep(/out/,@{$e->{DIRECTION}})) { - $self->ParseElementPush($e, "ndr", $env, 1, 1); + $self->ParseElementPush($e, $ndr, $env, 1, 1); } } if ($fn->{RETURN_TYPE}) { - $self->pidl("NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));"); + $self->pidl("NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}($ndr, NDR_SCALARS, r->out.result));"); } $self->deindent; @@ -2086,9 +2088,10 @@ sub AllocateArrayLevel($$$$$$) sub ParseFunctionPull($$) { my($self,$fn) = @_; + my $ndr = "ndr"; # pull function args - $self->fn_declare("pull", $fn, "enum ndr_err_code ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)") or return; + $self->fn_declare("pull", $fn, "enum ndr_err_code ndr_pull_$fn->{NAME}(struct ndr_pull *$ndr, int flags, struct $fn->{NAME} *r)") or return; $self->pidl("{"); $self->indent; @@ -2125,7 +2128,7 @@ sub ParseFunctionPull($$) foreach my $e (@{$fn->{ELEMENTS}}) { next unless (grep(/in/, @{$e->{DIRECTION}})); - $self->ParseElementPull($e, "ndr", $env, 1, 1); + $self->ParseElementPull($e, $ndr, $env, 1, 1); } # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's @@ -2143,9 +2146,9 @@ sub ParseFunctionPull($$) if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") { my $size = ParseExprExt($e->{LEVELS}[1]->{SIZE_IS}, $env, $e->{ORIGINAL}, check_null_pointer($e, $env, sub { $self->pidl(shift); }, - "return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"), + "return ndr_pull_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL Pointer for size_is()\");"), check_fully_dereferenced($e, $env)); - $self->pidl("NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);"); + $self->pidl("NDR_PULL_ALLOC_N($ndr, r->out.$e->{NAME}, $size);"); if (grep(/in/, @{$e->{DIRECTION}})) { $self->pidl("memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, ($size) * sizeof(*r->in.$e->{NAME}));"); @@ -2153,7 +2156,7 @@ sub ParseFunctionPull($$) $self->pidl("memset(r->out.$e->{NAME}, 0, ($size) * sizeof(*r->out.$e->{NAME}));"); } } else { - $self->pidl("NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});"); + $self->pidl("NDR_PULL_ALLOC($ndr, r->out.$e->{NAME});"); if (grep(/in/, @{$e->{DIRECTION}})) { $self->pidl("*r->out.$e->{NAME} = *r->in.$e->{NAME};"); @@ -2173,11 +2176,11 @@ sub ParseFunctionPull($$) $env = GenerateFunctionOutEnv($fn); foreach my $e (@{$fn->{ELEMENTS}}) { next unless grep(/out/, @{$e->{DIRECTION}}); - $self->ParseElementPull($e, "ndr", $env, 1, 1); + $self->ParseElementPull($e, $ndr, $env, 1, 1); } if ($fn->{RETURN_TYPE}) { - $self->pidl("NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));"); + $self->pidl("NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}($ndr, NDR_SCALARS, &r->out.result));"); } $self->add_deferred(); -- cgit From 98450a5a7c02d452999d31017949ddf7591a54fd Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 19 Aug 2008 20:48:53 +0200 Subject: pidl/NDR::Parser: pass $ndr to ParsePtrPush() metze (This used to be commit 77571cd7c74dfaa93e58f047530df369ae293ffd) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index bb2c62a895..5909a9b9d0 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -543,7 +543,7 @@ sub ParseElementPushLevel $self->ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1); $self->ParseSubcontextPushEnd($e, $l, $ndr, $env); } elsif ($l->{TYPE} eq "POINTER") { - $self->ParsePtrPush($e, $l, $var_name); + $self->ParsePtrPush($e, $l, $ndr, $var_name); } elsif ($l->{TYPE} eq "ARRAY") { my $length = $self->ParseArrayPushHeader($e, $l, $ndr, $var_name, $env); @@ -647,25 +647,25 @@ sub ParseElementPush($$$$$$) ##################################################################### # parse a pointer in a struct element or function -sub ParsePtrPush($$$$) +sub ParsePtrPush($$$$$) { - my ($self,$e,$l,$var_name) = @_; + my ($self,$e,$l,$ndr,$var_name) = @_; if ($l->{POINTER_TYPE} eq "ref") { $self->pidl("if ($var_name == NULL) {"); $self->indent; - $self->pidl("return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, \"NULL [ref] pointer\");"); + $self->pidl("return ndr_push_error($ndr, NDR_ERR_INVALID_POINTER, \"NULL [ref] pointer\");"); $self->deindent; $self->pidl("}"); if ($l->{LEVEL} eq "EMBEDDED") { $self->pidl("NDR_CHECK(ndr_push_ref_ptr(ndr));"); } } elsif ($l->{POINTER_TYPE} eq "relative") { - $self->pidl("NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));"); + $self->pidl("NDR_CHECK(ndr_push_relative_ptr1($ndr, $var_name));"); } elsif ($l->{POINTER_TYPE} eq "unique") { - $self->pidl("NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));"); + $self->pidl("NDR_CHECK(ndr_push_unique_ptr($ndr, $var_name));"); } elsif ($l->{POINTER_TYPE} eq "full") { - $self->pidl("NDR_CHECK(ndr_push_full_ptr(ndr, $var_name));"); + $self->pidl("NDR_CHECK(ndr_push_full_ptr($ndr, $var_name));"); } else { die("Unhandled pointer type $l->{POINTER_TYPE}"); } -- cgit From ecc1c3a27cc5bba96879aa8485d7abce1103a154 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 19 Aug 2008 20:51:27 +0200 Subject: pidl/NDR::Parser: pass $ndr to ParseMemCtxPull*() metze (This used to be commit c3921c7b4e7a3b51b97a2afb688271a8ae403105) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 5909a9b9d0..d6acf6bdcb 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -936,9 +936,9 @@ sub ParseMemCtxPullFlags($$$$) return $mem_flags; } -sub ParseMemCtxPullStart($$$$) +sub ParseMemCtxPullStart($$$$$) { - my ($self, $e, $l, $ptr_name) = @_; + my ($self, $e, $l, $ndr, $ptr_name) = @_; my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; my $mem_c_ctx = $ptr_name; @@ -946,20 +946,20 @@ sub ParseMemCtxPullStart($$$$) return unless defined($mem_c_flags); - $self->pidl("$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);"); - $self->pidl("NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);"); + $self->pidl("$mem_r_ctx = NDR_PULL_GET_MEM_CTX($ndr);"); + $self->pidl("NDR_PULL_SET_MEM_CTX($ndr, $mem_c_ctx, $mem_c_flags);"); } -sub ParseMemCtxPullEnd($$$) +sub ParseMemCtxPullEnd($$$$) { - my ($self, $e, $l) = @_; + my ($self, $e, $l, $ndr) = @_; my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}"; my $mem_r_flags = $self->ParseMemCtxPullFlags($e, $l); return unless defined($mem_r_flags); - $self->pidl("NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);"); + $self->pidl("NDR_PULL_SET_MEM_CTX($ndr, $mem_r_ctx, $mem_r_flags);"); } sub CheckStringTerminator($$$$$) @@ -1027,12 +1027,12 @@ sub ParseElementPullLevel } } - $self->ParseMemCtxPullStart($e, $l, $var_name); + $self->ParseMemCtxPullStart($e, $l, $ndr, $var_name); $var_name = get_value_of($var_name); $self->ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1); - $self->ParseMemCtxPullEnd($e,$l); + $self->ParseMemCtxPullEnd($e, $l, $ndr); if ($l->{POINTER_TYPE} ne "ref") { if ($l->{POINTER_TYPE} eq "relative") { @@ -1049,7 +1049,7 @@ sub ParseElementPullLevel $var_name = get_array_element($var_name, $counter); - $self->ParseMemCtxPullStart($e, $l, $array_name); + $self->ParseMemCtxPullStart($e, $l, $ndr, $array_name); if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) { my $nl = GetNextLevel($e,$l); @@ -1073,7 +1073,7 @@ sub ParseElementPullLevel $self->pidl("}"); } - $self->ParseMemCtxPullEnd($e, $l); + $self->ParseMemCtxPullEnd($e, $l, $ndr); } elsif ($l->{TYPE} eq "SWITCH") { $self->ParseElementPullLevel($e, GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred); -- cgit From 8e6161d1b237a9967cbca01fcc4e31b6a84109d2 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 19 Aug 2008 20:53:18 +0200 Subject: pidl/NDR::Parser: pass $ndr to ->start_flags() and ->end_flags() metze (This used to be commit bdff9728cc1c8b5fe5a29040e092a8e48603725b) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 70 ++++++++++++------------ 1 file changed, 35 insertions(+), 35 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index d6acf6bdcb..8053e5004e 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -158,26 +158,26 @@ sub fn_declare($$$$) ################################################################### # setup any special flags for an element or structure -sub start_flags($$) +sub start_flags($$$) { - my ($self, $e) = @_; + my ($self, $e, $ndr) = @_; my $flags = has_property($e, "flag"); if (defined $flags) { $self->pidl("{"); $self->indent; - $self->pidl("uint32_t _flags_save_$e->{TYPE} = ndr->flags;"); - $self->pidl("ndr_set_flags(&ndr->flags, $flags);"); + $self->pidl("uint32_t _flags_save_$e->{TYPE} = $ndr->flags;"); + $self->pidl("ndr_set_flags(&$ndr->flags, $flags);"); } } ################################################################### # end any special flags for an element or structure -sub end_flags($$) +sub end_flags($$$) { - my ($self, $e) = @_; + my ($self, $e, $ndr) = @_; my $flags = has_property($e, "flag"); if (defined $flags) { - $self->pidl("ndr->flags = _flags_save_$e->{TYPE};"); + $self->pidl("$ndr->flags = _flags_save_$e->{TYPE};"); $self->deindent; $self->pidl("}"); } @@ -629,7 +629,7 @@ sub ParseElementPush($$$$$$) $var_name = append_prefix($e, $var_name); - $self->start_flags($e); + $self->start_flags($e, $ndr); if (defined(my $value = has_property($e, "value"))) { $var_name = ParseExpr($value, $env, $e->{ORIGINAL}); @@ -637,7 +637,7 @@ sub ParseElementPush($$$$$$) $self->ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred); - $self->end_flags($e); + $self->end_flags($e, $ndr); if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { $self->deindent; @@ -1103,11 +1103,11 @@ sub ParseElementPull($$$$$$) $var_name = append_prefix($e, $var_name); - $self->start_flags($e); + $self->start_flags($e, $ndr); $self->ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred); - $self->end_flags($e); + $self->end_flags($e, $ndr); # Representation type is different from transmit_as if ($e->{REPRESENTATION_TYPE} ne $e->{TYPE}) { @@ -1240,7 +1240,7 @@ sub ParseStructPush($$$$) $self->DeclareArrayVariables($_) foreach (@{$struct->{ELEMENTS}}); - $self->start_flags($struct); + $self->start_flags($struct, $ndr); $self->pidl("if (ndr_flags & NDR_SCALARS) {"); $self->indent; @@ -1254,7 +1254,7 @@ sub ParseStructPush($$$$) $self->deindent; $self->pidl("}"); - $self->end_flags($struct); + $self->end_flags($struct, $ndr); } ##################################################################### @@ -1264,9 +1264,9 @@ sub ParseEnumPush($$$$) my($self,$enum,$ndr,$varname) = @_; my($type_fn) = $enum->{BASE_TYPE}; - $self->start_flags($enum); + $self->start_flags($enum, $ndr); $self->pidl("NDR_CHECK(ndr_push_$type_fn($ndr, NDR_SCALARS, $varname));"); - $self->end_flags($enum); + $self->end_flags($enum, $ndr); } ##################################################################### @@ -1278,11 +1278,11 @@ sub ParseEnumPull($$$$) my($type_v_decl) = mapTypeName($type_fn); $self->pidl("$type_v_decl v;"); - $self->start_flags($enum); + $self->start_flags($enum, $ndr); $self->pidl("NDR_CHECK(ndr_pull_$type_fn($ndr, NDR_SCALARS, &v));"); $self->pidl("*$varname = v;"); - $self->end_flags($enum); + $self->end_flags($enum, $ndr); } ##################################################################### @@ -1294,7 +1294,7 @@ sub ParseEnumPrint($$$$$) $self->pidl("const char *val = NULL;"); $self->pidl(""); - $self->start_flags($enum); + $self->start_flags($enum, $ndr); $self->pidl("switch ($varname) {"); $self->indent; @@ -1313,7 +1313,7 @@ sub ParseEnumPrint($$$$$) $self->pidl("ndr_print_enum($ndr, name, \"$enum->{TYPE}\", val, $varname);"); - $self->end_flags($enum); + $self->end_flags($enum, $ndr); } sub DeclEnum($$$$) @@ -1337,11 +1337,11 @@ sub ParseBitmapPush($$$$) my($self,$bitmap,$ndr,$varname) = @_; my($type_fn) = $bitmap->{BASE_TYPE}; - $self->start_flags($bitmap); + $self->start_flags($bitmap, $ndr); $self->pidl("NDR_CHECK(ndr_push_$type_fn($ndr, NDR_SCALARS, $varname));"); - $self->end_flags($bitmap); + $self->end_flags($bitmap, $ndr); } ##################################################################### @@ -1353,11 +1353,11 @@ sub ParseBitmapPull($$$$) my($type_decl) = mapTypeName($bitmap->{BASE_TYPE}); $self->pidl("$type_decl v;"); - $self->start_flags($bitmap); + $self->start_flags($bitmap, $ndr); $self->pidl("NDR_CHECK(ndr_pull_$type_fn($ndr, NDR_SCALARS, &v));"); $self->pidl("*$varname = v;"); - $self->end_flags($bitmap); + $self->end_flags($bitmap, $ndr); } ##################################################################### @@ -1386,7 +1386,7 @@ sub ParseBitmapPrint($$$$$) my($type_decl) = mapTypeName($bitmap->{TYPE}); my($type_fn) = $bitmap->{BASE_TYPE}; - $self->start_flags($bitmap); + $self->start_flags($bitmap, $ndr); $self->pidl("ndr_print_$type_fn($ndr, name, $varname);"); @@ -1396,7 +1396,7 @@ sub ParseBitmapPrint($$$$$) } $self->pidl("$ndr->depth--;"); - $self->end_flags($bitmap); + $self->end_flags($bitmap, $ndr); } sub DeclBitmap($$$$) @@ -1427,7 +1427,7 @@ sub ParseStructPrint($$$$$) $self->pidl("ndr_print_struct($ndr, name, \"$name\");"); - $self->start_flags($struct); + $self->start_flags($struct, $ndr); $self->pidl("$ndr->depth++;"); @@ -1435,7 +1435,7 @@ sub ParseStructPrint($$$$$) foreach (@{$struct->{ELEMENTS}}); $self->pidl("$ndr->depth--;"); - $self->end_flags($struct); + $self->end_flags($struct, $ndr); } sub DeclarePtrVariables($$) @@ -1526,7 +1526,7 @@ sub ParseStructPull($$$$) $self->DeclareMemCtxVariables($e); } - $self->start_flags($struct); + $self->start_flags($struct, $ndr); my $env = GenerateStructEnv($struct, $varname); @@ -1541,7 +1541,7 @@ sub ParseStructPull($$$$) $self->deindent; $self->pidl("}"); - $self->end_flags($struct); + $self->end_flags($struct, $ndr); } ##################################################################### @@ -1678,7 +1678,7 @@ sub ParseUnionPush($$$$) my ($self,$e,$ndr,$varname) = @_; my $have_default = 0; - $self->start_flags($e); + $self->start_flags($e, $ndr); $self->pidl("if (ndr_flags & NDR_SCALARS) {"); $self->indent; @@ -1690,7 +1690,7 @@ sub ParseUnionPush($$$$) $self->ParseUnionPushDeferred($e, $ndr, $varname); $self->deindent; $self->pidl("}"); - $self->end_flags($e); + $self->end_flags($e, $ndr); } ##################################################################### @@ -1705,7 +1705,7 @@ sub ParseUnionPrint($$$$$) $self->DeclareArrayVariables($el); } - $self->start_flags($e); + $self->start_flags($e, $ndr); $self->pidl("level = ndr_print_get_switch_value($ndr, $varname);"); @@ -1733,7 +1733,7 @@ sub ParseUnionPrint($$$$$) $self->deindent; $self->pidl("}"); - $self->end_flags($e); + $self->end_flags($e, $ndr); } sub ParseUnionPullPrimitives($$$$$) @@ -1839,7 +1839,7 @@ sub ParseUnionPull($$$$) $double_cases{"$el->{NAME}"} = 1; } - $self->start_flags($e); + $self->start_flags($e, $ndr); $self->pidl("level = ndr_pull_get_switch_value($ndr, $varname);"); @@ -1857,7 +1857,7 @@ sub ParseUnionPull($$$$) $self->add_deferred(); - $self->end_flags($e); + $self->end_flags($e, $ndr); } sub DeclUnion($$$$) -- cgit From 9941c1e7fc7385ad72e3786ca266924d392326e3 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 20 Aug 2008 10:18:42 +0200 Subject: pidl/NDR: correctly check for valid properties grep($str, @array) returns the number of elements in @array! We need grep(/^$str$/, @array) to the only the amount of matches. Also fix unitialized vars for the error case. metze (This used to be commit f002f147d8a8a0b49389e30e611ff8b33dd077e1) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 58 ++++++++++++++++++++------------------ 1 file changed, 31 insertions(+), 27 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 1e4504764a..25743f512f 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -795,20 +795,21 @@ sub ContainsDeferred($$) sub el_name($) { my $e = shift; + my $name = ""; - if ($e->{PARENT} && $e->{PARENT}->{NAME}) { - return "$e->{PARENT}->{NAME}.$e->{NAME}"; - } + $name = $e->{NAME} if defined($e->{NAME}); - if ($e->{PARENT} && $e->{PARENT}->{PARENT}->{NAME}) { - return "$e->{PARENT}->{PARENT}->{NAME}.$e->{NAME}"; + if (defined($e->{PARENT}) and defined($e->{PARENT}->{NAME})) { + return "$e->{PARENT}->{NAME}.$name"; } - if ($e->{PARENT}) { - return "$e->{PARENT}->{NAME}.$e->{NAME}"; + if (defined($e->{PARENT}) and + defined($e->{PARENT}->{PARENT}) and + defined($e->{PARENT}->{PARENT}->{NAME})) { + return "$e->{PARENT}->{PARENT}->{NAME}.$name"; } - return $e->{NAME}; + return $name; } ################################### @@ -858,25 +859,25 @@ my %property_list = ( "unique" => ["ELEMENT"], "ignore" => ["ELEMENT"], "relative" => ["ELEMENT"], - "relative_base" => ["TYPEDEF"], + "relative_base" => ["TYPEDEF", "STRUCT", "UNION"], - "gensize" => ["TYPEDEF"], + "gensize" => ["TYPEDEF", "STRUCT", "UNION"], "value" => ["ELEMENT"], - "flag" => ["ELEMENT", "TYPEDEF"], + "flag" => ["ELEMENT", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"], # generic - "public" => ["FUNCTION", "TYPEDEF"], - "nopush" => ["FUNCTION", "TYPEDEF"], - "nopull" => ["FUNCTION", "TYPEDEF"], - "nosize" => ["FUNCTION", "TYPEDEF"], - "noprint" => ["FUNCTION", "TYPEDEF"], - "noejs" => ["FUNCTION", "TYPEDEF"], + "public" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"], + "nopush" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"], + "nopull" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"], + "nosize" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"], + "noprint" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP", "ELEMENT"], + "noejs" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"], "todo" => ["FUNCTION"], # union "switch_is" => ["ELEMENT"], - "switch_type" => ["ELEMENT", "TYPEDEF"], - "nodiscriminant" => ["TYPEDEF"], + "switch_type" => ["ELEMENT", "UNION"], + "nodiscriminant" => ["UNION"], "case" => ["ELEMENT"], "default" => ["ELEMENT"], @@ -889,15 +890,15 @@ my %property_list = ( "compression" => ["ELEMENT"], # enum - "enum8bit" => ["TYPEDEF"], - "enum16bit" => ["TYPEDEF"], - "v1_enum" => ["TYPEDEF"], + "enum8bit" => ["ENUM"], + "enum16bit" => ["ENUM"], + "v1_enum" => ["ENUM"], # bitmap - "bitmap8bit" => ["TYPEDEF"], - "bitmap16bit" => ["TYPEDEF"], - "bitmap32bit" => ["TYPEDEF"], - "bitmap64bit" => ["TYPEDEF"], + "bitmap8bit" => ["BITMAP"], + "bitmap16bit" => ["BITMAP"], + "bitmap32bit" => ["BITMAP"], + "bitmap64bit" => ["BITMAP"], # array "range" => ["ELEMENT"], @@ -921,7 +922,7 @@ sub ValidProperties($$) unless defined($property_list{$key}); fatal($e, el_name($e) . ": property '$key' not allowed on '$t'") - unless grep($t, @{$property_list{$key}}); + unless grep(/^$t$/, @{$property_list{$key}}); } } @@ -1101,6 +1102,9 @@ sub ValidTypedef($) $data->{PARENT} = $typedef; + $data->{FILE} = $typedef->{FILE} unless defined($data->{FILE}); + $data->{LINE} = $typedef->{LINE} unless defined($data->{LINE}); + ValidType($data) if (ref($data) eq "HASH"); } -- cgit From 397b007df993852577897823e3a454756d385732 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 20 Aug 2008 14:41:05 +0200 Subject: pidl/NDR: generate a LEVELS array for typedefs metze (This used to be commit 6785684db3446c03d8061c8bb3d94889b443d7d5) --- source4/pidl/lib/Parse/Pidl/NDR.pm | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/NDR.pm b/source4/pidl/lib/Parse/Pidl/NDR.pm index 25743f512f..10bd29715b 100644 --- a/source4/pidl/lib/Parse/Pidl/NDR.pm +++ b/source4/pidl/lib/Parse/Pidl/NDR.pm @@ -287,6 +287,22 @@ sub GetElementLevelTable($$) return $order; } +sub GetTypedefLevelTable($$$) +{ + my ($e, $data, $pointer_default) = @_; + + my $order = []; + + push (@$order, { + TYPE => "TYPEDEF" + }); + + my $i = 0; + foreach (@$order) { $_->{LEVEL_INDEX} = $i; $i+=1; } + + return $order; +} + ##################################################################### # see if a type contains any deferred data sub can_contain_deferred($) @@ -575,6 +591,7 @@ sub ParseTypedef($$) NAME => $d->{NAME}, TYPE => $d->{TYPE}, PROPERTIES => $d->{PROPERTIES}, + LEVELS => GetTypedefLevelTable($d, $data, $pointer_default), DATA => $data, ORIGINAL => $d }; -- cgit From 9f2468af157a80de3b71b472ab8aa337b10c5f84 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 20 Aug 2008 14:41:38 +0200 Subject: pidl/NDR::Parser: pass typedefs through the ParseElement*Level() functions metze (This used to be commit e51c0cf62c91f79f703b17bcf37c4a6fa8107ae0) --- source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) (limited to 'source4/pidl/lib/Parse/Pidl') diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm index 8053e5004e..745777d012 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/NDR/Parser.pm @@ -561,6 +561,8 @@ sub ParseElementPushLevel $self->ParseSwitchPush($e, $l, $ndr, $var_name, $env); } elsif ($l->{TYPE} eq "DATA") { $self->ParseDataPush($e, $l, $ndr, $var_name, $primitives, $deferred); + } elsif ($l->{TYPE} eq "TYPEDEF") { + $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($self, $e->{DATA}, $ndr, $var_name); } } @@ -1011,6 +1013,8 @@ sub ParseElementPullLevel $self->ParseSwitchPull($e, $l, $ndr, $var_name, $env); } elsif ($l->{TYPE} eq "DATA") { $self->ParseDataPull($e, $l, $ndr, $var_name, $primitives, $deferred); + } elsif ($l->{TYPE} eq "TYPEDEF") { + $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($self, $e->{DATA}, $ndr, $var_name); } } @@ -1887,7 +1891,11 @@ sub ParseTypedefPush($$$$) { my($self,$e,$ndr,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($self, $e->{DATA}, $ndr, $varname); + my $env; + + $env->{$e->{NAME}} = $varname; + + $self->ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $varname, $env, 1, 1); } ##################################################################### @@ -1896,7 +1904,11 @@ sub ParseTypedefPull($$$$) { my($self,$e,$ndr,$varname) = @_; - $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($self, $e->{DATA}, $ndr, $varname); + my $env; + + $env->{$e->{NAME}} = $varname; + + $self->ParseElementPullLevel($e, $e->{LEVELS}[0], $ndr, $varname, $env, 1, 1); } ##################################################################### -- cgit