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

using std::vector;
using std::string;

int Uc_converse2_statement::nest = 0;

/*
 *  Delete.
 */

Uc_block_statement::~Uc_block_statement
  (
  )
  {
          // Delete all the statements.
  for (std::vector<Uc_statement *>::const_iterator it = statements.begin();
          it != statements.end(); it++)
    delete (*it);
  }

/*
 *  Generate code.
 */

void Uc_block_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
  for (std::vector<Uc_statement *>::const_iterator it = statements.begin();
          it != statements.end(); it++)
    {
    Uc_statement *stmt = *it;
    stmt->gen(out, fun);
    }
  }


/*
 *  Delete.
 */

Uc_assignment_statement::~Uc_assignment_statement
  (
  )
  {
  delete target;
  delete value;
  }


/*
 *  Generate code.
 */

void Uc_assignment_statement::gen
  (
  vector<char>& out,
  Uc_function * /* fun */
  )
  {
  value->gen_value(out);    // Get value on stack.
  target->gen_assign(out);
  }

/*
 *  Generate code.
 */

void Uc_if_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
          // Gen JNE (or CMPS) past IF code.
  int jne_offset = expr->gen_jmp_if_false(out, 0);
  if (if_stmt)
    if_stmt->gen(out, fun);
  int jmp_past_else_offset = -1;  // Where following JMP offset is.
  if (else_stmt)      // JMP past ELSE code.
    {
    out.push_back((char) UC_JMP);
    jmp_past_else_offset = out.size();
    Write2(out, 0);   // Write place-holder for offset.
    }
  int if_end = out.size();
          // Fixup JNE at start.
  Write2(out, jne_offset, if_end - (jne_offset + 2));
  if (else_stmt)      // Generate ELSE.
    {
    else_stmt->gen(out, fun);
    int else_end = out.size();
    Write2(out, jmp_past_else_offset,
          else_end - (jmp_past_else_offset + 2));
    }
  }

/*
 *  Delete.
 */

Uc_if_statement::~Uc_if_statement
  (
  )
  {
  delete expr;
  delete if_stmt;
  delete else_stmt;
  }

/*
 *  Delete.
 */

Uc_while_statement::~Uc_while_statement
  (
  )
  {
  delete expr;
  delete stmt;
  }

/*
 *  Generate code.
 */

void Uc_while_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
  int top = out.size();   // Get current position.
  expr->gen_value(out);   // Generate expr. value.
  vector<char> stmt_code;
  stmt_code.reserve(4000);
  fun->start_breakable(this);
  if (stmt) {
    fun->adjust_reloffset(out.size() + 3);
    stmt->gen(stmt_code, fun);  // Generate statement's code.
    fun->adjust_reloffset(-out.size() - 3);
  }
  int stmtlen = stmt_code.size();
          // Get distance back to top, including
          //   a JNE and a JMP.
  long dist = stmtlen + (out.size() - top) + 3 + 3;
          // Generate JMP back to top.
  stmt_code.push_back((char) UC_JMP);
  Write2(stmt_code, -dist);
  stmtlen = stmt_code.size(); // Get total length.
  fun->end_breakable(this, stmt_code);
  out.push_back((char) UC_JNE); // Put cond. jmp. after test.
  Write2(out, stmtlen);   // Skip around body if false.
//  out.append(stmt_code);
          // Append code to end.
  out.insert(out.end(), stmt_code.begin(), stmt_code.end());
  }

/*
 *  Delete.
 */

Uc_arrayloop_statement::~Uc_arrayloop_statement
  (
  )
  {
  delete stmt;
  }

/*
 *  Finish up creation.
 */

void Uc_arrayloop_statement::finish
  (
  Uc_function *fun
  )
  {
  char buf[100];
  if (!index)     // Create vars. if not given.
    {
    sprintf(buf, "_%s_index", array->get_name());
    index = fun->add_symbol(buf);
    }
  if (!array_size);
    {
    sprintf(buf, "_%s_size", array->get_name());
    array_size = fun->add_symbol(buf);
    }
  }

/*
 *  Generate code.
 */

void Uc_arrayloop_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
  if (!stmt)
    return;     // Nothing useful to do.
  out.push_back((char) UC_LOOP);  // Start of loop.
  int top = out.size();   // This is where to jump back to.
  out.push_back((char) UC_LOOPTOP);
  Write2(out, index->get_offset());// Counter, total-count variables.
  Write2(out, array_size->get_offset());
  Write2(out, var->get_offset()); // Loop variable, than array.
  Write2(out, array->get_offset());
          // Still need to write offset to end.
  int testlen = out.size() + 2 - top;
  vector<char> stmt_code;
  stmt_code.reserve(4000);
  fun->start_breakable(this);
  fun->adjust_reloffset(out.size() + 2);
  stmt->gen(stmt_code, fun);  // Generate statement's code.
  fun->adjust_reloffset(-out.size() - 2);
          // Back to top includes JMP at end.
  int dist = testlen + stmt_code.size() + 3;
  stmt_code.push_back((char) UC_JMP); // Generate JMP back to top.
  Write2(stmt_code, -dist);
  int stmtlen = stmt_code.size(); // Get total length.
  Write2(out, stmtlen);   // Finally, offset past loop stmt.
  fun->end_breakable(this, stmt_code);
          // Write out body.
  out.insert(out.end(), stmt_code.begin(), stmt_code.end());
  }

/*
 *  Delete.
 */

Uc_return_statement::~Uc_return_statement
  (
  )
  {
  delete expr;
  }

/*
 *  Generate code.
 */

void Uc_return_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
  if (expr)     // Returning something?
    {
    expr->gen_value(out); // Put value on stack.
    out.push_back((char) UC_SETR);// Pop into ret_value.
    out.push_back((char) UC_RTS);
    }
  else
    out.push_back((char) UC_RET);
  }


/*
 *  Generate code.
 */

void Uc_break_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
          // Store our location.
  fun->add_break(out.size()); //+++++if in an IF???
  out.push_back((char) UC_JMP);
  Write2(out, 0);     // To be filled in at end of loop.
  }


void Uc_label_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
{
  // use reloffset to compensate for jumps to points in separately
  // generated blocks of code
  label->set_offset(out.size() + fun->get_reloffset());

  // no code
}


void Uc_goto_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
{
  Uc_label *l = fun->search_label(label);
  if (l) {
    // use reloffset to compensate for jumps to points in separately
    // generated blocks of code
    l->add_reference(out.size() + fun->get_reloffset());
    out.push_back((char) UC_JMP);
    Write2(out, 0); // will be filled in later
  } else {
    char buf[255];
    snprintf(buf, 255, "Undeclared label: '%s'", label);
    error(buf);
  }
}

/*
 *  Delete.
 */

Uc_converse_statement::~Uc_converse_statement
  (
  )
  {
  delete stmt;
  }

/*
 *  Generate code.
 */

void Uc_converse_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
  long top = out.size();    // Get current position.
  vector<char> stmt_code;
  fun->start_breakable(this);
  if (stmt) {
    fun->adjust_reloffset(out.size() + 3);
    stmt->gen(stmt_code, fun);  // Generate statement's code.
    fun->adjust_reloffset(-out.size() - 3);
  }
  int stmtlen = stmt_code.size();
          // Get distance back to top, including
          //   a CONVERSE & JMP back to top.
  long dist = stmtlen + 3 + 3;
  stmt_code.push_back((char) UC_JMP); // Generate JMP back to top.
  Write2(stmt_code, -dist);
  stmtlen = stmt_code.size(); // Get total length.
  fun->end_breakable(this, stmt_code);
  out.push_back((char) UC_CONVERSE);  // Put CONVERSE at top.
  Write2(out, stmtlen);   // Skip around body if no choices.
          // Write out body.
  out.insert(out.end(), stmt_code.begin(), stmt_code.end());
  out.push_back((char) UC_CONVERSELOC); // Past CONVERSE loop.
  }

/*
 *  Generate a call to an intrinsic with 0 or 1 parameter.
 */
static void Call_intrinsic
  (
  vector<char>& out,
  Uc_function *fun,   // Function we're in.
  Uc_intrinsic_symbol *intr,  // What to call.
  Uc_expression *parm0 = 0  // Parm, or null.
  )
  {
          // Create parms. list.
  Uc_array_expression *parms = new Uc_array_expression;
  if (parm0)
    parms->add(parm0);
  Uc_call_expression *fcall = new Uc_call_expression(intr, parms, fun);
  Uc_call_statement fstmt(fcall);
  fstmt.gen(out, fun);
  parms->clear();     // DON'T want to delete parm0.
  }

/*
 *  Generate code.
 */

void Uc_converse_case_statement::gen
  (
  vector<char>& out,    // Contains all CASE statements up to
          //   this point.
  Uc_function *fun
  )
  {
  out.push_back((char) UC_PUSHS); // Gen. string comparison.
  Write2(out, string_offset);
  out.push_back((char) UC_CMPS);  // Generate comparison.
  Write2(out, 1);     // # strings on stack.
  int to_top_index = out.size();  // Remember this spot to fill in.
  Write2(out, 0);     // Place holder.
  if (remove)     // Remove answer?
    {
    Uc_string_expression str(string_offset);
    Call_intrinsic(out, fun,
        Uc_function::get_remove_answer(), &str);
    }
  if (statements)     // Generate statement's code.
    statements->gen(out, fun);
          // Get distance back to top, including
          //   this JMP
          //   and the CONVERSE above 'out' code.
  long dist = out.size() + 3 + 3;
          // Generate JMP to start of conv.
  out.push_back((char) UC_JMP);
  Write2(out, -dist);
          // Fill in offset in CMPS.
  Write2(out, to_top_index, out.size() - (to_top_index + 2));
  }

/*
 *  Delete.
 */

Uc_converse2_statement::~Uc_converse2_statement
  (
  )
  {
  delete answers;
  delete cases;
  }

/*
 *  Generate code.
 */

void Uc_converse2_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
  if (nest++ > 0)     // Not the outermost?
          // Generate a 'push_answers()'.
    Call_intrinsic(out, fun, Uc_function::get_push_answers());
  if (answers)      // Add desired answers.
    Call_intrinsic(out, fun, 
        Uc_function::get_add_answer(), answers);
  vector<char> stmt_code;
  fun->start_breakable(this);
  if (cases) 
    {
    fun->adjust_reloffset(out.size() + 3);
    cases->gen(stmt_code, fun); // Generate statement's code.
    fun->adjust_reloffset(-out.size() - 3);
    }
  int stmtlen = stmt_code.size();
          // Get distance back to top, including
          //   a CONVERSE & JMP back to top.
  long dist = stmtlen + 3 + 3;
  stmt_code.push_back((char) UC_JMP); // Generate JMP back to top.
  Write2(stmt_code, -dist);
  stmtlen = stmt_code.size(); // Get total length.
  fun->end_breakable(this, stmt_code);
  out.push_back((char) UC_CONVERSE);  // Put CONVERSE at top.
  Write2(out, stmtlen);   // Skip around body if no choices.
          // Write out body.
  out.insert(out.end(), stmt_code.begin(), stmt_code.end());
  out.push_back((char) UC_CONVERSELOC); // Past CONVERSE loop.
  if (--nest > 0)     // Not the outermost?
          // Generate a 'pop_answers()'.
    Call_intrinsic(out, fun, Uc_function::get_pop_answers());
  }

/*
 *  Generate code.
 */

void Uc_message_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
  if (!msgs)
    return;
  const std::vector<Uc_expression*>& exprs = msgs->get_exprs();
  for (std::vector<Uc_expression*>::const_iterator it = exprs.begin();
          it != exprs.end(); ++it)
    {
    Uc_expression *msg = *it;
          // A known string?
    int offset = msg->get_string_offset();
    if (offset >= 0)
      {
      out.push_back((char) UC_ADDSI);
      Write2(out, offset);
      }
    else
      {
      Uc_var_symbol *var = msg->need_var(out, fun);
      if (var)  // Shouldn't fail.
        {
        out.push_back((char) UC_ADDSV);
        Write2(out, var->get_offset());
        }
      }
    }
  }

/*
 *  Generate code.
 */

void Uc_say_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
          // Add the messages.
  Uc_message_statement::gen(out, fun);
  out.push_back((char) UC_SAY);   // Show on screen.
  }

/*
 *  Create.
 */

Uc_call_statement::Uc_call_statement
  (
  Uc_call_expression *f
  ) : function_call(f)
  {
  if (function_call)
    function_call->set_no_return();
  }

/*
 *  Delete.
 */

Uc_call_statement::~Uc_call_statement
  (
  )
  {
  delete function_call;
  }

/*
 *  Generate code.
 */

void Uc_call_statement::gen
  (
  vector<char>& out,
  Uc_function *fun
  )
  {
  function_call->gen_value(out);  // (We set 'no_return'.)
  }

---