Building AST (Abstract Syntax Tree): Module node

Using Nodes:

Pyrser provide 2 ways to fill nodes:

  • Capture with :

    In the DSL, CREATE a node and STORE the result of a rule in it:

    R = [
        ThisRuleReturnSomethingIn_ : weCaptureInThisNode
    ThisRuleReturnSomethingIn_ = [
  • Binding with :>

    Change the content of a previously CREATED node to the result of a rule:

    R = [
        Create : aNodeHere

    You could use __scope__ to create a node from scratch. It’s common to use it with binding:

    R = [
        __scope__:B  //
    loop = [
        #addBim(bim, i) // bim is a node visible here but attached to the scope of R

    In the previous rule, Bla is optional. So his content is only bind to B when Bla is parsed.

Life Cycle and Visibility:

Nodes lives and is visible thru rules in a logical way:

R = [
    // _ is the return of R
    aRule : A
        // A is visible and live
        anotherRule1 : B
        anotherRule2 : C
        // B die
        // C die
        anotherRule3 : D
    // D die
// A die

anotherRule1 = [
    // A live
    // _ is the return of anotherRule1
    doSomething1 #doOn(A)

anotherRule2 = [
    // A is visible and lives
    // B is visible and lives
    // _ is the return of anotherRule2
    doSomething2 #doOn(A, B)

anotherRule3 = [
    // A is visible and lives
    // _ is the return of anotherRule3

They are no difference between created nodes or binded nodes for the visibility/live cycle.

Python API: class Node

Basic classes for AST manipulation

class pyrser.parsing.node.Node[source]

Bases: dict

Base class for node manipulation.

check(self, ndict: dict, info= '') → bool[source]

Debug method, help detect cycle and/or other incoherence in a tree of Node

set(self, othernode)[source]

allow to completly mutate the node into any subclasses of Node


Allow to get the YML string representation of a Node.:

from pyrser.passes import to_yml

t = Node()
class pyrser.parsing.node.ListNode(it: []=None)[source]

Bases: object

__init__(self, it= None)[source]
append(self, d)[source]
prepend(self, d)[source]
__str__(self) → str[source]
__repr__(self) → str[source]
__len__(self) → int[source]
__iter__(self) → ListNodeItemIterator[source]
__reversed__(self) → ListNodeItemIterator[source]
_trueindex(self, k) → int[source]
_cache(self) → str[source]
index(self, v) → int[source]
count(self, v) → int[source]
get(self, k) → ListNodeItem[source]
__getitem__(self, k) → object[source]
__setitem__(self, k, d)[source]
__delitem__(self, k)[source]
class pyrser.parsing.node.ListNodeItem(data)[source]

Bases: object

__init__(self, data)[source]
__str__(self) → str[source]
__repr__(self) → str[source]
index(self, v) → int[source]
count(self, v) → int[source]
_get_slice(self, sl)[source]
__getitem__(self, k) → object[source]
__setitem__(self, k, d)[source]
__delitem__(self, k)[source]
popitem(self) → object[source]
append(self, data) → ListNodeItem[source]
prepend(self, data) → ListNodeItem[source]
class pyrser.parsing.node.ListNodeItemIterator(current: pyrser.parsing.node.ListNodeItem, reverse=False)[source]

Bases: object

__init__(self, current: ListNodeItem, reverse= False)[source]