$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);
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;
}
}
+ $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
});
}
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;
}
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, {
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
});
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
+ return can_contain_deferred($type->{DATA}) if ($type->{TYPE} eq "TYPEDEF");
- foreach my $x (@{$type->{DATA}->{ELEMENTS}}) {
- return 1 if ($x->{POINTERS});
- return 1 if (can_contain_deferred ($x));
+ return 0 unless defined($type->{ELEMENTS});
+
+ foreach (@{$type->{ELEMENTS}}) {
+ return 1 if ($_->{POINTERS});
+ return 1 if (can_contain_deferred ($_->{TYPE}));
}
return 0;
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;
}
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));
} 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);
}
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);
{
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;
{
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,
{
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;
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") {
my @consts = ();
my @functions = ();
my @endpoints;
- my @declares = ();
my $opnum = 0;
my $version;
}
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));
FUNCTIONS => \@functions,
CONSTS => \@consts,
TYPES => \@types,
- DECLARES => \@declares,
ENDPOINTS => \@endpoints
};
}
my @ndr = ();
foreach (@{$idl}) {
+ ($_->{TYPE} eq "CPP_QUOTE") && push(@ndr, $_);
($_->{TYPE} eq "INTERFACE") && push(@ndr, ParseInterface($_));
($_->{TYPE} eq "IMPORT") && push(@ndr, $_);
}
ValidProperties($struct, "STRUCT");
+ return unless defined($struct->{ELEMENTS});
+
foreach my $e (@{$struct->{ELEMENTS}}) {
$e->{PARENT} = $struct;
ValidElement($e);
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;
$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);
}
}
($x->{TYPE} eq "INTERFACE") &&
ValidInterface($x);
($x->{TYPE} eq "IMPORTLIB") &&
- warning($x, "importlib() not supported");
+ fatal($x, "importlib() not supported");
}
}