# Tom Christiansen, <tchrist@convex.com>
# As pstruct, dump C structures as generated from 'cc -g -S' stabs.
# As c2ph, do this PLUS generate perl code for getting at the structures.
# See the usage message for more. If this isn't enough, read the code.
$RCSID = '$RCSfile: c2ph.SH,v $$Revision: 4.0.1.2 $$Date: 92/06/08 11:56:08 $';
######################################################################
# some handy data definitions. many of these can be reset later.
$bitorder = 'b'; # ascending; set to B for descending bit fields
'unsigned short int', 'S',
'short unsigned int', 'S',
'long unsigned int', 'L',
'unsigned long int', 'L',
'unsigned long long', 'Q',
'unsigned long long int', 'Q',
delete $intrinsics{'neganull'};
delete $intrinsics{'bit'};
delete $intrinsics{'null'};
# use -s to recompute sizes
'unsigned short int', '2',
'short unsigned int', '2',
'unsigned long int', '4',
'long unsigned int', '4',
'unsigned long long', '8',
'unsigned long long int', '8',
($type_width, $member_width, $offset_width, $size_width) = (20, 20, 6, 5);
($offset_fmt, $size_fmt) = ('d', 'd');
$perl++ if $0 =~ m#/?c2ph$#;
eval '$'.$1.'$2;' while $ARGV[0] =~ /^([A-Za-z_]+=)(.*)/ && shift;
&Getopts('aixdpvtnws:') || &usage(0);
($type_width, $member_width, $offset_width) = (45, 35, 8);
($offset_fmt, $offset_width, $size_fmt, $size_width) = ( 'x', '08', 'x', 04 );
eval '$'.$1.'$2;' while $ARGV[0] =~ /^([A-Za-z_]+=)(.*)/ && shift;
print "oops, apperent pager foulup\n";
print "hit <RETURN> for further explanation: ";
open (PIPE, "|". ($ENV{PAGER} || 'more'));
print "usage: $0 [-dpnP] [var=val] [files ...]\n";
-w wide; short for: type_width=45 member_width=35 offset_width=8
-x hex; short for: offset_fmt=x offset_width=08 size_fmt=x size_width=04
-n do not generate perl code (default when invoked as pstruct)
-p generate perl code (default when invoked as c2ph)
-v generate perl code, with C decls as comments
-i do NOT recompute sizes for intrinsic datatypes
-a dump information on intrinsics also
-d spew reams of debugging output
-slist give comma-separated list a structures to dump
Var Name Default Value Meaning
&defvar('CC', 'which_compiler to call');
&defvar('CFLAGS', 'how to generate *.s files with stabs');
&defvar('DEFINES','any extra cflags or cpp defines, like -I, -D, -U');
&defvar('type_width', 'width of type field (column 1)');
&defvar('member_width', 'width of member field (column 2)');
&defvar('offset_width', 'width of offset field (column 3)');
&defvar('size_width', 'width of size field (column 4)');
&defvar('offset_fmt', 'sprintf format type for offset');
&defvar('size_fmt', 'sprintf format type for size');
&defvar('indent', 'how far to indent each nesting level');
If any *.[ch] files are given, these will be catted together into
a temporary *.c file and sent through:
and the resulting *.s groped for stab information. If no files are
supplied, then stdin is read directly with the assumption that it
contains stab information. All other liens will be ignored. At
most one *.s file should be supplied.
printf "%-16s%-15s %s\n", $var, eval "\$$var", $msg;
if (grep(!/\.[csh]$/,@ARGV)) {
warn "Only *.[csh] files expected!\n";
elsif (grep(/\.s$/,@ARGV)) {
warn "Only one *.s file allowed!\n";
elsif (@ARGV == 1 && $ARGV[0] =~ /\.c$/) {
local($dir, $file) = $ARGV[0] =~ m#(.*/)?(.*)$#;
$chdir = "cd $dir; " if $dir;
&system("$chdir$CC $CFLAGS $DEFINES $file") && exit 1;
&system("cat @ARGV > $TMP") && exit 1;
&system("cd /tmp; $CC $CFLAGS $DEFINES $TMP") && exit 1;
for (split(/[\s,]+/, $opt_s)) {
print STDERR "reading from your keyboard: ";
print STDERR "reading from " . (@ARGV ? "@ARGV" : "<STDIN>").": ";
if ($trace && !($. % 10)) {
print STDERR $lineno, "\b" x length($lineno);
next unless /^\s*\.stabs\s+/;
print STDERR "$.\n" if $trace;
&compute_intrinsics if $perl && !$opt_i;
print STDERR "resolving types\n" if $trace;
$sum = 2 + $type_width + $member_width;
$pmask1 = "%-${type_width}s %-${member_width}s";
$pmask2 = "%-${sum}s %${offset_width}${offset_fmt}%s %${size_width}${size_fmt}%s";
# resolve template -- should be in stab define order, but even this isn't enough.
print STDERR "\nbuilding type templates: " if $trace;
for $i (reverse 0..$#type) {
next unless defined($name = $type[$i]);
next unless defined $struct{$name};
&build_template($name) unless defined $template{&psou($name)} ||
$opt_s && !$interested{$name};
print STDERR "\n\n" if $trace;
print STDERR "dumping structs: " if $trace;
foreach $name (sort keys %struct) {
next if $opt_s && !$interested{$name};
print STDERR "$name " if $trace;
print "# " if $perl && $verbose;
print "$fname {\n" if !$perl || $verbose;
$template{$fname} = &scrunch($template{$fname}) if $perl;
print "# " if $perl && $verbose;
print "}\n" if !$perl || $verbose;
print "\n" if $perl && $verbose;
printf("\nsub %-32s { %4d; }\n\n", "${mname}'struct", $countof{$name});
local(\$${mname}'index) = shift;
? \$${mname}'typedef[\$${mname}'index]
local(\$${mname}'index) = shift;
? \$${mname}'sizeof[\$${mname}'index]
local(\$${mname}'index) = shift;
? \$${mname}'offsetof[\$${mname}'index]
local(\$${mname}'index) = shift;
? \$${mname}'typeof[\$${mname}'index]
print "\$${mname}'typedef = '" . &scrunch($template{$fname})
print "\$${mname}'sizeof = $sizeof{$name};\n\n";
print "\@${mname}'indices = (", &squishseq(@indices), ");\n";
print "\@${mname}'typedef[\@${mname}'indices] = (",
join("\n\t", '', @typedef), "\n );\n\n";
print "\@${mname}'sizeof[\@${mname}'indices] = (",
join("\n\t", '', @sizeof), "\n );\n\n";
print "\@${mname}'offsetof[\@${mname}'indices] = (",
join("\n\t", '', @offsetof), "\n );\n\n";
print "\@${mname}'typeof[\@${mname}'indices] = (",
join("\n\t", '', @typeof), "\n );\n\n";
$template_printed{$fname}++;
print STDERR "\n" if $trace;
unless ($perl && $opt_a) {
foreach $name (sort bysizevalue keys %intrinsics) {
next if $size_printed{$name};
print '$',&munge($name),"'sizeof = ", $sizeof{$name}, ";\n";
sub bysizevalue { $sizeof{$a} <=> $sizeof{$b}; }
foreach $name (sort keys %intrinsics) {
print '$',&munge($name),"'typedef = '", $template{$name}, "';\n";
########################################################################################
next unless /:[\$\w]+(\(\d+,\d+\))?=[\*\$\w]+/; # (\d+,\d+) is for sun
s/",([x\d]+),([x\d]+),([x\d]+),.*// || next;
if (($name, $pdecl) = /^([\$ \w]+):[tT]((\d+)(=[rufs*](\d+))+)$/) {
print "$name is a typedef for some funky pointers: $pdecl\n" if $debug;
if (/(([ \w]+):t(\d+|\(\d+,\d+\)))=r?(\d+|\(\d+,\d+\))(;\d+;\d+;)?/) {
push(@intrinsics, $ident);
print STDERR "intrinsic $ident in new type $typeno\n" if $debug;
if (($name, $typeordef, $typeno, $extra, $struct, $_)
= /^([\$ \w]+):([ustT])(\d+|\(\d+,\d+\))(=[rufs*](\d+))?(.*)$/)
$typeno = &typeno($typeno); # sun foolery
warn "can't grok stab: <$_> in: $line " if $_;
#warn "got size $size for $name\n";
$sizeof{$name} = $size if $size;
s/;[-\d]*;[-\d]*;$//; # we don't care about ranges
$typenos{$name} = $typeno;
unless (defined $type[$typeno]) {
&panic("type 0??") unless $typeno;
$type[$typeno] = $name unless defined $type[$typeno];
printf "new type $typeno is $name" if $debug;
if ($extra =~ /\*/ && defined $type[$struct]) {
print ", a typedef for a pointer to " , $type[$struct] if $debug;
printf "%s is type %d", $name, $typeno if $debug;
print ", a typedef for " , $type[$typeno] if $debug;
#next unless $extra =~ /[su*]/;
$_ = &sdecl($name, $_, 0);
print "it's a bare array typedef -- that's pretty sick\n" if $debug;
elsif (s/((\w+):t(\d+|\(\d+,\d+\)))?=r?(;\d+;\d+;)?//) { # the ?'s are for gcc
print STDERR "intrinsic $2 in new type $typeno\n" if $debug;
elsif (s/^=e//) { # blessed by thy compiler; mine won't do this
warn "Funny remainder for $name on line $_ left in $line " if $_;
sub typeno { # sun thinks types are (0,27) instead of just 27
local($what,$prefix,$base) = @_;
local($field, $fieldname, $typeno, $count, $offset, $entry);
local($mytype, $mycount, $entry2);
local($struct_count) = 0;
local($pad, $revpad, $length, $prepad, $lastoffset, $lastlength, $fmt);
local($mname) = &munge($name);
local($sname) = &psou($what);
for $field (split(/;/, $struct{$what})) {
($fieldname, $typeno, $count, $offset, $length) = split(/,/, $field);
$type =~ /([^[]*)(\[.*\])?/;
$fieldtype = &psou($mytype);
local($fname) = &psou($name);
$pad = ($offset - ($lastoffset + $lastlength))/8
if (! $finished_template{$sname}) {
$template{$sname} .= 'X' x $revpad . ' ' if $revpad;
$template{$sname} .= 'x' x $pad . ' ' if $pad;
$template = &fetch_template($type) x
($count ? &scripts2count($count) : 1);
if (! $finished_template{$sname}) {
$template{$sname} .= $template;
$revpad = $length/8 if $isaunion{$what};
($lastoffset, $lastlength) = ($offset, $length);
print '# ' if $perl && $verbose;
$entry = sprintf($pmask1,
' ' x ($nesting * $indent) . $fieldtype,
"$prefix.$fieldname" . $count);
$entry =~ s/(\*+)( )/$2$1/;
($bits = ($base+$offset)%8) ? ".$bits" : " ",
($bits = $length % 8) ? ".$bits": ""
if ($perl && $nesting == 1) {
$template = &scrunch(&fetch_template($type) x
($count ? &scripts2count($count) : 1));
push(@sizeof, int($length/8) .",\t# $fieldname");
push(@offsetof, int($offset/8) .",\t# $fieldname");
push(@typedef, "'$template', \t# $fieldname");
$type =~ s/(struct|union) //;
push(@typeof, "'$type" . ($count ? $count : '') .
print ' ', ' ' x $indent x $nesting, $template
print "\n" if !$perl || $verbose;
local($mycount) = defined $struct{$mytype} ? $countof{$mytype} : 1;
$mycount *= &scripts2count($count) if $count;
if ($nesting==1 && !$build_templates) {
$pcode .= sprintf("sub %-32s { %4d; }\n",
"${mname}'${fieldname}", $struct_count);
push(@indices, $struct_count);
$struct_count += $mycount;
&pstruct($type, "$prefix.$fieldname", $base+$offset)
if $recurse && defined $struct{$type};
$countof{$what} = $struct_count unless defined $countof{$whati};
$template{$sname} .= '$' if $build_templates;
$finished_template{$sname}++;
if ($build_templates && !defined $sizeof{$name}) {
local($fmt) = &scrunch($template{$sname});
print STDERR "no size for $name, punting with $fmt..." if $debug;
eval '$sizeof{$name} = length(pack($fmt, ()))';
warn "couldn't get size for \$name: $@";
print STDERR $sizeof{$name}, "\n" if $debUg;
local($amstruct) = $struct{$me} ? 'struct ' : '';
print '$sizeof{\'', $amstruct, $me, '\'} = ';
printf "%d;\n", $sizeof{$me};
warn "pdecl: $pdecl\n" if $debug;
$pdecl =~ s/\(\d+,(\d+)\)/$1/g;
@pdecls = split(/=/, $pdecl);
if ($tname =~ s/^f//) { $tname = "$tname&"; }
#else { $tname = "$tname*"; }
$tname .= s/^f// ? "&" : "*";
#$tname =~ s/^f(.*)/$1&/;
print "type[$_] is $tname\n" if $debug;
$type[$_] = $tname unless defined $type[$_];
($arraytype, $unknown, $lower, $upper) = ();
local($_, $typedef) = @_;
while (s/^((\d+)=)?ar(\d+);//) {
($arraytype, $unknown) = ($2, $3);
($lower, $upper) = ($1, $2);
$scripts .= '[' . ($upper+1) . ']';
warn "can't find array bounds: $_";
if (s/^([\d*f=]*),(\d+),(\d+);//) {
($start, $length) = ($2, $3);
if ($whatis =~ /^(\d+)=/) {
} elsif (s/^(\d+)(=[*suf]\d*)//) {
} elsif ($whatis =~ /[su]/) { #
print "$prefix.$fieldname is an array$scripts anon structs; disgusting\n"
#$type[$typeno] = $name unless defined $type[$typeno];
##printf "new type $typeno is $name" if $debug;
$type[$typeno] = "$prefix.$fieldname";
local($name) = $type[$typeno];
$_ = &sdecl($name, $_, $start+$offset);
$offset = $sizeof{$name};
warn "what's this? $whatis in $line ";
warn "bad array stab: $_ in $line ";
#local($wasdef) = defined($type[$typeno]) && $debug;
#print "redefining $type[$typeno] to " if $wasdef;
#$type[$typeno] = "$whatis$scripts"; # unless defined $type[$typeno];
#print "$type[$typeno]\n" if $wasdef;
#$type[$arraytype] = $type[$typeno] unless defined $type[$arraytype];
$type[$arraytype] = "$type[$typeno]$scripts" if defined $type[$typeno];
print "type[$arraytype] is $type[$arraytype]\n" if $debug;
print "$prefix.$fieldname is an array of $type[$arraytype]\n" if $debug;
local($prefix, $_, $offset) = @_;
local($fieldname, $scripts, $type, $arraytype, $unknown,
$whatis, $pdecl, $upper,$lower, $start,$length) = ();
warn "sdecl $_\n" if $debug;
} elsif (s/(\d+)=([us])(\d+|\(\d+,\d+\))//) { #
$type[$typeno] = "$prefix.$fieldname";
local($name) = "$prefix.$fieldname";
$_ = &sdecl("$prefix.$fieldname", $_, $start+$offset);
$offset += $sizeof{$name};
#print "done with anon, start is $start, offset is $offset\n";
warn "weird field $_ of $line" if $debug;
#$_ = &sdecl("$prefix.$fieldname", $_, $start+$offset);
elsif (s/^(\d+|\(\d+,\d+\))?,(\d+),(\d+);//) {
($start, $length) = ($2, $3);
&panic("no length?") unless $length;
$typeno = &typeno($1) if $1;
elsif (s/^((\d+|\(\d+,\d+\))(=[*f](\d+|\(\d+,\d+\)))+),(\d+),(\d+);//) {
($pdecl, $start, $length) = ($1,$5,$6);
elsif (s/(\d+)=([us])(\d+|\(\d+,\d+\))//) { # the dratted anon struct
($typeno, $sou) = ($1, $2);
$typeno = &typeno($typeno);
if (defined($type[$typeno])) {
warn "now how did we get type $1 in $fieldname of $line?";
print "anon type $typeno is $prefix.$fieldname\n" if $debug;
$type[$typeno] = "$prefix.$fieldname" unless defined $type[$typeno];
local($name) = "$prefix.$fieldname";
print "anon ".($isastruct{$name}) ? "struct":"union"." for $prefix.$fieldname\n" if $debug;
$type[$typeno] = "$prefix.$fieldname";
$_ = &sdecl("$prefix.$fieldname", $_, $start+$offset);
$length = $sizeof{$name};
warn "can't grok stab for $name ($_) in line $line ";
&panic("no length for $prefix.$fieldname") unless $length;
$struct{$name} .= join(',', $fieldname, $typeno, $scripts, $start, $length) . ';';
if (s/;\d*,(\d+),(\d+);//) {
local($start, $size) = ($1, $2);
$sizeof{$prefix} = $size;
print "start of $prefix is $start, size of $sizeof{$prefix}\n" if $debug;
$start{$prefix} = $start;
next unless defined $type[$i];
print "type[$i] $type[$i]\n" if $debug;
print "type[$i] $_ ==> " if $debug;
s/^(\d+)(\**)\&\*(\**)/"$2($3".&type($1) . ')()'/e;
s/(\*+)([^*]+)(\*+)/$1$3$2/;
s/\((\*+)(\w+)(\*+)\)/$3($1$2)/;
s/^(\d+)([\*\[].*)/&type($1).$2/e;
#s/(\d+)(\*|(\[[\[\]\d\*]+]\])+)/&type($1).$2/ge;
sub type { &psou($type[$_[0]] || "<UNDEFINED>"); }
($basename = $_) =~ s/\.[^.]+$//;
$start{$_} += $start{$basename};
print "start: $_ @ $start{$_}\n" if $debug;
/u/ && $isaunion{$what}++;
/s/ && $isastruct{$what}++;
} elsif ($isastruct{$what}) {
1 while s/(\w) \1/$1$1/g;
# i wanna say this, but perl resists my efforts:
# s/(\w)(\1+)/$2 . length($1)/ge;
$scrunch_code = "sub quick_scrunch {\n";
for (values %intrinsics) {
$scrunch_code .= "\ts/($_{2,})/'$_' . length(\$1)/ge;\n";
print "$scrunch_code" if $debug;
&panic("can't eval scrunch_code $@ \nscrunch_code") if $@;
&panic("why do you care?") unless $perl;
if ($mytype =~ s/(\[\d+\])+$//) {
$fmt = $template{'pointer'};
elsif (defined $template{$mytype}) {
$fmt = $template{$mytype};
elsif (defined $struct{$mytype}) {
if (!defined $template{&psou($mytype)}) {
&build_template($mytype) unless $mytype eq $name;
elsif ($template{&psou($mytype)} !~ /\$$/) {
#warn "incomplete template for $mytype\n";
$fmt = $template{&psou($mytype)} || '?';
warn "unknown fmt for $mytype\n";
local($TMP) = "/tmp/c2ph-i.$$.c";
open (TMP, ">$TMP") || die "can't open $TMP: $!";
print STDERR "computing intrinsic sizes: " if $trace;
for $type (@intrinsics) {
printf(mask,sizeof($type), "$type");
printf(mask,sizeof(char *), "pointer");
open(PIPE, "cd /tmp && $CC $TMP && /tmp/a.out|");
print "intrinsic $_[1] is size $_[0]\n" if $debug;
$intrinsics{$_[1]} = $template{$_[0]};
close(PIPE) || die "couldn't read intrinsics!";
unlink($TMP, '/tmp/a.out');
print STDERR "done\n" if $trace;
print STDERR "@_\n" if $trace;
&panic("already got a template for $name") if defined $template{$name};
local($build_templates) = 1;
local($lparen) = '(' x $build_recursed;
local($rparen) = ')' x $build_recursed;
print STDERR "$lparen$name$rparen " if $trace;
print STDERR "TEMPLATE for $name is ", $template{&psou($name)}, "\n" if $debug;
exit 1 if $] <= 4.003; # caller broken
local($p,$f,$l,$s,$h,$a,@a,@sub);
for ($i = 0; ($p,$f,$l,$s,$h,$w) = caller($i); $i++) {
if (/^StB\000/ && length($_) == length($_main{'_main'})) {
s/([^\0]*)/'$1'/ unless /^-?[\d.]+$/;
s/([\200-\377])/sprintf("M-%c",ord($1)&0177)/eg;
s/([\0-\37\177])/sprintf("^%c",ord($1)^64)/eg;
$w = $w ? '@ = ' : '$ = ';
$a = $h ? '(' . join(', ', @a) . ')' : '';
push(@sub, "$w&$s$a from file $f line $l\n");
for ($i=0; $i <= $#sub; $i++) {
while (defined($num = shift)) {
if ($num == ($last + 1)) {
$string .= $seq unless $inseq++;
$string .= $last unless $last == -1e8;
$string .= ',' if defined $string;
$string .= $last if $inseq && $last != -e18;