मैं सबसे आसान तरीका क्या इसे संभाल करने के लिए पता नहीं है है टोकन, लेकिन अगले एक अपेक्षाकृत आसान तरीका है। जब भी आप अपने लेक्सर में लाइन ब्रेक से मेल खाते हैं, वैकल्पिक रूप से एक या अधिक रिक्त स्थान से मेल खाते हैं। यदि लाइन ब्रेक के बाद रिक्त स्थान हैं, तो मौजूदा रिक्त स्थान के साथ इन रिक्त स्थान की लंबाई की तुलना करें। यदि यह वर्तमान इंडेंट आकार से अधिक है, तो Indent टोकन उत्सर्जित करें, यदि यह वर्तमान इंडेंट-साइज से कम है, तो Dedent टोकन उत्सर्जित करें और यदि यह वही है, तो कुछ भी न करें।
आप फ़ाइल के अंत में Dedent टोकन को भी छोड़ना चाहते हैं ताकि प्रत्येक Indent मिलान Dedent टोकन हो।
इस ठीक से काम करने के लिए, आपचाहिए अपने इनपुट स्रोत फ़ाइल के लिए एक प्रमुख और अनुगामी लाइन ब्रेक जोड़ने!
ANTRL3
एक त्वरित प्रदर्शन:
grammar PyEsque;
options {
output=AST;
}
tokens {
BLOCK;
}
@lexer::members {
private int previousIndents = -1;
private int indentLevel = 0;
java.util.Queue<Token> tokens = new java.util.LinkedList<Token>();
@Override
public void emit(Token t) {
state.token = t;
tokens.offer(t);
}
@Override
public Token nextToken() {
super.nextToken();
return tokens.isEmpty() ? Token.EOF_TOKEN : tokens.poll();
}
private void jump(int ttype) {
indentLevel += (ttype == Dedent ? -1 : 1);
emit(new CommonToken(ttype, "level=" + indentLevel));
}
}
parse
: block EOF -> block
;
block
: Indent block_atoms Dedent -> ^(BLOCK block_atoms)
;
block_atoms
: (Id | block)+
;
NewLine
: NL SP?
{
int n = $SP.text == null ? 0 : $SP.text.length();
if(n > previousIndents) {
jump(Indent);
previousIndents = n;
}
else if(n < previousIndents) {
jump(Dedent);
previousIndents = n;
}
else if(input.LA(1) == EOF) {
while(indentLevel > 0) {
jump(Dedent);
}
}
else {
skip();
}
}
;
Id
: ('a'..'z' | 'A'..'Z')+
;
SpaceChars
: SP {skip();}
;
fragment NL : '\r'? '\n' | '\r';
fragment SP : (' ' | '\t')+;
fragment Indent : ;
fragment Dedent : ;
आप वर्ग के साथ पार्सर का परीक्षण कर सकते हैं:
import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;
import org.antlr.stringtemplate.*;
public class Main {
public static void main(String[] args) throws Exception {
PyEsqueLexer lexer = new PyEsqueLexer(new ANTLRFileStream("in.txt"));
PyEsqueParser parser = new PyEsqueParser(new CommonTokenStream(lexer));
CommonTree tree = (CommonTree)parser.parse().getTree();
DOTTreeGenerator gen = new DOTTreeGenerator();
StringTemplate st = gen.toDOT(tree);
System.out.println(st);
}
}
आप अब in.txt नामक एक फ़ाइल में निम्न डाल दिया:
AAA AAAAA
BBB BB B
BB BBBBB BB
CCCCCC C CC
BB BBBBBB
C CCC
DDD DD D
DDD D DDD
(अग्रणी और पिछली लाइन ब्रेक नोट करें!(2 dedent
नोट है कि मेरे प्रदर्शन लगातार पर्याप्त dedents का उत्पादन नहीं होता है, ccc से aaa को dedenting की तरह:)
तो आप उत्पादन जो निम्न एएसटी से मेल खाती है देखेंगे टोकन की आवश्यकता होती है):
aaa
bbb
ccc
aaa
आप संभवतः 1 से अधिक dedent टोकन बस फेंकना else if(n < previousIndents) { ... } अंदर कोड को समायोजित करने की आवश्यकता होगी n और previousIndents के बीच अंतर पर एड करें। मेरे सिर के ऊपर से, कि ऐसा दिखाई दे सकता:
else if(n < previousIndents) {
// Note: assuming indent-size is 2. Jumping from previousIndents=6
// to n=2 will result in emitting 2 `Dedent` tokens
int numDedents = (previousIndents - n)/2;
while(numDedents-- > 0) {
jump(Dedent);
}
previousIndents = n;
}
ANTLR4
ANTLR4 के लिए, कुछ इस तरह करते हैं:
grammar Python3;
tokens { INDENT, DEDENT }
@lexer::members {
// A queue where extra tokens are pushed on (see the NEWLINE lexer rule).
private java.util.LinkedList<Token> tokens = new java.util.LinkedList<>();
// The stack that keeps track of the indentation level.
private java.util.Stack<Integer> indents = new java.util.Stack<>();
// The amount of opened braces, brackets and parenthesis.
private int opened = 0;
// The most recently produced token.
private Token lastToken = null;
@Override
public void emit(Token t) {
super.setToken(t);
tokens.offer(t);
}
@Override
public Token nextToken() {
// Check if the end-of-file is ahead and there are still some DEDENTS expected.
if (_input.LA(1) == EOF && !this.indents.isEmpty()) {
// Remove any trailing EOF tokens from our buffer.
for (int i = tokens.size() - 1; i >= 0; i--) {
if (tokens.get(i).getType() == EOF) {
tokens.remove(i);
}
}
// First emit an extra line break that serves as the end of the statement.
this.emit(commonToken(Python3Parser.NEWLINE, "\n"));
// Now emit as much DEDENT tokens as needed.
while (!indents.isEmpty()) {
this.emit(createDedent());
indents.pop();
}
// Put the EOF back on the token stream.
this.emit(commonToken(Python3Parser.EOF, "<EOF>"));
}
Token next = super.nextToken();
if (next.getChannel() == Token.DEFAULT_CHANNEL) {
// Keep track of the last token on the default channel.
this.lastToken = next;
}
return tokens.isEmpty() ? next : tokens.poll();
}
private Token createDedent() {
CommonToken dedent = commonToken(Python3Parser.DEDENT, "");
dedent.setLine(this.lastToken.getLine());
return dedent;
}
private CommonToken commonToken(int type, String text) {
int stop = this.getCharIndex() - 1;
int start = text.isEmpty() ? stop : stop - text.length() + 1;
return new CommonToken(this._tokenFactorySourcePair, type, DEFAULT_TOKEN_CHANNEL, start, stop);
}
// Calculates the indentation of the provided spaces, taking the
// following rules into account:
//
// "Tabs are replaced (from left to right) by one to eight spaces
// such that the total number of characters up to and including
// the replacement is a multiple of eight [...]"
//
// -- https://docs.python.org/3.1/reference/lexical_analysis.html#indentation
static int getIndentationCount(String spaces) {
int count = 0;
for (char ch : spaces.toCharArray()) {
switch (ch) {
case '\t':
count += 8 - (count % 8);
break;
default:
// A normal space char.
count++;
}
}
return count;
}
boolean atStartOfInput() {
return super.getCharPositionInLine() == 0 && super.getLine() == 1;
}
}
single_input
: NEWLINE
| simple_stmt
| compound_stmt NEWLINE
;
// more parser rules
NEWLINE
: ({atStartOfInput()}? SPACES
| ('\r'? '\n' | '\r') SPACES?
)
{
String newLine = getText().replaceAll("[^\r\n]+", "");
String spaces = getText().replaceAll("[\r\n]+", "");
int next = _input.LA(1);
if (opened > 0 || next == '\r' || next == '\n' || next == '#') {
// If we're inside a list or on a blank line, ignore all indents,
// dedents and line breaks.
skip();
}
else {
emit(commonToken(NEWLINE, newLine));
int indent = getIndentationCount(spaces);
int previous = indents.isEmpty() ? 0 : indents.peek();
if (indent == previous) {
// skip indents of the same size as the present indent-size
skip();
}
else if (indent > previous) {
indents.push(indent);
emit(commonToken(Python3Parser.INDENT, spaces));
}
else {
// Possibly emit more than 1 DEDENT token.
while(!indents.isEmpty() && indents.peek() > indent) {
this.emit(createDedent());
indents.pop();
}
}
}
}
;
// more lexer rules
लिया से: https://github.com/antlr/grammars-v4/blob/master/python3/Python3.g4
Thanx, यह काम करता है :) – Astronavigator
आपका स्वागत है @Astronavigator। –
हाय @ बार्ट कियर्स, मैं अग्रणी और पिछली लाइनब्रेक्स सीमा को कैसे दूर कर सकता हूं? मैंने पार्सिंग शुरू करने से पहले इसे इंडेंट टोकन प्रोग्रामेटिक रूप से उत्सर्जित करने की कोशिश की, लेकिन कोई भाग्य नहीं। – ains