ucstmt.h

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.
*/

#ifndef INCL_UCSTMT
#define INCL_UCSTMT

#include <vector>
#include "ucloc.h"
#include "uclabel.h"

class Uc_expression;
class Uc_call_expression;
class Uc_array_expression;
class Uc_function;
class Uc_var_symbol;

#ifndef ALPHA_LINUX_CXX
#  include <iosfwd>
#endif

/*
 *  A statement:
 */
class Uc_statement : public Uc_location
  {
public:
  Uc_statement() : Uc_location()
    {  }
  virtual ~Uc_statement() {  }
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun) = 0;
  };

/*
 *  A group of statements.
 */
class Uc_block_statement : public Uc_statement
  {
    std::vector<Uc_statement *> statements;
public:
  Uc_block_statement()
    {  }
  ~Uc_block_statement();
  void add(Uc_statement *stmt)
    { statements.push_back(stmt); }
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  An assignment statement:
 */
class Uc_assignment_statement : public Uc_statement
  {
  Uc_expression *target, *value;
public:
  Uc_assignment_statement(Uc_expression *t, Uc_expression *v)
    : target(t), value(v)
    {  }
  ~Uc_assignment_statement();
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  An IF statement:
 */
class Uc_if_statement : public Uc_statement
  {
  Uc_expression *expr;    // What to test.
          // What to execute:
  Uc_statement *if_stmt, *else_stmt;
public:
  Uc_if_statement(Uc_expression *e, Uc_statement *t, Uc_statement *f)
    : expr(e), if_stmt(t), else_stmt(f)
    {  }
  ~Uc_if_statement();
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  An WHILE statement:
 */
class Uc_while_statement : public Uc_statement
  {
  Uc_expression *expr;    // What to test.
  Uc_statement *stmt;   // What to execute.
public:
  Uc_while_statement(Uc_expression *e, Uc_statement *s)
    : expr(e), stmt(s)
    {  }
  ~Uc_while_statement();
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  An array loop statement:
 */
class Uc_arrayloop_statement : public Uc_statement
  {
  Uc_var_symbol *var;   // Loop variable.
  Uc_var_symbol *array;   // Array to loop over.
  Uc_var_symbol *index;   // Counter.
  Uc_var_symbol *array_size;  // Symbol holding array size.
  Uc_statement *stmt;   // What to execute.
public:
  Uc_arrayloop_statement(Uc_var_symbol *v, Uc_var_symbol *a)
    : var(v), array(a), index(0), array_size(0), stmt(0)
    {  }
  ~Uc_arrayloop_statement();
  void set_statement(Uc_statement *s)
    { stmt = s; }
  void set_index(Uc_var_symbol *i)
    { index = i; }
  void set_array_size(Uc_var_symbol *as)
    { array_size = as; }
  void finish(Uc_function *fun);  // Create tmps. if necessary.
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  An RETURN statement:
 */
class Uc_return_statement : public Uc_statement
  {
  Uc_expression *expr;    // What to return.  May be 0.
public:
  Uc_return_statement(Uc_expression *e = 0) : expr(e)
    {  }
  ~Uc_return_statement();
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  BREAK statement:
 */
class Uc_break_statement : public Uc_statement
  {
public:
  Uc_break_statement() {  }
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  a LABEL statement:
 */
class Uc_label_statement : public Uc_statement
{
  Uc_label *label;
 public:
  Uc_label_statement(Uc_label *l) : label(l)
    { }
  virtual void gen(std::vector<char>& out, Uc_function *fun);
};

/*
 *  a GOTO statement:
 */
class Uc_goto_statement : public Uc_statement
{
  char *label;
 public:
  Uc_goto_statement(char *l) : label(l)
    { }
  virtual void gen(std::vector<char>& out, Uc_function *fun);
};



/*
 *  A CONVERSE statement is a loop that prompts for a user response at
 *  the top, or exits the loop if there are no possible answers.
 */
class Uc_converse_statement : public Uc_statement
  {
  Uc_statement *stmt;   // What to execute.
public:
  Uc_converse_statement(Uc_statement *s)
    : stmt(s)
    {  }
  ~Uc_converse_statement();
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  Conversation CASE statement:
 */
class Uc_converse_case_statement : public Uc_statement
  {
  int string_offset;    // Offset of string to compare.
  bool remove;      // True to remove answer.
  Uc_statement *statements; // Execute these.
public:
  Uc_converse_case_statement(int soff, bool rem, Uc_statement *stmts)
    : string_offset(soff), remove(rem), statements(stmts)
    {  }
  ~Uc_converse_case_statement()
    { delete statements; }
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  A CONVERSE2 statement provides a less wordy way to implement a
 *  conversation.  It provides for CASE entries for the comparisons, and
 *  also generates push/pop-answers so these can be nested.
 */
class Uc_converse2_statement : public Uc_statement
  {
  static int nest;    // Keeps track of nesting.
  Uc_expression *answers;   // Answers to add.
  Uc_statement *cases;    // What to execute.
public:
  Uc_converse2_statement(Uc_expression *a, Uc_statement *cs)
    : answers(a), cases(cs)
    {  }
  ~Uc_converse2_statement();
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  Add string to current message (for conversations).
 */
class Uc_message_statement : public Uc_statement
  {
  Uc_array_expression *msgs;
public:
  Uc_message_statement(Uc_array_expression *m) : msgs(m) {  }
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  Print message on screen (in conversation).
 */
class Uc_say_statement : public Uc_message_statement
  {
public:
  Uc_say_statement(Uc_array_expression *m) : Uc_message_statement(m) 
    {  }
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

/*
 *  Call a function/intrinsic.
 */
class Uc_call_statement : public Uc_statement
  {
  Uc_call_expression *function_call;
public:
  Uc_call_statement(Uc_call_expression *f);
  ~Uc_call_statement();
          // Generate code.
  virtual void gen(std::vector<char>& out, Uc_function *fun);
  };

#endif

---