Libaray of the classes


SgAttribute
SgProject
SgFile
SgStatement
SgExpression
SgSymbol
SgType
SgLabel
SgValueExp
a value of one of the base types. variants: INT_VAL, CHAR_VAL, FLOAT_VAL, DOUBLE_VAL, STRING_VAL, COMPLEX_VAL, KEYWORD_VAL
SgKeywordValExp
SgUnaryExp
SgCastExp
SgDeleteExp
variant == DELETE_OP
SgNewExp
variant == NEW_OP
SgExprIfExp
(expr1)? expr2 : expr3, variant == EXPR_IF
SgFunctionRefExp
function_name(formal args) - for function headers and protytpes. variant = FUNCTION_REF
SgFunctionCallExp
function_name(expr1, expr2, --). variant == FUNC_CALL
SgFuncPntrExp
(functionpointer)(expr1,expr2,expr3). variant == FUNCTION_OP
SgExprListExp
variant == EXPR_LIST, CONTROL_LIST
SgRefExp
Fortran name references, variant == CONST_REF, TYPE_REF, INTERFACE_REF
SgTypeRefExp
a reference to a type in a c++ template argument
SgVarRefExp
scalar variable reference or non-indexed array reference. variant == VAR_REF
SgThisExp
variant == THIS_NODE
SgTripletExp
variant ==DDOT
SgArrayRefExp
an array reference. variant == ARRAY_REF
SgPntrArrRefExp
SgPointerDerefExp
pointer dereferencing. variant == DEREF_OP
SgRecordRefExp
a field reference of a structure. variant == RECORD_REF
SgStructConstExp
Fortran 90 structure constructor. variant == STRUCTURE_CONSTRUCTOR
SgConstExp
SgVecConstExp
a vector constant of the form: [ expr1, expr2, expr3]. variant == VECTOR_CONST
SgInitListExp
used for initializations. form: { expr1,expr2,expr3}, variant == INIT_LIST
SgObjectListExp
used for EQUIVALENCE, NAMELIST and COMMON statements. variant == EQUI_LIST, NAMELIST_LIST, COMM_LIST
SgAttributeExp
Fortran 90 attributes
SgKeywordArgExp
Fortran 90 keyword argument. variant == KEYWORD_ARG
SgSubscriptExp
Fortran 90 vector subscript expression. variant == DDOT
SgIndexOpExp
variant == INDEX_OP
SgUseOnlyExp
Fortran 90 USE statement ONLY attribute. variant == ONLY_NODE
SgUseRenameExp
Fortran 90 USE statement renaming, variant == RENAME_NODE
SgSpecPairExp
Fortran default control arguments to Input/Output statements. variant == SPEC_PAIR
SgIOAccessExp
Fortran index variable bound instantiation, variant == IOACCESS
SgImplicitTypeExp
Fortran index variable bound instantiation. variant == IMPL_TYPE
SgTypeExp
Fortran type expression. variant == TYPE_OP
SgSeqExp
Fortran index variable bound instantiation. variant == SEQ
SgStringLengthExp
Fortran index variable bound instantiation. variant == LEN_OP
SgDefaultExp
Fortran default node. variant == DEFAULT
SgLabelRefExp
Fortran label reference. variant == LABEL_REF
SgProgHedrStmt
Fortran Program block. variant == PROG_HEDR
SgProcHedrStmt
Fortran subroutine, variant == PROC_HEDR
SgProsHedrStmt
Fortran M process, variant == PROS_HEDR
SgFuncHedrStmt
Fortran and C function, variant == FUNC_HEDR
SgTemplateStmt
a function template or class template
SgModuleStmt
Fortran 90 Module statement. variant == MODULE_STMT
SgInterfaceStmt
Fortran 90 Operator Interface Statement. variant == INTERFACE_STMT
SgBlockDataStmt
Fortran Block Data statement. variant == BLOCK_DATA
SgClassStmt
C++ class statement
SgStructStmt
basic C++ structure
SgUnionStmt
basic C++ structure variant == UNION_DECL union name { body } variables_list;
SgEnumStmt
basic C++ structure
SgCollectionStmt
basic C++ structure
SgBasicBlockStmt
in C we have: { body; } . variant == BASIC_BLOCK
SgForStmt
for Fortran Do and C for(). variant = FOR_NODE
SgForallStmt
variant = FORALL_CONSTRUCT_STMT, FORALL_STMT
SgProcessDoStmt
for Fortran M ProcessDo statement. variant = PROCESS_DO_STAT
SgWhileStmt
for C while()
SgDoWhileStmt
For Fortran dowhile().. and C do{....) while();
SgLogIfStmt
For Fortran logical if - only one body statement allowed. variant == LOGIF_NODE
SgIfStmt
For Fortran if then else and C if(). variant == IF_NODE
SgIfElseIfStmt
For Fortran if then elseif .. elseif ... case. variant == ELSEIF_NODE
SgArithIfStmt
For Fortran Arithementic if
SgWhereStmt
fortran Where stmt. variant == WHERE_NODE
SgWhereBlockStmt
fortran Where - Elsewhere stmt. variant == WHERE_BLOCK_STMT
SgSwitchStmt
Fortran Case and C switch(). variant == SWITCH_NODE
SgCaseOptionStmt
Fortran case option statement. variant == CASE_NODE
SgExecutableStatement
this is really a non-control, non-declaration stmt. no special functions here.
SgAssignStmt
Fortran assignment Statment. variant == ASSIGN_STAT
SgCExpStmt
C non-control expression Statment. variant == EXPR_STMT_NODE
SgPointerAssignStmt
Fortran pointer assignment statement. variant == POINTER_ASSIGN_STAT
SgHeapStmt
Fortran heap space allocation and deallocation statements variant == ALLOCATE_STMT or DEALLOCATE_STMT heap and nullify statements can be sub-classes of list executable statement class
SgNullifyStmt
Fortran pointer initialization statement. variant == NULLIFY_STMT
SgContinueStmt
variant == CONT_STAT in Fortran and variant == CONTINUE_NODE in C
SgControlEndStmt
the end of a basic block. variant == CONTROL_END
SgBreakStmt
the end of a basic block. variant == BREAK_NODE
SgCycleStmt
the fortran 90 cycle statement. variant == CYCLE_STMT
SgReturnStmt
the return (expr) node variant == RETURN_NODE/RETURN_STAT
SgExitStmt
the fortran 90 exit statement. variant == EXIT_STMT
SgGotoStmt
the fortran or C goto. variant == GOTO_NODE
SgLabelListStmt
the fortran statements containg a list of labels
SgAssignedGotoStmt
the fortran. variant == ASSGOTO_NODE
SgComputedGotoStmt
the fortran goto. variant == COMGOTO_NODE
SgStopOrPauseStmt
the fortran stop. variant == STOP_STAT
SgCallStmt
the fortran call. variant == PROC_STAT
SgProsCallStmt
the Fortran M process call
SgProsCallLctn
the Fortran M process call with location
SgProsCallSubm
the Fortran M process call with submachine
SgProcessesStmt
the Fortran M processes statement
SgEndProcessesStmt
the Fortran M endprocesses statement
SgPortTypeExp
variant == PORT_TYPE_OP, INPORT_TYPE_OP, or OUTPORT_TYPE_OP
SgInportStmt
the Fortran M inport statement
SgOutportStmt
the Fortran M outport statement. variant == OUTPORT_DECL
SgChannelStmt
the Fortran M channel statement. variant == CHANNEL_STAT
SgMergerStmt
the Fortran M merger statement. variant == MERGER_STAT
SgMoveportStmt
the Fortran M moveport statement
SgSendStmt
the Fortran M send statement
SgReceiveStmt
the Fortran M receive statement
SgEndchannelStmt
the Fortran M endchannel statement
SgProbeStmt
the Fortran M probe statement
SgProcessorsRefExp
variant == PROCESSORS_REF
SgControlExp
parent of INPORT_NAME, OUTPORT_NAME, FROMPORT_NAME, TOPORT_NAME IOSTAT_STORE, EMPTY_STORE, ERR_LABEL, END_LABEL
SgInportExp
variant == INPORT_NAME
SgOutportExp
variant == OUTPORT_NAME
SgFromportExp
variant == FROMPORT_NAME
SgToportExp
SgIO_statStoreExp
variant == IOSTAT_STORE
SgEmptyStoreExp
variant == EMPTY_STORE
SgErrLabelExp
variant == ERR_LABEL
SgEndLabelExp
variant == END_LABEL
SgDataImpliedDoExp
variant == DATA_IMPL_DO
SgDataEltExp
variant == DATA_ELT
SgDataSubsExp
variant == DATA_SUBS
SgDataRangeExp
variant == DATA_RANGE
SgIconExprExp
variant == ICON_EXPR
SgImpliedDoExp
variant == IMPLIED_DO;
SgIOStmt
fortran input/output and their control statements. abstract class
SgInputOutputStmt
fortran input and output statements. variant = READ_STAT, WRITE_STATE, PRINT_STAT
SgIOControlStmt
fortran input/output control and editing statements variant = OPEN_STAT, CLOSE_STAT, INQUIRE_STAT, BACKSPACE_STAT, REWIND_STAT, ENDFILE_STAT, FORMAT_STAT
SgDeclarationStatement
Declaration class. abstract class
SgVarDeclStmt
Declaration Statement. variant == VAR_DECL
SgIntentStmt
the Fortran M Intent Statement. variant == INTENT_STMT
SgVarListDeclStmt
Declaration Statement
SgStructureDeclStmt
Fortran 90 structure declaration statement. variant == STRUCT_DECL
SgNestedVarListDeclStmt
Declaration statement
SgParameterStmt
Fortran constants declaration statement. variant = PARAM_DECL
SgImplicitStmt
Fortran implicit type declaration statement. variant = IMPL_DECL
SgUseStmt
Fortran 90 module usuage statement. variant = USE_STMT
SgStmtFunctionStmt
Fortran statement function declaration. variant == STMTFN_DECL
SgMiscellStmt
Fortran 90 simple miscellaneous statements. variant == CONTAINS_STMT, PRIVATE_STMT, SEQUENCE_STMT
SgInheritStmt
for HPF : INHERIT_DECL ;
SgConstantSymb
a symbol for a constant object. variant == CONST_NAME
SgFunctionSymb
a subroutine, function or main program. variant == PROGRAM_NAME, PROCEDURE_NAME, or FUNCTION_NAME
SgMemberFuncSymb
a member function for a class or struct or collection
SgFieldSymb
a field in an enum or in a struct. variant == ENUM_NAME or FIELD_NAME
SgClassSymb
the class, union, struct and collection type
SgTypeSymb
a C typedef. the type() function returns the base type. variant == TYPE_NAME
SgLabelSymb
a C label name. variant == LABEL_NAME
SgLabelVarSymb
a Fortran label variable for an assigned goto stmt. variant == LABEL_NAME
SgExternalSymb
for fortran external statement. variant == ROUTINE_NAME
SgConstructSymb
for fortran statement with construct names. variant == CONSTRUCT_NAME
SgInterfaceSymb
for fortran interface statement. variant == INTERFACE_NAME
SgModuleSymb
for fortran module statement
SgArrayType
A new array type is generated for each array. variant == T_ARRAY
SgClassType
a C struct or Fortran Record, a C++ class, a C Union and a C Enum and a pC++ collection
SgPointerType
A pointer type contains only one hany bit of information: the base type
SgFunctionType
Function Types have a returned value type. variant == T_FUNCTION
SgReferenceType
A reference (&xx in c+=) type contains only one hany bit of information: the base type. variant == T_REFERENCE
SgDerivedType
for example: typedef int integer; go to the symbol table for the base type and Id
SgDerivedClassType
variant == T_DERIVED_CLASS
SgDerivedTemplateType
this is the type for a template object: T_DERIVED_TEMPLATE
SgDescriptType
for example in C: long volatile int x; long and volatile are modifiers and there is a descriptor type whose base type is the real type of x
SgDerivedCollectionType
for example: Collection DistributedArray {body1} ; class object {body2} ; DistributedArray<object> X; X is of type with variant = T_DERIVED_COLLECTION
SgDistributeAttrExp
for variant=DISTRIBUTE_OP
SgAlignAttrExp
for variant=ALIGN_ATT
SgDataDistExp
for variant=BLOCK_OP,CYCLIC_OP,COLON_OP,STAR_OP
SgType* SgTypeInt()
SgType* SgTypeChar()
SgType* SgTypeFloat()
SgType* SgTypeDouble()
SgType* SgTypeVoid()
SgType* SgTypeBool()
SgType* SgTypeDefault()
SgType* SgTypeProcessors()
SgType* SgTypeTemplates()
SgUnaryExp& SgDerefOp(SgExpression &e)
SgUnaryExp& SgAddrOp(SgExpression &e)
SgUnaryExp& SgUMinusOp(SgExpression &e)
SgUnaryExp& SgUPlusOp(SgExpression &e)
SgUnaryExp& SgPrePlusPlusOp(SgExpression &e)
SgUnaryExp& SgPreMinusMinusOp(SgExpression &e)
SgUnaryExp& SgPostPlusPlusOp(SgExpression &e)
SgUnaryExp& SgPostMinusMinusOp(SgExpression &e)
SgUnaryExp& SgBitCompfOp(SgExpression &e)
SgUnaryExp& SgNotOp(SgExpression &e)
SgUnaryExp& SgSizeOfOp(SgExpression &e)
SgUnaryExp& makeAnUnaryExpression(int code, PTR_LLND ll1)
SgValueExp* isSgValueExp(SgExpression *pt)
SgKeywordValExp* isSgKeywordValExp(SgExpression *pt)
SgUnaryExp* isSgUnaryExp(SgExpression *pt)
SgCastExp* isSgCastExp(SgExpression *pt)
SgDeleteExp* isSgDeleteExp(SgExpression *pt)
SgNewExp* isSgNewExp(SgExpression *pt)
SgExprIfExp* isSgExprIfExp(SgExpression *pt)
SgFunctionCallExp* isSgFunctionCallExp(SgExpression *pt)
SgFuncPntrExp* isSgFuncPntrExp(SgExpression *pt)
SgExprListExp* isSgExprListExp(SgExpression *pt)
SgRefExp* isSgRefExp(SgExpression *pt)
SgVarRefExp* isSgVarRefExp(SgExpression *pt)
SgThisExp* isSgThisExp(SgExpression *pt)
SgArrayRefExp* isSgArrayRefExp(SgExpression *pt)
SgPntrArrRefExp* isSgPntrArrRefExp(SgExpression *pt)
SgPointerDerefExp* isSgPointerDerefExp(SgExpression *pt)
SgRecordRefExp* isSgRecordRefExp(SgExpression *pt)
SgStructConstExp* isSgStructConstExp(SgExpression *pt)
SgConstExp* isSgConstExp(SgExpression *pt)
SgVecConstExp* isSgVecConstExp(SgExpression *pt)
SgInitListExp* isSgInitListExp(SgExpression *pt)
SgObjectListExp* isSgObjectListExp(SgExpression *pt)
SgAttributeExp* isSgAttributeExp(SgExpression *pt)
SgKeywordArgExp* isSgKeywordArgExp(SgExpression *pt)
SgSubscriptExp* isSgSubscriptExp(SgExpression *pt)
SgUseOnlyExp* isSgUseOnlyExp(SgExpression *pt)
SgUseRenameExp* isSgUseRenameExp(SgExpression *pt)
SgSpecPairExp* isSgSpecPairExp(SgExpression *pt)
SgIOAccessExp* isSgIOAccessExp(SgExpression *pt)
SgImplicitTypeExp* isSgImplicitTypeExp(SgExpression *pt)
SgTypeExp* isSgTypeExp(SgExpression *pt)
SgSeqExp* isSgSeqExp(SgExpression *pt)
SgStringLengthExp* isSgStringLengthExp(SgExpression *pt)
SgDefaultExp* isSgDefaultExp(SgExpression *pt)
SgLabelRefExp* isSgLabelRefExp(SgExpression *pt)
SgProgHedrStmt* isSgProgHedrStmt(SgStatement *pt)
SgProcHedrStmt* isSgProcHedrStmt(SgStatement *pt)
SgFuncHedrStmt* isSgFuncHedrStmt(SgStatement *pt)
SgClassStmt* isSgClassStmt(SgStatement *pt)
SgStructStmt* isSgStructStmt(SgStatement *pt)
SgUnionStmt* isSgUnionStmt(SgStatement *pt)
SgEnumStmt* isSgEnumStmt(SgStatement *pt)
SgCollectionStmt* isSgCollectionStmt(SgStatement *pt)
SgBasicBlockStmt* isSgBasicBlockStmt(SgStatement *pt)
SgForStmt* isSgForStmt(SgStatement *pt)
SgWhileStmt* isSgWhileStmt(SgStatement *pt)
SgDoWhileStmt* isSgDoWhileStmt(SgStatement *pt)
SgLogIfStmt* isSgLogIfStmt(SgStatement *pt)
SgIfStmt* isSgIfStmt(SgStatement *pt)
SgArithIfStmt* isSgArithIfStmt(SgStatement *pt)
SgWhereStmt* isSgWhereStmt(SgStatement *pt)
SgWhereBlockStmt* isSgWhereBlockStmt(SgStatement *pt)
SgSwitchStmt* isSgSwitchStmt(SgStatement *pt)
SgCaseOptionStmt* isSgCaseOptionStmt(SgStatement *pt)
SgExecutableStatement* isSgExecutableStatement(SgStatement *pt)
SgAssignStmt* isSgAssignStmt(SgStatement *pt)
SgCExpStmt* isSgCExpStmt(SgStatement *pt)
SgPointerAssignStmt* isSgPointerAssignStmt(SgStatement *pt)
SgHeapStmt* isSgHeapStmt(SgStatement *pt)
SgNullifyStmt* isSgNullifyStmt(SgStatement *pt)
SgContinueStmt* isSgContinueStmt(SgStatement *pt)
SgControlEndStmt* isSgControlEndStmt(SgStatement *pt)
SgBreakStmt* isSgBreakStmt(SgStatement *pt)
SgCycleStmt* isSgCycleStmt(SgStatement *pt)
SgReturnStmt* isSgReturnStmt(SgStatement *pt)
SgExitStmt* isSgExitStmt(SgStatement *pt)
SgGotoStmt* isSgGotoStmt(SgStatement *pt)
SgLabelListStmt* isSgLabelListStmt(SgStatement *pt)
SgAssignedGotoStmt* isSgAssignedGotoStmt(SgStatement *pt)
SgComputedGotoStmt* isSgComputedGotoStmt(SgStatement *pt)
SgStopOrPauseStmt* isSgStopOrPauseStmt(SgStatement *pt)
SgCallStmt* isSgCallStmt(SgStatement *pt)
SgProsHedrStmt* isSgProsHedrStmt(SgStatement *pt)
Fortran M
SgProcessDoStmt* isSgProcessDoStmt(SgStatement *pt)
Fortran M
SgProsCallStmt* isSgProsCallStmt(SgStatement *pt)
Fortran M
SgProsCallLctn* isSgProsCallLctn(SgStatement *pt)
Fortran M
SgProsCallSubm* isSgProsCallSubm(SgStatement *pt)
Fortran M
SgInportStmt* isSgInportStmt(SgStatement *pt)
Fortran M
SgOutportStmt* isSgOutportStmt(SgStatement *pt)
Fortran M
SgIntentStmt* isSgIntentStmt(SgStatement *pt)
Fortran M
SgChannelStmt* isSgChannelStmt(SgStatement *pt)
Fortran M
SgMergerStmt* isSgMergerStmt(SgStatement *pt)
Fortran M
SgMoveportStmt* isSgMoveportStmt(SgStatement *pt)
Fortran M
SgSendStmt* isSgSendStmt(SgStatement *pt)
Fortran M
SgReceiveStmt* isSgReceiveStmt(SgStatement *pt)
Fortran M
SgEndchannelStmt* isSgEndchannelStmt(SgStatement *pt)
Fortran M
SgProbeStmt* isSgProbeStmt(SgStatement *pt)
Fortran M
SgProcessorsRefExp* isSgProcessorsRefExp(SgExpression *pt)
Fortran M
SgPortTypeExp* isSgPortTypeExp(SgExpression *pt)
Fortran M
SgInportExp* isSgInportExp(SgExpression *pt)
Fortran M
SgOutportExp* isSgOutportExp(SgExpression *pt)
Fortran M
SgFromportExp* isSgFromportExp(SgExpression *pt)
Fortran M
SgToportExp* isSgToportExp(SgExpression *pt)
Fortran M
SgIO_statStoreExp* isSgIO_statStoreExp(SgExpression *pt)
Fortran M
SgEmptyStoreExp* isSgEmptyStoreExp(SgExpression *pt)
Fortran M
SgErrLabelExp* isSgErrLabelExp(SgExpression *pt)
Fortran M
SgEndLabelExp* isSgEndLabelExp(SgExpression *pt)
Fortran M
SgDataImpliedDoExp* isSgDataImpliedDoExp(SgExpression *pt)
Fortran M
SgDataEltExp* isSgDataEltExp(SgExpression *pt)
Fortran M
SgDataSubsExp* isSgDataSubsExp(SgExpression *pt)
Fortran M
SgDataRangeExp* isSgDataRangeExp(SgExpression *pt)
Fortran M
SgIconExprExp* isSgIconExprExp(SgExpression *pt)
Fortran M
SgIOStmt* isSgIOStmt(SgStatement *pt)
SgInputOutputStmt* isSgInputOutputStmt(SgStatement *pt)
SgIOControlStmt* isSgIOControlStmt(SgStatement *pt)
SgDeclarationStatement* isSgDeclarationStatement(SgStatement *pt)
SgVarDeclStmt* isSgVarDeclStmt(SgStatement *pt)
SgVarListDeclStmt* isSgVarListDeclStmt(SgStatement *pt)
SgStructureDeclStmt* isSgStructureDeclStmt(SgStatement *pt)
SgNestedVarListDeclStmt* isSgNestedVarListDeclStmt(SgStatement *pt)
SgParameterStmt* isSgParameterStmt(SgStatement *pt)
SgImplicitStmt* isSgImplicitStmt(SgStatement *pt)
SgVariableSymb* isSgVariableSymb(SgSymbol *pt)
SgConstantSymb* isSgConstantSymb(SgSymbol *pt)
SgFunctionSymb* isSgFunctionSymb(SgSymbol *pt)
SgMemberFuncSymb* isSgMemberFuncSymb(SgSymbol *pt)
SgFieldSymb* isSgFieldSymb(SgSymbol *pt)
SgClassSymb* isSgClassSymb(SgSymbol *pt)
SgLabelSymb* isSgLabelSymb(SgSymbol *pt)
SgLabelVarSymb* isSgLabelVarSymb(SgSymbol *pt)
SgExternalSymb* isSgExternalSymb(SgSymbol *pt)
SgConstructSymb* isSgConstructSymb(SgSymbol *pt)
SgInterfaceSymb* isSgInterfaceSymb(SgSymbol *pt)
SgModuleSymb* isSgModuleSymb(SgSymbol *pt)
SgArrayType* isSgArrayType(SgType *pt)
SgPointerType* isSgPointerType(SgType *pt)
SgFunctionType* isSgFunctionType(SgType *pt)
SgReferenceType* isSgReferenceType(SgType *pt)
SgDerivedType* isSgDerivedType(SgType *pt)
SgDerivedClassType* isSgDerivedClassType(SgType *pt)
SgDescriptType* isSgDescriptType(SgType *pt)
SgDerivedCollectionType* isSgDerivedCollectionType(SgType *pt)

alphabetic index hierarchy of classes


Email contact: zgs@npac.syr.edu

generated by doc++