#ifndef __CFE_H__
#define __CFE_H__
#include "suifkernel/suifkernel_forwarders.h"
#include "suifkernel/suif_object.h"
#include "common/suif_list.h"
#include "common/suif_vector.h"
#include "common/suif_indexed_list.h"
#ifdef PGI_BUILD
#include <new>
#else
#include <new.h>
#endif
#include "cfe_forwarders.h"
#include "common/formatted.h"
#include "suifkernel/iter.h"
#include "common/i_integer.h"
#include "basicnodes/basic.h"
#include "suifnodes/suif.h"
#include "iokernel/meta_class.h"
extern "C" void EXPORT init_cfenodes(SuifEnv* suif);
#ifdef SUIF_NAMESPACE
namespace SUIF_NAMESPACE {
#endif
class CForStatement : public  Statement {
  public:
    virtual Statement*  get_before () const;
    virtual Statement*  set_before(Statement*  the_value);
    
    virtual Expression*  get_test () const;
    virtual Expression*  set_test(Expression*  the_value);
    
    virtual Statement*  get_step () const;
    virtual Statement*  set_step(Statement*  the_value);
    
    virtual Statement*  get_body () const;
    virtual Statement*  set_body(Statement*  the_value);
    
    virtual Statement*  get_pre_pad () const;
    virtual Statement*  set_pre_pad(Statement*  the_value);
    
    virtual CodeLabelSymbol*  get_break_label () const;
    virtual void set_break_label(CodeLabelSymbol*  the_value);
    
    virtual CodeLabelSymbol*  get_continue_label () const;
    virtual void set_continue_label(CodeLabelSymbol*  the_value);
    
    
    
    
    virtual ~CForStatement();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    CForStatement();
    static void constructor_function( Address address );
  private:
    Statement*  _before;
    Expression*  _test;
    Statement*  _step;
    Statement*  _body;
    Statement*  _pre_pad;
    CodeLabelSymbol*  _break_label;
    CodeLabelSymbol*  _continue_label;
    }; 



class CallExpression : public  Expression {
  public:
    virtual Expression*  get_callee_address () const;
    virtual Expression*  set_callee_address(Expression*  the_value);
    
    
    Iter<Expression* sf_owned> get_argument_iterator() const;
    void append_argument(Expression* sf_owned x);
    size_t get_argument_count() const;
    void insert_argument(size_t pos,Expression* sf_owned x);
    void remove_argument(size_t pos);
    Expression* sf_owned get_argument (size_t pos) const;
    void replace_argument(size_t pos,Expression* sf_owned x);
    
    
    
    virtual ~CallExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    CallExpression();
    static void constructor_function( Address address );
  private:
    Expression*  _callee_address;
    suif_vector<Expression* > _arguments;
    }; 



class CExpression : public  Expression {
  public:
    virtual Statement*  get_statement () const;
    virtual Statement*  set_statement(Statement*  the_value);
    
    virtual Expression*  get_expression () const;
    virtual Expression*  set_expression(Expression*  the_value);
    
    
    
    
    virtual ~CExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    CExpression();
    static void constructor_function( Address address );
  private:
    Statement*  _statement;
    Expression*  _expression;
    }; 



class BitSizeOfExpression : public  Expression {
  public:
    virtual Type*  get_ref_type () const;
    virtual void set_ref_type(Type*  the_value);
    
    
    
    
    virtual ~BitSizeOfExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    BitSizeOfExpression();
    static void constructor_function( Address address );
  private:
    Type*  _ref_type;
    }; 



class ByteSizeOfExpression : public  Expression {
  public:
    virtual Type*  get_ref_type () const;
    virtual void set_ref_type(Type*  the_value);
    
    
    
    
    virtual ~ByteSizeOfExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    ByteSizeOfExpression();
    static void constructor_function( Address address );
  private:
    Type*  _ref_type;
    }; 



class BitAlignmentOfExpression : public  Expression {
  public:
    virtual Type*  get_ref_type () const;
    virtual void set_ref_type(Type*  the_value);
    
    
    
    
    virtual ~BitAlignmentOfExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    BitAlignmentOfExpression();
    static void constructor_function( Address address );
  private:
    Type*  _ref_type;
    }; 



class ByteAlignmentOfExpression : public  Expression {
  public:
    virtual Type*  get_ref_type () const;
    virtual void set_ref_type(Type*  the_value);
    
    
    
    
    virtual ~ByteAlignmentOfExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    ByteAlignmentOfExpression();
    static void constructor_function( Address address );
  private:
    Type*  _ref_type;
    }; 



class BitOffsetOfExpression : public  Expression {
  public:
    virtual FieldSymbol*  get_field () const;
    virtual void set_field(FieldSymbol*  the_value);
    
    
    
    
    virtual ~BitOffsetOfExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    BitOffsetOfExpression();
    static void constructor_function( Address address );
  private:
    FieldSymbol*  _field;
    }; 



class ByteOffsetOfExpression : public  Expression {
  public:
    virtual FieldSymbol*  get_field () const;
    virtual void set_field(FieldSymbol*  the_value);
    
    
    
    
    virtual ~ByteOffsetOfExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    ByteOffsetOfExpression();
    static void constructor_function( Address address );
  private:
    FieldSymbol*  _field;
    }; 



class ScAndExpression : public  Expression {
  public:
    virtual Expression*  get_source1 () const;
    virtual Expression*  set_source1(Expression*  the_value);
    
    virtual Expression*  get_source2 () const;
    virtual Expression*  set_source2(Expression*  the_value);
    
    
    
    
    virtual ~ScAndExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    ScAndExpression();
    static void constructor_function( Address address );
  private:
    Expression*  _source1;
    Expression*  _source2;
    }; 



class ScOrExpression : public  Expression {
  public:
    virtual Expression*  get_source1 () const;
    virtual Expression*  set_source1(Expression*  the_value);
    
    virtual Expression*  get_source2 () const;
    virtual Expression*  set_source2(Expression*  the_value);
    
    
    
    
    virtual ~ScOrExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    ScOrExpression();
    static void constructor_function( Address address );
  private:
    Expression*  _source1;
    Expression*  _source2;
    }; 



class ScSelectExpression : public  Expression {
  public:
    virtual Expression*  get_selector () const;
    virtual Expression*  set_selector(Expression*  the_value);
    
    virtual Expression*  get_selection1 () const;
    virtual Expression*  set_selection1(Expression*  the_value);
    
    virtual Expression*  get_selection2 () const;
    virtual Expression*  set_selection2(Expression*  the_value);
    
    
    
    
    virtual ~ScSelectExpression();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    ScSelectExpression();
    static void constructor_function( Address address );
  private:
    Expression*  _selector;
    Expression*  _selection1;
    Expression*  _selection2;
    }; 



class CStringConstant : public  Constant {
  public:
    virtual String get_value () const;
    virtual void set_value(String the_value);
    
    
    
    
    virtual ~CStringConstant();
    virtual void print(FormattedText &x) const;
    static const LString &get_class_name();
  protected:
    //use the factory to create objects
    friend class CfeObjectFactory;
    
    CStringConstant();
    static void constructor_function( Address address );
  private:
    String _value;
    }; 




#ifdef SUIF_NAMESPACE
}
#ifndef NO_IMPLICIT_USING
using namespace SUIF_NAMESPACE;
#endif
#endif
#endif