Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SemaModule_8cpp_source.html below:

clang: lib/Sema/SemaModule.cpp Source File

;

FromInclude =

) {

(

*LSD = dyn_cast<LinkageSpecDecl>(DC)) {

(LSD->getLanguage()) {

LinkageSpecLanguageIDs::C:

ExternCLoc = LSD->getBeginLoc();

LinkageSpecLanguageIDs::CXX:

(isa<LinkageSpecDecl>(DC) || isa<ExportDecl>(DC))

(!isa<TranslationUnitDecl>(DC)) {

? diag::ext_module_import_not_at_top_level_noop

: diag::err_module_import_not_at_top_level_fatal)

S.

(cast<Decl>(DC)->getBeginLoc(),

diag::note_module_import_not_at_top_level)

S.

(ImportLoc, diag::ext_module_import_in_extern_c)

S.

(ExternCLoc, diag::note_extern_c_begins_here);

(

&Piece :

) {

Name += Piece.first->getName();

*&FoundPrimaryModuleInterface) {

(FoundPrimaryModuleInterface)

Imported == FoundPrimaryModuleInterface;

assert(!FoundPrimaryModuleInterface ||

FoundPrimaryModuleInterface == Imported);

FoundPrimaryModuleInterface = Imported;

IsImportingPrimaryModuleInterface =

) {

Worklist.push_back(Imported);

*FoundPrimaryModuleInterface =

IsImportingPrimaryModuleInterface ? Imported :

;

(!Worklist.empty()) {

*Importing = Worklist.pop_back_val();

(VisibleModules.

(Importing))

VisibleModules.

(Importing, ImportLoc);

FoundPrimaryModuleInterface))

(!VisibleModules.

(TransImported))

Worklist.push_back(TransImported);

PushGlobalModuleFragment(ModuleLoc);

TU->setLocalOwningModule(GlobalModule);

Sema::HandleStartOfHeaderUnit() {

);

(HUName.empty()) {

assert(F &&

);

*Mod = Map.createHeaderUnit(StartOfTU, HUName, H);

assert(Mod &&

);

ModuleScopes.push_back({});

ModuleScopes.back().BeginLoc = StartOfTU;

ModuleScopes.back().Module = Mod;

TU->setLocalOwningModule(Mod);

(II->

(

) || II->

(

))

S.

(

, diag::err_invalid_module_name) << II;

S.

(

, diag::warn_reserved_module_name) << II;

llvm_unreachable(

);

);

IsPartition = !Partition.empty();

llvm_unreachable(

);

(ModuleLoc, diag::err_module_interface_implementation_mismatch)

(ModuleLoc, diag::err_module_decl_in_module_map_module);

(ModuleLoc, diag::err_module_decl_in_header_unit);

assert(ModuleScopes.size() <= 1 &&

);

(isCurrentModulePurview()) {

(ModuleLoc, diag::err_module_redeclaration);

diag::note_prev_module_declaration);

SeenGMF == (

)this->TheGlobalModuleFragment) &&

);

(

().CPlusPlusModules && !IsFirstDecl && !SeenGMF) {

(ModuleLoc, diag::err_module_decl_not_at_start);

: ModuleScopes.back().BeginLoc;

(BeginLoc, diag::note_global_module_introducer_missing)

StringRef FirstComponentName =

[0].first->getName();

(FirstComponentName ==

||

(FirstComponentName.starts_with(

) &&

llvm::all_of(FirstComponentName.drop_front(3), &llvm::isDigit))))

(

[0].second, diag::warn_reserved_module_name) <<

[0].first;

(

Part :

) {

(

.front().second, diag::err_current_module_name_mismatch)

? Partition.back().second

:

.back().second)

(

*M = Map.findModule(ModuleName)) {

(

[0].second, diag::err_module_redefinition) << ModuleName;

(M->DefinitionLoc.isValid())

(M->DefinitionLoc, diag::note_prev_module_definition);

(M->DefinitionLoc, diag::note_prev_module_definition_from_ast_file)

Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName);

assert(Mod &&

);

std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc(

(ModuleLoc, diag::err_module_not_defined) << ModuleName;

Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName);

Mod = Map.createModuleForImplementationUnit(ModuleLoc, ModuleName);

Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName);

(!this->TheGlobalModuleFragment) {

ModuleScopes.push_back({});

ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);

ModuleScopes.back().BeginLoc = StartLoc;

ModuleScopes.back().Module = Mod;

TU->setLocalOwningModule(Mod);

Listener->EnteringModulePurview();

: ModuleScopes.back().Module->Kind) {

(PrivateLoc, diag::err_private_module_fragment_not_module);

(PrivateLoc, diag::err_private_module_fragment_redefined);

(ModuleScopes.back().BeginLoc, diag::note_previous_definition);

(PrivateLoc, diag::err_private_module_fragment_not_module_interface);

(ModuleScopes.back().BeginLoc,

diag::note_not_module_interface_add_export)

*PrivateModuleFragment =

Map.createPrivateModuleFragmentForInterfaceUnit(

ModuleScopes.back().Module, PrivateLoc);

assert(PrivateModuleFragment &&

);

ModuleScopes.push_back({});

ModuleScopes.back().BeginLoc = ModuleLoc;

ModuleScopes.back().Module = PrivateModuleFragment;

VisibleModules.

(PrivateModuleFragment, ModuleLoc);

TU->setLocalOwningModule(PrivateModuleFragment);

assert((!IsPartition ||

().CPlusPlusModules) &&

);

std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;

std::string ModuleName;

assert(!ModuleScopes.empty() &&

);

*NamedMod = ModuleScopes.back().Module;

(

().CPlusPlusModules && isCurrentModulePurview() &&

(ImportLoc, diag::err_module_self_import_cxx20)

(ImportLoc, diag::err_module_import_non_interface_nor_parition)

(

*ED = dyn_cast<ExportDecl>(DC))

(ImportLoc, diag::warn_experimental_header_unit);

);

diag::warn_import_implementation_partition_unit_in_interface_unit)

? diag::err_module_self_import

: diag::err_module_import_in_implementation)

(

.empty()) {

(

*ModCheck = Mod; ModCheck; ModCheck = ModCheck->

)

IdentifierLocs.push_back(

[0].second);

(

I = 0, N =

.size(); I != N; ++I) {

ModCheck = ModCheck->

;

IdentifierLocs.push_back(

[I].second);

Mod, IdentifierLocs);

(!ModuleScopes.empty())

(ExportLoc, diag::err_export_partition_impl)

}

(ExportLoc.

()) {

(ExportLoc, diag::err_export_not_in_module_interface);

IsInModuleIncludes =

(

().Modules && !IsInModuleIncludes) {

(!ModuleScopes.empty())

VisibleModules.

(Mod, DirectiveLoc);

().CurrentModule, DirectiveLoc,

,

);

assert(ThisModule &&

);

ModuleScopes.push_back({});

ModuleScopes.back().Module = Mod;

ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);

VisibleModules.

(Mod, DirectiveLoc);

cast<Decl>(DC)->setModuleOwnershipKind(

cast<Decl>(DC)->setLocalOwningModule(Mod);

VisibleModules = std::move(ModuleScopes.back().OuterVisibleModules);

assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&

);

ModuleScopes.pop_back();

);

DirectiveLoc = EomLoc;

cast<Decl>(DC)->setModuleOwnershipKind(

->setRBraceLoc(LBraceLoc);

(!isCurrentModulePurview()) {

(ExportLoc, diag::err_export_not_in_module_interface) << 0;

(ExportLoc, diag::err_export_not_in_module_interface) << 1;

(ModuleScopes.back().BeginLoc,

diag::note_not_module_interface_add_export)

}

(ModuleScopes.back().Module->Kind ==

(ExportLoc, diag::err_export_in_private_module_fragment);

(ModuleScopes.back().BeginLoc, diag::note_private_module_fragment);

(

*ND = dyn_cast<NamespaceDecl>(DC)) {

(ND->isAnonymousNamespace()) {

(ExportLoc, diag::err_export_within_anonymous_namespace);

(ND->getLocation(), diag::note_anonymous_namespace);

(!

().

&& !DeferredExportedNamespaces.insert(ND).second)

(ExportLoc, diag::err_export_within_export);

(ED->getLocation(), diag::note_export);

AllUnnamed =

;

(

*

: DC->

())

(!dyn_cast<FunctionDecl>(

) && !dyn_cast<ExportDecl>(

)) {

HasName =

;

(

*ND = dyn_cast<NamedDecl>(

)) {

HasName = (

)ND->getDeclName();

S.

(ND->getLocation(), diag::err_export_internal) << ND;

S.

(BlockStart, diag::note_export);

(

*USD = dyn_cast<UsingShadowDecl>(

)) {

S.

(USD->getLocation(), diag::err_export_using_internal)

S.

(

->getLocation(), diag::note_using_decl_target);

S.

(BlockStart, diag::note_export);

(

*DC = dyn_cast<DeclContext>(

)) {

(!isa<NamespaceDecl>(

))

(

*ND = dyn_cast<NamedDecl>(

)) {

(!ND->getDeclName()) {

S.

(ND->getLocation(), diag::err_export_anon_ns_internal);

S.

(BlockStart, diag::note_export);

}

(!DC->decls().empty() &&

DC->getRedeclContext()->isFileContext()) {

*ED = cast<ExportDecl>(

);

ED->setRBraceLoc(RBraceLoc);

(

*Child : ED->decls()) {

(

*FD = dyn_cast<FunctionDecl>(Child)) {

(FD->isInlineSpecified() && !FD->isDefined())

PendingInlineFuncDecls.insert(FD);

(

*Exported : ED->decls())

(!TheGlobalModuleFragment) {

assert(TheGlobalModuleFragment &&

);

ModuleScopes.push_back({BeginLoc, TheGlobalModuleFragment,

VisibleModules.

(TheGlobalModuleFragment, BeginLoc);

TheGlobalModuleFragment;

Sema::PopGlobalModuleFragment() {

assert(!ModuleScopes.empty() &&

);

ModuleScopes.pop_back();

(!TheImplicitGlobalModuleFragment) {

TheImplicitGlobalModuleFragment =

assert(TheImplicitGlobalModuleFragment &&

);

ModuleScopes.push_back({BeginLoc, TheImplicitGlobalModuleFragment,

VisibleModules.

(TheImplicitGlobalModuleFragment, BeginLoc);

TheImplicitGlobalModuleFragment;

Sema::PopImplicitGlobalModuleFragment() {

assert(!ModuleScopes.empty() &&

);

ModuleScopes.pop_back();

Sema::isCurrentModulePurview()

{

llvm::MachO::Target Target

Defines the clang::Preprocessor interface.

static void makeTransitiveImportsVisible(ASTContext &Ctx, VisibleModuleSet &VisibleModules, Module *Imported, Module *CurrentModule, SourceLocation ImportLoc, bool IsImportingPrimaryModuleInterface=false)

[module.import]p7: Additionally, when a module-import-declaration in a module unit of some module M i...

static bool DiagReservedModuleName(Sema &S, const IdentifierInfo *II, SourceLocation Loc)

Tests whether the given identifier is reserved as a module name and diagnoses if it is.

static const ExportDecl * getEnclosingExportDecl(const Decl *D)

Determine whether D is lexically within an export-declaration.

static bool checkExportedDecl(Sema &, Decl *, SourceLocation)

Check that it's valid to export D.

static std::string stringFromPath(ModuleIdPath Path)

static void checkModuleImportContext(Sema &S, Module *M, SourceLocation ImportLoc, DeclContext *DC, bool FromInclude=false)

static bool checkExportedDeclContext(Sema &S, DeclContext *DC, SourceLocation BlockStart)

Check that it's valid to export all the declarations in DC.

static bool isImportingModuleUnitFromSameModule(ASTContext &Ctx, Module *Imported, Module *CurrentModule, Module *&FoundPrimaryModuleInterface)

Helper function for makeTransitiveImportsVisible to decide whether the.

virtual void HandleImplicitImportDecl(ImportDecl *D)

Handle an ImportDecl that was implicitly created due to an inclusion directive.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

TranslationUnitDecl * getTranslationUnitDecl() const

void setCurrentNamedModule(Module *M)

Set the (C++20) module we are building.

void addModuleInitializer(Module *M, Decl *Init)

Add a declaration to the list of declarations that are initialized for a module.

bool isInSameModule(const Module *M1, const Module *M2)

If the two module M1 and M2 are in the same module.

The result of parsing/analyzing an expression, statement etc.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

DeclContext * getParent()

getParent - Returns the containing DeclContext.

DeclContext * getLexicalParent()

getLexicalParent - Returns the containing lexical DeclContext.

void addDecl(Decl *D)

Add the declaration D into this context.

decl_range decls() const

decls_begin/decls_end - Iterate over the declarations stored in this context.

Decl - This represents one declaration (or definition), e.g.

void setInvalidDecl(bool Invalid=true)

setInvalidDecl - Indicates the Decl had a semantic error.

bool isInvalidDecl() const

SourceLocation getBeginLoc() const LLVM_READONLY

DeclContext * getLexicalDeclContext()

getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).

@ VisibleWhenImported

This declaration has an owning module, and is visible when that module is imported.

@ Unowned

This declaration is not owned by a module.

@ ReachableWhenImported

This declaration has an owning module, and is visible to lookups that occurs within that module.

@ ModulePrivate

This declaration has an owning module, but is only visible to lookups that occur within that module.

@ Visible

This declaration has an owning module, but is globally visible (typically because its owning module i...

void setModuleOwnershipKind(ModuleOwnershipKind MOK)

Set whether this declaration is hidden from name lookup.

Represents a standard C++ module export declaration.

static ExportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExportLoc)

StringRef getName() const

The name of this FileEntry.

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)

Get a FileEntryRef if it exists, without doing anything on error.

static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)

Create a code modification hint that inserts the given code string at a specific location.

One of these records is kept for each identifier that is lexed.

ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const

Determine whether this is a name reserved for the implementation (C99 7.1.3, C++ [lib....

bool isStr(const char(&Str)[StrLen]) const

Return true if this is the identifier for the specified string.

Describes a module import declaration, which makes the contents of the named module visible in the cu...

static ImportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, ArrayRef< SourceLocation > IdentifierLocs)

Create a new module import declaration.

static ImportDecl * CreateImplicit(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, SourceLocation EndLoc)

Create a new module import declaration for an implicitly-generated import.

@ CMK_None

Not compiling a module interface at all.

@ CMK_HeaderUnit

Compiling a module header unit.

@ CMK_ModuleMap

Compiling a module from a module map.

@ CMK_ModuleInterface

Compiling a C++ modules interface unit.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

std::string CurrentModule

The name of the current module, of which the main source file is a part.

virtual ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective)=0

Attempt to load the given module.

virtual void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc)=0

Make the given module visible.

Module * createGlobalModuleFragmentForModuleUnit(SourceLocation Loc, Module *Parent=nullptr)

Create a global module fragment for a C++ module unit.

Module * createImplicitGlobalModuleFragmentForModuleUnit(SourceLocation Loc, Module *Parent)

Describes a module or submodule.

SmallVector< ExportDecl, 2 > Exports

The set of export declarations.

bool isForBuilding(const LangOptions &LangOpts) const

Determine whether this module can be built in this compilation.

bool isInterfaceOrPartition() const

bool isModulePartitionImplementation() const

Is this a module partition implementation unit.

@ AllVisible

All of the names in this module are visible.

Module * Parent

The parent of this module.

ModuleKind Kind

The kind of this module.

llvm::SmallSetVector< Module *, 2 > Imports

The set of modules imported by this module, and on which this module depends.

std::string Name

The name of this module.

unsigned IsExternC

Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "C"...

StringRef getPrimaryModuleInterfaceName() const

Get the primary module interface name from a partition.

bool isModulePartition() const

Is this a module partition.

bool isHeaderUnit() const

Is this module a header unit.

@ ModuleImplementationUnit

This is a C++20 module implementation unit.

@ ModuleMapModule

This is a module that was defined by a module map and built out of header files.

@ ImplicitGlobalModuleFragment

This is an implicit fragment of the global module which contains only language linkage declarations (...

@ ModulePartitionInterface

This is a C++20 module partition interface.

@ ModuleInterfaceUnit

This is a C++20 module interface unit.

@ ModuleHeaderUnit

This is a C++20 header unit.

@ ModulePartitionImplementation

This is a C++20 module partition implementation.

@ PrivateModuleFragment

This is the private module fragment within some C++ module.

@ ExplicitGlobalModuleFragment

This is the explicit Global Module Fragment of a modular TU.

std::string getFullModuleName(bool AllowStringLiterals=false) const

Retrieve the full name of this module, including the path from its top-level module.

bool isNamedModule() const

Does this Module is a named module of a standard named module?

This represents a decl that may have a name.

NamedDecl * getUnderlyingDecl()

Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.

Linkage getFormalLinkage() const

Get the linkage from a semantic point of view.

Wrapper for void* pointer.

IdentifierInfo * getIdentifierInfo(StringRef Name) const

Return information about the specified preprocessor identifier token.

HeaderSearch & getHeaderSearchInfo() const

Scope - A scope is a transient data structure that is used while parsing the program.

SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)

Emit a diagnostic.

Sema - This implements semantic analysis and AST building for C.

void ActOnAnnotModuleBegin(SourceLocation DirectiveLoc, Module *Mod)

The parsed has entered a submodule.

void ActOnAnnotModuleInclude(SourceLocation DirectiveLoc, Module *Mod)

The parser has processed a module import translated from a #include or similar preprocessing directiv...

const TranslationUnitKind TUKind

The kind of translation unit we are processing.

@ PartitionImplementation

'module X:Y;'

@ Interface

'export module X;'

@ Implementation

'module X;'

@ PartitionInterface

'export module X:Y;'

DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc, ModuleDeclKind MDK, ModuleIdPath Path, ModuleIdPath Partition, ModuleImportState &ImportState)

The parser has processed a module-declaration that begins the definition of a module interface or imp...

llvm::DenseMap< NamedDecl *, NamedDecl * > VisibleNamespaceCache

Map from the most recent declaration of a namespace to the most recent visible declaration of that na...

void ActOnAnnotModuleEnd(SourceLocation DirectiveLoc, Module *Mod)

The parser has left a submodule.

bool currentModuleIsImplementation() const

Is the module scope we are an implementation unit?

DeclResult ActOnModuleImport(SourceLocation StartLoc, SourceLocation ExportLoc, SourceLocation ImportLoc, ModuleIdPath Path, bool IsPartition=false)

The parser has processed a module import declaration.

DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)

ASTContext & getASTContext() const

Decl * ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc, SourceLocation LBraceLoc)

We have parsed the start of an export declaration, including the '{' (if present).

const LangOptions & getLangOpts() const

void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind)

DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc)

The parser has processed a global-module-fragment declaration that begins the definition of the globa...

std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const

Determines whether we are currently in a context where template argument substitution failures are no...

Module * getCurrentModule() const

Get the module unit whose scope we are currently within.

DeclContext * CurContext

CurContext - This is the current declaration context of parsing.

DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc, SourceLocation PrivateLoc)

The parser has processed a private-module-fragment declaration that begins the definition of the priv...

SourceManager & getSourceManager() const

void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod)

bool isModuleVisible(const Module *M, bool ModulePrivate=false)

@ Global

The global module fragment, between 'module;' and a module-declaration.

@ Normal

A normal translation unit fragment.

ModuleImportState

An enumeration to represent the transition of states in parsing module fragments and imports.

@ FirstDecl

Parsing the first decl in a TU.

@ GlobalFragment

after 'module;' but before 'module X;'

@ NotACXX20Module

Not a C++20 TU, or an invalid state was found.

@ ImportAllowed

after 'module X;' but before any non-import decl.

ModuleLoader & getModuleLoader() const

Retrieve the module loader associated with the preprocessor.

void PushDeclContext(Scope *S, DeclContext *DC)

Set the current declaration context until it gets popped.

SourceManager & SourceMgr

Decl * ActOnFinishExportDecl(Scope *S, Decl *ExportDecl, SourceLocation RBraceLoc)

Complete the definition of an export declaration.

ASTMutationListener * getASTMutationListener() const

void createImplicitModuleImportForErrorRecovery(SourceLocation Loc, Module *Mod)

Create an implicit import of the given module at the given source location, for error recovery,...

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

FileID getFileID(SourceLocation SpellingLoc) const

Return the FileID for a SourceLocation.

OptionalFileEntryRef getFileEntryRefForID(FileID FID) const

Returns the FileEntryRef for the provided FileID.

FileManager & getFileManager() const

FileID getMainFileID() const

Returns the FileID of the main source file.

SourceLocation getIncludeLoc(FileID FID) const

Returns the include location if FID is a #include'd file otherwise it returns an invalid location.

bool isInSystemHeader(SourceLocation Loc) const

Returns if a SourceLocation is in a system header.

SourceLocation getLocForStartOfFile(FileID FID) const

Return the source location corresponding to the first byte of the specified file.

bool isWrittenInMainFile(SourceLocation Loc) const

Returns true if the spelling location for the given location is in the main file buffer.

A trivial tuple used to represent a source range.

The top declaration context.

A set of visible modules.

SourceLocation getImportLoc(const Module *M) const

Get the location at which the import of a module was triggered.

bool isVisible(const Module *M) const

Determine whether a module is visible.

void setVisible(Module *M, SourceLocation Loc, VisibleCallback Vis=[](Module *) {}, ConflictCallback Cb=[](ArrayRef< Module * >, Module *, StringRef) {})

Make a specific module visible.

The JSON file list parser is used to communicate input to InstallAPI.

ArrayRef< std::pair< IdentifierInfo *, SourceLocation > > ModuleIdPath

A sequence of identifier/location pairs used to describe a particular module or submodule,...

Linkage

Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.

@ Internal

Internal linkage, which indicates that the entity can be referred to from within the translation unit...

@ Module

Module linkage, which indicates that the entity can be referred to from other translation units withi...

@ TU_ClangModule

The translation unit is a clang module.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4