Initial check in lib
This commit is contained in:
@@ -0,0 +1,349 @@
|
||||
unit z.dpglib.DpgLexer;
|
||||
|
||||
lexer TDpgLexer;
|
||||
options
|
||||
{
|
||||
testLiterals = false;
|
||||
k = 2;
|
||||
}
|
||||
|
||||
tokens
|
||||
{
|
||||
"unit";
|
||||
"uses";
|
||||
"const";
|
||||
"type";
|
||||
|
||||
"lexer";
|
||||
"parser";
|
||||
|
||||
"options";
|
||||
"tokens";
|
||||
"memberdecl";
|
||||
"memberdef";
|
||||
|
||||
"private";
|
||||
"protected";
|
||||
"public";
|
||||
|
||||
"returns";
|
||||
"local";
|
||||
|
||||
"except";
|
||||
"finally";
|
||||
|
||||
SEMPRED;
|
||||
|
||||
USES;
|
||||
OPTIONS;
|
||||
TOKENS;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Simple tokens
|
||||
// ----------------------------------------------------------------------------
|
||||
LPAREN: '(';
|
||||
RPAREN: ')';
|
||||
|
||||
RCURLY: '}';
|
||||
|
||||
COLON: ':';
|
||||
SEMI: ';';
|
||||
COMMA: ',';
|
||||
|
||||
ASSIGN: '=';
|
||||
IMPLIES: "=>";
|
||||
|
||||
QUEST: '?';
|
||||
PLUS: '+';
|
||||
STAR: '*';
|
||||
AT: '@';
|
||||
|
||||
NOT: '~';
|
||||
OR: '|';
|
||||
BANG: '!';
|
||||
|
||||
WILDCARD: '.';
|
||||
RANGE: "..";
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Character literal
|
||||
// ----------------------------------------------------------------------------
|
||||
CHARLIT
|
||||
: '\''! (ESC | ~'\'') '\''! ;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// String literal
|
||||
// ----------------------------------------------------------------------------
|
||||
STRINGLIT
|
||||
: '"' (ESC | ~'"')* '"' ;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Integer
|
||||
// ----------------------------------------------------------------------------
|
||||
INTEGER
|
||||
local
|
||||
{
|
||||
i: integer;
|
||||
v: integer;
|
||||
}
|
||||
:
|
||||
(
|
||||
DNUMBER
|
||||
{
|
||||
v := 0;
|
||||
for i:=1 to Length( TokenText) do
|
||||
begin
|
||||
v := v * 10 + ord( TokenText[i]) - ord('0');
|
||||
end;
|
||||
|
||||
TokenText := IntToStr( v);
|
||||
}
|
||||
|
|
||||
XNUMBER
|
||||
{
|
||||
v := 0;
|
||||
for i:=1 to Length( TokenText) do
|
||||
begin
|
||||
case TokenText[i] of
|
||||
'0'..'9': v := v * 16 + ord(TokenText[i]) - ord('0');
|
||||
'a'..'z': v := v * 16 + ord(TokenText[i]) - ord('a');
|
||||
'A'..'Z': v := v * 16 + ord(TokenText[i]) - ord('A');
|
||||
end;
|
||||
end;
|
||||
|
||||
TokenText := IntToStr( v);
|
||||
}
|
||||
)
|
||||
;
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Argument action
|
||||
// ----------------------------------------------------------------------------
|
||||
ARGACTION
|
||||
:
|
||||
'['!
|
||||
(
|
||||
options
|
||||
{
|
||||
generateAmbigWarnings = false;
|
||||
}
|
||||
: '\r' '\n' { newLine; }
|
||||
| '\r' { newLine; }
|
||||
| '\n' { newLine; }
|
||||
| ~']'
|
||||
)*
|
||||
']'!
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Action
|
||||
// ----------------------------------------------------------------------------
|
||||
ACTION
|
||||
:
|
||||
'{'
|
||||
(
|
||||
options
|
||||
{
|
||||
generateAmbigWarnings = false;
|
||||
}
|
||||
: '\r' '\n' { newLine; }
|
||||
| '\r' { newLine; }
|
||||
| '\n' { newLine; }
|
||||
| ~'}'
|
||||
)*
|
||||
'}'
|
||||
( '?'! { _ttype := TT_SEMPRED; } )?
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Token ref
|
||||
// ----------------------------------------------------------------------------
|
||||
TOKENREF
|
||||
options
|
||||
{
|
||||
testLiterals = true;
|
||||
}
|
||||
: 'A'..'Z' ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')* ;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Rule ref
|
||||
// ----------------------------------------------------------------------------
|
||||
RULEREF
|
||||
local
|
||||
{
|
||||
t: integer;
|
||||
}
|
||||
:
|
||||
t = INT_RULEREF { _ttype := t; }
|
||||
(
|
||||
{t = LT_uses}? WS_LOOP ('{' { _ttype := TT_USES; } )?
|
||||
| {t = LT_options}? WS_LOOP ('{' { _ttype := TT_OPTIONS; } )?
|
||||
| {t = LT_tokens}? WS_LOOP ('{' { _ttype := TT_TOKENS; } )?
|
||||
)?
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Internal rule ref
|
||||
// ----------------------------------------------------------------------------
|
||||
protected
|
||||
INT_RULEREF returns [integer]
|
||||
{
|
||||
_ttype := TT_RULEREF;
|
||||
}
|
||||
: 'a'..'z' ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*
|
||||
{
|
||||
result := TestLiteral( _ttype);
|
||||
}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// COMMENT
|
||||
// ----------------------------------------------------------------------------
|
||||
COMMENT
|
||||
: SLCOMMENT { _ttype := TT_SKIP; }
|
||||
| MLCOMMENT1 { _ttype := TT_SKIP; }
|
||||
| MLCOMMENT2 { _ttype := TT_SKIP; }
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// SLCOMMENT
|
||||
// ----------------------------------------------------------------------------
|
||||
protected
|
||||
SLCOMMENT
|
||||
:
|
||||
"//"
|
||||
( ~( '\r' | '\n') )*
|
||||
(
|
||||
options
|
||||
{
|
||||
generateAmbigWarnings = false;
|
||||
}
|
||||
: '\r' '\n' { newLine; }
|
||||
| '\r' { newLine; }
|
||||
| '\n' { newLine; }
|
||||
)
|
||||
;
|
||||
|
||||
// ============================================================================
|
||||
// Multi line comment version 1
|
||||
// Nested comments aren't allowed!
|
||||
// ============================================================================
|
||||
protected
|
||||
MLCOMMENT1
|
||||
:
|
||||
"(*"
|
||||
(
|
||||
options
|
||||
{
|
||||
greedy = false;
|
||||
generateAmbigWarnings = false;
|
||||
}
|
||||
: '\r' '\n' { newLine; }
|
||||
| '\r' { newLine; }
|
||||
| '\n' { newLine; }
|
||||
| .
|
||||
)*
|
||||
"*)"
|
||||
;
|
||||
|
||||
// ============================================================================
|
||||
// Multi line comment version 2
|
||||
// Nested comments aren't allowed!
|
||||
// ============================================================================
|
||||
protected
|
||||
MLCOMMENT2
|
||||
:
|
||||
"/*"
|
||||
(
|
||||
options
|
||||
{
|
||||
greedy = false;
|
||||
generateAmbigWarnings = false;
|
||||
}
|
||||
: '\r' '\n' { newLine; }
|
||||
| '\r' { newLine; }
|
||||
| '\n' { newLine; }
|
||||
| .
|
||||
)*
|
||||
"*/"
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Numbers
|
||||
// ----------------------------------------------------------------------------
|
||||
protected DNUMBER: '0'..'9' (DDIGIT)*;
|
||||
protected XNUMBER: '$'! (XDIGIT)+;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Digits
|
||||
// ----------------------------------------------------------------------------
|
||||
protected DDIGIT: '0'..'9';
|
||||
protected XDIGIT: '0'..'9' | 'a'..'f' | 'A'..'F';
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// WS
|
||||
// ----------------------------------------------------------------------------
|
||||
WS
|
||||
:
|
||||
(
|
||||
options
|
||||
{
|
||||
generateAmbigWarnings = false;
|
||||
}
|
||||
: ' '
|
||||
| '\t' { tab; }
|
||||
| '\r' '\n' { newLine; }
|
||||
| '\r' { newLine; }
|
||||
| '\n' { newLine; }
|
||||
)
|
||||
{
|
||||
_ttype := TT_SKIP;
|
||||
}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// WS_LOOP
|
||||
// ----------------------------------------------------------------------------
|
||||
protected
|
||||
WS_LOOP
|
||||
:
|
||||
(
|
||||
options
|
||||
{
|
||||
greedy = true;
|
||||
}
|
||||
: WS
|
||||
| COMMENT
|
||||
)*
|
||||
;
|
||||
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Esc
|
||||
// ----------------------------------------------------------------------------
|
||||
protected
|
||||
ESC
|
||||
local
|
||||
{
|
||||
number: AnsiString;
|
||||
}
|
||||
:
|
||||
'\\'!
|
||||
(
|
||||
'r' { TokenText[ Length( TokenText)] := AnsiChar(13); }
|
||||
| 'n' { TokenText[ Length( TokenText)] := AnsiChar(10); }
|
||||
| 't' { TokenText[ Length( TokenText)] := AnsiChar(9); }
|
||||
| '\\'
|
||||
| '\''
|
||||
| '"'
|
||||
| 'x' d1:XDIGIT! d2:XDIGIT!
|
||||
{
|
||||
number := '$' + d1.TokenText + d2.TokenText;
|
||||
TokenText[ Length( TokenText)] := AnsiChar( StrToInt( number));
|
||||
}
|
||||
)
|
||||
;
|
||||
|
||||
@@ -0,0 +1,798 @@
|
||||
unit z.dpglib.DpgParser;
|
||||
|
||||
uses
|
||||
{
|
||||
z.dpglib.types;
|
||||
}
|
||||
|
||||
|
||||
parser TDpgParser;
|
||||
options
|
||||
{
|
||||
defaultErrorHandler = false;
|
||||
importVocab = z.dpglib.DpgLexer;
|
||||
exportVocab = z.dpglib.DpgParser;
|
||||
k = 2;
|
||||
}
|
||||
|
||||
memberdecl
|
||||
{
|
||||
protected
|
||||
fGrammarMaker : IGrammarBehavior;
|
||||
fTool : ITool;
|
||||
fNesting : integer;
|
||||
|
||||
fExchangeDir : AnsiString;
|
||||
fGrammarFile : AnsiString;
|
||||
fGrammarUnit : AnsiString;
|
||||
|
||||
private
|
||||
function lastInRule : boolean;
|
||||
procedure checkEndRule( pToken: IToken);
|
||||
|
||||
public
|
||||
constructor Create( pParserState : IParserState;
|
||||
pGrammarMaker : IGrammarBehavior;
|
||||
pTool : ITool;
|
||||
pExchangeDir : AnsiString); overload;
|
||||
|
||||
constructor Create( pTokenBuffer : ITokenBuffer;
|
||||
pGrammarMaker : IGrammarBehavior;
|
||||
pTool : ITool;
|
||||
pExchangeDir : AnsiString); overload;
|
||||
|
||||
constructor Create( pTokenStream : ITokenStream;
|
||||
pGrammarMaker : IGrammarBehavior;
|
||||
pTool : ITool;
|
||||
pExchangeDir : AnsiString); overload;
|
||||
|
||||
destructor Destroy; override;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// grammar
|
||||
// ----------------------------------------------------------------------------
|
||||
grammar
|
||||
local
|
||||
{
|
||||
unitName: IToken;
|
||||
}
|
||||
:
|
||||
"unit" "[" unitName=qualifiedId {fGrammarUnit := unitName.TokenText;} SEMI
|
||||
(usesDecl)?
|
||||
(constDecl)?
|
||||
(typeDecl)?
|
||||
classDecl
|
||||
{fGrammarMaker.endGrammar;}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// usesDecl
|
||||
// ----------------------------------------------------------------------------
|
||||
usesDecl
|
||||
:
|
||||
USES
|
||||
(
|
||||
// tr:TOKENREF SEMI {fGrammarMaker.defineUses( tr);}
|
||||
// | rr:RULEREF SEMI {fGrammarMaker.defineUses( rr);}
|
||||
qualifiedUsesName SEMI
|
||||
)*
|
||||
|
||||
RCURLY
|
||||
;
|
||||
|
||||
qualifiedUsesName
|
||||
local
|
||||
{
|
||||
id: AnsiString;
|
||||
}
|
||||
: ( r:TOKENREF | r:RULEREF ) { id := r.TokenText; }
|
||||
( WILDCARD
|
||||
( r:TOKENREF | r:RULEREF) { id := id +'.'+ r.TokenText; }
|
||||
)*
|
||||
{
|
||||
fGrammarMaker.defineUses(id);
|
||||
}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constDecl
|
||||
// ----------------------------------------------------------------------------
|
||||
constDecl
|
||||
:
|
||||
"const"
|
||||
a:ACTION {fGrammarMaker.RefConstAction( a);}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// typeDecl
|
||||
// ----------------------------------------------------------------------------
|
||||
typeDecl
|
||||
:
|
||||
"type"
|
||||
a:ACTION {fGrammarMaker.RefTypeAction( a);}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// classDecl
|
||||
// ----------------------------------------------------------------------------
|
||||
classDecl
|
||||
local
|
||||
{
|
||||
grType : integer;
|
||||
grObject : IToken;
|
||||
grSuper : IToken;
|
||||
}
|
||||
{
|
||||
grObject := nil;
|
||||
grSuper := nil;
|
||||
}
|
||||
:
|
||||
// ------------------------------------------------------------
|
||||
// Determine parser type
|
||||
// ------------------------------------------------------------
|
||||
( "lexer" { grType := 0; }
|
||||
| "parser" { grType := 1; }
|
||||
)
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// get class name
|
||||
// ------------------------------------------------------------
|
||||
grObject = id
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// get superclass name
|
||||
// ------------------------------------------------------------
|
||||
// (
|
||||
// LPAREN
|
||||
// grSuper=id
|
||||
// RPAREN
|
||||
// )?
|
||||
|
||||
SEMI
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Start the grammar
|
||||
// ------------------------------------------------------------
|
||||
{
|
||||
// ---------------------------------------------------------
|
||||
// Now we have enough information to start the grammar.
|
||||
// ---------------------------------------------------------
|
||||
case grType of
|
||||
0: fGrammarMaker.StartLexer( InputState.FileName,
|
||||
grObject,
|
||||
grSuper);
|
||||
|
||||
1: fGrammarMaker.StartParser( InputState.FileName,
|
||||
grObject,
|
||||
grSuper);
|
||||
|
||||
2: fGrammarMaker.StartTreeWalker( InputState.FileName,
|
||||
grObject,
|
||||
grSuper);
|
||||
end;
|
||||
|
||||
fGrammarMaker.defineGrammarUnit( fGrammarUnit);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Process optional class "options {...}" clause
|
||||
// ------------------------------------------------------------
|
||||
(classOptions)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Process optional class "tokens {...}" clause
|
||||
// But only for lexers.
|
||||
// ------------------------------------------------------------
|
||||
( {grType=0}? classTokens)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Process optional class "memberDecl {...}" clause
|
||||
// ------------------------------------------------------------
|
||||
(classMemberDecl)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Well, the rules
|
||||
// ------------------------------------------------------------
|
||||
rules
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Process optional class "memberDecl {...}" clause
|
||||
// ------------------------------------------------------------
|
||||
(classMemberDef)?
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// classOptions
|
||||
// ----------------------------------------------------------------------------
|
||||
classOptions
|
||||
local
|
||||
{
|
||||
optName : IToken;
|
||||
optValue : IToken;
|
||||
}
|
||||
:
|
||||
OPTIONS
|
||||
(
|
||||
optName = id
|
||||
ASSIGN
|
||||
optValue = optionValue
|
||||
SEMI
|
||||
{fGrammarMaker.setGrammarOption( optName, optValue);}
|
||||
)*
|
||||
|
||||
RCURLY
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// classTokens
|
||||
// ----------------------------------------------------------------------------
|
||||
classTokens
|
||||
:
|
||||
TOKENS
|
||||
(
|
||||
{
|
||||
tokenName := nil;
|
||||
tokenString := nil;
|
||||
}
|
||||
|
||||
(
|
||||
tokenName: TOKENREF (ASSIGN tokenString:STRINGLIT)?
|
||||
| tokenString: STRINGLIT
|
||||
)
|
||||
|
||||
SEMI
|
||||
{fGrammarMaker.defineToken( tokenName, tokenString);}
|
||||
)*
|
||||
|
||||
RCURLY
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// classMemberDecl
|
||||
// ----------------------------------------------------------------------------
|
||||
classMemberDecl
|
||||
:
|
||||
"memberDecl"
|
||||
memberDecl:ACTION
|
||||
{fGrammarMaker.refMemberDecl(memberDecl);}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// classMemberDef
|
||||
// ----------------------------------------------------------------------------
|
||||
classMemberDef
|
||||
:
|
||||
"memberDef"
|
||||
memberDef:ACTION
|
||||
{fGrammarMaker.refMemberDef(memberDef);}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// rules
|
||||
// ----------------------------------------------------------------------------
|
||||
rules
|
||||
:
|
||||
(rule)*
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// ruleExceptionBlock
|
||||
// ----------------------------------------------------------------------------
|
||||
ruleExceptionBlock
|
||||
:
|
||||
t:"except" a:ACTION { fGrammarMaker.RefRuleExHandler( t, a); }
|
||||
| t:"finally" a:ACTION { fGrammarMaker.RefRuleExHandler( t, a); }
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// ruleExceptionBlock
|
||||
// ----------------------------------------------------------------------------
|
||||
altExceptionBlock
|
||||
:
|
||||
t:"except" a:ACTION { fGrammarMaker.RefAltExHandler( t, a); }
|
||||
| t:"finally" a:ACTION { fGrammarMaker.RefAltExHandler( t, a); }
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// rule
|
||||
// ----------------------------------------------------------------------------
|
||||
rule
|
||||
local
|
||||
{
|
||||
access : AnsiString;
|
||||
ag : integer;
|
||||
returns : IToken;
|
||||
name : IToken;
|
||||
}
|
||||
{
|
||||
access := 'public';
|
||||
args := nil;
|
||||
name := nil;
|
||||
ag := AUTOGEN_NONE;
|
||||
}
|
||||
:
|
||||
// ------------------------------------------------------------
|
||||
// Parse rule scope
|
||||
// ------------------------------------------------------------
|
||||
( "public" { access := 'public'; }
|
||||
| "protected" { access := 'protected'; }
|
||||
| "private" { access := 'private'; }
|
||||
)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Parse rule name
|
||||
// ------------------------------------------------------------
|
||||
name=id
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Parse optional BANG operator
|
||||
// ------------------------------------------------------------
|
||||
// ( BANG { ag := AUTOGEN_BANG;} )?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Optional arguments
|
||||
// ------------------------------------------------------------
|
||||
( args:ARGACTION)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Optional return type
|
||||
// ------------------------------------------------------------
|
||||
( "returns" ret:ARGACTION)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Now start the rule definition
|
||||
// ------------------------------------------------------------
|
||||
{
|
||||
fGrammarMaker.defineRuleName( name, access, true, '');
|
||||
|
||||
if args <> nil then
|
||||
fGrammarMaker.refArgAction( args);
|
||||
|
||||
if ret <> nil then
|
||||
fGrammarMaker.refReturnAction( ret);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Optional rule options
|
||||
// ------------------------------------------------------------
|
||||
(ruleOptions)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Optional rule local variable declarations
|
||||
// ------------------------------------------------------------
|
||||
(
|
||||
"local"
|
||||
locals:ACTION
|
||||
{fGrammarMaker.refRuleLocals( locals);}
|
||||
)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Optional rule init action
|
||||
// ------------------------------------------------------------
|
||||
(
|
||||
initAction:ACTION
|
||||
{fGrammarMaker.refInitAction( initAction);}
|
||||
)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Rule block
|
||||
// ------------------------------------------------------------
|
||||
COLON
|
||||
block
|
||||
SEMI
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Optional exception handler
|
||||
// ------------------------------------------------------------
|
||||
( ruleExceptionBlock)?
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Finish the rule
|
||||
// ------------------------------------------------------------
|
||||
{ fGrammarMaker.endRule('');}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// block
|
||||
// ----------------------------------------------------------------------------
|
||||
block
|
||||
{
|
||||
INC( fNesting);
|
||||
}
|
||||
: alternative (OR alternative)* {DEC(fNesting);}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// alternative
|
||||
// ----------------------------------------------------------------------------
|
||||
alternative
|
||||
local
|
||||
{
|
||||
autoGen : boolean;
|
||||
}
|
||||
{
|
||||
autoGen := true;
|
||||
}
|
||||
:
|
||||
// (BANG {autoGen := false;})?
|
||||
{fGrammarMaker.beginAlt( autoGen);}
|
||||
(elem)*
|
||||
(altExceptionBlock)?
|
||||
{fGrammarMaker.endAlt;}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// elem
|
||||
// ----------------------------------------------------------------------------
|
||||
elem
|
||||
: element
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// element
|
||||
// ----------------------------------------------------------------------------
|
||||
element
|
||||
local
|
||||
{
|
||||
assignId : IToken;
|
||||
assignLabel : IToken;
|
||||
autoGen : integer;
|
||||
}
|
||||
{
|
||||
assignId := nil;
|
||||
assignLabel := nil;
|
||||
autoGen := AUTOGEN_NONE;
|
||||
}
|
||||
:
|
||||
(
|
||||
assignId=id ASSIGN
|
||||
(assignLabel=id COLON {checkEndRule(assignLabel);})?
|
||||
(
|
||||
ruleRef:RULEREF (args:ARGACTION)? (ag:BANG {autoGen := AUTOGEN_BANG;})?
|
||||
{fGrammarMaker.refRule( assignId, ruleRef, assignLabel, args, autoGen);}
|
||||
|
|
||||
tokenRef:TOKENREF (args:ARGACTION)?
|
||||
{fGrammarMaker.refToken( assignId, tokenRef, assignLabel, args, false, autoGen, lastInRule);}
|
||||
)
|
||||
)
|
||||
|
|
||||
(assignLabel=id COLON {checkEndRule(assignLabel);})?
|
||||
(
|
||||
ruleRef:RULEREF (args:ARGACTION)? (ag:BANG {autoGen := AUTOGEN_BANG;})?
|
||||
{fGrammarMaker.refRule( assignId, ruleRef, assignLabel, args, autoGen);}
|
||||
| range[assignLabel]
|
||||
| terminal[assignLabel]
|
||||
| NOT (notTerminal[assignLabel] | ebnf[ assignLabel, true])
|
||||
| ebnf[ assignLabel, false]
|
||||
)
|
||||
|
|
||||
action:ACTION
|
||||
{fGrammarMaker.refAction( action);}
|
||||
|
|
||||
semPred:SEMPRED
|
||||
{fGrammarMaker.refSemPred( semPred);}
|
||||
;
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// range
|
||||
// ----------------------------------------------------------------------------
|
||||
range [pTokenLabel: IToken]
|
||||
local
|
||||
{
|
||||
autoGen: integer;
|
||||
}
|
||||
{
|
||||
autoGen := AUTOGEN_NONE;
|
||||
}
|
||||
:
|
||||
crLeft:CHARLIT
|
||||
RANGE
|
||||
crRight:CHARLIT
|
||||
(BANG {autoGen := AUTOGEN_BANG;} )?
|
||||
{fGrammarMaker.refCharRange( crLeft, crRight, pTokenLabel, autoGen, lastInRule);}
|
||||
|
|
||||
(trLeft:TOKENREF | trLeft:STRINGLIT)
|
||||
RANGE
|
||||
(trRight:TOKENREF | trRight:STRINGLIT)
|
||||
autoGen=astTypeSpec
|
||||
{fGrammarMaker.refTokenRange( trLeft, trRight, pTokenLabel, autoGen, lastInRule);}
|
||||
;
|
||||
// ----------------------------------------------------------------------------
|
||||
// terminal
|
||||
// ----------------------------------------------------------------------------
|
||||
terminal [pTokenLabel: IToken]
|
||||
local
|
||||
{
|
||||
autoGen : integer;
|
||||
}
|
||||
{
|
||||
autoGen := AUTOGEN_NONE;
|
||||
aa := nil;
|
||||
}
|
||||
:
|
||||
cl:CHARLIT
|
||||
(BANG {autoGen := AUTOGEN_BANG;} )?
|
||||
{fGrammarMaker.refCharLiteral( cl, pTokenLabel, false, autoGen, lastInRule);}
|
||||
|
|
||||
tr:TOKENREF
|
||||
autoGen=astTypeSpec
|
||||
(aa:ARGACTION)?
|
||||
{fGrammarMaker.refToken( nil, tr, pTokenLabel, aa, false, autoGen, lastInRule);}
|
||||
|
|
||||
sl:STRINGLIT
|
||||
autoGen=astTypeSpec
|
||||
{fGrammarMaker.refStringLiteral( sl, pTokenLabel, autoGen, lastInRule);}
|
||||
|
|
||||
wc:WILDCARD
|
||||
autogen=astTypeSpec
|
||||
{fGrammarMaker.refWildCard( wc, pTokenLabel, autoGen);}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// notTerminal
|
||||
// ----------------------------------------------------------------------------
|
||||
notTerminal [pTokenLabel: IToken]
|
||||
local
|
||||
{
|
||||
autoGen : integer;
|
||||
}
|
||||
{
|
||||
autoGen := AUTOGEN_NONE;
|
||||
}
|
||||
:
|
||||
cl:CHARLIT
|
||||
(BANG {autoGen := AUTOGEN_BANG;} )?
|
||||
{fGrammarMaker.refCharLiteral( cl, pTokenLabel, true, autoGen, lastInRule);}
|
||||
|
|
||||
tr:TOKENREF
|
||||
autoGen=astTypeSpec
|
||||
{fGrammarMaker.refToken( nil, tr, pTokenLabel, nil, true, autoGen, lastInRule);}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// ebnf
|
||||
// ----------------------------------------------------------------------------
|
||||
ebnf [pTokenLabel: IToken; pTokenNot: boolean]
|
||||
:
|
||||
lp:LPAREN
|
||||
{fGrammarMaker.beginSubrule( pTokenLabel, lp, pTokenNot);}
|
||||
|
||||
(
|
||||
// ---------------------------------------------------------
|
||||
// 2nd alt and optional branch ambig due to linear approx
|
||||
// LL(2) issue. COLON ACTION matched correctly in 2nd alt.
|
||||
// ---------------------------------------------------------
|
||||
options
|
||||
{
|
||||
warnWhenFollowAmbig = false;
|
||||
}
|
||||
:
|
||||
subRuleOptions
|
||||
(aa:ACTION {fGrammarMaker.refInitAction(aa);} )?
|
||||
COLON
|
||||
|
|
||||
aa:ACTION {fGrammarMaker.refInitAction(aa);}
|
||||
COLON
|
||||
)?
|
||||
|
||||
|
||||
block
|
||||
RPAREN
|
||||
|
||||
(
|
||||
( QUEST { fGrammarMaker.optionalSubrule; }
|
||||
| STAR { fGrammarMaker.zeroOrMoreSubrule; }
|
||||
| PLUS { fGrammarMaker.oneOrMoreSubrule; }
|
||||
| AT { fGrammarMaker.nmSubrule; }
|
||||
LPAREN
|
||||
(
|
||||
m:INTEGER { fGrammarMaker.refRangeLow( StrToInt(m.TokenText)); }
|
||||
(
|
||||
COMMA { fGrammarMaker.refRangeHigh( maxint); }
|
||||
(
|
||||
n:INTEGER { fGrammarMaker.refRangeHigh(StrToInt(n.TokenText)); }
|
||||
)?
|
||||
)?
|
||||
|
|
||||
COMMA
|
||||
n:INTEGER { fGrammarMaker.refRangeHigh(StrToInt(n.TokenText)); }
|
||||
)
|
||||
RPAREN
|
||||
| IMPLIES {fGrammarMaker.synPred; }
|
||||
)?
|
||||
|
||||
// ( BANG {fGrammarMaker.noASTSubrule;} )?
|
||||
)
|
||||
|
||||
{fGrammarMaker.endSubRule;}
|
||||
;
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// optionValue
|
||||
// ----------------------------------------------------------------------------
|
||||
optionValue returns [IToken]
|
||||
:
|
||||
result=qualifiedId
|
||||
| result:STRINGLIT
|
||||
| result:CHARLIT
|
||||
| result:INTEGER
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// subruleOptions
|
||||
// ----------------------------------------------------------------------------
|
||||
subruleOptions
|
||||
local
|
||||
{
|
||||
optName : IToken;
|
||||
optValue : IToken;
|
||||
}
|
||||
:
|
||||
OPTIONS
|
||||
(
|
||||
optName = id
|
||||
ASSIGN
|
||||
optValue = optionValue
|
||||
SEMI
|
||||
{fGrammarMaker.setSubruleOption( optName, optValue);}
|
||||
)*
|
||||
|
||||
RCURLY
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// ruleOptions
|
||||
// ----------------------------------------------------------------------------
|
||||
ruleOptions
|
||||
local
|
||||
{
|
||||
optName : IToken;
|
||||
optValue : IToken;
|
||||
}
|
||||
:
|
||||
OPTIONS
|
||||
(
|
||||
optName = id
|
||||
ASSIGN
|
||||
optValue = optionValue
|
||||
SEMI
|
||||
{fGrammarMaker.setRuleOption( optName, optValue);}
|
||||
)*
|
||||
|
||||
RCURLY
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// astTypeSpec
|
||||
// ----------------------------------------------------------------------------
|
||||
astTypeSpec returns [integer]
|
||||
{
|
||||
result := AUTOGEN_NONE;
|
||||
}
|
||||
:
|
||||
(BANG {result := AUTOGEN_BANG;})?
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// qualifiedId
|
||||
// ----------------------------------------------------------------------------
|
||||
qualifiedId returns [IToken]
|
||||
local
|
||||
{
|
||||
buf : AnsiString;
|
||||
a : IToken;
|
||||
}
|
||||
:
|
||||
a=id { buf := a.TokenText; }
|
||||
(
|
||||
WILDCARD a=id { buf := buf + '.' + a.TokenText; }
|
||||
)*
|
||||
{
|
||||
// -----------------------------------------------------------
|
||||
// Can either TOKENREF or RULEREF. Should really create QID or
|
||||
// something else instead.
|
||||
// -----------------------------------------------------------
|
||||
result := TToken.Create( TT_TOKENREF, buf);
|
||||
result.TokenLine := a.TokenLine;
|
||||
result.TokenColumn := a.TokenColumn;
|
||||
}
|
||||
;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// id
|
||||
// ----------------------------------------------------------------------------
|
||||
id returns [IToken]
|
||||
:
|
||||
result:TOKENREF
|
||||
| result:RULEREF
|
||||
;
|
||||
|
||||
memberdef
|
||||
{
|
||||
// ============================================================================
|
||||
// Constructor
|
||||
// ============================================================================
|
||||
constructor TDpgParser.Create( pParserState : IParserState;
|
||||
pGrammarMaker : IGrammarBehavior;
|
||||
pTool : ITool;
|
||||
pExchangeDir : AnsiString);
|
||||
begin
|
||||
inherited Create( pParserState, 2);
|
||||
|
||||
fGrammarMaker := pGrammarMaker;
|
||||
fExchangeDir := pExchangeDir;
|
||||
fTool := pTool;
|
||||
fNesting := 0;
|
||||
end;
|
||||
|
||||
// ============================================================================
|
||||
// Constructor
|
||||
// ============================================================================
|
||||
constructor TDpgParser.Create( pTokenBuffer : ITokenBuffer;
|
||||
pGrammarMaker : IGrammarBehavior;
|
||||
pTool : ITool;
|
||||
pExchangeDir : AnsiString);
|
||||
begin
|
||||
inherited Create( pTokenBuffer, 2);
|
||||
|
||||
fGrammarMaker := pGrammarMaker;
|
||||
fExchangeDir := pExchangeDir;
|
||||
fTool := pTool;
|
||||
fNesting := 0;
|
||||
end;
|
||||
|
||||
// ============================================================================
|
||||
// Constructor
|
||||
// ============================================================================
|
||||
constructor TDpgParser.Create( pTokenStream : ITokenStream;
|
||||
pGrammarMaker : IGrammarBehavior;
|
||||
pTool : ITool;
|
||||
pExchangeDir : AnsiString);
|
||||
begin
|
||||
inherited Create( pTokenStream, 2);
|
||||
|
||||
fGrammarMaker := pGrammarMaker;
|
||||
fExchangeDir := pExchangeDir;
|
||||
fTool := pTool;
|
||||
fNesting := 0;
|
||||
end;
|
||||
|
||||
// ============================================================================
|
||||
// Destructor
|
||||
// ============================================================================
|
||||
destructor TDpgParser.Destroy;
|
||||
begin
|
||||
fGrammarMaker := nil;
|
||||
fTool := nil;
|
||||
|
||||
inherited;
|
||||
end;
|
||||
|
||||
// ============================================================================
|
||||
// lastInRule
|
||||
// ============================================================================
|
||||
function TDpgParser.lastInRule: boolean;
|
||||
begin
|
||||
if (fNesting = 0) and (LA(1) in [TT_SEMI, TT_OR])
|
||||
then result := true
|
||||
else result := false;
|
||||
end;
|
||||
|
||||
// ============================================================================
|
||||
// checkEndRule
|
||||
// ============================================================================
|
||||
procedure TDpgParser.checkEndRule( pToken: IToken);
|
||||
begin
|
||||
if pToken <> nil then
|
||||
if pToken.TokenColumn = 1 then
|
||||
fTool.Warning('Did you forget to close the previous rule?',
|
||||
InputState.FileName,
|
||||
pToken.TokenLine,
|
||||
pToken.TokenColumn);
|
||||
end;
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,72 @@
|
||||
// ============================================================================
|
||||
// This file is generated by the Delphi Parser Generator.
|
||||
// ----------------------------------------------------------------------------
|
||||
// DPG version: 2.0.1.0r
|
||||
// Grammar: lexer.g
|
||||
// ============================================================================
|
||||
unit dpglib.DpgLexerTokens;
|
||||
|
||||
interface
|
||||
|
||||
const
|
||||
TT_EOF = 1;
|
||||
LT_unit = 4;
|
||||
LT_uses = 5;
|
||||
LT_const = 6;
|
||||
LT_type = 7;
|
||||
LT_lexer = 8;
|
||||
LT_parser = 9;
|
||||
LT_options = 10;
|
||||
LT_tokens = 11;
|
||||
LT_memberdecl = 12;
|
||||
LT_memberdef = 13;
|
||||
LT_private = 14;
|
||||
LT_protected = 15;
|
||||
LT_public = 16;
|
||||
LT_returns = 17;
|
||||
LT_local = 18;
|
||||
LT_except = 19;
|
||||
LT_finally = 20;
|
||||
TT_SEMPRED = 21;
|
||||
TT_USES = 22;
|
||||
TT_OPTIONS = 23;
|
||||
TT_TOKENS = 24;
|
||||
TT_LPAREN = 25;
|
||||
TT_RPAREN = 26;
|
||||
TT_RCURLY = 27;
|
||||
TT_COLON = 28;
|
||||
TT_SEMI = 29;
|
||||
TT_COMMA = 30;
|
||||
TT_ASSIGN = 31;
|
||||
TT_IMPLIES = 32;
|
||||
TT_QUEST = 33;
|
||||
TT_PLUS = 34;
|
||||
TT_STAR = 35;
|
||||
TT_AT = 36;
|
||||
TT_NOT = 37;
|
||||
TT_OR = 38;
|
||||
TT_BANG = 39;
|
||||
TT_WILDCARD = 40;
|
||||
TT_RANGE = 41;
|
||||
TT_CHARLIT = 42;
|
||||
TT_STRINGLIT = 43;
|
||||
TT_INTEGER = 44;
|
||||
TT_ARGACTION = 45;
|
||||
TT_ACTION = 46;
|
||||
TT_TOKENREF = 47;
|
||||
TT_RULEREF = 48;
|
||||
TT_INT_RULEREF = 49;
|
||||
TT_COMMENT = 50;
|
||||
TT_SLCOMMENT = 51;
|
||||
TT_MLCOMMENT1 = 52;
|
||||
TT_MLCOMMENT2 = 53;
|
||||
TT_DNUMBER = 54;
|
||||
TT_XNUMBER = 55;
|
||||
TT_DDIGIT = 56;
|
||||
TT_XDIGIT = 57;
|
||||
TT_WS = 58;
|
||||
TT_WS_LOOP = 59;
|
||||
TT_ESC = 60;
|
||||
|
||||
implementation
|
||||
end.
|
||||
@@ -0,0 +1,60 @@
|
||||
// $Delphi Parser Generator: lexer.g -> lexer.gTokens.txt$
|
||||
TDpgLexer
|
||||
TT_EOF=1
|
||||
LT_unit="unit"=4
|
||||
LT_uses="uses"=5
|
||||
LT_const="const"=6
|
||||
LT_type="type"=7
|
||||
LT_lexer="lexer"=8
|
||||
LT_parser="parser"=9
|
||||
LT_options="options"=10
|
||||
LT_tokens="tokens"=11
|
||||
LT_memberdecl="memberdecl"=12
|
||||
LT_memberdef="memberdef"=13
|
||||
LT_private="private"=14
|
||||
LT_protected="protected"=15
|
||||
LT_public="public"=16
|
||||
LT_returns="returns"=17
|
||||
LT_local="local"=18
|
||||
LT_except="except"=19
|
||||
LT_finally="finally"=20
|
||||
TT_SEMPRED=21
|
||||
TT_USES=22
|
||||
TT_OPTIONS=23
|
||||
TT_TOKENS=24
|
||||
TT_LPAREN=25
|
||||
TT_RPAREN=26
|
||||
TT_RCURLY=27
|
||||
TT_COLON=28
|
||||
TT_SEMI=29
|
||||
TT_COMMA=30
|
||||
TT_ASSIGN=31
|
||||
TT_IMPLIES=32
|
||||
TT_QUEST=33
|
||||
TT_PLUS=34
|
||||
TT_STAR=35
|
||||
TT_AT=36
|
||||
TT_NOT=37
|
||||
TT_OR=38
|
||||
TT_BANG=39
|
||||
TT_WILDCARD=40
|
||||
TT_RANGE=41
|
||||
TT_CHARLIT=42
|
||||
TT_STRINGLIT=43
|
||||
TT_INTEGER=44
|
||||
TT_ARGACTION=45
|
||||
TT_ACTION=46
|
||||
TT_TOKENREF=47
|
||||
TT_RULEREF=48
|
||||
TT_INT_RULEREF=49
|
||||
TT_COMMENT=50
|
||||
TT_SLCOMMENT=51
|
||||
TT_MLCOMMENT1=52
|
||||
TT_MLCOMMENT2=53
|
||||
TT_DNUMBER=54
|
||||
TT_XNUMBER=55
|
||||
TT_DDIGIT=56
|
||||
TT_XDIGIT=57
|
||||
TT_WS=58
|
||||
TT_WS_LOOP=59
|
||||
TT_ESC=60
|
||||
Reference in New Issue
Block a user