LAVM/md_parser.y

%{

#include "experimental/LAVM/md_grammar.h"

#include <cstdio>

extern int md_scannerleng;
extern char* md_scannertext;
void yyerror(const char* s);

extern void def_clause_init();
extern void def_clause_done();
extern void def_clause_set_name(const char*);
extern void def_clause_set_mnemonics(const char*);
extern void def_clause_add_inout(const char*, const char*, bool);
extern void def_clause_set_pattern(PatternNode*);
extern void def_clause_set_llvm(const char*);

// Macro magic.
int md_scannerlex();
#define yylex md_scannerlex

%}

%union {
  char* str;
  struct PatternNode* pattern_node_ptr;
  struct PatternNodePtrList* pattern_node_ptr_list_ptr;
}

// All grammar tokens.
%token       MD TARGET MAP MEMORY ARROW INTEGER
%token <str> DEF TYPEEXPR TENSOR VAR ID QID STRING
%token       DEF_MNEMONICS DEF_OUTS DEF_INS DEF_PATTERN DEF_LLVM

%type <str>                       id def_pattern_op mnemonics llvm str_lit
%type <pattern_node_ptr>          def_pattern def_pattern_arg
%type <pattern_node_ptr_list_ptr> optional_def_pattern_arg_list
%type <pattern_node_ptr_list_ptr> def_pattern_arg_list


%start clauses

%%

clauses : clauses clause
        |
        ;

clause  : target_clause
        | map_clause
        | memory_clause
        | md_clause
        ;

md_clause          : MD '{' def_clause_list '}' { printf("md clause\n"); }
                   ;

def_clause_list    : def_clause_list def_clause
                   |
                   ;

def_clause         : DEF { def_clause_init(); } QID { def_clause_set_name($3); }
                     '{' def_list '}' { def_clause_done(); }
                   ;

def_list           : def_list def ';'
                   |
                   ;

def                : DEF_MNEMONICS '=' mnemonics
                     { def_clause_set_mnemonics($3); }
                   | DEF_OUTS '='
                     '(' { parsing_outs = true; } optional_inouts_list ')'
                   | DEF_INS '='
                     '(' { parsing_outs = false; } optional_inouts_list ')'
                   | DEF_PATTERN '=' def_pattern { def_clause_set_pattern($3); }
                   | DEF_LLVM '=' llvm { def_clause_set_llvm($3); }
                   ;

mnemonics          : str_lit { $$ = $1; }
                   ;

optional_inouts_list : inouts_list
                     |
                     ;

inouts_list        : inouts_list ',' inout
                   | inout
                   ;

inout              : id ':' id { def_clause_add_inout($1, $3, parsing_outs); }
                   ;

def_pattern        : '(' def_pattern_op optional_def_pattern_arg_list ')'
                     { $$ = PatternNode::CreateInternal($2, $3); }
                   ;

def_pattern_op     : id
                   ;

optional_def_pattern_arg_list : def_pattern_arg_list { $$ = $1; }
                              | { $$ = PatternNodePtrList::CreateEmpty(); }
                              ;

def_pattern_arg_list : def_pattern_arg_list ',' def_pattern_arg
                       { $$ = PatternNodePtrList::Append($1, $3); }
                     | def_pattern_arg
                       { $$ = PatternNodePtrList::Append(
                         PatternNodePtrList::CreateEmpty(), $1); }
                     ;

def_pattern_arg    : def_pattern { $$ = $1; }
                   | id ':' id  { $$ = PatternNode::CreateLeaf($1, $3); }
                   ;

llvm               : id { $$ = $1; }
                   ;

target_clause      : TARGET '{' target_list '}' { printf("target clause\n"); }
                   ;

map_clause         : MAP    '{' map_list    '}' { printf("map clause\n");    }
                   ;

memory_clause      : MEMORY '{' memory_list '}' { printf("memory clause\n"); }
                   ;

target_list        : target_list target
                   |
                   ;

map_list           : map_list map
                   |
                   ;

memory_list        : memory_list memory
                   |
                   ;

target             : id '(' optional_var_list ')' ':' toplevel_type_list ';'
                   ;

map                : id '(' optional_var_list ')' ':' pattern_list ';'
                   ;

memory             : id ':' xid '=' xid ';'
                   | id ARROW mem_red   ';'
                   ;

optional_var_list  : var_list
                   |
                   ;

var_list           : var_list ',' VAR
                   | VAR
                   ;

toplevel_type_list : toplevel_type_list ',' toplevel_type
                   | toplevel_type
                   ;

optional_type_list : type_list
                   |
                   ;

type_list          : type_list ',' type
                   | type
                   ;

pattern_list       : pattern_list ',' pattern
                   | pattern
                   ;

pattern            : id '(' pattern_list ')'
                   | VAR
                   ;

toplevel_type      : type optional_cost
                   ;

type               : id
                   | TYPEEXPR
                   | TENSOR
                   | '(' optional_type_list ')' ARROW type
                   | '(' optional_type_list ')' ARROW '(' optional_type_list ')'
                   ;

optional_cost      : '@' INTEGER
                   |
                   ;

mem_red            : mem_red ARROW xid
                   | xid
                   ;

id                 : ID { $$ = $1; }
                   | QID { $$ = $1; }
                   ;

xid                : id
                   | TYPEEXPR
                   | str_lit
                   ;

str_lit            : STRING  { $$ = $1; }
                   ;

%%

// Error method.
void yyerror(const char* s) {
  const int col_start = md_column + 1 - md_scannerleng;
  const int col_end  = md_column;
  fprintf(stderr, "Machine description %s %d:%d-%d\n",
          s, md_line, col_start, col_end);
}