From d274608d70cddfa40d8c201393708fc6df35af32 Mon Sep 17 00:00:00 2001 From: Hackerpilot Date: Mon, 3 Feb 2014 01:03:51 -0800 Subject: [PATCH] Updated ddoc --- stdx/d/parser.d | 9 + stdx/d/parser.html | 2201 ++++++++++++++++++++++++++++++++++++++++++++ stdx/d/parser.o | Bin 0 -> 497324 bytes 3 files changed, 2210 insertions(+) create mode 100644 stdx/d/parser.html create mode 100644 stdx/d/parser.o diff --git a/stdx/d/parser.d b/stdx/d/parser.d index 3b1830e..05e8354 100644 --- a/stdx/d/parser.d +++ b/stdx/d/parser.d @@ -1,5 +1,13 @@ // Written in the D programming language +/** + * MACROS: + * GRAMMAR = 
$0
+ * RULEDEF = $(B $(DDOC_ANCHOR $0) $0) + * RULE = $(LINK2 #$0, $0) + * LITERAL = $(D_STRING $(I $0)) + */ + module stdx.d.parser; import stdx.d.lexer; @@ -17,6 +25,7 @@ import std.string : format; /** * Params: * tokens = the tokens parsed by std.d.lexer + * fileName = the name of the file being parsed * messageFunction = a function to call on error or warning messages. * The parameters are the file name, line number, column number, * the error or warning message, and a boolean (true means error, false diff --git a/stdx/d/parser.html b/stdx/d/parser.html new file mode 100644 index 0000000..8ba7bbb --- /dev/null +++ b/stdx/d/parser.html @@ -0,0 +1,2201 @@ + + + stdx.d.parser + +

stdx.d.parser

+ + +
Module parseModule(const(Token)[] tokens, string fileName, void function(string, size_t, size_t, string, bool) messageFunction = null); +
+
Params:
+ + + + + + +
const(Token)[] tokensthe tokens parsed by std.d.lexer
string fileNamethe name of the file being parsed
void function(string, size_t, size_t, string, bool) messageFunctiona function to call on error or warning messages. + The parameters are the file name, line number, column number, + the error or warning message, and a boolean (true means error, false + means warning).

+Returns:
+the parsed module

+ +
+
class Parser; +
+
Parser structure

+ +
ExpressionNode parseAddExpression(); +
+
Parses an AddExpression. +

+
 addExpression:
+       mulExpression
+     | addExpression ('+' | '-' | '~') mulExpression
+     ;


+ +
+
AliasDeclaration parseAliasDeclaration(); +
+
Parses an AliasDeclaration. +

+
 aliasDeclaration:
+       'alias' aliasInitializer (',' aliasInitializer)* ';'
+     | 'alias' type identifier ';'
+     ;


+ +
+
AliasInitializer parseAliasInitializer(); +
+
Parses an AliasInitializer + 
 aliasInitializer:
+     Identifier '=' type
+     ;


+ +
+
AliasThisDeclaration parseAliasThisDeclaration(); +
+
Parses an AliasThisDeclaration + 
 aliasThisDeclaration:
+     'alias' Identifier 'this' ';'
+     ;


+ +
+
AlignAttribute parseAlignAttribute(); +
+
Parses an AlignAttribute. + 
 alignAttribute:
+     'align' ('(' IntegerLiteral ')')?
+     ;


+ +
+
ExpressionNode parseAndAndExpression(); +
+
Parses an AndAndExpression + 
 andAndExpression:
+       orExpression
+     | andAndExpression '&&' orExpression
+     ;


+ +
+
ExpressionNode parseAndExpression(); +
+
Parses an AndExpression +

+
 andExpression:
+       cmpExpression
+     | andExpression '&' cmpExpression
+     ;


+ +
+
ArgumentList parseArgumentList(); +
+
Parses an ArgumentList +

+
 argumentList:
+     assignExpression (',' assignExpression?)*
+     ;


+ +
+
Arguments parseArguments(); +
+
Parses Arguments +

+
 arguments:
+     '(' argumentList? ')'
+     ;


+ +
+
ArrayInitializer parseArrayInitializer(); +
+
Parses an ArrayInitializer +

+
 arrayInitializer:
+       '[' ']'
+     | '[' arrayMemberInitialization (',' arrayMemberInitialization?)* ']'
+     ;


+ +
+
ArrayLiteral parseArrayLiteral(); +
+
Parses an ArrayLiteral +

+
 arrayLiteral:
+     '[' (assignExpression (',' assignExpression)*)? ']'
+     ;


+ +
+
ArrayMemberInitialization parseArrayMemberInitialization(); +
+
Parses an ArrayMemberInitialization +

+
 arrayMemberInitialization:
+     (assignExpression ':')? nonVoidInitializer
+     ;


+ +
+
ExpressionNode parseAsmAddExp(); +
+
Parses an AsmAddExp +

+
 asmAddExp:
+       asmMulExp
+     | asmAddExp ('+' | '-') asmMulExp
+     ;


+ +
+
AsmAndExp parseAsmAndExp(); +
+
Parses an AsmAndExp +

+
 asmAndExp:
+     asmEqualExp ('&' asmEqualExp)?
+     ;


+ +
+
AsmBrExp parseAsmBrExp(); +
+
Parses an AsmBrExp +

+
 asmBrExp:
+       asmUnaExp
+     | asmBrExp '[' asmExp ']'
+     ;


+ +
+
AsmEqualExp parseAsmEqualExp(); +
+
Parses an AsmEqualExp +

+
 asmEqualExp:
+     asmRelExp (('==' | '!=') asmRelExp)?
+     ;


+ +
+
AsmExp parseAsmExp(); +
+
Parses an AsmExp +

+
 asmExp:
+     asmLogOrExp ('?' asmExp ':' asmExp)?
+     ;


+ +
+
AsmInstruction parseAsmInstruction(); +
+
Parses an AsmInstruction +

+
 asmInstruction:
+     Identifier
+     | 'align' IntegerLiteral
+     | 'align' Identifier
+     | Identifier ':' asmInstruction
+     | Identifier asmExp
+     | Identifier operands
+     ;


+ +
+
AsmLogAndExp parseAsmLogAndExp(); +
+
Parses an AsmLogAndExp +

+
 asmLogAndExp:
+     asmOrExp ('&&' asmOrExp)?
+     ;


+ +
+
AsmLogOrExp parseAsmLogOrExp(); +
+
Parses an AsmLogOrExp +

+
 asmLogOrExp:
+     asmLogAndExp ('||' asmLogAndExp)?
+     ;


+ +
+
AsmMulExp parseAsmMulExp(); +
+
Parses an AsmMulExp +

+
 asmMulExp:
+     asmBrExp (('*' | '/' | '%') asmBrExp)?
+     ;


+ +
+
AsmOrExp parseAsmOrExp(); +
+
Parses an AsmOrExp +

+
 asmOrExp:
+     asmXorExp ('|' asmXorExp)?
+     ;


+ +
+
AsmPrimaryExp parseAsmPrimaryExp(); +
+
Parses an AsmPrimaryExp +

+
 asmPrimaryExp:
+       IntegerLiteral
+     | FloatLiteral
+     | register
+     | identifierChain
+     | '$'
+     ;


+ +
+
AsmRelExp parseAsmRelExp(); +
+
Parses an AsmRelExp +

+
 asmRelExp:
+     asmShiftExp (('<' | '<=' | '>' | '>=') asmShiftExp)?
+     ;


+ +
+
AsmShiftExp parseAsmShiftExp(); +
+
Parses an AsmShiftExp +

+
 asmShiftExp:
+     asmAddExp (('<<' | '>>' | '>>>') asmAddExp)?
+     ;


+ +
+
AsmStatement parseAsmStatement(); +
+
Parses an AsmStatement +

+
 asmStatement:
+     'asm' '{' asmInstruction+ '}'
+     ;


+ +
+
AsmTypePrefix parseAsmTypePrefix(); +
+
Parses an AsmTypePrefix +

+
 asmTypePrefix:
+       Identifier Identifier
+     | 'byte' Identifier
+     | 'short' Identifier
+     | 'int' Identifier
+     | 'float' Identifier
+     | 'double' Identifier
+     | 'real' Identifier
+     ;


+ +
+
AsmUnaExp parseAsmUnaExp(); +
+
Parses an AsmUnaExp +

+
 asmUnaExp:
+       asmTypePrefix asmExp
+     | Identifier asmExp
+     | '+' asmUnaExp
+     | '-' asmUnaExp
+     | '!' asmUnaExp
+     | '~' asmUnaExp
+     | asmPrimaryExp
+     ;


+ +
+
AsmXorExp parseAsmXorExp(); +
+
Parses an AsmXorExp +

+
 asmXorExp:
+     asmAndExp ('^' asmAndExp)?
+     ;


+ +
+
AssertExpression parseAssertExpression(); +
+
Parses an AssertExpression +

+
 assertExpression:
+     'assert' '(' assignExpression (',' assignExpression)? ')'
+     ;


+ +
+
AssignExpression parseAssignExpression(); +
+
Parses an AssignExpression +

+
 assignExpression:
+     ternaryExpression (assignOperator assignExpression)?
+     ;
+ assignOperator:
+       '='
+     | '>>>='
+     | '>>='
+     | '<<='
+     | '+='
+     | '-='
+     | '*='
+     | '%='
+     | '&='
+     | '/='
+     | '|='
+     | '^^='
+     | '^='
+     | '~='
+     ;


+ +
+
AssocArrayLiteral parseAssocArrayLiteral(); +
+
Parses an AssocArrayLiteral +

+
 assocArrayLiteral:
+     '[' keyValuePairs ']'
+     ;


+ +
+
AtAttribute parseAtAttribute(); +
+
Parses an AtAttribute +

+
 atAttribute:
+     '@' (Identifier | '(' argumentList ')' | functionCallExpression)
+     ;


+ +
+
Attribute parseAttribute(); +
+
Parses an Attribute +

+
 attribute:
+       alignAttribute
+     | linkageAttribute
+     | pragmaExpression
+     | storageClass
+     | 'export'
+     | 'package'
+     | 'private'
+     | 'protected'
+     | 'public'
+     ;


+ +
+
AttributeDeclaration parseAttributeDeclaration(Attribute attribute = null); +
+
Parses an AttributeDeclaration +

+
 attributeDeclaration:
+     attribute ':'
+     ;


+ +
+
AutoDeclaration parseAutoDeclaration(); +
+
Parses an AutoDeclaration +

+
 autoDeclaration:
+     storageClass Identifier '=' initializer (',' Identifier '=' initializer)* ';'
+     ;


+ +
+
BlockStatement parseBlockStatement(); +
+
Parses a BlockStatement +

+
 blockStatement:
+     '{' declarationsAndStatements? '}'
+     ;


+ +
+
BodyStatement parseBodyStatement(); +
+
Parses a BodyStatement +

+
 bodyStatement:
+     'body' blockStatement
+     ;


+ +
+
BreakStatement parseBreakStatement(); +
+
Parses a BreakStatement +

+
 breakStatement:
+     'break' Identifier? ';'
+     ;


+ +
+
BaseClass parseBaseClass(); +
+
Parses a BaseClass +

+
 baseClass:
+     (typeofExpression '.')? identifierOrTemplateChain
+     ;


+ +
+
BaseClassList parseBaseClassList(); +
+
Parses a BaseClassList +

+
 baseClassList:
+     baseClass (',' baseClass)*
+     ;


+ +
+
IdType parseBasicType(); +
+
Parses an BuiltinType +

+
 builtinType:
+      'bool'
+    | 'byte'
+    | 'ubyte'
+    | 'short'
+    | 'ushort'
+    | 'int'
+    | 'uint'
+    | 'long'
+    | 'ulong'
+    | 'char'
+    | 'wchar'
+    | 'dchar'
+    | 'float'
+    | 'double'
+    | 'real'
+    | 'ifloat'
+    | 'idouble'
+    | 'ireal'
+    | 'cfloat'
+    | 'cdouble'
+    | 'creal'
+    | 'void'
+    ;


+ +
+
CaseRangeStatement parseCaseRangeStatement(AssignExpression low = null); +
+
Parses a CaseRangeStatement +

+
 caseRangeStatement:
+     'case' assignExpression ':' '...' 'case' assignExpression ':' declarationsAndStatements
+     ;


+ +
+
CaseStatement parseCaseStatement(ArgumentList argumentList = null); +
+
Parses an CaseStatement +

+
 caseStatement:
+     'case' argumentList ':' declarationsAndStatements
+     ;


+ +
+
CastExpression parseCastExpression(); +
+
Parses a CastExpression +

+
 castExpression:
+     'cast' '(' (type | castQualifier)? ')' unaryExpression
+     ;


+ +
+
CastQualifier parseCastQualifier(); +
+
Parses a CastQualifier +

+
 castQualifier:
+      'const'
+    | 'const' 'shared'
+    | 'immutable'
+    | 'inout'
+    | 'inout' 'shared'
+    | 'shared'
+    | 'shared' 'const'
+    | 'shared' 'inout'
+    ;


+ +
+
Catch parseCatch(); +
+
Parses a Catch +

+
 catch:
+     'catch' '(' type Identifier? ')' declarationOrStatement
+     ;


+ +
+
Catches parseCatches(); +
+
Parses a Catches +

+
 catches:
+       catch+
+     | catch* lastCatch
+     ;


+ +
+
ClassDeclaration parseClassDeclaration(); +
+
Parses a ClassDeclaration +

+
 classDeclaration:
+     'class' Identifier (templateParameters constraint?)? (':' baseClassList)? structBody
+     ;


+ +
+
ExpressionNode parseCmpExpression(); +
+
Parses a CmpExpression +

+
 cmpExpression:
+       shiftExpression
+     | equalExpression
+     | identityExpression
+     | relExpression
+     | inExpression
+     ;


+ +
+
CompileCondition parseCompileCondition(); +
+
Parses a CompileCondition +

+
 compileCondition:
+       versionCondition
+     | debugCondition
+     | staticIfCondition
+     ;


+ +
+
ConditionalDeclaration parseConditionalDeclaration(); +
+
Parses a ConditionalDeclaration +

+
 conditionalDeclaration:
+       compileCondition declaration
+     | compileCondition ':' declaration+
+     | compileCondition declaration ('else' declaration)?
+     ;


+ +
+
ConditionalStatement parseConditionalStatement(); +
+
Parses a ConditionalStatement +

+
 conditionalStatement:
+     compileCondition declarationOrStatement ('else' declarationOrStatement)?
+     ;


+ +
+
Constraint parseConstraint(); +
+
Parses a Constraint +

+
 constraint:
+     'if' '(' expression ')'
+     ;


+ +
+
Constructor parseConstructor(); +
+
Parses a Constructor +

+
 constructor:
+       'this' templateParameters parameters memberFunctionAttribute* constraint? (functionBody | ';')
+     ;


+ +
+
ContinueStatement parseContinueStatement(); +
+
Parses an ContinueStatement +

+
 continueStatement:
+     'continue' Identifier? ';'
+     ;


+ +
+
DebugCondition parseDebugCondition(); +
+
Parses a DebugCondition +

+
 debugCondition:
+     'debug' ('(' (IntegerLiteral | Identifier) ')')?
+     ;


+ +
+
DebugSpecification parseDebugSpecification(); +
+
Parses a DebugSpecification +

+
 debugSpecification:
+     'debug' '=' (Identifier | IntegerLiteral) ';'
+     ;


+ +
+
Declaration parseDeclaration(); +
+
Parses a Declaration +

+
 declaration:
+     attribute* 
+     ;
+  declaration2:
+       aliasDeclaration
+     | aliasThisDeclaration
+     | classDeclaration
+     | conditionalDeclaration
+     | constructor
+     | destructor
+     | enumDeclaration
+     | functionDeclaration
+     | importDeclaration
+     | interfaceDeclaration
+     | mixinDeclaration
+     | mixinTemplateDeclaration
+     | pragmaDeclaration
+     | sharedStaticConstructor
+     | sharedStaticDestructor
+     | staticAssertDeclaration
+     | staticConstructor
+     | staticDestructor
+     | structDeclaration
+     | templateDeclaration
+     | unionDeclaration
+     | unittest
+     | variableDeclaration
+     | attributeDeclaration
+     | invariant
+     | '{' declaration+ '}'
+     ;


+ +
+
DeclarationsAndStatements parseDeclarationsAndStatements(); +
+
Parses DeclarationsAndStatements +

+
 declarationsAndStatements:
+     declarationOrStatement+
+     ;


+ +
+
DeclarationOrStatement parseDeclarationOrStatement(); +
+
Parses a DeclarationOrStatement +

+
 declarationOrStatement:
+       declaration
+     | statement
+     ;


+ +
+
Declarator parseDeclarator(); +
+
Parses a Declarator +

+
 declarator:
+     Identifier ('=' initializer)?
+     ;


+ +
+
DefaultStatement parseDefaultStatement(); +
+
Parses a DefaultStatement +

+
 defaultStatement:
+     'default' ':' declarationsAndStatements
+     ;


+ +
+
DeleteExpression parseDeleteExpression(); +
+
Parses a DeleteExpression +

+
 deleteExpression:
+     'delete' unaryExpression
+     ;


+ +
+
Deprecated parseDeprecated(); +
+
Parses a Deprecated attribute +

+
 deprecated:
+     'deprecated' ('(' assignExpression ')')?
+     ;


+ +
+
Destructor parseDestructor(); +
+
Parses a Destructor +

+
 destructor:
+     '~' 'this' '(' ')' (functionBody | ';')
+     ;


+ +
+
DoStatement parseDoStatement(); +
+
Parses a DoStatement +

+
 doStatement:
+     'do' statementNoCaseNoDefault 'while' '(' expression ')' ';'
+     ;


+ +
+
EnumBody parseEnumBody(); +
+
Parses an EnumBody +

+
 enumBody:
+       ';'
+     | '{' enumMember (',' enumMember?)* '}'
+     ;


+ +
+
EnumDeclaration parseEnumDeclaration(); +
+
Parses an EnumDeclaration +

+
 enumDeclaration:
+     'enum' Identifier? (':' type)? enumBody
+     ;


+ +
+
EnumMember parseEnumMember(); +
+
Parses an EnumMember +

+
 enumMember:
+       Identifier
+     | (Identifier | type) '=' assignExpression
+     ;


+ +
+
EqualExpression parseEqualExpression(ExpressionNode shift = null); +
+
Parses an EqualExpression +

+
 equalExpression:
+     shiftExpression ('==' | '!=') shiftExpression
+     ;


+ +
+
Expression parseExpression(); +
+
Parses an Expression +

+
 expression:
+     assignExpression (',' assignExpression)*
+     ;


+ +
+
ExpressionStatement parseExpressionStatement(Expression expression = null); +
+
Parses an ExpressionStatement +

+
 expressionStatement:
+     expression ';'
+     ;


+ +
+
FinalSwitchStatement parseFinalSwitchStatement(); +
+
Parses a FinalSwitchStatement +

+
 finalSwitchStatement:
+     'final' switchStatement
+     ;


+ +
+
Finally parseFinally(); +
+
Parses a Finally +

+
 finally:
+     'finally' declarationOrStatement
+     ;


+ +
+
ForStatement parseForStatement(); +
+
Parses a ForStatement +

+
 forStatement:
+     'for' '(' declarationOrStatement expression? ';' expression? ')' declarationOrStatement
+     ;


+ +
+
ForeachStatement parseForeachStatement(); +
+
Parses a ForeachStatement +

+
 foreachStatement:
+       ('foreach' | 'foreach_reverse') '(' foreachTypeList ';' expression ')' declarationOrStatement
+     | ('foreach' | 'foreach_reverse') '(' foreachType ';' expression '..' expression ')' declarationOrStatement
+     ;


+ +
+
ForeachType parseForeachType(); +
+
Parses a ForeachType +

+
 foreachType:
+     typeConstructors? type? Identifier
+     ;


+ +
+
ForeachTypeList parseForeachTypeList(); +
+
Parses a ForeachTypeList +

+
 foreachTypeList:
+     foreachType (',' foreachType)*
+     ;


+ +
+
FunctionAttribute parseFunctionAttribute(bool validate = true); +
+
Parses a FunctionAttribute +

+
 functionAttribute:
+       atAttribute
+     | 'pure'
+     | 'nothrow'
+     ;


+ +
+
FunctionBody parseFunctionBody(); +
+
Parses a FunctionBody +

+
 functionBody:
+       blockStatement
+     | (inStatement | outStatement | outStatement inStatement | inStatement outStatement)? bodyStatement
+     ;


+ +
+
FunctionCallExpression parseFunctionCallExpression(UnaryExpression unary = null); +
+
Parses a FunctionCallExpression +

+
 functionCallExpression:
+     unaryExpression templateArguments? arguments
+     ;


+ +
+
FunctionCallStatement parseFunctionCallStatement(); +
+
Parses a FunctionCallStatement +

+
 functionCallStatement:
+     functionCallExpression ';'
+     ;


+ +
+
FunctionDeclaration parseFunctionDeclaration(Type type = null, bool isAuto = false); +
+
Parses a FunctionDeclaration +

+
 functionDeclaration:
+       (storageClass | type) Identifier templateParameters parameters memberFunctionAttribute* constraint? (functionBody | ';')
+     ;


+ +
+
FunctionLiteralExpression parseFunctionLiteralExpression(); +
+
Parses a FunctionLiteralExpression +

+
 functionLiteralExpression:
+     (('function' | 'delegate') type?)? (parameters functionAttribute*)? functionBody
+     ;


+ +
+
GotoStatement parseGotoStatement(); +
+
Parses a GotoStatement +

+
 gotoStatement:
+     'goto' (Identifier | 'default' | 'case' expression?) ';'
+     ;


+ +
+
IdentifierChain parseIdentifierChain(); +
+
Parses an IdentifierChain +

+
 identifierChain:
+     Identifier ('.' Identifier)*
+     ;


+ +
+
IdentifierList parseIdentifierList(); +
+
Parses an IdentifierList +

+
 identifierList:
+     Identifier (',' Identifier)*
+     ;


+ +
+
IdentifierOrTemplateChain parseIdentifierOrTemplateChain(); +
+
Parses an IdentifierOrTemplateChain +

+
 identifierOrTemplateChain:
+     identifierOrTemplateInstance ('.' identifierOrTemplateInstance)*
+     ;


+ +
+
IdentifierOrTemplateInstance parseIdentifierOrTemplateInstance(); +
+
Parses an IdentifierOrTemplateInstance +

+
 identifierOrTemplateInstance:
+       Identifier
+     | templateInstance
+     ;


+ +
+
ExpressionNode parseIdentityExpression(ExpressionNode shift = null); +
+
Parses an IdentityExpression +

+
 identityExpression:
+     shiftExpression ('is' | '!' 'is') shiftExpression
+     ;


+ +
+
IfStatement parseIfStatement(); +
+
Parses an IfStatement +

+
 ifStatement:
+     'if' '(' ifCondition ')' declarationOrStatement ('else' declarationOrStatement)?
+  ifCondition:
+       'auto' Identifier '=' expression
+     | type Identifier '=' expression
+     | expression
+     ;


+ +
+
ImportBind parseImportBind(); +
+
Parses an ImportBind +

+
 importBind:
+     Identifier ('=' Identifier)?
+     ;


+ +
+
ImportBindings parseImportBindings(SingleImport singleImport); +
+
Parses ImportBindings +

+
 importBindings:
+     singleImport ':' importBind (',' importBind)*
+     ;


+ +
+
ImportDeclaration parseImportDeclaration(); +
+
Parses an ImportDeclaration +

+
 importDeclaration:
+       'import' singleImport (',' singleImport)* (',' importBindings)? ';'
+     | 'import' importBindings ';'
+     ;


+ +
+
ImportExpression parseImportExpression(); +
+
Parses an ImportExpression +

+
 importExpression:
+     'import' '(' assignExpression ')'
+     ;


+ +
+
IndexExpression parseIndexExpression(UnaryExpression unaryExpression = null); +
+
Parses an IndexExpression +

+
 indexExpression:
+     unaryExpression '[' argumentList ']'
+     ;


+ +
+
ExpressionNode parseInExpression(ExpressionNode shift = null); +
+
Parses an InExpression +

+
 inExpression:
+     shiftExpression ('in' | '!' 'in') shiftExpression
+     ;


+ +
+
InStatement parseInStatement(); +
+
Parses an InStatement +

+
 inStatement:
+     'in' blockStatement
+     ;


+ +
+
Initialize parseInitialize(); +
+
Parses an Initialize +

+
 initialize:
+       ';'
+     | statementNoCaseNoDefault
+     ;


+ +
+
Initializer parseInitializer(); +
+
Parses an Initializer +

+
 initializer:
+       'void'
+     | nonVoidInitializer
+     ;


+ +
+
InterfaceDeclaration parseInterfaceDeclaration(); +
+
Parses an InterfaceDeclaration +

+
 interfaceDeclaration:
+     'interface' Identifier (templateParameters constraint?)? (':' baseClassList)? structBody
+     ;


+ +
+
Invariant parseInvariant(); +
+
Parses an Invariant +

+
 invariant:
+     'invariant' ('(' ')')? blockStatement
+     ;


+ +
+
IsExpression parseIsExpression(); +
+
Parses an IsExpression +

+
 isExpression:
+     'is' '(' type Identifier? ((':' | '==') typeSpecialization (',' templateParameterList)?)? ')'
+     ;


+ +
+
KeyValuePair parseKeyValuePair(); +
+
Parses a KeyValuePair +

+
 keyValuePair:
+     assignExpression ':' assignExpression
+     ;


+ +
+
KeyValuePairs parseKeyValuePairs(); +
+
Parses KeyValuePairs +

+
 keyValuePairs:
+     keyValuePair (',' keyValuePair)* ','?
+     ;


+ +
+
LabeledStatement parseLabeledStatement(); +
+
Parses a LabeledStatement +

+
 labeledStatement:
+     Identifier ':' declarationOrStatement
+     ;


+ +
+
LambdaExpression parseLambdaExpression(); +
+
Parses a LambdaExpression +

+
 lambdaExpression:
+       Identifier '=>' assignExpression
+     | 'function' parameters functionAttribute* '=>' assignExpression
+     | 'delegate' parameters functionAttribute* '=>' assignExpression
+     | parameters functionAttribute* '=>' assignExpression
+     ;


+ +
+
LastCatch parseLastCatch(); +
+
Parses a LastCatch +

+
 lastCatch:
+     'catch' statementNoCaseNoDefault
+     ;


+ +
+
LinkageAttribute parseLinkageAttribute(); +
+
Parses a LinkageAttribute +

+
 linkageAttribute:
+     'extern' '(' Identifier '++'? ')'
+     ;


+ +
+
MemberFunctionAttribute parseMemberFunctionAttribute(); +
+
Parses a MemberFunctionAttribute +

+
 memberFunctionAttribute:
+       functionAttribute
+     | 'immutable'
+     | 'inout'
+     | 'shared'
+     | 'const'
+     ;


+ +
+
MixinDeclaration parseMixinDeclaration(); +
+
Parses a MixinDeclaration +

+
 mixinDeclaration:
+       mixinExpression ';'
+     | templateMixinExpression ';'
+     ;


+ +
+
MixinExpression parseMixinExpression(); +
+
Parses a MixinExpression +

+
 mixinExpression:
+     'mixin' '(' assignExpression ')'
+     ;


+ +
+
MixinTemplateDeclaration parseMixinTemplateDeclaration(); +
+
Parses a MixinTemplateDeclaration +

+
 mixinTemplateDeclaration:
+     'mixin' templateDeclaration
+     ;


+ +
+
MixinTemplateName parseMixinTemplateName(); +
+
Parses a MixinTemplateName +

+
 mixinTemplateName:
+       symbol
+     | typeofExpression '.' identifierOrTemplateChain
+     ;


+ +
+
Module parseModule(); +
+
Parses a Module +

+
 module:
+     moduleDeclaration? declaration*
+     ;


+ +
+
ModuleDeclaration parseModuleDeclaration(); +
+
Parses a ModuleDeclaration +

+
 moduleDeclaration:
+     'module' identifierChain ';'
+     ;


+ +
+
ExpressionNode parseMulExpression(); +
+
Parses a MulExpression + 
 mulExpression:
+       powExpression
+     | mulExpression ('*' | '/' | '%') powExpression
+     ;


+ +
+
NewAnonClassExpression parseNewAnonClassExpression(); +
+
Parses a NewAnonClassExpression +

+
 newAnonClassExpression:
+     'new' arguments? 'class' arguments? baseClassList? structBody
+     ;


+ +
+
NewExpression parseNewExpression(); +
+
Parses a NewExpression +

+
 newExpression:
+       'new' type ('[' assignExpression ']' | arguments)?
+     | newAnonClassExpression
+     ;


+ +
+
StatementNoCaseNoDefault parseStatementNoCaseNoDefault(); +
+
Parses a StatementNoCaseNoDefault +

+
 statementNoCaseNoDefault:
+       labeledStatement
+     | blockStatement
+     | ifStatement
+     | whileStatement
+     | doStatement
+     | forStatement
+     | foreachStatement
+     | switchStatement
+     | finalSwitchStatement
+     | continueStatement
+     | breakStatement
+     | returnStatement
+     | gotoStatement
+     | withStatement
+     | synchronizedStatement
+     | tryStatement
+     | throwStatement
+     | scopeGuardStatement
+     | asmStatement
+     | conditionalStatement
+     | staticAssertStatement
+     | versionSpecification
+     | debugSpecification
+     | expressionStatement
+     ;


+ +
+
NonVoidInitializer parseNonVoidInitializer(); +
+
Parses a NonVoidInitializer +

+
 nonVoidInitializer:
+       assignExpression
+     | arrayInitializer
+     | structInitializer
+     ;


+ +
+
Operands parseOperands(); +
+
Parses Operands +

+
 operands:
+     asmExp+
+     ;


+ +
+
ExpressionNode parseOrExpression(); +
+
Parses an OrExpression +

+
 orExpression:
+       xorExpression
+     | orExpression '|' xorExpression
+     ;


+ +
+
ExpressionNode parseOrOrExpression(); +
+
Parses an OrOrExpression +

+
 orOrExpression:
+       andAndExpression
+     | orOrExpression '||' andAndExpression
+     ;


+ +
+
OutStatement parseOutStatement(); +
+
Parses an OutStatement +

+
 outStatement:
+     'out' ('(' Identifier ')')? blockStatement
+     ;


+ +
+
Parameter parseParameter(); +
+
Parses a Parameter +

+
 parameter:
+     parameterAttribute* type (Identifier? '...' | (Identifier? ('=' assignExpression)?))?
+     ;


+ +
+
IdType parseParameterAttribute(bool validate = false); +
+
Parses a ParameterAttribute +

+
 parameterAttribute:
+       typeConstructor
+     | 'final'
+     | 'in'
+     | 'lazy'
+     | 'out'
+     | 'ref'
+     | 'scope'
+     | 'auto'
+     ;


+ +
+
Parameters parseParameters(); +
+
Parses Parameters +

+
 parameters:
+       '(' parameter (',' parameter)* (',' '...')? ')'
+     | '(' '...' ')'
+     | '(' ')'
+     ;


+ +
+
Postblit parsePostblit(); +
+
Parses a Postblit +

+
 postblit:
+     'this' '(' 'this' ')' (functionBody | ';')
+     ;


+ +
+
PostIncDecExpression parsePostIncDecExpression(UnaryExpression unary = null); +
+
Parses a PostIncDecExpression +

+
 postIncDecExpression:
+     unaryExpression ('++' | '--')
+     ;


+ +
+
ExpressionNode parsePowExpression(); +
+
Parses a PowExpression +

+
 powExpression:
+       unaryExpression
+     | powExpression '^^' unaryExpression
+     ;


+ +
+
PragmaDeclaration parsePragmaDeclaration(); +
+
Parses a PragmaDeclaration +

+
 pragmaDeclaration:
+     pragmaExpression ';'
+     ;


+ +
+
PragmaExpression parsePragmaExpression(); +
+
Parses a PragmaExpression +

+
 pragmaExpression:
+     'pragma' '(' Identifier (',' argumentList)? ')'
+     ;


+ +
+
PreIncDecExpression parsePreIncDecExpression(); +
+
Parses a PreIncDecExpression +

+
 preIncDecExpression:
+     ('++' | '--') unaryExpression
+     ;


+ +
+
PrimaryExpression parsePrimaryExpression(); +
+
Parses a PrimaryExpression +

+
 primaryExpression:
+       identifierOrTemplateInstance
+     | '.' identifierOrTemplateInstance
+     | basicType '.' Identifier
+     | typeofExpression
+     | typeidExpression
+     | vector
+     | arrayLiteral
+     | assocArrayLiteral
+     | '(' expression ')'
+     | isExpression
+     | lambdaExpression
+     | functionLiteralExpression
+     | traitsExpression
+     | mixinExpression
+     | importExpression
+     | '$'
+     | 'this'
+     | 'super'
+     | 'null'
+     | 'true'
+     | 'false'
+     | '__DATE__'
+     | '__TIME__'
+     | '__TIMESTAMP__'
+     | '__VENDOR__'
+     | '__VERSION__'
+     | '__FILE__'
+     | '__LINE__'
+     | '__MODULE__'
+     | '__FUNCTION__'
+     | '__PRETTY_FUNCTION__'
+     | IntegerLiteral
+     | FloatLiteral
+     | StringLiteral+
+     | CharacterLiteral
+     ;


+ +
+
Register parseRegister(); +
+
Parses a Register +

+
 register:
+     Identifier
+     | Identifier '(' IntegerLiteral ')'
+     ;


+ +
+
ExpressionNode parseRelExpression(ExpressionNode shift); +
+
Parses a RelExpression +

+
 relExpression:
+       shiftExpression
+     | relExpression relOperator shiftExpression
+     ;
+ relOperator:
+       '<'
+     | '<='
+     | '>'
+     | '>='
+     | '!<>='
+     | '!<>'
+     | '<>'
+     | '<>='
+     | '!>'
+     | '!>='
+     | '!<'
+     | '!<='
+     ;


+ +
+
ReturnStatement parseReturnStatement(); +
+
Parses a ReturnStatement +

+
 returnStatement:
+     'return' expression? ';'
+     ;


+ +
+
ScopeGuardStatement parseScopeGuardStatement(); +
+
Parses a ScopeGuardStatement +

+
 scopeGuardStatement:
+     'scope' '(' Identifier ')' statementNoCaseNoDefault
+     ;


+ +
+
SharedStaticConstructor parseSharedStaticConstructor(); +
+
Parses a SharedStaticConstructor +

+
 sharedStaticConstructor:
+     'shared' 'static' 'this' '(' ')' functionBody
+     ;


+ +
+
SharedStaticDestructor parseSharedStaticDestructor(); +
+
Parses a SharedStaticDestructor +

+
 sharedStaticDestructor:
+     'shared' 'static' '~' 'this' '(' ')' functionBody
+     ;


+ +
+
ExpressionNode parseShiftExpression(); +
+
Parses a ShiftExpression +

+
 shiftExpression:
+       addExpression
+     | shiftExpression ('<<' | '>>' | '>>>') addExpression
+     ;


+ +
+
SingleImport parseSingleImport(); +
+
Parses a SingleImport +

+
 singleImport:
+     (Identifier '=')? identifierChain
+     ;


+ +
+
SliceExpression parseSliceExpression(UnaryExpression unary = null); +
+
Parses a SliceExpression +

+
 sliceExpression:
+       unaryExpression '[' assignExpression '..' assignExpression ']'
+     | unaryExpression '[' ']'
+     ;


+ +
+
Statement parseStatement(); +
+
Parses a Statement +

+
 statement:
+       statementNoCaseNoDefault
+     | caseStatement
+     | caseRangeStatement
+     | defaultStatement
+     ;


+ +
+
StaticAssertDeclaration parseStaticAssertDeclaration(); +
+
Parses a StaticAssertDeclaration +

+
 staticAssertDeclaration:
+     staticAssertStatement
+     ;


+ +
+
StaticAssertStatement parseStaticAssertStatement(); +
+
Parses a StaticAssertStatement +

+
 staticAssertStatement:
+     'static' assertExpression ';'
+     ;


+ +
+
StaticConstructor parseStaticConstructor(); +
+
Parses a StaticConstructor +

+
 staticConstructor:
+     'static' 'this' '(' ')' functionBody
+     ;


+ +
+
StaticDestructor parseStaticDestructor(); +
+
Parses a StaticDestructor +

+
 staticDestructor:
+     'static' '~' 'this' '(' ')' functionBody
+     ;


+ +
+
StaticIfCondition parseStaticIfCondition(); +
+
Parses an StaticIfCondition +

+
 staticIfCondition:
+     'static' 'if' '(' assignExpression ')'
+     ;


+ +
+
StorageClass parseStorageClass(); +
+
Parses an StorageClass +

+
 storageClass:
+       atAttribute
+     | typeConstructor
+     | deprecated
+     | 'abstract'
+     | 'auto'
+     | 'enum'
+     | 'extern'
+     | 'final'
+     | 'nothrow'
+     | 'override'
+     | 'pure'
+     | 'ref'
+     | '__gshared'
+     | 'scope'
+     | 'static'
+     | 'synchronized'
+     ;


+ +
+
StructBody parseStructBody(); +
+
Parses a StructBody +

+
 structBody:
+     '{' declaration* '}'
+     ;


+ +
+
StructDeclaration parseStructDeclaration(); +
+
Parses a StructDeclaration +

+
 structDeclaration:
+     'struct' Identifier? (templateParameters constraint? structBody | (structBody | ';'))
+     ;


+ +
+
StructInitializer parseStructInitializer(); +
+
Parses an StructInitializer +

+
 structInitializer:
+     '{' structMemberInitializers? '}'
+     ;


+ +
+
StructMemberInitializer parseStructMemberInitializer(); +
+
Parses a StructMemberInitializer +

+
 structMemberInitializer:
+     (Identifier ':')? nonVoidInitializer
+     ;


+ +
+
StructMemberInitializers parseStructMemberInitializers(); +
+
Parses StructMemberInitializers +

+
 structMemberInitializers:
+     structMemberInitializer (',' structMemberInitializer?)*
+     ;


+ +
+
SwitchStatement parseSwitchStatement(); +
+
Parses a SwitchStatement +

+
 switchStatement:
+     'switch' '(' expression ')' statement
+     ;


+ +
+
Symbol parseSymbol(); +
+
Parses a Symbol +

+
 symbol:
+     '.'? identifierOrTemplateChain
+     ;


+ +
+
SynchronizedStatement parseSynchronizedStatement(); +
+
Parses a SynchronizedStatement +

+
 synchronizedStatement:
+     'synchronized' ('(' expression ')')? statementNoCaseNoDefault
+     ;


+ +
+
TemplateAliasParameter parseTemplateAliasParameter(); +
+
Parses a TemplateAliasParameter +

+
 templateAliasParameter:
+     'alias' type? Identifier (':' (type | assignExpression))? ('=' (type | assignExpression))?
+     ;


+ +
+
TemplateArgument parseTemplateArgument(); +
+
Parses a TemplateArgument +

+
 templateArgument:
+       type
+     | assignExpression
+     ;


+ +
+
TemplateArgumentList parseTemplateArgumentList(); +
+
Parses a TemplateArgumentList +

+
 templateArgumentList:
+     templateArgument (',' templateArgument?)*
+     ;


+ +
+
TemplateArguments parseTemplateArguments(); +
+
Parses TemplateArguments +

+
 templateArguments:
+     '!' ('(' templateArgumentList? ')' | templateSingleArgument)
+     ;


+ +
+
TemplateDeclaration parseTemplateDeclaration(); +
+
Parses a TemplateDeclaration +

+
 templateDeclaration:
+       'template' Identifier templateParameters constraint? '{' declaration* '}'
+     | eponymousTemplateDeclaration
+     ;


+ +
+
EponymousTemplateDeclaration parseEponymousTemplateDeclaration(); +
+
Parses an EponymousTemplateDeclaration +

+
 eponymousTemplateDeclaration:
+     'enum' Identifier templateParameters '=' assignExpression ';'
+     ;


+ +
+
TemplateInstance parseTemplateInstance(); +
+
Parses a TemplateInstance +

+
 templateInstance:
+     Identifier templateArguments
+     ;


+ +
+
TemplateMixinExpression parseTemplateMixinExpression(); +
+
Parses a TemplateMixinExpression +

+
 templateMixinExpression:
+     'mixin' mixinTemplateName templateArguments? Identifier?
+     ;


+ +
+
TemplateParameter parseTemplateParameter(); +
+
Parses a TemplateParameter +

+
 templateParameter:
+       templateTypeParameter
+     | templateValueParameter
+     | templateAliasParameter
+     | templateTupleParameter
+     | templateThisParameter
+     ;


+ +
+
TemplateParameterList parseTemplateParameterList(); +
+
Parses an TemplateParameterList +

+
 templateParameterList:
+     templateParameter (',' templateParameter?)*
+     ;


+ +
+
TemplateParameters parseTemplateParameters(); +
+
Parses TemplateParameters +

+
 templateParameters:
+     '(' templateParameterList? ')'
+     ;


+ +
+
TemplateSingleArgument parseTemplateSingleArgument(); +
+
Parses a TemplateSingleArgument +

+
 templateSingleArgument:
+       builtinType
+     | Identifier
+     | CharacterLiteral
+     | StringLiteral
+     | IntegerLiteral
+     | FloatLiteral
+     | 'true'
+     | 'false'
+     | 'null'
+     | 'this'
+     | '__DATE__'
+     | '__TIME__'
+     | '__TIMESTAMP__'
+     | '__VENDOR__'
+     | '__VERSION__'
+     | '__FILE__'
+     | '__LINE__'
+     | '__MODULE__'
+     | '__FUNCTION__'
+     | '__PRETTY_FUNCTION__'
+     ;


+ +
+
TemplateThisParameter parseTemplateThisParameter(); +
+
Parses a TemplateThisParameter +

+
 templateThisParameter:
+     'this' templateTypeParameter
+     ;


+ +
+
TemplateTupleParameter parseTemplateTupleParameter(); +
+
Parses an TemplateTupleParameter +

+
 templateTupleParameter:
+     Identifier '...'
+     ;


+ +
+
TemplateTypeParameter parseTemplateTypeParameter(); +
+
Parses a TemplateTypeParameter +

+
 templateTypeParameter:
+     Identifier (':' type)? ('=' type)?
+     ;


+ +
+
TemplateValueParameter parseTemplateValueParameter(); +
+
Parses a TemplateValueParameter +

+
 templateValueParameter:
+     type Identifier (':' expression)? templateValueParameterDefault?
+     ;


+ +
+
TemplateValueParameterDefault parseTemplateValueParameterDefault(); +
+
Parses a TemplateValueParameterDefault +

+
 templateValueParameterDefault:
+     '=' ('__FILE__' | '__MODULE__' | '__LINE__' | '__FUNCTION__' | '__PRETTY_FUNCTION__' | assignExpression)
+     ;


+ +
+
ExpressionNode parseTernaryExpression(); +
+
Parses a TernaryExpression +

+
 ternaryExpression:
+     orOrExpression ('?' expression ':' ternaryExpression)?
+     ;


+ +
+
ThrowStatement parseThrowStatement(); +
+
Parses a ThrowStatement +

+
 throwStatement:
+     'throw' expression ';'
+     ;


+ +
+
TraitsExpression parseTraitsExpression(); +
+
Parses an TraitsExpression +

+
 traitsExpression:
+     '__traits' '(' Identifier ',' TemplateArgumentList ')'
+     ;


+ +
+
TryStatement parseTryStatement(); +
+
Parses a TryStatement +

+
 tryStatement:
+     'try' declarationOrStatement (catches | catches finally | finally)
+     ;


+ +
+
Type parseType(); +
+
Parses a Type +

+
 type:
+     attribute? type2 typeSuffix*
+     ;


+ +
+
Type2 parseType2(); +
+
Parses a Type2 +

+
 type2:
+       builtinType
+     | symbol
+     | typeofExpression ('.' identifierOrTemplateChain)?
+     | typeConstructor '(' type ')'
+     ;


+ +
+
IdType parseTypeConstructor(bool validate = true); +
+
Parses a TypeConstructor +

+
 typeConstructor:
+       'const'
+     | 'immutable'
+     | 'inout'
+     | 'shared'
+     | 'scope'
+     ;


+ +
+
IdType[] parseTypeConstructors(); +
+
Parses TypeConstructors +

+
 typeConstructors:
+     typeConstructor+
+     ;


+ +
+
TypeSpecialization parseTypeSpecialization(); +
+
Parses a TypeSpecialization +

+
 typeSpecialization:
+       type
+     | 'struct'
+     | 'union'
+     | 'class'
+     | 'interface'
+     | 'enum'
+     | 'function'
+     | 'delegate'
+     | 'super'
+     | 'const'
+     | 'immutable'
+     | 'inout'
+     | 'shared'
+     | 'return'
+     | 'typedef'
+     | '__parameters'
+     ;


+ +
+
TypeSuffix parseTypeSuffix(); +
+
Parses a TypeSuffix +

+
 typeSuffix:
+       '*'
+     | '[' type? ']'
+     | '[' assignExpression ']'
+     | '[' assignExpression '..'  assignExpression ']'
+     | ('delegate' | 'function') parameters memberFunctionAttribute*
+     ;


+ +
+
TypeidExpression parseTypeidExpression(); +
+
Parses a TypeidExpression +

+
 typeidExpression:
+     'typeid' '(' (type | expression) ')'
+     ;


+ +
+
TypeofExpression parseTypeofExpression(); +
+
Parses a TypeofExpression +

+
 typeofExpression:
+     'typeof' '(' (expression | 'return') ')'
+     ;


+ +
+
UnaryExpression parseUnaryExpression(); +
+
Parses a UnaryExpression +

+
 unaryExpression:
+       primaryExpression
+     | '&' unaryExpression
+     | '!' unaryExpression
+     | '*' unaryExpression
+     | '+' unaryExpression
+     | '-' unaryExpression
+     | '~' unaryExpression
+     | '++' unaryExpression
+     | '--' unaryExpression
+     | newExpression
+     | deleteExpression
+     | castExpression
+     | assertExpression
+     | functionCallExpression
+     | sliceExpression
+     | indexExpression
+     | '$LPAREN' type '$RPAREN' '.' identifierOrTemplateInstance
+     | unaryExpression '.' identifierOrTemplateInstance
+     | unaryExpression '--'
+     | unaryExpression '++'
+     ;


+ +
+
UnionDeclaration parseUnionDeclaration(); +
+
Parses an UnionDeclaration +

+
 unionDeclaration:
+       'union' Identifier templateParameters constraint? structBody
+     | 'union' Identifier (structBody | ';')
+     | 'union' structBody
+     ;


+ +
+
Unittest parseUnittest(); +
+
Parses a Unittest +

+
 unittest:
+     'unittest' blockStatement
+     ;


+ +
+
VariableDeclaration parseVariableDeclaration(Type type = null, bool isAuto = false); +
+
Parses a VariableDeclaration +

+
 variableDeclaration:
+       type declarator (',' declarator)* ';'
+     | autoDeclaration
+     ;


+ +
+
Vector parseVector(); +
+
Parses a Vector +

+
 vector:
+     '__vector' '(' type ')'
+     ;


+ +
+
VersionCondition parseVersionCondition(); +
+
Parses a VersionCondition +

+
 versionCondition:
+     'version' '(' (IntegerLiteral | Identifier | 'unittest' | 'assert') ')'
+     ;


+ +
+
VersionSpecification parseVersionSpecification(); +
+
Parses a VersionSpecification +

+
 versionSpecification:
+     'version' '=' (Identifier | IntegerLiteral) ';'
+     ;


+ +
+
WhileStatement parseWhileStatement(); +
+
Parses a WhileStatement +

+
 whileStatement:
+     'while' '(' expression ')' declarationOrStatement
+     ;


+ +
+
WithStatement parseWithStatement(); +
+
Parses a WithStatement +

+
 withStatement:
+     'with' '(' expression ')' statementNoCaseNoDefault
+     ;


+ +
+
ExpressionNode parseXorExpression(); +
+
Parses an XorExpression +

+
 xorExpression:
+       andExpression
+     | xorExpression '^' andExpression
+     ;


+ +
+
uint errorCount; +
+
Current error count

+ +
+
uint warningCount; +
+
Current warning count

+ +
+
string fileName; +
+
Name used when reporting warnings and errors

+ +
+
void function(string, size_t, size_t, string, bool) messageFunction; +
+
Function that is called when a warning or error is encountered. + The parameters are the file name, line number, column number, + and the error or warning message.

+ +
+
protected const(Token)* expect(IdType type); +
+
Returns a token of the specified type if it was the next token, otherwise + calls the error function and returns null.

+ +
+
protected const @property Token current(); +
+
Returns:
+the current token

+ +
+
protected Token advance(); +
+
Advances to the next token and returns the current token

+ +
+
protected const bool currentIs(IdType type); +
+
Returns:
+true if the current token has the given type

+ +
+
protected const bool currentIsOneOf(IdType[] types...); +
+
Returns:
+true if the current token is one of the given types

+ +
+
protected const nothrow bool moreTokens(); +
+
Returns:
+true if there are more tokens

+ +
+
+
+
+ +
Page generated by Ddoc. + diff --git a/stdx/d/parser.o b/stdx/d/parser.o new file mode 100644 index 0000000000000000000000000000000000000000..b721184fa40c40dc3ff137c81f81da5f7b697314 GIT binary patch literal 497324 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

cY8ymJ&gfHqFnFi)IZ=82PC!V7KQh~vcvAx;j) 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