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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
This is set to true when the call is a virtual function call. Note that even though the function may be declared virtual, the call itself may not be virtual (in the event that an explicit class qualifier was used in order to suppress the virtual mechanism).
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 */
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
// 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 */
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
"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;
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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;
};
/* 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();
}
Base class for expression initialization.
For base class see SgExpression
Variant name: EXPR_INIT.
class SgInitializer : public SgExpression {
/* Generated accessors */
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
![[Extreme]](images/extreme.icon.gif){kind=icon}
Extreme! Computing Home Page