Forked jakubledl\dissect

Author: WalterWoshid

.gitignore

@@ -0,0 +1,3 @@
+vendor/
+composer.phar
+composer.lock

.idea/dissect.iml

@@ -0,0 +1,14 @@
+language: php
+
+php:
+    - 5.3
+    - 5.4
+
+branches:
+    only:
+        - master
+        - develop
+
+before_script:
+    - wget http://getcomposer.org/composer.phar
+    - php composer.phar dump-autoload

.idea/misc.xml

@@ -0,0 +1,12 @@
+Changelog
+=========
+
+1.0.1 (2013-01-29)
+------------------
+
+- 2b40f94: Fixed an invalid format in the CLI
+
+1.0.0 (2013-01-15)
+------------------
+
+- First release.

.idea/modules.xml

@@ -0,0 +1,13 @@
+# Welcome to Dissect!
+- [master](https://github.com/jakubledl/dissect/tree/master) [![build status](https://travis-ci.org/jakubledl/dissect.png?branch=master)](https://travis-ci.org/jakubledl/dissect) - this branch always contains the last stable version.
+- [develop](https://github.com/jakubledl/dissect) [![build status](https://travis-ci.org/jakubledl/dissect.png?branch=develop)](https://travis-ci.org/jakubledl/dissect) - the unstable development branch.
+
+Dissect is a set of tools for lexical and syntactical analysis written
+in pure PHP.
+
+Documentation?
+--------------
+
+[Here][docs].
+
+[docs]: https://github.com/jakubledl/dissect/blob/master/docs/index.md

.travis.yml

@@ -0,0 +1,18 @@
+Goals
+=====
+
+1.1
+---
+
+- Optional operator precedence support (à la *yacc*, *bison*) - ✔
+- A performance-oriented regex lexer (based on doctrine/lexer) - ✔
+- An option to generate a hybrid recursive ascent parser - □
+
+1.0
+---
+
+- Compute reduction lookahead by the channel algorithm from *yacc*
+  instead of the current LALR-by-SLR algorithm - ✔
+- Change the analyzer API to allow for grammar debugging
+  (provide access to resolved conflicts, dumping the automaton to DOT ...) - ✔
+- Provide classes for dumping the parse table to PHP (both the dev & prod version) - ✔

CHANGELOG.md

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author
+of this software dedicates any and all copyright interest in the
+software to the public domain. I make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. I intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 AUTHOR 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.
+
+For more information, please refer to <http://unlicense.org/>

README.md

@@ -0,0 +1,4 @@
+#!/usr/bin/env php
+<?php
+
+require __DIR__ . '/dissect.php';

TODO.md

@@ -0,0 +1,30 @@
+<?php
+
+define('DISSECT_VERSION', 'DEV');
+
+if (is_dir($vendor = getcwd() . '/vendor')) {
+    require $vendor . '/autoload.php';
+}
+
+if (is_dir($vendor = __DIR__ . '/../vendor')) {
+    require $vendor . '/autoload.php';
+} elseif (is_dir($vendor = __DIR__ . '/../../../../vendor')) {
+    require $vendor . '/autoload.php';
+} else {
+    die(
+        'You must set up the project dependencies.' . PHP_EOL .
+        'To do that, run the following commands:' . PHP_EOL . PHP_EOL .
+        '$ curl -s http://getcomposer.org/installer | php' . PHP_EOL .
+        '$ php composer.phar install' . PHP_EOL
+    );
+}
+
+if (!class_exists('Symfony\Component\Console\Application')) {
+    die(
+        'You must install the symfony/console package in order ' .
+        'to use the command-line tool.' . PHP_EOL
+    );
+}
+
+$app = new Dissect\Console\Application(DISSECT_VERSION);
+$app->run();

UNLICENSE

@@ -0,0 +1,31 @@
+{
+    "name": "jakubledl/dissect",
+    "description": "Lexing and parsing in pure PHP",
+    "keywords": ["lexing", "parsing", "ast", "parser"],
+    "homepage": "https://github.com/jakubledl/dissect",
+    "license": "unlicense",
+    "authors": [
+        {
+            "name": "Jakub Lédl",
+            "email": "[email protected]"
+        }
+    ],
+
+    "require": {
+        "php": ">=5.3.3"
+    },
+
+    "require-dev": {
+        "symfony/console": "~2.1"
+    },
+
+    "suggest": {
+        "symfony/console": "for the command-line tool"
+    },
+
+    "bin": ["bin/dissect.php", "bin/dissect"],
+
+    "autoload": {
+        "psr-0": { "Dissect": ["src/"] }
+    }
+}

bin/dissect

@@ -0,0 +1,141 @@
+Building an AST
+===============
+
+Often, when parsing a language that's more complex than
+[mathematical expressions][prev], you will want to represent
+the input as an *abstract syntax tree*, or AST (for a real-life
+example, see [Twig][twig-ast] or [Gherkin][gherkin-ast]).
+
+Getting the AST of the input with Dissect is nothing special; the
+callbacks in your grammar can return anything, so they might as well
+return AST nodes. Dissect however helps you by providing a simple base
+class for the different node types: `Dissect\Node\CommonNode`.
+
+Let's say we want to create an AST for the mathematical expressions from
+the previous chapter. Since the input can consist of binary operations
+and integers, let's create a subclass for each case:
+
+```php
+use Dissect\Node\CommonNode;
+use Dissect\Node\Node;
+
+class BinaryExpressionNode extends CommonNode
+{
+    const PLUS = 1;
+    const TIMES = 2;
+    const POWER = 3;
+
+    public function __construct(Node $left, $op, Node $right)
+    {
+        parent::__construct(['operator' => $op], [
+            'left' => $left,
+            'right' => $right,
+        ]);
+    }
+
+    public function getLeft()
+    {
+        return $this->getNode('left');
+    }
+
+    public function getRight()
+    {
+        return $this->getNode('right');
+    }
+
+    public function getOperator()
+    {
+        return $this->getAttribute('operator');
+    }
+}
+
+class IntNode extends CommonNode
+{
+    public function __construct($value)
+    {
+        parent::__construct(['value' => $value]);
+    }
+
+    public function getValue()
+    {
+        return $this->getAttribute('value');
+    }
+}
+```
+
+The original constructor has two parameters, an array of child nodes and
+an array of node attributes. `Dissect\Node\Node` is an interface
+describing common operations for an AST node.
+
+We can now easily modify the original grammar to build the AST:
+
+```php
+$this('Additive')
+    ->is('Additive', '+', 'Multiplicative')
+    ->call(function ($l, $_, $r) {
+        return new BinaryExpressionNode($l, BinaryExpressionNode::PLUS, $r);
+    })
+
+    ->is('Multiplicative');
+
+$this('Multiplicative')
+    ->is('Multiplicative', '*', 'Power')
+    ->call(function ($l, $_, $r) {
+        return new BinaryExpressionNode($l, BinaryExpressionNode::TIMES, $r);
+    })
+
+    ->is('Power');
+
+$this('Power')
+    ->is('Primary', '**', 'Power')
+    ->call(function ($l, $_, $r) {
+        return new BinaryExpressionNode($l, BinaryExpressionNode::POWER, $r);
+    })
+
+    ->is('Primary');
+
+$this('Primary')
+    ->is('(', 'Additive', ')')
+    ->call(function ($_, $e, $_) {
+        return $e;
+    })
+
+    ->is('INT')
+    ->call(function ($int) {
+        return new IntNode((int)$int->getValue());
+    });
+```
+
+Traversing the AST
+------------------
+
+When we have the AST of our input, we want to interpret it somehow.
+The most common way to do this is to create a *node visitor* (sometimes
+called a *tree walker*). A trivial node visitor for our example could be
+the following recursive function:
+
+```php
+function visit(Node $node)
+{
+    if ($node instanceof BinaryExpressionNode) {
+        switch ($node->getOperator()) {
+            case BinaryExpressionNode::PLUS:
+                return visit($node->getLeft()) + visit($node->getRight());
+            case BinaryExpressionNode::TIMES:
+                return visit($node->getLeft()) * visit($node->getRight());
+            case BinaryExpressionNode::POWER:
+                return pow(visit($node->getLeft()), visit($node->getRight());
+        }
+    } elseif ($node instanceof IntNode) {
+        return $node->getValue();
+    } else {
+        throw new \Exception("Unknown node type.");
+    }
+}
+
+echo visit($parser->parse(...));
+```
+
+[prev]: parsing.md#example-parsing-mathematical-expressions
+[twig-ast]: https://github.com/fabpot/Twig/tree/master/lib/Twig/Node
+[gherkin-ast]: https://github.com/Behat/Gherkin/tree/master/src/Behat/Gherkin/Node