C Bison、Flex和使用parser.y编译我的编译器错误

我在编译编译器时出错，我不知道为什么。我正在运行OSX10.9.1和最新的Xcode

parser.y:1.1-5:无效指令：`%code' parser.y:1.7-9:语法错误，意外标识符

这是我的解析器的代码

%code top {

#include "frontend.h"
#include "type.h"
#include "ast.h"
#include "env.h"
#include <glib.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>

extern int yylex(void);
extern int yyerror(const char*);

}

%code requires {

#include "type.h"
#include "ast.h"
#include <glib.h>

}

%union {
      char* id;
      char* str;
      int num;
      GList* list;
      Type* type;
      struct exp* exp;
      struct decl* decl;
      struct stmt *stmt;
      struct GList *stmts_list;
};

%type <exp> exp
%type <exp> aexp
%type <exp> bexp
%type <exp> obj_lit
%type <exp> lvalue
%type <exp> fun_call

%type <list> decls
%type <list> var_decls
%type <decl> decl
%type <decl> var_decl
%type <decl> fun_decl
%type <decl> type_decl
%type <type> type


/* Ids could be types or exps. */
%token <id> T_ID
%token <str> T_STR
%token <num> T_NUM

%token T_LT_EQ "<="
%token T_GT_EQ ">="
%token T_EQ "=="
%token T_NOT_EQ "!="

%token T_VAR T_TYPE T_FUNCTION
      T_FOR T_TO T_WHILE T_IF T_ELSE T_RETURN
      T_NIL T_TRUE T_FALSE
      T_INT T_BOOL
      T_UNKNOWN

%left '|'
%left '&'
%left "==" "!="
%left '<' '>' "<=" ">="
%left '+' '-'
%left '*' '/' '%'
%left T_UMINUS T_UPLUS '!'

%start program

%%

// ian start

program:
      decls {
            done_parsing($1);
      }

decls:
      { GList* declsList = NULL; $$ = declsList; }
    | decls decl {
            $$ = g_list_append($1, $2);
      }

decl: var_decl {
            $$ = $1;
      }
      | fun_decl {
            $$ = $1;
      }
      | type_decl {
            $$ = $1;
      }

var_decls: 
      { GList* declsList = NULL; $$ = declsList; } | var_decls var_decl {
            $$ = g_list_append($1, $2);
      }

var_decl: 
      T_VAR T_ID ':' type ';' {
            Symbol varName = symbol_var($2);
            $$ = decl_new(varName, $4, NULL, NULL, NULL);
      }
      | T_VAR T_ID ':' type '=' exp ';' {
            Symbol varName = symbol_var($2);
            $$ = decl_new(varName, $4, $6, NULL, NULL);
      }

type_decl: 
      T_TYPE T_ID ':' type ';' {
            Symbol typeName = symbol_typename($2);
            $$ = decl_new(typeName, $4, NULL, NULL, NULL);
      }

// ian end

// adam start

param_decl: 
      T_ID ':' type

param_decls: 
      param_decl
      | param_decls ',' param_decl

field_decl: 
      T_ID ':' type

field_decls: 
      field_decl
      | field_decls ',' field_decl

type: 
      T_INT
      | T_BOOL
      | T_ID
      | '[' type ']'
      | '{' field_decls '}'

fun_decl: 
      T_FUNCTION T_ID '(' param_decls ')' ':' type '{' var_decls stmts '}'
      | T_FUNCTION T_ID '(' param_decls ')' '{' var_decls stmts '}'
      | T_FUNCTION T_ID '(' ')' ':' type '{' var_decls stmts '}'
      | T_FUNCTION T_ID '(' ')' '{' var_decls stmts '}'

// adam end

// vv IAN
exp:
      aexp {
            $$ = $1;
      }
      | bexp {
            $$ = $1;
      }
      | obj_lit {
            $$ = $1;
      }
      | fun_call {
            $$ = $1;
      }
      | lvalue {
            $$ = $1;
      }
      | '(' exp ')' {
            $$ = $2;
      }

aexp: 
      T_NUM {
            exp_num_new($1);
      }
      | '+' exp %prec T_UPLUS {
            $$ = exp_binop_new(AST_EXP_MUL, exp_num_new(1), $2);
      }
      | '-' exp %prec T_UMINUS {
            $$ = exp_binop_new(AST_EXP_MUL, exp_num_new(-1), $2);
      }
      | exp '+' exp {
            $$ = exp_binop_new(AST_EXP_PLUS, $1, $3);
      }
      | exp '-' exp {
            $$ = exp_binop_new(AST_EXP_MINUS, $1, $3);
      }
      | exp '/' exp {
            $$ = exp_binop_new(AST_EXP_DIV, $1, $3);
      }
      | exp '%' exp {
            $$ = exp_binop_new(AST_EXP_MOD, $1, $3);
      }
      | exp '*' exp {
            $$ = exp_binop_new(AST_EXP_MUL, $1, $3);
      }

bexp: 
      T_TRUE {
            $$ = exp_new(AST_EXP_TRUE);
      }
      | T_FALSE {
            $$ = exp_new(AST_EXP_FALSE);
      }
      | '!' exp {
            $$ = exp_not_new($2);
      }
      | exp '|' exp {
            $$ = exp_binop_new(AST_EXP_OR, $1, $3);
      }
      | exp '&' exp {
            $$ = exp_binop_new(AST_EXP_AND, $1, $3);
      }
      | exp '<' exp {
            $$ = exp_binop_new(AST_EXP_LT, $1, $3);
      }
      | exp "<=" exp {
            $$ = exp_binop_new(AST_EXP_LT_EQ, $1, $3);
      }
      | exp '>' exp {
            $$ = exp_binop_new(AST_EXP_GT, $1, $3);
      }
      | exp ">=" exp {
            $$ = exp_binop_new(AST_EXP_GT_EQ, $1, $3);
      }
      | exp "==" exp {
            $$ = exp_binop_new(AST_EXP_EQ, $1, $3);
      }
      | exp "!=" exp {
            $$ = exp_binop_new(AST_EXP_NOT_EQ, $1, $3);
      }

// jon start

obj_lit: array_lit | struct_lit
      | T_NIL

array_lit:
      '[' exps ']'
      | T_STR

exps: 
      exp
      | exps ',' exp

struct_lit:
      '{' field_inits '}'

field_init: 
      T_ID '=' exp

field_inits: 
      field_init
      | field_inits ',' field_init

fun_call:
      T_ID '(' exps ')'
      | T_ID '(' ')'

lvalue: 
      T_ID
      | struct_exp '.' T_ID
      | array_exp '[' exp ']'

array_exp: array_lit | fun_call | lvalue
struct_exp: struct_lit | fun_call | lvalue

// jon end

// patrick start

stmts:               { GList *stmts_list = NULL; stmts_list = $$; }
        | stmts stmt { $$ = g_list_append($1, $2); }

stmt:
    exp ';' { $$ = stmt_exp_new($2); }
    | lvalue '=' exp ';' { $$ = stmt_assign_new($1 , $3); }
    | T_IF '(' exp ')' block T_ELSE block { $$ = stmt_if_new($3, $5, $7); }
    | T_IF '(' exp ')' block { $$ = stmt_if_new($3, $5, NULL); }
    | T_WHILE '(' exp ')' block { $$ = stmt_while_new($3, $5); }
    | T_FOR '(' lvalue '=' exp T_TO exp ')' block { $$ = stmt_for_new($3, $5, $7, $9); }
    | T_RETURN '(' exp ')' ';' { $$ = stmt_return_new($3); }
    | T_RETURN ';' { $$ = stmt_return_new(NULL); }

block:
    '{' stmts '}' { $$ = $2; }

//patrick end

%%

int yyerror(const char *p) {
      fprintf(stderr, "Error: %s\n", p);
      return 0;
}

%code顶部{
#包括“frontend.h”
#包括“h型”
#包括“ast.h”
#包括“环境卫生”
#包括
#包括
#包括
#包括
外部内部yylex（无效）；
外部输入错误（常量字符*）；
}
%代码要求{
#包括“h型”
#包括“ast.h”
#包括
}
%联合{
字符*id；
char*str；
int-num；
GList*列表；
类型*类型；
结构exp*exp；
结构decl*decl；
结构stmt*stmt；
结构GList*stmts\u列表；
};
%类型exp
%aexp型
%类型bexp
%类型obj_-lit
%类型左值
%键入fun_call
%decls型
%类型var_decls
%decl型
%类型var_decl
%类型fun_decl
%类型_decl
%类型类型
/*ID可以是类型或表达式*/
%令牌T_ID
%代币T_街
%令牌T_NUM
%令牌T_LT_EQ“=”
%令牌T_EQ“==”
%令牌T_NOT_EQ“！=”
%令牌T_VAR T_类型T_函数
T_为T_TO T_，而T_如果T_其他T_返回
T_NIL T_真T_假
T_INT T_BOOL
未知
%左“|”
%左“&”
%左“==”！=”
%左“=”
%左'+''-'
%左'*''/''%
%左T_umius T_UPLUS'！'
%启动程序
%%
//伊恩·斯特恩
节目：
德克斯{
完成语法分析（1美元）；
}
decls：
{GList*declsList=NULL；$$=declsList；}
|十二月{
$$=g_list_append（$1，$2）；
}
decl:var_decl{
$$ = $1;
}
|乐天{
$$ = $1;
}
|类型_decl{
$$ = $1;
}
var_decls：
{GList*declsList=NULL；$$=declsList；}| var_decls var_decl{
$$=g_list_append（$1，$2）；
}
var_decl：
T_VAR T_ID'：'type'；'{
Symbol varName=Symbol_var（$2）；
$$=decl_new（varName，$4，NULL，NULL，NULL）；
}
|T_VAR T_ID'：'type'='exp'；'{
Symbol varName=Symbol_var（$2）；
$$=decl_new（varName，$4，$6，NULL，NULL）；
}
类型_decl:
T_TYPE T_ID'：'TYPE'；'{
Symbol typeName=Symbol\U typeName（$2）；
$$=decl_new（typeName，$4，NULL，NULL，NULL）；
}
//伊恩端
//亚当·斯泰特
参数：
T_ID'：'类型
参数：
帕拉姆·德克尔
|param_decls'，“param_decls”
字段名称：
T_ID'：'类型
现场数据：
德克尔油田
|字段名称“，”字段名称“，”
类型：
图因
|图布尔
|T_ID
|“[”类型“]”
|“{field_decls'}”
趣事：
T_函数T_ID'（'param_decls'）''type'{'var_decls stmts'}'
|T_函数T_ID'（'param_decls'）'{'var_decls stmts'}'
|T_函数T_ID'（''）：'type'{'var_decls stmts'}'
|T_函数T_ID'（''）{'var_decls stmts'}
//亚当端
//伊恩
经验：
aexp{
$$ = $1;
}
|bexp{
$$ = $1;
}
|obj_照明{
$$ = $1;
}
|有趣的电话{
$$ = $1;
}
|左值{
$$ = $1;
}
|“（'exp'）”{
$$ = $2;
}
aexp：
T_NUM{
新支出（1美元）；
}
|“+”exp%prec T_UPLUS{
$$=exp\u binop\u new（AST\u exp\u MUL，exp\u num\u new（1），$2）；
}
|“-”exp%prec T_umius{
$$=exp\u binop\u new（AST\u exp\u MUL，exp\u num\u new（-1），$2）；
}
|exp'+'exp{
$$=exp\u binop\u new（AST\u exp\u PLUS，$1，$3）；
}
|exp'-'exp{
$$=exp\u binop\u new（AST\u exp\u减$1，$3）；
}
|exp“/”exp{
$$=exp\u binop\u new（AST\u exp\u DIV，$1，$3）；
}
|exp“%”exp{
$$=exp\u binop\u new（AST\u exp\u MOD，$1，$3）；
}
|exp'*'exp{
$$=exp\u binop\u new（AST\u exp\u MUL，$1，$3）；
}
bexp：
真的吗{
$$=exp\u new（AST\u exp\u TRUE）；
}
|图假{
$$=exp\u new（AST\u exp\u FALSE）；
}
| '!' 经验{
$$=exp\u not\u new（$2）；
}
|exp'| exp{
$$=exp\u binop\u new（AST\u exp\u或$1，$3）；
}
|exp'&'exp{
$$=exp\u binop\u new（AST\u exp\u和$1，$3）；
}
|exp“”exp{
$$=exp\u binop\u new（AST\u exp\u GT，$1，$3）；
}
|exp“>=”exp{
$$=exp\u binop\u new（AST\u exp\u GT\u EQ，$1，$3）；
}
|exp“==”exp{
$$=exp\u binop\u new（AST\u exp\u EQ，$1，$3）；
}
|exp“！=”exp{
$$=exp\u binop\u new（AST\u exp\u NOT\u EQ，$1，$3）；
}
//乔恩·斯特恩
对象照明：阵列照明|结构照明
|图尼尔
阵列照明：
“['exps']”
|图街
出口：
经验
|exps'，'exp
结构灯：
“{”字段_inits'}”
字段_init：
T_ID'='exp
字段初始化：
字段初始化
|字段“初始化”，“字段”初始化
趣味电话：
T_ID'（'exps'）'
|T_ID'（''）
左值：
T_ID
|结构exp.'T\u ID
|数组_exp'['exp']'
array_exp:array_lit | fun|u call |左值
struct_exp:struct_lit | fun|u call |左值
//乔恩·恩德
//帕特里克·斯特恩
stmts:{GList*stmts_list=NULL；stmts_list=$$；}
|stmts stmt{$$=g_list_append（$1，$2）；}
stmt：
exp'；'{$$=stmt\u exp\u new（$2）；}
|左值“=”exp“；”{$$=stmt_assign_new（$1，$3）；}
|T_IF'（'exp'）'块T_ELSE块{$=stmt_IF_new（$3，$5，$7）；}
|T_IF'（'exp'）'块{$$=stmt_IF_new（$3，$5，NULL）；}
|T_WHILE'（'exp'）'块{$$=stm_WHILE_new（$3，$5）；}
|对于“（'lvalue'='exp T_TO exp'）”块{$$=stmt_FOR_new（$3，$5，$7，$9）；}
|返回“（'exp'）”；'{$$=stmt_return_new（$3）；}
|返回“；”{$$=stmt_return_new（NULL）；}
区块：
{'stmts'}{$$=$2；}
//帕特里克端
%%
int yyerror（常量字符*p）{
fprintf（标准，“错误：%s\n”，p）；
返回0；
}

从评论中可以看出，您正在使用的

bison

的版本似乎没有