pegase 1.0.0__py3-none-any.whl

pegase/LICENSE

@@ -0,0 +1,7 @@
+Copyright © 2025 Shinichiro Ikeda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pegase/LICENSE.jp

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright © 2025 池田真一郎
+
+本ソフトウェアおよび関連する文書のファイル（以下「ソフトウェア」）の複製を取得した全ての人物に対し、以下の条件に従うことを前提に、ソフトウェアを無制限に扱うことを無償で許可します。これには、ソフトウェアの複製を使用、複製、改変、結合、公開、頒布、再許諾、および/または販売する権利、およびソフトウェアを提供する人物に同様の行為を許可する権利が含まれますが、これらに限定されません。
+
+上記の著作権表示および本許諾表示を、ソフトウェアの全ての複製または実質的な部分に記載するものとします。
+
+ソフトウェアは「現状有姿」で提供され、商品性、特定目的への適合性、および権利の非侵害性に関する保証を含むがこれらに限定されず、明示的であるか黙示的であるかを問わず、いかなる種類の保証も行われません。著作者または著作権者は、契約、不法行為、またはその他の行為であるかを問わず、ソフトウェアまたはソフトウェアの使用もしくはその他に取り扱いに起因または関連して生じるいかなる請求、損害賠償、その他の責任について、一切の責任を負いません。

pegase/README.md

@@ -0,0 +1,128 @@
+# Pegase
+Parsing Expression Grammar Abstract Syntax Extension
+
+
+## License
+MIR License
+
+### [英語]
+https://opensource.org/license/mit
+
+### [日本語]
+https://licenses.opensource.jp/MIT/MIT.html
+
+
+## Author
+Shinichiro Ikeda
+
+
+## 概要
+Pegaseは、マサチューセッツ工科大学(Massachusetts Institute of Technology)のBryan Fordが POPL 2004 (ACM SIGPLAN - SIGACT Symposium on Principles of Programming Languages)で発表したParsing Expression Grammars:
+A Recognition-Based Syntactic Foundationに基づき、構文解析モジュールとしてPythonで実装したものです。
+PEGの論文はhttps://bford.info/pub/lang/peg/で見ることができます。
+
+Pegaseの文法オブジェクト(G)は、外部から与えられた構文規則(Syntax Rule)および非終端記号オブジェクト(Nonterminals)から文法(Grammar)を定義し、その文法オブジェクトのparseメソッドで構文解析を実行する機能を持ちます。
+構文解析の結果は非終端記号オブジェクトによる構文解析木(Syntax Tree)として構築して出力します。
+
+PEG文法で記述された構文定義を解析する際は、Pegase内部に用意されたPEG準拠の構文規則および非終端記号オブジェクトを用いて、構文解析の実行および解析結果の構文規則を得ることができます。
+
+
+## ファイル構成
+
+```
+	LICENSE				MIT License (英語)
+	LICENSE.jp			MIT License (日本語)
+	README.md			本ファイル
+	__init__.py			package定義ファイル
+	grammar.py			文法オブジェクトクラスファイル
+	primitive.py		プリミティブ処理ファイル
+	peg.py				PEG文法の構文解析用VNおよびRの定義ファイル
+	peg.peg				PEG文法定義ファイル(参考資料:peg.pyの元となったファイル。構文解析の実行には必要ありません)
+```
+
+## 使用方法
+Pegaseの文法オブジェクトは、pegaseパッケージのGクラスのインスタンスを生成することで作成します。文法オブジェクトの生成時には、パラメータに非終端記号オブジェクトを定義したパッケージ名(VN)、構文規則を定義したS式(R)、構文解析の起点となるS式の名前(eS)を指定します。このパラメータを省略した場合、pegaseパッケージの内部に持つPEG文法解析用のVN、R、およびeSを使用します。
+
+```
+from pegase import G
+PEG = G()
+```
+
+ソースコードを記述するプログラミング言語の文法定義(PEG文法で記述されたもの)を、このPEG文法オブジェクト(PEG)を用いて構文解析することで抽象構文木を取得し、それを評価することでプログラミング言語用の構文規則(R)を得ることができます。
+
+ここでは例として、四則演算の機能を持つ言語を定義し、`basic-calc.peg`として保存します。
+
+```basic-calc.peg
+expr <- term (('+' / '-') term)*
+term <- factor (('*' / '/') factor)*
+factor <- [0-9]+ / '(' expr ')'
+```
+
+この文法定義ファイル(basic-calc.peg)を先ほど作成したPEG文法オブジェクトのparseメソッドを使用して解析し、解析結果の抽象構文木(ST)を評価することでbasic-calc.pegの構文規則(R)を取得します。
+
+```
+basic_ST = PEG.parse('basic-calc.peg')
+basic_R = basic_ST.evaluate()
+```
+
+抽象構文木の各ノード毎の評価処理は、PEG文法の非終端記号名をクラスとしたPythonパッケージとして記述します。ここで作成する四則演算の例では、expr、term、factorのクラスを作成し、非終端記号オブジェクトとします。
+
+四則演算の機能を持つ言語の非終端記号オブジェクトのPythonパッケージを`basic-calc_VN.py`として作成します。
+
+```python:basic-calc_VN.py
+from functools import reduce
+from pegase import A
+
+def calc(x,opcode,y):
+  match opcode:
+    case '+':
+      return x + y
+    case '-':
+      return x- y
+    case '*':
+      return x * y
+    case '/':
+      return x / y
+
+class _expr(A):
+  def evaluate(self):
+    return reduce(lambda x,y:calc(x,y[0],y[1].evaluate()),[('+',self.value[0])] if len(self.value) == 1 else [('+',self.value[0])] + list(zip(self.value[1::2],self.value[2::2])),0)
+
+class _term(A):
+  def evaluate(self):
+    return reduce(lambda x,y:calc(x,y[0],y[1].evaluate()),[('+',self.value[0])] if len(self.value) == 1 else [('+',self.value[0])] + list(zip(self.value[1::2],self.value[2::2])),0)
+
+class _factor(A):
+  def evaluate(self):
+    match self.value[0]:
+      case '(':
+        return self.value[1].evaluate()
+      case _:
+        return int(''.join(self.value))
+```
+
+
+非終端記号オブジェクト名、構文規則、構文解析の起点名を元に四則演算言語の文法オブジェクトを生成し、その文法オブジェクトのparseメソッドを用いて数式を解析した結果を評価することで、四則演算の結果を得ます。
+
+四則演算のメインプログラムを`basic-calc.py`として作成します。
+
+```python:basic-calc.py
+import sys
+from pegase import G
+
+if __name__ == '__main__':
+  PEG = G()
+  basic_ST = PEG.parse('basic-calc.peg')
+  basic_R = basic_ST.evaluate()
+  basic_G = G('basic-calc_VN',basic_R,'expr')
+  result = basic_G.parse(sys.argv[1]).evaluate()
+  print(result)
+```
+
+実行結果は以下の通りです。
+
+```
+$ python basic-calc.py '1+2*3/(4-5)'
+-5.0
+```
+

pegase/__init__.py

@@ -0,0 +1,6 @@
+from .grammar import G
+from .nonterminal import A
+from .primitive import Verbose,DefinitionError,ParseError
+from .flatten import flatten
+
+__all__ = ['G','A','Verbose','DefinitionError','ParseError','flatten']

pegase/flatten.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+#-*- coding: utf-8 -*-
+
+# Copyright © 2025 Shinichiro Ikeda
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+# flatten(source [,exclude]) -- n次元の配列を1次元配列に変換する
+#  - strは展開しない
+#  - excludeで指定したクラスは展開しない
+#  - excludeはクラス単体またはクラスのリストで指定する
+# 例)
+#   flatten(x)					str以外の__iter__オブジェクトを展開する
+#   flatten(x,tuple)			tupleを展開対象外にする
+#   flatten(x,[tuple,dict])		tuple,dictを展開対象外にする
+
+flatten = lambda x,ts=[],f=lambda x,ts,g: [z for y in x for z in (g(y,ts,g) if hasattr(y, '__iter__') and not any([isinstance(y,t) for t in (ts+[str] if isinstance(ts,list) else [ts,str])]) else (y,))]: f(x,ts,f)

pegase/grammar.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python
+#-*- coding: utf-8 -*-
+
+# Copyright © 2025 Shinichiro Ikeda
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import importlib
+import inspect
+import os
+import re
+import sys
+from functools import reduce
+
+from .nonterminal import A
+from .peg import peg_R
+from .primitive import Stream,_expression,DefinitionError,ParseError
+from .flatten import flatten
+
+
+# Definition
+#   G = (VN,VT,R,eS)
+#   A ∈ VN
+#   a ∈ VT
+#   r ∈ R, A <- e ∈ R
+#   e = R[A]
+
+# Usage:
+#	PEG = G()
+#	target_R = PEG.parse('target.peg').evaluate()
+#	target_eS = 'TargetStartExpr'
+#	result = G(target_VN,target_R,target_eS).parse('source-file')
+
+#	from pegase import G
+#	querre_VN = 'querre_VN'
+#	querre_eS = 'direct_SQL_statement'
+#	result = G(querre_VN,G().parse('querre.peg').evaluate(),querre_eS).parse('select * from "a.csv";').evaluate()
+
+
+#	PEG = G()
+#	ebnf_VN = 'ebnf_VN'
+#	ebnf_R = PEG.parse('ebnf.peg').evaluate()
+#	ebnf_eS = 'Grammar'
+#	querre_VN = 'querre_VN'
+#	querre_R = G(ebnf_VN,ebnf_R,ebnf_eS).parse('querre.ebnf').evaluate()
+#	querre_eS = 'direct_SQL_statement'
+#	result = G(querre_VN,querre_R,querre_eS).parse('select * from "a.csv";').evaluate()
+
+#	result = G('querre_VN',G('ebnf_VN',G().parse('ebnf.peg').evaluate(),'Grammar').parse('querre.ebnf').evaluate(),'direct_SQL_statement').parse('select * from "a.csv";').evaluate()
+
+
+#	G.grammar(pegfile,eS,VN) コンストラクタ使用
+#	result = G.grammar('querre.peg','direct_SQL_statement','querre_VN').parse('select * from "a.csv";').evaluate()
+
+
+#================================================================================
+# G Class
+# parameters:
+#	VN		A ∈ VN			Aをクラスとして実装したVNモジュール (省略した場合はpeg_VNを使用)
+#							パッケージから呼び出す場合は('package','.module')のようにtupleで指定する (モジュール名は相対表示)
+#	R		A <- e ∈ R		解析ルール(A <- e)の一覧を{'A':e}として実装したdict (省略した場合はpeg_Rを使用)
+#	eS		e = R(A)		解析を開始するexpressionをAとして指定 (省略した場合はpeg_VN.Grammarを使用)
+#================================================================================
+class G:
+	def __init__(self,VN=None,R=None,eS=None,verbose=0):
+		R = R or peg_R
+		# eSが指定されなかった場合はRに定義された最初の項目をeSとして使用する
+		eS = eS or list(R.keys())[0]
+		self.verbose = verbose
+#		# verboseが0の場合はtracebackを表示しない
+#		if self.verbose == 0:
+#			sys.tracebacklimit=0
+		# モジュールVNに定義されているクラス一覧をdictとして取得
+		self.VN = dict(inspect.getmembers(importlib.import_module('.peg',package=__package__) if VN is None else (importlib.import_module(VN[1],package=VN[0]) if isinstance(VN,tuple) else importlib.import_module(VN)),inspect.isclass))
+		parent_VN = 'peg' if VN is None else (VN[1].split('.')[-1] if isinstance(VN,tuple) else VN)
+		self.parent = (self.VN[parent_VN],) if parent_VN in self.VN else (A,)
+		self.R = {A:_expression(e) for A,e in R.items()}
+		self.eS = eS
+		if self.eS not in self.R.keys():
+			raise DefinitionError(f'eS not defined in R: {self.eS}')
+
+		# ----------------------------
+		# 未定義の非終端記号参照の検出
+		# ----------------------------
+		nonterminals = list(R.keys())
+
+		rules = list(set(flatten(
+			reduce(
+				lambda rules,definition:
+					rules + (
+						lambda expr,
+							   f=lambda ex,g: [ex[1]] if ex[0] == '_rules' else [g(e,g) for e in ex[1:] if e[0] in ['_optional','_zero_or_more','_one_or_more','_and_predicate','_not_predicate','_sequence','_prioritized_choice','_rules']]
+						: f(expr,f)
+					)(definition[2]),
+					R.values(),
+					[]
+			)
+		))) + [eS]
+
+		unused_rules = sorted(set(nonterminals) - set(rules))
+		if len(unused_rules) > 0 and self.verbose > 0:
+			print(f'WARNING: Unuse rules detected: {unused_rules}')
+
+		undefined_rules = sorted(set(rules) - set(nonterminals))
+		if len(undefined_rules) > 0:
+			raise ParseError(f'Undefined rules detected: {undefined_rules}')
+#		if len(undefined_rules) > 0 and self.verbose > 0:
+#			print(f'WARNING: Undefined rules detected: {undefined_rules}')
+
+		# --------------------
+		# left recursionの検出
+		# --------------------
+		# 各ルール毎に最初の_rulesプリミティブを抽出(最初が終端記号の場合を除く)
+		leading_rules = {definition[1]: flatten((lambda expr,f=lambda ex,g:
+											# sequenceはe1のみ抽出対象とする
+											[] if ex[0] in ['_empty_string','_literal_string','_character_class','_any_character'] else
+											[ex[1]] if ex[0] == '_rules' else
+											[g(e,g) for e in ex[1:] if e[0] in ['_optional','_zero_or_more','_one_or_more','_and_predicate','_not_predicate','_sequence','_prioritized_choice','_rules']] if ex[0] == '_prioritized_choice' else
+											[g(e,g) for e in [ex[1]] if e[0] in ['_optional','_zero_or_more','_one_or_more','_and_predicate','_not_predicate','_sequence','_prioritized_choice','_rules']]
+										: f(expr,f)
+				    	)(definition[2]))
+						for definition in R.values()
+		}
+		# 自分の配下で自分を呼び出す定義を左再帰として検出
+		left_recursions = {A:e for A,e in 
+			{A: flatten(
+					(lambda A,e,f=lambda A,a,ex,g: [g(A+[e],e,leading_rules[e],g) if e in leading_rules and e not in A else (f'{a} <- {e}' if e == A[0] else []) for e in ex]: f([A],None,e,f))(A,e)
+				) for A,e in leading_rules.items()
+			}.items()
+			if len(e) > 0
+		}
+		if len(left_recursions) > 0:
+			raise DefinitionError(f'left recursion detected',left_recursions)
+
+	def __repr__(self):
+		return '{1}.{0.__class__.__name__}(\n  VN = {2},\n  R = {3},\n  eS = {4}\n)'.format(self,__package__,list(self.VN.keys()),list(self.R.keys()),self.eS)
+
+	def parse(self,src,forcefile=False):
+		if os.path.isfile(src):
+			with open(src,'r') as f:
+				stream = f.read()
+		elif forcefile:
+			raise ParseError(f'File not found: {src}')
+		else:
+			stream = src
+
+		s = Stream(stream,self)
+		# eSと!.のsequenceを作成して実行する
+		parsed = _expression(('_sequence',('_rules',self.eS),('_not_predicate',('_any_character','.'))))(s)
+
+		if parsed is None:
+			raise ParseError('Parse error detected at line #{}: {}'.format(len(re.findall('\n',s._stream[:s._hwm]))+1,s._stream[s._stream[:s._hwm].rfind('\n')+1:s._hwm]),s)
+
+		return parsed[0]
+
+
+	# G.grammar(pegfile,eS,VN) コンストラクタ
+	@classmethod
+	def grammar(cls,pegfile,eS=None,VN=None,verbose=0):
+		return cls(VN,G().parse(pegfile,forcefile=True).evaluate(),eS,verbose=verbose)
+
+# EOF

pegase/nonterminal.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+#-*- coding: utf-8 -*-
+
+# Copyright © 2025 Shinichiro Ikeda
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+from functools import reduce
+
+
+def _format_ast(ast,indent=0):
+	if len(ast.value) == 1 and isinstance(ast.value[0],str):
+		result = f'{" "*indent}{ast.__class__.__name__}({repr(ast.value[0])})\n'
+	else:
+#		result = f'{" "*indent}{ast.__class__.__name__}(\n' + \
+#				 reduce(lambda x,n: x + f'{" "*(indent+4)}{repr(n)}\n' if isinstance(n,str) else x + _format_ast(n,indent+4), [''.join(ast.value)] if len(ast.value) > 0 and all([isinstance(v,str) for v in ast.value]) else ast.value, '') + \
+#				 f'{" "*indent})\n'
+		result = f'{" "*indent}{ast.__class__.__name__}(\n' + \
+				 reduce(lambda x,n: x + f'{" "*(indent+4)}{repr(n)}\n' if isinstance(n,str) else x + _format_ast(n,indent+4), ast.value, '') + \
+				 f'{" "*indent})\n'
+	return result
+
+
+#================================================================================
+# A Class
+#================================================================================
+class A:
+	def __init__(self,value):
+		self.value = value
+
+	def __repr__(self):
+		return f'{self.__class__.__name__}({repr(self.value)})'
+
+	def evaluate(self):
+		return reduce(lambda x,y: x + y if isinstance(y,str) else x + y.evaluate(),self.value,'')
+
+	def format(self):
+		return _format_ast(self)[:-1]
+
+# EOF

pegase/peg.peg

@@ -0,0 +1,36 @@
+# Hierarchial syntax
+Grammar <- Spacing Definition+ EndOfFile
+Definition <- Identifier LEFTARROW Expression
+
+Expression <- Sequence (SLASH Sequence)*
+Sequence <- Prefix+
+Prefix <- (AND / NOT)? Suffix
+Suffix <- Primary (QUESTION / STAR / PLUS)?
+Primary <- Identifier !LEFTARROW / OPEN Expression CLOSE / Literal / Class / DOT
+
+# Lexical syntax
+Identifier <- IdentStart IdentCont* Spacing
+IdentStart <- [a-zA-Z_]
+IdentCont <- IdentStart / [0-9]
+
+Literal <- ['] (!['] Char)* ['] Spacing / ["] (!["] Char)* ["] Spacing
+Class <- '[' (!']' Range)* ']' Spacing
+Range <- Char '-' Char / Char
+Char <- '\\' [nrt'"\[\]\\] / '\\' [0-2][0-7][0-7] / '\\' [0-7][0-7]? / !'\\' .
+
+LEFTARROW <- '<-' Spacing
+SLASH <- '/' Spacing
+AND <- '&' Spacing
+NOT <- '!' Spacing
+QUESTION <- '?' Spacing
+STAR <- '*' Spacing
+PLUS <- '+' Spacing
+OPEN <- '(' Spacing
+CLOSE <- ')' Spacing
+DOT <- '.' Spacing
+
+Spacing <- (Space / Comment)*
+Comment <- '#' (!EndOfLine .)* EndOfLine
+Space <- ' ' / '\t' / EndOfLine
+EndOfLine <- '\r\n' / '\n' / '\r'
+EndOfFile <- !.

pegase/peg.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python
+#-*- coding: utf-8 -*-
+
+# Copyright © 2025 Shinichiro Ikeda
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+from functools import reduce
+from .nonterminal import A
+from .primitive import ParseError
+
+
+#================================================================================
+# Persing Expression Grammar VN
+#================================================================================
+class peg(A):
+	def preprocessing(self):
+		self.value = [v if isinstance(v,str) else v.preprocessing() for v in self.value if not isinstance(v,_Spacing)]
+		return self
+
+#--------------------------------------------------------------------------------
+class _Grammar(peg):
+	# Grammar <- Spacing Definition+ EndOfFile
+	def evaluate(self):
+		return dict([d.evaluate() for d in self.value if isinstance(d,_Definition)])
+
+class _Definition(peg):
+	# Definition <- Identifier LEFTARROW Expression
+	def evaluate(self):
+		return (self.value[0].evaluate()[1],('_definition',self.value[0].evaluate()[1],self.value[2].evaluate()))
+
+class _Expression(peg):
+	# Expression <- Sequence (SLASH Sequence)*
+	def evaluate(self):
+		return ('_prioritized_choice',*[s.evaluate() for s in self.value[::2]]) if len(self.value) > 1 else self.value[0].evaluate()
+
+class _Sequence(peg):
+	# Sequence <- Prefix*
+	def evaluate(self):
+		s = [s.evaluate() for s in self.value]
+		return ('_sequence',*s) if len(s) > 1 else s[0]
+
+class _Prefix(peg):
+	# Prefix <- (AND / NOT)? Suffix
+	def evaluate(self):
+		match self.value[0]:
+			case _AND():
+				return ('_and_predicate',self.value[1].evaluate())
+			case _NOT():
+				return ('_not_predicate',self.value[1].evaluate())
+			case _:
+				# Just Suffix:
+				return self.value[0].evaluate()
+
+class _Suffix(peg):
+	# Suffix <- Primary (QUESTION / STAR / PLUS)?
+	def evaluate(self):
+		if len(self.value) > 1:
+			match self.value[1]:
+				case _QUESTION():
+					return ('_optional',self.value[0].evaluate())
+				case _STAR():
+					return ('_zero_or_more',self.value[0].evaluate())
+				case _PLUS():
+					return ('_one_or_more',self.value[0].evaluate())
+				case _:
+					raise ParseError(f'Unrecognized suffix: {self.value[1]}')
+
+		return self.value[0].evaluate()
+
+class _Primary(peg):
+	# Primary <- Identifier !LEFTARROW / OPEN Expression CLOSE / Literal / Class / DOT
+	def evaluate(self):
+		match self.value[0]:
+			case _Identifier():
+				return self.value[0].evaluate()
+			case _OPEN():
+				assert isinstance(self.value[2],_CLOSE),'ParseError, "(" was never closed:'+str(self.value)
+				return self.value[1].evaluate()
+			case _Literal():
+				return self.value[0].evaluate()
+			case _Class():
+				return self.value[0].evaluate()
+			case _DOT():
+				return self.value[0].evaluate()
+			case _:
+				raise ParseError('Unrecognized primary value: {self.value[0]}')
+
+class _Identifier(peg):
+	# Identifier <- IdentStart IdentCont* Spacing
+	def preprocessing(self):
+		self.value = [''.join([v if isinstance(v,str) else v.evaluate() for v in self.value if not isinstance(v,_Spacing)])]
+		return self
+
+	def evaluate(self):
+		identifier = ''.join([v if isinstance(v,str) else v.evaluate() for v in self.value if not isinstance(v,_Spacing)])
+		return ('_rules',identifier)
+
+class _IdentStart(peg):
+	# IdentStart <- [a-zA-Z_]
+	def evaluate(self):
+		return reduce(lambda x,y: x + y if isinstance(y,str) else x + y.evaluate(),self.value,'')
+
+class _IdentCont(peg):
+	# IdentCont <- IdentStart / [0-9]
+	def evaluate(self):
+		return reduce(lambda x,y: x + y if isinstance(y,str) else x + y.evaluate(),self.value,'')
+
+class _Literal(peg):
+	# Literal <- ['] (!['] Char)* ['] Spacing / ["] (!["] Char)* ["] Spacing
+	def preprocessing(self):
+		self.value = [''.join([v if isinstance(v,str) else v.evaluate() for v in self.value if not isinstance(v,_Spacing)])]
+		return self
+
+	def evaluate(self):
+		return ('_literal_string',reduce(lambda x,y: x + y if isinstance(y,str) else x if isinstance(y,_Spacing) else x + y.evaluate(),self.value,''))
+
+class _Class(peg):
+	# Class <- '[' (!']' Range)* ']' Spacing
+	def preprocessing(self):
+		self.value = [''.join([v if isinstance(v,str) else v.evaluate() for v in self.value if not isinstance(v,_Spacing)])]
+		return self
+
+	def evaluate(self):
+		return ('_character_class',reduce(lambda x,y: x + y if isinstance(y,str) else x if isinstance(y,_Spacing) else x + y.evaluate(),self.value,''))
+
+class _Range(peg):
+	# Range <- Char '-' Char / Char
+	def evaluate(self):
+		return reduce(lambda x,y: x + y if isinstance(y,str) else x if isinstance(y,_Spacing) else x + y.evaluate(),self.value,'')
+
+class _Char(peg):
+	# Char <- '\\' [nrt'"\[\]\\] / '\\' [0-2][0-7][0-7] / '\\' [0-7][0-7]? / !'\\' .
+	def evaluate(self):
+		return self.value[0]
+
+class _LEFTARROW(peg):
+	# LEFTARROW <- '<-' Spacing
+	pass
+
+class _SLASH(peg):
+	# SLASH <- '/' Spacing
+	pass
+
+class _AND(peg):
+	# AND <- '&' Spacing
+	pass
+
+class _NOT(peg):
+	# NOT <- '!' Spacing
+	pass
+
+class _QUESTION(peg):
+	# QUESTION <- '?' Spacing
+	pass
+
+class _STAR(peg):
+	# STAR <- '*' Spacing
+	pass
+
+class _PLUS(peg):
+	# PLUS <- '+' Spacing
+	pass
+
+class _OPEN(peg):
+	# OPEN <- '(' Spacing
+	pass
+
+class _CLOSE(peg):
+	# CLOSE <- ')' Spacing
+	pass
+
+class _DOT(peg):
+	# DOT <- '.' Spacing
+	def evaluate(self):
+		return ('_any_character',self.value[0])
+
+class _Spacing(peg):
+	# Spacing <- (Space / Comment)*
+	def evaluate(self):
+		return reduce(lambda x,y: x + y if isinstance(y,str) else x + y.evaluate(),self.value,'')
+
+class _Comment(peg):
+	# Comment <- '#' (!EndOfLine .)* EndOfLine
+	def evaluate(self):
+		return reduce(lambda x,y: x + y if isinstance(y,str) else x + y.evaluate(),self.value,'')
+
+class _Space(peg):
+	# Space <- ' ' / '\t' / EndOfLine
+	def evaluate(self):
+		return reduce(lambda x,y: x + y if isinstance(y,str) else x + y.evaluate(),self.value,'')
+
+class _EndOfLine(peg):
+	# EndOfLine <- '\r\n' / '\n' / '\r'
+	def evaluate(self):
+		return reduce(lambda x,y: x + y if isinstance(y,str) else x + y.evaluate(),self.value,'')
+
+class _EndOfFile(peg):
+	# EndOfFile <- !.
+	pass
+
+#================================================================================
+# Persing Expression Grammar R and eS
+#================================================================================
+peg_R = {
+	'Grammar': ('_definition', 'Grammar', ('_sequence', ('_rules', 'Spacing'), ('_one_or_more', ('_rules', 'Definition')), ('_rules', 'EndOfFile'))),
+	'Definition': ('_definition', 'Definition', ('_sequence', ('_rules', 'Identifier'), ('_rules', 'LEFTARROW'), ('_rules', 'Expression'))),
+	'Expression': ('_definition', 'Expression', ('_sequence', ('_rules', 'Sequence'), ('_zero_or_more', ('_sequence', ('_rules', 'SLASH'), ('_rules', 'Sequence'))))),
+	'Sequence': ('_definition', 'Sequence', ('_one_or_more', ('_rules', 'Prefix'))),
+	'Prefix': ('_definition', 'Prefix', ('_sequence', ('_optional', ('_prioritized_choice', ('_rules', 'AND'), ('_rules', 'NOT'))), ('_rules', 'Suffix'))),
+	'Suffix': ('_definition', 'Suffix', ('_sequence', ('_rules', 'Primary'), ('_optional', ('_prioritized_choice', ('_rules', 'QUESTION'), ('_rules', 'STAR'), ('_rules', 'PLUS'))))),
+	'Primary': ('_definition', 'Primary', ('_prioritized_choice', ('_sequence', ('_rules', 'Identifier'), ('_not_predicate', ('_rules', 'LEFTARROW'))), ('_sequence', ('_rules', 'OPEN'), ('_rules', 'Expression'), ('_rules', 'CLOSE')), ('_rules', 'Literal'), ('_rules', 'Class'), ('_rules', 'DOT'))),
+	'Identifier': ('_definition', 'Identifier', ('_sequence', ('_rules', 'IdentStart'), ('_zero_or_more', ('_rules', 'IdentCont')), ('_rules', 'Spacing'))),
+	'IdentStart': ('_definition', 'IdentStart', ('_character_class', '[a-zA-Z_]')),
+	'IdentCont': ('_definition', 'IdentCont', ('_prioritized_choice', ('_rules', 'IdentStart'), ('_character_class', '[0-9]'))),
+	'Literal': ('_definition', 'Literal', ('_prioritized_choice', ('_sequence', ('_character_class', "[']"), ('_zero_or_more', ('_sequence', ('_not_predicate', ('_character_class', "[']")), ('_rules', 'Char'))), ('_character_class', "[']"), ('_rules', 'Spacing')), ('_sequence', ('_character_class', '["]'), ('_zero_or_more', ('_sequence', ('_not_predicate', ('_character_class', '["]')), ('_rules', 'Char'))), ('_character_class', '["]'), ('_rules', 'Spacing')))),
+	'Class': ('_definition', 'Class', ('_sequence', ('_literal_string', "'['"), ('_zero_or_more', ('_sequence', ('_not_predicate', ('_literal_string', "']'")), ('_rules', 'Range'))), ('_literal_string', "']'"), ('_rules', 'Spacing'))),
+	'Range': ('_definition', 'Range', ('_prioritized_choice', ('_sequence', ('_rules', 'Char'), ('_literal_string', "'-'"), ('_rules', 'Char')), ('_rules', 'Char'))),
+	'Char': ('_definition', 'Char', ('_prioritized_choice', ('_sequence', ('_literal_string', "'\\\\'"), ('_character_class', '[nrt\'"\\[\\]\\\\]')), ('_sequence', ('_literal_string', "'\\\\'"), ('_character_class', '[0-2]'), ('_character_class', '[0-7]'), ('_character_class', '[0-7]')), ('_sequence', ('_literal_string', "'\\\\'"), ('_character_class', '[0-7]'), ('_optional', ('_character_class', '[0-7]'))), ('_sequence', ('_not_predicate', ('_literal_string', "'\\\\'")), ('_any_character', '.')))), 'LEFTARROW': ('_definition', 'LEFTARROW', ('_sequence', ('_literal_string', "'<-'"), ('_rules', 'Spacing'))),
+	'SLASH': ('_definition', 'SLASH', ('_sequence', ('_literal_string', "'/'"), ('_rules', 'Spacing'))),
+	'AND': ('_definition', 'AND', ('_sequence', ('_literal_string', "'&'"), ('_rules', 'Spacing'))),
+	'NOT': ('_definition', 'NOT', ('_sequence', ('_literal_string', "'!'"), ('_rules', 'Spacing'))),
+	'QUESTION': ('_definition', 'QUESTION', ('_sequence', ('_literal_string', "'?'"), ('_rules', 'Spacing'))),
+	'STAR': ('_definition', 'STAR', ('_sequence', ('_literal_string', "'*'"), ('_rules', 'Spacing'))),
+	'PLUS': ('_definition', 'PLUS', ('_sequence', ('_literal_string', "'+'"), ('_rules', 'Spacing'))),
+	'OPEN': ('_definition', 'OPEN', ('_sequence', ('_literal_string', "'('"), ('_rules', 'Spacing'))),
+	'CLOSE': ('_definition', 'CLOSE', ('_sequence', ('_literal_string', "')'"), ('_rules', 'Spacing'))),
+	'DOT': ('_definition', 'DOT', ('_sequence', ('_literal_string', "'.'"), ('_rules', 'Spacing'))),
+	'Spacing': ('_definition', 'Spacing', ('_zero_or_more', ('_prioritized_choice', ('_rules', 'Space'), ('_rules', 'Comment')))),
+	'Comment': ('_definition', 'Comment', ('_sequence', ('_literal_string', "'#'"), ('_zero_or_more', ('_sequence', ('_not_predicate', ('_rules', 'EndOfLine')), ('_any_character', '.'))), ('_rules', 'EndOfLine'))),
+	'Space': ('_definition', 'Space', ('_prioritized_choice', ('_literal_string', "' '"), ('_literal_string', "'\\t'"), ('_rules', 'EndOfLine'))),
+	'EndOfLine': ('_definition', 'EndOfLine', ('_prioritized_choice', ('_literal_string', "'\\r\\n'"), ('_literal_string', "'\\n'"), ('_literal_string', "'\\r'"))),
+	'EndOfFile': ('_definition', 'EndOfFile', ('_not_predicate', ('_any_character', '.')))
+}
+
+# EOF

pegase/pegase_gen_R.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+#-*- coding: utf-8 -*-
+
+# Copyright © 2025 Shinichiro Ikeda
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Description:
+#   文法ファイルの構文解析を行い、構文解析式の集合Rを生成する
+#   文法ファイルがPEG文法以外で記述されている場合、その文法を定義したPEG文法定義ファイルを-gパラメータを使って指定する
+#
+# Usage:
+#   $ python pegase_gen_R.py [-g PEG文法定義ファイル] 文法ファイル > generated_R.py
+#
+# 使用例:
+#   $ python pegase_gen_R.py epeg.peg > epeg_R.py
+#   $ python pegase_gen_R.py sql1992.peg > sql1992_R.py
+#   $ python pegase_gen_R.py -g epeg.peg sql2016.epeg > sql2016_R.py
+
+import os
+import sys
+from pegase import G
+
+
+#================================================================================
+if __name__ == '__main__':
+
+	# パラメータ取得
+	args = sys.argv[1:]
+
+	# パラメータ取得(grammar)
+	grammar = None
+	if '-g' in args:
+		_idx = [i for i,p in enumerate(args) if p == '-g'][0]
+		grammar = args[_idx+1]
+		args = [p for i,p in enumerate(args) if i != _idx and i != _idx + 1]
+
+	# パラメータ取得(verbose)
+	verbose = 0
+	if '-v' in args:
+		_idx = [i for i,p in enumerate(args) if p == '-v'][0]
+		verbose = int([args[_idx+1]][0])
+		args = [p for i,p in enumerate(args) if i != _idx and i != _idx + 1]
+
+	# パラメータ取得(pegfile)
+	pegfile = [p for p in args if p[0] != '-' and os.path.isfile(p)][0]
+
+	# 抽象構文木を取得
+	AST = G(R = None if grammar is None else G().parse(grammar).evaluate(),verbose=verbose).parse(pegfile)
+
+	# 構文解析式Rを生成
+	R = AST.evaluate()
+	print(f'{os.path.splitext(os.path.basename(pegfile))[0]}_R =','{')
+	for a,e in R.items():
+		print(f'\t\'{a}\': {e},')
+	print('}')
+
+# EOF

pegase/primitive.py

@@ -0,0 +1,377 @@
+#!/usr/bin/env python
+#-*- coding: utf-8 -*-
+
+# Copyright © 2025 Shinichiro Ikeda
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import re
+from functools import reduce
+from enum import IntEnum
+
+
+#================================================================================
+# Exceptions
+#================================================================================
+
+# Base class for exceptions
+class Error(Exception):
+	def __init__(self,*p):
+		# 例外発生時の例外名からパッケージ名を除く
+		# pegase.primitive.Error -> pegase.Error
+		self.__class__.__module__ = __package__
+
+# DefinitionError(message [,left_recursion])
+class DefinitionError(Error):
+	def __str__(self):
+		if self.args[0] == 'left recursion detected':
+			recursions = self.args[1]
+			for A,r in recursions.items():
+				self.add_note(f'  {A}: {r}')
+		return self.args[0]
+
+
+# ParseError(message [,Stream])
+class ParseError(Error):
+	def __str__(self):
+		if len(self.args) >= 2 and isinstance(self.args[1],Stream):
+			s = self.args[1]
+			start = s._stream[:max(s._stream[:s._hwm].rfind('\n'),0)].rfind('\n')+1
+			end = len(s._stream) if s._stream[s._hwm:].find('\n') < 0 else s._hwm+s._stream[s._hwm:].find('\n')
+			linepos = s._hwm - 1 - s._stream[:s._hwm].rfind('\n')
+			s_no = len(re.findall('\n',s._stream[:start]))+1
+			e_no = len(re.findall('\n',s._stream[:s._hwm]))+1
+			self.add_note(f'Syntax error around line {s_no if s_no == e_no else str(s_no)+" to "+str(e_no)}:')
+			self.add_note(f'{s._stream[start:end]}')
+			self.add_note(f'{" "*linepos}^')
+		return self.args[0]
+
+
+#================================================================================
+# Verbose Level
+#================================================================================
+class Verbose(IntEnum):
+	SILENT = 0
+	PROGRESS = 1
+	MUMBLE = 2
+	DEBUG = 3
+
+
+#================================================================================
+# Constructing Operators
+#================================================================================
+
+#----------------------------------------
+# ε			Empty String
+#----------------------------------------
+def _empty_string():
+	def _(s):
+#DEBUG
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'  - _empty_string')
+		return ''
+	return _
+
+#----------------------------------------
+# ' '		Literal String
+# " "		Literal String
+#----------------------------------------
+def _literal_string(pattern):
+	assert len(pattern) > 2 and ((pattern[0] == "'" and pattern[-1] == "'") or (pattern[0] == '"' and pattern[-1] == '"')), '_literal_string pattern must be enclosed in quotes or double quotes:'+str(pattern)
+	pattern = pattern.replace('\\n','\n').replace('\\r','\r').replace('\\t','\t').replace("\\'","'").replace('\\"','"').replace('\\[','[').replace('\\]',']').replace('\\\\','\\')
+	def _(s):
+		result = None
+		if s.stream()[:len(pattern[1:-1])] == pattern[1:-1]:
+			result = s.stream()[:len(pattern[1:-1])]
+			s.forward(len(pattern[1:-1]))
+#DEBUG
+			if s.G.verbose >= Verbose.DEBUG:
+				print(f'  * _literal_string      : stream:{repr(result)} length:{len(pattern[1:-1])} pattern:{repr(pattern)}')
+		else:
+			if s.G.verbose >= Verbose.DEBUG:
+				print(f'    _literal_string      : stream:{repr(s.stream()[:10])} length:{len(pattern[1:-1])} pattern:{repr(pattern)}')
+		return result
+	return _
+
+#----------------------------------------
+# [ ]		Character Class
+#----------------------------------------
+def _character_class(pattern):
+	assert len(pattern) > 2 and pattern[0] == '[' and pattern[-1] == ']', '_character_class pattern should be enclosed in "[" and "]":'+str(pattern)
+	p = re.compile(pattern)
+	def _(s):
+		result = None
+		m = p.match(s.stream())
+		if m:
+			s.forward(m.end())
+			result = [m.group()]
+#DEBUG
+			if s.G.verbose >= Verbose.DEBUG:
+				print(f'  * _characger_class     : stream:{repr(result)} length:{len(pattern)} pattern:{repr(pattern)}')
+		else:
+			if s.G.verbose >= Verbose.DEBUG:
+				print(f'    _character_class     : stream:{repr(s.stream()[:10])} length:{len(pattern)} pattern:{repr(pattern)}')
+		return result
+	return _
+
+#----------------------------------------
+# .			Any Character
+#----------------------------------------
+def _any_character(pattern):
+	assert pattern == '.', '_any_character pattern should be ".":'+str(pattern)
+	def _(s):
+		result = None
+		if len(s.stream()) > 0:
+			result = [s.stream()[0]]
+			s.forward(1)
+			if s.G.verbose >= Verbose.DEBUG:
+				print(f'  * _any_character       : stream:{repr(result)} length:{len(pattern)} pattern:{repr(pattern)}')
+		else:
+			if s.G.verbose >= Verbose.DEBUG:
+				print(f'    _any_character       : stream:{repr(s.stream()[:10])} length:{len(pattern)} pattern:{repr(pattern)}')
+		return result
+	return _
+
+#----------------------------------------
+# e?		Optional
+#----------------------------------------
+def _optional(e):
+	def _(s):
+#DEBUG
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'  - _optional')
+		x = e(s)
+		return x or []
+	return _
+
+#----------------------------------------
+# e*		Zero-or-more
+#----------------------------------------
+def _zero_or_more(e):
+	def _(s):
+#DEBUG
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'  - _zero_or_more')
+		result = []
+		while True:
+			x = e(s)
+			if x is None:
+				break
+			else:
+				result += x
+		return result
+	return _
+
+#----------------------------------------
+# e+		One-or-more
+#----------------------------------------
+def _one_or_more(e):
+	def _(s):
+#DEBUG
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'  - _one_or_more')
+		result = []
+		while True:
+			x = e(s)
+			if x is None:
+				break
+			else:
+				result += x
+		return result if len(result) > 0 else None
+	return _
+
+#----------------------------------------
+# &e		And-redicate
+#----------------------------------------
+def _and_predicate(e):
+	def _(s):
+#DEBUG
+		i = s.cursor()
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'&   _and_predicate       : at {i}')
+		x = e(s)
+		if x is None:
+			result = None
+		else:
+			result = []
+		s.backtracking(i)
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'<&  _and_predicate       : result = {result}, backtracing to {i} stream:{repr(s._stream[i:i+10])}')
+		return result
+	return _
+
+#----------------------------------------
+# !e		Not-predicate
+#----------------------------------------
+def _not_predicate(e):
+	def _(s):
+#DEBUG
+		i = s.cursor()
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'!   _not_predicate       : at {i}')
+		x = e(s)
+		if x is None:
+			result = []
+		else:
+			result = None
+		s.backtracking(i)
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'<!  _not_predicate       : result = {result}, backtracing to {i} stream:{repr(s._stream[i:i+10])}')
+		return result
+	return _
+
+#----------------------------------------
+# e1 e2		Sequence
+#----------------------------------------
+def _sequence(*es):
+#DEBUG
+#	print('*** _sequence *es:',*es)
+	def _(s):
+#DEBUG
+		result = []
+		i = s.cursor()
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'.   _sequence   _        : at {i} ',['e'+str(i+1) for i,_ in enumerate(es)])
+		for e in es:
+			x = e(s)
+			if x is None:
+				result = None
+				s.backtracking(i)
+				if s.G.verbose >= Verbose.DEBUG:
+					print(f'<   _sequence            : backtracing to {i} stream:{repr(s._stream[i:i+10])}')
+				break
+			else:
+				result += x
+#		if s.G.verbose >= Verbose.MUMBLE:
+#			if result is None:
+#				print(f'<   _sequence            : backtracing to {i} stream:{repr(s._stream[i:i+10])}')
+#			elif len(result) == 0:
+#				print(f'    _sequence     result :', result)
+#			else:
+#				print(f'    _sequence     result :', reduce(lambda x,y: x[:-1] + [''.join([x[-1],y])] if isinstance(x[-1],str) and isinstance(y,str) else x + [y], result[1:], [result[0]]))
+		return result if result is None or len(result) == 0 else reduce(lambda x,y: x[:-1] + [''.join([x[-1],y])] if isinstance(x[-1],str) and isinstance(y,str) else x + [y], result[1:], [result[0]])
+	return _
+
+#----------------------------------------
+# e1 / e2	Prioritized Choice
+#----------------------------------------
+def _prioritized_choice(*es):
+#DEBUG
+#	print('*** _prioritized_choice *es:',*es)
+	def _(s):
+#DEBUG
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'  - _prioritized_choice  :',['e'+str(i+1) for i,_ in enumerate(es)])
+		result = None
+		i = s.cursor()
+		for e in es:
+			x = e(s)
+			if x is None:
+				pass
+			else:
+				result = x
+				break
+		return result
+	return _
+
+#----------------------------------------
+# A <- e	Definition
+#----------------------------------------
+def _definition(A,e,ex):
+#DEBUG
+#	print('*** _definition A <- e:',A,e)
+	_A = '_' + A
+	def _(s):
+#DEBUG
+		if s.G.verbose >= Verbose.DEBUG:
+			print(f'    _definition _ A <- e : {A} <- {ex}')
+		x = e(s)
+		if _A not in s.G.VN:
+			# VNにAが定義されていない場合、Aのクラス定義を生成してVNに登録する
+			s.G.VN[_A] = type(_A,s.G.parent,{})
+#VERBOSE
+		if x is not None and s.G.verbose >= Verbose.MUMBLE:
+			print(f' ** _definition _ A <- e : {A} <- {x}')
+		return x if x is None else [s.G.VN[_A](x)]
+	return _
+
+#----------------------------------------
+# R(A)		Rules
+#----------------------------------------
+def _rules(A):
+#	print('*** _rules A:',A)
+	def _(s):
+#DEBUG
+		if s.G.verbose >= Verbose.MUMBLE:
+			print(f'  - _rules      _ A      : {A}')
+		return s.G.R[A](s)
+	return _
+
+#================================================================================
+# "readable rules" to expressions conversion
+#================================================================================
+def _expression(expr):
+	f,*p = expr
+	match f:
+		case '_empty_string':
+			x = _empty_string()
+		case '_literal_string':
+			x = _literal_string(*p)
+		case '_character_class':
+			x = _character_class(*p)
+		case '_any_character':
+			x = _any_character(*p)
+		case '_optional':
+			x = _optional(_expression(*p))
+		case '_zero_or_more':
+			x = _zero_or_more(_expression(*p))
+		case '_one_or_more':
+			x = _one_or_more(_expression(*p))
+		case '_and_predicate':
+			x = _and_predicate(_expression(*p))
+		case '_not_predicate':
+			x = _not_predicate(_expression(*p))
+		case '_sequence':
+			x = _sequence(*[_expression(e) for e in p])
+		case '_prioritized_choice':
+			x = _prioritized_choice(*[_expression(e) for e in p])
+		case '_definition':
+			A,e = p
+			x = _definition(A,_expression(e),e)
+		case '_rules':
+			x = _rules(*p)
+		case _:
+			raise DefinitionError(f'Unrecognized primitive: {f}')
+	return x
+
+#================================================================================
+# Stream Class
+#================================================================================
+class Stream:
+	def __init__(self,stream,G):
+		self._stream = stream
+		self._cursor = 0
+		self._hwm = 0
+		self.G = G
+
+	def __repr__(self):
+		return "{1}.{0.__class__.__name__}({0._stream})".format(self,__package__)
+
+	def stream(self):
+		return self._stream[self._cursor:]
+
+	def cursor(self):
+		return self._cursor
+
+	def forward(self,i):
+		self._cursor += i
+		self._hwm = max(self._cursor,self._hwm)
+
+	def backtracking(self,i):
+		self._cursor = i
+
+# EOF

pegase-1.0.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: pegase
+Version: 1.0.0
+Summary: Parsing Expression Grammar Abstract Syntax Extension
+Author: Shinichiro Ikeda
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Pegase
+Parsing Expression Grammar Abstract Syntax Extension
+
+
+# Overview
+Pegase is a parsing module implemented in Python based on "Parsing Expression Grammars: A Recognition-Based Syntactic Foundation," a paper presented by Bryan Ford of the Massachusetts Institute of Technology at POPL 2004 (ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages).
+The PEG paper is available at https://bford.info/pub/lang/peg/.
+
+The Pegase grammar object (G) defines a grammar based on externally provided syntax rules and non-terminal objects, and provides functionality to perform parsing via its `parse` method.
+The parsing result is constructed and output as a syntax tree composed of non-terminal objects.
+
+When parsing syntax definitions written in PEG, you can use the PEG-compliant syntax rules and non-terminal objects built into Pegase to execute the parse and obtain the resulting syntax rules.
+
+# Usage
+A grammar object in Pegase is created by instantiating the `G` class from the `pegase` package. When creating the grammar object, you specify the following parameters: the package name (VN) defining the non-terminal symbol objects, the S-expression (R) defining the syntax rules, and the name (eS) of the S-expression serving as the starting point for parsing. If these parameters are omitted, the internal VN, R, and eS values ​​for PEG grammar parsing within the `pegase` package are used.
+
+```
+from pegase import G
+PEG = G()
+```
+
+By parsing the grammar definition of a programming language (written in PEG syntax) using this PEG grammar object (PEG), you can obtain an abstract syntax tree; evaluating this tree allows you to derive the syntax rules (R) for the programming language.
+
+As an example, we will define a language capable of performing the four basic arithmetic operations and save it as `basic-calc.peg`.
+
+```basic-calc.peg
+expr <- term (('+' / '-') term)*
+term <- factor (('*' / '/') factor)*
+factor <- [0-9]+ / '(' expr ')'
+```
+
+We parse this grammar definition file (basic-calc.peg) using the `parse` method of the previously created PEG grammar object, and then evaluate the resulting abstract syntax tree (AST) to obtain the syntax rules (R) of basic-calc.peg.
+
+```
+basic_ST = PEG.parse('basic-calc.peg')
+basic_R = basic_ST.evaluate()
+```
+
+The evaluation logic for each node of the abstract syntax tree is implemented as a Python package, where the names of the PEG grammar's non-terminal symbols serve as class names. In the arithmetic operation example presented here, we define classes named `expr`, `term`, and `factor` to represent the non-terminal symbol objects.
+
+Create a Python package named `basic-calc_VN.py` containing non-terminal symbol objects for a language that supports the four basic arithmetic operations.
+
+```python:basic-calc_VN.py
+from functools import reduce
+from pegase import A
+
+def calc(x,opcode,y):
+  match opcode:
+    case '+':
+      return x + y
+    case '-':
+      return x- y
+    case '*':
+      return x * y
+    case '/':
+      return x / y
+
+class _expr(A):
+  def evaluate(self):
+    return reduce(lambda x,y:calc(x,y[0],y[1].evaluate()),[('+',self.value[0])] if len(self.value) == 1 else [('+',self.value[0])] + list(zip(self.value[1::2],self.value[2::2])),0)
+
+class _term(A):
+  def evaluate(self):
+    return reduce(lambda x,y:calc(x,y[0],y[1].evaluate()),[('+',self.value[0])] if len(self.value) == 1 else [('+',self.value[0])] + list(zip(self.value[1::2],self.value[2::2])),0)
+
+class _factor(A):
+  def evaluate(self):
+    match self.value[0]:
+      case '(':
+        return self.value[1].evaluate()
+      case _:
+        return int(''.join(self.value))
+```
+
+A grammar object for a language supporting the four basic arithmetic operations is generated based on the non-terminal symbol object name, syntax rules, and the start symbol name; the result of the arithmetic operation is then obtained by parsing a mathematical expression using the grammar object's `parse` method and evaluating the result.
+
+Create the main program for the four basic arithmetic operations as `basic-calc.py`.
+
+```python:basic-calc.py
+import sys
+from pegase import G
+
+if __name__ == '__main__':
+  PEG = G()
+  basic_ST = PEG.parse('basic-calc.peg')
+  basic_R = basic_ST.evaluate()
+  basic_G = G('basic-calc_VN',basic_R,'expr')
+  result = basic_G.parse(sys.argv[1]).evaluate()
+  print(result)
+```
+
+
+The execution results are as follows.
+
+```
+$ python basic-calc.py '1+2*3/(4-5)'
+-5.0
+```

pegase-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pegase/LICENSE,sha256=GMEwjerQru8MF-_DbBCbU9cvQyiirI2PDCIcQh4ejyk,1067
+pegase/LICENSE.jp,sha256=DiIT58eb7DLyPfc1GUTeCwqfpc4ICeLk_w-vXfpUHpE,1423
+pegase/README.md,sha256=agwOM7kyj6ZEeVI1GP4jNIp2f6SuHToHLPUb_7pf6xU,5446
+pegase/__init__.py,sha256=Nquww0UHn_v7I-5n6wN9IK9hjEfhlyQDyl1qJq1b7z0,209
+pegase/flatten.py,sha256=ZwdK5beqwcVtT5-AkureljeB0sbBsqrGidmDVXKy-5s,1782
+pegase/grammar.py,sha256=Gd8hjDS2ihdK37mY9voMkV_DGqaANmSWUcoimwvgjnQ,7539
+pegase/nonterminal.py,sha256=AUQZkLvJGr2PEFOVjvygYSGg2Vt0_bYgkWa4SuB44no,2358
+pegase/peg.peg,sha256=nYjMzQ-QPtMJunP95V9dqx6Uf2jIGgYEFNHb-o51zFk,1027
+pegase/peg.py,sha256=HoaPhtdxRtERsbkHtFfCD4hTKjRb4A7EWo9OfKX_Yzg,11819
+pegase/pegase_gen_R.py,sha256=w9wD8IGkgT3INo0500nLQbpIpBfAlGFgcJUnqpJ8z_8,2777
+pegase/primitive.py,sha256=7IKPLVCwYVuvcdEewqUj-NUgCrQWgZyS3DQLTgwOt-E,11940
+pegase-1.0.0.dist-info/METADATA,sha256=m-QEx2GU_oIaiPzmt0fv8ycmnxhJFIPaKbzeThbR-y8,4668
+pegase-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pegase-1.0.0.dist-info/top_level.txt,sha256=dtrPD-lRnVSj8wFyh1Kr0vQtWt1y_MdEy1T-7ZLfkvo,7
+pegase-1.0.0.dist-info/RECORD,,

pegase-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pegase-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pegase