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

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

clang: lib/Lex/PPExpressions.cpp Source File

;

PPValue(

BitWidth) : Val(BitWidth) {}

getBitWidth()

{

Val.getBitWidth(); }

()

{

Val.isUnsigned(); }

&PeekTok,

ValueLive,

&IncludedUndefinedIds,

Result.setBegin(beginLoc);

(PeekTok.

(tok::l_paren)) {

(PeekTok.

(tok::code_completion)) {

Result.Val = !!Macro;

Result.Val.setIsUnsigned(

);

(II->

() ==

|| II->

() ==

) ?

:

);

(Result.Val != 0 && ValueLive)

macroToken(PeekTok);

(PeekTok.

(tok::r_paren)) {

<<

<< tok::r_paren;

PP.

(LParenLoc, diag::note_matching) << tok::l_paren;

IsFunctionTypeMacro =

(IsFunctionTypeMacro)

PP.

(beginLoc, diag::warn_defined_in_function_type_macro);

PP.

(beginLoc, diag::warn_defined_in_object_type_macro);

Callbacks->Defined(macroToken, Macro,

Result.setIdentifier(

);

(PeekTok.

(tok::code_completion)) {

(II->

(

))

PP.

(PeekTok, diag::warn_pp_undef_identifier) << II;

(DiagEngine.

(diag::warn_pp_undef_identifier,

std::vector<std::string> UndefPrefixes =

StringRef IdentifierName = II->

();

(llvm::any_of(UndefPrefixes,

[&IdentifierName](

std::string &Prefix) {

IdentifierName.starts_with(Prefix);

PP.

(PeekTok, diag::warn_pp_undef_prefix)

<<

{llvm::join(UndefPrefixes,

)} << II;

Result.Val.setIsUnsigned(

);

Result.setIdentifier(II);

PP.

(PeekTok, diag::err_pp_expr_bad_token_start_expr);

PP.

(PeekTok, diag::err_pp_expected_value_in_expr);

tok::numeric_constant: {

NumberInvalid =

;

StringRef Spelling = PP.

(PeekTok, IntegerBuffer,

(Literal.hadError)

(Literal.isFloatingLiteral() || Literal.isImaginary) {

PP.

(PeekTok, diag::err_pp_illegal_floating_literal);

assert(Literal.isIntegerLiteral() &&

);

(Literal.hasUDSuffix())

PP.

(PeekTok, diag::err_pp_invalid_udl) <<

1;

(!PP.

().C99 && Literal.isLongLong) {

diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);

PP.

(PeekTok, diag::ext_c99_longlong);

? diag::warn_cxx20_compat_size_t_suffix

: diag::ext_cxx23_size_t_suffix

: diag::err_cxx23_size_t_suffix);

(Literal.isBitInt)

PP.

(PeekTok, PP.

().CPlusPlus ? diag::ext_cxx_bitint_suffix

? diag::warn_c23_compat_bitint_suffix

: diag::ext_c23_bitint_suffix);

(Literal.GetIntegerValue(Result.Val)) {

PP.

(PeekTok, diag::err_integer_literal_too_large)

Result.Val.setIsUnsigned(

);

Result.Val.setIsUnsigned(Literal.isUnsigned);

(!Literal.isUnsigned && Result.Val.isNegative()) {

(ValueLive && Literal.getRadix() == 10)

PP.

(PeekTok, diag::ext_integer_literal_too_large_for_signed);

Result.Val.setIsUnsigned(

);

tok::char_constant:

tok::wide_char_constant:

tok::utf8_char_constant:

tok::utf16_char_constant:

tok::utf32_char_constant: {

PP.

(PeekTok, diag::err_pp_invalid_udl) <<

0;

CharInvalid =

;

StringRef ThisTok = PP.

(PeekTok, CharBuffer, &CharInvalid);

(Literal.hadError())

(Literal.isMultiChar())

(Literal.isWide())

(Literal.isUTF16())

(Literal.isUTF32())

llvm::APSInt Val(NumBits);

Val = Literal.getValue();

(Literal.isWide())

(Literal.isUTF16() || Literal.isUTF32())

Val.setIsUnsigned(

);

(Literal.isUTF8()) {

Val.setIsUnsigned(

);

Val.setIsUnsigned(!PP.

().CharIsSigned);

(Result.Val.getBitWidth() > Val.getBitWidth()) {

Result.Val = Val.extend(Result.Val.getBitWidth());

assert(Result.Val.getBitWidth() == Val.getBitWidth() &&

);

(

(Result, PeekTok, DT, ValueLive, PP))

;

(PeekTok.

(tok::r_paren)) {

(PeekTok.

(tok::r_paren)) {

<< Result.getRange();

PP.

(Start, diag::note_matching) << tok::l_paren;

Result.setIdentifier(

);

(

(Result, PeekTok, DT, ValueLive, PP))

;

Result.setBegin(Start);

Result.setIdentifier(

);

(

(Result, PeekTok, DT, ValueLive, PP))

;

Result.setBegin(

);

Result.setIdentifier(

);

Result.Val = -Result.Val;

Overflow = !Result.isUnsigned() && Result.Val.isMinSignedValue();

(Overflow && ValueLive)

PP.

(

, diag::warn_pp_expr_overflow) << Result.getRange();

(

(Result, PeekTok, DT, ValueLive, PP))

;

Result.setBegin(Start);

Result.setIdentifier(

);

Result.Val = ~Result.Val;

(

(Result, PeekTok, DT, ValueLive, PP))

;

Result.setBegin(Start);

Result.Val = !Result.Val;

Result.Val.setIsUnsigned(

);

Result.setIdentifier(

);

Result.Val = PeekTok.

() == tok::kw_true;

Result.Val.setIsUnsigned(

);

:

~0

;

tok::star:

14;

tok::minus:

13;

tok::greatergreater:

12;

tok::greaterequal:

tok::greater:

11;

tok::exclaimequal:

tok::equalequal:

10;

tok::amp:

9;

tok::caret:

8;

tok::pipe:

7;

tok::ampamp:

6;

tok::pipepipe:

5;

tok::question:

4;

tok::comma:

3;

tok::colon:

2;

tok::r_paren:

0;

tok::eod:

0;

(Tok.

(tok::l_paren) && LHS.getIdentifier())

PP.

(LHS.getRange().getBegin(), diag::err_pp_expr_bad_token_lparen)

<< LHS.getIdentifier();

&PeekTok,

ValueLive,

&IncludedUndefinedIds,

(PeekPrec == ~0

) {

(PeekPrec < MinPrec)

(Operator == tok::ampamp && LHS.Val == 0)

(Operator == tok::pipepipe && LHS.Val != 0)

(Operator == tok::question && LHS.Val == 0)

RHSIsLive = ValueLive;

PPValue RHS(LHS.getBitWidth());

(

(RHS, PeekTok, DT, RHSIsLive, PP))

;

ThisPrec = PeekPrec;

(PeekPrec == ~0

) {

(Operator == tok::question)

RHSPrec = ThisPrec+1;

(PeekPrec >= RHSPrec) {

IncludedUndefinedIds, PP))

assert(PeekPrec <= ThisPrec &&

);

llvm::APSInt Res(LHS.getBitWidth());

tok::greatergreater:

Res.setIsUnsigned(LHS.isUnsigned() || RHS.isUnsigned());

(ValueLive && Res.isUnsigned()) {

(!LHS.isUnsigned() && LHS.Val.isNegative())

PP.

(OpLoc, diag::warn_pp_convert_to_positive) << 0

<<

(LHS.Val, 10,

) +

+

<< LHS.getRange() << RHS.getRange();

(!RHS.isUnsigned() && RHS.Val.isNegative())

PP.

(OpLoc, diag::warn_pp_convert_to_positive) << 1

<<

(RHS.Val, 10,

) +

+

<< LHS.getRange() << RHS.getRange();

LHS.Val.setIsUnsigned(Res.isUnsigned());

RHS.Val.setIsUnsigned(Res.isUnsigned());

Overflow =

;

: llvm_unreachable(

);

Res = LHS.Val % RHS.Val;

(ValueLive) {

PP.

(OpLoc, diag::err_pp_remainder_by_zero)

<< LHS.getRange() << RHS.getRange();

(LHS.Val.isSigned())

Res = llvm::APSInt(LHS.Val.sdiv_ov(RHS.Val, Overflow),

);

Res = LHS.Val / RHS.Val;

}

(ValueLive) {

PP.

(OpLoc, diag::err_pp_division_by_zero)

<< LHS.getRange() << RHS.getRange();

Res = llvm::APSInt(LHS.Val.smul_ov(RHS.Val, Overflow),

);

Res = LHS.Val * RHS.Val;

tok::lessless: {

(LHS.isUnsigned())

Res = LHS.Val.ushl_ov(RHS.Val, Overflow);

Res = llvm::APSInt(LHS.Val.sshl_ov(RHS.Val, Overflow),

);

tok::greatergreater: {

ShAmt =

(RHS.Val.getLimitedValue());

(ShAmt >= LHS.getBitWidth()) {

ShAmt = LHS.getBitWidth()-1;

Res = LHS.Val >> ShAmt;

(LHS.isUnsigned())

Res = LHS.Val + RHS.Val;

Res = llvm::APSInt(LHS.Val.sadd_ov(RHS.Val, Overflow),

);

(LHS.isUnsigned())

Res = LHS.Val - RHS.Val;

Res = llvm::APSInt(LHS.Val.ssub_ov(RHS.Val, Overflow),

);

Res = LHS.Val <= RHS.Val;

Res.setIsUnsigned(

);

Res = LHS.Val < RHS.Val;

Res.setIsUnsigned(

);

tok::greaterequal:

Res = LHS.Val >= RHS.Val;

Res.setIsUnsigned(

);

Res = LHS.Val > RHS.Val;

Res.setIsUnsigned(

);

tok::exclaimequal:

Res = LHS.Val != RHS.Val;

Res.setIsUnsigned(

);

tok::equalequal:

Res = LHS.Val == RHS.Val;

Res.setIsUnsigned(

);

Res = LHS.Val & RHS.Val;

Res = LHS.Val ^ RHS.Val;

Res = LHS.Val | RHS.Val;

Res = (LHS.Val != 0 && RHS.Val != 0);

Res.setIsUnsigned(

);

Res = (LHS.Val != 0 || RHS.Val != 0);

Res.setIsUnsigned(

);

PP.

(OpLoc, diag::ext_pp_comma_expr)

<< LHS.getRange() << RHS.getRange();

tok::question: {

(PeekTok.

(tok::colon)) {

<< tok::colon << LHS.getRange() << RHS.getRange();

PP.

(OpLoc, diag::note_matching) << tok::question;

AfterColonLive = ValueLive && LHS.Val == 0;

PPValue AfterColonVal(LHS.getBitWidth());

(

(AfterColonVal, PeekTok, DT, AfterColonLive, PP))

PeekTok, AfterColonLive,

IncludedUndefinedIds, PP))

Res = LHS.Val != 0 ? RHS.Val : AfterColonVal.Val;

RHS.setEnd(AfterColonVal.getRange().getEnd());

Res.setIsUnsigned(RHS.isUnsigned() || AfterColonVal.isUnsigned());

PP.

(OpLoc, diag::err_pp_colon_without_question)

<< LHS.getRange() << RHS.getRange();

(Overflow && ValueLive)

PP.

(OpLoc, diag::warn_pp_expr_overflow)

<< LHS.getRange() << RHS.getRange();

LHS.setEnd(RHS.getRange().getEnd());

RHS.setIdentifier(

);

Preprocessor::DirectiveEvalResult

Preprocessor::EvaluateDirectiveExpression(

*&IfNDefMacro,

&Tok,

&EvaluatedDefined,

DisableMacroExpansionAtStartOfDirective = DisableMacroExpansion;

DisableMacroExpansion =

;

PPValue ResVal(BitWidth);

(Tok.

(tok::eod))

DisableMacroExpansion = DisableMacroExpansionAtStartOfDirective;

{std::nullopt,

{ExprStartLoc, ConditionRange.

()}};

(Tok.

(tok::eod)) {

DisableMacroExpansion = DisableMacroExpansionAtStartOfDirective;

IsNonZero = ResVal.Val != 0;

(Tok.

(tok::eod))

DisableMacroExpansion = DisableMacroExpansionAtStartOfDirective;

(Tok.

(tok::eod)) {

(Tok, diag::err_pp_expected_eol);

DisableMacroExpansion = DisableMacroExpansionAtStartOfDirective;

IsNonZero = ResVal.Val != 0;

Preprocessor::DirectiveEvalResult

Preprocessor::EvaluateDirectiveExpression(

*&IfNDefMacro,

EvaluatedDefined;

EvaluateDirectiveExpression(IfNDefMacro, Tok, EvaluatedDefined,

static bool isUnsigned(SValBuilder &SVB, NonLoc Value)

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

Defines the clang::MacroInfo and clang::MacroDirective classes.

Defines the PPCallbacks interface.

static bool EvaluateValue(PPValue &Result, Token &PeekTok, DefinedTracker &DT, bool ValueLive, Preprocessor &PP)

EvaluateValue - Evaluate the token PeekTok (and any others needed) and return the computed value in R...

static void diagnoseUnexpectedOperator(Preprocessor &PP, PPValue &LHS, Token &Tok)

static bool EvaluateDirectiveSubExpr(PPValue &LHS, unsigned MinPrec, Token &PeekTok, bool ValueLive, bool &IncludedUndefinedIds, Preprocessor &PP)

EvaluateDirectiveSubExpr - Evaluate the subexpression whose first token is PeekTok,...

static unsigned getPrecedence(tok::TokenKind Kind)

getPrecedence - Return the precedence of the specified binary operator token.

static bool EvaluateDefined(PPValue &Result, Token &PeekTok, DefinedTracker &DT, bool ValueLive, Preprocessor &PP)

EvaluateDefined - Process a 'defined(sym)' expression.

static StringRef getIdentifier(const Token &Tok)

Defines the clang::Preprocessor interface.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

static CharSourceRange getRange(const CharSourceRange &EditRange, const SourceManager &SM, const LangOptions &LangOpts, bool IncludeMacroExpansion)

Defines the clang::SourceLocation class and associated facilities.

Defines the SourceManager interface.

Defines the clang::TokenKind enum and support functions.

CharLiteralParser - Perform interpretation and semantic analysis of a character literal.

virtual void CodeCompleteMacroName(bool IsDefinition)

Callback invoked when performing code completion in a context where the name of a macro is expected.

virtual void CodeCompletePreprocessorExpression()

Callback invoked when performing code completion in a preprocessor expression, such as the condition ...

std::vector< std::string > UndefPrefixes

The list of prefixes from -Wundef-prefix=... used to generate warnings for undefined macros.

Concrete class used by the front-end to report problems and issues.

DiagnosticOptions & getDiagnosticOptions() const

Retrieve the diagnostic options.

bool isIgnored(unsigned DiagID, SourceLocation Loc) const

Determine whether the diagnostic is known to be ignored.

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

bool isCPlusPlusOperatorKeyword() const

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

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

StringRef getName() const

Return the actual identifier string.

A description of the current definition of a macro.

NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber,...

This interface provides a way to observe the actions of the preprocessor as it does its thing.

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

PPCallbacks * getPPCallbacks() const

void markMacroAsUsed(MacroInfo *MI)

A macro is used, update information about macros that need unused warnings.

void setCodeCompletionReached()

Note that we hit the code-completion point.

void LexNonComment(Token &Result)

Lex a token.

SourceRange DiscardUntilEndOfDirective()

Read and discard all tokens remaining on the current line until the tok::eod token is found.

SourceManager & getSourceManager() const

MacroDefinition getMacroDefinition(const IdentifierInfo *II)

bool CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef, bool *ShadowFlag=nullptr)

const TargetInfo & getTargetInfo() const

void LexUnexpandedNonComment(Token &Result)

Like LexNonComment, but this disables macro expansion of identifier tokens.

StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const

Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...

void emitMacroExpansionWarnings(const Token &Identifier, bool IsIfnDef=false) const

CodeCompletionHandler * getCodeCompletionHandler() const

Retrieve the current code-completion handler.

const LangOptions & getLangOpts() const

DiagnosticsEngine & getDiagnostics() const

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const

Forwarding function for diagnostics.

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.

SourceLocation getExpansionLoc(SourceLocation Loc) const

Given a SourceLocation object Loc, return the expansion location referenced by the ID.

const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const

A trivial tuple used to represent a source range.

void setBegin(SourceLocation b)

SourceLocation getEnd() const

void setEnd(SourceLocation e)

bool isFunctionMacroExpansion() const

const ExpansionInfo & getExpansion() const

Exposes information about the current target.

unsigned getChar32Width() const

getChar32Width/Align - Return the size of 'char32_t' for this target, in bits.

static bool isTypeSigned(IntType T)

Returns true if the type is signed; false otherwise.

unsigned getChar16Width() const

getChar16Width/Align - Return the size of 'char16_t' for this target, in bits.

unsigned getIntWidth() const

getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...

IntType getWCharType() const

unsigned getWCharWidth() const

getWCharWidth/Align - Return the size of 'wchar_t' for this target, in bits.

unsigned getIntMaxTWidth() const

Return the size of intmax_t and uintmax_t for this target, in bits.

unsigned getCharWidth() const

Token - This structure provides full information about a lexed token.

IdentifierInfo * getIdentifierInfo() const

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

bool is(tok::TokenKind K) const

is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....

tok::TokenKind getKind() const

bool isNot(tok::TokenKind K) const

bool hasUDSuffix() const

Return true if this token is a string or character literal which has a ud-suffix.

Defines the clang::TargetInfo interface.

TokenKind

Provides a simple uniform namespace for tokens from all C languages.

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

DefinedTracker - This struct is used while parsing expressions to keep track of whether !...

TrackerState

Each time a Value is evaluated, it returns information about whether the parsed value is of the form ...

bool IncludedUndefinedIds

IdentifierInfo * TheMacro

TheMacro - When the state is DefinedMacro or NotDefinedMacro, this indicates the macro that was check...

enum DefinedTracker::TrackerState State

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