dmd.parse

class Parser(AST, Lexer = dmd.lexer.Lexer): Lexer;

bool transitionIn;

-transition=in is active, in parameters are listed

scope this(const ref Loc loc, AST.Module _module, const(char)[] input, bool doDocComment, ErrorSink errorSink, const CompileEnv* compileEnv, const bool doUnittests);

Use this constructor for string mixins.

Input loc = location in source file of mixin

scope this(AST.Module _module, const(char)[] input, bool doDocComment, ErrorSink errorSink, const CompileEnv* compileEnv, const bool doUnittests);

Main Parser constructor.

AST.Dsymbols* parseModule();

Parse a module, i.e. the optional module x.y.z declaration and all declarations found in the current file.

Returns:

the list of declarations or an empty list in case of malformed declarations, the module declaration will be stored as this.md if found

final bool parseModuleDeclaration();

Parse the optional module declaration

Returns:

false if a malformed module declaration was found

final AST.Dsymbols* parseModuleContent();

Parse the content of a module, i.e. all declarations found until the end of file.

Returns:

the list of declarations or an empty list in case of malformed declarations

AST.Dsymbols* parseDeclDefs(int once, AST.Dsymbol* pLastDecl = null, PrefixAttributes!AST* pAttrs = null);

Parse declarations and definitions

Parameters:

int once	!=0 means parse exactly one decl or def
AST.Dsymbol* pLastDecl	set to last decl or def parsed
PrefixAttributes!AST* pAttrs	keep track of attributes

Returns:

array of declared symbols

RootObject parseTypeOrAssignExp(TOK endtoken = TOK.reserved);

Parse a Type or an Expression

Returns:

RootObject representing the AST

AST.Parameter parseAssignCondition();

Parse an assignment condition for if or while statements.

Returns:

The variable that is declared inside the condition

AST.Statement parseStatement(int flags, const(char)** endPtr = null, Loc* pEndloc = null);

Input flags PSxxxx

Output pEndloc if { ... statements ... }, store location of closing brace, otherwise loc of last token of statement

AST.Statement parseAsm(bool endOfLine);

Parse inline assembler block. Enters with token on the asm. https://dlang.org/spec/iasm.html

AsmStatement asm FunctionAttributes(opt) { AsmInstructionListopt }

AsmInstructionList AsmInstruction ; AsmInstruction ; AsmInstruction

Parameters:

bool endOfLine

true if EOL means end of asm statement

Returns:

inline assembler block as a Statement

void check(Loc loc, TOK value);

Issue error if the current token is not value, advance to next token.

Parameters:

Loc loc	location for error message
TOK value	token value to compare with

void check(TOK value);

Issue error if the current token is not value, advance to next token.

Parameters:

TOK value

token value to compare with

void check(TOK value, const(char)* string);

Issue error if the current token is not value, advance to next token.

Parameters:

TOK value	token value to compare with
const(char)* string	for error message

enum NeedDeclaratorId;

bool skipParens(Token* t, Token** pt);

Skip parentheses.

Parameters:

Token* t	on opening (
Token** pt	*pt is set to token past ')' on true

Returns:

true successful false some parsing error

AST.Expression parsePrimaryExp();

Expression Parser

static StorageClass isBuiltinAtAttribute(Identifier ident);

Recognize builtin @ attributes

Parameters:

Identifier ident

identifier

Returns:

storage class for attribute, 0 if not

immutable PREC[EXP.max + 1] precedence;

Set operator precedence for each operator.

Used by hdrgen

struct ParsedLinkage(AST);

The result of the ParseLinkage function

LINK link;

What linkage was specified

CPPMANGLE cppmangle;

If extern(C++, class|struct), contains the class|struct

AST.Identifiers* idents;

If extern(C++, some.identifier), will be the identifiers

AST.Expressions* identExps;

If `extern(C++, (some_tuple_expression)|"string"), will be the expressions