Pegjs: 들여쓰기 기반 언어의 구문 분석 지원

들여쓰기 기반 문법을 구문 분석하기 위해 사용자 정의 처리기에 추가하는 부작용에 의존하는 것은 매우 위험합니다. 그냥 하지 마세요. Pegjs는 구문 분석 들여쓰기(및 기타 상황에 맞는 문법)를 안전하게 만들기 위해 조건부 상태를 푸시하고 팝하는 기능을 추가해야 합니다.

이것이 내가 지금 하는 일이며 다음과 같이 하는 것이 좋습니다. 입력 파일을 사전 처리하고 고유한 들여쓰기/내어쓰기 토큰을 삽입합니다. 저는 각각 {{{{ 및 }}}}를 사용합니다. 그러면 문법이 컨텍스트가 없고 정상적으로 구문 분석될 수 있습니다. 행/열 값을 엉망으로 만들 수 있지만 후처리기에서 수정할 수 있습니다.

자바스크립트를 대상으로 할 필요가 없다면 C#용 내 pegjs 클론인 Pegasus 가 푸시/팝핑 상태를 지원합니다. 다음은 원하는 작업을 정확히 수행하는 방법에 대한 위키 문서입니다. https://github.com/otac0n/Pegasus/wiki/Significant-Whitespace-Parsing

pegjs가 내 구문을 상태 기반 구문 분석의 시작점으로 사용하도록 제안하고 싶습니다.

안전하게 밀고 터지는 능력이 좋다. Javascript 기반이라면 그것을 사용할 것입니다. 구문 분석을 위해 CLR을 통합할 가치가 없습니다.

그게 내가 생각한거야. 이 경우 개선 사항을 pegjs로 백포트해야 한다고 생각합니다.

그러나 @dmajda와 대화하지 않고 반드시 그렇게 하고 싶지는 않습니다.

@otac0n 반갑습니다. 나는 C#을 쓰지 않는다. JavaScript가 저에게 훨씬 좋습니다.

들여쓰기 기반 언어가 중요합니다. 1.0.0 이후의 구문 분석을 단순화하는 방법을 살펴보고 싶습니다.

이 문제는 Pegasus가 #285에서 제안한 것처럼 일반적으로 상태를 허용함으로써 가장 잘 해결될 수 있다고 생각합니다. 여기 아이디어가 있습니다(다음은 pegjs로 번역되고 내 구문 아이디어가 추가된 Pegasus의 중요한 공백 문법입니다):

{var indentation = 0}

program
  = s:statements eof { return s }

statements
  = line+

line
  = INDENTATION s:statement { return s }

statement
  = s:simpleStatement eol { return s }
  / "if" _ n:name _? ":" eol INDENT !"bar " s:statements UNDENT {
      return { condition: n, statements: s }
    }
  / "def" _ n:name _? ":" eol INDENT s:statements UNDENT {
      return { name: n, statements: s }
    }

simpleStatement
  = a:name _? "=" _? b:name { return { lValue: a, expression: b } }

name
  = [a-zA-Z] [a-zA-Z0-9]* { return text() }

_ = [ \t]+

eol = _? comment? ("\r\n" / "\n\r" / "\r" / "\n" / eof)

comment = "//" [^\r\n]*

eof = !.

INDENTATION
  = spaces:" "* &{ return spaces.length == indentation }

INDENT
  = #STATE{indentation}{ indentation += 4 }

UNDENT
  = #STATE{indentation}{ indentation -= 4 }

바닥 근처의 #STATE{indentation} 블록에 주목하십시오(페가수스에서 영감을 받은 것이 분명함). 나는 그 상태 블록을 호출합니다. 아이디어는 작업 전에 상태 차단을 허용하는 것입니다. 다음은 더 복잡한 상태 블록입니다.

#STATE{a, b, arr: {arr.slice()}, obj: {shallowCopy(obj)}, c}

다음의 줄임말입니다.

#STATE{a: {a}, b: {b}, arr: {arr.slice()}, obj: {shallowCopy(obj)}, c: {c}}

즉, 속기 확장이 적용된 후 상태 블록의 내용은 identifier ":" "{" code "}" 목록입니다. 작업 앞에 상태 블록을 추가하면 pegjs에 이 작업이 나열된 식별자를 수정하고 규칙이 역추적되면 해당 식별자가 중괄호 사이의 코드로 재설정되어야 한다고 알려줍니다.

indentation 변수 재설정이 추가된 위의 문법에서 INDENT 및 UNDENT에 대해 컴파일된 함수는 다음과 같습니다.

    function peg$parseINDENT() {
      var s0, s1, t0;

      s0 = peg$currPos;
      t0 = indentation;
      s1 = [];
      if (s1 !== peg$FAILED) {
        peg$reportedPos = s0;
        s1 = peg$c41();
      } else {
        indentation = t0;
      }
      s0 = s1;

      return s0;
    }

    function peg$parseUNDENT() {
      var s0, s1, t0;

      s0 = peg$currPos;
      t0 = indentation;
      s1 = [];
      if (s1 !== peg$FAILED) {
        peg$reportedPos = s0;
        s1 = peg$c42();
      } else {
        indentation = t0;
      }
      s0 = s1;

      return s0;
    }

그리고 다음은 위의 "복잡한 상태 블록"을 컴파일할 수 있는 방법입니다.

s0 = peg$currPos;
t0 = a;
t1 = b;
t2 = arr.slice();
t3 = shallowCopy(obj);
t4 = c;
// ...
if (s1 !== peg$FAILED) {
  // ...
} else {
  peg$currPos = s0;
  a = t0;
  b = t1;
  arr = t2;
  obj = t3;
  c = t4;
}

다음을 할 수 있다는 아이디어에 대해 어떻게 생각하세요?

• 작업에 의해 수정될 상태 저장 변수에 대해 pegjs에 알립니다.
• 재설정해야 하는 경우 해당 변수를 저장하는 데 필요한 코드를 제공합니다. (변수가 기본 값인 간단한 경우에 대한 약식 구문 포함)

그리고 구문에 대해 어떻게 생각하십니까?

편집: 다음은 제안된 구문 문법입니다(재미로):

diff --git a/src/parser.pegjs b/src/parser.pegjs
index 08f6c4f..09e079f 100644
--- a/src/parser.pegjs
+++ b/src/parser.pegjs
@@ -116,12 +116,31 @@ ChoiceExpression
     }

 ActionExpression
-  = expression:SequenceExpression code:(__ CodeBlock)? {
+  = expression:SequenceExpression code:((__ StateBlock)? __ CodeBlock)? {
       return code !== null
-        ? { type: "action", expression: expression, code: code[1] }
+        ? {
+            type:       "action",
+            expression: expression,
+            code:       code[2],
+            stateVars:  (code[0] !== null ? code[0][1] : [])
+          }
         : expression;
     }

+StateBlock "state block"
+  = "#STATE{" __ first:StateBlockItem rest:(__ "," __ StateBlockItem)* __ "}" {
+      return buildList(first, rest, 3);
+    }
+
+StateBlockItem
+  = varName:Identifier expression:(__ ":" __ CodeBlock)? {
+      return {
+        type:       "stateVar",
+        name:       varName,
+        expression: expression !== null ? expression[3] : varName
+      };
+    }
+
 SequenceExpression
   = first:LabeledExpression rest:(__ LabeledExpression)* {
       return rest.length > 0

안녕하세요 여러분,
명확히 하자면, 이 문제가 종료될 때까지 들여쓰기 기반 언어와 함께 PEG.js(이 문제의 상단에서 해결 방법 포함)를 사용하지 않는 것이 더 낫다는 것이 맞습니까?
감사 해요.

@hoho 나는 당신에게 의미가 없습니다. 하지만 나중에 솔루션 과 결합기로 들여쓰기 를

내 말은 들여쓰기를 구문 분석하는 해결 방법이 있지만 의견에 따르면 이러한 해결 방법은 특정 경우에 실패할 수 있습니다.

상황을 명확히 하겠습니다. PEG.js에서 들여쓰기 기반 언어를 구문 분석하는 것이 가능합니다. 위에서 언급한 다양한 솔루션이 있으며 이에 대한 "느낌"을 얻으려고 할 때 다른 솔루션을 만들었습니다(예: if 와 유사한 들여쓰기된 하위 명령문을 포함할 수 있는 두 개의 명령문이 있는 간단한 언어의 문법입니다

모든 솔루션에 공통적인 한 가지는 들여쓰기 상태를 수동으로 추적해야 한다는 것입니다(PEG.js는 그렇게 할 수 없기 때문에). 이는 두 가지 제한 사항이 있음을 의미합니다.

1. 캐싱으로 문법을 안전하게 컴파일할 수 없습니다(파서가 상태 조작 코드를 실행하는 대신 캐시된 결과를 사용할 수 있기 때문입니다).
2. 들여쓰기 수준에서 역추적할 수 없습니다(현재 역추적할 때 상태를 해제할 방법이 없기 때문에). 즉, 개행 및 들여쓰기 수준 변경 후에만 명확하게 할 수 있는 두 개의 유효한 구문이 있는 언어를 구문 분석할 수 없습니다.

제한 1은 경우에 따라 성능 문제를 일으킬 수 있지만 제한 2가 문제가 되는 언어는 많지 않다고 생각합니다.

나는 1.0.0까지는 이 상태에 만족하고 나중에 언젠가 이 주제로 돌아갈 계획입니다. 개선의 첫 번째 수준은 보다 명시적인 상태 추적(위에서 제안한 대로)을 사용하거나 역추적 후크를 제공하여(상태를 올바르게 해제할 수 있도록) 제한 2를 제거하는 것입니다. 두 번째 수준은 몇 가지 선언적 방법을 제공하여 들여쓰기 상태를 수동으로 추적할 필요성을 제거할 수 있습니다. 이것은 제한 사항 1에 도움이 될 수 있습니다.

H, 여기에 설명된 대로 적절한 역추적을 지원하는 PEG.js용 (작고 해킹된) 패치를 작성했습니다. https://github.com/pegjs/pegjs/issues/45

범프 죄송합니다 😜

저는 디자인 중인 언어에 대한 CSON 및 YAML 파서를 만드는 방법을 찾고 있었는데 PEG.js를 사용하여 들여쓰기 기반 파서를 만드는 방법을 찾는 동안 다음과 같은 간단한 방법을 생각해냈습니다.

1) 푸시/팝 상태에 의존하지 않음
2) 작업 내 코드를 통해 들여쓰기 수준 주장

위의 두 가지 솔루션 중 하나가 실제로 생성된 파서에 성능 문제를 추가한다는 생각이 들었습니다. 추가로 제 생각에는:

1) 상태에 의존하면 못생긴 PEG.js 구문이 추가될 뿐만 아니라 작업 기반 상태 처리를 지원해야 하므로 생성할 수 있는 파서 유형에 영향을 줄 수 있습니다.
2) 때때로 액션에 일부 코드를 추가하면 언어 종속 규칙이 생성되며, 일부 개발자의 경우 규칙에 대한 액션을 처리하기 위해 더 많은 플러그인에 의존하지 않고는 플러그인을 사용하여 C 또는 PHP와 같은 다른 언어용 파서를 생성할 수 없음을 의미합니다. 1 또는 2개의 변경 사항을 지원하기 위한 더 큰 빌드 시스템을 의미합니다.

잠시 후 나는 PEG.js 파서의 변형을 만들기 시작했고 생각했습니다. 증가("++") 및 감소("--") 접두사 연산자(__++ expression__ 및 __-- expression__ ) 일치 표현식(__expression *__ 또는 __expression +__)의 결과를 처리합니다.

다음은 @dmajda의 기반으로 예를 들어 문법이다 간단한 intentation 기반 언어 를 사용하기 위해 다시 작성, 새로운 __ ++ expression__ 및 __-- expression__ 대신 __ & {조건} __ :

Start
  = Statements

Statements
  = Statement*

Statement
  = Indent* statement:(S / I) { return statement; }

S
  = "S" EOS {
      return "S";
    }

I
  = "I" EOL ++Indent statements:Statements --Indent { return statements; }
  / "I" EOS { return []; }

Indent "indent"
  = "\t"
 / !__ "  "

__ "white space"
 = " \t"
 / " "

EOS
  = EOL
  / EOF

EOL
  = "\n"

EOF
  = !.

훨씬 눈이 즐겁죠? 인간과 소프트웨어 모두 이해하기 쉽습니다.

어떻게 작동합니까? 단순한:

1) Indent* 는 파서에게 Indent 가 반환하는 것 중 0개 이상을 원한다고 알려줍니다.
2) ++Indent 는 파서에게 Indent 필요한 최소 일치 수를 늘리도록 지시합니다.
3) 이제 파서는 Indent 대한 일치 항목을 반환하려고 할 때마다 먼저 이전보다 __1개 더__ 일치할 것으로 예상하고, 그렇지 않으면 _peg$SyntaxError_가 발생합니다.
4) --Indent 는 파서에게 Indent 필요한 최소 일치 수를 줄이도록 지시합니다.
5) 이제 파서가 Indent 찾고 이전보다 __1개 적은__ 일치할 것으로 예상하는 일치 항목을 반환할 때마다, 그렇지 않으면 _peg$SyntaxError_가 발생합니다.

이 솔루션은 PEG.js 문법에 추악한 구문을 추가하거나 타사 생성기를 차단하지 않고 '중요한 공백 구문 분석'에 대한 지원을 추가하는 가장 좋은 방법입니다.

다음은 _src/parser.pegjs_에서 구문 분석 지원을 추가하기 위해 변경된 규칙입니다.

{
  const OPS_TO_PREFIXED_TYPES = {
    "$": "text",
    "&": "simple_and",
    "!": "simple_not",
    "++": "increment_match",
    "--": "decrement_match"
  };
}

PrefixedOperator
  = "$"
  / "&"
  / "!"
  / "++"
  / "--"

SuffixedOperator
  = "?"
  / "*"
  / "+" !"+"

컴파일러/생성기 쪽을 지원하려면 다음을 수행해야 한다고 가정하는 것이 맞습니까?

1) __++ expression__ 또는 __-- expression__이 __expression *__ 또는 __expression +__에서만 사용되도록 하는 컴파일러 패스를 추가합니다. 여기서 __expression__은 선택, 시퀀스 또는 규칙_ref 유형이어야 합니다.
2) 일치 항목을 반환하기 전에 필요한 최소 일치 항목이 충족되었는지 확인하는 __expression *__ 또는 __expression +__에 대해 생성된 파서에 캐시 기반 검사를 추가합니다.
3) 주어진 규칙에 필요한 일치 수를 반환하는 구현하기 위해 생성된 파서에 대한 도우미 메서드를 선택적으로 추가합니다. nMatches( name: String ): Number

@futagoza , 이것은 깨끗하고 영리합니다. 좋아요. 저는 상태를 처리하는 파서에서 작업하고 있지만 실제로 필요한 유일한 상태는 들여쓰기 수준입니다. 나는 이 아이디어를 사용하고 당신에게 그것에 대한 크레딧을 줄 수 있습니다. 들여쓰기 수준을 추적하려면 여전히 효과적으로 푸시/팝핑 상태가 필요하므로 일부 최적화를 방지할 수 있지만 이것의 의미는 매우 좋습니다.

문법에 연산자를 추가하는 경우 @ 접두사 연산자도 추가하는 것이 좋습니다. 그 목적은 단순히 시퀀스에서 단일 규칙 결과를 추출하는 것입니다. 이를 사용하면 샘플 문법이 더욱 깔끔해집니다. 더 이상 사소한 { return x } 작업이 없습니다.

Start
  = Statements

Statements
  = Statement*

Statement
  = Indent* @(S / I)

S
  = "S" EOS {
      return "S";
    }

I
  = "I" EOL ++Indent <strong i="8">@Statements</strong> --Indent
  / "I" EOS { return []; }

Indent "indent"
  = "\t"
 / !__ "  "

__ "white space"
 = " \t"
 / " "

EOS
  = EOL
  / EOF

EOL
  = "\n"

EOF
  = !.

@kodyjking 이거 어떻게 생각하세요?

@futagoza 들여쓰기 패치가 활성화된 포크/분기와 작은 샘플 문법이 있습니까?

이 포크/분기 들여쓰기 작업 중입니다.

@krinye " @ 접두사 연산자도 추가하는 것이 좋습니다. 그 목적은 단순히 시퀀스에서 단일 규칙 결과를 추출하는 것입니다."

여러분 중 한 명이 보고 수정 사항에 대해 의견을 말하거나 PR을 할 수 있습니까? 감사 해요 :)

읽어보기: 포크 변경 사항

디버깅했습니다... increment_match-not-found

아, 주의 사항을 눈치채지 못했습니다.

컴파일러/생성기 쪽을 지원하려면 다음을 수행해야 한다고 가정하는 것이 맞습니까?

• ++ 표현식 또는 -- 표현식이 표현식 * 또는 표현식 +에서만 사용되도록 하는 컴파일러 패스를 추가합니다. 여기서 표현식은 선택, 시퀀스 또는 규칙_ref 유형이어야 합니다.
• 일치 항목을 반환하기 전에 필요한 최소 일치 항목이 충족되었는지 확인하는 표현식 * 또는 표현식 +에 대해 생성된 파서에 캐시 기반 검사를 추가합니다.
• 선택적으로 주어진 규칙에 필요한 일치 수를 반환하는 구현하기 위해 생성된 파서에 대한 도우미 메서드를 추가합니다. nMatches(이름: 문자열): 숫자

그냥 킥을 위해 visitor.js 추가하려고 했습니다.

      increment_match: visitExpression,
      decrement_match: visitExpression,

이제 Invalid opcode: undefined. 받습니다.

시퀀스에서 단일 값을 추출하는 @ 연산자와 관련된 @kristianmandrup , 여기에서 사용할 수 있는 PegJS에 해당 기능이 추가된 포크가 있습니다.

https://github.com/krisnye/pegjs

아주 간단한 추가 기능입니다.

@krisnye +1 문법 기반 구현, 훌륭하고 간단합니다. 괜찮으시다면 PEG.js 변형에 이것을 추가하겠습니다 😄

@kristianmandrup 당신이 내 제안에 대한 커밋을 참조하십시오

@futagoza 해주세요.

나는 동료와 들여쓰기 논리에 대해 논의하고 있었고 다음과 같은 구문 요소를 제안합니다.

// 명명된 상태 변수를 증가시킵니다.
식별자++
// 명명된 상태 변수를 감소시킵니다.
식별자--

// 일정한 양 또는 상태 변수를 반복합니다(변수가 아직 증가하지 않은 경우 기본값은 0).
규칙{정수 | 식별자}
// 상수 또는 상태 변수를 사용하여 최소/최대 반복
규칙{정수 | 식별자, 정수 | 식별자}

우리가 작업하고 있는 파서는 임의의 상태를 처리할 수 있지만 솔직히 위의 내용은 들여쓰기 파싱에 필요한 전부입니다.

고마워요! 그렇게 하기 쉽다면 언급한 것이 "그냥 작동"하는 "전용" 포크를 만드십시오. ;)
건배!

@krisnye

1. __identifier++__를 사용하면 개발자가 __identifier+__를 의미하는 경우 쉽게 지저분한 오류가 발생할 수 있습니다. 그래서 __++identifier__와 일관성을 위해 __--identifier__를 선택했습니다.
2. 범위에 대한 다른 문제에서 언급했듯이 rule{ STATE_REPEAT / RANGE } 는 rule{ ACTION } 와 혼동될 수 있습니다. 특히 PEG.js용 구문 형광펜을 구축하는 경우 이 접근 방식은 @dmajda 에서 거부되었습니다

@kristianmandrup _(OFF TOPIC)_ 저는 기능을 설계하고 때로는 구현을 하는 데 능숙하지만 테스트 및 벤치마킹에는 끔찍합니다. 그래서 일반적으로 내 PC의 private non-repo 디렉토리에 작업 변형(테스트 또는 벤치마크 없이)을 만듭니다. , 그리고 그것들을 잊어버리세요 🤣. PEG.js의 현재 변형(ePEG.js 😝, PEG.js의 확장된 재작성)의 경우 여기에 언급된 항목과 다른 기능(범위, 가져오기, 템플릿 등)을 추가하고 있으므로 추가하고 있습니다. 테스트 및 벤치마크, 하지만 현재 시간이 걸리는 C++ 프로젝트도 진행 중이므로 ETA가 없습니다.

@futagoza 감사합니다 메이트 :) 기능 확장을 살펴보고 있지만 들여쓰기 지원은 언급하지 않습니다. 포함되어 있지만 문서화되지 않았거나 앞으로 나올 예정입니까?

이 목록의 다른 누군가가 내가 조사할 수 있는 다른 파서 빌더/생성기 솔루션을 알려 주었습니다. 계속 알려주세요! 건배!

@kristianmandrup 내가 말할 수 있는 한 포함되어 있지는 않지만 는 3년 전에 PEG.js v1을 출시한 후 이를 조사할 것이라고 밝혔지만 그가 계획하지 않는 한 앞으로 2년 동안은 그렇지 않을 것이라고 말했습니다. PEG.js v0(_0.12_, _0.13_, _etc_)의 더 많은 마이너 버전 출시

ePEG에 들여쓰기 지원을 이미 포함했거나 로드맵에 포함했다면?

@kristianmandrup 오 😆, 로드맵에 있습니다. 한동안 ePEG.js 저장소를 업데이트하지 않았고 최근에 플러그인 대신 PEG.js를 완전히 다시 작성하기로 결정했습니다.

@futagoza 는 사전 작업으로 ++/--에 동의했고 작업 구문을 잊어버렸고 [min,max]로 변경했습니다.

그래서

++identifier
--identifier
rule[integer | identifier]
rule[integer | identifier, integer | identifier]

@krisnye [ ... ] 는 문자 클래스에 사용됩니다( https://github.com/pegjs/pegjs#characters 참조).

내가 ePEG.js에서 하고 있는 일은 범위(로드맵에도 있음)를 추가하여 귀하가 설명하는 바를 달성하는 것입니다.

space = [ \t]*
rule = range|expression

• __expression__은 __++space__, __--space__ 또는 __space__ 중 하나일 수 있습니다.
• __범위__는 __ min.. __, __ min..max __, __ ..max __ 또는 __ exact __일 수 있습니다.
• __min__, __max__ 또는 __exact__는 __unsigned integer__만 될 수 있습니다.
• __expression__(예: 2|expression)과 함께 __range__를 사용하면 __rule__이 성공적으로 구문 분석하는 데 필요한 __expression__의 총량을 설정할 수 있습니다.
• __++expression__ 또는 __--expression__(예: 3|++expression)과 함께 __exact__ 범위를 사용하면 기본적으로 __1__인 __++__ 또는 __--__에 대한 __integer__ 양을 설정할 수 있습니다.
• __++expression__ 또는 __--expression__과 함께 __min__ 또는 __max__ 범위를 사용하면 구문 오류가 발생합니다.

규칙 식별자와 혼동될 수 있으므로 상태 변수를 사용하지 않습니다.

__range__, __++__, __--__ 또는 __ @__ 조합을 사용하여 결과에 대해 __action__ 규칙에 덜 의존하는 PEG 문법 파일을 만들고 싶습니다. 그러면 공백(예: 들여쓰기)의 개발 시간이 늘어납니다. 기반, ASCII 아트 등) 언어 설계자 및/또는 구현자는 올바른 양의 공백이 구문 분석되었는지 확인하는 것에 대해 걱정할 필요가 없습니다.
이것은 또한 플러그인 개발자가 __action__의 언어가 무엇인지에 대해 _덜 두려워_ 최적화할 수 있는 파서 생성기를 만들 수 있도록 허용해야 합니다(기본적으로 JavaScript이지만 플러그인을 사용하면 CoffeeScript, PHP 등으로 변경할 수 있음).

따라서 PEG.js를 사용하여 Python을 즉시 구문 분석하는 것은 오늘날에도 여전히 불가능한 것 같습니다. 맞습니까?

그렇지 않다면 이것은 곧 올 것입니까? 사람들이 기여할 수 있는 이 작업을 수행하는 데 필요한 일련의 작업이 있습니까?

JS에서 Python AST를 얻고 수정한 다음 동일한 형식의 소스 코드로 다시 변환할 수 있기를 원하는 프로젝트가 있습니다. 로드맵.

@mindjuice 아직, 1.0 이후로 예정되어 있습니다.

기다릴 수 없다면 내 조카와 나는 동일한 구문을 사용하고 들여쓰기를 처리하는 TypeScript로 작성된 파서를 만들었습니다. 아직 문서화되지 않았지만 매우 간단합니다. 새로운 언어 디자인을 위한 파서로 사용하기 때문에 아직 작업이 진행 중입니다.

https://github.com/krisnye/pegs

chevrotain 과 같은 지원 기능이 있는 다른 파서 생성기를 사용해 볼 수도 있습니다.

파이썬 들여쓰기 예

PEGjs를 사용하여 파이썬과 같은 들여쓰기를 구문 분석하는 것이 매우 가능하다고 생각합니다.
아래 예에서는 4개의 공백 기반 들여쓰기만 사용하지만 임의 간격의 탭 및 기타 공백 문자를 포함하도록 확장할 수 있습니다.
사실 내가 작업하고 있는 언어는 Python보다 들여쓰기가 약간 더 복잡하고 이 문법이 잘 작동합니다.

{
    let prevIndentCount = 0;
    function print(...s) { console.log(...s); }
}

Indent 'indent'
    = i:("    "+) { 
        let currentIndentCount = i.toString().replace(/,/g, "").length;
        if (currentIndentCount === prevIndentCount + 4) { 
            // DEBUG //
            print("=== Indent ===");
            print("    current:"+currentIndentCount); 
            print("    previous:"+prevIndentCount);
            print("    lineNumber:"+location().start.line); 
            // DEBUG //
            prevIndentCount += 4;
            return "[indent]";
        }
        error("error: expected a 4-space indentation here!")
    } // 4 spaces 

Samedent 'samedent'
    = s:("    "+ / "") &{
        let currentIndentCount = s.toString().replace(/,/g, "").length;
        if (currentIndentCount === prevIndentCount) {
            print("=== Samedent ===");
            return true;
        }
        return false;
    }

Dedent 'dedent'
    = d:("    "+ / "") {
        let currentIndentCount = d.toString().replace(/,/g, "").length;
        if (currentIndentCount < prevIndentCount) {
            // DEBUG //
            print("=== Dedent ===");
            print("    current:"+currentIndentCount); 
            print("    previous:"+prevIndentCount);
            print("    lineNumber:"+location().start.line); 
            // DEBUG //
            prevIndentCount -= 4;
            return "[dedent]";
        }
        error("error: expected a 4-space dedentation here!");
    }

위의 문법을 사용하여 다음과 같이 들여쓰기 차단 규칙을 만들 수 있습니다.

FunctionDeclaration 
    = 'function' _ Identifier _ FunctionParameterSection _ ":" _ FunctionBody

FunctionBody
    = Newline Indent FunctionSourceCode (Newline Samedent FunctionSourceCode)* Dedent