addExpressionQualificationFields
void addExpressionQualificationFields( std::vector<std::string>& fields, SgExpression* expr); | |
addExpressionType
void addExpressionType( std::vector<std::string>& fields, SgExpression* expr, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
addLocatedPreprocessing
void addLocatedPreprocessing( std::vector<std::string>& fields, SgLocatedNode const* node); | |
aggregateConstructionFieldsFromJson
AggregateConstructionFields aggregateConstructionFieldsFromJson( JsonValue const& properties, NodeMap const& nodes, SgUnsignedCharList source_roles); | |
aggregateSourceElementRolesFromJson
SgUnsignedCharList aggregateSourceElementRolesFromJson(JsonValue const& properties); | |
alignmentSpecifierFromProperties
SgAlignmentSpecifier* alignmentSpecifierFromProperties( JsonValue const& properties, SgExpression* operand); | |
alignmentSpellingFromProperties
SgAlignmentSpecifier::spelling_enum alignmentSpellingFromProperties( JsonValue const& properties, bool has_operand); | |
appendCanonicalJson
void appendCanonicalJson( std::ostream& out, JsonValue const& value); | |
appendRawExternalDeclarationStatementFields
void appendRawExternalDeclarationStatementFields( std::vector<std::string>& fields, SgDeclarationStatement* decl, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& context); | |
appendRawTypeModifierFields
void appendRawTypeModifierFields( std::vector<std::string>& fields, SgTypeModifier const& modifier, std::string const& prefix = "declaration_type"); | |
applyFunctionCallSourceFields
void applyFunctionCallSourceFields( SgFunctionCallExp* call, FunctionCallSourceFields const& fields); | |
argumentSelectsCheckpoint
bool argumentSelectsCheckpoint( std::string const& value, Checkpoint checkpoint); | |
arrayInitBindingCategoryFromJson
SgCastExp::value_category_enum arrayInitBindingCategoryFromJson(JsonValue const& json); | |
arrayInitReferenceFieldsFromJson
ArrayInitReferenceFields arrayInitReferenceFieldsFromJson(JsonValue const& json); | |
asmOperandFieldsFromJson
AsmOperandConstructionFields asmOperandFieldsFromJson(JsonValue const& properties); | |
asmStatementFieldsFromJson
AsmStatementConstructionFields asmStatementFieldsFromJson(JsonValue const& properties); | |
assignmentInitializerSourceFieldsFromJson
AssignmentInitializerSourceFields assignmentInitializerSourceFieldsFromJson(JsonValue const& properties); | |
attachAstAttributes
void attachAstAttributes( SgNode* node, PreparedAstAttributes attributes); | |
attachJsonNodeId
void attachJsonNodeId( SgNode* node, uint64_t id); | |
attachPointerMemberJsonIdentity
void attachPointerMemberJsonIdentity( SgPointerMemberType* type, uint64_t identity); | |
attachPreprocessingInfo
void attachPreprocessingInfo( SgNode* node, PreparedPreprocessingInfo entries); | |
attachSemanticArrayJsonIdentity
void attachSemanticArrayJsonIdentity( SgArrayType* type, uint64_t identity); | |
attachSourceTypeJsonIdentity
void attachSourceTypeJsonIdentity( SgType* type, uint64_t identity); | |
binaryEmissionRoleFromJson
std::optional<SgArrowExp::emission_role_enum> binaryEmissionRoleFromJson( JsonValue const& properties, std::string const& kind); | |
binaryStorageSizeFromJson
std::optional<long long> binaryStorageSizeFromJson( JsonValue const& properties, std::string const& kind); | |
binarySubscriptStridesFromJson
std::vector<std::optional<long long>> binarySubscriptStridesFromJson( JsonValue const& properties, std::string const& kind); | |
bitVectorFromJson
SgBitVector bitVectorFromJson( JsonValue const& json, std::string const& context, std::size_t expected_size); | |
buildCachedJsonPointerType
SgPointerType* buildCachedJsonPointerType(SgType* base); | |
buildFileInfo
Sg_File_Info* buildFileInfo( JsonValue const& json, SgNode* parent); | |
buildJson
std::string buildJson( SgNode* root, Checkpoint checkpoint, SgSourceFile* file, SgFileList* project_files = nullptr, NodeMap* serialized_nodes = nullptr); | |
canonicalSourceIdentityFromJson
std::optional<SgTemplateParameter::canonical_source_identity> canonicalSourceIdentityFromJson( JsonValue const& object, char const* owner); | |
canonicalSubtreeSignature
std::string canonicalSubtreeSignature(SgNode* root); | |
canonicalTypedefDeclarationId
uint64_t canonicalTypedefDeclarationId( std::unordered_map<SgNode const*, uint64_t> const& ids, SgTypedefDeclaration const* decl); | |
castConstructionFieldsFromJson
CastConstructionFields castConstructionFieldsFromJson(JsonValue const& properties); | |
castExpressionFromProperties
SgCastExp* castExpressionFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand, SgType* type, CastConstructionFields const& fields); | |
checkpointEnabled
bool checkpointEnabled( SgSourceFile const* file, Checkpoint checkpoint); | |
checkpointName
char const* checkpointName(Checkpoint checkpoint); | |
checkpointPath
std::filesystem::path checkpointPath( SgSourceFile* file, Checkpoint checkpoint, Options const& options); | |
chooseSelectionFromJson
SgChooseExpression::selection_kind_enum chooseSelectionFromJson(JsonValue const& properties); | |
classDeclarationHasDefinition
bool classDeclarationHasDefinition(SgClassDeclaration* decl); | |
classDeclarationIsFirstNondefining
bool classDeclarationIsFirstNondefining(SgClassDeclaration* decl); | |
classSymbolForDeclaration
SgClassSymbol* classSymbolForDeclaration(SgClassDeclaration* decl); | |
classTypeForDeclaration
SgClassType* classTypeForDeclaration(SgClassDeclaration* decl); | |
collectDelayedDeclarations
std::vector<NodeRecord const*> collectDelayedDeclarations( AstFileRecord const& ast, NodeMap const& nodes); | |
collectExternalFunctionConstructionDependencies
void collectExternalFunctionConstructionDependencies( JsonValue const& json, std::unordered_set<uint64_t>& ids); | |
collectNodes
std::vector<SgNode*> collectNodes(SgNode* root); | |
collectTypeDependencyIds
void collectTypeDependencyIds( JsonValue const& json, std::unordered_set<uint64_t>& ids, std::unordered_set<uint64_t>& symbol_ids, std::unordered_set<uint64_t>& type_ids); | |
commandLine
std::vector<std::string> commandLine(SgSourceFile const* file); | |
commandLineFromJson
std::vector<std::string> commandLineFromJson(JsonValue const& properties); | |
commandLineValue
std::string commandLineValue( SgSourceFile const* file, std::string const& option); | |
complexValueFromProperties
SgComplexVal* complexValueFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
compoundLiteralFromProperties
SgCompoundLiteralExp* compoundLiteralFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
conditionalFromProperties
SgConditionalExp* conditionalFromProperties( JsonValue const& properties, NodeMap const& nodes, SgConditionalExp::conditional_operator_kind_enum kind, SgExpression* condition, SgExpression* true_expression, SgExpression* false_expression); | |
conditionalOperatorKindFromJson
SgConditionalExp::conditional_operator_kind_enum conditionalOperatorKindFromJson(JsonValue const& properties); | |
constructAggregateInitializer
SgAggregateInitializer* constructAggregateInitializer( AggregateConstructionFields const& fields, SgExprListExp* initializers, SgExpressionPtrList const& elements); | |
constructAsmOperand
SgAsmOp* constructAsmOperand( AsmOperandConstructionFields const& fields, SgExpression* expression); | |
constructAsmStatement
SgAsmStmt* constructAsmStatement( AsmStatementConstructionFields const& fields, SgExpressionPtrList const& operands); | |
constructBinaryOp
SgBinaryOp* constructBinaryOp( std::string const& kind, SgExpression* lhs, SgExpression* rhs, SgType* result_type, std::optional<SgArrowExp::emission_role_enum> arrow_role, std::optional<long long> result_storage_size_bytes, std::vector<std::optional<long long>> const& strides); | |
constructChooseExpression
SgChooseExpression* constructChooseExpression( SgType* type, SgChooseExpression::selection_kind_enum selection, SgExpression* condition, SgExpression* true_expression, SgExpression* false_expression); | |
constructClassTypeForDeclaration
SgClassType* constructClassTypeForDeclaration(SgClassDeclaration* decl); | |
constructExternalFunctionOwnedAttributes
void constructExternalFunctionOwnedAttributes( SgFunctionDeclaration* declaration, JsonValue const& json, NodeMap const& nodes); | |
constructExternalFunctionParameterScopeDeclarationsFromJson
void constructExternalFunctionParameterScopeDeclarationsFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, SgInitializedNamePtrList const& parameters, std::string const& function_name, std::optional<SourcePositions> positions); | |
constructExternalFunctionParameterScopeSymbols
bool constructExternalFunctionParameterScopeSymbols( AstFileRecord const& ast, NodeMap const& nodes, bool require_complete); | |
constructExternalFunctionParameterScopeSymbolsFromJson
void constructExternalFunctionParameterScopeSymbolsFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, SgInitializedNamePtrList const& parameters, std::string const& function_name); | |
constructExternalInitializedName
SgInitializedName* constructExternalInitializedName( JsonValue const& json, NodeMap const& nodes, ExternalInitializedNameFields const& fields, SgDeclarationStatement* decl, SgNode* parent, SgScopeStatement* scope, std::string const& context); | |
constructFileInfo
Sg_File_Info* constructFileInfo( std::optional<FileInfoFields> const& fields, SgNode* parent); | |
constructFortranImplicitRange
SgFortranImplicitRange* constructFortranImplicitRange( char first, std::optional<char> last, SgFortranImplicitRange::type_spec_enum type_spec, JsonValue const& properties, NodeMap const& nodes); | |
constructFunctionCall
SgFunctionCallExp* constructFunctionCall( FunctionCallSourceFields const& fields, SgExpression* function, SgExprListExp* arguments, SgType* type, SgCxxLiteralTokenList* literal_tokens); | |
constructInitializedName
SgInitializedName* constructInitializedName( SgName const& name, SgType* type); | |
constructNewExpression
SgNewExp* constructNewExpression( NewConstructionFields const& fields, SgExpression* array_bound, SgExprListExp* placement, SgConstructorInitializer* constructor, SgExpression* builtin, SgFunctionDeclaration* operator_declaration, SgExpressionPtrList const& placement_elements); | |
constructOperandRequirement
SgExpression* constructOperandRequirement( OperandRequirementKind kind, SgExpression* operand, SgExpression* type_constraint, bool noexcept_required); | |
constructPendingSerializedSymbols
bool constructPendingSerializedSymbols( SerializedSymbolTableConstruction& construction, NodeMap const& nodes, bool require_complete); | |
constructPreprocessingInfo
PreparedPreprocessingInfo constructPreprocessingInfo(std::vector<PreprocessingInfoFields> const& fields); | |
constructSourcePositions
SourcePositions constructSourcePositions(SourcePositionFields const& fields); | |
constructTypedefDeclaration
SgTypedefDeclaration* constructTypedefDeclaration( SgName const& name, SgType* base_type, SgDeclarationStatement* base_declaration, bool owns_base_declaration, VariantT kind, SgTemplateTypedefDeclaration* template_declaration, SgTemplateArgumentPtrList const& arguments, SgTemplateArgumentPtrList const& deduced_arguments, TypedefMetadata const& metadata); | |
constructUnaryOp
SgUnaryOp* constructUnaryOp( std::string const& kind, SgExpression* operand, UnaryConstructionFields const& fields, SgType* result_type); | |
constructVisibilitySymbol
std::unique_ptr<SgSymbol> constructVisibilitySymbol( VisibilitySymbolFields const& fields, NodeMap const& nodes, SgNodePtrList causes); | |
constructorArgumentSourceFromProperties
SgConstructorInitializer::argument_source_enum constructorArgumentSourceFromProperties(JsonValue const& properties); | |
constructorElisionFromProperties
bool constructorElisionFromProperties(JsonValue const& properties); | |
constructorInitializerFromProperties
SgConstructorInitializer* constructorInitializerFromProperties( JsonValue const& properties, SgMemberFunctionDeclaration* declaration, SgExprListExp* arguments, SgExpressionPtrList const& elements, SgType* type); | |
contextPropertyFieldsFromRecord
OmpContextPropertyFields contextPropertyFieldsFromRecord(NodeRecord const& record); | |
contextSelectorFieldsFromJson
OmpContextSelectorFields contextSelectorFieldsFromJson(JsonValue const& properties); | |
contextSelectorSetKindFromJson
SgOmpClause::omp_context_selector_set_kind_enum contextSelectorSetKindFromJson(JsonValue const& properties); | |
coroutineKeywordKindFromJson
SgAwaitExpression::coroutine_keyword_kind_enum coroutineKeywordKindFromJson(JsonValue const& properties); | |
createExternalSymbolFromJson
SgSymbol* createExternalSymbolFromJson( JsonValue const& json, NodeMap const& nodes, SgSymbolTable* owner_table); | |
createNodeFromRecord
SgNode* createNodeFromRecord( NodeRecord const& record, SgProject* project, NodeMap const& dependencies); | |
createSourceFileFromRecord
SgSourceFile* createSourceFileFromRecord( NodeRecord const& record, SgProject* project, SgFileList* owner, NodeMap const& dependencies = {}); | |
createSymbolForKindAndBasis
SgSymbol* createSymbolForKindAndBasis( VariantT kind, SgNode* basis, JsonValue const& properties); | |
createUseStatementFromRecord
SgNode* createUseStatementFromRecord( NodeRecord const& record, SgProject* project, SgModuleStatement* module); | |
currentDeserializationSourceFiles
std::vector<SgSourceFile*> currentDeserializationSourceFiles(); | |
declarationConstructionDependencyReady
bool declarationConstructionDependencyReady( AstFileRecord const& ast, NodeMap const& nodes, uint64_t id, bool needs_symbol, bool needs_type_identity, VariantT symbol_kind = V_SgSymbol); | |
declarationFieldsFromJson
DeclarationFields declarationFieldsFromJson( JsonValue const& properties, VariantT kind, std::string const& context, std::string const& qualifier_context = "declaration source qualifier"); | |
declarationNameQualificationFieldsFromJson
DeclarationNameQualificationFields declarationNameQualificationFieldsFromJson(JsonValue const& properties); | |
declarationNeedsExternalReferenceRecord
bool declarationNeedsExternalReferenceRecord( SgDeclarationStatement* decl, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
declarationSourceFieldsFromJson
DeclarationSourceFields declarationSourceFieldsFromJson( JsonValue const& properties, std::string const& context, std::string const& qualifier_context = "declaration source qualifier", bool variable = false); | |
decodeExternalClassDeclaration
std::function<SgClassDeclaration*()> decodeExternalClassDeclaration(JsonValue const& json); | |
decodeExternalFunction
std::function<SgFunctionDeclaration*()> decodeExternalFunction( JsonValue const& json, NodeMap const& nodes); | |
decodeExternalModule
std::function<SgModuleStatement*()> decodeExternalModule(JsonValue const& json); | |
defaultInitializerDeclarationFromJson
SgInitializedName* defaultInitializerDeclarationFromJson( JsonValue const& json, NodeMap const& nodes); | |
defaultInitializerDeclarationNodeFromJson
uint64_t defaultInitializerDeclarationNodeFromJson(JsonValue const& json); | |
defaultInitializerKindFromJson
SgCxxDefaultInitExp::source_kind_enum defaultInitializerKindFromJson(JsonValue const& properties); | |
defaultOutputDirectory
std::string defaultOutputDirectory(SgSourceFile const* file); | |
drainDelayedDeclarations
void drainDelayedDeclarations( AstFileRecord const& ast, std::vector<NodeRecord const*>& pending, NodeMap& nodes, bool require_complete, SymbolConstructionAdvance const& symbols = {}); | |
edgeTargetIsInParentChain
bool edgeTargetIsInParentChain( SgNode const* node, SgNode const* target); | |
edgesFor
std::vector<EdgeRecord> edgesFor( NodeRecord const& record, std::string const& field); | |
enforceSymbolTablePreferences
void enforceSymbolTablePreferences(std::vector<ExpectedSymbolTablePreference> const& entries); | |
enumValueFromProperties
SgEnumVal* enumValueFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
exactBoundSymbolFromJson
SgSymbol* exactBoundSymbolFromJson( JsonValue const& json, NodeMap const& nodes, SgSymbolTable* local_table = nullptr); | |
exactInitializedNameType
SgType* exactInitializedNameType( JsonValue const& properties, NodeMap const& nodes); | |
exactJsonValueHash
uint64_t exactJsonValueHash(JsonValue const& value); | |
exactSerializedPointerTarget
uint64_t exactSerializedPointerTarget( NodeRecord const& record, std::string const& property, std::string const& edge); | |
exactSymbolBindingDependenciesReady
bool exactSymbolBindingDependenciesReady( JsonValue const& json, NodeMap const& nodes); | |
exactSymbolBindingEntryIndex
size_t exactSymbolBindingEntryIndex( JsonValue const& binding, JsonValue const& entries); | |
exactTypedefBaseType
SgType* exactTypedefBaseType( JsonValue const& properties, NodeMap const& nodes); | |
exprListExpFromTypeJson
SgExprListExp* exprListExpFromTypeJson( JsonValue const& json, NodeMap const& nodes); | |
expressionCarriesSemanticType
bool expressionCarriesSemanticType(SgExpression const* expression); | |
expressionConstructionFieldsFromJson
ExpressionConstructionFields expressionConstructionFieldsFromJson(JsonValue const& properties); | |
expressionFromRef
SgExpression* expressionFromRef( JsonValue const& json, NodeMap const& nodes); | |
expressionQualificationFieldsFromJson
std::optional<ExpressionQualificationFields> expressionQualificationFieldsFromJson( std::string const& kind, JsonValue const& properties); | |
expressionSourceFieldsFromJson
ExpressionSourceFields expressionSourceFieldsFromJson( std::string const& kind, JsonValue const& properties); | |
extendedFloatingValueFromJson
Rose::FloatingValue extendedFloatingValueFromJson(JsonValue const& json); | |
externalClassDeclarationFromJson
SgClassDeclaration* externalClassDeclarationFromJson(JsonValue const& json); | |
externalDeclarationFieldsFromJson
ExternalDeclarationFields externalDeclarationFieldsFromJson( JsonValue const& json, VariantT kind, std::string const& context); | |
externalDeclarationReferenceFromJson
SgDeclarationStatement* externalDeclarationReferenceFromJson( JsonValue const& json, NodeMap const& nodes, std::string const& context); | |
externalFunctionFromJson
SgFunctionDeclaration* externalFunctionFromJson( JsonValue const& json, NodeMap const& nodes); | |
externalFunctionParameterScopeOwner
SgFunctionDeclaration* externalFunctionParameterScopeOwner( SgFunctionDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
externalInitializedNameFieldsFromJson
ExternalInitializedNameFields externalInitializedNameFieldsFromJson( JsonValue const& json, NodeMap const& nodes, std::string const& context); | |
externalInitializedNameFromJson
SgInitializedName* externalInitializedNameFromJson( JsonValue const& json, NodeMap const& nodes, SgDeclarationStatement* decl, SgNode* parent, SgScopeStatement* scope, std::string const& context); | |
externalModuleFromJson
SgModuleStatement* externalModuleFromJson(JsonValue const& json); | |
externalParameterScopeDeclarationFromJson
SgDeclarationStatement* externalParameterScopeDeclarationFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, std::string const& function_name); | |
fileInfoFieldsFromJson
std::optional<FileInfoFields> fileInfoFieldsFromJson(JsonValue const& json); | |
fileLanguageFromJson
SgFile::languageOption_enum fileLanguageFromJson( JsonValue const& properties, std::string const& key); | |
fileOutputFormatFromJson
SgFile::outputFormatOption_enum fileOutputFormatFromJson( JsonValue const& properties, std::string const& key); | |
filenameForFileId
std::string filenameForFileId( int id, std::string const& context); | |
floatingValueFromJson
template<typename Float> Float floatingValueFromJson(JsonValue const& json); | |
fnv1a64
uint64_t fnv1a64(std::string const& value); | |
foldConstructionFieldsFromJson
FoldConstructionFields foldConstructionFieldsFromJson(JsonValue const& properties); | |
formatItemFieldsFromJson
FormatItemFields formatItemFieldsFromJson(JsonValue const& properties); | |
fortranCArgumentPassingFromJson
SgInitializedName::fortran_c_argument_passing_enum fortranCArgumentPassingFromJson(JsonValue const& properties); | |
fortranInterfaceFieldsFromJson
FortranInterfaceFields fortranInterfaceFieldsFromJson(JsonValue const& properties); | |
fortranProcedureComponentBindingFromJson
std::optional<SgInitializedName::FortranProcedureComponentBinding> fortranProcedureComponentBindingFromJson(JsonValue const& properties); | |
fortranSourceContextFromJson
SgSourceFile::fortran_source_context fortranSourceContextFromJson(JsonValue const& properties); | |
functionCallSourceFieldsFromJson
FunctionCallSourceFields functionCallSourceFieldsFromJson(JsonValue const& properties); | |
functionConstexprSpecifierFromJson
SgFunctionDeclaration::constexpr_specifier_enum functionConstexprSpecifierFromJson( JsonValue const& properties, std::string const& kind); | |
functionModifierFieldsFromJson
FunctionModifierFields functionModifierFieldsFromJson(NodeRecord const& record); | |
functionParameterReferenceFromProperties
SgFunctionParameterRefExp* functionParameterReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
functionParameterScopeNeedsExternalReferenceRecord
bool functionParameterScopeNeedsExternalReferenceRecord( SgFunctionDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
functionReferenceFromProperties
SgFunctionRefExp* functionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
functionReturnTypeSourceFieldsFromJson
FunctionReturnTypeSourceFields functionReturnTypeSourceFieldsFromJson(JsonValue const& properties); | |
groupSymbolTablePreferences
SymbolTablePreferenceGroups groupSymbolTablePreferences( std::vector<ExpectedSymbolTablePreference> const& entries, std::optional<bool> case_insensitive = std::nullopt); | |
hasCheckpointArgument
bool hasCheckpointArgument( SgSourceFile const* file, Checkpoint checkpoint); | |
hasExternalMarkerAncestor
bool hasExternalMarkerAncestor(SgNode* node); | |
hex64
std::string hex64(uint64_t value); | |
idFor
uint64_t idFor( std::unordered_map<SgNode const*, uint64_t> const& ids, SgNode const* node); | |
ifStatementKindFromJson
SgIfStmt::if_statement_kind_enum ifStatementKindFromJson(JsonValue const& properties); | |
indent
void indent( std::ostream& out, int level); | |
initModifierKindFromJson
SgOmpClause::omp_init_modifier_kind_enum initModifierKindFromJson(JsonValue const& properties); | |
initializeScalarLiteralType
void initializeScalarLiteralType( SgValueExp* value, JsonValue const& properties, NodeMap const& nodes); | |
initializeTemplateParameterTypes
void initializeTemplateParameterTypes( SgTemplateParameter* parameter, NodeRecord const& record, NodeMap const& nodes); | |
initializedNameMetadataFromJson
InitializedNameMetadata initializedNameMetadataFromJson(JsonValue const& properties); | |
initializedNameRolesFromJson
InitializedNameRoles initializedNameRolesFromJson(JsonValue const& properties); | |
insideCollectionBoundary
bool insideCollectionBoundary(SgNode* node); | |
installSourcePositions
void installSourcePositions( SgNode* node, SourcePositions positions, std::string const& context); | |
installTransformationSourcePosition
void installTransformationSourcePosition(SgLocatedNode* node); | |
integer128ValueFromJson
Rose::Integer128Value integer128ValueFromJson(JsonValue const& json); | |
isAnonymousDataMemberReference
bool isAnonymousDataMemberReference(SgVarRefExp* ref); | |
isAstJsonExternalClassDeclaration
bool isAstJsonExternalClassDeclaration(SgClassDeclaration* decl); | |
isAstJsonExternalFunction
bool isAstJsonExternalFunction(SgFunctionDeclaration* decl); | |
isAstJsonExternalModule
bool isAstJsonExternalModule(SgModuleStatement* module); | |
isExternalUseModuleEdge
bool isExternalUseModuleEdge( SgNode* source, SgNode* target, std::string const& field, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
isJsonBinaryOpKind
bool isJsonBinaryOpKind(std::string const& kind); | |
isJsonScalarLiteralKind
bool isJsonScalarLiteralKind(std::string const& kind); | |
isJsonUnaryOpKind
bool isJsonUnaryOpKind(std::string const& kind); | |
isJsonValueExpressionKind
bool isJsonValueExpressionKind(std::string const& kind); | |
isRightHandSideOfMemberAccess
bool isRightHandSideOfMemberAccess(SgNode const* node); | |
isStructuralAstChildOfParent
bool isStructuralAstChildOfParent(SgNode* node); | |
isTypedefOwnedSourceType
bool isTypedefOwnedSourceType(SgType* base); | |
jsonString
std::string jsonString(std::string const& input); | |
kindInVariants
bool kindInVariants( std::string const& kind, VariantVector const& variants); | |
labelReferenceFromProperties
SgLabelRefExp* labelReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
labelSymbolBasisKind
LabelSymbolBasisKind labelSymbolBasisKind(SgLabelSymbol const* symbol); | |
labelSymbolFieldsFromJson
LabelSymbolFields labelSymbolFieldsFromJson(JsonValue const& json); | |
labelSymbolScopeForBasis
SgScopeStatement* labelSymbolScopeForBasis(SgNode* basis); | |
linkDeclarationGroupEdges
void linkDeclarationGroupEdges( AstFileRecord const& ast, NodeMap const& nodes); | |
linkNodeEdges
void linkNodeEdges( NodeRecord const& record, NodeMap const& nodes); | |
literalSpellingFormFromJson
SgValueExp::literal_spelling_form_enum literalSpellingFormFromJson(JsonValue const& properties); | |
literalTokenFieldsFromJson
LiteralTokenFields literalTokenFieldsFromJson(JsonValue const& properties); | |
mappedNodePointers
NodeIds mappedNodePointers(NodeMap const& nodes); | |
markAstJsonExternalClassDeclaration
void markAstJsonExternalClassDeclaration( SgClassDeclaration* decl, std::string const& source_file); | |
markAstJsonExternalFunction
void markAstJsonExternalFunction( SgFunctionDeclaration* decl, std::string const& source_file); | |
markAstJsonExternalModule
void markAstJsonExternalModule( SgModuleStatement* module, std::string const& source_file); | |
memberFunctionReferenceFromProperties
SgMemberFunctionRefExp* memberFunctionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes, SgTypeExpression* type_id); | |
moduleNameForNode
std::string moduleNameForNode(SgNode* node); | |
nearestScope
SgScopeStatement* nearestScope(SgNode* node); | |
newArrayBoundSourceFormFromJson
SgNewExp::array_bound_source_form_enum newArrayBoundSourceFormFromJson(JsonValue const& properties); | |
newConstructionFieldsFromJson
NewConstructionFields newConstructionFieldsFromJson( JsonValue const& properties, NodeMap const& nodes); | |
nodeById
SgNode* nodeById( NodeMap const& nodes, uint64_t id); | |
nodeByIdAs
template<typename T> T* nodeByIdAs( NodeMap const& nodes, uint64_t id); | |
noexceptFromProperties
SgNoexceptOp* noexceptFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand); | |
nonrealReferenceFromProperties
SgNonrealRefExp* nonrealReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes, SgTypeExpression* type_id); | |
nonrealSymbolForDeclaration
SgNonrealSymbol* nonrealSymbolForDeclaration(SgNonrealDecl* decl); | |
nullableCxxSourceTypeFromJson
SgType* nullableCxxSourceTypeFromJson( JsonValue const& json, NodeMap const& nodes); | |
nullableDeclaredExceptionSignatureFromJson
SgFunctionType* nullableDeclaredExceptionSignatureFromJson( JsonValue const& json, NodeMap const& nodes); | |
nullableFunctionSyntaxTypeFromJson
SgFunctionType* nullableFunctionSyntaxTypeFromJson( JsonValue const& json, NodeMap const& nodes); | |
nullableTypeFromJson
SgType* nullableTypeFromJson( JsonValue const& json, NodeMap const& nodes); | |
nullptrValueFromProperties
SgNullptrValExp* nullptrValueFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
ompClauseFieldsFromJson
OmpClauseFields ompClauseFieldsFromJson(NodeRecord const& record); | |
ompContextHierarchyVariant
std::optional<VariantT> ompContextHierarchyVariant(std::string const& kind); | |
ompContextSelectorIdentity
OmpContextSelectorIdentity ompContextSelectorIdentity( SgOmpClause::omp_context_trait_selector_kind_enum kind, SgName const& implementation_name, std::optional<VariantT> construct_kind); | |
ompDefaultOptionFromJson
SgOmpClause::omp_default_option_enum ompDefaultOptionFromJson(JsonValue const& properties); | |
ompDeviceTypeKindFromJson
SgOmpClause::omp_when_context_kind_enum ompDeviceTypeKindFromJson( JsonValue const& properties, std::string const& node_kind); | |
ompDoacrossKindFromJson
SgOmpClause::omp_doacross_kind_enum ompDoacrossKindFromJson(JsonValue const& properties); | |
opaqueValueFieldsFromJson
OpaqueValueFields opaqueValueFieldsFromJson(JsonValue const& json); | |
optionsFromCommandLine
Options optionsFromCommandLine(SgSourceFile const* file); | |
ordinaryOmpVariablesClauseVariant
std::optional<VariantT> ordinaryOmpVariablesClauseVariant(std::string const& kind); | |
owningProject
SgProject* owningProject(SgSourceFile* file); | |
parseAstFileJson
AstFileRecord parseAstFileJson( std::string const& json, std::string const& expected_checkpoint); | |
parseJson
JsonValue parseJson(std::string const& json); | |
pointerMemberJsonIdentity
uint64_t pointerMemberJsonIdentity(SgPointerMemberType* type); | |
populateExternalFunctionParameterScopeFromJson
void populateExternalFunctionParameterScopeFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, SgInitializedNamePtrList const& parameters, std::string const& function_name); | |
prepareAstAttributes
PreparedAstAttributes prepareAstAttributes(NodeRecord const& record); | |
prepareExternalSymbolFromJson
std::function<SgSymbol*()> prepareExternalSymbolFromJson( JsonValue const& json, NodeMap const& nodes, SgSymbolTable* owner_table); | |
preparePreprocessingInfo
PreparedPreprocessingInfo preparePreprocessingInfo(NodeRecord const& record); | |
prepareSymbolForKindAndBasis
std::function<SgSymbol*()> prepareSymbolForKindAndBasis( VariantT kind, SgNode* basis, JsonValue const& properties); | |
preprocessingInfoFieldsFromJson
std::vector<PreprocessingInfoFields> preprocessingInfoFieldsFromJson(NodeRecord const& record); | |
preservedJsonNodeId
uint64_t preservedJsonNodeId(SgNode* node); | |
preservedPointerMemberJsonIdentity
uint64_t preservedPointerMemberJsonIdentity(SgPointerMemberType const* type); | |
preservedSemanticArrayJsonIdentity
uint64_t preservedSemanticArrayJsonIdentity(SgArrayType const* type); | |
preservedSourceTypeJsonIdentity
uint64_t preservedSourceTypeJsonIdentity(SgType const* type); | |
processId
uint64_t processId(); | |
rawAlignmentSpecifiersJson
std::string rawAlignmentSpecifiersJson( SgAlignmentSpecifierPtrList const& specifiers, SgNode* owner, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawAstAttributesJson
std::string rawAstAttributesJson(SgNode* node); | |
rawBitVectorJson
std::string rawBitVectorJson(SgBitVector const& bits); | |
rawBoolField
std::string rawBoolField( std::string const& name, bool value); | |
rawCanonicalSourceIdentityJson
std::string rawCanonicalSourceIdentityJson( std::optional<SgTemplateParameter::canonical_source_identity> const& identity, char const* owner); | |
rawExactBoundSymbolRef
std::string rawExactBoundSymbolRef( SgSymbol* symbol, std::unordered_map<SgNode const*, uint64_t> const& ids, SgScopeStatement const* inline_scope = nullptr); | |
rawExpressionRef
std::string rawExpressionRef( SgExpression* expression, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawExtendedFloatingValue
std::string rawExtendedFloatingValue(Rose::FloatingValue value); | |
rawExternalClassDeclarationJson
std::string rawExternalClassDeclarationJson(SgClassDeclaration* decl); | |
rawExternalDeclarationReferenceJson
std::string rawExternalDeclarationReferenceJson( SgDeclarationStatement* decl, SgDeclarationStatement* owner, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawExternalFunctionJson
std::string rawExternalFunctionJson( SgFunctionDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids, bool force_external = false); | |
rawExternalFunctionParameterScopeJson
std::string rawExternalFunctionParameterScopeJson( SgFunctionDeclaration* function, SgFunctionParameterScope* scope, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name); | |
rawExternalInitializedNameJson
std::string rawExternalInitializedNameJson( SgInitializedName* name, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name); | |
rawExternalModuleJson
std::string rawExternalModuleJson( SgModuleStatement* module, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawExternalUseStatementJson
std::string rawExternalUseStatementJson( SgUseStatement* stmt, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name); | |
rawExternalVariableDeclarationJson
std::string rawExternalVariableDeclarationJson( SgVariableDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name); | |
rawFileInfoJson
std::string rawFileInfoJson(Sg_File_Info const* info); | |
rawFloatingValueBits
template<typename Float> std::string rawFloatingValueBits(Float value); | |
rawFormatDescriptor
std::string rawFormatDescriptor(SgFormatItem::Descriptor const& descriptor); | |
rawInteger128Value
std::string rawInteger128Value(Rose::Integer128Value value); | |
rawIntegerField
std::string rawIntegerField( std::string const& name, int64_t value); | |
rawLocationJson
std::string rawLocationJson(SgNode* node); | |
rawNodeFlagsJson
std::string rawNodeFlagsJson(SgNode* node); | |
rawNodeProperties
std::string rawNodeProperties( SgNode* node, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawOptionalUnsignedIntegerField
std::string rawOptionalUnsignedIntegerField( std::string const& name, std::optional<unsigned int> const& value); | |
rawRequiredLocationJson
std::string rawRequiredLocationJson( SgNode* node, std::string const& context); | |
rawStringField
std::string rawStringField( std::string const& name, std::string const& value); | |
rawStringListJson
std::string rawStringListJson(SgStringList const& values); | |
rawSymbolRef
std::string rawSymbolRef( SgSymbol* symbol, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawSymbolTableJson
std::string rawSymbolTableJson( SgScopeStatement* scope, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTargetAbiJson
std::string rawTargetAbiJson(SgSourceFile::target_abi_info const& abi); | |
rawTemplateArgumentListJson
std::string rawTemplateArgumentListJson( SgTemplateArgumentPtrList const& arguments, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTypeJson
std::string rawTypeJson( SgType* type, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTypeOwnedExprListExpJson
std::string rawTypeOwnedExprListExpJson( SgExprListExp* expr_list, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTypeOwnedExpressionListJson
std::string rawTypeOwnedExpressionListJson( SgExpressionPtrList const& expressions, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTypeOwnedExpressionRef
std::string rawTypeOwnedExpressionRef( SgExpression* expr, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawUnaryTraitEvaluatedValue
std::string rawUnaryTraitEvaluatedValue( std::optional<Rose::Integer128Value> const& value, bool alignment); | |
rawVisibilitySymbolFields
std::vector<std::string> rawVisibilitySymbolFields( SgSymbol* symbol, std::unordered_map<SgNode const*, uint64_t> const& ids, SgScopeStatement const* inline_scope = nullptr); | |
readFile
std::string readFile(std::filesystem::path const& path); | |
rebuildConstructorOnlyNodes
void rebuildConstructorOnlyNodes( AstFileRecord const& ast, NodeMap& nodes); | |
reconstructSourceFile
SgSourceFile* reconstructSourceFile( AstFileRecord const& ast, SgSourceFile* old_file, NodeMap* restored_nodes = nullptr); | |
rejectRemovedQualifiedNameState
void rejectRemovedQualifiedNameState(JsonValue const& properties); | |
replaceFileInProject
void replaceFileInProject( SgSourceFile* old_file, SgSourceFile* new_file); | |
replaceProjectFiles
void replaceProjectFiles( SgProject* project, uint64_t root_id, uint64_t project_files_id, NodeMap const& original, NodeMap const& restored); | |
requireFileIdMapping
void requireFileIdMapping( int id, std::string const& filename, std::string const& context); | |
requireFortranProcedureComponentBinding
void requireFortranProcedureComponentBinding( std::optional<SgInitializedName::FortranProcedureComponentBinding> const& binding, SgType* type, SgScopeStatement* scope); | |
requireFortranProcedureInterface
void requireFortranProcedureInterface( SgExpression* interface, SgType* type, SgInitializedName::fortran_type_spec_enum spec, SgSymbol* source_symbol); | |
requireRestoredKind
void requireRestoredKind( SgNode* node, NodeRecord const& record); | |
requireUnaryTraitResultType
SgType* requireUnaryTraitResultType( SgType* type, std::string const& context); | |
requiredBaseClassAccessModifier
SgAccessModifier::access_modifier_enum requiredBaseClassAccessModifier( JsonValue const& object, std::string const& field, std::string const& context); | |
requiredClassType
SgClassDeclaration::class_types requiredClassType( JsonValue const& object, std::string const& context); | |
requiredClosedEnumRange
template<typename Enum> Enum requiredClosedEnumRange( JsonValue const& object, std::string const& field, std::string const& context, Enum first, Enum last); | |
requiredDeclarationAccessModifier
SgAccessModifier::access_modifier_enum requiredDeclarationAccessModifier( JsonValue const& object, std::string const& field, std::string const& context); | |
requiredEnum
template<typename Enum> Enum requiredEnum( JsonValue const& object, std::string const& field, std::string const& context, std::initializer_list<Enum> legal_values, std::string const& field_description = {}); | |
requiredFortranTypeSpec
SgInitializedName::fortran_type_spec_enum requiredFortranTypeSpec( JsonValue const& object, std::string const& context); | |
requiredGnuDeclarationVisibility
SgDeclarationModifier::gnu_declaration_visibility_enum requiredGnuDeclarationVisibility( JsonValue const& object, std::string const& field, std::string const& context); | |
requiredIntegerBoolean
bool requiredIntegerBoolean( JsonValue const& object, std::string const& field); | |
requiredOmpDeclareVariantRegionOrdinal
std::optional<unsigned int> requiredOmpDeclareVariantRegionOrdinal( JsonValue const& properties, std::string const& semantic_function_name, std::string const& context); | |
requiredOptionalUnsignedInteger
std::optional<unsigned int> requiredOptionalUnsignedInteger( JsonValue const& properties, std::string const& name, std::string const& context); | |
requiredPositiveId
uint64_t requiredPositiveId( JsonValue const& value, std::string const& context); | |
requiredPreinitialization
SgInitializedName::preinitialization_enum requiredPreinitialization( JsonValue const& object, std::string const& context); | |
requiredSingleEdgeTarget
uint64_t requiredSingleEdgeTarget( NodeRecord const& record, std::string const& field); | |
requiredSourcePositionFieldsFromJson
SourcePositionFields requiredSourcePositionFieldsFromJson( JsonValue const& location, std::string const& context); | |
requiredSourcePositionsFromJson
SourcePositions requiredSourcePositionsFromJson( JsonValue const& location, std::string const& context); | |
requiredStorageModifier
SgStorageModifier::storage_modifier_enum requiredStorageModifier( JsonValue const& object, std::string const& field, std::string const& context); | |
requiredTemplateArgumentType
SgTemplateArgument::template_argument_enum requiredTemplateArgumentType( JsonValue const& object, std::string const& context); | |
requiredTemplateParameterType
SgTemplateParameter::template_parameter_enum requiredTemplateParameterType( JsonValue const& object, std::string const& context); | |
requiredTranslationUnitSourceOrder
std::optional<unsigned int> requiredTranslationUnitSourceOrder( JsonValue const& properties, std::string const& context); | |
requiresDelayedRebuild
bool requiresDelayedRebuild(NodeRecord const& record); | |
resolveExistingSymbolFromJson
SgSymbol* resolveExistingSymbolFromJson( JsonValue const& json, NodeMap const& nodes); | |
restoreAvailableAuxiliaryDeclarationOwnership
void restoreAvailableAuxiliaryDeclarationOwnership( AstFileRecord const& ast, NodeMap const& nodes); | |
restoreAvailableConstructionScopes
void restoreAvailableConstructionScopes( AstFileRecord const& ast, NodeMap const& nodes); | |
restoreAvailableParentsAndScopes
void restoreAvailableParentsAndScopes( AstFileRecord const& ast, NodeMap const& nodes); | |
restoreFileIdMapFromMetadata
void restoreFileIdMapFromMetadata(JsonValue const& metadata); | |
restoreRecordedParentEdges
void restoreRecordedParentEdges( AstFileRecord const& ast, NodeMap const& nodes); | |
restoreSerializedSymbolTables
void restoreSerializedSymbolTables( AstFileRecord const& ast, NodeMap const& nodes, std::unordered_set<uint64_t> const& scope_ids, SerializedSymbolTableConstruction* construction = nullptr); | |
restoredExternalClassFromJson
SgClassDeclaration* restoredExternalClassFromJson(JsonValue const& json); | |
restoredExternalFunctionFromJson
SgFunctionDeclaration* restoredExternalFunctionFromJson(JsonValue const& json); | |
returnStatementFieldsFromJson
ReturnStatementFields returnStatementFieldsFromJson(JsonValue const& properties); | |
roundTripSourceFile
SgSourceFile* roundTripSourceFile( SgSourceFile* file, Checkpoint checkpoint); | |
safeNodeText
std::string safeNodeText(SgNode* node); | |
sameAstJsonPath
bool sameAstJsonPath( std::string const& lhs, std::string const& rhs); | |
sanitizePathComponent
std::string sanitizePathComponent(std::string name); | |
semanticArrayDependenciesReady
bool semanticArrayDependenciesReady( JsonValue const& json, SemanticArrayConstruction const* owner); | |
semanticArrayJsonIdentity
uint64_t semanticArrayJsonIdentity(SgArrayType* type); | |
semanticFunctionTypeFromJson
SgFunctionType* semanticFunctionTypeFromJson( JsonValue const& json, NodeMap const& nodes); | |
semanticFunctionTypeKindFromJson
VariantT semanticFunctionTypeKindFromJson(JsonValue const& json); | |
semanticSignature
std::string semanticSignature(AstFileRecord const& ast); | |
semanticSignatureEquals
bool semanticSignatureEquals( AstFileRecord const& ast, std::string const& signature); | |
singleEdgeTarget
uint64_t singleEdgeTarget( NodeRecord const& record, std::string const& field); | |
sourceFileMatchesExternalRecord
bool sourceFileMatchesExternalRecord( SgSourceFile* file, std::string const& source_file); | |
sourceFileNameForExternalFunction
std::string sourceFileNameForExternalFunction(SgFunctionDeclaration* decl); | |
sourceFileNameForNode
std::string sourceFileNameForNode(SgNode* node); | |
sourceIsBeingReplaced
bool sourceIsBeingReplaced(SgSourceFile* file); | |
sourceLocationBuiltinFromProperties
SgSourceLocationBuiltinExp* sourceLocationBuiltinFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
sourceLocationBuiltinKindFromJson
SgSourceLocationBuiltinExp::source_location_builtin_kind_enum sourceLocationBuiltinKindFromJson(JsonValue const& properties); | |
sourcePositionsFromJson
SourcePositions sourcePositionsFromJson( JsonValue const& location, bool expression); | |
sourceTypeJsonIdentity
uint64_t sourceTypeJsonIdentity(SgType* type); | |
startsWith
bool startsWith( std::string const& s, std::string const& prefix); | |
statementFieldsFromJson
StatementFields statementFieldsFromJson( NodeRecord const& record, VariantT kind); | |
storageSizeFromJson
std::optional<long long> storageSizeFromJson( JsonValue const& properties, std::string const& field); | |
stringListFromJson
SgStringList stringListFromJson( JsonValue const& value, std::string const& context); | |
structuredBindingKindFromJson
SgInitializedName::structured_binding_kind_enum structuredBindingKindFromJson(JsonValue const& properties); | |
subobjectDestructionKindFromJson
SgCxxSubobjectDestruction::target_kind_enum subobjectDestructionKindFromJson(JsonValue const& json); | |
symbolBasis
SgNode const* symbolBasis(SgSymbol const* symbol); | |
symbolDependencyOrder
std::vector<size_t> symbolDependencyOrder(std::vector<std::optional<size_t>> const& dependencies); | |
symbolFromJson
SgSymbol* symbolFromJson( JsonValue const& json, NodeMap const& nodes); | |
symbolIsLookupPreferred
bool symbolIsLookupPreferred( SgSymbolTable* table, SgName const& name, SgSymbol* symbol); | |
symbolLookupPreferenceCategory
VariantT symbolLookupPreferenceCategory(VariantT kind); | |
symbolName
std::string symbolName(SgSymbol const* symbol); | |
symbolTableEntriesFromRecord
std::vector<SerializedSymbolTableEntry> symbolTableEntriesFromRecord(NodeRecord const& record); | |
symbolVariantFromJsonKind
VariantT symbolVariantFromJsonKind(std::string const& kind); | |
targetAbiFromJson
SgSourceFile::target_abi_info targetAbiFromJson(JsonValue const& json); | |
targetSizeTypeFromJson
SgType* targetSizeTypeFromJson( JsonValue const& json, NodeMap const& nodes, bool target_available); | |
templateArgumentListFromJson
SgTemplateArgumentPtrList templateArgumentListFromJson( JsonValue const& json, NodeMap const& nodes, SgNode* parent); | |
templateFunctionReferenceFromProperties
SgTemplateFunctionRefExp* templateFunctionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
templateMemberFunctionReferenceFromProperties
SgTemplateMemberFunctionRefExp* templateMemberFunctionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes, SgTypeExpression* type_id); | |
templateParameterOperandsFromRecord
TemplateParameterOperands templateParameterOperandsFromRecord( NodeRecord const& record, NodeMap const& nodes, SgTemplateParameter const* owner = nullptr); | |
templateParameterSourceFieldsFromJson
TemplateParameterSourceFields templateParameterSourceFieldsFromJson(JsonValue const& object); | |
templateParameterValueFromProperties
SgTemplateParameterVal* templateParameterValueFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
temporaryWritePath
std::filesystem::path temporaryWritePath(std::filesystem::path const& path); | |
thisExpressionFromProperties
SgThisExp* thisExpressionFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
trim
std::string trim(std::string const& input); | |
typeFromJson
SgType* typeFromJson( JsonValue const& json, NodeMap const& nodes, std::string const& exact_type_error = "AST JSON type requires an exact type"); | |
typeIdFromProperties
SgTypeIdOp* typeIdFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand, SgType* operand_type, bool operand_is_evaluated); | |
typeModifierFieldsFromJson
TypeModifierFields typeModifierFieldsFromJson( JsonValue const& json, std::string const& context, std::string const& prefix = "declaration_type"); | |
typeOwnsSourceJsonIdentity
bool typeOwnsSourceJsonIdentity(SgType const* type); | |
typeRequirementFromProperties
SgTypeRequirement* typeRequirementFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
typeTraitBuiltinFromProperties
SgTypeTraitBuiltinOperator* typeTraitBuiltinFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpressionPtrList const& arguments); | |
typedefMetadataFromJson
TypedefMetadata typedefMetadataFromJson(JsonValue const& properties); | |
unaryConstructionFieldsFromJson
UnaryConstructionFields unaryConstructionFieldsFromJson( JsonValue const& properties, std::string const& kind, NodeMap const& nodes); | |
unaryTraitEvaluatedValueFromJson
std::optional<Rose::Integer128Value> unaryTraitEvaluatedValueFromJson( JsonValue const& json, bool alignment); | |
unaryTraitKindFromProperties
SgExpression::unary_type_trait_kind_enum unaryTraitKindFromProperties(NodeRecord const& record); | |
unaryTraitSourceFieldsFromJson
UnaryTraitSourceFields unaryTraitSourceFieldsFromJson( JsonValue const& properties, std::string const& context); | |
unsigned64ValueFromJson
uint64_t unsigned64ValueFromJson(JsonValue const& json); | |
validFortranSeparatePointerOwnership
bool validFortranSeparatePointerOwnership(SgInitializedName const* name); | |
validateAnonymousDataMemberReferenceQualification
void validateAnonymousDataMemberReferenceQualification(SgVarRefExp* ref); | |
validateConstructionFlags
NodeConstructionFlags validateConstructionFlags(NodeRecord const& record); | |
validateExactSemanticExpressionType
void validateExactSemanticExpressionType( SgExpression const* expression, SgType const* type, std::string const& phase); | |
validateExpressionLifetime
void validateExpressionLifetime( ExpressionConstructionFields const& fields, JsonValue const& properties, NodeMap const& nodes); | |
validateExternalSymbolBasisOwnership
void validateExternalSymbolBasisOwnership(SgSymbol* symbol); | |
validateFortranAggregateConstruction
void validateFortranAggregateConstruction(AggregateConstructionFields const& fields); | |
validateFortranInterfaceFields
void validateFortranInterfaceFields(FortranInterfaceFields const& fields); | |
validateFortranProgramNameMetadata
void validateFortranProgramNameMetadata( std::string const& opening_name, int64_t statement_kind, bool named_in_end_statement, std::string const& end_statement_name); | |
validateFunctionCallInputs
void validateFunctionCallInputs( FunctionCallSourceFields const& fields, SgExpression* function, SgExprListExp* arguments, SgType* type, SgCxxLiteralTokenList* literal_tokens, size_t argument_count, size_t token_count); | |
validateLabelSymbolFields
void validateLabelSymbolFields( SgLabelSymbol const* symbol, JsonValue const& json); | |
validateNamespaceSymbolKey
void validateNamespaceSymbolKey( SgName const& entry_name, SgNode* basis); | |
validateNonrealResolvedTargetIdentity
template<typename Identity> void validateNonrealResolvedTargetIdentity( Identity function, Identity variable, Identity spelling_target); | |
validateOmpContextKindAny
void validateOmpContextKindAny( bool has_any, size_t property_count, size_t selector_count); | |
validateOmpContextPropertyPayload
void validateOmpContextPropertyPayload( bool has_expression, SgOmpClause::omp_when_context_kind_enum kind, SgOmpClause::omp_when_context_vendor_enum vendor, SgOmpClause::omp_atomic_default_mem_order_kind_enum atomic_order, SgOmpClause::omp_requires_property_kind_enum requires_kind, SgOmpClause::omp_atomic_default_mem_order_kind_enum requires_atomic_order, bool has_requires_expression, bool has_requires_extension); | |
validateOmpContextPropertySelectorKind
void validateOmpContextPropertySelectorKind( SgOmpClause::omp_context_trait_selector_kind_enum selector_kind, bool has_expression, SgOmpClause::omp_when_context_kind_enum kind, SgOmpClause::omp_when_context_vendor_enum vendor, SgOmpClause::omp_atomic_default_mem_order_kind_enum atomic_order, SgOmpClause::omp_requires_property_kind_enum requires_kind); | |
validateOmpContextSelector
void validateOmpContextSelector(SgOmpContextSelector const* selector); | |
validateOmpContextSelectorPayload
void validateOmpContextSelectorPayload( SgOmpClause::omp_context_trait_selector_kind_enum kind, SgName const& implementation_name, SgExpression* score, SgStatement* construct_directive, SgOmpContextSelectorPropertyPtrList const& properties); | |
validateOmpContextSelectorProperty
void validateOmpContextSelectorProperty( SgOmpContextSelectorProperty const* property, SgOmpContextSelector const* selector); | |
validateOmpContextSelectorPropertyPayload
OmpContextPropertyIdentity validateOmpContextSelectorPropertyPayload( SgOmpContextSelectorProperty const* property, SgOmpClause::omp_context_trait_selector_kind_enum selector_kind); | |
validateOmpContextSelectorSet
void validateOmpContextSelectorSet(SgOmpContextSelectorSet const* set); | |
validateOmpContextSelectorSetPayload
void validateOmpContextSelectorSetPayload( SgOmpClause::omp_context_selector_set_kind_enum kind, SgOmpContextSelectorPtrList const& selectors); | |
validateOmpContextSelectorSets
void validateOmpContextSelectorSets( SgOmpContextSelectorSetPtrList const& sets, SgNode const* owner); | |
validateOmpContextSelectorSetsPayload
void validateOmpContextSelectorSetsPayload(SgOmpContextSelectorSetPtrList const& sets); | |
validateOmpContextSelectorShape
void validateOmpContextSelectorShape( SgOmpClause::omp_context_trait_selector_kind_enum kind, SgName const& implementation_name, bool has_score, bool has_construct, size_t property_count); | |
validateOmpContextTraitInSet
void validateOmpContextTraitInSet( SgOmpClause::omp_context_selector_set_kind_enum set_kind, SgOmpClause::omp_context_trait_selector_kind_enum selector_kind); | |
validateParentChains
void validateParentChains(AstFileRecord const& ast); | |
validateReconstructedTypesAndSymbols
void validateReconstructedTypesAndSymbols( AstFileRecord const& ast, NodeMap const& nodes); | |
validateRestoredOmpOwnedClausePayloads
void validateRestoredOmpOwnedClausePayloads( AstFileRecord const& ast, NodeMap const& nodes); | |
validateSourcePositionRecord
SourcePositionFields validateSourcePositionRecord(NodeRecord const& record); | |
validateSymbolTablePreferenceGroups
void validateSymbolTablePreferenceGroups( std::vector<ExpectedSymbolTablePreference> const& entries, std::optional<bool> case_insensitive = std::nullopt); | |
validateSymbolTablePreferences
void validateSymbolTablePreferences(std::vector<ExpectedSymbolTablePreference> const& entries); | |
validateTemplateParameterContract
void validateTemplateParameterContract( SgTemplateParameter const* parameter, std::string const& context); | |
validateTypedefBaseShape
void validateTypedefBaseShape(JsonValue const& properties); | |
validatedExpressionTypeProperty
JsonValue const* validatedExpressionTypeProperty(NodeRecord const& record); | |
varArgFromProperties
SgVarArgOp* varArgFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand); | |
varRefSymbolDeclarationId
uint64_t varRefSymbolDeclarationId( SgVarRefExp* ref, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
variableReferenceFromProperties
SgVarRefExp* variableReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
writeBoolField
void writeBoolField( std::ostream& out, int level, char const* name, bool value, bool comma = true); | |
writeFile
void writeFile( std::filesystem::path const& path, std::string const& content); | |
writeFileIdMapJson
void writeFileIdMapJson( std::ostream& out, int level, bool comma = true); | |
writeFileInfoJson
void writeFileInfoJson( std::ostream& out, int level, Sg_File_Info const* info, bool comma = true); | |
writeIntegerField
void writeIntegerField( std::ostream& out, int level, char const* name, int64_t value, bool comma = true); | |
writeJson
void writeJson( std::ostream& out, SgNode* root, Checkpoint checkpoint, SgSourceFile* file, SgFileList* project_files = nullptr, NodeMap* serialized_nodes = nullptr); | |
writeNodeJson
void writeNodeJson( std::ostream& out, SgNode* node, std::unordered_map<SgNode const*, uint64_t> const& ids, bool comma); | |
writeProjectJson
void writeProjectJson( SgProject* project, std::string const& path, Options const& options); | |
writeRawObject
void writeRawObject( std::ostream& out, int level, std::vector<std::string> const& fields, bool comma = true); | |
writeSemanticSignature
void writeSemanticSignature( std::ostream& out, AstFileRecord const& ast); | |
writeSourceFileJson
void writeSourceFileJson( SgSourceFile* file, Checkpoint checkpoint, std::string const& path, Options const& options); | |
writeStringField
void writeStringField( std::ostream& out, int level, char const* name, std::string const& value, bool comma = true); | |
writeToString
std::string writeToString(std::function<void(std::ostream&)> const& write); | |
operator<<
std::ostream& operator<<( std::ostream& out, JsonKey const& key); | Stream insertion operator |
operator==
bool operator==( JsonKey const& lhs, char const* rhs); | Equality operators |
operator!=
bool operator!=( JsonKey const& lhs, char const* rhs); | Inequality operators |