ucfunc.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 "ucdata.h"
#include "ucfunc.h"
#include <set>
#ifdef HAVE_SSTREAM
#include <sstream>
#else
#include <strstream>
#endif
#include <algorithm>
#include <iomanip>
#include "files/utils.h"

#include "ops.h"

#if 0
  #define DEBUG_INDENT
  #define DEBUG_PARSE
  #define DEBUG_PARSE2
  #define DEBUG_PARSE2a
  #define DEBUG_READ
  #define DEBUG_PRINT
  #define DEBUG_READ_PAIR(X, Y) cout << '\t' << X << '\t' << Y << endl;
#else
  #undef DEBUG_INDENT
  #undef DEBUG_PARSE
  #undef DEBUG_PARSE2
  #undef DEBUG_READ
  #undef DEBUG_PRINT
  #define DEBUG_READ_PAIR(X, Y)
#endif

//#define DEBUG_PARSE2
//#define DEBUG_PARSE2a
//#define DEBUG_PRINT

using std::ostream;
using std::ifstream;
using std::string;
using std::vector;
using std::map;
using std::endl;
using std::pair;
using std::ios;
using std::streampos;
using std::cout;
using std::setw;
using std::less;

const string VARNAME = "var";
const string VARPREFIX = "var";

string demunge_ocstring(UCFunc &ucf, const FuncMap &funcmap, const string &asmstr, const vector<unsigned int> &params, const map<unsigned int, string> &intrinsics, const UCc &op, bool ucs_output);

/* Assumption the 'var's are in their 'zeroed' state on initialization,
   unless something else is assigned to them. */

inline ostream &tab_indent(const unsigned int indent, ostream &o)
{
  #ifdef DEBUG_INDENT
  o << indent;
  #endif
  
  switch(indent)
  {
    case 0:                    break;
    case 1: o << '\t';         break;
    case 2: o << "\t\t";       break;
    case 3: o << "\t\t\t";     break;
    case 4: o << "\t\t\t\t";   break;
    case 5: o << "\t\t\t\t\t"; break;
    default:
      for(unsigned int i=0; i<indent; ++i) o << '\t';
      break;
  }
  return o;
}

/* Outputs the short function data 'list' format, returns true upon success */
bool UCFunc::output_list(ostream &o, unsigned int funcno, const UCOptions &options)
{
  o << "#" << std::setbase(10) << std::setw(4) << funcno << std::setbase(16) << ": "
    << (return_var ? '&' : ' ')
    << std::setw(4) << _funcid    << "H  "
    << std::setw(8) << _offset    << "  "
    << std::setw(4) << _funcsize  << "  "
    << std::setw(4) << _datasize  << "  "
    << std::setw(4) << codesize() << "  ";
  
  if(options.ucdebug)
    o << _data.find(0)->second;
  
  o << endl;
  
  return true;
}

/* Outputs the usecode-script formatted usecode, returns true upon success */
bool UCFunc::output_ucs(ostream &o, const FuncMap &funcmap, const map<unsigned int, string> &intrinsics, const UCOptions &options)
{
  unsigned int indent=0;
  
  if(_externs.size()) tab_indent(indent, o) << "// externs" << endl;
  // output the 'externs'
  for(vector<unsigned int>::iterator e=_externs.begin(); e!=_externs.end(); e++)
  {
    FuncMap::const_iterator fmp = funcmap.find(*e);
    output_ucs_funcname(tab_indent(indent, o) << "extern ", funcmap, *e, fmp->second.num_args, fmp->second.return_var) << ';' << endl;
  }
  
  if(_externs.size()) o << endl;
  
  // output the function name
  output_ucs_funcname(tab_indent(indent, o), funcmap, _funcid, _num_args, return_var) << endl;
  // start of func
  tab_indent(indent++, o) << '{' << endl;
  
  for(unsigned int i=_num_args; i<_num_args+_num_locals; i++)
    tab_indent(indent, o) << VARNAME << ' ' << VARPREFIX << std::setw(4) << i << ';' << endl;
    
  if(return_var) tab_indent(indent, o) << VARNAME << ' ' << "rr" << ';' << endl;
  
  if(_num_locals>0) o << endl;
  
  output_ucs_data(o, funcmap, intrinsics, options, indent);
  
  tab_indent(--indent, o) << '}' << endl;
  
  return true;
}

/* outputs the general 'function name' in long format. For function
  declarations and externs */
ostream &UCFunc::output_ucs_funcname(ostream &o, const FuncMap &funcmap,
                                     unsigned int funcid,
                                     unsigned int numargs, bool return_var)
{
  // do we return a variable
  if(return_var) o << VARNAME << ' ';
  
  // output the "function name"
  // TODO: Probably want to grab this from a file in the future...
  //o << demunge_ocstring(*this, funcmap, "%f1", ucc._params_parsed, intrinsics, ucc, true)
  
  FuncMap::const_iterator fmp = funcmap.find(funcid);
  if(fmp->second.funcname.size())
  {
    if(fmp->second.funcname[0]=='&')
      o << fmp->second.funcname.substr(1, fmp->second.funcname.size()-1);
    else
      o << fmp->second.funcname;
  }
  else
    o << "Func" << std::setw(4) << funcid;
  
  // output the "function number"
  o << " 0x" << funcid
  // output ObCurly braces
    << " (";
  
  for(unsigned int i=0; i<numargs; i++)
    o << VARNAME << ' ' << VARPREFIX << std::setw(4) << i << ((i==numargs-1) ? "" : ", ");
  
  o << ")";
  
  return o;
}

ostream &UCFunc::output_ucs_funcname(ostream &o, const FuncMap &funcmap)
{
    return output_ucs_funcname(o, funcmap, _funcid, _num_args, return_var);
}

void UCFunc::output_ucs_data(ostream &o, const FuncMap &funcmap, const map<unsigned int, string> &intrinsics, const UCOptions &options, unsigned int indent)
{
  vector<unsigned int> labeltmp(1);
  for(vector<GotoSet>::iterator i=gotoset.begin(); i!=gotoset.end(); ++i)
  {
    // we don't want to output the first "jump" (the start of the function)
    if(i!=gotoset.begin())
    {
      labeltmp[0]=i->offset();
      tab_indent(indent++, o) << demunge_ocstring(*this, funcmap, "label%f*_%1:", labeltmp, intrinsics, UCc(), true) << endl;
    }
    
    for(GotoSet::iterator j=(*i)().begin(); j!=(*i)().end(); j++)
    {
      const UCc &ucc = *(j->first);
      
      if(options.uselesscomment)
        tab_indent(indent, o) << "// Offset: " << std::setw(4) << ucc._offset << endl;

      output_ucs_opcode(o, funcmap, opcode_table_data, ucc, intrinsics, indent);
    }
    if(i!=gotoset.begin()) --indent; //decrement it again to skip the label statement.
    
  }
}

void UCFunc::output_ucs_opcode(ostream &o, const FuncMap &funcmap, const vector<UCOpcodeData> &optab, const UCc &op, const map<unsigned int, string> &intrinsics, unsigned int indent)
{
  tab_indent(indent, o) << demunge_ocstring(*this, funcmap, optab[op._id].ucs_nmo, op._params_parsed, intrinsics, op, true) << ';' << endl;
  
  #ifdef DEBUG_PRINT
  for(vector<UCc *>::const_iterator i=op._popped.begin(); i!=op._popped.end(); i++)
  {
    if((*i)->_popped.size())
      output_ucs_opcode(o, funcmap, opcode_table_data, **i, intrinsics, indent+1);
    else
//      tab_indent(indent+1, o) << demunge_ocstring(*this, funcmap, optab[(*i)->_id].ucs_nmo, op._params_parsed, **i) << endl;
      tab_indent(indent+1, o) << optab[(*i)->_id].ucs_nmo << endl;
  }
  #endif
}

void UCFunc::output_ucs_node(ostream &o, const FuncMap &funcmap, UCNode* ucn, const map<unsigned int, string> &intrinsics, unsigned int indent, const UCOptions &options)
{
  if(!ucn->nodelist.empty()) tab_indent(indent, o) << '{' << endl;
  
  if(ucn->ucc!=0)
    output_asm_opcode(tab_indent(indent, o), funcmap, opcode_table_data, intrinsics, *(ucn->ucc), options);
  
  if(ucn->nodelist.size())
    for(vector<UCNode *>::iterator i=ucn->nodelist.begin(); i!=ucn->nodelist.end(); i++)
    {
      //tab_indent(indent, o);
      output_ucs_node(o, funcmap, *i, intrinsics, indent+1, options);
    }
      
  // end of func
  if(!ucn->nodelist.empty()) tab_indent(indent, o) << '}' << endl;
}

/* Just a quick function to remove all the ucc structured flagged as removable */
inline void gc_gotoset(vector<GotoSet> &gotoset)
{
  for(vector<GotoSet>::iterator i=gotoset.begin(); i!=gotoset.end(); i++)
  {
    i->gc();
    #ifdef DEBUG_GOTOSET
    cout << "----" << endl;
    #endif
  }
}

void UCFunc::parse_ucs(const FuncMap &funcmap, const map<unsigned int, string> &intrinsics, const UCOptions &options)
{
  for(vector<UCc>::iterator i=_opcodes.begin(); i!=_opcodes.end(); i++)
    node.nodelist.push_back(new UCNode(&(*i)));
  
  parse_ucs_pass1(node.nodelist);
  parse_ucs_pass2(gotoset, funcmap, intrinsics);
  gc_gotoset(gotoset);
  
  if(!options.basic)
  {
    parse_ucs_pass3(gotoset, intrinsics);
  }
  
  #ifdef DEBUG_PARSE2
  for(vector<GotoSet>::iterator i=gotoset.begin(); i!=gotoset.end(); i++)
  {
    cout << std::setw(4) << i->offset() << endl;
    
    for(GotoSet::iterator j=(*i)().begin(); j!=(*i)().end(); j++)
    {
      cout << '\t' << std::setw(4) << j->first->_offset << '\t' << j->first->_id << endl;
    }
  }
  #endif
}

/* Pass 1 turns the 1-dimentional vector of opcodes, into a 2-dimentional array
   consisting of all the opcodes within two 'goto target offsets'. */
void UCFunc::parse_ucs_pass1(vector<UCNode *> &nodes)
{
  vector<unsigned int> jumps;

  // collect jump references
  for(unsigned int i=0; i<nodes.size(); i++)
  {
    if(nodes[i]->ucc!=0)
    {
      unsigned int isjump=0;
      for(vector<pair<unsigned int, unsigned int> >::iterator op=opcode_jumps.begin(); op!=opcode_jumps.end(); op++)
        if(op->first==nodes[i]->ucc->_id)
        {
          isjump=op->second;
          break;
        }
      
      if(isjump!=0)
      {
        assert(nodes[i]->ucc->_params_parsed.size()>=isjump);
        jumps.push_back(nodes[i]->ucc->_params_parsed[isjump-1]);
      }
    }
  }

  gotoset.push_back(GotoSet());

  for(unsigned int i=0; i<nodes.size(); i++)
  {
    if(nodes[i]->ucc!=0)
    {
      if(count(jumps.begin(), jumps.end(), nodes[i]->ucc->_offset))
      {
        gotoset.push_back(nodes[i]->ucc);
      }
      else
        gotoset.back().add(nodes[i]->ucc);
    }
  }
}

/* In Pass 2 we convert our 2-dimensional 'GotoSet' array into an array with
   each UCc, having it's parameters sitting in it's UCc::_popped vector. Elements
   that are parameters are flagged for removal (Gotoset::()[i]->second=true) from
   the original GotoSet. */
void UCFunc::parse_ucs_pass2(vector<GotoSet> &gotoset, const FuncMap &funcmap, const map<unsigned int, string> &intrinsics)
{
  for(vector<GotoSet>::iterator i=gotoset.begin(); i!=gotoset.end(); ++i)
  {
    parse_ucs_pass2a((*i)().rbegin(), (*i)(), 0, funcmap, intrinsics);
  }
}

vector<UCc *> UCFunc::parse_ucs_pass2a(vector<pair<UCc *, bool> >::reverse_iterator current, vector<pair<UCc *, bool> > &vec, unsigned int opsneeded, const FuncMap &funcmap, const map<unsigned int, string> &intrinsics)
{
  vector<UCc *> vucc;
  unsigned int opsfound=0;
  
  #ifdef DEBUG_PARSE2
  output_asm_opcode(tab_indent(4, cout), *this, funcmap, opcode_table_data, intrinsics, *(current->first));
  #endif
  
  for(;vec.rend()!=current; current++)
  {
    #ifdef DEBUG_PARSE2
    output_asm_opcode(tab_indent(3, cout), *this, funcmap, opcode_table_data, intrinsics, *(current->first));
    #endif
    
    if(current->second==false)
    {
      if((opcode_table_data[current->first->_id].num_pop!=0) || (opcode_table_data[current->first->_id].call_effect!=0))
      {
        //if(opcode_table_data[current->first->_id].num_pop<0x7F)
        {
          #ifdef DEBUG_PARSE2
          output_asm_opcode(tab_indent(3, cout << "0x" << std::setw(2) << current->first->_id << "-"), *this, funcmap, opcode_table_data, intrinsics, *(current->first));
          tab_indent(3, cout << "0x" << std::setw(2) << current->first->_id << "-") << opcode_table_data[current->first->_id].num_pop << endl;
          #endif
          
          unsigned int num_args=0;
          
          if(opcode_table_data[current->first->_id].num_pop>0x7F)
          {
            #ifdef DEBUG_PARSE2a
            cout << "CALL EFFECT: " << opcode_table_data[current->first->_id].num_pop << '\t';
            #endif
            
            unsigned int offset = 0x100 - opcode_table_data[current->first->_id].num_pop - 1;
            num_args = current->first->_params_parsed[offset];
            
            #ifdef DEBUG_PARSE2a
            cout << num_args << endl;
            #endif
          }
          else if(opcode_table_data[current->first->_id].call_effect!=0)
          {
            assert(current->first->_params_parsed.size()>=1);
            assert(_externs.size()>=current->first->_params_parsed[0]);
            FuncMap::const_iterator fmp = funcmap.find(_externs[current->first->_params_parsed[0]]);
            assert(fmp!=funcmap.end());
            #ifdef DEBUG_PARSE2
            cout << "CALL:     " << fmp->second.funcid << '\t' << fmp->second.num_args << endl;
            #endif
            
            num_args = fmp->second.num_args;
          }
          else
          {
            #ifdef DEBUG_PARSE2
            cout << "Non-CALL: \t" << opcode_table_data[current->first->_id].num_pop << endl;
            #endif
            num_args = opcode_table_data[current->first->_id].num_pop;
          }
          
          if(num_args>0)
          {
            /* save the 'current' value as the return value and increment it so it's
               pointing at the 'next' current value */
            vector<pair<UCc *, bool> >::reverse_iterator ret(current);
            
            ret->first->_popped = parse_ucs_pass2a(++current, vec, num_args, funcmap, intrinsics);
            
            assert(current!=ret);
            
            --current;
            
            assert(current==ret);
            #ifdef DEBUG_PARSE2a
            output_asm_opcode(tab_indent(1, cout), *this, funcmap, opcode_table_data, intrinsics, *(ret->first));
            
            for(vector<UCc *>::iterator i=ret->first->_popped.begin(); i!=ret->first->_popped.end(); i++)
              output_asm_opcode(tab_indent(2, cout), *this, funcmap, opcode_table_data, intrinsics, **i);
            #endif
          }
        }
      }
      if((opsneeded!=0) && (current->second==false))
      {
        // if it's a 'push' opcode and we need items to return that we've popped off the stack...
        if(opcode_table_data[current->first->_id].num_push!=0)
        {
          #ifdef DEBUG_PARSE2
          output_asm_opcode(tab_indent(4, cout << "P-"), *this, funcmap, opcode_table_data, intrinsics, *(current->first));
          #endif
          
          opsfound+=opcode_table_data[current->first->_id].num_push;
          vucc.push_back(current->first);
          current->second=true;
        }
        // if it's a call to a function that returns a variable...
        else if(opcode_table_data[current->first->_id].call_effect!=0)
        {
          FuncMap::const_iterator fmp = funcmap.find(_externs[current->first->_params_parsed[0]]);
          assert(fmp!=funcmap.end());
          
          if(fmp->second.return_var)
          {
            #ifdef DEBUG_PARSE2
            output_asm_opcode(tab_indent(4, cout << "C-"), *this, funcmap, opcode_table_data, intrinsics, *(current->first));
            #endif
          
            opsfound+=1;
            vucc.push_back(current->first);
            current->second=true;
          }
        }
        else
          current->second=true;
          
        // if we've found all the ops we were searching for, return them
        if(opsfound>=opsneeded)
        {
          return vucc;
        }
      }
    }
  }
  
  if(vucc.size()>0) cout << "DID NOT FIND ALL OPCODE PARAMETERS." << endl;
  return vucc;
}

/* The 'optimisation' phase. Attempting to remove as many goto...labels as possible. */
void UCFunc::parse_ucs_pass3(vector<GotoSet> &gotoset, const map<unsigned int, string> &intrinsics)
{

}

bool UCFunc::output_tt(std::ostream &o)
{
  o << "\t<0x" << setw(4) << _funcid << ">" << endl;
  
  for(map<unsigned int, string, less<unsigned int> >::iterator i=_data.begin(); i!=_data.end(); i++)
  {
    o << "\t\t<0x" << setw(4) << i->first << ">" << endl
      << "\t\t`" << i->second << "`" << endl
      << "\t\t</>" << endl;
  }
  o << "\t</>" << endl;
  
  return true;
}

/* calculates the relative offset jump location, used in opcodes jmp && jne */
inline int calc16reloffset(const UCc &op, unsigned int param)
{
  /* forumla:
     real offset = offset of start of current opcode
                 + int of parameter (since you can jump backwards)
                 + 1 (size of "opcode")
                 + size of "opcode" parameter data
     NOTE: since param is unsigned, a twos-complimant is required:
           formula: 0xFFFF - (unsigned short)param + 1
                    ^^^^^^ max of unsighed short
  */
  return op._offset + ((param>>15) ? (-1 * (0xFFFF - static_cast<unsigned short>(param) + 1)) : static_cast<int>(param)) + 1 + op._params.size();
}

/* calculates the relative offset jump location, used in opcodes jmp && jne */
inline int calc32reloffset(const UCc &op, unsigned int param) //FIXME: Test this!
{
  /* forumla:
     real offset = offset of start of current opcode
                 + int of parameter (since you can jump backwards)
                 + 1 (size of "opcode")
                 + size of "opcode" parameter data
     NOTE: since param is unsigned, a twos-complimant is required:
           formula: 0xFFFFFFFF - (unsigned int)param + 1
                    ^^^^^^ max of unsighed int
  */
  return op._offset + ((param>>31) ? (-1 * (0xFFFFFFFF - static_cast<unsigned int>(param) + 1)) : static_cast<int>(param)) + 1 + op._params.size();
}

void ucc_parse_parambytes(UCc &ucop, const UCOpcodeData &otd)
{
  unsigned int first=0;
  
  for(vector<pair<unsigned int, bool> >::const_iterator s=otd.param_sizes.begin(); s!=otd.param_sizes.end(); ++s)
  {
    //cout << ucop._id << '\t' << ucop._params.size() << endl;
    
    assert(first<ucop._params.size());
    
    unsigned int ssize=s->first;
    bool offset_munge=s->second;
    
    assert(ssize!=0);

    if(ssize==1)
      ucop._params_parsed.push_back(static_cast<unsigned int>(ucop._params[first++]));
    else if(ssize==2)
      if(offset_munge)
      {
        unsigned int calcvar = static_cast<unsigned int>(ucop._params[first++]);
        calcvar += ((static_cast<unsigned int>(ucop._params[first++])) << 8);
        unsigned int reloffset = calc16reloffset(ucop, calcvar);
        ucop._params_parsed.push_back(reloffset);
        ucop._jump_offsets.push_back(reloffset);
      }
      else
      {
        unsigned int calcvar = static_cast<unsigned int>(ucop._params[first++]);
        calcvar += ((static_cast<unsigned int>(ucop._params[first++])) << 8);
        ucop._params_parsed.push_back(calcvar);
      }
    else if(ssize==4)
      if(offset_munge)
      {
        unsigned int calcvar = static_cast<unsigned int>(ucop._params[first++]);
        calcvar += ((static_cast<unsigned int>(ucop._params[first++])) << 8);
        calcvar += ((static_cast<unsigned int>(ucop._params[first++])) << 16);
        calcvar += ((static_cast<unsigned int>(ucop._params[first++])) << 24);
        unsigned int reloffset = calc32reloffset(ucop, calcvar);
        ucop._params_parsed.push_back(reloffset);
        ucop._jump_offsets.push_back(reloffset);
      }
      else
      {
        unsigned int calcvar = static_cast<unsigned int>(ucop._params[first++]);
        calcvar += ((static_cast<unsigned int>(ucop._params[first++])) << 8);
        calcvar += ((static_cast<unsigned int>(ucop._params[first++])) << 16);
        calcvar += ((static_cast<unsigned int>(ucop._params[first++])) << 24);
        ucop._params_parsed.push_back(calcvar);
      }
    else
      assert(false); // just paranoia.
  }
}

/* prints the "assembler" output of the usecode, currently trying to duplicate
   the output of the original ucdump... returns true if successful*/
bool UCFunc::output_asm(ostream &o, const FuncMap &funcmap, const map<unsigned int, string> &intrinsics, const UCOptions &options)
{
  if(options.verbose) cout << "Printing function..." << endl;
  
  o << "Function at file offset " << std::setw(8) << _offset << "H" << endl;
  o << "\t.funcnumber  " << std::setw(4) << _funcid << "H" << endl;
  if(ext32) o << "\t.ext32" << endl;
  o << "\t.msize       " << ((ext32) ? setw(8) : setw(4)) << _funcsize << "H" << endl;
  o << "\t.dsize       " << ((ext32) ? setw(8) : setw(4)) << _datasize << "H" << endl;
  
  if(debugging_info)
    o << "\t  .dbgoffset " << std::setw(4) << debugging_offset << "H" << endl;
  
  if(_data.size())
    output_asm_data(o);
  
  o << "Code segment at file offset " << std::setw(8) << _codeoffset << "H" << endl;
  o << "\t.argc        " << std::setw(4) << _num_args << "H" << endl;
  o << "\t.localc      " << std::setw(4) << _num_locals << "H" << endl;
  o << "\t.externsize  " << std::setw(4) << _externs.size() << "H" << endl;
  
  for(typeof(_externs.begin()) i=_externs.begin(); i!=_externs.end(); i++)
    o << '\t' << "  .extern    " << std::setw(4) << *i << "H" << endl;
/*  for(unsigned int i=0; i<_externs.size(); i++) //FIXME: ::iterators
    o << '\t' << "  .extern    " << std::setw(4) << _externs[i] << "H" << endl;*/
  
  for(vector<UCc>::iterator op=_opcodes.begin(); op!=_opcodes.end(); op++)
    output_asm_opcode(o, funcmap, opcode_table_data, intrinsics, *op, options);
  
  return true;
}

void UCFunc::output_asm_data(ostream &o)
{
  static const unsigned int nochars=60;
  // limit of about 60 chars to a line, wrap to the next line if longer then this...
  for(map<unsigned int, string, less<unsigned int> >::iterator i=_data.begin(); i!=_data.end(); i++)
  {
    for(unsigned int j=0; j<i->second.size(); j++)
    {
      if(j==0)
        o << setw(4) << i->first;
      if((j!=0) && !(j%nochars))
        o << "'" << endl;
      if(!(j%nochars))
        o << "\tdb\t'";

      o << i->second[j];
    }
    o << "'" << endl;
    o << "\tdb\t00" << endl;
  }
}

void UCFunc::output_raw_opcodes(ostream &o, const UCc &op)
{
  // chars in opcode
  o << ' ' << std::setw(2) << static_cast<unsigned int>(op._id);
  if(op._params.size()) cout << ' ';

  for(unsigned int i=0; i<op._params.size(); i++)
  {
    o << std::setw(2) << static_cast<unsigned int>(op._params[i]);
    if(i!=op._params.size())
      o << ' ';
  }

  // seperator
  unsigned int numsep = op._params.size();
  //cout << endl << numsep << endl;
  if(numsep>6)
    o << endl << "\t\t\t";
  else if (numsep>5)
    o << " ";
  else if (numsep>2)
    o << "\t";
  else
    o << "\t\t";
}

void UCFunc::output_asm_opcode(ostream &o, const FuncMap &funcmap, const vector<UCOpcodeData> &optab, const map<unsigned int, string> &intrinsics, const UCc &op, const UCOptions &options)
{
  // offset
  o << std::setw(4) << op._offset << ':';

  if(options.rawops) output_raw_opcodes(o, op);
  else            o << '\t';

  o << demunge_ocstring(*this, funcmap, optab[op._id].asm_nmo, op._params_parsed, intrinsics, op, false);

  if(options.autocomment)
    o << demunge_ocstring(*this, funcmap, optab[op._id].asm_comment, op._params_parsed, intrinsics, op, false);

  o << endl;
}

inline unsigned int charnum2uint(const char c)
{
  switch(c)
  {
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;
    default:  return 0;
  }
  return 0; // can't happen
}

// FIXME: Remove the passed &params value. Get it from op._params_parsed
string demunge_ocstring(UCFunc &ucf, const FuncMap &funcmap, const string &asmstr, const vector<unsigned int> &params, const map<unsigned int, string> &intrinsics, const UCc &op, bool ucs_output)
{
#ifdef HAVE_SSTREAM
  std::stringstream str;
#else
  std::strstream str;
#endif
  str << std::setfill('0') << std::setbase(16);
  str.setf(ios::uppercase);
  size_t  len=asmstr.length();

  if(len==0) return string(); // for the degenerate case

  bool finished=false; // terminating details are at end-of-while
  unsigned int i=0; // istr index
  unsigned int width=0; // width value for setw()

  if(ucs_output && opcode_table_data[op._id].flag_paren) str << '(';
  
  while(!finished&&i<len)
  {
    bool special_call(false); // FIXME: <sigh> temporary exception handling for call (0x24)
    
    char c = asmstr[i];
    
    width = 4; // with defaults to 4
    
    switch(c)
    {
      case '\\':
        i++;
        c = asmstr[i];
        switch(c)
        {
          case '\\': str << '\\'; break;
          case 'n':  str << '\n'; break;
          case 't':  str << '\t'; break;
          case '\'': str << '\''; break;
          case '"':  str << '\"'; break;
          case 'b':  // bell is invalid
          default:   // we'll silently drop errors... it's the only "clean" way
            str << '\\' << c;
        }
        break;
      case '%':
        {
          i++;
          c = asmstr[i];

          // if it's a "byte" set width to 2, and get the next char
          if(c=='b')      { i++; c = asmstr[i]; width=2; }
          // if it's a "short" set width to 4, and get the next char
          else if(c=='s') { i++; c = asmstr[i]; width=4; }
          // if it's a "int" set width to 8, and get the next char
          else if(c=='n') { i++; c = asmstr[i]; width=8; }
          // if it's a "long" set width to 16, and get the next char
          else if(c=='l') { i++; c = asmstr[i]; width=16; }
          // if we want to output the 'decimal' value rather then the default hex
          else if(c=='d')
          {
            i++; c = asmstr[i];
            unsigned int t = charnum2uint(c);
            
            if(t!=0)
            {
              assert(params.size()>=t);
              str << std::setbase(10) << params[t-1] << std::setbase(16);
            }
            else if(c=='%')
              str << '%';
            break;
          }
          // if it's the character representation of a text data string we want
          else if(c=='t')
          {
            bool commentformat=false;
            i++; c = asmstr[i];
            
            // if we only want to output the 'short' format of the text (comment format)
            if(c=='c')
            {
              commentformat=true;
              i++; c = asmstr[i];
            }
            
            unsigned int t = charnum2uint(c);
            
            assert(params.size()>=t);
            assert(t!=0);
            string s = ucf._data.find(params[t-1])->second;
            
            if(commentformat)
              if(s.size()>17) s = s.substr(0, 17) + string("...");
            
            // escape the appropriate characters...
            // we'll only do it in the 'full' text output for the moment.
            if(!commentformat)
              for(string::size_type i=0; i<s.size(); i++)
                if((s[i]=='\"') || (s[i]=='\\'))
                {
                  s.insert(i, "\\");
                  ++i;
                }
            
            str << s;
            break;
          }
          // if it's the intrinsic name we want
          else if(c=='i')
          {
            i++; c = asmstr[i];
            unsigned int t = charnum2uint(c);
            
            assert(params.size()>=t);
            assert(t!=0);
            string s = intrinsics.find(params[t-1])->second;
            str << s;
            break;
          }
          // if it's external function name we want
          else if(c=='f')
          {
            i++; c = asmstr[i];
            
            if(c=='*')
            {
              if(ucf.funcname.size())
              {
                if(ucf.funcname[0]=='&')
                  str << ucf.funcname.substr(1, ucf.funcname.size()-1);
                else
                  str << ucf.funcname;
              }
              else
                str << "Func" << std::setw(4) << ucf._funcid;
            }
            else
            {
              unsigned int t = charnum2uint(c);
              
              assert(ucf._externs.size()>=t);
              assert(t!=0);
              assert(op._params_parsed.size()>=1);
              
              FuncMap::const_iterator fmp = funcmap.find(ucf._externs[op._params_parsed[t-1]]);
              if(fmp->second.funcname.size())
              {
                if(fmp->second.funcname[0]=='&')
                  str << fmp->second.funcname.substr(1, fmp->second.funcname.size()-1);
                else
                  str << fmp->second.funcname;
              }
              else
                str << "Func" << std::setw(4) << ucf._externs[op._params_parsed[t-1]];
            }
            break;
          }
          // if it's the character representation of a text data string we want
          else if(c=='p')
          {
            i++; c = asmstr[i];
            unsigned int t = charnum2uint(c);
            
            // FIXME: this is the special 'call' case, it may be a good idea to make more general
            if((t==0) && (c==','))
            {
              special_call=true;
            
              for(vector<UCc *>::const_iterator i=op._popped.begin(); i!=op._popped.end();)
              {
                str << demunge_ocstring(ucf, funcmap, opcode_table_data[(*i)->_id].ucs_nmo, (*i)->_params_parsed, intrinsics, **i, ucs_output);
                if(++i!=op._popped.end())
                  str << ", ";
              }
            }
            
            if(t!=0)
            {
              if(t>op._popped.size())
                str << "SOMETHING_GOES_HERE()";
              else
              {
                UCc &ucc(*op._popped[t-1]);
                str << demunge_ocstring(ucf, funcmap, opcode_table_data[ucc._id].ucs_nmo, ucc._params_parsed, intrinsics, ucc, ucs_output);
              }
            }
            break;
          }
          
          if(special_call!=true)
          {
            unsigned int t = charnum2uint(c);
            if(t!=0)
            {
              assert(params.size()>=t);
              str << std::setw(width) << params[t-1];
            }
            else if(c=='%')
              str << '%';
          }
        }
        break;
      default: // it's just a character, leave it be
        str << c;
    }

    i++;
    if(i==asmstr.size()) finished=true;
  }
  
  if(ucs_output && opcode_table_data[op._id].flag_paren) str << ')';
  
  return str.str();
}

void readbin_U7UCFunc(ifstream &f, UCFunc &ucf, const UCOptions &options)
{
//  #define DEBUG_READ_PAIR(X, Y) cout << '\t' << X << '\t' << Y << endl;
  // offset to start of function
  ucf._offset = f.tellg();
  DEBUG_READ_PAIR("  Offset: ", ucf._offset);

  // Read Function Header
  ucf._funcid = Read2(f);
  
  if(options.very_verbose)
    cout << "\tReading Function: " << setw(4) << ucf._funcid << endl;
  
  DEBUG_READ_PAIR("  FuncID: ", ucf._funcid);
  
  if(ucf._funcid!=0xFFFF)
  {
    
    // This is the original usecode function header
    ucf._funcsize = Read2(f);
    DEBUG_READ_PAIR("  FuncSize: ", ucf._funcsize);
    
    // save body offset in case we need it
    ucf._bodyoffset = f.tellg();
    
    ucf._datasize = Read2(f);
    DEBUG_READ_PAIR("  DataSize: ", ucf._datasize);
  }
  else
  {
    // This is the ext32 extended usecode function header
    ucf.ext32=true;
    ucf._funcid = Read2(f);
    
    if(options.very_verbose)
      cout << "\tReading Function: " << setw(4) << ucf._funcid << endl;
    
    DEBUG_READ_PAIR("  extFuncID: ", ucf._funcid);
    ucf._funcsize = Read4(f);
    DEBUG_READ_PAIR("  extFuncSize: ", ucf._funcsize);
    
    // save body offset in case we need it
    ucf._bodyoffset = f.tellg();
    
    ucf._datasize = Read4(f);
    DEBUG_READ_PAIR("  extDataSize: ", ucf._datasize);
  }
  
  // process ze data segment!
  {
    streampos pos = f.tellg(); // paranoia
  
    unsigned int off = 0;
    // Load all strings & their offsets
    while( off < ucf._datasize )
    {
      assert(!f.eof());
      
      string data;
      getline(f, data, static_cast<char>(0x00));
      ucf._data.insert(pair<unsigned int, string>(off, data));
      off+=data.size()+1;
    }
    f.seekg(pos, ios::beg); // paranoia
    f.seekg(ucf._datasize, ios::cur); // paranoia
  }

  #if 0 
  if(ucf._funcid==_search_func)
    for(map<unsigned int, string>::iterator i=ucf._data.begin(); i!=ucf._data.end(); i++)
      cout << i->first << "\t" << i->second << endl;
  #endif
  
  // process code segment
  {
    //streampos start_of_code_seg = f.tellg(); // what's this used for?
    ucf._codeoffset = f.tellg();

    // get the number of arguments to the function
    ucf._num_args = Read2(f);

    // get the number of local variables
    ucf._num_locals = Read2(f);

    // get the number of external function numbers
    ucf._num_externs = Read2(f);
    
    // load the external function numbers
    for(unsigned int i=0; i<ucf._num_externs; i++)
      ucf._externs.push_back(Read2(f));
    
    // ok, now to load the usecode
    unsigned int code_offset=0;

    /* Here the '3+' comes from the sizeof(_datasize) + sizeof(_num_args)
      + sizeof(_num_locals) + sizeof(_num_externs)
      which are stored in the file as 16bit shorts, with the exception of
      an ext32 function header, where the _datasize is a 32bit structure */
    unsigned int code_size = ucf._funcsize - ucf._datasize - ((4+ucf._num_externs) * SIZEOF_USHORT);
    if(ucf.ext32==true) code_size-=2;
    
    DEBUG_READ_PAIR("Code Size: ", code_size);

    while(code_offset<code_size)
    {
      assert(!f.eof());
      UCc ucop;
      
      ucop._offset = code_offset;

      ucop._id = Read1(f);
      code_offset++;

      const UCOpcodeData &otd = opcode_table_data[ucop._id];

      if(otd.opcode==0x00)
      {
        cout << ucop._id << ' ' << code_offset << endl;
        assert(otd.opcode!=0x00);
      }
      
      //assert(((otd.asm_nmo.size()!=0) && (otd.ucs_nmo.size()!=0)));
      for(unsigned int i=0; i<otd.num_bytes; i++)
        ucop._params.push_back(Read1(f));

      // parse the parameters
      ucc_parse_parambytes(ucop, otd);

      code_offset+=otd.num_bytes;

      /* if we're an opcode that sets a return value, we need to mark the
        function as one that returns a value */
      if(otd.flag_return==true)
        ucf.return_var=true;
      
      /* if we're a function debugging opcode, set the debuging flag, and
        assign the variable name string offset
        TODO: Add this to opcodes.txt */
      if((ucop._id==0x4D) && (options.game_bg() || options.game_si()))
      {
        ucf.debugging_info=true;
        assert(ucop._params_parsed.size()>=2);
        ucf.debugging_offset = ucop._params_parsed[1];
        ucf.funcname = ucf._data.find(0x0000)->second;
      }
      
      ucf._opcodes.push_back(ucop);

      #ifdef DEBUG_READ
      cout << std::setw(4) << code_size << "\t" << std::setw(4) << code_offset << "\t" << std::setw(4) << (unsigned int)ucop._offset << "\t" << std::setw(2) << (unsigned int)ucop._id << "\t";
      for(unsigned int i=0; i<ucop._params.size(); i++)
        cout << std::setw(2) << (unsigned int)ucop._params[i] << ',';
      cout << endl;
      #endif
    }
  }
}

void readbin_U8UCFunc(ifstream &f, UCFunc &ucf)
{

}

---