source4/build/pidl/header.pm

   1 ###################################################
   2 # create C header files for an IDL structure
   3 # Copyright tridge@samba.org 2000
   4 # released under the GNU GPL
   5
   6 package IdlHeader;
   7
   8 use strict;
   9 use needed;
  10
  11 my($res);
  12 my($tab_depth);
  13
  14 sub pidl ($)
  15 {
  16         $res .= shift;
  17 }
  18
  19 sub tabs()
  20 {
  21         for (my($i)=0; $i < $tab_depth; $i++) {
  22                 pidl "\t";
  23         }
  24 }
  25
  26 #####################################################################
  27 # parse a properties list
  28 sub HeaderProperties($$)
  29 {
  30     my($props) = shift;
  31         my($ignores) = shift;
  32         my $ret = "";
  33
  34         return;
  35
  36     foreach my $d (keys %{$props}) {
  37                 next if ($ignores->{$d});
  38                 if($props->{$d} ne "1") {
  39                         $ret.= "$d(" . $props->{$d} . "),";
  40                 } else {
  41                         $ret.="$d,";
  42                 }
  43         }
  44
  45         if ($ret) {
  46                 pidl "/* [" . substr($ret, 0, -1) . "] */";
  47         }
  48 }
  49
  50 #####################################################################
  51 # parse a structure element
  52 sub HeaderElement($)
  53 {
  54     my($element) = shift;
  55
  56     if (defined $element->{PROPERTIES}) {
  57                 HeaderProperties($element->{PROPERTIES}, {"in" => 1, "out" => 1});
  58         }
  59     pidl tabs();
  60     HeaderType($element, $element->{TYPE}, "");
  61     pidl " ";
  62     if ($element->{POINTERS} &&
  63         $element->{TYPE} ne "string") {
  64             my($n) = $element->{POINTERS};
  65             for (my($i)=$n; $i > 0; $i--) {
  66                     pidl "*";
  67             }
  68     }
  69     if (defined $element->{ARRAY_LEN} &&
  70         !util::is_constant($element->{ARRAY_LEN}) &&
  71         !$element->{POINTERS}) {
  72             # conformant arrays are ugly! I choose to implement them with
  73             # pointers instead of the [1] method
  74             pidl "*";
  75     }
  76     pidl "$element->{NAME}";
  77     if (defined $element->{ARRAY_LEN} && util::is_constant($element->{ARRAY_LEN})) {
  78             pidl "[$element->{ARRAY_LEN}]";
  79     }
  80     pidl ";\n";
  81 }
  82
  83 #####################################################################
  84 # parse a struct
  85 sub HeaderStruct($$)
  86 {
  87     my($struct) = shift;
  88     my($name) = shift;
  89     pidl "\nstruct $name {\n";
  90     $tab_depth++;
  91     my $el_count=0;
  92     if (defined $struct->{ELEMENTS}) {
  93         foreach my $e (@{$struct->{ELEMENTS}}) {
  94             HeaderElement($e);
  95             $el_count++;
  96         }
  97     }
  98     if ($el_count == 0) {
  99             # some compilers can't handle empty structures
 100             pidl "\tchar _empty_;\n";
 101     }
 102     $tab_depth--;
 103     pidl "}";
 104 }
 105
 106 #####################################################################
 107 # parse a enum
 108 sub HeaderEnum($$)
 109 {
 110     my($enum) = shift;
 111     my($name) = shift;
 112
 113     pidl "\nenum $name {\n";
 114     $tab_depth++;
 115     my $els = \@{$enum->{ELEMENTS}};
 116     foreach my $i (0 .. $#{$els}-1) {
 117             my $e = ${$els}[$i];
 118             tabs();
 119             chomp $e;
 120             pidl "$e,\n";
 121     }
 122
 123     my $e = ${$els}[$#{$els}];
 124     tabs();
 125     chomp $e;
 126     if ($e !~ /^(.*?)\s*$/) {
 127             die "Bad enum $name\n";
 128     }
 129     pidl "$1\n";
 130     $tab_depth--;
 131     pidl "}";
 132 }
 133
 134 #####################################################################
 135 # parse a bitmap
 136 sub HeaderBitmap($$)
 137 {
 138     my($bitmap) = shift;
 139     my($name) = shift;
 140
 141     pidl "\n/* bitmap $name */\n";
 142
 143     my $els = \@{$bitmap->{ELEMENTS}};
 144     foreach my $i (0 .. $#{$els}) {
 145             my $e = ${$els}[$i];
 146             chomp $e;
 147             pidl "#define $e\n";
 148     }
 149
 150     pidl "\n";
 151 }
 152
 153 #####################################################################
 154 # parse a union
 155 sub HeaderUnion($$)
 156 {
 157         my($union) = shift;
 158         my($name) = shift;
 159         my %done = ();
 160
 161         if (defined $union->{PROPERTIES}) {
 162                 HeaderProperties($union->{PROPERTIES}, {});
 163         }
 164         pidl "\nunion $name {\n";
 165         $tab_depth++;
 166         foreach my $e (@{$union->{ELEMENTS}}) {
 167                 if ($e->{TYPE} ne "EMPTY") {
 168                         if (! defined $done{$e->{NAME}}) {
 169                                 HeaderElement($e);
 170                         }
 171                         $done{$e->{NAME}} = 1;
 172                 }
 173         }
 174         $tab_depth--;
 175         pidl "}";
 176 }
 177
 178 #####################################################################
 179 # parse a type
 180 sub HeaderType($$$)
 181 {
 182         my $e = shift;
 183         my($data) = shift;
 184         my($name) = shift;
 185         if (ref($data) eq "HASH") {
 186                 ($data->{TYPE} eq "ENUM") &&
 187                     HeaderEnum($data, $name);
 188                 ($data->{TYPE} eq "BITMAP") &&
 189                     HeaderBitmap($data, $name);
 190                 ($data->{TYPE} eq "STRUCT") &&
 191                     HeaderStruct($data, $name);
 192                 ($data->{TYPE} eq "UNION") &&
 193                     HeaderUnion($data, $name);
 194                 return;
 195         }
 196
 197         my $dt;
 198         if (my $t = NdrParser::get_typedef($e->{TYPE})) {
 199                 $dt = $t->{DATA};
 200         }
 201
 202         if ($data =~ "string") {
 203                 pidl "const char *";
 204         } elsif (not defined($dt->{TYPE})) {
 205                 pidl "struct $data";
 206         } else {
 207                 if ($dt->{TYPE} eq "ENUM") {
 208                         pidl "enum $data";
 209                 } elsif ($dt->{TYPE} eq "BITMAP") {
 210                         pidl util::bitmap_type_decl($dt);
 211                 } elsif ($dt->{TYPE} eq "SCALAR") {
 212                         pidl util::map_type($data);
 213                 } elsif ($dt->{TYPE} eq "UNION") {
 214                         pidl "union $data";
 215                 } elsif ($dt->{TYPE} eq "STRUCT") {
 216                         pidl "struct $data";
 217                 } else {
 218                         print "Unknown data type type $dt->{TYPE}\n";
 219                 }
 220         }
 221 }
 222
 223 #####################################################################
 224 # parse a typedef
 225 sub HeaderTypedef($)
 226 {
 227     my($typedef) = shift;
 228     HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME});
 229     pidl ";\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP");
 230 }
 231
 232 #####################################################################
 233 # prototype a typedef
 234 sub HeaderTypedefProto($)
 235 {
 236     my($d) = shift;
 237
 238     if (needed::is_needed("ndr_size_$d->{NAME}")) {
 239             if ($d->{DATA}{TYPE} eq "STRUCT") {
 240                     pidl "size_t ndr_size_$d->{NAME}(const struct $d->{NAME} *r, int flags);\n";
 241             }
 242             if ($d->{DATA}{TYPE} eq "UNION") {
 243                     pidl "size_t ndr_size_$d->{NAME}(const union $d->{NAME} *r, uint32_t level, int flags);\n";
 244             }
 245     }
 246
 247     return unless util::has_property($d, "public");
 248
 249         my $tf = NdrParser::get_typefamily($d->{DATA}{TYPE});
 250
 251         my $pull_args = $tf->{PULL_FN_ARGS}->($d);
 252         my $push_args = $tf->{PUSH_FN_ARGS}->($d);
 253         my $print_args = $tf->{PRINT_FN_ARGS}->($d);
 254         pidl "NTSTATUS ndr_push_$d->{NAME}($push_args);\n";
 255     pidl "NTSTATUS ndr_pull_$d->{NAME}($pull_args);\n";
 256     if (!util::has_property($d, "noprint")) {
 257             pidl "void ndr_print_$d->{NAME}($print_args);\n";
 258     }
 259 }
 260
 261 #####################################################################
 262 # parse a const
 263 sub HeaderConst($)
 264 {
 265     my($const) = shift;
 266     if (!defined($const->{ARRAY_LEN})) {
 267         pidl "#define $const->{NAME}\t( $const->{VALUE} )\n";
 268     } else {
 269         pidl "#define $const->{NAME}\t $const->{VALUE}\n";
 270     }
 271 }
 272
 273 #####################################################################
 274 # parse a function
 275 sub HeaderFunctionInOut($$)
 276 {
 277     my($fn) = shift;
 278     my($prop) = shift;
 279
 280     foreach my $e (@{$fn->{ELEMENTS}}) {
 281             if (util::has_property($e, $prop)) {
 282                     HeaderElement($e);
 283             }
 284     }
 285 }
 286
 287 #####################################################################
 288 # determine if we need an "in" or "out" section
 289 sub HeaderFunctionInOut_needed($$)
 290 {
 291     my($fn) = shift;
 292     my($prop) = shift;
 293
 294     if ($prop eq "out" && $fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
 295             return 1;
 296     }
 297
 298     foreach my $e (@{$fn->{ELEMENTS}}) {
 299             if (util::has_property($e, $prop)) {
 300                     return 1;
 301             }
 302     }
 303
 304     return undef;
 305 }
 306
 307
 308 #####################################################################
 309 # parse a function
 310 sub HeaderFunction($)
 311 {
 312     my($fn) = shift;
 313
 314     pidl "\nstruct $fn->{NAME} {\n";
 315     $tab_depth++;
 316     my $needed = 0;
 317
 318     if (HeaderFunctionInOut_needed($fn, "in")) {
 319             tabs();
 320             pidl "struct {\n";
 321             $tab_depth++;
 322             HeaderFunctionInOut($fn, "in");
 323             $tab_depth--;
 324             tabs();
 325             pidl "} in;\n\n";
 326             $needed++;
 327     }
 328
 329     if (HeaderFunctionInOut_needed($fn, "out")) {
 330             tabs();
 331             pidl "struct {\n";
 332             $tab_depth++;
 333             HeaderFunctionInOut($fn, "out");
 334             if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
 335                     tabs();
 336                     pidl util::map_type($fn->{RETURN_TYPE}) . " result;\n";
 337             }
 338             $tab_depth--;
 339             tabs();
 340             pidl "} out;\n\n";
 341             $needed++;
 342     }
 343
 344     if (! $needed) {
 345             # sigh - some compilers don't like empty structures
 346             tabs();
 347             pidl "int _dummy_element;\n";
 348     }
 349
 350     $tab_depth--;
 351     pidl "};\n\n";
 352 }
 353
 354 #####################################################################
 355 # output prototypes for a IDL function
 356 sub HeaderFnProto($$)
 357 {
 358         my $interface = shift;
 359     my $fn = shift;
 360     my $name = $fn->{NAME};
 361
 362     pidl "void ndr_print_$name(struct ndr_print *ndr, const char *name, int flags, struct $name *r);\n";
 363
 364         if (util::has_property($interface, "object")) {
 365                 pidl "NTSTATUS dcom_$interface->{NAME}_$name (struct dcom_interface_p *d, TALLOC_CTX *mem_ctx, struct $name *r);\n";
 366         } else {
 367             pidl "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
 368         pidl "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
 369         }
 370     pidl "\n";
 371 }
 372
 373
 374 #####################################################################
 375 # generate vtable structure for DCOM interface
 376 sub HeaderVTable($)
 377 {
 378         my $interface = shift;
 379         pidl "struct dcom_$interface->{NAME}_vtable {\n";
 380         if (defined($interface->{BASE})) {
 381                 pidl "\tstruct dcom_$interface->{BASE}\_vtable base;\n";
 382         }
 383
 384         my $data = $interface->{DATA};
 385         foreach my $d (@{$data}) {
 386                 pidl "\tNTSTATUS (*$d->{NAME}) (struct dcom_interface_p *d, TALLOC_CTX *mem_ctx, struct $d->{NAME} *r);\n" if ($d->{TYPE} eq "FUNCTION");
 387         }
 388         pidl "};\n\n";
 389 }
 390
 391
 392 #####################################################################
 393 # parse the interface definitions
 394 sub HeaderInterface($)
 395 {
 396     my($interface) = shift;
 397     my($data) = $interface->{DATA};
 398
 399     my $count = 0;
 400
 401     pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n";
 402     pidl "#define _HEADER_NDR_$interface->{NAME}\n\n";
 403
 404     if (defined $interface->{PROPERTIES}->{depends}) {
 405             my @d = split / /, $interface->{PROPERTIES}->{depends};
 406             foreach my $i (@d) {
 407                     pidl "#include \"librpc/gen_ndr/ndr_$i\.h\"\n";
 408             }
 409     }
 410
 411     if (defined $interface->{PROPERTIES}->{uuid}) {
 412             my $name = uc $interface->{NAME};
 413             pidl "#define DCERPC_$name\_UUID " .
 414                 util::make_str($interface->{PROPERTIES}->{uuid}) . "\n";
 415
 416                 if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; }
 417             pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n";
 418
 419             pidl "#define DCERPC_$name\_NAME \"$interface->{NAME}\"\n";
 420
 421                 if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; }
 422                 pidl "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}\n";
 423
 424             pidl "\nextern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n";
 425             pidl "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);\n\n";
 426     }
 427
 428     foreach my $d (@{$data}) {
 429             if ($d->{TYPE} eq "FUNCTION") {
 430                     my $u_name = uc $d->{NAME};
 431                         pidl "#define DCERPC_$u_name (";
 432
 433                         if (defined($interface->{BASE})) {
 434                                 pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
 435                         }
 436
 437                     pidl sprintf("0x%02x", $count) . ")\n";
 438                     $count++;
 439             }
 440     }
 441
 442         pidl "\n#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT (";
 443
 444         if (defined($interface->{BASE})) {
 445                 pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
 446         }
 447
 448         pidl "$count)\n\n";
 449
 450     foreach my $d (@{$data}) {
 451         ($d->{TYPE} eq "CONST") &&
 452             HeaderConst($d);
 453         ($d->{TYPE} eq "TYPEDEF") &&
 454             HeaderTypedef($d);
 455         ($d->{TYPE} eq "TYPEDEF") &&
 456             HeaderTypedefProto($d);
 457         ($d->{TYPE} eq "FUNCTION") &&
 458             HeaderFunction($d);
 459         ($d->{TYPE} eq "FUNCTION") &&
 460             HeaderFnProto($interface, $d);
 461     }
 462
 463         (util::has_property($interface, "object")) &&
 464                 HeaderVTable($interface);
 465
 466     pidl "#endif /* _HEADER_NDR_$interface->{NAME} */\n";
 467 }
 468
 469 #####################################################################
 470 # parse a parsed IDL into a C header
 471 sub Parse($)
 472 {
 473     my($idl) = shift;
 474     $tab_depth = 0;
 475
 476         NdrParser::Load($idl);
 477
 478         $res = "";
 479     pidl "/* header auto-generated by pidl */\n\n";
 480     foreach my $x (@{$idl}) {
 481             if ($x->{TYPE} eq "INTERFACE") {
 482                     needed::BuildNeeded($x);
 483                     HeaderInterface($x);
 484             }
 485     }
 486     return $res;
 487 }
 488
 489 1;