ucdata.cc

Go to the documentation of this file.

/*
 *  Copyright (C) 2001-2002  The Exult Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <cstdlib>
#include <vector>
#include "ucdata.h"
#include "ops.h"
#include "files/utils.h"

using std::cout;
using std::setw;
using std::endl;
using std::vector;
using std::setbase;
using std::setfill;
using std::string;
using std::ostream;

UCData::UCData() : _search_opcode(-1), _search_intrinsic(-1)
{
}

UCData::~UCData()
{
  _file.close();
  for(unsigned int i=0; i<_funcs.size(); i++)
    delete _funcs[i];
}

void UCData::parse_params(const unsigned int argc, char **argv)
{
  /* Parse command line */
  for(unsigned int i=1; i<argc; i++)
  {
    if     (strcmp(argv[i], "-si"   )==0) options._game = UCOptions::GAME_SI;
    else if(strcmp(argv[i], "-bg"   )==0) options._game = UCOptions::GAME_BG;
    else if(strcmp(argv[i], "-u8"   )==0) options._game = UCOptions::GAME_U8;

    else if(strcmp(argv[i], "-a"    )==0) options.mode_all=true;

    else if(strcmp(argv[i], "-nc"   )==0) options.noconf  = true;
    else if(strcmp(argv[i], "-ro"   )==0) options.rawops  = true;
    else if(strcmp(argv[i], "-ac"   )==0) options.autocomment = true;
    else if(strcmp(argv[i], "-uc"   )==0) options.uselesscomment = true;
    else if(strcmp(argv[i], "-v"    )==0) options.verbose = true;
    else if(strcmp(argv[i], "-vv"   )==0) { options.verbose = options.very_verbose = true; }
    else if(strcmp(argv[i], "-dbg"  )==0) options.ucdebug = true;
    else if(strcmp(argv[i], "-ext32")==0) options.force_ext32 = true;
    else if(strcmp(argv[i], "-b"    )==0) options.basic = true;

    else if(strcmp(argv[i], "-fl"   )==0) options.output_list = true;
    else if(strcmp(argv[i], "-fa"   )==0) options.output_asm  = true;
    else if(strcmp(argv[i], "-fz"   )==0) options.output_ucs  = true;
    else if(strcmp(argv[i], "-fs"   )==0) options.output_ucs  = true;
    else if(strcmp(argv[i], "-ff"   )==0) options.output_flag = true;
    else if(strcmp(argv[i], "-ftt"  )==0) options.output_trans_table = true;

    else if(strcmp(argv[i], "--extern-header" )==0) options.output_extern_header = true;
    
    else if(argv[i][0] != '-')
    {
      char* stopstr;
      /* Disassembly mode */
      unsigned int search_func = strtoul(argv[i], &stopstr, 16);
      if( stopstr - argv[i] < static_cast<int>(strlen(argv[i])) )
        /* Invalid number */
      { /* Do Nothing */ }
      else
      {
        search_funcs.push_back(search_func);
        if(options.verbose) cout << "Disassembling Function: " << search_func << endl;
        options.mode_dis = true;
      }
    }
    else if((string(argv[i]).size()>2) && string(argv[i]).substr(0, 2)=="-o")
    {
      _output_redirect = string(argv[i]).substr(2, string(argv[i]).size()-2);
      if(options.verbose) cout << "Outputting to filename: " << _output_redirect << endl;
    }
    else if((string(argv[i]).size()>2) && string(argv[i]).substr(0, 2)=="-i")
    {
      _input_usecode_file = string(argv[i]).substr(2, string(argv[i]).size()-2);
      if(options.verbose) cout << "Inputting from file: " << _input_usecode_file << endl;
    }
    else
    {
      cout << "unsupported parameter " << argv[i] << " detected. countinuing." << endl;
    }
  }
}

void UCData::open_usecode(const string &filename)
{
  file_open(filename);
  
  if(fail())
    return;
}

// FIXME: Pass ostream to this, rather then cout-ing everything
void UCData::disassamble()
{
  load_funcs();

  if(options.verbose)
  {
    for(vector<unsigned int>::iterator i=search_funcs.begin(); i!=search_funcs.end(); i++)
      cout << "Looking for function number " << setw(8) << (*i) << endl;
    cout << endl;
  }
  
  if(options.output_list)
    cout << "Function       offset    size  data  code" << (options.ucdebug ? " funcname" : "") << endl;

  if(options.output_trans_table)
    cout << "<trans>" << endl;
    
  bool _foundfunc=false; //did we find and print the function?
  for(unsigned int i=0; i<_funcs.size(); i++)
  {
    if(options.mode_all || (options.mode_dis && count(search_funcs.begin(), search_funcs.end(), _funcs[i]->_funcid)))
    {
      _foundfunc=true;
      bool _func_printed=false; // to test if we've actually printed a function ouput

      if(options.output_list)
        _func_printed = _funcs[i]->output_list(cout, i, options);
      
      if(options.output_ucs)
      {
        _funcs[i]->parse_ucs(_funcmap, uc_intrinsics, options);
        _func_printed = _funcs[i]->output_ucs(cout, _funcmap, uc_intrinsics, options);
        //_func_printed=true;
      }

      if(options.output_trans_table)
      {
        _func_printed=_funcs[i]->output_tt(cout);
        //_func_printed=true;
      }
      
      // if we haven't printed one by now, we'll print an asm output.
      if(options.output_asm || (_func_printed==false))
        _funcs[i]->output_asm(cout, _funcmap, uc_intrinsics, options);
    }
  }

  if(!_foundfunc)
    printf("Function not found.\n");

  if(search_funcs.size()==0)
  {
    printf("Functions: %d\n", _funcs.size());
  }

  if(options.output_list)
    cout << endl << "Functions: " << setbase(10) << _funcs.size() << setbase(16) << endl;
  
  if(options.output_trans_table)
    cout << "</>" << endl;
    
  cout << endl;
}

/* FIXME: Need to remove the hard coded opcode numbers (0x42 and 0x43) and replace them
  with 'variables' in the opcodes.txt file, that signify if it's a pop/push and a flag */
void UCData::dump_flags(ostream &o)
{
  if(!(options.game_bg() || options.game_si()))
  {
    o << "This option only works for U7:BG and U7:SI" << endl;
    return;
  }
  load_funcs();
  
  if(options.verbose) cout << "Finding flags..." << endl;
  vector<FlagData> flags;

  // *BLEH* ugly!
  for(vector<UCFunc *>::iterator func=_funcs.begin(); func!=_funcs.end(); func++)
    for(vector<UCc>::iterator op=(*func)->_opcodes.begin(); op!=(*func)->_opcodes.end(); op++)
    {
      if(op->_id==0x42)
        flags.push_back(FlagData((*func)->_funcid, op->_offset, op->_params_parsed[0], FlagData::GETFLAG));
      else if(op->_id==0x43)
        flags.push_back(FlagData((*func)->_funcid, op->_offset, op->_params_parsed[0], FlagData::SETFLAG));
    }
    
  o << "Number of flags found: " << setbase(10) << flags.size() << endl << endl;

  // output per function
  {
    sort(flags.begin(), flags.end(), SortFlagDataLessFunc());
    
    o << setbase(16) << setfill('0');
    int currfunc = -1;
    for(unsigned int i=0; i<flags.size(); i++)
    {
      if(currfunc!=flags[i].func())
      {
        o << "Function: " << setw(4) << flags[i].func() << endl;
        currfunc=flags[i].func();
        o << "              flag  offset" << endl;
      }
      
      o << "        ";
      if(flags[i].access()==FlagData::GETFLAG)
        o << "push  ";
      else if(flags[i].access()==FlagData::SETFLAG)
        o << "pop   ";
      o << setw(4) << flags[i].flag()   << "  "
        << setw(4) << flags[i].offset() << endl;
    }
  }
  
  // output per flag
  {
    sort(flags.begin(), flags.end(), SortFlagDataLessFlag());
    
    o << setbase(16) << setfill('0');
    unsigned int currflag = static_cast<unsigned int>(-1);
    for(unsigned int i=0; i<flags.size(); i++)
    {
      if(currflag!=flags[i].flag())
      {
        o << "Flag: " << setw(4) << flags[i].flag() << endl;
        currflag=flags[i].flag();
        o << "              func  offset" << endl;
      }
    
    o << "        ";
    if(flags[i].access()==FlagData::GETFLAG)
      o << "push  ";
    else if(flags[i].access()==FlagData::SETFLAG)
      o << "pop   ";
    o << setw(4) << flags[i].func()   << "  "
      << setw(4) << flags[i].offset() << endl;
    }
  }
}

void UCData::file_open(const string &filename)
{
  /* Open a usecode file */
  U7open(_file, filename.c_str(), false);
}

#undef LOAD_SPEED_TEST

#ifdef LOAD_SPEED_TEST
#include "tools/dbgutils.h"
#endif

void UCData::load_funcs()
{
  if(options.verbose) cout << "Loading functions..." << endl;
  
  #ifdef LOAD_SPEED_TEST
  dbg::DateDiff dd;
  dbg::timeDateDiff(cout);
  dd.start();
  #endif
  
  bool eof=false;
  while( !eof )
  {
    UCFunc *ucfunc = new UCFunc();

    if(options.game_bg() || options.game_si())
      readbin_U7UCFunc(_file, *ucfunc, options);
    else if(options.game_u8())
      readbin_U8UCFunc(_file, *ucfunc);
    else
      exit(-1); // can't happen
    
    /* if we're forcing ext32 on output, this is where we do so.
      if we try doing it before reading it, it'll get corrupted. */
    if(options.force_ext32) ucfunc->ext32=true;
    
    _funcs.push_back(ucfunc);
    {
      _file.get();
      eof = _file.eof();
      _file.unget();
    }
  }
  
  #ifdef LOAD_SPEED_TEST
  dd.end();
  cout << setbase(10) << setfill(' ');
  dd.print_start(cout) << endl;
  dd.print_end(cout) << endl;
  dd.print_diff(cout) << endl;
  cout << setbase(16) << setfill('0');
  #endif
  
  if(options.verbose) cout << "Creating function map..." << endl;
  
  for(vector<UCFunc *>::iterator i=_funcs.begin(); i!=_funcs.end(); i++)
  {
    _funcmap.insert(FuncMapPair((*i)->_funcid, UCFuncSet((*i)->_funcid, (*i)->_num_args, (*i)->return_var, (*i)->funcname)));
  }
/*  for(map<unsigned int, UCFuncSet>::iterator i=_funcmap.begin(); i!=_funcmap.end(); i++)
    cout << i->first << "\t" << i->second.num_args << endl;*/
}

void UCData::output_extern_header(ostream &o)
{
  if(!(options.game_bg() || options.game_si()))
  {
    o << "This option only works for U7:BG and U7:SI" << endl;
    return;
  }
  load_funcs();

  for(vector<UCFunc *>::iterator func=_funcs.begin(); func!=_funcs.end(); func++)
  {
    //(*func)->output_ucs_funcname(o << "extern ", _funcmap, (*func)->_funcid, (*func)->_num_args, (*func)->return_var) << ';' << endl;
    (*func)->output_ucs_funcname(o << "extern ", _funcmap) << ';' << endl;
  }
}

---