SAGE 2.0: Documentation for expressions


SgUnaryOp

Base abstract class for unary operators

For base class see SgExpression

Variant name: ABSTRACT. Abstract class, can not be instantiated.

class SgUnaryOp : public SgExpression {

void post_construction_initialization()
{ 
  if (get_operand()) get_operand()->set_parent(this);
  p_mode = SgUnaryOp::prefix;
}

SgExpression * get_operand() const { return get_operand_i(); }
void set_operand(SgExpression * exp);
SgType * get_type() const { return get_expression_type(); }

int length() const { return 1;}
int empty() const { return 0; }
	
void operator_unparse(const char * op, 
	Unparse_Info & info, ostream & os);

public:
enum op_mode { prefix=0, postfix};

int get_mode() { return p_mode; }
void set_mode(op_mode m) { p_mode=m; }

//returns the expression operand, if n is 0; n gets incremented;
//else returns 0
SgExpression *get_next(int &n) const;

// if o matches the current expression operand then 
// set it to expression n and return 1; else return 0; 
int replace_expression(SgExpression *o, SgExpression *n);


/* Generated accessors */
SgExpression* get_operand_i() const;
void set_operand_i(SgExpression*);
SgType* get_expression_type() const;
void set_expression_type(SgType*);

/* Protected data members */ protected: SgExpression* p_operand_i; SgType* p_expression_type; op_mode p_mode; };

SgUnaryOp -- Constructors

/* This is generated in the header file  */
  SgUnaryOp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgUnaryOp::SgUnaryOp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgExpression(info)
{
p_operand_i = operand_i; p_expression_type = expression_type;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgUnaryOp -- Members

Description


SgBinaryOp

Base abstract class for binary operators.

For base class see SgExpression

Variant name: ABSTRACT. Abstract class, can not be instantiated.

class SgBinaryOp : public SgExpression {

void post_construction_initialization() { 
	if (get_lhs_operand()) get_lhs_operand()->set_parent(this);
	if (get_rhs_operand()) get_rhs_operand()->set_parent(this);
}

SgExpression * get_lhs_operand() const;
void set_lhs_operand(SgExpression * exp);

SgExpression * get_rhs_operand() const;
void set_rhs_operand(SgExpression * exp);

SgType * get_type() const { return get_expression_type(); }

int length() const { return 2;}
int empty() const { return 0; }

void operator_unparse(const char * op, 
	Unparse_Info & info, ostream &);

// if n is 0 returns the lhs-operand; if n is 1 returns the rhs-operand
// else returns 0; n gets incremented
SgExpression* get_next(int& n) const;

// replaces the operand that matches with o by n
// returns 1 on success 0 otherwise
int replace_expression(SgExpression *o, SgExpression *n);


/* Generated accessors */
SgExpression* get_lhs_operand_i() const;
void set_lhs_operand_i(SgExpression*);
SgExpression* get_rhs_operand_i() const;
void set_rhs_operand_i(SgExpression*);
SgType* get_expression_type() const;
void set_expression_type(SgType*);

/* Protected data members */ protected: SgExpression* p_lhs_operand_i; SgExpression* p_rhs_operand_i; SgType* p_expression_type; };

SgBinaryOp -- Constructors

/* This is generated in the header file  */
  SgBinaryOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgBinaryOp::SgBinaryOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgExpression(info)
{
p_lhs_operand_i = lhs_operand_i; p_rhs_operand_i = rhs_operand_i; p_expression_type = expression_type;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgBinaryOp -- Members

Description


SgExpressionRoot

Is this one ever used?

For base class see SgUnaryOp

Variant name: EXPRESSION_ROOT.

class SgExpressionRoot : public SgUnaryOp {

SgExpressionRoot() : SgUnaryOp(0, 0, 0) {}
void set_type();
void initialize_root(SgExpression * exp, SgStatement * stmt);


/* Generated accessors */
SgStatement* get_statement() const;
void set_statement(SgStatement*);

/* Protected data members */ protected: SgStatement* p_statement; };

SgExpressionRoot -- Constructors

/* This is generated in the header file  */
  SgExpressionRoot(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0, SgStatement* statement = 0);

 /* This is the generated constructor */
SgExpressionRoot::SgExpressionRoot(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type, SgStatement* statement) 
:SgUnaryOp(info, operand_i, expression_type)
{
p_statement = statement;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgExpressionRoot -- Members

Description


SgExprListExp

An expression made up of a list of expressions.

For base class see SgExpression

Variant name: EXPR_LIST.

class SgExprListExp : public SgExpression {

SgType * get_type() const { return SgTypeDefault::createType(); }
void set_type() {}

// test for empty expression 
int empty() const { if(p_expressions.empty()) return 0; else return 1;}

SgExpressionPtrList& get_expressions();
const SgExpressionPtrList& get_expressions() const;
void append_expression(SgExpression *what);
void prepend_expression(SgExpression *what);
void insert_expression(SgExpressionPtrList::iterator where,
                    SgExpression * what);

// to be called from SgFunctionCallExp and SgAggregateInitializer
void insert_expression(SgExpression::iterator &where, SgExpression *what);

SgExpression *get_first() const;
SgExpression *get_end() const;

// returns the index of the given expression in the expression list
// -1 if expression list is empty
int get_idx(SgExpression *) const; 

void insert_expression(SgExpression *, SgExpression *, int);
int replace_expression(SgExpression *, SgExpression *);

/* Generated accessors */

/* Protected data members */ protected: SgExpressionPtrList p_expressions; };

SgExprListExp -- Constructors

/* This is generated in the header file  */
  SgExprListExp(Sg_File_Info *info );

 /* This is the generated constructor */
SgExprListExp::SgExprListExp(Sg_File_Info* info ) 
:SgExpression(info)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

SgExprListExp -- Members

Description


SgVarRefExp

A variable reference expression. (ex: i=.....)

For base class see SgExpression

Variant name: VAR_REF.

class SgVarRefExp : public SgExpression {

SgType * get_type() const;
void set_type() {};
void post_construction_initialization() { set_type(); }

/* Generated accessors */
SgVariableSymbol* get_symbol() const;
void set_symbol(SgVariableSymbol*);

/* Protected data members */ protected: SgVariableSymbol* p_symbol; };

SgVarRefExp -- Constructors

/* This is generated in the header file  */
  SgVarRefExp(Sg_File_Info *info , SgVariableSymbol* symbol);

 /* This is the generated constructor */
SgVarRefExp::SgVarRefExp(Sg_File_Info* info , SgVariableSymbol* symbol) 
:SgExpression(info)
{
p_symbol = symbol;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgVarRefExp -- Members

Description


SgClassNameRefExp

A reference to a class name expression.

For base class see SgExpression

Variant name: CLASSNAME_REF.

class SgClassNameRefExp : public SgExpression {

void set_type() {}
void post_construction_initialization() { set_type(); }

/* Generated accessors */
SgClassSymbol* get_symbol() const;
void set_symbol(SgClassSymbol*);

/* Protected data members */ protected: SgClassSymbol* p_symbol; };

SgClassNameRefExp -- Constructors

/* This is generated in the header file  */
  SgClassNameRefExp(Sg_File_Info *info , SgClassSymbol* symbol);

 /* This is the generated constructor */
SgClassNameRefExp::SgClassNameRefExp(Sg_File_Info* info , SgClassSymbol* symbol) 
:SgExpression(info)
{
p_symbol = symbol;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgClassNameRefExp -- Members

Description


SgFunctionRefExp

Function reference expression like: ..... foo(b);

For base class see SgExpression

Variant name: FUNCTION_REF.

class SgFunctionRefExp : public SgExpression {

SgFunctionSymbol * get_symbol() const { return get_symbol_i(); }
void set_symbol(SgFunctionSymbol * symbol);

void post_construction_initialization() { 
    if (! p_return_type) set_type(); 
}
SgType * get_type() const { return get_return_type(); }
void set_type(); 

/* Generated accessors */
SgFunctionSymbol* get_symbol_i() const;
void set_symbol_i(SgFunctionSymbol*);
SgType* get_return_type() const;
void set_return_type(SgType*);

/* Protected data members */ protected: SgFunctionSymbol* p_symbol_i; SgType* p_return_type; };

SgFunctionRefExp -- Constructors

/* This is generated in the header file  */
  SgFunctionRefExp(Sg_File_Info *info , SgFunctionSymbol* symbol_i = 0, SgType* return_type = 0);

 /* This is the generated constructor */
SgFunctionRefExp::SgFunctionRefExp(Sg_File_Info* info , SgFunctionSymbol* symbol_i, SgType* return_type) 
:SgExpression(info)
{
p_symbol_i = symbol_i; p_return_type = return_type;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgFunctionRefExp -- Members

Description


SgMemberFunctionRefExp

Member function call

For base class see SgExpression

Variant name: MEMBER_FUNCTION_REF.

class SgMemberFunctionRefExp : public SgExpression {

void post_construction_initialization() { set_type(); }
SgType * get_type() const;
void set_type() {}; 

/* Generated accessors */
SgMemberFunctionSymbol* get_symbol() const;
void set_symbol(SgMemberFunctionSymbol*);
int get_is_virtual_call() const;
void set_is_virtual_call(int);

/* Protected data members */ protected: SgMemberFunctionSymbol* p_symbol; int p_is_virtual_call; };

SgMemberFunctionRefExp -- Constructors

/* This is generated in the header file  */
  SgMemberFunctionRefExp(Sg_File_Info *info , SgMemberFunctionSymbol* symbol, int is_virtual_call = 0);

 /* This is the generated constructor */
SgMemberFunctionRefExp::SgMemberFunctionRefExp(Sg_File_Info* info , SgMemberFunctionSymbol* symbol, int is_virtual_call) 
:SgExpression(info)
{
p_symbol = symbol; p_is_virtual_call = is_virtual_call;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgMemberFunctionRefExp -- Members

Description


SgValueExp

Abstract class for which no constructors are generated. Only to gather the value.

For base class see SgExpression

Variant name: ABSTRACT. Abstract class, can not be instantiated.

class SgValueExp : public SgExpression {

void set_type() {}

/* Generated accessors */

};

SgValueExp -- Constructors

/* This is generated in the header file  */
  SgValueExp(Sg_File_Info *info );

 /* This is the generated constructor */
SgValueExp::SgValueExp(Sg_File_Info* info ) 
:SgExpression(info)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgValueExp


SgBoolValExp

Boolean value expression

For base class see SgValueExp

Variant name: BOOL_VAL.

class SgBoolValExp : public SgValueExp {

SgType* get_type(void) const { return SgTypeBool::createType(); }

/* still missing the method to add the value */ 

/* Generated accessors */
int get_value() const;
void set_value(int);

/* Protected data members */ protected: int p_value; };

SgBoolValExp -- Constructors

/* This is generated in the header file  */
  SgBoolValExp(Sg_File_Info *info , int value);

 /* This is the generated constructor */
SgBoolValExp::SgBoolValExp(Sg_File_Info* info , int value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgBoolValExp -- Members

Description


SgStringVal

The value of a string. (ex: ...... = "string";

For base class see SgValueExp

Variant name: STRING_VAL.

class SgStringVal : public SgValueExp {

void post_construction_initialization() { p_value = (char*)0L; }

SgStringVal(Sg_File_Info*, char*);
~SgStringVal()
{   delete [] p_value; }

SgType* get_type(void) const { return SgTypeString::createType(); }

inline const char* get_value() const
{   return p_value; }

/* Generated accessors */

/* Protected data members */ protected: char * p_value; };

SgStringVal -- Constructors

/* This is generated in the header file  */
  SgStringVal(Sg_File_Info *info );

 /* This is the generated constructor */
SgStringVal::SgStringVal(Sg_File_Info* info ) 
:SgValueExp(info)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

SgStringVal -- Members

Description


SgShortVal

Short values

For base class see SgValueExp

Variant name: SHORT_VAL.

class SgShortVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeShort::createType(); }

/* Generated accessors */
short get_value() const;
void set_value(short);

/* Protected data members */ protected: short p_value; };

SgShortVal -- Constructors

/* This is generated in the header file  */
  SgShortVal(Sg_File_Info *info , short value);

 /* This is the generated constructor */
SgShortVal::SgShortVal(Sg_File_Info* info , short value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgShortVal -- Members

Description


SgCharVal

Character value.

For base class see SgValueExp

Variant name: CHAR_VAL.

class SgCharVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeChar::createType(); }

/* Generated accessors */
char get_value() const;
void set_value(char);

/* Protected data members */ protected: char p_value; };

SgCharVal -- Constructors

/* This is generated in the header file  */
  SgCharVal(Sg_File_Info *info , char value);

 /* This is the generated constructor */
SgCharVal::SgCharVal(Sg_File_Info* info , char value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgCharVal -- Members

Description


SgUnsignedCharVal

Unsigned character value.

For base class see SgValueExp

Variant name: UNSIGNED_CHAR_VAL.

class SgUnsignedCharVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeUnsignedChar::createType(); }

/* Generated accessors */
unsigned char get_value() const;
void set_value(unsigned char);

/* Protected data members */ protected: unsigned char p_value; };

SgUnsignedCharVal -- Constructors

/* This is generated in the header file  */
  SgUnsignedCharVal(Sg_File_Info *info , unsigned char value);

 /* This is the generated constructor */
SgUnsignedCharVal::SgUnsignedCharVal(Sg_File_Info* info , unsigned char value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgUnsignedCharVal -- Members

Description


SgWcharVal

Word char value.

For base class see SgValueExp

Variant name: WCHAR_VAL.

class SgWcharVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeWchar::createType(); }

/* Generated accessors */
wchar_t get_value() const;
void set_value(wchar_t);

/* Protected data members */ protected: wchar_t p_value; };

SgWcharVal -- Constructors

/* This is generated in the header file  */
  SgWcharVal(Sg_File_Info *info , wchar_t value);

 /* This is the generated constructor */
SgWcharVal::SgWcharVal(Sg_File_Info* info , wchar_t value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgWcharVal -- Members

Description


SgUnsignedShortVal

Unsigned short value.

For base class see SgValueExp

Variant name: UNSIGNED_SHORT_VAL.

class SgUnsignedShortVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeUnsignedShort::createType(); }

/* Generated accessors */
unsigned short get_value() const;
void set_value(unsigned short);

/* Protected data members */ protected: unsigned short p_value; };

SgUnsignedShortVal -- Constructors

/* This is generated in the header file  */
  SgUnsignedShortVal(Sg_File_Info *info , unsigned short value);

 /* This is the generated constructor */
SgUnsignedShortVal::SgUnsignedShortVal(Sg_File_Info* info , unsigned short value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgUnsignedShortVal -- Members

Description


SgIntVal

Integer value.

For base class see SgValueExp

Variant name: INT_VAL.

class SgIntVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeInt::createType(); }

/* Generated accessors */
int get_value() const;
void set_value(int);

/* Protected data members */ protected: int p_value; };

SgIntVal -- Constructors

/* This is generated in the header file  */
  SgIntVal(Sg_File_Info *info , int value);

 /* This is the generated constructor */
SgIntVal::SgIntVal(Sg_File_Info* info , int value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgIntVal -- Members

Description


SgEnumVal

Enumeration declaration

For base class see SgValueExp

Variant name: ENUM_VAL.

class SgEnumVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeInt::createType(); }

/* Generated accessors */
int get_value() const;
void set_value(int);
SgEnumDeclaration* get_declaration() const;
void set_declaration(SgEnumDeclaration*);
SgName get_name() const;
void set_name(SgName);

/* Protected data members */ protected: int p_value; SgEnumDeclaration* p_declaration; SgName p_name; };

SgEnumVal -- Constructors

/* This is generated in the header file  */
  SgEnumVal(Sg_File_Info *info , int value, SgEnumDeclaration* declaration, SgName name);

 /* This is the generated constructor */
SgEnumVal::SgEnumVal(Sg_File_Info* info , int value, SgEnumDeclaration* declaration, SgName name) 
:SgValueExp(info)
{
p_value = value; p_declaration = declaration; p_name = name;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgEnumVal -- Members

Description


SgUnsignedIntVal

Unsigned integer value

For base class see SgValueExp

Variant name: UNSIGNED_INT_VAL.

class SgUnsignedIntVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeUnsignedInt::createType(); }

/* Generated accessors */
unsigned int get_value() const;
void set_value(unsigned int);

/* Protected data members */ protected: unsigned int p_value; };

SgUnsignedIntVal -- Constructors

/* This is generated in the header file  */
  SgUnsignedIntVal(Sg_File_Info *info , unsigned int value);

 /* This is the generated constructor */
SgUnsignedIntVal::SgUnsignedIntVal(Sg_File_Info* info , unsigned int value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgUnsignedIntVal -- Members

Description


SgLongIntVal

Long integer value

For base class see SgValueExp

Variant name: LONG_INT_VAL.

class SgLongIntVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeLong::createType(); }

/* Generated accessors */
long int get_value() const;
void set_value(long int);

/* Protected data members */ protected: long int p_value; };

SgLongIntVal -- Constructors

/* This is generated in the header file  */
  SgLongIntVal(Sg_File_Info *info , long int value);

 /* This is the generated constructor */
SgLongIntVal::SgLongIntVal(Sg_File_Info* info , long int value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgLongIntVal -- Members

Description


SgLongLongIntVal

Double long int value

For base class see SgValueExp

Variant name: LONG_LONG_INT_VAL.

class SgLongLongIntVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeLong::createType(); }

/* Generated accessors */
long long int get_value() const;
void set_value(long long int);

/* Protected data members */ protected: long long int p_value; };

SgLongLongIntVal -- Constructors

/* This is generated in the header file  */
  SgLongLongIntVal(Sg_File_Info *info , long long int value);

 /* This is the generated constructor */
SgLongLongIntVal::SgLongLongIntVal(Sg_File_Info* info , long long int value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgLongLongIntVal -- Members

Description


SgUnsignedLongLongIntVal

Double unsigned long int

For base class see SgValueExp

Variant name: UNSIGNED_LONG_LONG_INT_VAL.

class SgUnsignedLongLongIntVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeUnsignedLongLong::createType(); }

/* Generated accessors */
unsigned long long int get_value() const;
void set_value(unsigned long long int);

/* Protected data members */ protected: unsigned long long int p_value; };

SgUnsignedLongLongIntVal -- Constructors

/* This is generated in the header file  */
  SgUnsignedLongLongIntVal(Sg_File_Info *info , unsigned long long int value);

 /* This is the generated constructor */
SgUnsignedLongLongIntVal::SgUnsignedLongLongIntVal(Sg_File_Info* info , unsigned long long int value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgUnsignedLongLongIntVal -- Members

Description


SgUnsignedLongVal

Unsigned long integer value

For base class see SgValueExp

Variant name: UNSIGNED_LONG_INT_VAL.

class SgUnsignedLongVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeUnsignedLong::createType(); }

/* Generated accessors */
unsigned long get_value() const;
void set_value(unsigned long);

/* Protected data members */ protected: unsigned long p_value; };

SgUnsignedLongVal -- Constructors

/* This is generated in the header file  */
  SgUnsignedLongVal(Sg_File_Info *info , unsigned long value);

 /* This is the generated constructor */
SgUnsignedLongVal::SgUnsignedLongVal(Sg_File_Info* info , unsigned long value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgUnsignedLongVal -- Members

Description


SgFloatVal

Float value

For base class see SgValueExp

Variant name: FLOAT_VAL.

class SgFloatVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeFloat::createType(); }

/* Generated accessors */
float get_value() const;
void set_value(float);

/* Protected data members */ protected: float p_value; };

SgFloatVal -- Constructors

/* This is generated in the header file  */
  SgFloatVal(Sg_File_Info *info , float value);

 /* This is the generated constructor */
SgFloatVal::SgFloatVal(Sg_File_Info* info , float value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgFloatVal -- Members

Description


SgDoubleVal

Double float value.

For base class see SgValueExp

Variant name: DOUBLE_VAL.

class SgDoubleVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeDouble::createType(); }

/* Generated accessors */
double get_value() const;
void set_value(double);

/* Protected data members */ protected: double p_value; };

SgDoubleVal -- Constructors

/* This is generated in the header file  */
  SgDoubleVal(Sg_File_Info *info , double value);

 /* This is the generated constructor */
SgDoubleVal::SgDoubleVal(Sg_File_Info* info , double value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgDoubleVal -- Members

Description


SgLongDoubleVal

Long double float value

For base class see SgValueExp

Variant name: LONG_DOUBLE_VAL.

class SgLongDoubleVal : public SgValueExp {

SgType* get_type(void) const { return SgTypeLongDouble::createType(); }

/* Generated accessors */
long double get_value() const;
void set_value(long double);

/* Protected data members */ protected: long double p_value; };

SgLongDoubleVal -- Constructors

/* This is generated in the header file  */
  SgLongDoubleVal(Sg_File_Info *info , long double value);

 /* This is the generated constructor */
SgLongDoubleVal::SgLongDoubleVal(Sg_File_Info* info , long double value) 
:SgValueExp(info)
{
p_value = value;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgLongDoubleVal -- Members

Description


SgFunctionCallExp

Function call expression.

For base class see SgExpression

Variant name: FUNC_CALL.

class SgFunctionCallExp : public SgExpression {

void post_construction_initialization() 
{ 
  if(p_function) p_function->set_parent(this);
  set_type();
}

SgType * get_type() const { return get_expression_type(); }
void set_type() { set_expression_type(get_function()->get_type()); } 

void append_arg(SgExpression* what);
void insert_arg(SgExpression::iterator & where, SgExpression* what);

SgExpression *get_next(int&) const;
int replace_expression(SgExpression *, SgExpression *);

/* Generated accessors */
SgExpression* get_function() const;
void set_function(SgExpression*);
SgExprListExp* get_args() const;
void set_args(SgExprListExp*);
SgType* get_expression_type() const;
void set_expression_type(SgType*);

/* Protected data members */ protected: SgExpression* p_function; SgExprListExp* p_args; SgType* p_expression_type; };

SgFunctionCallExp -- Constructors

/* This is generated in the header file  */
  SgFunctionCallExp(Sg_File_Info *info , SgExpression* function, SgExprListExp* args = 0, SgType* expression_type = 0);

 /* This is the generated constructor */
SgFunctionCallExp::SgFunctionCallExp(Sg_File_Info* info , SgExpression* function, SgExprListExp* args, SgType* expression_type) 
:SgExpression(info)
{
p_function = function; p_args = args; p_expression_type = expression_type;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgFunctionCallExp -- Members

Description


SgArrowExp

Pointer referencing.

For base class see SgBinaryOp

Variant name: POINTST_OP.

class SgArrowExp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_rhs_operand()->get_type());};
int precedence() const { return 16; }

/* Generated accessors */

};

SgArrowExp -- Constructors

/* This is generated in the header file  */
  SgArrowExp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgArrowExp::SgArrowExp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgArrowExp


SgDotExp

Structure member referencing.

For base class see SgBinaryOp

Variant name: RECORD_REF.

class SgDotExp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_rhs_operand()->get_type()); };
int precedence() const { return 16; }

/* Generated accessors */

};

SgDotExp -- Constructors

/* This is generated in the header file  */
  SgDotExp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgDotExp::SgDotExp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgDotExp


SgDotStarOp

For base class see SgBinaryOp

Variant name: DOTSTAR_OP.

class SgDotStarOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
int precedence() const { return 14; }

/* Generated accessors */

};

SgDotStarOp -- Constructors

/* This is generated in the header file  */
  SgDotStarOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgDotStarOp::SgDotStarOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgDotStarOp


SgArrowStarOp

For base class see SgBinaryOp

Variant name: ARROWSTAR_OP.

class SgArrowStarOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() 
{ set_expression_type(get_rhs_operand()->get_type()->dereference());};
int precedence() const { return 14; }

/* Generated accessors */

};

SgArrowStarOp -- Constructors

/* This is generated in the header file  */
  SgArrowStarOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgArrowStarOp::SgArrowStarOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgArrowStarOp


SgEqualityOp

For base class see SgBinaryOp

Variant name: EQ_OP.

class SgEqualityOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(SgTypeBool::createType());};
int precedence() const { return 2; }

/* Generated accessors */

};

SgEqualityOp -- Constructors

/* This is generated in the header file  */
  SgEqualityOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgEqualityOp::SgEqualityOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgEqualityOp


SgLessThanOp

For base class see SgBinaryOp

Variant name: LT_OP.

class SgLessThanOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(SgTypeBool::createType());};
int precedence() const { return 10; }

/* Generated accessors */

};

SgLessThanOp -- Constructors

/* This is generated in the header file  */
  SgLessThanOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgLessThanOp::SgLessThanOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgLessThanOp


SgGreaterThanOp

For base class see SgBinaryOp

Variant name: GT_OP.

class SgGreaterThanOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(SgTypeBool::createType());};
int precedence() const { return 10; }

/* Generated accessors */

};

SgGreaterThanOp -- Constructors

/* This is generated in the header file  */
  SgGreaterThanOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgGreaterThanOp::SgGreaterThanOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgGreaterThanOp


SgNotEqualOp

For base class see SgBinaryOp

Variant name: NE_OP.

class SgNotEqualOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(SgTypeBool::createType());};
int precedence() const { return 9; }

/* Generated accessors */

};

SgNotEqualOp -- Constructors

/* This is generated in the header file  */
  SgNotEqualOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgNotEqualOp::SgNotEqualOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgNotEqualOp


SgLessOrEqualOp

For base class see SgBinaryOp

Variant name: LE_OP.

class SgLessOrEqualOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(SgTypeBool::createType());};
int precedence() const { return 10; }

/* Generated accessors */

};

SgLessOrEqualOp -- Constructors

/* This is generated in the header file  */
  SgLessOrEqualOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgLessOrEqualOp::SgLessOrEqualOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgLessOrEqualOp


SgGreaterOrEqualOp

For base class see SgBinaryOp

Variant name: GE_OP.

class SgGreaterOrEqualOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(SgTypeBool::createType());};
int precedence() const { return 10; }

/* Generated accessors */

};

SgGreaterOrEqualOp -- Constructors

/* This is generated in the header file  */
  SgGreaterOrEqualOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgGreaterOrEqualOp::SgGreaterOrEqualOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgGreaterOrEqualOp


SgAddOp

For base class see SgBinaryOp

Variant name: ADD_OP.

class SgAddOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { 
  SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
  set_expression_type(op_type);
}
int precedence() const { return 12; }

/* Generated accessors */

};

SgAddOp -- Constructors

/* This is generated in the header file  */
  SgAddOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgAddOp::SgAddOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgAddOp


SgSubtractOp

For base class see SgBinaryOp

Variant name: SUBT_OP.

class SgSubtractOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { 
  SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
  set_expression_type(op_type);
}
int precedence() const { return 12; }

/* Generated accessors */

};

SgSubtractOp -- Constructors

/* This is generated in the header file  */
  SgSubtractOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgSubtractOp::SgSubtractOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgSubtractOp


SgMultiplyOp

For base class see SgBinaryOp

Variant name: MULT_OP.

class SgMultiplyOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { 
  SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
  set_expression_type(op_type);
}
int precedence() const { return 13; }

/* Generated accessors */

};

SgMultiplyOp -- Constructors

/* This is generated in the header file  */
  SgMultiplyOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgMultiplyOp::SgMultiplyOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgMultiplyOp


SgDivideOp

For base class see SgBinaryOp

Variant name: DIV_OP.

class SgDivideOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { 
  SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
  set_expression_type(op_type);
}
int precedence() const { return 13; }

/* Generated accessors */

};

SgDivideOp -- Constructors

/* This is generated in the header file  */
  SgDivideOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgDivideOp::SgDivideOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgDivideOp


SgIntegerDivideOp

For base class see SgBinaryOp

Variant name: INTEGER_DIV_OP.

class SgIntegerDivideOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
// todo: why does this operator have "INTEGER" in the name?
void set_type() { 
  SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
  set_expression_type(op_type);
}
int precedence() const { return 13; }

/* Generated accessors */

};

SgIntegerDivideOp -- Constructors

/* This is generated in the header file  */
  SgIntegerDivideOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgIntegerDivideOp::SgIntegerDivideOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgIntegerDivideOp


SgModOp

For base class see SgBinaryOp

Variant name: MOD_OP.

class SgModOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { 
  SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
  set_expression_type(op_type);
}
int precedence() const { return 13; }

/* Generated accessors */

};

SgModOp -- Constructors

/* This is generated in the header file  */
  SgModOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgModOp::SgModOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgModOp


SgAndOp

For base class see SgBinaryOp

Variant name: AND_OP.

class SgAndOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(SgTypeInt::createType()); }
int precedence() const { return 5; }

/* Generated accessors */

};

SgAndOp -- Constructors

/* This is generated in the header file  */
  SgAndOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgAndOp::SgAndOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgAndOp


SgOrOp

For base class see SgBinaryOp

Variant name: OR_OP.

class SgOrOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(SgTypeInt::createType()); }
int precedence() const { return 4; }

/* Generated accessors */

};

SgOrOp -- Constructors

/* This is generated in the header file  */
  SgOrOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgOrOp::SgOrOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgOrOp


SgBitXorOp

For base class see SgBinaryOp

Variant name: BITXOR_OP.

class SgBitXorOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() {  
  SgType * int_type = SgType::integer_promotion(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
  set_expression_type(int_type); 
}
int precedence() const { return 7; }

/* Generated accessors */

};

SgBitXorOp -- Constructors

/* This is generated in the header file  */
  SgBitXorOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgBitXorOp::SgBitXorOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgBitXorOp


SgBitAndOp

For base class see SgBinaryOp

Variant name: BITAND_OP.

class SgBitAndOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() {  
  SgType * int_type = SgType::integer_promotion(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
  set_expression_type(int_type); 
}
int precedence() const { return 8; }

/* Generated accessors */

};

SgBitAndOp -- Constructors

/* This is generated in the header file  */
  SgBitAndOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgBitAndOp::SgBitAndOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgBitAndOp


SgBitOrOp

For base class see SgBinaryOp

Variant name: BITOR_OP.

class SgBitOrOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() {  
  SgType * int_type = SgType::integer_promotion(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
  set_expression_type(int_type); 
}
int precedence() const { return 6; }

/* Generated accessors */

};

SgBitOrOp -- Constructors

/* This is generated in the header file  */
  SgBitOrOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgBitOrOp::SgBitOrOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgBitOrOp


SgCommaOpExp

For base class see SgBinaryOp

Variant name: COMMA_OP.

class SgCommaOpExp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_rhs_operand()->get_type()); }
int precedence() const { return 1; }

/* Generated accessors */

};

SgCommaOpExp -- Constructors

/* This is generated in the header file  */
  SgCommaOpExp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgCommaOpExp::SgCommaOpExp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgCommaOpExp


SgLshiftOp

For base class see SgBinaryOp

Variant name: LSHIFT_OP.

class SgLshiftOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 11; }

/* Generated accessors */

};

SgLshiftOp -- Constructors

/* This is generated in the header file  */
  SgLshiftOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgLshiftOp::SgLshiftOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgLshiftOp


SgRshiftOp

For base class see SgBinaryOp

Variant name: RSHIFT_OP.

class SgRshiftOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 11; }

/* Generated accessors */

};

SgRshiftOp -- Constructors

/* This is generated in the header file  */
  SgRshiftOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgRshiftOp::SgRshiftOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgRshiftOp


SgMinusOp

For base class see SgUnaryOp

Variant name: UNARY_MINUS_OP.

class SgMinusOp : public SgUnaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_operand()->get_type()); } 
int precedence() const { return 15; }

/* Generated accessors */

};

SgMinusOp -- Constructors

/* This is generated in the header file  */
  SgMinusOp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgMinusOp::SgMinusOp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgUnaryOp(info, operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgMinusOp


SgUnaryAddOp

For base class see SgUnaryOp

Variant name: UNARY_ADD_OP.

class SgUnaryAddOp : public SgUnaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_operand()->get_type()); } 
int precedence() const { return 15; }

/* Generated accessors */

};

SgUnaryAddOp -- Constructors

/* This is generated in the header file  */
  SgUnaryAddOp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgUnaryAddOp::SgUnaryAddOp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgUnaryOp(info, operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgUnaryAddOp


SgSizeOfOp

For base class see SgUnaryOp

Variant name: SIZE_OP.

class SgSizeOfOp : public SgUnaryOp {

void post_construction_initialization() { set_type(); }
int precedence() const { return 16; }

/* Generated accessors */

};

SgSizeOfOp -- Constructors

/* This is generated in the header file  */
  SgSizeOfOp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgSizeOfOp::SgSizeOfOp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgUnaryOp(info, operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgSizeOfOp


SgNotOp

For base class see SgUnaryOp

Variant name: NOT_OP.

class SgNotOp : public SgUnaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(SgTypeInt::createType()); }
int precedence() const { return 15; }

/* Generated accessors */

};

SgNotOp -- Constructors

/* This is generated in the header file  */
  SgNotOp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgNotOp::SgNotOp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgUnaryOp(info, operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgNotOp


SgPointerDerefExp

For base class see SgUnaryOp

Variant name: DEREF_OP.

class SgPointerDerefExp : public SgUnaryOp {

void post_construction_initialization() { set_type(); }
void set_type()
{
  if (get_operand() && get_operand()->get_type()->variant() != T_DEFAULT) {	
      set_expression_type(
        ((SgPointerType *) (get_operand()->get_type()))->dereference());
  } else
    set_expression_type(SgTypeDefault::createType());
}
int precedence() const { return 15; }

/* Generated accessors */

};

SgPointerDerefExp -- Constructors

/* This is generated in the header file  */
  SgPointerDerefExp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgPointerDerefExp::SgPointerDerefExp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgUnaryOp(info, operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgPointerDerefExp


SgAddressOfOp

For base class see SgUnaryOp

Variant name: ADDRESS_OP.

class SgAddressOfOp : public SgUnaryOp {

void post_construction_initialization() { set_type(); }
void set_type()
{ set_expression_type(SgPointerType::createType(get_operand()->get_type())); }
int precedence() const { return 15; }

/* Generated accessors */

};

SgAddressOfOp -- Constructors

/* This is generated in the header file  */
  SgAddressOfOp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgAddressOfOp::SgAddressOfOp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgUnaryOp(info, operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgAddressOfOp


SgMinusMinusOp

For base class see SgUnaryOp

Variant name: MINUSMINUS_OP.

class SgMinusMinusOp : public SgUnaryOp {

void post_construction_initialization();
int precedence() const { return 15; }
SgMinusMinusOp(Sg_File_Info * fi, SgExpression * exp, op_mode a_mode);
void set_type() { set_expression_type(get_operand()->get_type()); } 

/* Generated accessors */

};

SgMinusMinusOp -- Constructors

/* This is generated in the header file  */
  SgMinusMinusOp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgMinusMinusOp::SgMinusMinusOp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgUnaryOp(info, operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgMinusMinusOp


SgPlusPlusOp

For base class see SgUnaryOp

Variant name: PLUSPLUS_OP.

class SgPlusPlusOp : public SgUnaryOp {

void post_construction_initialization();
int precedence() const { return 15; }
SgPlusPlusOp(Sg_File_Info * fi, SgExpression * exp, op_mode a_mode);
/* need to call set_type */
void set_type() { set_expression_type(get_operand()->get_type()); } 

/* Generated accessors */

};

SgPlusPlusOp -- Constructors

/* This is generated in the header file  */
  SgPlusPlusOp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgPlusPlusOp::SgPlusPlusOp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgUnaryOp(info, operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgPlusPlusOp


SgBitComplementOp

For base class see SgUnaryOp

Variant name: BIT_COMPLEMENT_OP.

class SgBitComplementOp : public SgUnaryOp {

void post_construction_initialization() { set_type(); }
void set_type() {  
  set_expression_type(get_operand()->get_type());
}
int precedence() const { return 15; }

/* Generated accessors */

};

SgBitComplementOp -- Constructors

/* This is generated in the header file  */
  SgBitComplementOp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgBitComplementOp::SgBitComplementOp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type) 
:SgUnaryOp(info, operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgBitComplementOp


SgConditionalExp

For base class see SgExpression

Variant name: EXPR_CONDITIONAL.

class SgConditionalExp : public SgExpression {

void post_construction_initialization()
{
  if(p_conditional_exp) p_conditional_exp->set_parent(this);
  if(p_true_exp) p_true_exp->set_parent(this);
  if(p_false_exp) p_false_exp->set_parent(this);
  set_type();
}

void set_type() { set_expression_type(get_true_exp()->get_type()); }
SgType * get_type() const { return get_expression_type(); }

SgExpression *get_next(int&) const;
int replace_expression(SgExpression *,SgExpression *);

/* Generated accessors */
SgExpression* get_conditional_exp() const;
void set_conditional_exp(SgExpression*);
SgExpression* get_true_exp() const;
void set_true_exp(SgExpression*);
SgExpression* get_false_exp() const;
void set_false_exp(SgExpression*);
SgType* get_expression_type() const;
void set_expression_type(SgType*);

/* Protected data members */ protected: SgExpression* p_conditional_exp; SgExpression* p_true_exp; SgExpression* p_false_exp; SgType* p_expression_type; };

SgConditionalExp -- Constructors

/* This is generated in the header file  */
  SgConditionalExp(Sg_File_Info *info , SgExpression* conditional_exp, SgExpression* true_exp, SgExpression* false_exp, SgType* expression_type = 0);

 /* This is the generated constructor */
SgConditionalExp::SgConditionalExp(Sg_File_Info* info , SgExpression* conditional_exp, SgExpression* true_exp, SgExpression* false_exp, SgType* expression_type) 
:SgExpression(info)
{
p_conditional_exp = conditional_exp; p_true_exp = true_exp; p_false_exp = false_exp; p_expression_type = expression_type;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgConditionalExp -- Members

Description


SgCastExp

For base class see SgUnaryOp

Variant name: CAST_OP.

class SgCastExp : public SgUnaryOp {

enum e_cast_type { c_cast=0,
                   const_cast,
                   dynamic_cast,
                   reinterpret_cast
};
void post_construction_initialization() 
{ 
  p_cast_type=c_cast;
  set_type();
}

void set_type()
{
   if (!p_expression_type && get_operand_i()) {
     set_expression_type(get_operand_i()->get_type());
   }
}

int precedence() const { return 15; }
e_cast_type cast_type() { return p_cast_type;}
void set_cast_type(e_cast_type v) { p_cast_type=v; }

/* Generated accessors */
bool get_parenthesized() const;
void set_parenthesized(bool);

/* Protected data members */ protected: bool p_parenthesized; e_cast_type p_cast_type; };

SgCastExp -- Constructors

/* This is generated in the header file  */
  SgCastExp(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0, bool parenthesized = 0);

 /* This is the generated constructor */
SgCastExp::SgCastExp(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type, bool parenthesized) 
:SgUnaryOp(info, operand_i, expression_type)
{
p_parenthesized = parenthesized;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgCastExp -- Members

Description


SgPntrArrRefExp

// todo: is this still used? These represent C pointers used as arrays.

For base class see SgBinaryOp

Variant name: ARRAY_OP.

class SgPntrArrRefExp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type()
{ set_expression_type(get_lhs_operand()->get_type()->dereference()); };
int precedence() const { return 16; }

/* Generated accessors */

};

SgPntrArrRefExp -- Constructors

/* This is generated in the header file  */
  SgPntrArrRefExp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgPntrArrRefExp::SgPntrArrRefExp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgPntrArrRefExp


SgNewExp

The new operator.

For base class see SgExpression

Variant name: NEW_OP.

class SgNewExp : public SgExpression {

void post_construction_initialization();
int length() const { return 2;}
int empty() const { return 0; }
SgType * get_type() const { return get_expression_type(); }
void set_type() { }
SgExpression *get_next(int&) const;
int replace_expression(SgExpression*, SgExpression*);

/* Generated accessors */
SgType* get_expression_type() const;
void set_expression_type(SgType*);
SgExprListExp* get_placement_args() const;
void set_placement_args(SgExprListExp*);
SgConstructorInitializer* get_constructor_args() const;
void set_constructor_args(SgConstructorInitializer*);

/* Protected data members */ protected: SgType* p_expression_type; SgExprListExp* p_placement_args; SgConstructorInitializer* p_constructor_args; };

SgNewExp -- Constructors

/* This is generated in the header file  */
  SgNewExp(Sg_File_Info *info , SgType* expression_type, SgExprListExp* placement_args = 0, SgConstructorInitializer* constructor_args = 0);

 /* This is the generated constructor */
SgNewExp::SgNewExp(Sg_File_Info* info , SgType* expression_type, SgExprListExp* placement_args, SgConstructorInitializer* constructor_args) 
:SgExpression(info)
{
p_expression_type = expression_type; p_placement_args = placement_args; p_constructor_args = constructor_args;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgNewExp -- Members

Description


SgDeleteExp

The delete operator.

For base class see SgExpression

Variant name: DELETE_OP.

class SgDeleteExp : public SgExpression {

void post_construction_initialization()
{ if(p_variable) p_variable->set_parent(this); }

int length() const { return 1;}
int empty() const { return 0; }

SgType * get_type() const { return SgTypeVoid::createType(); }
void set_type() { }
SgExpression *get_next(int&) const;
int replace_expression(SgExpression *, SgExpression *);

/* Generated accessors */
SgExpression* get_variable() const;
void set_variable(SgExpression*);
int get_is_array() const;
void set_is_array(int);

/* Protected data members */ protected: SgExpression* p_variable; int p_is_array; };

SgDeleteExp -- Constructors

/* This is generated in the header file  */
  SgDeleteExp(Sg_File_Info *info , SgExpression* variable, int is_array = 0);

 /* This is the generated constructor */
SgDeleteExp::SgDeleteExp(Sg_File_Info* info , SgExpression* variable, int is_array) 
:SgExpression(info)
{
p_variable = variable; p_is_array = is_array;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgDeleteExp -- Members

Description


SgThisExp

"This" expression.

For base class see SgExpression

Variant name: THIS_NODE.

class SgThisExp : public SgExpression {

SgType * get_type() const;
void set_type() {};

/* Generated accessors */
SgClassSymbol* get_class_symbol() const;
void set_class_symbol(SgClassSymbol*);
int get_pobj_this() const;
void set_pobj_this(int);

/* Protected data members */ protected: SgClassSymbol* p_class_symbol; int p_pobj_this; };

SgThisExp -- Constructors

/* This is generated in the header file  */
  SgThisExp(Sg_File_Info *info , SgClassSymbol* class_symbol, int pobj_this = 0);

 /* This is the generated constructor */
SgThisExp::SgThisExp(Sg_File_Info* info , SgClassSymbol* class_symbol, int pobj_this) 
:SgExpression(info)
{
p_class_symbol = class_symbol; p_pobj_this = pobj_this;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgThisExp -- Members

Description


SgScopeOp

The scope operator ::

For base class see SgBinaryOp

Variant name: SCOPE_OP.

class SgScopeOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_rhs_operand()->get_type()); }
int precedence() const { return 17; } // highest precedence

/* Generated accessors */

};

SgScopeOp -- Constructors

/* This is generated in the header file  */
  SgScopeOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgScopeOp::SgScopeOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgScopeOp


SgAssignOp

Assign operator.

For base class see SgBinaryOp

Variant name: ASSIGN_OP.

class SgAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() {  set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgAssignOp -- Constructors

/* This is generated in the header file  */
  SgAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgAssignOp::SgAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgAssignOp


SgPlusAssignOp

Plus assign operator.

For base class see SgBinaryOp

Variant name: PLUS_ASSIGN_OP.

class SgPlusAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() {  SgBinaryOp::set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgPlusAssignOp -- Constructors

/* This is generated in the header file  */
  SgPlusAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgPlusAssignOp::SgPlusAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgPlusAssignOp


SgMinusAssignOp

Minus assign operator.

For base class see SgBinaryOp

Variant name: MINUS_ASSIGN_OP.

class SgMinusAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgMinusAssignOp -- Constructors

/* This is generated in the header file  */
  SgMinusAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgMinusAssignOp::SgMinusAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgMinusAssignOp


SgAndAssignOp

And assign operator.

For base class see SgBinaryOp

Variant name: AND_ASSIGN_OP.

class SgAndAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgAndAssignOp -- Constructors

/* This is generated in the header file  */
  SgAndAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgAndAssignOp::SgAndAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgAndAssignOp


SgIorAssignOp

Or assign operator.

For base class see SgBinaryOp

Variant name: IOR_ASSIGN_OP.

class SgIorAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgIorAssignOp -- Constructors

/* This is generated in the header file  */
  SgIorAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgIorAssignOp::SgIorAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgIorAssignOp


SgMultAssignOp

Multiply assign operator.

For base class see SgBinaryOp

Variant name: MULT_ASSIGN_OP.

class SgMultAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgMultAssignOp -- Constructors

/* This is generated in the header file  */
  SgMultAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgMultAssignOp::SgMultAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgMultAssignOp


SgDivAssignOp

Divide assign operator.

For base class see SgBinaryOp

Variant name: DIV_ASSIGN_OP.

class SgDivAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgDivAssignOp -- Constructors

/* This is generated in the header file  */
  SgDivAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgDivAssignOp::SgDivAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgDivAssignOp


SgModAssignOp

Modulo assign operator

For base class see SgBinaryOp

Variant name: MOD_ASSIGN_OP.

class SgModAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgModAssignOp -- Constructors

/* This is generated in the header file  */
  SgModAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgModAssignOp::SgModAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgModAssignOp


SgXorAssignOp

XOR assign operator.

For base class see SgBinaryOp

Variant name: XOR_ASSIGN_OP.

class SgXorAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgXorAssignOp -- Constructors

/* This is generated in the header file  */
  SgXorAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgXorAssignOp::SgXorAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgXorAssignOp


SgLshiftAssignOp

Left shift assign operator.

For base class see SgBinaryOp

Variant name: LSHIFT_ASSIGN_OP.

class SgLshiftAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgLshiftAssignOp -- Constructors

/* This is generated in the header file  */
  SgLshiftAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgLshiftAssignOp::SgLshiftAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgLshiftAssignOp


SgRshiftAssignOp

Right shift assign operator.

For base class see SgBinaryOp

Variant name: RSHIFT_ASSIGN_OP.

class SgRshiftAssignOp : public SgBinaryOp {

void post_construction_initialization() { set_type(); }
void set_type() { set_expression_type(get_lhs_operand()->get_type()); }
int precedence() const { return 2; }

/* Generated accessors */

};

SgRshiftAssignOp -- Constructors

/* This is generated in the header file  */
  SgRshiftAssignOp(Sg_File_Info *info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type = 0);

 /* This is the generated constructor */
SgRshiftAssignOp::SgRshiftAssignOp(Sg_File_Info* info , SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) 
:SgBinaryOp(info, lhs_operand_i, rhs_operand_i, expression_type)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgRshiftAssignOp


SgRefExp

Expression reference.

For base class see SgExpression

Variant name: TYPE_REF.

class SgRefExp : public SgExpression {

/* Generated accessors */
SgType* get_type_name() const;
void set_type_name(SgType*);

/* Protected data members */ protected: SgType* p_type_name; };

SgRefExp -- Constructors

/* This is generated in the header file  */
  SgRefExp(Sg_File_Info *info , SgType* type_name);

 /* This is the generated constructor */
SgRefExp::SgRefExp(Sg_File_Info* info , SgType* type_name) 
:SgExpression(info)
{
p_type_name = type_name;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgRefExp -- Members

Description


SgInitializer

Base class for expression initialization.

For base class see SgExpression

Variant name: EXPR_INIT.

class SgInitializer : public SgExpression {

/* Generated accessors */

};

SgInitializer -- Constructors

/* This is generated in the header file  */
  SgInitializer(Sg_File_Info *info );

 /* This is the generated constructor */
SgInitializer::SgInitializer(Sg_File_Info* info ) 
:SgExpression(info)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgInitializer


SgAggregateInitializer

Represents initializations of the form \verb+{exp1, exp2, exp3}+.

For base class see SgInitializer

Variant name: AGGREGATE_INIT.

class SgAggregateInitializer : public SgInitializer {

void post_construction_initialization() 
{ if (get_initializers()) get_initializers()->set_parent(this); }

void set_type() {}
SgType * get_type() const { return SgTypeDefault::createType(); }

void append_initializer(SgExpression* what);
void insert_initializer(SgExpression::iterator & where, SgExpression* what);

SgExpression *get_next(int&) const;
int replace_expression(SgExpression *, SgExpression *);

/* Generated accessors */
SgExprListExp* get_initializers() const;
void set_initializers(SgExprListExp*);

/* Protected data members */ protected: SgExprListExp* p_initializers; };

SgAggregateInitializer -- Constructors

/* This is generated in the header file  */
  SgAggregateInitializer(Sg_File_Info *info , SgExprListExp* initializers = 0);

 /* This is the generated constructor */
SgAggregateInitializer::SgAggregateInitializer(Sg_File_Info* info , SgExprListExp* initializers) 
:SgInitializer(info)
{
p_initializers = initializers;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgAggregateInitializer -- Members

Description


SgConstructorInitializer

Initialization constructor for: -dynamic initialization use like: f(classP(arg1, arg2)); -default constructor, like classP a; and return classP(), when classP() is a system supplied default constructor

For base class see SgInitializer

Variant name: CONSTRUCTOR_INIT.

class SgConstructorInitializer : public SgInitializer {

void post_construction_initialization()
{ 
   p_need_name = 0;
   p_need_qualifier=0;
   p_need_paren=0;
   if (get_args()) get_args()->set_parent(this);
}
SgType * get_type() const { return SgTypeDefault::createType();}
void set_type() {} ; 
void set_need_name(int v) { p_need_name=v; }
int get_need_name() const { return p_need_name; }
void set_need_paren(int v) { p_need_paren=v; }
int get_need_paren() const { return p_need_paren; }
void set_need_qualifier(int v) { p_need_qualifier=v; }
int get_need_qualifier() const { return p_need_qualifier; }
SgExpression *get_next(int&) const;
int replace_expression(SgExpression *, SgExpression *);

/* Generated accessors */
SgMemberFunctionDeclaration* get_declaration() const;
void set_declaration(SgMemberFunctionDeclaration*);
SgExprListExp* get_args() const;
void set_args(SgExprListExp*);
SgClassDeclaration* get_class_decl() const;
void set_class_decl(SgClassDeclaration*);

/* Protected data members */ protected: SgMemberFunctionDeclaration* p_declaration; SgExprListExp* p_args; SgClassDeclaration* p_class_decl; int p_need_name; int p_need_paren; int p_need_qualifier; };

SgConstructorInitializer -- Constructors

/* This is generated in the header file  */
  SgConstructorInitializer(Sg_File_Info *info , SgMemberFunctionDeclaration* declaration, SgExprListExp* args = 0, SgClassDeclaration* class_decl = 0);

 /* This is the generated constructor */
SgConstructorInitializer::SgConstructorInitializer(Sg_File_Info* info , SgMemberFunctionDeclaration* declaration, SgExprListExp* args, SgClassDeclaration* class_decl) 
:SgInitializer(info)
{
p_declaration = declaration; p_args = args; p_class_decl = class_decl;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgConstructorInitializer -- Members

Description


SgAssignInitializer

Assignment initialization

For base class see SgInitializer

Variant name: ASSIGN_INIT.

class SgAssignInitializer : public SgInitializer {

void post_construction_initialization() { 
    if (get_operand()) get_operand()->set_parent(this);
    set_type(); 
}

SgExpression * get_operand() const { return get_operand_i(); }
void set_operand(SgExpression * exp);

void set_type(void) { set_expression_type(get_operand()->get_type()); }
SgType * get_type() const { return get_expression_type(); }

SgExpression *get_next(int& n) const;
int replace_expression(SgExpression *o, SgExpression *n);


/* Generated accessors */
SgExpression* get_operand_i() const;
void set_operand_i(SgExpression*);
SgType* get_expression_type() const;
void set_expression_type(SgType*);
bool get_parenthesized() const;
void set_parenthesized(bool);

/* Protected data members */ protected: SgExpression* p_operand_i; SgType* p_expression_type; bool p_parenthesized; };

SgAssignInitializer -- Constructors

/* This is generated in the header file  */
  SgAssignInitializer(Sg_File_Info *info , SgExpression* operand_i, SgType* expression_type = 0, bool parenthesized = 0);

 /* This is the generated constructor */
SgAssignInitializer::SgAssignInitializer(Sg_File_Info* info , SgExpression* operand_i, SgType* expression_type, bool parenthesized) 
:SgInitializer(info)
{
p_operand_i = operand_i; p_expression_type = expression_type; p_parenthesized = parenthesized;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgAssignInitializer -- Members

Description


Goto:
[Extreme] Extreme! Computing Home Page


horea adrian abrudan
Last modified: Wed June 18 13:20:54 EST