openscad-parser.jison

/* description: Parses openscad to openjscad. */

/* lexical grammar */

%lex

%options flex


%s cond_include cond_use cond_comment cond_string cond_import

D [0-9]
E [Ee][+-]?{D}+

%%

/* Note: use and include statements here are ignored. Instead they are preprocessed. */
include[ \t\r\n>]*"<"        %{ this.begin('cond_include'); %}
<cond_include>[^\t\r\n>]*"/" %{ yy.filepath = yytext; %}
<cond_include>[^\t\r\n>/]+   %{ yy.filename = yytext; %}
<cond_include>">"            %{  this.popState(); %}

use[ \t\r\n>]*"<"           %{ this.begin('cond_use');%}
<cond_use>[^\t\r\n>]+       %{ yy.filename = yytext; %}
<cond_use>">"               %{ this.popState(); %}

"module"                    return 'TOK_MODULE'
"function"                  return 'TOK_FUNCTION'
"if"                        return 'TOK_IF'
"else"                      return 'TOK_ELSE'
"true"                      return 'TOK_TRUE'
"false"                     return 'TOK_FALSE'
"undef"                     return 'TOK_UNDEF'

<cond_string>"\\t"          %{ stringcontents += '    ';  %}
<cond_string>"\\n"          %{ stringcontents += '\n';  %}
<cond_string>"\\\""         %{ stringcontents += '\"';  %}
<cond_string>"\\r"          %{ stringcontents += '\r';  %}
<cond_string>"\\\\"         %{ stringcontents += '\\';  %}

<cond_string>"\\0"          %{ stringcontents += '\0';  %}
<cond_string>"\\a"          %{ stringcontents += '\a';  %}
<cond_string>"\\b"          %{ stringcontents += '\b';  %}
<cond_string>"\\t"          %{ stringcontents += '\t';  %}
<cond_string>"\\n"          %{ stringcontents += '\n';  %}
<cond_string>"\\v"          %{ stringcontents += '\v';  %}
<cond_string>"\\f"          %{ stringcontents += '\f';  %}
<cond_string>"\\e"          %{ stringcontents += '\e';  %}
<cond_string>[^\\\n\"]+     %{ /*"*/
                                stringcontents += yytext;
                            %}
<cond_string>"\""           %{
                                this.popState();
                                yytext = stringcontents;
                                return 'TOK_STRING';
                            %}
[\"]                        %{ /*"*/
                                this.begin('cond_string');
                                stringcontents = "";
                            %}

[\n]                        /* Ignore */
[\r\t ]                     /* Ignore */
\/\/[^\n]*\n?               /* Ignore */
\/\*.+\*\/                  /* Ignore Note: multi-line comments are removed via a preparse regex. */

{D}*\.{D}+{E}?              return 'TOK_NUMBER'
{D}+\.{D}*{E}?              return 'TOK_NUMBER'
{D}+{E}?                    return 'TOK_NUMBER'
"$"?[a-zA-Z0-9_]+           return 'TOK_ID'

"<="                        return 'LE'
">="                        return 'GE'
"=="                        return 'EQ'
"!="                        return 'NE'
"&&"                        return 'AND'
"||"                        return 'OR'

.                           return yytext;

/lex

/* operator associations and precedence */

%right '?' ':'
%left OR
%left AND
%left '<' LE GE '>'
%left EQ NE
%left '!' '+' '-'
%left '*' '/' '%'
%left '[' ']'
%left '.'

%start program

%% /* language grammar */

program:
        input
        {
            return ext.processModule(yy);
        }
    ;


input:
        /* empty */
    |   input statement
    ;

inner_input:
        /* empty */
    |   inner_input statement
    ;

statement:
        statement_begin statement_end
    ;

statement_begin:
        /*empty*/
    |   TOK_MODULE TOK_ID '(' arguments_decl optional_commas ')'
        {
            ext.stashModule($2, $4.argnames, $4.argexpr);
            delete $4;
        }
    ;

statement_end:
        ';'
        {
        }
    |   '{' inner_input '}'
        {
            ext.popModule();
        }
    |   module_instantiation
        {
            ext.addModuleChild($1);
        }
    |   TOK_ID '=' expr ';'
        {
            ext.addModuleAssignmentVar($1, $3);
        }
    |   TOK_FUNCTION TOK_ID '(' arguments_decl optional_commas ')' '=' expr ';'
        {
            ext.addModuleFunction($2, $8, $4.argnames, $4.argexpr);
            delete $4;
        }
    |   BR
    ;

children_instantiation:
        module_instantiation
        {
            $$ = new ModuleInstantiation();
            if ($1) {
                $$.children.push($1);
            }
        }
    |   '{' module_instantiation_list '}'
        {
            $$ = $2;
        }
    ;


if_statement:
        TOK_IF '(' expr ')' children_instantiation
        {
            $$ = new IfElseModuleInstantiation();
            $$.argnames.push("");
            $$.argexpr.push($3);

            if ($$) {
                $$.children = $5.children;
            } else {
                for (var i = 0; i < $5.children.size(); i++)
                    delete $5.children[i];
            }
            delete $5;
        }
    ;

ifelse_statement:
        if_statement
        {
            $$ = $1;
        }
    |   if_statement TOK_ELSE children_instantiation
        {
            $$ = $1;
            if ($$) {
                $$.else_children = $3.children;
            } else {
                for (var i = 0; i < $3.children.size(); i++)
                    delete $3.children[i];
            }
            delete $3;
        }
    ;

module_instantiation:
        single_module_instantiation ';'
        {
            $$ = $1;
        }
    |   single_module_instantiation children_instantiation
        {
            $$ = $1;
            if ($$) {
                $$.children = $2.children;
            } else {
                for (var i = 0; i < $2.children.length; i++)
                delete $2.children[i];
            }
            delete $2;
        }
    |
        ifelse_statement
        {
            $$ = $1;
        }
    ;

module_instantiation_list:
        /* empty */
        {
            $$ = new ModuleInstantiation();
        }
    |   module_instantiation_list module_instantiation
        {
            $$ = $1;
            if ($$) {
                if ($2) {
                    $$.children.push($2);
                }
            } else {
                delete $2;
            }
        }
    ;

single_module_instantiation:
        TOK_ID '(' arguments_call ')'
        {
            $$ = new ModuleInstantiation();
            $$.name = $1;
            $$.argnames = $3.argnames;
            $$.argexpr = $3.argexpr;
            delete $3;
        }
    |   '!' single_module_instantiation
        {
            $$ = $2;
            if ($$) {
                $$.tag_root = true;
            }
        }
    |   '#' single_module_instantiation
        {
            $$ = $2;
            if ($$) {
                $$.tag_highlight = true;
            }
        }
    |   '%' single_module_instantiation
        {
            /* - NOTE: Currently unimplemented, therefore not displaying parts marked with %
                $$ = $2;
                if ($$) {
                    $$.tag_background = true;
                }
            */
            delete $2;
            $$ = undefined;
        }
    |   '*' single_module_instantiation
        {
            delete $2;
            $$ = undefined;
        }
    ;

expr:
        TOK_TRUE
        {
            $$ = new Expression(true);
        }
    |   TOK_FALSE
        {
            $$ = new Expression(false);
        }
    |   TOK_UNDEF
        {
            $$ = new Expression(undefined);
        }
    |   TOK_ID
        {
            $$ = new Expression();
            $$.type = "L";
            $$.var_name = $1;
        }
    |   expr '.' TOK_ID
        {
            $$ = new Expression();
            $$.type = "N";
            $$.children.push($1);
            $$.var_name = $3;
        }
    |   TOK_STRING
        {
            $$ = new Expression(String($1));
        }
    |   TOK_NUMBER
        {
            $$ = new Expression(Number($1));
        }
    |   '[' expr ':' expr ']'
        {
            var e_one = new Expression(1.0);
            $$ = new Expression();
            $$.type = "R";
            $$.children.push($2);
            $$.children.push(e_one);
            $$.children.push($4);
        }
    |   '[' expr ':' expr ':' expr ']'
        {
            $$ = new Expression();
            $$.type = "R";
            $$.children.push($2);
            $$.children.push($4);
            $$.children.push($6);
        }
    |   '[' optional_commas ']'
        {
            $$ = new Expression([]);
        }
    |   '[' vector_expr optional_commas ']'
        {
            $$ = $2;
        }
    |   expr '*' expr
        {
            $$ = new Expression();
            $$.type = '*';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr '/' expr
        {
            $$ = new Expression();
            $$.type = '/';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr '%' expr
        {
            $$ = new Expression();
            $$.type = '%';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr '+' expr
        {
            $$ = new Expression();
            $$.type = '+';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr '-' expr
        {
            $$ = new Expression();
            $$.type = '-';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr '<' expr
        {
            $$ = new Expression();
            $$.type = '<';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr LE expr
        {
            $$ = new Expression();
            $$.type = '<=';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr EQ expr
        {
            $$ = new Expression();
            $$.type = '==';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr NE expr
        {
            $$ = new Expression();
            $$.type = '!=';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr GE expr
        {
            $$ = new Expression();
            $$.type = '>=';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr '>' expr
        {
            $$ = new Expression();
            $$.type = '>';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr AND expr
        {
            $$ = new Expression();
            $$.type = '&&';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   expr OR expr
        {
            $$ = new Expression();
            $$.type = '||';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   '+' expr
        {
            $$ = $2;
        }
    |   '-' expr
        {
            $$ = new Expression();
            $$.type = 'I';
            $$.children.push($2);
        }
    |   '!' expr
        {
            $$ = new Expression();
            $$.type = '!';
            $$.children.push($2);
        }
    |   '(' expr ')'
            { $$ = $2; }
    |   expr '?' expr ':' expr
        {
            $$ = new Expression();
            $$.type = '?:';
            $$.children.push($1);
            $$.children.push($3);
            $$.children.push($5);
        }
    |   expr '[' expr ']'
        {
            $$ = new Expression();
            $$.type = '[]';
            $$.children.push($1);
            $$.children.push($3);
        }
    |   TOK_ID '(' arguments_call ')'
        {
            $$ = new Expression();
            $$.type = 'F';
            $$.call_funcname = $1;
            $$.call_argnames = $3.argnames;
            $$.children = $3.argexpr;
            delete $3;
        }
    ;

optional_commas:
        ',' optional_commas
    |
    ;

vector_expr:
        expr
        {
            $$ = new Expression();
            $$.type = 'V';
            $$.children.push($1);
        }
    |   vector_expr ',' optional_commas expr
        {
            $$ = $1;
            $$.children.push($4);
        }
    ;

arguments_decl:
        /* empty */
        {
            $$ = new ArgsContainer();
        }
    |   argument_decl
        {
            $$ = new ArgsContainer();
            $$.argnames.push($1.argname);
            $$.argexpr.push($1.argexpr);
            delete $1;
        }
    |   arguments_decl ',' optional_commas argument_decl
        {
            $$ = $1;
            $$.argnames.push($4.argname);
            $$.argexpr.push($4.argexpr);
            delete $4;
        }
    ;

argument_decl:
        TOK_ID
        {
            $$ = new ArgContainer();
            $$.argname = $1;
            $$.argexpr = undefined;
        }
    |   TOK_ID '=' expr
        {
            $$ = new ArgContainer();
            $$.argname = $1;
            $$.argexpr = $3;
        }
    ;

arguments_call:
        /* empty */
        {
            $$ = new ArgsContainer();
        }
    |   argument_call
        {
            $$ = new ArgsContainer();
            $$.argnames.push($1.argname);
            $$.argexpr.push($1.argexpr);
            delete $1;
        }
    |   arguments_call ',' optional_commas argument_call
        {
            $$ = $1;
            $$.argnames.push($4.argname);
            $$.argexpr.push($4.argexpr);
            delete $4;
        }
    ;

argument_call:
        expr
        {
            $$ = new ArgContainer();
            $$.argexpr = $1;
        }
    |   TOK_ID '=' expr
        {
            $$ = new ArgContainer();
            $$.argname = $1;
            $$.argexpr = $3;
        }
    ;

%%