use strict;
use Parse::Pidl qw(warning fatal);
-use Parse::Pidl::Typelist qw(hasType getType expandAlias);
+use Parse::Pidl::Typelist qw(hasType getType expandAlias mapScalarType);
use Parse::Pidl::Util qw(has_property property_matches);
# Alignment of the built-in scalar types
'uint8' => 1,
'int16' => 2,
'uint16' => 2,
+ 'int1632' => 3,
+ 'uint1632' => 3,
'int32' => 4,
'uint32' => 4,
+ 'int3264' => 5,
+ 'uint3264' => 5,
'hyper' => 8,
+ 'double' => 8,
'pointer' => 8,
'dlong' => 4,
'udlong' => 4,
'string' => 4,
'string_array' => 4, #???
'time_t' => 4,
+ 'uid_t' => 8,
+ 'gid_t' => 8,
'NTTIME' => 4,
'NTTIME_1sec' => 4,
'NTTIME_hyper' => 8,
'WERROR' => 4,
'NTSTATUS' => 4,
'COMRESULT' => 4,
+ 'dns_string' => 4,
'nbt_string' => 4,
'wrepl_nbt_name' => 4,
- 'ipv4address' => 4
+ 'ipv4address' => 4,
+ 'ipv6address' => 4, #16?
+ 'dnsp_name' => 1,
+ 'dnsp_string' => 1
};
-sub GetElementLevelTable($$)
+sub GetElementLevelTable($$$)
{
- my ($e, $pointer_default) = @_;
+ my ($e, $pointer_default, $ms_union) = @_;
my $order = [];
my $is_deferred = 0;
if (has_property($e, "out")) {
my $needptrs = 1;
- if (has_property($e, "string")) { $needptrs++; }
+ if (has_property($e, "string") and not has_property($e, "in")) { $needptrs++; }
if ($#bracket_array >= 0) { $needptrs = 0; }
warning($e, "[out] argument `$e->{NAME}' not a pointer") if ($needptrs > $e->{POINTERS});
if ($d eq "*") {
$is_conformant = 1;
if ($size = shift @size_is) {
+ if ($e->{POINTERS} < 1 and has_property($e, "string")) {
+ $is_string = 1;
+ delete($e->{PROPERTIES}->{string});
+ }
} elsif ((scalar(@size_is) == 0) and has_property($e, "string")) {
$is_string = 1;
delete($e->{PROPERTIES}->{string});
$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));
+ if ($i == 0 and $is_fixed and has_property($e, "string")) {
+ $is_fixed = 0;
+ $is_varying = 1;
+ $is_string = 1;
+ delete($e->{PROPERTIES}->{string});
+ }
+
push (@$order, {
TYPE => "ARRAY",
SIZE_IS => $size,
return $order;
}
-sub GetTypedefLevelTable($$$)
+sub GetTypedefLevelTable($$$$)
{
- my ($e, $data, $pointer_default) = @_;
+ my ($e, $data, $pointer_default, $ms_union) = @_;
my $order = [];
return "sptr" if (has_property($e, "sptr"));
return "unique" if (has_property($e, "unique"));
return "relative" if (has_property($e, "relative"));
+ return "relative_short" if (has_property($e, "relative_short"));
return "ignore" if (has_property($e, "ignore"));
return undef;
my $a = 1;
if ($e->{POINTERS}) {
- $a = 4;
+ # this is a hack for NDR64
+ # the NDR layer translates this into
+ # an alignment of 4 for NDR and 8 for NDR64
+ $a = 5;
} elsif (has_property($e, "subcontext")) {
$a = 1;
} elsif (has_property($e, "transmit_as")) {
if ($dt->{TYPE} eq "TYPEDEF") {
return align_type($dt->{DATA});
+ } elsif ($dt->{TYPE} eq "CONFORMANCE") {
+ return $dt->{DATA}->{ALIGN};
} elsif ($dt->{TYPE} eq "ENUM") {
return align_type(Parse::Pidl::Typelist::enum_type_fn($dt));
} elsif ($dt->{TYPE} eq "BITMAP") {
die("Unknown data type type $dt->{TYPE}");
}
-sub ParseElement($$)
+sub ParseElement($$$)
{
- my ($e, $pointer_default) = @_;
+ my ($e, $pointer_default, $ms_union) = @_;
$e->{TYPE} = expandAlias($e->{TYPE});
if (ref($e->{TYPE}) eq "HASH") {
- $e->{TYPE} = ParseType($e->{TYPE}, $pointer_default);
+ $e->{TYPE} = ParseType($e->{TYPE}, $pointer_default, $ms_union);
}
return {
NAME => $e->{NAME},
TYPE => $e->{TYPE},
PROPERTIES => $e->{PROPERTIES},
- LEVELS => GetElementLevelTable($e, $pointer_default),
+ LEVELS => GetElementLevelTable($e, $pointer_default, $ms_union),
REPRESENTATION_TYPE => ($e->{PROPERTIES}->{represent_as} or $e->{TYPE}),
ALIGN => align_type($e->{TYPE}),
ORIGINAL => $e
};
}
-sub ParseStruct($$)
+sub ParseStruct($$$)
{
- my ($struct, $pointer_default) = @_;
+ my ($struct, $pointer_default, $ms_union) = @_;
my @elements = ();
my $surrounding = undef;
foreach my $x (@{$struct->{ELEMENTS}})
{
- my $e = ParseElement($x, $pointer_default);
+ my $e = ParseElement($x, $pointer_default, $ms_union);
if ($x != $struct->{ELEMENTS}[-1] and
$e->{LEVELS}[0]->{IS_SURROUNDING}) {
fatal($x, "conformant member not at end of struct");
sub ParseUnion($$)
{
- my ($e, $pointer_default) = @_;
+ my ($e, $pointer_default, $ms_union) = @_;
my @elements = ();
+ my $is_ms_union = $ms_union;
+ $is_ms_union = 1 if has_property($e, "ms_union");
my $hasdefault = 0;
my $switch_type = has_property($e, "switch_type");
unless (defined($switch_type)) { $switch_type = "uint32"; }
ELEMENTS => undef,
PROPERTIES => $e->{PROPERTIES},
HAS_DEFAULT => $hasdefault,
- ORIGINAL => $e
+ IS_MS_UNION => $is_ms_union,
+ ORIGINAL => $e,
+ ALIGN => undef
} unless defined($e->{ELEMENTS});
CheckPointerTypes($e, $pointer_default);
if ($x->{TYPE} eq "EMPTY") {
$t = { TYPE => "EMPTY" };
} else {
- $t = ParseElement($x, $pointer_default);
+ $t = ParseElement($x, $pointer_default, $ms_union);
}
if (has_property($x, "default")) {
$t->{CASE} = "default";
push @elements, $t;
}
+ my $align = undef;
+ if ($e->{NAME}) {
+ $align = align_type($e->{NAME});
+ }
+
return {
TYPE => "UNION",
NAME => $e->{NAME},
ELEMENTS => \@elements,
PROPERTIES => $e->{PROPERTIES},
HAS_DEFAULT => $hasdefault,
- ORIGINAL => $e
+ IS_MS_UNION => $is_ms_union,
+ ORIGINAL => $e,
+ ALIGN => $align
};
}
sub ParseEnum($$)
{
- my ($e, $pointer_default) = @_;
+ my ($e, $pointer_default, $ms_union) = @_;
return {
TYPE => "ENUM",
};
}
-sub ParseBitmap($$)
+sub ParseBitmap($$$)
{
- my ($e, $pointer_default) = @_;
+ my ($e, $pointer_default, $ms_union) = @_;
return {
TYPE => "BITMAP",
};
}
-sub ParseType($$)
+sub ParseType($$$)
{
- my ($d, $pointer_default) = @_;
+ my ($d, $pointer_default, $ms_union) = @_;
my $data = {
STRUCT => \&ParseStruct,
ENUM => \&ParseEnum,
BITMAP => \&ParseBitmap,
TYPEDEF => \&ParseTypedef,
- }->{$d->{TYPE}}->($d, $pointer_default);
+ }->{$d->{TYPE}}->($d, $pointer_default, $ms_union);
return $data;
}
sub ParseTypedef($$)
{
- my ($d, $pointer_default) = @_;
+ my ($d, $pointer_default, $ms_union) = @_;
- if (defined($d->{DATA}->{PROPERTIES}) && !defined($d->{PROPERTIES})) {
- $d->{PROPERTIES} = $d->{DATA}->{PROPERTIES};
- }
+ my $data;
- my $data = ParseType($d->{DATA}, $pointer_default);
- $data->{ALIGN} = align_type($d->{NAME});
+ if (ref($d->{DATA}) eq "HASH") {
+ if (defined($d->{DATA}->{PROPERTIES})
+ and not defined($d->{PROPERTIES})) {
+ $d->{PROPERTIES} = $d->{DATA}->{PROPERTIES};
+ }
+
+ $data = ParseType($d->{DATA}, $pointer_default, $ms_union);
+ $data->{ALIGN} = align_type($d->{NAME});
+ } else {
+ $data = getType($d->{DATA});
+ }
return {
NAME => $d->{NAME},
TYPE => $d->{TYPE},
PROPERTIES => $d->{PROPERTIES},
- LEVELS => GetTypedefLevelTable($d, $data, $pointer_default),
+ LEVELS => GetTypedefLevelTable($d, $data, $pointer_default, $ms_union),
DATA => $data,
ORIGINAL => $d
};
return $d;
}
-sub ParseFunction($$$)
+sub ParseFunction($$$$)
{
- my ($ndr,$d,$opnum) = @_;
+ my ($ndr,$d,$opnum,$ms_union) = @_;
my @elements = ();
my $rettype = undef;
my $thisopnum = undef;
}
foreach my $x (@{$d->{ELEMENTS}}) {
- my $e = ParseElement($x, $ndr->{PROPERTIES}->{pointer_default});
+ my $e = ParseElement($x, $ndr->{PROPERTIES}->{pointer_default}, $ms_union);
push (@{$e->{DIRECTION}}, "in") if (has_property($x, "in"));
push (@{$e->{DIRECTION}}, "out") if (has_property($x, "out"));
$rettype = expandAlias($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,
my @endpoints;
my $opnum = 0;
my $version;
+ my $ms_union = 0;
+ $ms_union = 1 if has_property($idl, "ms_union");
if (not has_property($idl, "pointer_default")) {
# MIDL defaults to "ptr" in DCE compatible mode (/osf)
foreach my $d (@{$idl->{DATA}}) {
if ($d->{TYPE} eq "FUNCTION") {
- push (@functions, ParseFunction($idl, $d, \$opnum));
+ push (@functions, ParseFunction($idl, $d, \$opnum, $ms_union));
} elsif ($d->{TYPE} eq "CONST") {
push (@consts, ParseConst($idl, $d));
} else {
- push (@types, ParseType($d, $idl->{PROPERTIES}->{pointer_default}));
+ push (@types, ParseType($d, $idl->{PROPERTIES}->{pointer_default}, $ms_union));
FindNestedTypes(\@types, $d);
}
}
"helper" => ["INTERFACE"],
"pyhelper" => ["INTERFACE"],
"authservice" => ["INTERFACE"],
- "restricted" => ["INTERFACE"],
+ "restricted" => ["INTERFACE"],
+ "no_srv_register" => ["INTERFACE"],
# dcom
"object" => ["INTERFACE"],
"noopnum" => ["FUNCTION"],
"in" => ["ELEMENT"],
"out" => ["ELEMENT"],
- "async" => ["FUNCTION"],
# pointer
- "ref" => ["ELEMENT"],
- "ptr" => ["ELEMENT"],
- "unique" => ["ELEMENT"],
+ "ref" => ["ELEMENT", "TYPEDEF"],
+ "ptr" => ["ELEMENT", "TYPEDEF"],
+ "unique" => ["ELEMENT", "TYPEDEF"],
"ignore" => ["ELEMENT"],
- "relative" => ["ELEMENT"],
- "null_is_ffffffff" => ["ELEMENT"],
+ "relative" => ["ELEMENT", "TYPEDEF"],
+ "relative_short" => ["ELEMENT", "TYPEDEF"],
+ "null_is_ffffffff" => ["ELEMENT"],
"relative_base" => ["TYPEDEF", "STRUCT", "UNION"],
"gensize" => ["TYPEDEF", "STRUCT", "UNION"],
"nopull" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"],
"nosize" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"],
"noprint" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP", "ELEMENT"],
+ "nopython" => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"],
"todo" => ["FUNCTION"],
# union
"switch_is" => ["ELEMENT"],
"switch_type" => ["ELEMENT", "UNION"],
"nodiscriminant" => ["UNION"],
+ "ms_union" => ["INTERFACE", "UNION"],
"case" => ["ELEMENT"],
"default" => ["ELEMENT"],
"bitmap64bit" => ["BITMAP"],
# array
- "range" => ["ELEMENT"],
+ "range" => ["ELEMENT", "PIPE"],
"size_is" => ["ELEMENT"],
"string" => ["ELEMENT"],
"noheader" => ["ELEMENT"],
my $discriminator_type = has_property($type->{DATA}, "switch_type");
$discriminator_type = "uint32" unless defined ($discriminator_type);
- my $t1 = mapToScalar($discriminator_type);
+ my $t1 = mapScalarType(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});
+ my $t2 = mapScalarType(mapToScalar($e2->{TYPE}));
if (not defined($t2)) {
fatal($e, el_name($e) . ": unable to map variable used for switch_is() to scalar");
}
has_property($e, "ptr") or
has_property($e, "unique") or
has_property($e, "relative") or
+ has_property($e, "relative_short") or
has_property($e, "ref"))) {
fatal($e, el_name($e) . " : pointer properties on non-pointer element\n");
}
}
}
+#####################################################################
+# validate a pipe
+sub ValidPipe($)
+{
+ my ($pipe) = @_;
+ my $data = $pipe->{DATA};
+
+ ValidProperties($pipe, "PIPE");
+
+ fatal($pipe, $pipe->{NAME} . ": 'pipe' is not yet supported by pidl");
+}
+
#####################################################################
# parse a typedef
sub ValidTypedef($)
ValidProperties($typedef, "TYPEDEF");
+ return unless (ref($data) eq "HASH");
+
$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");
+ ValidType($data);
}
#####################################################################
STRUCT => \&ValidStruct,
UNION => \&ValidUnion,
ENUM => \&ValidEnum,
- BITMAP => \&ValidBitmap
+ BITMAP => \&ValidBitmap,
+ PIPE => \&ValidPipe
}->{$t->{TYPE}}->($t);
}
$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" or
+ $d->{TYPE} eq "PIPE") && ValidType($d);
}
}
git.samba.org / ab / samba.git / .git / blobdiff