ucsym.cc

Go to the documentation of this file.

/*
Copyright (C) 2000 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 <stdio.h>
#include "ucsym.h"
#include "opcodes.h"
#include "utils.h"
#include "ucexpr.h"
#include "ucfun.h"

using std::strcmp;

int Uc_function_symbol::last_num = -1;
Uc_function_symbol::Sym_nums Uc_function_symbol::nums_used;

/*
 *  Assign value on stack.
 *
 *  Output: 0 if can't do this.
 */

int Uc_symbol::gen_assign
  (
  vector<char>& out
  )
  {
  return 0;
  }

/*
 *  Generate code to push variable's value on stack.
 *
 *  Output: 0 if can't do this.
 */

int Uc_symbol::gen_value
  (
  vector<char>& out
  )
  {
  return 0;
  }

/*
 *  Generate function call.
 *
 *  Output: 0 if can't do this.
 */

int Uc_symbol::gen_call
  (
  vector<char>& out,
  Uc_function *fun,
  bool orig,      // Call original (not one from patch).
  Uc_expression *itemref,   // Non-NULL for CALLE.
  Uc_array_expression *parms, // Parameter list.
  bool retvalue     // True if a function.
  )
  {
  return 0;
  }

/*
 *  Create an expression with this value.
 */

Uc_expression *Uc_symbol::create_expression
  (
  )
  {
  return 0;
  }

/*
 *  Assign value on stack.
 *
 *  Output: 0 if can't do this.
 */

int Uc_var_symbol::gen_assign
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_POP);
  Write2(out, offset);
  return 1;
  }

/*
 *  Generate code to push variable's value on stack.
 *
 *  Output: 0 if can't do this.
 */

int Uc_var_symbol::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSH);
  Write2(out, offset);
  return 1;
  }

/*
 *  Create an expression with this value.
 */

Uc_expression *Uc_var_symbol::create_expression
  (
  )
  {
  return new Uc_var_expression(this);
  }

/*
 *  Assign value on stack.
 *
 *  Output: 0 if can't do this.
 */

int Uc_static_var_symbol::gen_assign
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_POPSTATIC);
  Write2(out, offset);
  return 1;
  }

/*
 *  Generate code to push variable's value on stack.
 *
 *  Output: 0 if can't do this.
 */

int Uc_static_var_symbol::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSHSTATIC);
  Write2(out, offset);
  return 1;
  }

/*
 *  Generate code to push variable's value on stack.
 *
 *  Output: 0 if can't do this.
 */

int Uc_const_int_symbol::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSHI);
  Write2(out, value);
  return 1;
  }

/*
 *  Create an expression with this value.
 */

Uc_expression *Uc_const_int_symbol::create_expression
  (
  )
  {
  return new Uc_int_expression(value);
  }

/*
 *  Generate code to push variable's value on stack.
 *
 *  Output: 0 if can't do this.
 */

int Uc_string_symbol::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSHS);
  Write2(out, offset);
  return 1;
  }

/*
 *  Create an expression with this value.
 */

Uc_expression *Uc_string_symbol::create_expression
  (
  )
  {
  return new Uc_string_expression(offset);
  }

/*
 *  Generate function call.
 *
 *  Output: 0 if can't do this.
 */

int Uc_intrinsic_symbol::gen_call
  (
  vector<char>& out,
  Uc_function *fun,
  bool orig,      // Call original (not one from patch).
  Uc_expression *itemref,   // Non-NULL for CALLE.
  Uc_array_expression *parms, // Parameter list.
  bool retvalue     // True if a function.
  )
  {
  int parmcnt = 0;
  if (itemref)      // Makes no sense for intrinsice.
    Uc_location::yyerror("Can't use ITEM for intrinsic");
          // Want to push parm. values.
  const std::vector<Uc_expression *>& exprs = parms->get_exprs();
          // Push backwards, so #0 pops first.
  for (std::vector<Uc_expression *>::const_reverse_iterator it = 
      exprs.rbegin(); it != exprs.rend(); it++)
    {
    Uc_expression *expr = *it;
    expr->gen_value(out);
    parmcnt++;
    }
          // ++++ parmcnt == num_parms.
          // Opcode depends on val. returned.
  out.push_back((char) (retvalue ? UC_CALLIS : UC_CALLI));
  Write2(out, intrinsic_num); // Intrinsic # is 2 bytes.
  out.push_back((char) parmcnt);  // Parm. count is 1.
  return 1;
  }

/*
 *  Create new function.
 */

Uc_function_symbol::Uc_function_symbol
  (
  char *nm, 
  int num,      // Function #, or -1 to assign
          //  1 + last_num.
  std::vector<char *>& p
  ) :  Uc_symbol(nm), parms(p), usecode_num(num)
  {
  last_num = usecode_num = num >= 0 ? num : (last_num + 1);
          // Keep track of #'s used.
  Sym_nums::const_iterator it = nums_used.find(usecode_num);
  if (it == nums_used.end())  // Unused?  That's good.
    nums_used[usecode_num] = this;
  else
    {
    char buf[256];
    sprintf(buf, "Function 0x%x already used for '%s'.",
        usecode_num, ((*it).second)->get_name());
    Uc_location::yyerror(buf);
    }
  }

/*
 *  Generate function call.
 *
 *  Output: 0 if can't do this.
 */

int Uc_function_symbol::gen_call
  (
  vector<char>& out,
  Uc_function *fun,
  bool orig,      // Call original (not one from patch).
  Uc_expression *itemref,   // Non-NULL for CALLE.
  Uc_array_expression *aparms,  // Actual parameter list.
  bool /* retvalue */   // True if a function.
  )
  {
  int parmcnt = 0;
          // Want to push parm. values.
  const std::vector<Uc_expression *>& exprs = aparms->get_exprs();
          // Push forwards, so #0 pops last.
  for (std::vector<Uc_expression *>::const_iterator it = exprs.begin(); 
            it != exprs.end(); it++)
    {
    Uc_expression *expr = *it;
    expr->gen_value(out);
    parmcnt++;
    }
  if (parmcnt != parms.size())
    {
    char buf[100];
    sprintf(buf,
      "# parms. passed (%d) doesn't match '%s' count (%d)",
      parmcnt, get_name(), parms.size());
    }       
  if (orig)
    {
    if (!itemref)
      {
      Uc_item_expression item;
      item.gen_value(out);
      }
    else
      itemref->gen_value(out);
    out.push_back((char) UC_CALLO);
    Write2(out, usecode_num); // Use fun# directly.
    }
  else if (itemref) // Doing CALLE?  Push item onto stack.
    {
    itemref->gen_value(out);
    out.push_back((char) UC_CALLE);
    Write2(out, usecode_num); // Use fun# directly.
    }
  else        // Normal CALL.
    {     // Called function sets return.
    out.push_back((char) UC_CALL);
          // Get offset in function's list.
    int link = fun->link(this);
    Write2(out, link);
    }
  return 1;
  }


bool String_compare::operator()(char * const &x, char * const &y) const
  { return strcmp(x, y) < 0; }

/*
 *  Delete.
 */

Uc_scope::~Uc_scope
  (
  )
  {
  for (std::map<char *, Uc_symbol *, String_compare>::iterator it = symbols.begin();
        it != symbols.end(); it++)
    delete (*it).second;
  for (std::vector<Uc_scope *>::iterator it = scopes.begin();
        it != scopes.end(); it++)
    delete *it;
  }

/*
 *  Search upwards through scope.
 *
 *  Output: ->symbol if found, else 0.
 */

Uc_symbol *Uc_scope::search_up
  (
  char *nm
  )
  {
  Uc_symbol *found = search(nm);  // First look here.
  if (found)
    return found;
  if (parent)     // Look upwards.
    return parent->search_up(nm);
  else
    return 0;
  }

/*
 *  Add a function symbol.
 *
 *  Output: 0 if already there.  Errors reported.
 */

int Uc_scope::add_function_symbol
  (
  Uc_function_symbol *fun
  )
  {
  char buf[150];
  const char *nm = fun->get_name();
  Uc_symbol *found = search(nm);  // Already here?
  if (!found)     // If not, that's good.
    {
    add(fun);
    return 1;
    }
  Uc_function_symbol *fun2 = dynamic_cast<Uc_function_symbol *> (found);
  if (!fun2)      // Non-function name.
    {
    sprintf(buf, "'%s' already declared", nm);
    Uc_location::yyerror(buf);
    }
  else if (fun->get_usecode_num() != fun2->get_usecode_num() ||
    fun->get_num_parms() != fun2->get_num_parms())
    {
    sprintf(buf, "Decl. of '%s' doesn't match previous decl", nm);
    Uc_location::yyerror(buf);
    }
  return 0;
  }

---