Guts is a language makes your life easier, it allows you to write less code to produce equivalent PHP code.

Guts compiler is written in Go, Go is faster than PHP, thus the compilation is fast, and of course you can compile sources concurrently.

For more details, please check the docs for the language synopsis.

• simple to learn.
• easy to use.
• fast compilation.
• shorter code.
• phpdoc friendly.

Simply run make to produce the parser:

git clone http://github.com/c9s/gutscript
cd gutscript
source goenv
make

For more language details, please check the docs for the language synopsis.

class Person
    # Print the name
    say :: (name) -> "Hello #{name}, Good morning"

    getPhone :: -> "12345678"

    setName :: (string name) -> @name = name

if str =~ /[a-z]/
    say "matched!"

The above code compiles to:

class Person {
    /**
     * Print the name
     * 
     * @param mixed $name
     */
    function say($name) {
        return "Hello " . $name . ', Good morning';
    }

    function getPhone() {
        return "12345678";
    }

    /**
     * @param string $name
     */
    function setName($name) {
        $this->name = $name;
    }
}
if ( preg_match('[a-z]',$str) ) {
    echo "matched!";
}

The file extension is named with "*.gs", the compiler compiles your .gs files to .php files.

To make guts compiler compatible with PHP, there are some syntax are simplified but the derived syntax shouldn't break the compiler.

(Move to separated doc file later)

Defining const can be done by the same syntax of PHP.

const VAR = 10;

$foo = 'string'; // explicitly defined without type

var $foo = 'string'; // explicitly defined and  implicitly typed

int $foo = 10; // explicitly defined and explicitly typed

string $foo = "foo bar"; // explicitly defined and explicitly typed

string[] $list = []; // define an array of string.

...

string[string] $contacts = []; // define a map for string -> string
$contacts["foo"] = "bar";
$contacts[0] = "bar"; // compilation error

The keyword function is optional, not required.

foo(Type $foo, Type $bar) : ReturnType {

}

The code below works

<?php
class Foo extends Bar implements DoorLocker {
}

But you can also write:

<?php
class Foo is Bar does DoorLocker {

}

The inheritance syntax was derived from Perl6, see https://doc.perl6.org/language/objects#Inheritance for more details.

PHP method syntax still works in guts:

class Buffer {
    public function write($string) { ... }
}

However you can also do:

class Buffer {
    public write($string) : bool { ... }
}

The function keyword can be ignored.

To override a parent method, you can add a keyword "override" to explicitly define the override method.

class EncodedBuffer is Buffer {
    override public write($string) : bool { ... }
}

When -Wmethod-implicitly-override option is enabled, method overriding without override keyword will throw out the warning messages:

...

Defining namespace is as the same as PHP:

namespace foo\bar;

• Implement a parser that parses PHP5.3
• Getter generator

Guts uses Go yacc parser generator to generate a LALR(1) parser.

To add new syntax, please checkout the parser.y file, which is located in src/gutscript/parser.y

The lexer uses concurrent strategy to parse tokens, the state machine runs in another goroutine, so the parser receives the tokens from lexer through the channel concurrently.

Codegen is expected to be a separated tree structure traverser, and which is not implemented inside the ast node structure like the coffee-script codegen. So the code generator can be PHP code generator, LLVM bit-code generator or JavaScript generator.

Basic optimization is on the roadmap. Optimizer uses tree-pattern matching strategy to traverse the IR structure. 2 basic optimizations are in the plan -- constant folding and dead code elimination.

Not ready for production. this project is still in alpha stage. but I'd like to recevie comments, patches and feature requests.

Feature requests, pull requests, comments are welcomed, but please discuss first on our GitHub issue. Just feel free to drop a line there.

First, go get a workable go compiler at http://golang.org

Run the below command to setup GOPATH:

source goenv

Run make to build and test:

make

If you modified the grammar, remember to update the parser:

make parser

Run test cases:

make test

To dump lex tokens:

go run utils/lexdump/main.go src/gutscript/tests/09_class_properties.guts

Test the command tool with test case:

./bin/guts src/gutscript/tests/03_if_else_statement.guts

| Rule                

--- | ------------------- x | assignment statement x | if statement x | if else statement x | if elseif else statement x | function statement x | function param list x | empty class x | class with properties x | class with methods x | function call as expr o | string concatenation o | list structure o | hash structure o | for block o | dot range o | static method call o | method call as expr. o | assignment from method call o | namespace design o | map

Yo-An Lin ([email protected])

Join us on irc.freenode.net #gutscript

MIT License Copyright (c) 2012 Yo-An Lin

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.