ucexpr.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 "ucexpr.h"
#include "ucsym.h"
#include "utils.h"
#include "opcodes.h"
#include "ucfun.h"

/*
 *  Default.  Just push the one value.
 *
 *  Output: # pushed
 */

int Uc_expression::gen_values
  (
  vector<char>& out
  )
  {
  gen_value(out);     // Gen. result on stack.
  return 1;
  }

/*
 *  Default jmp-if-false generation.
 *
 *  Output: offset where offset is stored.
 */

int Uc_expression::gen_jmp_if_false
  (
  vector<char>& out,
  int offset      // Offset to jmp (relative).
  )
  {
  gen_value(out);     // Gen. result on stack.
  out.push_back((char) UC_JNE);   // Pop and jmp if false.
  Write2(out, offset);
  return out.size() - 2;
  }

/*
 *  Default assignment generation.
 */

void Uc_expression::gen_assign
  (
  vector<char>& out
  )
  {
  error("Can't assign to this expression");
  }

/*
 *  Need a variable whose value is this expression.
 */

Uc_var_symbol *Uc_expression::need_var
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
  static int cnt = 0;
  char buf[50];
  sprintf(buf, "_tmpval_%d", cnt++);
          // Create a 'tmp' variable.
  Uc_var_symbol *var = fun->add_symbol(buf);
  if (!var)
    return 0;   // Shouldn't happen.  Err. reported.
  gen_value(out);     // Want to assign this value to it.
  var->gen_assign(out);
  return var;
  }

/*
 *  Evaluate constant.
 *
 *  Output: true if successful, with result returned in 'val'.
 */

bool Uc_expression::eval_const
  (
  int& val      // Value returned here.
  )
  {
  val = 0;
  error("Integer constant expected.");
  return false;
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_var_expression::gen_value
  (
  vector<char>& out
  )
  {
  char buf[150];
  if (!var->gen_value(out))
    {
    sprintf(buf, "Can't use value of '%s'", var->get_name());
    error(buf);
    }
  }

/*
 *  Generate assignment to this variable.
 */

void Uc_var_expression::gen_assign
  (
  vector<char>& out
  )
  {
  char buf[150];
  if (!var->gen_assign(out))
    {
    sprintf(buf, "Can't assign to '%s'", var->get_name());
    error(buf);
    }
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_arrayelem_expression::gen_value
  (
  vector<char>& out
  )
  {
  if (!index || !array)
    return;
  index->gen_value(out);    // Want index on stack.
  out.push_back((char) UC_AIDX);  // Opcode, var #.
  Write2(out, array->get_offset());
  }

/*
 *  Generate assignment to this variable.
 */

void Uc_arrayelem_expression::gen_assign
  (
  vector<char>& out
  )
  {
  if (!index || !array)
    return;
  index->gen_value(out);    // Want index on stack.
  out.push_back((char) UC_POPARR);  // Opcode, var #.
  Write2(out, array->get_offset());
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_flag_expression::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSHF); // Opcode, flag #.
  Write2(out, index);
  }

/*
 *  Generate assignment to this variable.
 */

void Uc_flag_expression::gen_assign
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_POPF);
  Write2(out, index);
  }

/*
 *  Get offset in function's text_data.
 *
 *  Output: Offset.
 */

int Uc_var_expression::get_string_offset
  (
  )
  { 
  return var->get_string_offset(); 
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_binary_expression::gen_value
  (
  vector<char>& out
  )
  {
  left->gen_value(out);   // First the left.
  right->gen_value(out);    // Then the right.
  out.push_back((char) opcode);
  }

/*
 *  Evaluate constant.
 *
 *  Output: true if successful, with result returned in 'val'.
 */

bool Uc_binary_expression::eval_const
  (
  int& val      // Value returned here.
  )
  {
  int val1, val2;     // Get each side.
  if (!left->eval_const(val1) || !right->eval_const(val2))
    return false;
  switch (opcode)
    {
  case UC_ADD:  val = val1 + val2; return true;
  case UC_SUB:  val = val1 - val2; return true;
  case UC_MUL:  val = val1*val2; return true;
  case UC_DIV:
    if (!val2)
      {
      error("Division by 0");
      return false;
      }
    val = val1/val2;
    return true;
    }
  val = 0;
  error("This operation not supported for integer constants");
  return false;
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_unary_expression::gen_value
  (
  vector<char>& out
  )
  {
  operand->gen_value(out);
  out.push_back((char) opcode);
  }

/*
 *  Can't use this expression just anywhere.
 */

void Uc_response_expression::gen_value
  (
  vector<char>& out
  )
  {
  error("Must use UcResponse in 'if (UcResponse == ...)'");
  }

/*
 *  Jmp-if-false generation for getting conversation response & comparing
 *  to a string or strings.
 *
 *  Output: offset where offset is stored.
 */

int Uc_response_expression::gen_jmp_if_false
  (
  vector<char>& out,
  int offset      // Offset to jmp (relative).
  )
  {
          // Push string(s) on stack.
  int cnt = operand->gen_values(out);
  out.push_back((char) UC_CMPS);
  Write2(out, cnt);   // # strings on stack.
  Write2(out, offset);    // Offset to jmp if false.
  return out.size() - 2;
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_int_expression::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSHI);
  Write2(out, value);
  }

/*
 *  Evaluate constant.
 *
 *  Output: true if successful, with result returned in 'val'.
 */

bool Uc_int_expression::eval_const
  (
  int& val      // Value returned here.
  )
  {
  val = value;
  return true;
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_bool_expression::gen_value
  (
  vector<char>& out
  )
  {
  if (tf)
    out.push_back((char) UC_PUSHTRUE);
  else
    out.push_back((char) UC_PUSHFALSE);
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_event_expression::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSHEVENTID);
  }

/*
 *  Generate assignment to this variable.
 */

void Uc_event_expression::gen_assign
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_POPEVENTID);
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_item_expression::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSHITEMREF);
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_string_expression::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSHS);
  Write2(out, offset);
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_string_prefix_expression::gen_value
  (
  vector<char>& out
  )
  {
  out.push_back((char) UC_PUSHS);
  Write2(out, get_string_offset());
  }

/*
 *  Get offset in function's text_data.
 *
 *  Output: Offset.
 */

int Uc_string_prefix_expression::get_string_offset
  (
  )
  { 
  if (offset < 0)     // First time?
          // Look up & print errors.
    offset = fun->find_string_prefix(*this, prefix.c_str());
  return offset;
  }

/*
 *  Delete a list of expressions.
 */

Uc_array_expression::~Uc_array_expression
  (
  )
  {
  for (std::vector<Uc_expression *>::iterator it = exprs.begin(); 
            it != exprs.end(); it++)
    delete (*it);
  }

/*
 *  Concatenate another expression, or its values if an array, onto this.
 *  If the expression is an array, it's deleted after its elements are
 *  taken.
 */

void Uc_array_expression::concat
  (
  Uc_expression *e
  )
  {
  Uc_array_expression *arr = dynamic_cast<Uc_array_expression *> (e);
  if (!arr)
    add(e);     // Singleton?  Just add it.
  else
    {
    for (std::vector<Uc_expression *>::iterator it = 
      arr->exprs.begin(); it != arr->exprs.end(); it++)
      add(*it);
    arr->exprs.clear(); // Don't want to delete elements.
    delete arr;   // But this array is history.
    }
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_array_expression::gen_value
  (
  vector<char>& out
  )
  {
  int actual = Uc_array_expression::gen_values(out);
  out.push_back((char) UC_ARRC);
  Write2(out, actual);
  }

/*
 *  Push all values onto the stack.
 *
 *  Output: # pushed
 */

int Uc_array_expression::gen_values
  (
  vector<char>& out
  )
  {
  int actual = 0;     // (Just to be safe.)
          // Push backwards, so #0 pops first.
  for (std::vector<Uc_expression *>::reverse_iterator it = 
        exprs.rbegin(); it != exprs.rend(); it++)
    {
    Uc_expression *expr = *it;
    if (expr)
      {
      actual++;
      expr->gen_value(out);
      }
    }
  return actual;
  }

/*
 *  Generate code to evaluate expression and leave result on stack.
 */

void Uc_call_expression::gen_value
  (
  vector<char>& out
  )
  {
  if (!sym)
    return;     // Already failed once.
  if (!sym->gen_call(out, function, original, itemref,  
              parms, return_value))
    {
    char buf[150];
    sprintf(buf, "'%s' isn't a function or intrinsic",
            sym->get_name());
    sym = 0;    // Avoid repeating error if in loop.
    error(buf);
    }
  }

---