examples/tools/pbc_checker.cpp

   1 /*
   2  * Copyright (C) 2009, Parrot Foundation.
   3  * $Id$
   4 */
   5
   6 // pbc_checker.cpp
   7 // A multiplatform checker for pbc files
   8
   9 #include <iostream>
  10 #include <fstream>
  11 #include <iomanip>
  12 #include <string>
  13 #include <vector>
  14 #include <algorithm>
  15 #include <functional>
  16 #include <stdexcept>
  17
  18 // Get most used symbols from std namespace
  19 using std::cout;
  20 using std::cerr;
  21 using std::ifstream;
  22 using std::string;
  23 using std::hex;
  24 using std::dec;
  25 using std::setw;
  26 using std::setfill;
  27 using std::runtime_error;
  28
  29 //**********************************************************************
  30
  31 // Type used to read parrot opcodes
  32 // You can use unsigned long here if your compiler does not support
  33 // long long, but in that case the results might not be accurate.
  34
  35 typedef unsigned long long opcode;
  36
  37 // Constants used in pbc and his descriptions
  38
  39 const char unknown[] = "Unknown";
  40
  41 const unsigned char
  42     ByteOrderLE = 0,
  43     ByteOrderBE = 1;
  44
  45 const char * desc_byte_order(unsigned char c)
  46 {
  47     switch(c) {
  48         case ByteOrderLE: return "Little endian";
  49         case ByteOrderBE: return "Big endian";
  50         default: return unknown;
  51     }
  52 }
  53
  54 const unsigned char
  55     FpEncodingIEEE_754_8 = 0,
  56     FpEncodingIEEE_i386_12 = 1,
  57     FpEncodingIEEE_754_16 = 2;
  58
  59 const char * desc_fp_encoding(unsigned char c)
  60 {
  61     switch(c) {
  62         case FpEncodingIEEE_754_8:  return "IEEE 754 8 byte double";
  63         case FpEncodingIEEE_i386_12:  return "i386 little endian 12 byte long double";
  64         case FpEncodingIEEE_754_16:  return "IEEE 754 16 byte long double";
  65         default: return unknown;
  66     }
  67 }
  68
  69 const char * desc_uuid_type(unsigned char c)
  70 {
  71     switch(c) {
  72         case 0:  return "none";
  73         case 1:  return "MD5";
  74         default: return unknown;
  75     }
  76 }
  77
  78 const opcode
  79     SegmentTypeDirectory     = 0x00,
  80     SegmentTypeDefault       = 0x01,
  81     SegmentTypeFixup         = 0x02,
  82     SegmentTypeConstantTable = 0x03,
  83     SegmentTypeBytecode      = 0x04,
  84     SegmentTypePIRDebug      = 0x05,
  85     SegmentTypeAnnotations   = 0x06,
  86     SegmentTypePICData       = 0x07,
  87     SegmentTypeDependencies  = 0x08;
  88
  89 const char * desc_segment_type(opcode t)
  90 {
  91     switch(t) {
  92         case SegmentTypeDirectory:     return "Directory";
  93         case SegmentTypeDefault:       return "Default";
  94         case SegmentTypeFixup:         return "Fixup";
  95         case SegmentTypeConstantTable: return "Constant table";
  96         case SegmentTypeBytecode:      return "Bytecode";
  97         case SegmentTypePIRDebug:      return "PIR Debug";
  98         case SegmentTypeAnnotations:   return "Annotations";
  99         case SegmentTypePICData:       return "PIC Data";
 100         case SegmentTypeDependencies:  return "Dependencies";
 101         default:                       return unknown;
 102     }
 103 }
 104
 105 const opcode
 106     ConstantTypeNone =   0x00,
 107     ConstantTypeNumber = 0x6E,
 108     ConstantTypeString = 0x73,
 109     ConstantTypePMC    = 0x70,
 110     ConstantTypeKey    = 0x6B;
 111
 112 const char * desc_constant_type(opcode t)
 113 {
 114     switch(t) {
 115         case ConstantTypeNone:   return "None";
 116         case ConstantTypeNumber: return "Number";
 117         case ConstantTypeString: return "String";
 118         case ConstantTypePMC:    return "PMC";
 119         case ConstantTypeKey:    return "Key";
 120         default:                 return unknown;
 121     }
 122 }
 123
 124 const opcode
 125     KeyIntegerRegister = 0x00,
 126     KeyStringRegister  = 0x01,
 127     KeyPMCRegister     = 0x02,
 128     KeyNumberRegister  = 0x03,
 129     KeyIntegerConstant = 0x10,
 130     KeyStringConstant  = 0x11,
 131     KeyPMCConstant     = 0x12,
 132     KeyNumberConstant  = 0x13;
 133
 134 const char * desc_key_type(opcode t)
 135 {
 136     switch (t) {
 137         case KeyIntegerRegister: return "Integer register";
 138         case KeyStringRegister:  return "String register";
 139         case KeyPMCRegister:     return "PMC register";
 140         case KeyNumberRegister:  return "Number register";
 141         case KeyIntegerConstant: return "Integer constant";
 142         case KeyStringConstant:  return "String constant";
 143         case KeyPMCConstant:     return "PMC constant";
 144         case KeyNumberConstant:  return "Number constant";
 145         default:                 return unknown;
 146     }
 147 }
 148
 149 const opcode
 150     AnnotationTypeInteger = 0x00,
 151     AnnotationTypeString =  0x01,
 152     AnnotationTypeNumber =  0x02,
 153     AnnotationTypePMC =     0x03;
 154
 155 const char * desc_annotation_type(opcode t)
 156 {
 157     switch(t) {
 158         case AnnotationTypeInteger: return "Integer";
 159         case AnnotationTypeString:  return "String";
 160         case AnnotationTypeNumber:  return "Number";
 161         case AnnotationTypePMC:     return "PMC";
 162         default:                    return unknown;
 163     }
 164 }
 165
 166 //**********************************************************************
 167
 168 class ReadError : public runtime_error
 169 {
 170 public:
 171     ReadError(const string &msg);
 172 };
 173
 174 ReadError::ReadError(const string &msg) :
 175     runtime_error("Error reading " + msg)
 176 {
 177 }
 178
 179 //**********************************************************************
 180
 181 void signature(ifstream &pbcfile)
 182 {
 183     static const char pbc_signature [] = {
 184         0xFE, 0x50, 0x42, 0x43, 0x0D, 0x0A, 0x1A, 0x0A
 185     };
 186     char signature [sizeof (pbc_signature)];
 187     pbcfile.read(signature, sizeof (signature));
 188     if (pbcfile.gcount() != sizeof (signature))
 189         throw ReadError("pbc signature");
 190     if (! std::equal(pbc_signature, pbc_signature + sizeof(pbc_signature),
 191             signature))
 192         throw runtime_error("Invalid pbc signature");
 193 }
 194
 195 //**********************************************************************
 196
 197 // Emit a open tag in the constructor
 198 // and his closing in the destructor.
 199
 200 class TagEmit
 201 {
 202 public:
 203     TagEmit(const string & name_n, std::ostream &os_n);
 204     ~TagEmit();
 205 private:
 206     string name;
 207     std::ostream &os;
 208 };
 209
 210 TagEmit::TagEmit(const string & name_n, std::ostream &os_n) :
 211     name(name_n), os(os_n)
 212 {
 213     os << '<' << name << ">\n";
 214 }
 215
 216 TagEmit::~TagEmit()
 217 {
 218     os << "</" << name << ">\n";
 219 }
 220
 221 //**********************************************************************
 222
 223 class DirEntry
 224 {
 225 public:
 226     DirEntry(string name_n, opcode type_n,
 227         opcode offset_n, opcode length_n);
 228     string getName() const;
 229     opcode getType() const;
 230     opcode getOffset() const;
 231     opcode getLength() const;
 232 private:
 233     string name;
 234     opcode type;
 235     opcode offset;
 236     opcode length;
 237 };
 238
 239 DirEntry::DirEntry(string name_n, opcode type_n,
 240         opcode offset_n, opcode length_n) :
 241     name(name_n),
 242     type(type_n),
 243     offset(offset_n),
 244     length(length_n)
 245 {
 246 }
 247
 248 string DirEntry::getName() const
 249 {
 250     return name;
 251 }
 252
 253 opcode DirEntry::getType() const
 254 {
 255     return type;
 256 }
 257
 258 opcode DirEntry::getOffset() const
 259 {
 260     return offset;
 261 }
 262
 263 opcode DirEntry::getLength() const
 264 {
 265     return length;
 266 }
 267
 268 bool operator < (const DirEntry & de1, const DirEntry & de2)
 269 {
 270     return de1.getOffset() < de2.getOffset();
 271 }
 272
 273 //**********************************************************************
 274
 275 // Check that segments does not overlap
 276
 277 void check_overlap(const std::vector<DirEntry> & directory)
 278 {
 279     unsigned int entries = directory.size();
 280     for (unsigned int i= 0; i < entries; ++i)
 281     {
 282         opcode offset = directory[i].getOffset();
 283         opcode length = directory[i].getLength();
 284         opcode after = offset + length;
 285         for (unsigned int j= i + 1; j < entries; ++j) {
 286             opcode offset2 = directory[j].getOffset();
 287             if (offset2 >= offset && offset2 < after)
 288                 throw runtime_error("overlap");
 289             opcode after2 = offset2 + directory[j].getLength();
 290             if (offset >= offset2 && offset < after2)
 291                 throw runtime_error("overlap");
 292         }
 293     }
 294 }
 295
 296 //**********************************************************************
 297
 298 class PbcFile
 299 {
 300 public:
 301     PbcFile();
 302     void read(const char *filename);
 303     void read_header(ifstream &pbcfile);
 304     void check_directory_format(ifstream &pbcfile);
 305     void read_directory(ifstream &pbcfile);
 306     void dump_segment(const DirEntry & entry, ifstream &pbcfile);
 307     void dump_segment_default(ifstream &pbcfile);
 308     void dump_segment_fixup(ifstream &pbcfile);
 309     void dump_segment_constant(ifstream &pbcfile);
 310     void dump_segment_bytecode(ifstream &pbcfile);
 311     void dump_segment_pir_debug(ifstream &pbcfile);
 312     void dump_segment_annotations(ifstream &pbcfile);
 313     void dump_segment_pic_data(ifstream &pbcfile);
 314     void dump_segment_dependencies(ifstream &pbcfile);
 315     void dump_constant_string(ifstream &pbcfile);
 316     void dump_constant_number(ifstream &pbcfile);
 317     void dump_constant_key(ifstream &pbcfile);
 318     void dump_bytes_hex(ifstream &pbcfile, opcode length);
 319     string read_cstring(ifstream &pbcfile);
 320     opcode read_opcode(ifstream &pbcfile);
 321 private:
 322     unsigned int opcode_size;
 323     unsigned int pbc_version;
 324
 325     unsigned char byte_order;
 326     unsigned char fp_encoding;
 327
 328     std::vector<DirEntry> directory;
 329 };
 330
 331 PbcFile::PbcFile()
 332 {
 333     opcode_size = 0;
 334 }
 335
 336 void PbcFile::read(const char *filename)
 337 {
 338     ifstream pbcfile(filename);
 339     if (! pbcfile.is_open())
 340         throw runtime_error("Can't open file");
 341
 342     TagEmit filetag("PbcFile", cout);
 343
 344     read_header(pbcfile);
 345
 346     check_directory_format(pbcfile);
 347     read_directory(pbcfile);
 348     check_overlap(directory);
 349
 350     std::sort(directory.begin(), directory.end());
 351
 352     TagEmit tag("Segments", cout);
 353     for (size_t i= 0; i < directory.size(); ++i)
 354         dump_segment(directory[i], pbcfile);
 355 }
 356
 357 void PbcFile::read_header(ifstream &pbcfile)
 358 {
 359     TagEmit tag("Header", cout);
 360
 361     signature(pbcfile);
 362     unsigned char opcode_size = pbcfile.get();
 363     unsigned char byte_order = pbcfile.get();
 364     unsigned char fp_encoding = pbcfile.get();
 365     unsigned char major = pbcfile.get();
 366     unsigned char minor = pbcfile.get();
 367     unsigned char patch = pbcfile.get();
 368     unsigned char pbc_major = pbcfile.get();
 369     unsigned char pbc_minor = pbcfile.get();
 370
 371     if (!pbcfile)
 372         throw ReadError("pbc header data");
 373
 374     cout <<
 375         "Opcode size            : " << (int) opcode_size << '\n' <<
 376         "Byte order             : " << desc_byte_order(byte_order) <<
 377                 " (" << (int) byte_order << ")\n" <<
 378         "Floating point encoding: " << desc_fp_encoding(fp_encoding) <<
 379                 " (" << (int) fp_encoding << ")\n" <<
 380         "Parrot version         : " <<
 381         (int) major << '.' << (int) minor << '.' << (int) patch << '\n' <<
 382         "PBC version            : " <<
 383         (int) pbc_major << '.' << (int) pbc_minor << '\n'
 384         ;
 385
 386     if (opcode_size > sizeof(opcode))
 387         cerr << "*** Warning: opcode size too big for this program ***\n";
 388
 389     this->opcode_size = opcode_size;
 390     this->pbc_version = ((unsigned int) pbc_major) * 8 + pbc_minor;
 391     this->byte_order = byte_order;
 392     this->fp_encoding = fp_encoding;
 393     if (byte_order != ByteOrderLE && byte_order != ByteOrderBE)
 394         throw runtime_error("Invalid byte order");
 395
 396     unsigned char uuid_type = pbcfile.get();
 397     cout <<
 398         "UUID type              : " << desc_uuid_type(uuid_type) <<
 399                 " (" << (int) uuid_type << ")\n"
 400         ;
 401     unsigned char uuid_length = pbcfile.get();
 402     cout <<
 403         "UUID length            : " << (int) uuid_length << '\n'
 404         ;
 405     unsigned int curpos = 18 + uuid_length;
 406     unsigned int endheader = ((curpos + 15) / 16) * 16;
 407     pbcfile.ignore(endheader - 18);
 408 }
 409
 410 void PbcFile::check_directory_format(ifstream &pbcfile)
 411 {
 412     TagEmit tag("DirectoryFormat", cout);
 413
 414     opcode dir_format = read_opcode(pbcfile);
 415     cout << "Directory format: " << dir_format << '\n';
 416     if (dir_format != 1)
 417         throw runtime_error("Unknown directory format");
 418
 419     opcode unused = read_opcode(pbcfile);
 420     unused = read_opcode(pbcfile);
 421     unused = read_opcode(pbcfile);
 422
 423     for (opcode n = opcode_size * 4; n % 16; ++n)
 424         pbcfile.ignore(1);
 425 }
 426
 427 void PbcFile::read_directory(ifstream &pbcfile)
 428 {
 429     TagEmit tag("Directory", cout);
 430
 431     opcode size = read_opcode(pbcfile);
 432     cout << "Directory segment size: " << size << '\n';
 433
 434     pbcfile.ignore(16 - opcode_size);
 435     if (pbc_version <= 0x0325 && opcode_size == 8)
 436         pbcfile.ignore(16);
 437
 438     opcode entries = read_opcode(pbcfile);
 439     cout << "Directory entries: " << entries << '\n';
 440
 441     for (unsigned int n= 0; n < entries; ++n)
 442     {
 443         opcode type = read_opcode(pbcfile);
 444         cout <<
 445             n << ": Type: '" << desc_segment_type(type) <<
 446                 " (" << type << ") "
 447             "' Name: '";
 448         string name = read_cstring(pbcfile);
 449         cout << name;
 450         opcode offset = read_opcode(pbcfile);
 451         opcode length = read_opcode(pbcfile);
 452         cout <<
 453             "'\n   Offset: " << offset << " Length: " << length << '\n';
 454         DirEntry entry(name, type, offset, length);
 455         directory.push_back(entry);
 456     }
 457 }
 458
 459 void PbcFile::dump_segment(const DirEntry &entry, ifstream &pbcfile)
 460 {
 461     cout << "Segment '" << entry.getName() << "'\n";
 462     opcode const type = entry.getType();
 463     cout << "Type: " << desc_segment_type(type) <<
 464         " (0x" << hex << type << dec << ")\n";
 465
 466     // Set file read position to segment's start
 467     pbcfile.seekg(entry.getOffset() * opcode_size);
 468
 469     switch(type)
 470     {
 471     case SegmentTypeDirectory:
 472         cout << "*** Unexpected directory segment ***\n";
 473         break;
 474     case SegmentTypeDefault:
 475         dump_segment_default(pbcfile);
 476         break;
 477     case SegmentTypeFixup:
 478         dump_segment_fixup(pbcfile);
 479         break;
 480     case SegmentTypeConstantTable:
 481         dump_segment_constant(pbcfile);
 482         break;
 483     case SegmentTypeBytecode:
 484         dump_segment_bytecode(pbcfile);
 485         break;
 486     case SegmentTypePIRDebug:
 487         dump_segment_pir_debug(pbcfile);
 488         break;
 489     case SegmentTypeAnnotations:
 490         dump_segment_annotations(pbcfile);
 491         break;
 492     case SegmentTypePICData:
 493         dump_segment_pic_data(pbcfile);
 494         break;
 495     case SegmentTypeDependencies:
 496         dump_segment_dependencies(pbcfile);
 497         break;
 498     default:
 499         cout << "*** Unknown segment type ***\n";
 500         break;
 501     }
 502 }
 503
 504 void PbcFile::dump_segment_default(ifstream &/*pbcfile*/)
 505 {
 506     TagEmit tag("SegmentDefault", cout);
 507     cout << "*** UNIMPLEMENTED ***\n";
 508 }
 509
 510 void PbcFile::dump_segment_fixup(ifstream &pbcfile)
 511 {
 512     TagEmit tag("SegmentFixup", cout);
 513
 514     opcode segsize = read_opcode(pbcfile);
 515     cout << "Segment size: " << segsize;
 516
 517     opcode itype = read_opcode(pbcfile);
 518     cout << " itype: " << itype;
 519     opcode id = read_opcode(pbcfile);
 520     cout << " id: " << id;
 521     opcode size = read_opcode(pbcfile);
 522     cout << " size: " << size;
 523
 524     opcode tablelength = read_opcode(pbcfile);
 525     cout << " Number of fixups: " << tablelength << '\n';
 526
 527     for (opcode n= 0; n < tablelength; ++n) {
 528         cout << "Fixup " << n;
 529         opcode type = read_opcode(pbcfile);
 530         cout << " Type: " <<
 531              " (0x" << hex << type << dec << ')';
 532         switch (type) {
 533             case 0x01:
 534                 {
 535                 opcode label = read_opcode(pbcfile);
 536                 cout << " Label: " << label;
 537                 opcode sub = read_opcode(pbcfile);
 538                 cout << " Sub: " << sub;
 539                 }
 540                 break;
 541             case 0x02:
 542                 {
 543                 string label = read_cstring(pbcfile);
 544                 cout << " Label: '" << label << '\'';
 545                 opcode sub = read_opcode(pbcfile);
 546                 cout << " Sub: " << sub;
 547                 }
 548                 break;
 549             default:
 550                 throw runtime_error("Invalid fixup");
 551         }
 552         cout << '\n';
 553     }
 554 }
 555
 556 void PbcFile::dump_segment_constant(ifstream &pbcfile)
 557 {
 558     TagEmit tag("SegmentConstantTable", cout);
 559
 560     opcode segsize = read_opcode(pbcfile);
 561     cout << "Segment size: " << segsize;
 562
 563     opcode itype = read_opcode(pbcfile);
 564     cout << " itype: " << itype;
 565     opcode id = read_opcode(pbcfile);
 566     cout << " id: " << id;
 567     opcode size = read_opcode(pbcfile);
 568     cout << " size: " << size;
 569
 570     opcode tablelength = read_opcode(pbcfile);
 571     cout << " Number of constants: " << tablelength << '\n';
 572
 573     for (opcode n= 0; n < tablelength; ++n) {
 574         cout << "Constant " << n;
 575         opcode type = read_opcode(pbcfile);
 576         cout << " Type: " << desc_constant_type(type) <<
 577              " (0x" << hex << type << dec << ") ";
 578         switch(type) {
 579             case ConstantTypeString:
 580             case ConstantTypePMC:
 581                 dump_constant_string(pbcfile);
 582                 break;
 583             case ConstantTypeNumber:
 584                 dump_constant_number(pbcfile);
 585                 break;
 586             case ConstantTypeKey:
 587                 dump_constant_key(pbcfile);
 588                 break;
 589             default:
 590                 throw runtime_error("Unknown constant type");
 591         }
 592     }
 593 }
 594
 595 void PbcFile::dump_segment_bytecode(ifstream &pbcfile)
 596 {
 597     TagEmit tag("SegmentBytecode", cout);
 598
 599     opcode segsize = read_opcode(pbcfile);
 600     cout << "Segment size: " << segsize;
 601
 602     opcode itype = read_opcode(pbcfile);
 603     cout << " itype: " << itype;
 604     opcode id = read_opcode(pbcfile);
 605     cout << " id: " << id;
 606     opcode size = read_opcode(pbcfile);
 607     cout << " size: " << size;
 608     cout << hex;
 609
 610     for (opcode n= 0; n < size; ++n) {
 611         opcode code = read_opcode(pbcfile);
 612         if ((n % 8) == 0)
 613             cout << '\n' << setfill('0') << setw (7) << n << ':';
 614         else
 615             cout << ' ';
 616         cout << setfill('0') << setw(opcode_size * 2) << code;
 617     }
 618     cout << dec << '\n';
 619 }
 620
 621 void PbcFile::dump_segment_pir_debug(ifstream &pbcfile)
 622 {
 623     TagEmit tag("SegmentPIRDebug", cout);
 624
 625     opcode segsize = read_opcode(pbcfile);
 626     cout << "Segment size: " << segsize;
 627
 628     opcode itype = read_opcode(pbcfile);
 629     cout << " itype: " << itype;
 630     opcode id = read_opcode(pbcfile);
 631     cout << " id: " << id;
 632     opcode size = read_opcode(pbcfile);
 633     cout << " size: " << size;
 634     cout << '\n';
 635
 636     opcode tablelength = size;
 637     for (opcode n= 0; n < tablelength; ++n) {
 638         opcode linenum = read_opcode(pbcfile);
 639         cout << " Line: " << linenum;
 640     }
 641     cout << '\n';
 642
 643     opcode mappings = read_opcode(pbcfile);
 644     cout << "Mappings: " << mappings << '\n';
 645     for (opcode n= 0; n < mappings; ++n) {
 646         cout << "  " << n;
 647         opcode offset = read_opcode(pbcfile);
 648         cout << " Offset: " << offset;
 649         opcode filename = read_opcode(pbcfile);
 650         cout << " File: " << filename;
 651         cout << '\n';
 652     }
 653 }
 654
 655 void PbcFile::dump_segment_annotations(ifstream &pbcfile)
 656 {
 657     TagEmit tag("SegmentAnnotations", cout);
 658
 659     opcode segsize = read_opcode(pbcfile);
 660     cout << "Segment size: " << segsize;
 661
 662     opcode itype = read_opcode(pbcfile);
 663     cout << " itype: " << itype;
 664     opcode id = read_opcode(pbcfile);
 665     cout << " id: " << id;
 666     opcode size = read_opcode(pbcfile);
 667     cout << " size: " << size;
 668     cout << '\n';
 669
 670     opcode tablelength = read_opcode(pbcfile);
 671     cout << "Number of annotations: " << tablelength << '\n';
 672
 673     for (opcode i= 0; i < tablelength; ++i) {
 674         cout << i;
 675         opcode name = read_opcode(pbcfile);
 676         cout << " Name: " << name;
 677         opcode type = read_opcode(pbcfile);
 678         cout << " Type: " << desc_annotation_type(type) << '\n';
 679     }
 680
 681     opcode grouplength = read_opcode(pbcfile);
 682     cout << "Number of annotation groups: " << grouplength << '\n';
 683     for (opcode i= 0; i < grouplength; ++i) {
 684         cout << i;
 685         opcode bcpos = read_opcode(pbcfile);
 686         cout << " Bytecode offset: " << bcpos;
 687         opcode value = read_opcode(pbcfile);
 688         cout << " Value: " << value << '\n';
 689     }
 690
 691     opcode mappings = read_opcode(pbcfile);
 692     cout << "Number of mappings: " << mappings << '\n';
 693     for (opcode i= 0; i < mappings; ++i) {
 694         cout << i;
 695         opcode bcpos = read_opcode(pbcfile);
 696         cout << " Bytecode offset: " << bcpos;
 697         opcode annotation = read_opcode(pbcfile);
 698         cout << " Annotation key: " << annotation;
 699         opcode value = read_opcode(pbcfile);
 700         cout << " Value: " << value << '\n';
 701     }
 702 }
 703
 704 void PbcFile::dump_segment_pic_data(ifstream &/*pbcfile*/)
 705 {
 706     TagEmit tag("SegmentPICData", cout);
 707     cout << "*** UNIMPLEMENTED ***\n";
 708 }
 709
 710 void PbcFile::dump_segment_dependencies(ifstream &/*pbcfile*/)
 711 {
 712     TagEmit tag("SegmentDependencies", cout);
 713     cout << "*** UNIMPLEMENTED ***\n";
 714 }
 715
 716 void PbcFile::dump_constant_string(ifstream &pbcfile)
 717 {
 718     opcode flags = read_opcode(pbcfile);
 719     cout << "Flags: 0x" << hex << flags << dec;
 720     opcode charset = read_opcode(pbcfile);
 721     cout << " Charset: " << charset;
 722
 723     //opcode encoding = read_opcode(pbcfile);
 724     //cout << " Encoding: "<< encoding;
 725
 726     opcode length = read_opcode(pbcfile);
 727     cout << " Length: "<< length;
 728     cout << " \'";
 729     for (opcode i= 0; i < length; ++i) {
 730         unsigned char c = pbcfile.get();
 731         if (c >= 32 && c < 128)
 732             cout << c;
 733         else
 734             cout << "\\x" << hex << setw(2) << setfill('0') <<
 735                 (unsigned int) c << dec;
 736     }
 737     cout << "'\n";
 738     for (unsigned int i= length; i % opcode_size; ++i) {
 739         pbcfile.ignore(1);
 740     }
 741 }
 742
 743 void PbcFile::dump_constant_number(ifstream &pbcfile)
 744 {
 745     cout << "Number constant: ";
 746     switch(fp_encoding) {
 747         case FpEncodingIEEE_754_8:
 748             dump_bytes_hex(pbcfile, 8);
 749             break;
 750         case FpEncodingIEEE_i386_12:
 751             dump_bytes_hex(pbcfile, 12);
 752             break;
 753         case FpEncodingIEEE_754_16:
 754             dump_bytes_hex(pbcfile, 16);
 755             break;
 756         default:
 757             // This must have been catched before reaching this point
 758             throw std::logic_error("Bad number type");
 759     }
 760 }
 761
 762 void PbcFile::dump_constant_key(ifstream &pbcfile)
 763 {
 764     opcode components = read_opcode(pbcfile);
 765     cout << "Key components: " << components << '\n';
 766     for (opcode i= 0; i < components; ++i) {
 767         cout << "  " << i << ' ';
 768         opcode type = read_opcode(pbcfile);
 769         cout << "Type: " << desc_key_type (type) <<
 770             " (0x" << hex << type << dec << ") ";
 771         opcode value = read_opcode(pbcfile);
 772         cout << "Value: " << value << '\n';
 773     }
 774 }
 775
 776 void PbcFile::dump_bytes_hex(ifstream &pbcfile, opcode length)
 777 {
 778     cout << "0x" << hex;
 779     for (opcode i= 0; i < length; ++i) {
 780         unsigned char c = pbcfile.get();
 781         cout << setw(2) << setfill('0') << (unsigned int) c;
 782     }
 783     cout << dec << '\n';
 784 }
 785
 786 string PbcFile::read_cstring(ifstream &pbcfile)
 787 {
 788     string r;
 789     char c;
 790     while ((c= pbcfile.get())) {
 791         r+= c;
 792     }
 793
 794     // cstrings are padded with trailing zeroes to opcode size
 795     for (opcode l = r.size() + 1; l % opcode_size; ++l)
 796         pbcfile.ignore(1);
 797
 798     if(! pbcfile)
 799         throw ReadError("cstring");
 800     return r;
 801 }
 802
 803 opcode PbcFile::read_opcode(ifstream &pbcfile)
 804 {
 805     unsigned char buffer [32]; // Allow 256 bits opcode size
 806     pbcfile.read((char *)buffer, opcode_size);
 807     if (static_cast<unsigned int>(pbcfile.gcount()) != opcode_size)
 808         throw ReadError("opcode");
 809
 810     opcode result = 0;
 811     switch(byte_order)
 812     {
 813     case ByteOrderLE:
 814         for (unsigned int i= 0; i < opcode_size; ++i) {
 815             result <<= 8;
 816             result += buffer [opcode_size - 1 - i];
 817         }
 818         break;
 819     case ByteOrderBE:
 820         for (unsigned int i= 0; i < opcode_size; ++i) {
 821             result <<= 8;
 822             result += buffer [i];
 823         }
 824         break;
 825     default:
 826         // This must have been catched before reaching this point
 827         throw std::logic_error("Bad byte order");
 828     }
 829     return result;
 830 }
 831
 832 //**********************************************************************
 833
 834 void pbc_checker_main(int argc, char **argv)
 835 {
 836     if (argc < 2)
 837         throw runtime_error("Bad args");
 838
 839     PbcFile pbcfile;
 840     pbcfile.read(argv[1]);
 841 }
 842
 843 //**********************************************************************
 844
 845 int main(int argc, char **argv)
 846 {
 847     try
 848     {
 849         pbc_checker_main(argc, argv);
 850         return 0;
 851     }
 852     catch(std::
 853     exception &e)
 854     {
 855         cerr << "FAILED: " << e.what() << '\n';
 856     }
 857     return 1;
 858 }
 859
 860 // End of pbc_checker.cpp
 861 /*
 862  * Local variables:
 863  *   c-file-style: "parrot"
 864  * End:
 865  * vim: expandtab shiftwidth=4:
 866  */