aidl_language_y.yy

%{
#include "aidl_language.h"
#include "aidl_language_y.h"
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int yylex(yy::parser::semantic_type *, yy::parser::location_type *, void *);

#define lex_scanner ps->Scanner()

%}

%parse-param { Parser* ps }
%lex-param { void *lex_scanner }

%pure-parser
%glr-parser
%skeleton "glr.cc"

%expect-rr 0

%error-verbose

%union {
    AidlToken* token;
    int integer;
    std::string *str;
    AidlAnnotation* annotation;
    std::set<std::unique_ptr<AidlAnnotation>>* annotation_list;
    AidlTypeSpecifier* type;
    AidlTypeSpecifier* unannotated_type;
    AidlArgument* arg;
    AidlArgument::Direction direction;
    AidlConstantValue* constant_value;
    std::vector<std::unique_ptr<AidlArgument>>* arg_list;
    AidlVariableDeclaration* variable;
    std::vector<std::unique_ptr<AidlVariableDeclaration>>* variable_list;
    AidlMethod* method;
    AidlMember* constant;
    std::vector<std::unique_ptr<AidlMember>>* interface_members;
    AidlQualifiedName* qname;
    AidlInterface* interface;
    AidlParcelable* parcelable;
    AidlDefinedType* declaration;
    AidlDocument* declaration_list;
    std::vector<std::unique_ptr<AidlTypeSpecifier>>* type_args;
}

%token<token> ANNOTATION "annotation"
%token<token> C_STR "string literal"
%token<token> HEXVALUE "hex literal"
%token<token> IDENTIFIER "identifier"
%token<token> INTERFACE "interface"
%token<token> ONEWAY "oneway"
%token<integer> INTVALUE "int literal"

%token '(' ')' ',' '=' '[' ']' '<' '>' '.' '{' '}' ';'
%token CONST "const"
%token UNKNOWN "unrecognized character"
%token CPP_HEADER "cpp_header"
%token IMPORT "import"
%token IN "in"
%token INOUT "inout"
%token OUT "out"
%token PACKAGE "package"
%token PARCELABLE "parcelable"

%type<declaration_list> decls
%type<declaration> decl
%type<variable_list> variable_decls
%type<variable> variable_decl
%type<interface_members> interface_members
%type<declaration> unannotated_decl
%type<interface> interface_decl
%type<parcelable> parcelable_decl
%type<method> method_decl
%type<constant> constant_decl
%type<annotation> annotation
%type<annotation_list>annotation_list
%type<type> type
%type<unannotated_type> unannotated_type
%type<arg_list> arg_list
%type<arg> arg
%type<direction> direction
%type<type_args> type_args
%type<qname> qualified_name
%type<constant_value> constant_value

%type<token> identifier error
%%
document
 : package imports decls
  { ps->SetDocument($3); }
 ;

/* A couple of tokens that are keywords elsewhere are identifiers when
 * occurring in the identifier position. Therefore identifier is a
 * non-terminal, which is either an IDENTIFIER token, or one of the
 * aforementioned keyword tokens.
 */
identifier
 : IDENTIFIER
  { $$ = $1; }
 | CPP_HEADER
  { $$ = new AidlToken("cpp_header", ""); }
 ;

package
 : {}
 | PACKAGE qualified_name ';'
  { ps->SetPackage($2); };

imports
 : {}
 | import imports {};

import
 : IMPORT qualified_name ';'
  { ps->AddImport($2, @1.begin.line); };

qualified_name
 : identifier {
    $$ = new AidlQualifiedName($1->GetText(), $1->GetComments());
    delete $1;
  }
 | qualified_name '.' identifier
  { $$ = $1;
    $$->AddTerm($3->GetText());
    delete $3;
  };

decls
 : /* empty */
  { $$ = new AidlDocument(); }
 | decls decl {
   $$ = $1;
   $$->AddDefinedType($2);
  }
 ;

decl
 : annotation_list unannotated_decl
   {
    $$ = $2;

    if ($$->AsUnstructuredParcelable() != nullptr && !$1->empty()) {
      std::cerr << ps->FileName() << ":" << @1 << ": unstructured parcelables cannot be annotated"
                << std::endl;
      ps->AddError();
    }

    $$->Annotate(std::move(*$1));
    delete $1;
   }
 ;

unannotated_decl
 : parcelable_decl
  { $$ = $1; }
 | interface_decl
  { $$ = $1; }
 ;

parcelable_decl
 : PARCELABLE qualified_name ';' {
    $$ = new AidlParcelable($2, @2.begin.line, ps->Package());
    ps->GetTypenames().AddDefinedType($$);
  }
 | PARCELABLE qualified_name CPP_HEADER C_STR ';' {
    $$ = new AidlParcelable($2, @2.begin.line, ps->Package(), $4->GetText());
    ps->GetTypenames().AddDefinedType($$);
  }
 | PARCELABLE identifier '{' variable_decls '}' {
    AidlQualifiedName* name = new AidlQualifiedName($2->GetText(), $2->GetComments());
    $$ = new AidlStructuredParcelable(name, @2.begin.line, ps->Package(), $4);
    ps->GetTypenames().AddDefinedType($$);
 }
 | PARCELABLE error ';' {
    ps->AddError();
    $$ = NULL;
  };

variable_decls
 : /* empty */ {
    $$ = new std::vector<std::unique_ptr<AidlVariableDeclaration>>; }
 | variable_decls variable_decl {
    $$ = $1;
    if ($2 != nullptr) {
      $$->push_back(std::unique_ptr<AidlVariableDeclaration>($2));
    }
 };

variable_decl
 : type identifier ';' {
   $$ = new AidlVariableDeclaration($1, $2->GetText(), @2.begin.line);
 }
 | type identifier '=' constant_value ';' {
   $$ = new AidlVariableDeclaration($1, $2->GetText(), @2.begin.line, $4);
 }
 | error ';' {
   ps->AddError();
   $$ = nullptr;
 }

interface_decl
 : INTERFACE identifier '{' interface_members '}' {
    $$ = new AidlInterface($2->GetText(), @1.begin.line, $1->GetComments(),
                           false, $4, ps->Package());
    ps->GetTypenames().AddDefinedType($$);
    delete $1;
    delete $2;
  }
 | ONEWAY INTERFACE identifier '{' interface_members '}' {
    $$ = new AidlInterface($3->GetText(), @2.begin.line, $1->GetComments(),
                           true, $5, ps->Package());
    ps->GetTypenames().AddDefinedType($$);
    delete $1;
    delete $2;
    delete $3;
  }
 | INTERFACE error '{' interface_members '}' {
    ps->AddError();
    $$ = nullptr;
    delete $1;
    delete $2;
    delete $4;
  };

interface_members
 :
  { $$ = new std::vector<std::unique_ptr<AidlMember>>(); }
 | interface_members method_decl
  { $1->push_back(std::unique_ptr<AidlMember>($2)); }
 | interface_members constant_decl
  { $1->push_back(std::unique_ptr<AidlMember>($2)); }
 | interface_members error ';' {
    ps->AddError();
    $$ = $1;
  };

constant_value
 : INTVALUE { $$ = AidlConstantValue::LiteralInt($1); }
 | HEXVALUE {
    $$ = AidlConstantValue::ParseHex($1->GetText(), @1.begin.line);
    delete $1;
  }
 | C_STR {
    $$ = AidlConstantValue::ParseString($1->GetText(), @1.begin.line);
    delete $1;
  }
 ;

constant_decl
 : CONST type identifier '=' constant_value ';' {
    $$ = new AidlConstantDeclaration($2, $3->GetText(), $5, @3.begin.line);
    delete $3;
   }
 ;

method_decl
 : type identifier '(' arg_list ')' ';' {
    $$ = new AidlMethod(false, $1, $2->GetText(), $4, @2.begin.line,
                        $1->GetComments());
    delete $2;
  }
 | ONEWAY type identifier '(' arg_list ')' ';' {
    $$ = new AidlMethod(true, $2, $3->GetText(), $5, @3.begin.line,
                        $1->GetComments());
    delete $1;
    delete $3;
  }
 | type identifier '(' arg_list ')' '=' INTVALUE ';' {
    $$ = new AidlMethod(false, $1, $2->GetText(), $4, @2.begin.line,
                        $1->GetComments(), $7);
    delete $2;
  }
 | ONEWAY type identifier '(' arg_list ')' '=' INTVALUE ';' {
    $$ = new AidlMethod(true, $2, $3->GetText(), $5, @3.begin.line,
                        $1->GetComments(), $8);
    delete $1;
    delete $3;
  };

arg_list
 :
  { $$ = new std::vector<std::unique_ptr<AidlArgument>>(); }
 | arg {
    $$ = new std::vector<std::unique_ptr<AidlArgument>>();
    $$->push_back(std::unique_ptr<AidlArgument>($1));
  }
 | arg_list ',' arg {
    $$ = $1;
    $$->push_back(std::unique_ptr<AidlArgument>($3));
  };

arg
 : direction type identifier {
    $$ = new AidlArgument($1, $2, $3->GetText(), @3.begin.line);
    delete $3;
  }
 | type identifier {
    $$ = new AidlArgument($1, $2->GetText(), @2.begin.line);
    delete $2;
  }
 | error {
    ps->AddError();
  };

unannotated_type
 : qualified_name {
    $$ = new AidlTypeSpecifier($1->GetDotName(), false, nullptr, @1.begin.line,
                               $1->GetComments());
    ps->DeferResolution($$);
    delete $1;
  }
 | qualified_name '[' ']' {
    $$ = new AidlTypeSpecifier($1->GetDotName(), true, nullptr, @1.begin.line,
                               $1->GetComments());
    ps->DeferResolution($$);
    delete $1;
  }
 | qualified_name '<' type_args '>' {
    $$ = new AidlTypeSpecifier($1->GetDotName(), false, $3, @1.begin.line,
                               $1->GetComments());
    ps->DeferResolution($$);
    delete $1;
  };

type
 : annotation_list unannotated_type {
    $$ = $2;
    $2->Annotate(std::move(*$1));
    delete $1;
  };

type_args
 : unannotated_type {
    $$ = new std::vector<std::unique_ptr<AidlTypeSpecifier>>();
    $$->emplace_back($1);
  }
 | type_args ',' unannotated_type {
    $1->emplace_back($3);
  };

annotation_list
 :
  { $$ = new std::set<unique_ptr<AidlAnnotation>>(); }
 | annotation_list annotation
  {
    if ($2 != nullptr) {
      $1->insert(std::unique_ptr<AidlAnnotation>($2));
    }
  };

annotation
 : ANNOTATION
  {
    std::string error;
    AidlAnnotation* annot = new AidlAnnotation($1->GetText(), error);
    if (error != "") {
      std::cerr << ps->FileName() << ":" << @1 << ": ";
      std::cerr << error << std::endl;
      ps->AddError();
      $$ = nullptr;
    } else {
      $$ = annot;
    }
  };

direction
 : IN
  { $$ = AidlArgument::IN_DIR; }
 | OUT
  { $$ = AidlArgument::OUT_DIR; }
 | INOUT
  { $$ = AidlArgument::INOUT_DIR; };

%%

#include <ctype.h>
#include <stdio.h>

void yy::parser::error(const yy::parser::location_type& l,
                       const std::string& errstr) {
  std::cerr << ps->FileName() << ":" << l << ": " << errstr << std::endl;
}