114 lines
5.1 KiB
Markdown
114 lines
5.1 KiB
Markdown
[](https://travis-ci.org/salama/salama-reader)
|
|
[](http://badge.fury.io/rb/salama-reader)
|
|
[](https://codeclimate.com/github/salama/salama-reader)
|
|
[](https://codeclimate.com/github/salama/salama-reader)
|
|
|
|
## Salama Reader*
|
|
|
|
The parser part of salama is now a standalone gem. It parses ruby using Parslet and no other dependencies.
|
|
|
|
This is interesting if you want to generate executable code, like salama, but also for other things, like code analysis.
|
|
|
|
Also it is very educational, as it is very readable code, and not too much of it.
|
|
|
|
*
|
|
It looks into it's salama ball and all it sees is red. A red salama . . . ruby, yes.
|
|
|
|
### Parser
|
|
|
|
The main parser per se is in parser/salama , but it just pulls in all the parts.
|
|
|
|
All the other files are ruby modules representing aspects of the parser.
|
|
Most names are quite self explanatory, but here is a list:
|
|
|
|
- basic_type defines just that. Strings, symbols, integers, floats , also comments and space
|
|
- call_site is a function call. May be qualified, but currently must still have braches
|
|
- compound types are hash and array definitions. Hashes still need curlies
|
|
- control is if statement which still must have an else
|
|
- expression is a helper for all code allowed in a function
|
|
- function definition must have braces too
|
|
- keywords is just a list of them
|
|
- operator expression are binary operators (see also below). There's a surprising amount
|
|
- return statement are straightforward
|
|
- while still needs a do, though i think in ruby a newline is sufficient
|
|
|
|
**Transform** defines how the rules map to Ast objects.
|
|
|
|
### Ast
|
|
|
|
The Abtract Syntax Tree (ast) layer puts the parsed code into objects, so they are nice and easy to work with.
|
|
|
|
The Classes don't really define any functionality, that is done in Salama, or can be done in any code using this. Salama just adds a compile function to each class, but a visitor pattern would do just as well.
|
|
|
|
The functionality that is in there is mainly to do with testing. Equality is defined, but also **inspect** in such a way that it's output (which you get from a failing test) can be pasted straight into the test case as the expected result.
|
|
|
|
|
|
### Parslet
|
|
|
|
Parslet is really great in that it:
|
|
- does not generate code but instead gives a clean dsl to define a grammar
|
|
- uses ruby modules so one can split the grammars up
|
|
- has support for binary operators with precedence and binding
|
|
- has a separate transform stage to generate an ast layer
|
|
|
|
Especially the last point is great. Since it is separate it does not clutter up the actual grammar.
|
|
And it can generate a layer that has no links to the actual parser anymore, thus saving/automating
|
|
a complete transformation process.
|
|
|
|
### Todo
|
|
|
|
A random list of things left for the future
|
|
|
|
- extract commonality of function call/definition,array, hash and multi assignment comma lists
|
|
- break and next
|
|
- blocks
|
|
- more loops, i'm not even sure what ruby supports
|
|
- ifs without else, also elsif
|
|
- negative tests
|
|
|
|
### Operators
|
|
|
|
Parslets operator support is **outstanding** and such it was a breeze to implement most of rubies operators very simply. See the operators.rb for details. Below is a list from the web of how it should be.
|
|
|
|
|
|
Operator list from http://stackoverflow.com/questions/21060234/ruby-operator-precedence-table
|
|
|
|
N A M Operator(s) Description
|
|
- - - ----------- -----------
|
|
1 R Y ! ~ + boolean NOT, bitwise complement, unary plus
|
|
(unary plus may be redefined from Ruby 1.9 with +@)
|
|
|
|
2 R Y ** exponentiation
|
|
1 R Y - unary minus (redefine with -@)
|
|
|
|
2 L Y * / % multiplication, division, modulo (remainder)
|
|
2 L Y + - addition (or concatenation), subtraction
|
|
|
|
2 L Y << >> bitwise shift-left (or append), bitwise shift-right
|
|
2 L Y & bitwise AND
|
|
|
|
2 L Y | ^ bitwise OR, bitwise XOR (exclusive OR)
|
|
2 L Y < <= >= > ordering
|
|
|
|
2 N Y == === != =~ !~ <=> equality, pattern matching, comparison
|
|
(!= and !~ may not be redefined prior to Ruby 1.9)
|
|
|
|
2 L N && boolean AND
|
|
2 L N || boolean OR
|
|
|
|
2 N N .. ... range creation (inclusive and exclusive)
|
|
and boolean flip-flops
|
|
|
|
3 R N ? : ternary if-then-else (conditional)
|
|
2 L N rescue exception-handling modifier
|
|
|
|
2 R N = assignment
|
|
2 R N **= *= /= %= += -= assignment
|
|
2 R N <<= >>= assignment
|
|
2 R N &&= &= ||= |= ^= assignment
|
|
|
|
1 N N defined? test variable definition and type
|
|
1 R N not boolean NOT (low precedence)
|
|
2 L N and or boolean AND, boolean OR (low precedence)
|
|
2 N N if unless while until conditional and loop modifiers
|