/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*
 *  Main authors:
 *     Guido Tack <guido.tack@monash.edu>
 */

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

%define api.pure

%parse-param {void *parm}

%define api.header.include {<minizinc/parser.tab.hh>}

%lex-param {void* SCANNER}
%{
#define SCANNER static_cast<ParserState*>(parm)->yyscanner
#include <iostream>
#include <fstream>
#include <map>
#include <cerrno>
#include <regex>

namespace MiniZinc{ class ParserLocation; }
#define YYLTYPE MiniZinc::ParserLocation
#define YYLTYPE_IS_DECLARED 1
#define YYLTYPE_IS_TRIVIAL 0

#define YYMAXDEPTH 10000
#define YYINITDEPTH 10000

#include <minizinc/parser.hh>
#include <minizinc/file_utils.hh>

using namespace std;
using namespace MiniZinc;

#define YYLLOC_DEFAULT(Current, Rhs, N) \
  do { \
    if (N > 0) { \
      (Current).filename(YYRHSLOC(Rhs, 1).filename()); \
      (Current).firstLine(YYRHSLOC(Rhs, 1).firstLine()); \
      (Current).firstColumn(YYRHSLOC(Rhs, 1).firstColumn()); \
      (Current).lastLine(YYRHSLOC(Rhs, N).lastLine()); \
      (Current).lastColumn(YYRHSLOC(Rhs, N).lastColumn()); \
    } else { \
      (Current).filename(YYRHSLOC(Rhs, 0).filename()); \
      (Current).firstLine(YYRHSLOC(Rhs, 0).lastLine()); \
      (Current).firstColumn(YYRHSLOC(Rhs, 0).lastColumn()); \
      (Current).lastLine(YYRHSLOC(Rhs, 0).lastLine()); \
      (Current).lastColumn(YYRHSLOC(Rhs, 0).lastColumn()); \
    } \
  } while (false)

int mzn_yyparse(void*);
int mzn_yylex(YYSTYPE*, YYLTYPE*, void* scanner);
int mzn_yylex_init (void** scanner);
int mzn_yylex_destroy (void* scanner);
int mzn_yyget_lineno (void* scanner);
void mzn_yyset_extra (void* user_defined ,void* yyscanner );

extern int yydebug;

namespace MiniZinc {

void yyerror(YYLTYPE* location, void* parm, const string& str) {
  ParserState* pp = static_cast<ParserState*>(parm);
  Model* m = pp->model;
  std::vector<ASTString> includeStack;
  while (m->parent() != nullptr) {
    m = m->parent();
    includeStack.push_back(m->filename());
  }
  auto currentLine = pp->getCurrentLine(location->firstColumn(), location->lastColumn());
  pp->hadError = true;
  pp->syntaxErrors.emplace_back(Location(*location), currentLine, includeStack, str);
}

bool notInDatafile(YYLTYPE* location, void* parm, const string& item) {
  ParserState* pp = static_cast<ParserState*>(parm);
  if (pp->isDatafile) {
    yyerror(location,parm,item+" item not allowed in data file");
    return false;
  }
  return true;
}

Expression* createDocComment(const ParserLocation& loc, const std::string& s) {
  std::vector<Expression*> args(1);
  args[0] = new StringLit(loc, s);
  Call* c = Call::a(Location(loc), Constants::constants().ann.doc_comment, args);
  Expression::type(c, Type::ann());
  return c;
}

Expression* createAccess(const ParserLocation& loc, Expression* e, const std::vector<Expression*>& idx) {
  Expression* ret = e;
  for (auto* expr : idx) {
    // Set location of access expression (TODO: can this be more accurate?)
    Expression::loc(expr, loc);

    // Insert member being accessed
    if (auto* fa = Expression::dynamicCast<FieldAccess>(expr)) {
      fa->v(ret);
    } else {
      auto* aa = Expression::cast<ArrayAccess>(expr);
      aa->v(ret);
    }

    // Set access expression as current incumbent
    ret = expr;
  }
  return ret;
}

// Variant of definition in lexer.lxx
IntVal fast_strtointval(const std::string& s) {
  MiniZinc::IntVal x = 0;
  try {
    for (size_t i = 0; i < s.size(); ++i) {
      x = (x*10) + (s[i] - '0');
    }
  } catch (MiniZinc::ArithmeticError&) {
    return false;
  }
  return x;
}

void parseFieldTail(const ParserLocation& loc, std::vector<Expression*>& parsed, const std::string& tail) {
  auto it = tail.begin();
  auto isWS = [&]() {
    return (*it == ' ' || *it == '\f' || *it == '\xd' || *it == '\t');
  };
  while (it != tail.end()) {
    // skip whitespace and dot
    while(isWS()) { ++it; }
    assert(*it == '.'); // otherwise error in the lexer regex
    ++it;
    while(isWS()) { ++it; }

    // parse field name
    auto field_start = it;
    bool is_num = isdigit(*it);
    std::string field;
    if (*it == '\'') {
      ++field_start;
      ++it;
      while (*it != '\'') {
        ++it;
        assert(it != tail.end()); // otherwise error in the lexer regex
      }
      field = std::string(field_start, it);
      ++it;
    } else {
      while (it != tail.end() && !isWS() && *it != '.') {
        is_num = is_num && isdigit(*it);
        ++it;
      }
      field = std::string(field_start, it);
    }

    // emit field
    Expression* field_expr = nullptr;
    if (is_num) {
      IntVal fieldVal = MiniZinc::fast_strtointval(field);
      field_expr = IntLit::a(fieldVal);
    } else {
      field_expr = new Id(loc, field, nullptr);
    }
    parsed.push_back({ new FieldAccess(loc, nullptr, field_expr) });
  }
}

}

%}

%union { long long int iValue; char* sValue; bool bValue; double dValue;
         MiniZinc::Item* item;
         MiniZinc::VarDecl* vardeclexpr;
         std::vector<MiniZinc::VarDecl*>* vardeclexprs;
         MiniZinc::TypeInst* tiexpr;
         std::vector<MiniZinc::TypeInst*>* tiexprs;
         MiniZinc::Expression* expression;
         std::vector<MiniZinc::Expression*>* expressions1d;
         std::vector<std::vector<MiniZinc::Expression*> >* expressions2d;
         std::vector<std::pair<std::vector<MiniZinc::Expression*>,std::vector<MiniZinc::Expression*>>>* indexedexpressions2d;
         std::pair<std::vector<MiniZinc::Expression*>,std::vector<MiniZinc::Expression*>>* indexedexpression2d;
         std::vector<std::vector<std::vector<MiniZinc::Expression*> > >* expressions3d;
         MiniZinc::Generator* generator;
         std::vector<MiniZinc::Generator>* generators;
         std::vector<std::string>* strings;
         std::vector<std::pair<MiniZinc::Expression*,MiniZinc::Expression*> >* expressionPairs;
         MiniZinc::Generators* generatorsPointer;
       }

%locations
%define parse.error verbose

%initial-action
{
  GCLock lock;
  @$.filename(ASTString(static_cast<ParserState*>(parm)->filename));
}

%token <iValue> MZN_INTEGER_LITERAL "integer literal" MZN_BOOL_LITERAL "bool literal"
%token <dValue> MZN_FLOAT_LITERAL "float literal"
%token <sValue> MZN_IDENTIFIER "identifier" MZN_QUOTED_IDENTIFIER "quoted identifier" MZN_STRING_LITERAL "string literal"
%token <sValue> MZN_STRING_QUOTE_START "interpolated string start" MZN_STRING_QUOTE_MID "interpolated string middle" MZN_STRING_QUOTE_END "interpolated string end"
%token <sValue> MZN_TI_IDENTIFIER "type-inst identifier" MZN_TI_ENUM_IDENTIFIER "type-inst enum identifier" MZN_DOC_COMMENT "documentation comment" MZN_DOC_FILE_COMMENT "file-level documentation comment"
%token <sValue> MZN_FIELD_TAIL "field access"

%token MZN_VAR "var" MZN_PAR "par"

%token MZN_ABSENT "<>"
%token MZN_ANN "ann"
%token MZN_ANNOTATION "annotation"
%token MZN_ANY "any"
%token MZN_ARRAY "array"
%token MZN_BOOL "bool"
%token MZN_CASE "case"
%token MZN_CONSTRAINT "constraint"
%token MZN_DEFAULT "default"
%token MZN_ELSE "else"
%token MZN_ELSEIF "elseif"
%token MZN_ENDIF "endif"
%token MZN_ENUM "enum"
%token MZN_FLOAT "float"
%token MZN_FUNCTION "function"
%token MZN_IF "if"
%token MZN_INCLUDE "include"
%token MZN_INFINITY "infinity"
%token MZN_INT "int"
%token MZN_LET "let"
%token MZN_LIST "list"
%token <bValue> MZN_MAXIMIZE "maximize"
%token <bValue> MZN_MINIMIZE "minimize"
%token MZN_OF "of"
%token MZN_OPT "opt"
%token MZN_SATISFY "satisfy"
%token MZN_OUTPUT "output"
%token MZN_PREDICATE "predicate"
%token MZN_RECORD "record"
%token MZN_SET "set"
%token MZN_SOLVE "solve"
%token MZN_STRING "string"
%token MZN_TEST "test"
%token MZN_THEN "then"
%token MZN_TUPLE "tuple"
%token MZN_TYPE "type"
%token MZN_UNDERSCORE "_"
%token MZN_VARIANT_RECORD "variant_record"
%token MZN_WHERE "where"
%token MZN_MAX_NEGATIVE_INTEGER_LITERAL "9223372036854775808"

%token MZN_LEFT_BRACKET "["
%token MZN_LEFT_2D_BRACKET "[|"
%token MZN_RIGHT_BRACKET "]"
%token MZN_RIGHT_2D_BRACKET "|]"

// Used to signal an error when parsing a FlatZinc file
// that contains quoted identifiers
%token QUOTED_IDENTIFIER

%token MZN_INVALID_INTEGER_LITERAL "invalid integer literal"
%token MZN_INVALID_FLOAT_LITERAL "invalid float literal"
%token MZN_UNTERMINATED_STRING "unterminated string"
%token MZN_END_OF_LINE_IN_STRING "end of line inside string literal"
%token MZN_INVALID_NULL "null character"
%token MZN_INVALID_STRING_LITERAL "invalid string literal"

%token END 0 "end of file"

%token MZN_EQUIV "<->"
%token MZN_IMPL "->" MZN_RIMPL "<-"
%token MZN_OR "\\/" MZN_XOR "xor"
%token MZN_AND "/\\"
%token MZN_LE "<" MZN_GR ">" MZN_LQ "<=" MZN_GQ ">=" MZN_EQ "=" MZN_NQ "!=" MZN_WEAK_EQ "~=" MZN_WEAK_NQ "~!="
%token MZN_IN "in" MZN_SUBSET "subset" MZN_SUPERSET "superset"
%token MZN_UNION "union" MZN_DIFF "diff" MZN_SYMDIFF "symdiff"
%token MZN_DOTDOT ".."
%token MZN_DOTDOT_LE "..<"
%token MZN_LE_DOTDOT "<.."
%token MZN_LE_DOTDOT_LE "<..<"
%token MZN_PLUS "+" MZN_MINUS "-" MZN_WEAK_PLUS "~+" MZN_WEAK_MINUS "~-"
%token MZN_MULT "*" MZN_DIV "/" MZN_IDIV "div" MZN_MOD "mod" MZN_WEAK_DIV "~/" MZN_WEAK_IDIV "~div"
%token MZN_INTERSECT "intersect" MZN_WEAK_MULT "~*"
%token MZN_POW "^"
%token MZN_POW_MINUS1 "^-1"
%token MZN_NOT "not"
%token MZN_PLUSPLUS "++"
%token MZN_COLONCOLON "::"

%right PREC_ANNO
%left MZN_EQUIV
%left MZN_IMPL MZN_RIMPL
%left MZN_OR MZN_XOR
%left MZN_AND
%nonassoc MZN_LE MZN_GR MZN_LQ MZN_GQ MZN_EQ MZN_NQ MZN_WEAK_EQ MZN_WEAK_NQ
%nonassoc MZN_IN MZN_SUBSET MZN_SUPERSET
%left MZN_UNION MZN_DIFF MZN_SYMDIFF
%left MZN_INTERSECT
%nonassoc MZN_DOTDOT MZN_DOTDOT_LE MZN_LE_DOTDOT MZN_LE_DOTDOT_LE
%left MZN_PLUS MZN_MINUS MZN_WEAK_PLUS MZN_WEAK_MINUS
%left MZN_MULT MZN_DIV MZN_IDIV MZN_MOD MZN_WEAK_MULT MZN_WEAK_DIV MZN_WEAK_IDIV
%left MZN_POW MZN_POW_MINUS1
%nonassoc MZN_NOT
%left MZN_PLUSPLUS
%left MZN_DEFAULT
%left MZN_QUOTED_IDENTIFIER
%left MZN_COLONCOLON

%token MZN_EQUIV_QUOTED "'<->'"
%token MZN_IMPL_QUOTED "'->'" MZN_RIMPL_QUOTED "'<-'"
%token MZN_OR_QUOTED "'\\/'" MZN_XOR_QUOTED "'xor'"
%token MZN_AND_QUOTED "'/\\'"
%token MZN_LE_QUOTED "'<'" MZN_GR_QUOTED "'>'" MZN_LQ_QUOTED "'<='" MZN_GQ_QUOTED "'>='" MZN_EQ_QUOTED "'='" MZN_NQ_QUOTED "'!='"
%token MZN_IN_QUOTED "'in'" MZN_SUBSET_QUOTED "'subset'" MZN_SUPERSET_QUOTED "'superset'"
%token MZN_UNION_QUOTED "'union'" MZN_DIFF_QUOTED "'diff'" MZN_SYMDIFF_QUOTED "'symdiff'"
%token MZN_DOTDOT_QUOTED "'..'"
%token MZN_LE_DOTDOT_QUOTED "'<..'"
%token MZN_DOTDOT_LE_QUOTED "'..<'"
%token MZN_LE_DOTDOT_LE_QUOTED "'<..<'"
%token MZN_PLUS_QUOTED "'+'" MZN_MINUS_QUOTED "'-'"
%token MZN_MULT_QUOTED "'*'" MZN_DIV_QUOTED "'/'" MZN_IDIV_QUOTED "'div'" MZN_MOD_QUOTED "'mod'" MZN_INTERSECT_QUOTED "'intersect'"
%token MZN_POW_QUOTED "'^'"
%token MZN_NOT_QUOTED "'not'"
%token MZN_COLONCOLON_QUOTED "'::'"
%token MZN_PLUSPLUS_QUOTED "'++'"

%type <item> item item_tail include_item vardecl_item assign_item constraint_item solve_item output_item predicate_item annotation_item function_item

%type <vardeclexpr> ti_expr_and_id ti_expr_and_id_or_anon let_vardecl_item ann_param  record_field
%type <vardeclexprs> params params_list params_list_head
%type <tiexpr> ti_expr base_ti_expr base_ti_expr_tail
%type <tiexprs> ti_expr_list ti_expr_list_head
%type <vardeclexprs> ti_expr_and_id_list ti_expr_and_id_list_head

%type <expression> expr expr_atom_head expr_atom_head_nonstring array_access_expr
%type <expression> set_expr string_expr string_quote_rest annotation_expr enum_construct
%type <expression> simple_array_literal simple_array_literal_2d simple_array_comp if_then_else_expr call_expr quoted_op_call let_expr operation_item_tail set_literal set_comp tuple_literal record_literal output_annotation

%type <expressions1d> expr_list expr_list_head array_access_expr_list array_access_expr_list_head elseif_list let_vardecl_item_list enum_init enum_id_list string_lit_list access_tail record_field_list_head
%type <indexedexpression2d> comp_expr_list comp_expr_list_head
%type <expressions2d> simple_array_literal_2d_list
%type <indexedexpressions2d> simple_array_literal_2d_indexed_list simple_array_literal_2d_indexed_list_head
%type <indexedexpression2d> simple_array_literal_2d_indexed_list_row simple_array_literal_2d_indexed_list_row_head
%type <expressions3d> simple_array_literal_3d_list

%type <generatorsPointer> comp_tail
%type <generator> generator generator_eq
%type <generators> generator_list generator_list_head
%type <strings> id_list id_list_head

%type <expressionPairs> comp_or_expr comp_or_expr_head

%type <expressions1d> annotations ne_annotations

%type <iValue> quoted_op

%type <sValue> id_or_quoted_op

%type <bValue> opt_opt

%%

/********************************/
/* main goal and item lists     */
/********************************/

model : item_list

item_list :
      /* empty */
    | item_list_head semi_or_none

item_list_head:
      item
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($1) {
          pp->model->addItem($1);
          GC::unlock();
          GC::lock();
        }
      }
    | doc_file_comments item
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($2) {
          pp->model->addItem($2);
          GC::unlock();
          GC::lock();
        }
      }
    | item_list_head ';' item
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($3) {
          pp->model->addItem($3);
          GC::unlock();
          GC::lock();
        }
      }
    | item_list_head ';' doc_file_comments item
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($4) {
          pp->model->addItem($4);
          GC::unlock();
          GC::lock();
        }
      }
    | item error_item_start
{ yyerror(&@2, parm, "unexpected item, expecting ';' or end of file"); YYERROR; }
    | error ';' item

doc_file_comments:
      MZN_DOC_FILE_COMMENT
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if (pp->parseDocComments && $1) {
          pp->model->addDocComment($1);
        }
        free($1);
      }
    | doc_file_comments MZN_DOC_FILE_COMMENT
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if (pp->parseDocComments && $2) {
          pp->model->addDocComment($2);
        }
        free($2);
      }

semi_or_none : | ';'

item : MZN_DOC_COMMENT item_tail
      { $$ = $2;
        ParserState* pp = static_cast<ParserState*>(parm);
        if (FunctionI* fi = Item::dynamicCast<FunctionI>($$)) {
          if (pp->parseDocComments) {
            fi->ann().add(createDocComment(@1,$1));
          }
        } else if (VarDeclI* vdi = Item::dynamicCast<VarDeclI>($$)) {
          if (pp->parseDocComments) {
            Expression::addAnnotation(vdi->e(), createDocComment(@1,$1));
          }
        } else {
          yyerror(&@2, parm, "documentation comments are only supported for function, predicate and variable declarations");
        }
        free($1);
      }
    | item_tail
      { $$ = $1; }

item_tail :
      include_item
      { $$=notInDatafile(&@$,parm,"include") ? $1 : nullptr; }
    | vardecl_item
      { $$=notInDatafile(&@$,parm, $1->cast<VarDeclI>()->e()->isTypeAlias() ? "type alias" : "variable declaration") ? $1 : nullptr; }
    | assign_item
    | constraint_item
      { $$=notInDatafile(&@$,parm,"constraint") ? $1 : nullptr; }
    | solve_item
      { $$=notInDatafile(&@$,parm,"solve") ? $1 : nullptr; }
    | output_item
      { $$=notInDatafile(&@$,parm,"output") ? $1 : nullptr; }
    | predicate_item
      { $$=notInDatafile(&@$,parm,"predicate") ? $1 : nullptr; }
    | function_item
      { $$=notInDatafile(&@$,parm,"predicate") ? $1 : nullptr; }
    | annotation_item
      { $$=notInDatafile(&@$,parm,"annotation") ? $1 : nullptr; }

error_item_start : MZN_INCLUDE | MZN_ENUM | MZN_OUTPUT
    | MZN_CONSTRAINT | MZN_SOLVE | MZN_PREDICATE | MZN_FUNCTION | MZN_TEST
    | MZN_ANNOTATION

include_item :
      MZN_INCLUDE MZN_STRING_LITERAL
      { ParserState* pp = static_cast<ParserState*>(parm);
        string canonicalName=pp->canonicalFilename($2);
        map<string,Model*>::iterator ret = pp->seenModels.find(canonicalName);
        IncludeI* ii = new IncludeI(@$,ASTString($2));
        $$ = ii;
        if (ret == pp->seenModels.end()) {
          Model* im = new Model;
          im->setParent(pp->model);
          im->setFilename(canonicalName);
          string fpath = FileUtils::dir_name(pp->filename);
          if (fpath=="")
            fpath="./";
          pp->files.emplace_back(im, ii, fpath, canonicalName, pp->isSTDLib);
          ii->m(im);
          pp->seenModels.insert(pair<string,Model*>(canonicalName,im));
        } else {
          ii->m(ret->second, false);
        }
        free($2);
      }

vardecl_item :
      ti_expr_and_id
      { if ($1) {
          if (Expression::type($1->ti()).any() && $1->ti()->domain() == nullptr) {
            // This is an any type, not allowed without a right hand side
            yyerror(&@1, parm, "declarations with `any' type-inst require definition");
          }
          $$ = VarDeclI::a(@$,$1);
        }
      }
    | ti_expr_and_id MZN_EQ expr
      { 
        if ($1) {
          $1->e($3);
          $$ = VarDeclI::a(@$,$1);
        }
      }
    | MZN_ENUM MZN_IDENTIFIER annotations
      {
        TypeInst* ti = new TypeInst(@$,Type::parsetint());
        ti->setIsEnum(true);
        VarDecl* vd = new VarDecl(@$,ti,$2);
        if ($2 && $3)
        Expression::addAnnotations(vd, *$3);
        free($2);
        $$ = VarDeclI::a(@$,vd);
      }
    | MZN_ENUM MZN_IDENTIFIER annotations MZN_EQ enum_init
      {
        if ($5) {
          TypeInst* ti = new TypeInst(@$,Type::parsetint());
          ti->setIsEnum(true);
          Expression* e;
          if ($5->size()==1) {
            e = (*$5)[0];
          } else {
            ArrayLit* al = new ArrayLit(@$,*$5);
            e = Call::a(@$, ASTString("enumFromConstructors"), {al});
          }
          VarDecl* vd = new VarDecl(@$,ti,$2,e);
          $$ = VarDeclI::a(@$,vd);
        }
        free($2);
        delete $5;
      }
    | MZN_ENUM MZN_IDENTIFIER annotations MZN_EQ MZN_LEFT_BRACKET string_lit_list MZN_RIGHT_BRACKET
      {
        TypeInst* ti = new TypeInst(@$,Type::parsetint());
        ti->setIsEnum(true);
        vector<Expression*> args;
        args.push_back(new ArrayLit(@$,*$6));
        Call* sl = Call::a(@$, Constants::constants().ids.anonEnumFromStrings, args);
        VarDecl* vd = new VarDecl(@$,ti,$2,sl);
        if ($2 && $3)
        Expression::addAnnotations(vd, *$3);
        free($2);
        delete $6;
        $$ = VarDeclI::a(@$,vd);
      }
    | MZN_TYPE MZN_IDENTIFIER annotations MZN_EQ ti_expr
      {
        TypeInst* ti = $5;
        VarDecl* vd = new VarDecl(@$, nullptr, $2, ti);
        if ($3) {
          Expression::addAnnotations(vd, *$3);
        }
        free($2);
        $$ = VarDeclI::a(@$, vd);
      }

enum_init :
      enum_construct
      {
        $$ = new std::vector<Expression*>({$1});
      }
    | enum_init MZN_PLUSPLUS enum_construct
      {
        $$ = $1;
        if ($$) {
          $$->push_back($3);
        }
      }

enum_construct :
      '{' enum_id_list comma_or_none '}'
      {
        $$ = new SetLit(@$, *$2);
        delete $2;
      }
    | MZN_IDENTIFIER '(' expr ')'
      {
        vector<Expression*> args({$3});
        $$ = Call::a(@$, ASTString($1), args);
        free($1);
      }
    | MZN_UNDERSCORE '(' expr ')'
      {
        $$ = Call::a(@$, Constants::constants().ids.anon_enum_set, {$3});
      }

string_lit_list :
      // empty
      { $$ = new std::vector<Expression*>(); }
    | MZN_STRING_LITERAL
      { $$ = new std::vector<Expression*>();
        $$->push_back(new StringLit(@$, $1)); free($1);
      }
    | string_lit_list ',' MZN_STRING_LITERAL
      { $$ = $1;
        if ($$) $$->push_back(new StringLit(@$, $3));
        free($3);
      }

enum_id_list :
      // empty
      { $$ = new std::vector<Expression*>(); }
    | MZN_IDENTIFIER
      { $$ = new std::vector<Expression*>();
        $$->push_back(new Id(@$,$1,nullptr)); free($1);
      }
    | enum_id_list ',' MZN_IDENTIFIER
      { $$ = $1; if ($$) $$->push_back(new Id(@$,$3,nullptr)); free($3); }

assign_item :
      MZN_IDENTIFIER MZN_EQ expr
      { $$ = new AssignI(@$,$1,$3);
        free($1);
      }

constraint_item :
      MZN_CONSTRAINT expr
      { $$ = new ConstraintI(@$,$2);}
    | MZN_CONSTRAINT MZN_COLONCOLON string_expr expr
      { $$ = new ConstraintI(@$,$4);
        if ($4 && $3)
          Expression::ann($$->cast<ConstraintI>()->e()).add(Call::a(@2, ASTString("mzn_constraint_name"), {$3}));
      }

solve_item :
      MZN_SOLVE annotations MZN_SATISFY
      { $$ = SolveI::sat(@$);
        if ($$ && $2) $$->cast<SolveI>()->ann().add(*$2);
        delete $2;
      }
    | MZN_SOLVE annotations MZN_MINIMIZE expr
      { $$ = SolveI::min(@$,$4);
        if ($$ && $2) $$->cast<SolveI>()->ann().add(*$2);
        delete $2;
      }
    | MZN_SOLVE annotations MZN_MAXIMIZE expr
      { $$ = SolveI::max(@$,$4);
        if ($$ && $2) $$->cast<SolveI>()->ann().add(*$2);
        delete $2;
      }

output_item :
        MZN_OUTPUT expr
      { $$ = new OutputI(@$,$2); }
      | MZN_OUTPUT MZN_COLONCOLON output_annotation expr
      { $$ = new OutputI(@$,$4);
        if ($$ && $3) {
          $$->cast<OutputI>()->ann().add(Call::a(@$, ASTString("mzn_output_section"), {$3}));
        }
      }

output_annotation :
        string_expr
      { $$ = $1; }
      | MZN_IDENTIFIER '(' ')'
      { $$ = Call::a(@$, $1, std::vector<Expression*>()); free($1); }
      | MZN_IDENTIFIER '(' expr_list ')'
      { $$ = Call::a(@$, $1, *$3); free($1); }
      | '(' expr ')'
      { $$ = $2; }

predicate_item :
        MZN_PREDICATE MZN_IDENTIFIER params ann_param annotations operation_item_tail
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($3 && $4) $3->push_back($4);
        if ($3) $$ = new FunctionI(@$,ASTString($2),new TypeInst(@$,
                                   Type::varbool()),*$3,$6,pp->isSTDLib,$4 != nullptr);
        if ($$ && $5) $$->cast<FunctionI>()->ann().add(*$5);
        free($2);
        delete $3;
        delete $5;
      }
      | MZN_TEST MZN_IDENTIFIER params ann_param annotations operation_item_tail
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($3 && $4) $3->push_back($4);
        if ($3) $$ = new FunctionI(@$,ASTString($2),new TypeInst(@$,
                                   Type::parbool()),*$3,$6,pp->isSTDLib,$4 != nullptr);
        if ($$ && $5) $$->cast<FunctionI>()->ann().add(*$5);
        free($2);
        delete $3;
        delete $5;
      }
      | MZN_PREDICATE MZN_IDENTIFIER MZN_POW_MINUS1 params ann_param annotations operation_item_tail
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($4 && $5) $4->push_back($5);
        if ($4) $$ = new FunctionI(@$,ASTString(std::string($2)+"⁻¹"),new TypeInst(@$,
                                   Type::varbool()),*$4,$7,pp->isSTDLib,$5 != nullptr);
        if ($$ && $6) $$->cast<FunctionI>()->ann().add(*$6);
        free($2);
        delete $4;
        delete $6;
      }
      | MZN_TEST MZN_IDENTIFIER MZN_POW_MINUS1 params ann_param annotations operation_item_tail
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($4 && $5) $4->push_back($5);
        if ($4) $$ = new FunctionI(@$,ASTString(std::string($2)+"⁻¹"),new TypeInst(@$,
                                   Type::parbool()),*$4,$7,pp->isSTDLib,$5 != nullptr);
        if ($$ && $6) $$->cast<FunctionI>()->ann().add(*$6);
        free($2);
        delete $4;
        delete $6;
      }

function_item :
        MZN_FUNCTION ti_expr ':' id_or_quoted_op params ann_param annotations operation_item_tail
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($5 && $6) $5->push_back($6);
        if ($2 && Expression::type($2).any() && $2->domain() == nullptr) {
          // This is an any type, not allowed without a right hand side
          yyerror(&@2, parm, "return type cannot have `any' type-inst without type-inst variable");
        }
        if ($5) $$ = new FunctionI(@$,ASTString($4),$2,*$5,$8,pp->isSTDLib,$6 != nullptr);
        if ($$ && $7) $$->cast<FunctionI>()->ann().add(*$7);
        free($4);
        delete $5;
        delete $7;
      }
      | ti_expr ':' MZN_IDENTIFIER '(' params_list ')' ann_param annotations operation_item_tail
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        if ($1 && Expression::type($1).any() && $1->domain() == nullptr) {
          // This is an any type, not allowed without a right hand side
          yyerror(&@1, parm, "return type cannot have `any' type-inst without type-inst variable");
        }
        if ($5 && $7) $5->push_back($7);
        if ($5) $$ = new FunctionI(@$,ASTString($3),$1,*$5,$9,pp->isSTDLib,$7 != nullptr);
        if ($$ && $8) $$->cast<FunctionI>()->ann().add(*$8);
        free($3);
        delete $5;
        delete $8;
      }

annotation_item :
        MZN_ANNOTATION MZN_IDENTIFIER params
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        TypeInst* ti=new TypeInst(@1,Type::ann());
        if ($3==nullptr || $3->empty()) {
          VarDecl* vd = new VarDecl(@$,ti,$2);
          $$ = VarDeclI::a(@$,vd);
        } else {
          $$ = new FunctionI(@$,ASTString($2),ti,*$3,nullptr,pp->isSTDLib);
        }
        free($2);
        delete $3;
      }
    | MZN_ANNOTATION MZN_IDENTIFIER params MZN_EQ expr
      {
        ParserState* pp = static_cast<ParserState*>(parm);
        TypeInst* ti=new TypeInst(@1,Type::ann());
        if ($3) $$ = new FunctionI(@$,ASTString($2),ti,*$3,$5,pp->isSTDLib);
        delete $3;
      }

ann_param :
      /*empty*/
      { $$=nullptr; }
    | MZN_ANN ':' MZN_IDENTIFIER
      { if ($3) {
          auto* ident = new Id(@3, $3, nullptr);
          auto* ti = new TypeInst(@$,Type::ann(1));
          $$ = new VarDecl(@$, ti, ident);
          $$->toplevel(false);
        } }

operation_item_tail :
      /*empty*/
      { $$=nullptr; }
    | MZN_EQ expr
      { $$=$2; }

params :
      /* empty */
      { $$=new vector<VarDecl*>(); }
    | '(' params_list ')'
      { $$=$2; }
    | '(' error ')'
      { $$=new vector<VarDecl*>(); }

params_list :
        /* empty */
      { $$=new vector<VarDecl*>(); }
    | params_list_head comma_or_none
      { $$=$1; }

params_list_head :
      ti_expr_and_id_or_anon
      { $$=new vector<VarDecl*>();
        if ($1) {
          if (Expression::type($1->ti()).any() && $1->ti()->domain() == nullptr) {
            // This is an any type, not allowed in parameter list
            yyerror(&@1, parm, "parameter declaration cannot have `any' type-inst without type-inst variable");
          }
          $1->toplevel(false);
          $$->push_back($1);
        }
      }
    | params_list_head ',' ti_expr_and_id_or_anon
      { $$=$1;
        if ($3) $3->toplevel(false);
        if ($1 && $3) {
          $1->push_back($3);
          if (Expression::type($3->ti()).any() && $3->ti()->domain() == nullptr) {
            // This is an any type, not allowed in parameter list
            yyerror(&@3, parm, "parameter declaration cannot have `any' type-inst without type-inst variable");
          }
        }
      }

comma_or_none : | ','
pipe_or_none : | '|'

ti_expr_and_id_or_anon :
      ti_expr_and_id
      { $$=$1; }
    | ti_expr
      { if ($1) $$=new VarDecl(@$, $1, ""); }

ti_expr_and_id :
      ti_expr ':' MZN_IDENTIFIER annotations
      { if ($1 && $3) {
          Id* ident = new Id(@3, $3, nullptr);
          $$ = new VarDecl(@$, $1, ident);
          if ($4) Expression::ann($$).add(*$4);
        }
        free($3);
        delete $4;
      }

ti_expr_and_id_list : ti_expr_and_id_list_head comma_or_none
      { $$=$1; }

ti_expr_and_id_list_head :
      ti_expr_and_id
      { $$=new vector<VarDecl*>(); $$->push_back($1); }
    | ti_expr_and_id_list_head ',' ti_expr_and_id
      { $$=$1; if ($1 && $3) $1->push_back($3); }

ti_expr_list : ti_expr_list_head comma_or_none
      { $$=$1; }

ti_expr_list_head :
      ti_expr
      { $$=new vector<TypeInst*>(); $$->push_back($1); }
    | ti_expr_list_head ',' ti_expr
      { $$=$1; if ($1 && $3) $1->push_back($3); }

ti_expr :
      base_ti_expr
    | MZN_ARRAY MZN_LEFT_BRACKET ti_expr_list MZN_RIGHT_BRACKET MZN_OF ti_expr  %prec MZN_NOT
      {
        if ($6 != nullptr && $6->isarray()) {
          $$ = new TypeInst(@$, Type::tuple(), $6);
        } else {
          $$ = $6;
        }
        if ($$ != nullptr && $3 != nullptr) {
          $$->setRanges(*$3);
        }
        delete $3;
      }
    | MZN_LIST MZN_OF base_ti_expr
      {
        $$ = $3;
        std::vector<TypeInst*> ti(1);
        ti[0] = new TypeInst(@$,Type::parint());
        if ($$ != nullptr){
          $$->setRanges(ti);
        }
      }
    | ti_expr MZN_PLUSPLUS base_ti_expr
      {
        $$ = $1;
        if ($$ != nullptr) {
          Type tt = Expression::type($$);
          tt.dim(0);
          TypeInst* lhs = new TypeInst(@$, tt, $1->domain());
          BinOp* bop = new BinOp(@$, lhs, BOT_PLUSPLUS, $3);
          bop->type(tt);
          $$->domain(bop);
        }
      }

base_ti_expr :
      base_ti_expr_tail
      { $$ = $1;
      }
    | MZN_OPT base_ti_expr_tail
      { $$ = $2;
        if ($$ != nullptr) {
          Type tt = Expression::type($$);
          tt.ot(Type::OT_OPTIONAL);
          tt.otExplicit(true);
          $$->type(tt);
        }
      }
    | MZN_PAR opt_opt base_ti_expr_tail
      { $$ = $3;
        if ($$ != nullptr) {
          Type tt = Expression::type($$);
          tt.tiExplicit(true);
          if ($2) {
            tt.ot(Type::OT_OPTIONAL);
            tt.otExplicit(true);
          }
          $$->type(tt);
        }
      }
    | MZN_VAR opt_opt base_ti_expr_tail
      { $$ = $3;
        if ($$ != nullptr) {
          Type tt = Expression::type($$);
          tt.ti(Type::TI_VAR);
          tt.tiExplicit(true);
          if ($2) {
            tt.ot(Type::OT_OPTIONAL);
            tt.otExplicit(true);
          }
          $$->type(tt);
        }
      }
    | MZN_SET MZN_OF base_ti_expr_tail
      { $$ = $3;
        if ($$ != nullptr) {
          Type tt = Expression::type($$);
          tt.st(Type::ST_SET);
          $$->type(tt);
        }
      }
    | MZN_OPT MZN_SET MZN_OF base_ti_expr_tail
      { $$ = $4;
        if ($$ != nullptr) {
          Type tt = Expression::type($$);
          tt.st(Type::ST_SET);
          tt.ot(Type::OT_OPTIONAL);
          tt.otExplicit(true);
          $$->type(tt);
        }
      }
    | MZN_PAR opt_opt MZN_SET MZN_OF base_ti_expr_tail
      { $$ = $5;
        if ($$ != nullptr) {
          Type tt = Expression::type($$);
          tt.tiExplicit(true);
          tt.st(Type::ST_SET);
          if ($2) {
            tt.ot(Type::OT_OPTIONAL);
            tt.otExplicit(true);
          }
          $$->type(tt);
        }
      }
    | MZN_VAR opt_opt MZN_SET MZN_OF base_ti_expr_tail
      { $$ = $5;
        if ($$ != nullptr) {
          Type tt = Expression::type($$);
          tt.ti(Type::TI_VAR);
          tt.tiExplicit(true);
          tt.st(Type::ST_SET);
          if ($2) {
            tt.ot(Type::OT_OPTIONAL);
            tt.otExplicit(true);
          }
          $$->type(tt);
        }
      }
    | MZN_ANY MZN_TI_IDENTIFIER
      { $$ = new TypeInst(@$,Type::mkAny(),new TIId(@$, $2));
        free($2);
      }
    | MZN_ANY
      { $$ = new TypeInst(@$,Type::mkAny()); }

opt_opt:
      /* nothing */
      { $$ = false; }
    | MZN_OPT
      { $$ = true; }

base_ti_expr_tail :
      MZN_INT
      { $$ = new TypeInst(@$,Type::parint()); }
    | MZN_BOOL
      { $$ = new TypeInst(@$,Type::parbool()); }
    | MZN_FLOAT
      { $$ = new TypeInst(@$,Type::parfloat()); }
    | MZN_STRING
      { $$ = new TypeInst(@$,Type::parstring()); }
    | MZN_ANN
      { $$ = new TypeInst(@$,Type::ann()); }
    | MZN_TUPLE '(' ti_expr_list ')'
      {
        std::vector<Expression*> tmp($3->begin(), $3->end());
        ArrayLit* al = ArrayLit::constructTuple(@$, tmp);
        $$ = new TypeInst(@$, Type::tuple(), al);
        delete $3;
      }
    | MZN_RECORD '(' ti_expr_and_id_list ')'
      {
        for (auto* vd : *$3) {
          vd->toplevel(false);
        }
        std::vector<Expression*> tmp($3->begin(), $3->end());
        ArrayLit* al = ArrayLit::constructTuple(@$, tmp);
        $$ = new TypeInst(@$, Type::record(), al);
        delete $3;
      }
    | set_expr
        { if ($1) $$ = new TypeInst(@$,Type(),$1); }
    | MZN_TI_IDENTIFIER
      { $$ = new TypeInst(@$,Type::top(),
                         new TIId(@$, $1));
        free($1);
      }
    | MZN_TI_ENUM_IDENTIFIER
      { $$ = new TypeInst(@$,Type::parint(),
          new TIId(@$, $1));
          free($1);
      }

array_access_expr_list : array_access_expr_list_head comma_or_none

array_access_expr_list_head :
      array_access_expr
      { $$=new std::vector<MiniZinc::Expression*>; $$->push_back($1); }
    | array_access_expr_list_head ',' array_access_expr
      { $$=$1; if ($$ && $3) $$->push_back($3); }

array_access_expr :
      expr
      { $$ = $1; }
    | MZN_DOTDOT
      { $$=new SetLit(@$, IntSetVal::a(-IntVal::infinity(),IntVal::infinity())); }
    | MZN_DOTDOT_LE
      { $$=Call::a(@$, ASTString("'..<'"), {}); }
    | MZN_LE_DOTDOT
      { $$=Call::a(@$, ASTString("'<..'"), {}); }
    | MZN_LE_DOTDOT_LE
      { $$=Call::a(@$, ASTString("'<..<'"), {}); }

expr_list : expr_list_head comma_or_none

expr_list_head :
      expr
      { $$=new std::vector<MiniZinc::Expression*>; $$->push_back($1); }
    | expr_list_head ',' expr
      { $$=$1; if ($$ && $3) $$->push_back($3); }

///

set_expr :
      expr_atom_head
    | set_expr MZN_COLONCOLON annotation_expr
      { if ($1 && $3) Expression::addAnnotation($1, $3); $$=$1; }
    | set_expr MZN_UNION set_expr
      { $$=new BinOp(@$, $1, BOT_UNION, $3); }
    | set_expr MZN_DIFF set_expr
      { $$=new BinOp(@$, $1, BOT_DIFF, $3); }
    | set_expr MZN_SYMDIFF set_expr
      { $$=new BinOp(@$, $1, BOT_SYMDIFF, $3); }
    | set_expr MZN_DOTDOT set_expr
      { if ($1==nullptr || $3==nullptr) {
          $$ = nullptr;
        } else if (Expression::isa<IntLit>($1) && Expression::isa<IntLit>($3)) {
          $$=new SetLit(@$, IntSetVal::a(IntLit::v(Expression::cast<IntLit>($1)),IntLit::v(Expression::cast<IntLit>($3))));
        } else {
          $$=new BinOp(@$, $1, BOT_DOTDOT, $3);
        }
      }
    | set_expr MZN_DOTDOT_LE set_expr
      { $$=Call::a(@$, ASTString("'..<'"), {$1, $3}); }
    | set_expr MZN_LE_DOTDOT set_expr
      { $$=Call::a(@$, ASTString("'<..'"), {$1, $3}); }
    | set_expr MZN_LE_DOTDOT_LE set_expr
      { $$=Call::a(@$, ASTString("'<..<'"), {$1, $3}); }
    | set_expr MZN_DOTDOT
      { $$=Call::a(@$, ASTString("..o"), {$1}); }
    | set_expr MZN_DOTDOT_LE
      { $$=Call::a(@$, ASTString("..<o"), {$1}); }
    | set_expr MZN_LE_DOTDOT
      { $$=Call::a(@$, ASTString("<..o"), {$1}); }
    | set_expr MZN_LE_DOTDOT_LE
      { $$=Call::a(@$, ASTString("<..<o"), {$1}); }
    | MZN_DOTDOT set_expr
      { $$=Call::a(@$, ASTString("o.."), {$2}); }
    | MZN_DOTDOT_LE set_expr
      { $$=Call::a(@$, ASTString("o..<"), {$2}); }
    | MZN_LE_DOTDOT set_expr
      { $$=Call::a(@$, ASTString("o<.."), {$2}); }
    | MZN_LE_DOTDOT_LE set_expr
      { $$=Call::a(@$, ASTString("o<..<"), {$2}); }
    | MZN_DOTDOT_LE_QUOTED '(' set_expr ',' set_expr ')'
      { $$=Call::a(@$, ASTString("'..<'"), {$3, $5}); }
    | MZN_LE_DOTDOT_QUOTED '(' set_expr ',' set_expr ')'
      { $$=Call::a(@$, ASTString("'<..'"), {$3, $5}); }
    | MZN_LE_DOTDOT_LE_QUOTED '(' set_expr ',' set_expr ')'
      { $$=Call::a(@$, ASTString("'<..<'"), {$3, $5}); }
    | MZN_DOTDOT_QUOTED '(' expr ',' expr ')'
      { if ($3==nullptr || $5==nullptr) {
          $$ = nullptr;
        } else if (Expression::isa<IntLit>($3) && Expression::isa<IntLit>($5)) {
          $$=new SetLit(@$, IntSetVal::a(IntLit::v(Expression::cast<IntLit>($3)),IntLit::v(Expression::cast<IntLit>($5))));
        } else {
          $$=new BinOp(@$, $3, BOT_DOTDOT, $5);
        }
      }
    | MZN_DOTDOT_LE_QUOTED '(' set_expr ')'
      { $$=Call::a(@$, ASTString("'..<'"), {$3}); }
    | MZN_LE_DOTDOT_QUOTED '(' set_expr ')'
      { $$=Call::a(@$, ASTString("'<..'"), {$3}); }
    | MZN_LE_DOTDOT_LE_QUOTED '(' set_expr ')'
      { $$=Call::a(@$, ASTString("'<..<'"), {$3}); }
    | MZN_DOTDOT_QUOTED '(' expr ')'
      { $$=Call::a(@$, ASTString("'..'"), {$3}); }
    | set_expr MZN_INTERSECT set_expr
      { $$=new BinOp(@$, $1, BOT_INTERSECT, $3); }
    | set_expr MZN_PLUS set_expr
      { $$=new BinOp(@$, $1, BOT_PLUS, $3); }
    | set_expr MZN_MINUS set_expr
      { $$=new BinOp(@$, $1, BOT_MINUS, $3); }
    | set_expr MZN_MULT set_expr
      { $$=new BinOp(@$, $1, BOT_MULT, $3); }
    | set_expr MZN_DIV set_expr
      { $$=new BinOp(@$, $1, BOT_DIV, $3); }
    | set_expr MZN_IDIV set_expr
      { $$=new BinOp(@$, $1, BOT_IDIV, $3); }
    | set_expr MZN_MOD set_expr
      { $$=new BinOp(@$, $1, BOT_MOD, $3); }
    | set_expr MZN_POW set_expr
      { $$=new BinOp(@$, $1, BOT_POW, $3); }
    | set_expr MZN_WEAK_PLUS set_expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~+"), args);
      }
    | set_expr MZN_WEAK_MINUS set_expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~-"), args);
      }
    | set_expr MZN_WEAK_MULT set_expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~*"), args);
      }
    | set_expr MZN_WEAK_DIV set_expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~/"), args);
      }
    | set_expr MZN_WEAK_IDIV set_expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~div"), args);
      }
    | set_expr MZN_WEAK_EQ set_expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~="), args);
      }
    | set_expr MZN_WEAK_NQ set_expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~!="), args);
      }
    | set_expr MZN_DEFAULT set_expr
      {
        vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("default"), args);
      }
    | set_expr MZN_QUOTED_IDENTIFIER set_expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, $2, args);
        free($2);
      }
    | MZN_PLUS set_expr %prec MZN_NOT
      { $$=new UnOp(@$, UOT_PLUS, $2); }
    | MZN_MINUS set_expr %prec MZN_NOT
      { if ($2 && Expression::isa<IntLit>($2)) {
          $$ = IntLit::a(-IntLit::v(Expression::cast<IntLit>($2)));
        } else if ($2 && Expression::isa<FloatLit>($2)) {
          $$ = FloatLit::a(-FloatLit::v(Expression::cast<FloatLit>($2)));
        } else {
          $$=new UnOp(@$, UOT_MINUS, $2);
        }
      }
    | MZN_MINUS MZN_MAX_NEGATIVE_INTEGER_LITERAL %prec MZN_NOT
      { $$ = IntLit::a((-9223372036854775807ll)-1); }

///

expr :
      expr_atom_head
    | expr MZN_COLONCOLON annotation_expr
      { if ($1 && $3) Expression::addAnnotation($1, $3); $$=$1; }
    | expr MZN_EQUIV expr
      { $$=new BinOp(@$, $1, BOT_EQUIV, $3); }
    | expr MZN_IMPL expr
      { $$=new BinOp(@$, $1, BOT_IMPL, $3); }
    | expr MZN_RIMPL expr
      { $$=new BinOp(@$, $1, BOT_RIMPL, $3); }
    | expr MZN_OR expr
      { $$=new BinOp(@$, $1, BOT_OR, $3); }
    | expr MZN_XOR expr
      { $$=new BinOp(@$, $1, BOT_XOR, $3); }
    | expr MZN_AND expr
      { $$=new BinOp(@$, $1, BOT_AND, $3); }
    | expr MZN_LE expr
      { $$=new BinOp(@$, $1, BOT_LE, $3); }
    | expr MZN_GR expr
      { $$=new BinOp(@$, $1, BOT_GR, $3); }
    | expr MZN_LQ expr
      { $$=new BinOp(@$, $1, BOT_LQ, $3); }
    | expr MZN_GQ expr
      { $$=new BinOp(@$, $1, BOT_GQ, $3); }
    | expr MZN_EQ expr
      { $$=new BinOp(@$, $1, BOT_EQ, $3); }
    | expr MZN_NQ expr
      { $$=new BinOp(@$, $1, BOT_NQ, $3); }
    | expr MZN_IN expr
      { $$=new BinOp(@$, $1, BOT_IN, $3); }
    | expr MZN_SUBSET expr
      { $$=new BinOp(@$, $1, BOT_SUBSET, $3); }
    | expr MZN_SUPERSET expr
      { $$=new BinOp(@$, $1, BOT_SUPERSET, $3); }
    | expr MZN_UNION expr
      { $$=new BinOp(@$, $1, BOT_UNION, $3); }
    | expr MZN_DIFF expr
      { $$=new BinOp(@$, $1, BOT_DIFF, $3); }
    | expr MZN_SYMDIFF expr
      { $$=new BinOp(@$, $1, BOT_SYMDIFF, $3); }
    | expr MZN_DOTDOT expr
      { if ($1==nullptr || $3==nullptr) {
          $$ = nullptr;
        } else if (Expression::isa<IntLit>($1) && Expression::isa<IntLit>($3)) {
          $$=new SetLit(@$, IntSetVal::a(IntLit::v(Expression::cast<IntLit>($1)),IntLit::v(Expression::cast<IntLit>($3))));
        } else {
          $$=new BinOp(@$, $1, BOT_DOTDOT, $3);
        }
      }
    | expr MZN_DOTDOT_LE expr
      { $$=Call::a(@$, ASTString("'..<'"), {$1, $3}); }
    | expr MZN_LE_DOTDOT expr
      { $$=Call::a(@$, ASTString("'<..'"), {$1, $3}); }
    | expr MZN_LE_DOTDOT_LE expr
      { $$=Call::a(@$, ASTString("'<..<'"), {$1, $3}); }
    | expr MZN_DOTDOT
      { $$=Call::a(@$, ASTString("..o"), {$1}); }
    | expr MZN_DOTDOT_LE
      { $$=Call::a(@$, ASTString("..<o"), {$1}); }
    | expr MZN_LE_DOTDOT
      { $$=Call::a(@$, ASTString("<..o"), {$1}); }
    | expr MZN_LE_DOTDOT_LE
      { $$=Call::a(@$, ASTString("<..<o"), {$1}); }
    | MZN_DOTDOT expr
      { $$=Call::a(@$, ASTString("o.."), {$2}); }
    | MZN_DOTDOT_LE expr
      { $$=Call::a(@$, ASTString("o..<"), {$2}); }
    | MZN_LE_DOTDOT expr
      { $$=Call::a(@$, ASTString("o<.."), {$2}); }
    | MZN_LE_DOTDOT_LE expr
      { $$=Call::a(@$, ASTString("o<..<"), {$2}); }
    | MZN_DOTDOT_LE_QUOTED '(' expr ',' expr ')'
      { $$=Call::a(@$, ASTString("'..<'"), {$3, $5}); }
    | MZN_LE_DOTDOT_QUOTED '(' expr ',' expr ')'
      { $$=Call::a(@$, ASTString("'<..'"), {$3, $5}); }
    | MZN_LE_DOTDOT_LE_QUOTED '(' expr ',' expr ')'
      { $$=Call::a(@$, ASTString("'<..<'"), {$3, $5}); }
    | MZN_DOTDOT_QUOTED '(' expr ',' expr ')'
      { if ($3==nullptr || $5==nullptr) {
          $$ = nullptr;
        } else if (Expression::isa<IntLit>($3) && Expression::isa<IntLit>($5)) {
          $$=new SetLit(@$, IntSetVal::a(IntLit::v(Expression::cast<IntLit>($3)),IntLit::v(Expression::cast<IntLit>($5))));
        } else {
          $$=new BinOp(@$, $3, BOT_DOTDOT, $5);
        }
      }
    | MZN_DOTDOT_LE_QUOTED '(' expr ')'
      { $$=Call::a(@$, ASTString("'..<'"), {$3}); }
    | MZN_LE_DOTDOT_QUOTED '(' expr ')'
      { $$=Call::a(@$, ASTString("'<..'"), {$3}); }
    | MZN_LE_DOTDOT_LE_QUOTED '(' expr ')'
      { $$=Call::a(@$, ASTString("'<..<'"), {$3}); }
    | MZN_DOTDOT_QUOTED '(' expr ')'
      { $$=Call::a(@$, ASTString("'..'"), {$3}); }
    | expr MZN_INTERSECT expr
      { $$=new BinOp(@$, $1, BOT_INTERSECT, $3); }
    | expr MZN_PLUSPLUS expr
      { $$=new BinOp(@$, $1, BOT_PLUSPLUS, $3); }
    | expr MZN_PLUS expr
      { $$=new BinOp(@$, $1, BOT_PLUS, $3); }
    | expr MZN_MINUS expr
      { $$=new BinOp(@$, $1, BOT_MINUS, $3); }
    | expr MZN_MULT expr
      { $$=new BinOp(@$, $1, BOT_MULT, $3); }
    | expr MZN_DIV expr
      { $$=new BinOp(@$, $1, BOT_DIV, $3); }
    | expr MZN_IDIV expr
      { $$=new BinOp(@$, $1, BOT_IDIV, $3); }
    | expr MZN_MOD expr
      { $$=new BinOp(@$, $1, BOT_MOD, $3); }
    | expr MZN_POW expr
      { $$=new BinOp(@$, $1, BOT_POW, $3); }
    | expr MZN_WEAK_PLUS expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~+"), args);
      }
    | expr MZN_WEAK_MINUS expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~-"), args);
      }
    | expr MZN_WEAK_MULT expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~*"), args);
      }
    | expr MZN_WEAK_DIV expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~/"), args);
      }
    | expr MZN_WEAK_IDIV expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~div"), args);
      }
    | expr MZN_WEAK_EQ expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~="), args);
      }
    | expr MZN_WEAK_NQ expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("~!="), args);
      }
    | expr MZN_DEFAULT expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, ASTString("default"), args);
      }
    | expr MZN_QUOTED_IDENTIFIER expr
      { vector<Expression*> args;
        args.push_back($1); args.push_back($3);
        $$=Call::a(@$, $2, args);
        free($2);
      }
    | MZN_NOT expr %prec MZN_NOT
      { $$=new UnOp(@$, UOT_NOT, $2); }
    | MZN_PLUS expr %prec MZN_MULT
      { if (($2 && Expression::isa<IntLit>($2)) || ($2 && Expression::isa<FloatLit>($2))) {
          $$ = $2;
        } else {
          $$=new UnOp(@$, UOT_PLUS, $2);
        }
      }
    | MZN_MINUS expr %prec MZN_MULT
      { if ($2 && Expression::isa<IntLit>($2)) {
          $$ = IntLit::a(-IntLit::v(Expression::cast<IntLit>($2)));
        } else if ($2 && Expression::isa<FloatLit>($2)) {
          $$ = FloatLit::a(-FloatLit::v(Expression::cast<FloatLit>($2)));
        } else {
          $$=new UnOp(@$, UOT_MINUS, $2);
        }
      }
    | MZN_MINUS MZN_MAX_NEGATIVE_INTEGER_LITERAL %prec MZN_NOT
      { $$ = IntLit::a((-9223372036854775807ll)-1); }


expr_atom_head :
      expr_atom_head_nonstring
      { $$=$1; }
    | string_expr
      { $$=$1; }

expr_atom_head_nonstring :
      '(' expr ')'
      { $$=$2; }
    | '(' expr ')' access_tail
      { if ($4) $$=createAccess(@$, $2, *$4); delete $4; }
    | '(' expr ')' MZN_POW_MINUS1
      { $$=new BinOp(@$, $2, BOT_POW, IntLit::a(-1)); }
    | '(' expr ')' access_tail MZN_POW_MINUS1
      { if ($4) $$=new BinOp(@$,createAccess(@$, $2, *$4), BOT_POW, IntLit::a(-1)); delete $4; }
    | MZN_IDENTIFIER
      { $$=new Id(@$, $1, nullptr); free($1); }
    | MZN_IDENTIFIER access_tail
      { if ($2) $$=createAccess(@$, new Id(@1,$1,nullptr), *$2);
        free($1); delete $2; }
    | MZN_IDENTIFIER MZN_POW_MINUS1
      { $$=new BinOp(@$,new Id(@$, $1, nullptr), BOT_POW, IntLit::a(-1)); free($1); }
    | MZN_IDENTIFIER access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, new Id(@1,$1,nullptr), *$2), BOT_POW, IntLit::a(-1));
        free($1); delete $2; }
    | MZN_UNDERSCORE
      { $$=new AnonVar(@$); }
    | MZN_UNDERSCORE access_tail
      { if ($2) $$=createAccess(@$, new AnonVar(@$), *$2);
        delete $2; }
    | MZN_UNDERSCORE MZN_POW_MINUS1
      { $$=new BinOp(@$,new AnonVar(@$), BOT_POW, IntLit::a(-1)); }
    | MZN_UNDERSCORE access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, new AnonVar(@$), *$2), BOT_POW, IntLit::a(-1));
        delete $2; }
    | MZN_UNDERSCORE '(' expr ')'
      { $$ = Call::a(@$, Constants::constants().ids.anon_enum_set, {$3}); }
    | MZN_BOOL_LITERAL
      { $$=Constants::constants().boollit(($1!=0)); }
    | MZN_BOOL_LITERAL MZN_POW_MINUS1
      { $$=new BinOp(@$,Constants::constants().boollit(($1!=0)), BOT_POW, IntLit::a(-1)); }
    | MZN_INTEGER_LITERAL
      { $$=IntLit::a($1); }
    | MZN_INTEGER_LITERAL MZN_POW_MINUS1
      { $$=new BinOp(@$,IntLit::a($1), BOT_POW, IntLit::a(-1)); }
    | MZN_INFINITY
      { $$=IntLit::a(IntVal::infinity()); }
    | MZN_INFINITY MZN_POW_MINUS1
      { $$=new BinOp(@$,IntLit::a(IntVal::infinity()), BOT_POW, IntLit::a(-1)); }
    | MZN_FLOAT_LITERAL
      { $$=FloatLit::a($1); }
    | MZN_FLOAT_LITERAL MZN_POW_MINUS1
      { $$=new BinOp(@$,FloatLit::a($1), BOT_POW, IntLit::a(-1)); }
    | MZN_ABSENT
      { $$=Constants::constants().absent; }
    | MZN_ABSENT MZN_POW_MINUS1
      { $$=Constants::constants().absent; }
    | set_literal
    | set_literal access_tail
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | set_literal MZN_POW_MINUS1
      { $$ = new BinOp(@$,$1, BOT_POW, IntLit::a(-1)); }
    | set_literal access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, $1, *$2), BOT_POW, IntLit::a(-1));
        delete $2; }
    | set_comp
    | set_comp access_tail
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | set_comp MZN_POW_MINUS1
      { $$ = new BinOp(@$,$1, BOT_POW, IntLit::a(-1)); }
    | set_comp access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, $1, *$2), BOT_POW, IntLit::a(-1));
        delete $2; }
    | simple_array_literal
    | simple_array_literal access_tail
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | simple_array_literal MZN_POW_MINUS1
      { $$ = new BinOp(@$,$1, BOT_POW, IntLit::a(-1)); }
    | simple_array_literal access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, $1, *$2), BOT_POW, IntLit::a(-1));
        delete $2; }
    | simple_array_literal_2d
    | simple_array_literal_2d access_tail
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | simple_array_literal_2d MZN_POW_MINUS1
      { $$ = new BinOp(@$,$1, BOT_POW, IntLit::a(-1)); }
    | simple_array_literal_2d access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, $1, *$2), BOT_POW, IntLit::a(-1));
        delete $2; }
    | simple_array_comp
    | simple_array_comp access_tail
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | simple_array_comp MZN_POW_MINUS1
      { $$ = new BinOp(@$,$1, BOT_POW, IntLit::a(-1)); }
    | simple_array_comp access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, $1, *$2), BOT_POW, IntLit::a(-1));
        delete $2; }
    | if_then_else_expr
    | if_then_else_expr access_tail
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | if_then_else_expr MZN_POW_MINUS1
      { $$ = new BinOp(@$,$1, BOT_POW, IntLit::a(-1)); }
    | if_then_else_expr access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, $1, *$2), BOT_POW, IntLit::a(-1));
        delete $2; }
    | let_expr
    | call_expr
    | call_expr access_tail
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | call_expr MZN_POW_MINUS1
    | call_expr access_tail MZN_POW_MINUS1
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | tuple_literal
    | tuple_literal access_tail
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | tuple_literal MZN_POW_MINUS1
      { $$ = new BinOp(@$,$1, BOT_POW, IntLit::a(-1)); }
    | tuple_literal access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, $1, *$2), BOT_POW, IntLit::a(-1));
        delete $2; }
    | record_literal
    | record_literal access_tail
      { if ($2) $$=createAccess(@$, $1, *$2);
        delete $2; }
    | record_literal MZN_POW_MINUS1
      { $$ = new BinOp(@$,$1, BOT_POW, IntLit::a(-1)); }
    | record_literal access_tail MZN_POW_MINUS1
      { if ($2) $$=new BinOp(@$,createAccess(@$, $1, *$2), BOT_POW, IntLit::a(-1));
        delete $2; }

string_expr:
      MZN_STRING_LITERAL
      { $$=new StringLit(@$, $1); free($1); }
    | MZN_STRING_QUOTE_START string_quote_rest
      { $$=new BinOp(@$, new StringLit(@$, $1), BOT_PLUSPLUS, $2);
        free($1);
      }

string_quote_rest:
      expr MZN_STRING_QUOTE_END
      { if ($1) {
          $$=new BinOp(@$, Call::a(@$, ASTString("format"), {$1}), BOT_PLUSPLUS, new StringLit(@$,$2));
        }
        free($2);
      }
    | expr MZN_STRING_QUOTE_MID string_quote_rest
      { if ($1) {
          $$=new BinOp(@$, Call::a(@$, ASTString("format"), {$1}), BOT_PLUSPLUS,
                       new BinOp(@$, new StringLit(@$,$2), BOT_PLUSPLUS, $3));
        }
        free($2);
      }

access_tail :
      MZN_LEFT_BRACKET array_access_expr_list MZN_RIGHT_BRACKET
      {
        $$=new std::vector<Expression*>();
        if ($2) {
          auto* al = new ArrayAccess(@$, nullptr, *$2);
          $$->push_back(al);
          delete $2;
        }
      }
    | MZN_FIELD_TAIL
      {
        $$=new std::vector<Expression*>();
        std::string tail($1); free($1);
        parseFieldTail(@$, *$$, tail);
      }
    | access_tail MZN_LEFT_BRACKET array_access_expr_list MZN_RIGHT_BRACKET
      {
        $$=$1;
        if ($$ && $3) {
          auto* al = new ArrayAccess(@$, nullptr, *$3);
          $$->push_back(al);
          delete $3;
        }
      }
    | access_tail MZN_FIELD_TAIL
      {
        $$=$1;
        std::string tail($2); free($2);
        parseFieldTail(@$, *$$, tail);
      }


set_literal :
      '{' '}'
      { $$ = new SetLit(@$, std::vector<Expression*>()); }
    | '{' expr_list '}'
      { if ($2) $$ = new SetLit(@$, *$2);
        delete $2; }

tuple_literal :
      '(' expr ',' ')'
      {
        std::vector<Expression*> list({ $2 });
        $$=ArrayLit::constructTuple(@$, list);
      }
    | '(' expr ',' expr_list ')'
      {
        auto* list = $4;
        if (list == nullptr) {
          list = new std::vector<Expression*>();
        }
        if ($2) {
          list->insert(list->begin(), $2);
        }
        $$=ArrayLit::constructTuple(@$, *list);
        delete list;
      }

record_literal :
      '(' record_field_list_head comma_or_none ')'
      {
        $$ = ArrayLit::constructTuple(@$, *$2);
        Expression::type($$, Type::record());
        delete($2);
      }
  
record_field_list_head :
      record_field
      { $$ = new vector<Expression*>(1); (*$$)[0] = $1; }
    | record_field_list_head ',' record_field
      { $$=$1; $$->push_back($3); }

record_field:
      MZN_IDENTIFIER ':' expr
      {
        $$ = new VarDecl(@$, new TypeInst(@$, Type()), $1, $3);
        free($1);
      }

set_comp :
      '{' expr '|' comp_tail '}'
      { if ($4) $$ = new Comprehension(@$, $2, *$4, true);
        delete $4;
      }

comp_tail :
      generator_list
      { if ($1) $$=new Generators; $$->g = *$1; delete $1; }

generator_list : generator_list_head comma_or_none

generator_list_head :
      generator
      { $$=new std::vector<Generator>; if ($1) $$->push_back(*$1); delete $1; }
    | generator_eq
      { $$=new std::vector<Generator>; if ($1) $$->push_back(*$1); delete $1; }
    | generator_eq MZN_WHERE expr
      { $$=new std::vector<Generator>;
        if ($1) $$->push_back(*$1);
        if ($1 && $3) $$->push_back(Generator(static_cast<int>($$->size()),$3));
        delete $1;
      }
    | generator_list_head ',' generator
      { $$=$1; if ($$ && $3) $$->push_back(*$3); delete $3; }
    | generator_list_head ',' generator_eq
      { $$=$1; if ($$ && $3) $$->push_back(*$3); delete $3; }
    | generator_list_head ',' generator_eq MZN_WHERE expr
      { $$=$1;
        if ($$ && $3) $$->push_back(*$3);
        if ($$ && $3 && $5) $$->push_back(Generator(static_cast<int>($$->size()),$5));
        delete $3;
      }

generator :
      id_list MZN_IN expr
      { if ($1 && $3) $$=new Generator(*$1,$3,nullptr); else $$=nullptr; delete $1; }
    | id_list MZN_IN expr MZN_WHERE expr
      { if ($1 && $3) $$=new Generator(*$1,$3,$5); else $$=nullptr; delete $1; }
generator_eq :
      MZN_IDENTIFIER MZN_EQ expr
      { if ($3) $$=new Generator({$1},nullptr,$3); else $$=nullptr; free($1); }

id_list : id_list_head comma_or_none

id_list_head :
      MZN_IDENTIFIER
      { $$=new std::vector<std::string>; $$->push_back($1); free($1); }
    | MZN_UNDERSCORE
      { $$=new std::vector<std::string>; $$->push_back(""); }
    | id_list_head ',' MZN_IDENTIFIER
      { $$=$1; if ($$ && $3) $$->push_back($3); free($3); }
    | id_list_head ',' MZN_UNDERSCORE
      { $$=$1; if ($$) $$->push_back(""); }

simple_array_literal :
      MZN_LEFT_BRACKET MZN_RIGHT_BRACKET
      { $$=new ArrayLit(@$, std::vector<MiniZinc::Expression*>()); }
    | MZN_LEFT_BRACKET comp_expr_list MZN_RIGHT_BRACKET
      { if ($2) {
          if ($2->first.empty()) {
            $$=new ArrayLit(@$, $2->second);
          } else {
            const auto* tuple = Expression::dynamicCast<ArrayLit>($2->first[0]);
            if (tuple) {
              std::vector<std::vector<Expression*>> dims(tuple->size());
              for (const auto* t : $2->first) {
                if ( (tuple = Expression::dynamicCast<ArrayLit>(t)) != nullptr ) {
                  if (tuple->size() == dims.size()) {
                    for (unsigned int i = 0; i < dims.size(); i++) {
                      dims[i].push_back((*tuple)[i]);
                    }
                  } else {
                    yyerror(&@2, parm, "syntax error, non-uniform indexed array literal");
                  }
                } else {
                  yyerror(&@2, parm, "syntax error, non-uniform indexed array literal");
                }
              }
              std::vector<Expression*> arrayNdArgs(dims.size());
              for (unsigned int i = 0; i < dims.size(); i++) {
                arrayNdArgs[i] = new ArrayLit(@$, dims[i]);
              }
              arrayNdArgs.push_back(new ArrayLit(@$, $2->second));

              if ($2->first.size() != $2->second.size()) {
                yyerror(&@2, parm, "syntax error, non-uniform indexed array literal");
                $$=nullptr;
              } else {
                $$=Call::a(@$, "arrayNd", arrayNdArgs);
              }
            } else {
              for (const auto* t : $2->first) {
                if (Expression::isa<ArrayLit>(t)) {
                  yyerror(&@2, parm, "syntax error, non-uniform indexed array literal");
                }
              }
              $$=Call::a(@$, "arrayNd", {new ArrayLit(@$, $2->first), new ArrayLit(@$, $2->second)});
            }
          }
          delete $2;
        }
      }

simple_array_literal_2d :
      MZN_LEFT_2D_BRACKET MZN_RIGHT_2D_BRACKET
      { $$=new ArrayLit(@$, std::vector<std::vector<Expression*> >()); }
    | MZN_LEFT_2D_BRACKET simple_array_literal_2d_indexed_list MZN_RIGHT_2D_BRACKET
      { if ($2) {
          std::vector<std::vector<Expression*>> v($2->size());
          std::vector<Expression*> columnHeader;
          std::vector<Expression*> rowHeader;
          bool hadHeaderRow = false;
          for (unsigned int i = 0; i < $2->size(); i++) {
            if (i == 0 && (*$2)[i].second.empty() && !(*$2)[i].first.empty()) {
              hadHeaderRow = true;
              columnHeader = (*$2)[i].first;
              v.resize(v.size()-1);
              continue;
            }
            if (i > 0 && (*$2)[i].second.size() != (*$2)[i-1].second.size()) {
              if (i == 1 && hadHeaderRow) {
                if ((*$2)[i].second.size() != (*$2)[i-1].first.size()) {
                  yyerror(&@2, parm, "syntax error, sub-array of 2d array literal has different length from index row");
                }
              } else {
                yyerror(&@2, parm, "syntax error, all sub-arrays of 2d array literal must have the same length");
              }
            }
            if (i > static_cast<unsigned int>(hadHeaderRow) && (*$2)[i].first.size() != (*$2)[i-1].first.size()) {
              yyerror(&@2, parm, "syntax error, mixing indexed and non-indexed sub-arrays in 2d array literal");
            }
            if (i >= static_cast<unsigned int>(hadHeaderRow) && !(*$2)[i].first.empty()) {
              rowHeader.push_back((*$2)[i].first[0]);
            }
            for (unsigned int j = 0; j < (*$2)[i].second.size(); j++) {
              v[i - hadHeaderRow].push_back((*$2)[i].second[j]);
            }
          }
          if (columnHeader.empty() && rowHeader.empty()) {
            $$=new ArrayLit(@$, v);
          } else {
            std::vector<Expression*> vv;
            for (auto& row : v) {
              for (auto* e : row) {
                vv.push_back(e);
              }
            }
            if (rowHeader.empty()) {
              auto nRows = vv.size() / columnHeader.size();
              rowHeader.resize(nRows);
              for (unsigned int i = 0; i < nRows; i++) {
                rowHeader[i] = IntLit::a(i+1);
              }
            } else if (columnHeader.empty()) {
              auto nCols = vv.size() / rowHeader.size();
              columnHeader.resize(nCols);
              for (unsigned int i = 0; i < nCols; i++) {
                columnHeader[i] = IntLit::a(i+1);
              }
            }
            $$=Call::a(@$, "array2d", {new ArrayLit(@$, rowHeader), new ArrayLit(@$, columnHeader), new ArrayLit(@$, vv)});
          }
          delete $2;
        } else {
          $$ = nullptr;
        }
      }
    | MZN_LEFT_2D_BRACKET simple_array_literal_3d_list MZN_RIGHT_2D_BRACKET
    {
      if ($2) {
        std::vector<std::pair<int,int> > dims(3);
        dims[0] = std::pair<int,int>(1,static_cast<int>($2->size()));
        if ($2->size()==0) {
          dims[1] = std::pair<int,int>(1,0);
          dims[2] = std::pair<int,int>(1,0);
        } else {
          dims[1] = std::pair<int,int>(1,static_cast<int>((*$2)[0].size()));
          if ((*$2)[0].size()==0) {
            dims[2] = std::pair<int,int>(1,0);
          } else {
            dims[2] = std::pair<int,int>(1,static_cast<int>((*$2)[0][0].size()));
          }
        }
        std::vector<Expression*> a;
        for (int i=0; i<dims[0].second; i++) {
          if ((*$2)[i].size() != dims[1].second) {
            yyerror(&@2, parm, "syntax error, all sub-arrays of 3d array literal must have the same length");
          } else {
            for (int j=0; j<dims[1].second; j++) {
              if ((*$2)[i][j].size() != dims[2].second) {
                yyerror(&@2, parm, "syntax error, all sub-arrays of 3d array literal must have the same length");
              } else {
                for (int k=0; k<dims[2].second; k++) {
                  a.push_back((*$2)[i][j][k]);
                }
              }
            }
          }
        }
        $$ = new ArrayLit(@$,a,dims);
        delete $2;
      } else {
        $$ = nullptr;
      }
    }

simple_array_literal_3d_list :
      '|' '|'
      { $$=new std::vector<std::vector<std::vector<MiniZinc::Expression*> > >;
      }
    | '|' simple_array_literal_2d_list '|'
      { $$=new std::vector<std::vector<std::vector<MiniZinc::Expression*> > >;
        if ($2) $$->push_back(*$2);
        delete $2;
      }
    | simple_array_literal_3d_list ',' '|' simple_array_literal_2d_list '|'
      { $$=$1;
        if ($$ && $4) $$->push_back(*$4);
        delete $4;
      }

simple_array_literal_2d_list :
      expr_list
      { $$=new std::vector<std::vector<MiniZinc::Expression*> >;
        if ($1) $$->push_back(*$1);
        delete $1;
      }
    | simple_array_literal_2d_list '|' expr_list
      { $$=$1; if ($$ && $3) $$->push_back(*$3); delete $3; }

simple_array_literal_2d_indexed_list: simple_array_literal_2d_indexed_list_head pipe_or_none

simple_array_literal_2d_indexed_list_head :
      simple_array_literal_2d_indexed_list_row
      { $$=new std::vector<std::pair<std::vector<MiniZinc::Expression*>,std::vector<MiniZinc::Expression*>>>();
        if ($1) {
          if ($1->first.size() > 1 || ($1->first.size() == 1 && $1->second.empty())) {
            yyerror(&@$,parm,"invalid array literal, mixing indexes and values");
          }
          $$->push_back(*$1);
          delete $1;
        }
      }
    | simple_array_literal_2d_indexed_list_row_head ':'
      { $$=new std::vector<std::pair<std::vector<MiniZinc::Expression*>,std::vector<MiniZinc::Expression*>>>();
        if ($1) {
          if ($1->second.size() != 1) {
            yyerror(&@$,parm,"invalid array literal, mixing indexes and values");
          }
          $1->first.push_back($1->second.back());
          $1->second.pop_back();
          $$->push_back(*$1);
          delete $1;
        }
      }
    | simple_array_literal_2d_indexed_list_head '|' simple_array_literal_2d_indexed_list_row
      { $$=$1;
        if ($$ && $3) {
          if ($3->first.size() > 1 || ($3->first.size() == 1 && $3->second.empty())) {
            yyerror(&@3,parm,"invalid array literal, mixing indexes and values");
          }
          $$->push_back(*$3);
          delete $3;
        }
      }

simple_array_literal_2d_indexed_list_row: simple_array_literal_2d_indexed_list_row_head comma_or_none

simple_array_literal_2d_indexed_list_row_head :
      expr
      { $$=new std::pair<std::vector<MiniZinc::Expression*>,std::vector<MiniZinc::Expression*>>();
        $$->second.push_back($1);
      }
    | simple_array_literal_2d_indexed_list_row_head ':' expr
      { $$=$1;
        if ($$) {
          if ($$->second.size() != 1) {
            yyerror(&@$,parm,"invalid array literal, mixing indexes and values");
          }
          $$->first.push_back($$->second.back());
          $$->second.pop_back();
          $$->second.push_back($3);
        }
      }
    | simple_array_literal_2d_indexed_list_row_head ',' expr
      { $$=$1;
        if ($$) {
          if ($$->second.empty()) {
            yyerror(&@$,parm,"invalid array literal, mixing indexes and values");
          }
          $$->second.push_back($3);
        }
      }

simple_array_comp :
      MZN_LEFT_BRACKET expr ':' expr '|' comp_tail MZN_RIGHT_BRACKET
      { if ($2 && $6) {
          std::vector<Expression*> tv;
          if (auto* al = Expression::dynamicCast<ArrayLit>($2)) {
            for (unsigned int i=0; i<al->size(); i++) {
              tv.push_back((*al)[i]);
            }
          } else {
            tv.push_back($2);
          }
          tv.push_back($4);
          auto* t = ArrayLit::constructTuple(@$,tv);
          Type ty = Type::tuple();
          ty.typeId(Type::COMP_INDEX);
          t->type(ty);
          $$=new Comprehension(@$, t, *$6, false);
          delete $6;
        }
      }
    | MZN_LEFT_BRACKET expr '|' comp_tail MZN_RIGHT_BRACKET
      { if ($4) $$=new Comprehension(@$, $2, *$4, false);
        delete $4;
      }

/***********************************************/

comp_expr_list : comp_expr_list_head comma_or_none

/// TODO: push index into first vector, make sure either all elements have indices or none
comp_expr_list_head :
      expr
      { $$=new std::pair<std::vector<MiniZinc::Expression*>,std::vector<MiniZinc::Expression*>>;
        $$->second.push_back($1); }
    | expr ':' expr
      { $$=new std::pair<std::vector<MiniZinc::Expression*>,std::vector<MiniZinc::Expression*>>;
        $$->first.push_back($1);
        $$->second.push_back($3); }
    | comp_expr_list_head ',' expr
      { $$=$1;
        if ($$ && $3) {
          if ($$->first.size() > 1) {
            yyerror(&@$,parm,"invalid array literal, mixing indexed and non-indexed values");
            $$ = nullptr;
          } else {
            $$->second.push_back($3);
          }
        }
      }
    | comp_expr_list_head ',' expr ':' expr
      { $$=$1;
        if ($$ && $3) {
          if ($$->first.size() != $$->second.size()) {
            yyerror(&@$,parm,"invalid array literal, mixing indexed and non-indexed values");
            $$ = nullptr;
          } else if (Expression::isa<ArrayLit>($3) && Expression::cast<ArrayLit>($3)->isTuple() && Expression::cast<ArrayLit>($3)->size() == 1) {
            $$->first.push_back((*Expression::cast<ArrayLit>($3))[0]);
            $$->second.push_back($5);
            delete $3;
          } else {
            $$->first.push_back($3);
            $$->second.push_back($5);
          }
        }
      }

/***********************************************/

if_then_else_expr :
      MZN_IF expr MZN_THEN expr elseif_list MZN_ELSE expr MZN_ENDIF
      {
        std::vector<Expression*> iexps;
        iexps.push_back($2);
        iexps.push_back($4);
        if ($5) {
          for (unsigned int i=0; i<$5->size(); i+=2) {
            iexps.push_back((*$5)[i]);
            iexps.push_back((*$5)[i+1]);
          }
        }
        $$=new ITE(@$, iexps,$7);
        delete $5;
      }
  | MZN_IF expr MZN_THEN expr elseif_list MZN_ENDIF
    {
      std::vector<Expression*> iexps;
      iexps.push_back($2);
      iexps.push_back($4);
      if ($5) {
        for (unsigned int i=0; i<$5->size(); i+=2) {
          iexps.push_back((*$5)[i]);
          iexps.push_back((*$5)[i+1]);
        }
      }
      $$=new ITE(@$, iexps, nullptr);
      delete $5;
    }

elseif_list :
      { $$=new std::vector<MiniZinc::Expression*>; }
    | elseif_list MZN_ELSEIF expr MZN_THEN expr
      { $$=$1; if ($$ && $3 && $5) { $$->push_back($3); $$->push_back($5); } }

quoted_op :
      MZN_EQUIV_QUOTED
      { $$=BOT_EQUIV; }
    | MZN_IMPL_QUOTED
      { $$=BOT_IMPL; }
    | MZN_RIMPL_QUOTED
      { $$=BOT_RIMPL; }
    | MZN_OR_QUOTED
      { $$=BOT_OR; }
    | MZN_XOR_QUOTED
      { $$=BOT_XOR; }
    | MZN_AND_QUOTED
      { $$=BOT_AND; }
    | MZN_LE_QUOTED
      { $$=BOT_LE; }
    | MZN_GR_QUOTED
      { $$=BOT_GR; }
    | MZN_LQ_QUOTED
      { $$=BOT_LQ; }
    | MZN_GQ_QUOTED
      { $$=BOT_GQ; }
    | MZN_EQ_QUOTED
      { $$=BOT_EQ; }
    | MZN_NQ_QUOTED
      { $$=BOT_NQ; }
    | MZN_IN_QUOTED
      { $$=BOT_IN; }
    | MZN_SUBSET_QUOTED
      { $$=BOT_SUBSET; }
    | MZN_SUPERSET_QUOTED
      { $$=BOT_SUPERSET; }
    | MZN_UNION_QUOTED
      { $$=BOT_UNION; }
    | MZN_DIFF_QUOTED
      { $$=BOT_DIFF; }
    | MZN_SYMDIFF_QUOTED
      { $$=BOT_SYMDIFF; }
    | MZN_PLUS_QUOTED
      { $$=BOT_PLUS; }
    | MZN_MINUS_QUOTED
      { $$=BOT_MINUS; }
    | MZN_MULT_QUOTED
      { $$=BOT_MULT; }
    | MZN_POW_QUOTED
      { $$=BOT_POW; }
    | MZN_DIV_QUOTED
      { $$=BOT_DIV; }
    | MZN_IDIV_QUOTED
      { $$=BOT_IDIV; }
    | MZN_MOD_QUOTED
      { $$=BOT_MOD; }
    | MZN_INTERSECT_QUOTED
      { $$=BOT_INTERSECT; }
    | MZN_PLUSPLUS_QUOTED
      { $$=BOT_PLUSPLUS; }
    | MZN_NOT_QUOTED
      { $$=-1; }

quoted_op_call :
      quoted_op '(' expr ',' expr ')'
      { if ($1==-1) {
          $$=nullptr;
          yyerror(&@3, parm, "syntax error, unary operator with two arguments");
        } else {
          $$=new BinOp(@$, $3,static_cast<BinOpType>($1),$5);
        }
      }
    | quoted_op '(' expr ')'
      { int uot=-1;
        switch ($1) {
        case -1:
          uot = UOT_NOT;
          break;
        case BOT_MINUS:
          uot = UOT_MINUS;
          break;
        case BOT_PLUS:
          uot = UOT_PLUS;
          break;
        default:
          yyerror(&@3, parm, "syntax error, binary operator with unary argument list");
          break;
        }
        if (uot==-1)
          $$=nullptr;
        else {
          if (uot==UOT_PLUS && $3 && (Expression::isa<IntLit>($3) || Expression::isa<FloatLit>($3))) {
            $$ = $3;
          } else if (uot==UOT_MINUS && $3 && Expression::isa<IntLit>($3)) {
            $$ = IntLit::a(-IntLit::v(Expression::cast<IntLit>($3)));
          } else if (uot==UOT_MINUS && $3 && Expression::isa<FloatLit>($3)) {
            $$ = FloatLit::a(-FloatLit::v(Expression::cast<FloatLit>($3)));
          } else {
            $$=new UnOp(@$, static_cast<UnOpType>(uot),$3);
          }
        }
      }

call_expr :
      MZN_IDENTIFIER '(' ')'
      { $$=Call::a(@$, $1, std::vector<Expression*>()); free($1); }
    | MZN_IDENTIFIER MZN_POW_MINUS1 '(' ')'
      { $$=Call::a(@$, std::string($1)+"⁻¹", std::vector<Expression*>()); free($1); }
    | quoted_op_call
    | MZN_IDENTIFIER '(' comp_or_expr ')'
      {
        if ($3!=nullptr) {
          bool hadWhere = false;
          std::vector<Expression*> args;
          for (unsigned int i=0; i<$3->size(); i++) {
            if ((*$3)[i].second) {
              yyerror(&@3, parm, "syntax error, 'where' expression outside generator call");
              hadWhere = true;
              $$=nullptr;
            }
            args.push_back((*$3)[i].first);
          }
          if (!hadWhere) {
            $$=Call::a(@$, $1, args);
          }
        }
        free($1);
        delete $3;
      }
    | MZN_IDENTIFIER '(' comp_or_expr ')' '(' expr ')'
      {
        vector<Generator> gens;
        vector<Id*> ids;
        if ($3) {
          for (unsigned int i=0; i<$3->size(); i++) {
            if (Id* id = Expression::dynamicCast<Id>((*$3)[i].first)) {
              if ((*$3)[i].second) {
                ParserLocation loc = Expression::loc((*$3)[i].second).parserLocation();
                yyerror(&loc, parm, "illegal where expression in generator call");
              }
              ids.push_back(id);
            } else {
              if (BinOp* boe = Expression::dynamicCast<BinOp>((*$3)[i].first)) {
                if (boe->lhs() && boe->rhs()) {
                  Id* id = Expression::dynamicCast<Id>(boe->lhs());
                  if (id && boe->op() == BOT_IN) {
                    ids.push_back(id);
                    gens.push_back(Generator(ids,boe->rhs(),(*$3)[i].second));
                    ids = vector<Id*>();
                  } else if (id && boe->op() == BOT_EQ && ids.empty()) {
                    ids.push_back(id);
                    gens.push_back(Generator(ids,nullptr,boe->rhs()));
                    if ((*$3)[i].second) {
                      gens.push_back(Generator(static_cast<int>(gens.size()),(*$3)[i].second));
                    }
                    ids = vector<Id*>();
                  } else {
                    ParserLocation loc = Expression::loc((*$3)[i].first).parserLocation();
                    yyerror(&loc, parm, "illegal expression in generator call");
                  }
                }
              } else {
                ParserLocation loc = Expression::loc((*$3)[i].first).parserLocation();
                yyerror(&loc, parm, "illegal expression in generator call");
              }
            }
          }
        }
        if (ids.size() != 0) {
          yyerror(&@3, parm, "illegal expression in generator call");
        }
        ParserState* pp = static_cast<ParserState*>(parm);
        if (pp->hadError) {
          $$=nullptr;
        } else {
          Generators g; g.g = gens;
          Comprehension* ac = new Comprehension(@$, $6,g,false);
          vector<Expression*> args; args.push_back(ac);
          $$=Call::a(@$, $1, args);
        }
        free($1);
        delete $3;
      }
    | MZN_IDENTIFIER MZN_POW_MINUS1 '(' comp_or_expr ')'
      {
        if ($4!=nullptr) {
          bool hadWhere = false;
          std::vector<Expression*> args;
          for (unsigned int i=0; i<$4->size(); i++) {
            if ((*$4)[i].second) {
              yyerror(&@4, parm, "syntax error, 'where' expression outside generator call");
              hadWhere = true;
              $$=nullptr;
            }
            args.push_back((*$4)[i].first);
          }
          if (!hadWhere) {
            $$=Call::a(@$, std::string($1)+"⁻¹", args);
          }
        }
        free($1);
        delete $4;
      }
    | MZN_IDENTIFIER MZN_POW_MINUS1 '(' comp_or_expr ')' '(' expr ')'
      {
        vector<Generator> gens;
        vector<Id*> ids;
        if ($4) {
          for (unsigned int i=0; i<$4->size(); i++) {
            if (Id* id = Expression::dynamicCast<Id>((*$4)[i].first)) {
              if ((*$4)[i].second) {
                ParserLocation loc = Expression::loc((*$4)[i].second).parserLocation();
                yyerror(&loc, parm, "illegal where expression in generator call");
              }
              ids.push_back(id);
            } else {
              if (BinOp* boe = Expression::dynamicCast<BinOp>((*$4)[i].first)) {
                if (boe->lhs() && boe->rhs()) {
                  Id* id = Expression::dynamicCast<Id>(boe->lhs());
                  if (id && boe->op() == BOT_IN) {
                    ids.push_back(id);
                    gens.push_back(Generator(ids,boe->rhs(),(*$4)[i].second));
                    ids = vector<Id*>();
                  } else if (id && boe->op() == BOT_EQ && ids.empty()) {
                    ids.push_back(id);
                    gens.push_back(Generator(ids,nullptr,boe->rhs()));
                    if ((*$4)[i].second) {
                      gens.push_back(Generator(static_cast<int>(gens.size()),(*$4)[i].second));
                    }
                    ids = vector<Id*>();
                  } else {
                    ParserLocation loc = Expression::loc((*$4)[i].first).parserLocation();
                    yyerror(&loc, parm, "illegal expression in generator call");
                  }
                }
              } else {
                ParserLocation loc = Expression::loc((*$4)[i].first).parserLocation();
                yyerror(&loc, parm, "illegal expression in generator call");
              }
            }
          }
        }
        if (ids.size() != 0) {
          yyerror(&@4, parm, "illegal expression in generator call");
        }
        ParserState* pp = static_cast<ParserState*>(parm);
        if (pp->hadError) {
          $$=nullptr;
        } else {
          Generators g; g.g = gens;
          Comprehension* ac = new Comprehension(@$, $7,g,false);
          vector<Expression*> args; args.push_back(ac);
          $$=Call::a(@$, std::string($1)+"⁻¹", args);
        }
        free($1);
        delete $4;
      }

comp_or_expr : comp_or_expr_head comma_or_none

comp_or_expr_head :
      expr
      { $$=new vector<pair<Expression*,Expression*> >;
        if ($1) {
          $$->push_back(pair<Expression*,Expression*>($1,nullptr));
        }
      }
    | expr MZN_WHERE expr
      { $$=new vector<pair<Expression*,Expression*> >;
        if ($1 && $3) {
          $$->push_back(pair<Expression*,Expression*>($1,$3));
        }
      }
    | comp_or_expr_head ',' expr
      { $$=$1; if ($$ && $3) $$->push_back(pair<Expression*,Expression*>($3,nullptr)); }
    | comp_or_expr_head ',' expr MZN_WHERE expr
      { $$=$1; if ($$ && $3 && $5) $$->push_back(pair<Expression*,Expression*>($3,$5)); }

let_expr :
      MZN_LET '{' '}' MZN_IN expr %prec PREC_ANNO
      { $$=$5; }
    | MZN_LET '{' let_vardecl_item_list '}' MZN_IN expr %prec PREC_ANNO
      { if ($3 && $6) {
          $$=new Let(@$, *$3, $6); delete $3;
        } else {
          $$=nullptr;
        }
      }
    | MZN_LET '{' let_vardecl_item_list comma_or_semi '}' MZN_IN expr %prec PREC_ANNO
      { if ($3 && $7) {
          $$=new Let(@$, *$3, $7); delete $3;
        } else {
          $$=nullptr;
        }
      }

let_vardecl_item_list :
      let_vardecl_item
      { $$=new vector<Expression*>; $$->push_back($1); }
    | constraint_item
      { $$=new vector<Expression*>;
        if ($1) {
          ConstraintI* ce = $1->cast<ConstraintI>();
          $$->push_back(ce->e());
          ce->e(nullptr);
        }
      }
    | let_vardecl_item_list comma_or_semi let_vardecl_item
      { $$=$1; if ($$ && $3) $$->push_back($3); }
    | let_vardecl_item_list comma_or_semi constraint_item
      { $$=$1;
        if ($$ && $3) {
          ConstraintI* ce = $3->cast<ConstraintI>();
          $$->push_back(ce->e());
          ce->e(nullptr);
        }
      }

comma_or_semi : ',' | ';'

let_vardecl_item :
      ti_expr_and_id
      { $$ = $1;
        if ($1 && Expression::type($1->ti()).any() && $1->ti()->domain() == nullptr) {
          // This is an any type, not allowed without a right hand side
          yyerror(&@1, parm, "declarations with `any' type-inst require definition");
        }
        if ($$) $$->toplevel(false);
      }
    | ti_expr_and_id MZN_EQ expr
      { if ($1) {
          $1->e($3);
        }
        $$ = $1;
        if ($$) Expression::loc($$, @$);
        if ($$) $$->toplevel(false);
      }

annotations :
      /* empty */
      { $$=nullptr; }
    | ne_annotations

annotation_expr :
      expr_atom_head_nonstring
      { $$ = $1; }
    | MZN_OUTPUT
      { $$ = new Id(@1, Constants::constants().ids.output, nullptr); }
    | string_expr
      { $$ = Call::a(@1, ASTString("mzn_expression_name"), {$1}); }

ne_annotations :
      MZN_COLONCOLON annotation_expr
      { $$=new std::vector<Expression*>(1);
        (*$$)[0] = $2;
      }
    | ne_annotations MZN_COLONCOLON annotation_expr
      { $$=$1; if ($$) $$->push_back($3); }

id_or_quoted_op :
      MZN_IDENTIFIER
      { $$=$1; }
    | MZN_IDENTIFIER MZN_POW_MINUS1
      { $$=strdup((std::string($1)+"⁻¹").c_str()); }
    | MZN_EQUIV_QUOTED
      { $$=strdup("'<->'"); }
    | MZN_IMPL_QUOTED
      { $$=strdup("'->'"); }
    | MZN_RIMPL_QUOTED
      { $$=strdup("'<-'"); }
    | MZN_OR_QUOTED
      { $$=strdup("'\\/'"); }
    | MZN_XOR_QUOTED
      { $$=strdup("'xor'"); }
    | MZN_AND_QUOTED
      { $$=strdup("'/\\'"); }
    | MZN_LE_QUOTED
      { $$=strdup("'<'"); }
    | MZN_GR_QUOTED
      { $$=strdup("'>'"); }
    | MZN_LQ_QUOTED
      { $$=strdup("'<='"); }
    | MZN_GQ_QUOTED
      { $$=strdup("'>='"); }
    | MZN_EQ_QUOTED
      { $$=strdup("'='"); }
    | MZN_NQ_QUOTED
      { $$=strdup("'!='"); }
    | MZN_IN_QUOTED
      { $$=strdup("'in'"); }
    | MZN_SUBSET_QUOTED
      { $$=strdup("'subset'"); }
    | MZN_SUPERSET_QUOTED
      { $$=strdup("'superset'"); }
    | MZN_UNION_QUOTED
      { $$=strdup("'union'"); }
    | MZN_DIFF_QUOTED
      { $$=strdup("'diff'"); }
    | MZN_SYMDIFF_QUOTED
      { $$=strdup("'symdiff'"); }
    | MZN_DOTDOT_QUOTED
      { $$=strdup("'..'"); }
    | MZN_LE_DOTDOT_QUOTED
      { $$=strdup("'<..'"); }
    | MZN_DOTDOT_LE_QUOTED
      { $$=strdup("'..<'"); }
    | MZN_LE_DOTDOT_LE_QUOTED
      { $$=strdup("'<..<'"); }
    | MZN_PLUS_QUOTED
      { $$=strdup("'+'"); }
    | MZN_MINUS_QUOTED
      { $$=strdup("'-'"); }
    | MZN_MULT_QUOTED
      { $$=strdup("'*'"); }
    | MZN_POW_QUOTED
      { $$=strdup("'^'"); }
    | MZN_DIV_QUOTED
      { $$=strdup("'/'"); }
    | MZN_IDIV_QUOTED
      { $$=strdup("'div'"); }
    | MZN_MOD_QUOTED
      { $$=strdup("'mod'"); }
    | MZN_INTERSECT_QUOTED
      { $$=strdup("'intersect'"); }
    | MZN_NOT_QUOTED
      { $$=strdup("'not'"); }
    | MZN_PLUSPLUS_QUOTED
      { $$=strdup("'++'"); }