1%{
2/*
3 * Copyright (C) 2009 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18#include <stdio.h>
19#include <stdlib.h>
20#include <string.h>
21
22#include <memory>
23#include <string>
24#include <vector>
25
26#include <android-base/macros.h>
27
28#include "edify/expr.h"
29#include "yydefs.h"
30#include "parser.h"
31
32extern int gLine;
33extern int gColumn;
34
35void yyerror(std::unique_ptr<Expr>* root, int* error_count, const char* s);
36int yyparse(std::unique_ptr<Expr>* root, int* error_count);
37
38struct yy_buffer_state;
39void yy_switch_to_buffer(struct yy_buffer_state* new_buffer);
40struct yy_buffer_state* yy_scan_string(const char* yystr);
41
42// Convenience function for building expressions with a fixed number
43// of arguments.
44static Expr* Build(Function fn, YYLTYPE loc, size_t count, ...) {
45    va_list v;
46    va_start(v, count);
47    Expr* e = new Expr(fn, "(operator)", loc.start, loc.end);
48    for (size_t i = 0; i < count; ++i) {
49        e->argv.emplace_back(va_arg(v, Expr*));
50    }
51    va_end(v);
52    return e;
53}
54
55%}
56
57%locations
58
59%union {
60    char* str;
61    Expr* expr;
62    std::vector<std::unique_ptr<Expr>>* args;
63}
64
65%token AND OR SUBSTR SUPERSTR EQ NE IF THEN ELSE ENDIF
66%token <str> STRING BAD
67%type <expr> expr
68%type <args> arglist
69
70%destructor { delete $$; } expr
71%destructor { delete $$; } arglist
72
73%parse-param {std::unique_ptr<Expr>* root}
74%parse-param {int* error_count}
75%define parse.error verbose
76
77/* declarations in increasing order of precedence */
78%left ';'
79%left ','
80%left OR
81%left AND
82%left EQ NE
83%left '+'
84%right '!'
85
86%%
87
88input:  expr           { root->reset($1); }
89;
90
91expr:  STRING {
92    $$ = new Expr(Literal, $1, @$.start, @$.end);
93}
94|  '(' expr ')'                      { $$ = $2; $$->start=@$.start; $$->end=@$.end; }
95|  expr ';'                          { $$ = $1; $$->start=@1.start; $$->end=@1.end; }
96|  expr ';' expr                     { $$ = Build(SequenceFn, @$, 2, $1, $3); }
97|  error ';' expr                    { $$ = $3; $$->start=@$.start; $$->end=@$.end; }
98|  expr '+' expr                     { $$ = Build(ConcatFn, @$, 2, $1, $3); }
99|  expr EQ expr                      { $$ = Build(EqualityFn, @$, 2, $1, $3); }
100|  expr NE expr                      { $$ = Build(InequalityFn, @$, 2, $1, $3); }
101|  expr AND expr                     { $$ = Build(LogicalAndFn, @$, 2, $1, $3); }
102|  expr OR expr                      { $$ = Build(LogicalOrFn, @$, 2, $1, $3); }
103|  '!' expr                          { $$ = Build(LogicalNotFn, @$, 1, $2); }
104|  IF expr THEN expr ENDIF           { $$ = Build(IfElseFn, @$, 2, $2, $4); }
105|  IF expr THEN expr ELSE expr ENDIF { $$ = Build(IfElseFn, @$, 3, $2, $4, $6); }
106| STRING '(' arglist ')' {
107    Function fn = FindFunction($1);
108    if (fn == nullptr) {
109        std::string msg = "unknown function \"" + std::string($1) + "\"";
110        yyerror(root, error_count, msg.c_str());
111        YYERROR;
112    }
113    $$ = new Expr(fn, $1, @$.start, @$.end);
114    $$->argv = std::move(*$3);
115}
116;
117
118arglist:    /* empty */ {
119    $$ = new std::vector<std::unique_ptr<Expr>>;
120}
121| expr {
122    $$ = new std::vector<std::unique_ptr<Expr>>;
123    $$->emplace_back($1);
124}
125| arglist ',' expr {
126    UNUSED($1);
127    $$->push_back(std::unique_ptr<Expr>($3));
128}
129;
130
131%%
132
133void yyerror(std::unique_ptr<Expr>* root, int* error_count, const char* s) {
134  if (strlen(s) == 0) {
135    s = "syntax error";
136  }
137  printf("line %d col %d: %s\n", gLine, gColumn, s);
138  ++*error_count;
139}
140
141int ParseString(const std::string& str, std::unique_ptr<Expr>* root, int* error_count) {
142  yy_switch_to_buffer(yy_scan_string(str.c_str()));
143  return yyparse(root, error_count);
144}
145