Skip to content

Rose::AstJson

Types

Name
AggregateConstructionFields
ArrayInitBindingScope
ArrayInitReferenceFields
AsmOperandConstructionFields
AsmStatementConstructionFields
AssignmentInitializerSourceFields
AstFileRecord
CastConstructionFields
CollectionBoundaryGuard
DeclarationFields
DeclarationNameQualificationFields
DeclarationSourceFields
DeserializationProjectGuard
EdgeRecord
ExpectedSymbolTablePreference
ExpressionConstructionFields
ExpressionQualificationFields
ExpressionSourceFields
ExternalClassDeserializationIdentityGuard
ExternalDeclarationFields
ExternalFunctionDeserializationIdentityGuard
ExternalInitializedNameFields
FileInfoFields
FoldConstructionFields
FormatItemFields
FortranInterfaceFields
FullTypeDeserializationIdentityGuard
FullTypeSerializationIdentityGuard
FunctionCallSourceFields
FunctionModifierFields
FunctionReturnTypeSourceFields
FunctionTypeDeserializationIdentityGuard
InitializedNameMetadata
InitializedNameRoles
InlineExpressionConstruction
JsonKey
JsonMember
JsonObject
JsonValue
LabelSymbolFields
LiteralTokenFields
NewConstructionFields
NodeConstructionFlags
NodeRecord
OmpClauseFields
OmpContextPropertyFields
OmpContextSelectorFields
OpaqueBindingScope
OpaqueValueFields
Options
PointerMemberTypeDeserializationIdentityGuard
PointerMemberTypeSerializationIdentityGuard
PreprocessingInfoFields
RecordNodeConstruction
RecordNodeConstructionScope
ReturnStatementFields
SemanticArrayConstruction
SemanticArrayConstructionScope
SerializedSymbolTableConstruction
SerializedSymbolTableEntry
SourceDeclaratorScopeConstruction
SourcePositionFields
SourcePositions
SourceTypeConstruction
SourceTypeConstructionScope
StatementFields
SubtreeBoundaryGuard
SymbolTableEntryJson
TemplateParameterOperands
TemplateParameterSourceFields
TemplateTypeDeserializationIdentityGuard
TypeModifierFields
TypeSerializationContext
TypedefMetadata
UnaryConstructionFields
UnaryTraitSourceFields
VisibilitySymbolFields

Type Aliases

Name
FloatingValueBits
NodeIds
NodeMap
OmpContextPropertyIdentity
OmpContextSelectorIdentity
PreparedAstAttributes
PreparedPreprocessingInfo
SerializedSymbolTableRecords
SymbolConstructionAdvance
SymbolTablePreferenceGroups

Enums

Name
Checkpoint
ExternalFunctionParameterScopeOwner
LabelSymbolBasisKind
OperandRequirementKind

Functions

Name Description
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

Variables

Name
collectionBoundaryFile
collectionBoundaryRoot
currentDeserializationClassDeclarationCache
currentDeserializationProject
currentTypeSerializationNode
kFormat
kSchemaVersion
serializingTypeOwnedExpression

Created with MrDocs