Jean-Damien Durand

In order to transpile JavaScript to (any language but first) perl(5), I wanted to have a generic methodology, independent of the target language. The proof of concept being the default transpiling of JavaScript to JavaScript.

Marpa::R2, came again to the rescue: Marpa allows the programmer to have introspection on the grammar. This mean that one can:

• generate automatically a package based on the introspection to do the transpilation


• use an AST that would contain the rule Ids which, together with the previously mentionned generated package, allows to transpile JavaScript to any target language.

Let's be concrete: If, in the Marpa grammar, you specify an action in the userspace like that:

:default ::= action => valuesAndRuleId
lexeme default = action => [start,length,value]

The valuesAndRuleId method beeing:

sub valuesAndRuleId {
  my $self = shift;
  return {values => [ @_ ], ruleId => $Marpa::R2::Context::rule};
}

This mean that, in the parse tree value of the grammar:

• every lexeme (let's say terminal) will have an associated value that is a reference to an array with three items:




1. start: the position in the stream


2. length: the length


3. value: the terminal itself




• every G1 (let's say non-terminal) rule will have an associated value that is a reference to hash with the following structure:




1. ruleId: the nonn-terminal rule Id


2. values: a reference to all RHS values

Let's evaluate the parse tree value of a simple JavaScript source code:

var i;

using the grammar in the __DATA__ section of this package. This will be:

$VAR1 = {
    'ruleId' => 230,
    'values' => [
    {
        'ruleId' => 227,
        'values' => [
        {
            'values' => [
            {
                'ruleId' => 233,
                'values' => [
                {
                    'values' => [
                    {
                        'values' => [
                        [
                         0,
                         3,
                         'var'
                        ],
                        {
                            'values' => [
                            {
                                'values' => [
                                [
                                 4,
                                 1,
                                 'i'
                                ],
                                {
                                    'values' => [],
                                    'ruleId' => 171
                                }
                                ],
                                'ruleId' => 168
                            }
                            ],
                            'ruleId' => 164
                        },
                        [
                         5,
                         1,
                         ';'
                        ]
                        ],
                        'ruleId' => 163
                    }
                    ],
                    'ruleId' => 146
                }
                ]
            }
            ],
            'ruleId' => 231
        }
        ]
    }
    ]
};

Now, using the generated transpilation package, one can reproduce a source code that would give the same AST as the original.

This is not only a proof of concept, but the starting point of JavaScript::Transpile, that should be a generic JavaScript transpilator, with perl5 as main target, providing also (yet another) a JavaScript running engine: the original source code will be transformed to an AST using MarpaX::Languages::ECMAScript::AST, then transpiled to perl.

Here is an example of full JavaScript to JavaScript of jquery-1.10.2, (the same here). This looks like jquery. But this is *not* a cut/paste of jquery. This is transpilation of JavaScript to JavaScript via an AST produced by Marpa.
Nothing prevents to transpile to another target language -;