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 <stdarg.h>
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
22
23#include <memory>
24#include <string>
25#include <vector>
26
27#include <android-base/macros.h>
28
29#include "edify/expr.h"
30#include "yydefs.h"
31#include "parser.h"
32
33extern int gLine;
34extern int gColumn;
35
36void yyerror(std::unique_ptr<Expr>* root, int* error_count, const char* s);
37int yyparse(std::unique_ptr<Expr>* root, int* error_count);
38
39struct yy_buffer_state;
40void yy_switch_to_buffer(struct yy_buffer_state* new_buffer);
41struct yy_buffer_state* yy_scan_string(const char* yystr);
42
43// Convenience function for building expressions with a fixed number
44// of arguments.
45static Expr* Build(Function fn, YYLTYPE loc, size_t count, ...) {
46    va_list v;
47    va_start(v, count);
48    Expr* e = new Expr(fn, "(operator)", loc.start, loc.end);
49    for (size_t i = 0; i < count; ++i) {
50        e->argv.emplace_back(va_arg(v, Expr*));
51    }
52    va_end(v);
53    return e;
54}
55
56%}
57
58%locations
59
60%union {
61    char* str;
62    Expr* expr;
63    std::vector<std::unique_ptr<Expr>>* args;
64}
65
66%token AND OR SUBSTR SUPERSTR EQ NE IF THEN ELSE ENDIF
67%token <str> STRING BAD
68%type <expr> expr
69%type <args> arglist
70
71%destructor { delete $$; } expr
72%destructor { delete $$; } arglist
73
74%parse-param {std::unique_ptr<Expr>* root}
75%parse-param {int* error_count}
76%define parse.error verbose
77
78/* declarations in increasing order of precedence */
79%left ';'
80%left ','
81%left OR
82%left AND
83%left EQ NE
84%left '+'
85%right '!'
86
87%%
88
89input:  expr           { root->reset($1); }
90;
91
92expr:  STRING {
93    $$ = new Expr(Literal, $1, @$.start, @$.end);
94}
95|  '(' expr ')'                      { $$ = $2; $$->start=@$.start; $$->end=@$.end; }
96|  expr ';'                          { $$ = $1; $$->start=@1.start; $$->end=@1.end; }
97|  expr ';' expr                     { $$ = Build(SequenceFn, @$, 2, $1, $3); }
98|  error ';' expr                    { $$ = $3; $$->start=@$.start; $$->end=@$.end; }
99|  expr '+' expr                     { $$ = Build(ConcatFn, @$, 2, $1, $3); }
100|  expr EQ expr                      { $$ = Build(EqualityFn, @$, 2, $1, $3); }
101|  expr NE expr                      { $$ = Build(InequalityFn, @$, 2, $1, $3); }
102|  expr AND expr                     { $$ = Build(LogicalAndFn, @$, 2, $1, $3); }
103|  expr OR expr                      { $$ = Build(LogicalOrFn, @$, 2, $1, $3); }
104|  '!' expr                          { $$ = Build(LogicalNotFn, @$, 1, $2); }
105|  IF expr THEN expr ENDIF           { $$ = Build(IfElseFn, @$, 2, $2, $4); }
106|  IF expr THEN expr ELSE expr ENDIF { $$ = Build(IfElseFn, @$, 3, $2, $4, $6); }
107| STRING '(' arglist ')' {
108    Function fn = FindFunction($1);
109    if (fn == nullptr) {
110        std::string msg = "unknown function \"" + std::string($1) + "\"";
111        yyerror(root, error_count, msg.c_str());
112        YYERROR;
113    }
114    $$ = new Expr(fn, $1, @$.start, @$.end);
115    $$->argv = std::move(*$3);
116}
117;
118
119arglist:    /* empty */ {
120    $$ = new std::vector<std::unique_ptr<Expr>>;
121}
122| expr {
123    $$ = new std::vector<std::unique_ptr<Expr>>;
124    $$->emplace_back($1);
125}
126| arglist ',' expr {
127    UNUSED($1);
128    $$->push_back(std::unique_ptr<Expr>($3));
129}
130;
131
132%%
133
134void yyerror(std::unique_ptr<Expr>* root, int* error_count, const char* s) {
135  if (strlen(s) == 0) {
136    s = "syntax error";
137  }
138  printf("line %d col %d: %s\n", gLine, gColumn, s);
139  ++*error_count;
140}
141
142int ParseString(const std::string& str, std::unique_ptr<Expr>* root, int* error_count) {
143  yy_switch_to_buffer(yy_scan_string(str.c_str()));
144  return yyparse(root, error_count);
145}
146