c - 为什么 $$ 不接受类型 char

Question

我不明白为什么这不起作用。我尝试将 int 值与 $$ 一起使用，并且效果很好，但除非有另一种方式，否则我希望它与字符一起使用。 这是我的 .l 文件:

%{
#include "y.tab.h"
%}
%option noyywrap
%option yylineno
%%
DEFINE return DEFINETAG;
BEGIN return BEGINTAG;
END return ENDTAG;
[A-Z]+[0-9] {strcpy(yylval.buf,yytext); return AUT;}
[a-z_]+(0|[1-9][0-9]*)? {strcpy(yylval.buf, yytext); return EST;}
(\{[^}*]*\})* {strcpy(yylval.buf, yytext); return CODC;}
[->;] return yytext[0];
[ \t\n] ;
. yyerror("Caracter Inválido");
%%

这是我的 .y 文件:

%{
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
extern int yylineno;
int r; int c;
%}
%union {char buf[50]; int val;}
%start gda
%token<buf> BEGINTAG ENDTAG DEFINETAG AUT EST CODC
%type<buf> desta daute dest dtraa dautt dtra
%%
gda  : gda desta dtraa devea {char ma[r][c]; printf("%d, %d\n",r,c);}
     |
     ;
desta: DEFINETAG BEGINTAG daute ENDTAG {$$=$3;}
     ;
daute: daute AUT dest {$$=$3;}
     |
     ;
dest : dest EST {r=r+1;$$=$2;}
     | EST {r=r+1;$$=$1;}
     ;
dtraa: DEFINETAG BEGINTAG dautt ENDTAG 
     ;
dautt: dautt AUT dtra 
     |
     ;    
dtra : dtra EST '-''>' EST {c=c+1;}
     | EST '-''>' EST {c=c+1;}
     ;
devea: devea AUT {printf("void %s(){\n",$2);} BEGINTAG deve ENDTAG {printf("}\n");}
     | AUT {printf("void %s(){\n",$1);} BEGINTAG deve ENDTAG {printf("}\n");}
     ;
deve : deve est CODC
     | 
     ;
est  : EST '-''>' EST {printf("if(estado==%s)estado=%s;\n",$1,$4);}
     |
     ;
%%
int main(){
yyparse();
return 0;
}
int yyerror(char *s){fprintf(stderr, "ERRO(%d):%s\n", yylineno,s); return 0;}

这是我的错误列表:

gda2.y: In function ‘yyparse’:
gda2.y:16:12: error: incompatible types when assigning to type ‘char[50]’ from type ‘char *’
gda2.y:18:12: error: incompatible types when assigning to type ‘char[50]’ from type ‘char *’
gda2.y:21:18: error: incompatible types when assigning to type ‘char[50]’ from type ‘char *’
gda2.y:22:18: error: incompatible types when assigning to type ‘char[50]’ from type ‘char *’

Answer 1

在 C 语言中，给数组赋值是不合法的。例如，您不能这样做:

 char c[50];
 c = "abc";  /* ILLEGAL */

将数组放在 union 中并不能解决问题:

 union {
   char c[50];
   int  i;
 } u;
 u.c = "abc";  /* ILLEGAL */

然而，奇怪的是，您可以将一个结构分配给另一个结构，即使它们包含数组:

 struct FiftyChars {
   char c[50];
 };

 struct FiftyChars a,b;
 strncpy(a.c, "abc", 49);
 b = a;                /* ¡LEGAL! */

bison 和 yacc 不会让你避开 C 的规则。因为 $$ = $2 实际上被翻译成类似这样的东西:

yylval.buf = yystack[top - 2].buf;

无论 buf 指的是什么，都需要允许直接赋值。所以它不可能是一个数组。但它可以是一个struct，其唯一成员是一个数组。这意味着您可以将 %union 声明更改为

%union {struct {char c[50];} buf; int val;}

然后在整个代码中进行适当的更改(例如将 flex 输入文件中的 buf 更改为 buf.c，以及 $n 到 printf 中的 $n.c。

或者，您可以通过使用 strncpy 复制字符串并编写

来避免此问题

strncpy($$, $1, 49);

代替

$$ = $1;

在你的行动中。这应该适用于野牛，虽然我不知道 yacc 的每个实现是否将默认操作($$ = $1)作为 union 副本(这会很好)或作为类型复制(这会引发错误)。

另一方面，您有时可能需要问自己大小 50 是从哪里来的。是否足够大？您是否检查以确保 token 的长度不超过 49 个字符？您的代码是否可能充满潜在的缓冲区溢出？

一旦你开始这样思考，你会发现最好用一个指向动态分配缓冲区的指针来定义你的 union :

%union {char* buf; int val;}

现在将一个语义值 union 中的 buf 分配给另一个语义值中的 buf 没有问题，你可以只使用 strdup 在您的 flex 文件中初始化 buf 字段。但是您现在遇到了另一个问题，那就是您需要释放所有那些动态分配的名称，否则就会出现内存泄漏。

如果您所做的只是构建一个小型的一次性编译器，那么内存泄漏是可能存在的，尽管很难看。毕竟，当程序终止时，它的所有内存都将被释放，而无需您执行任何操作。这是传统风格，尽管我怀疑绝大多数阅读此答案的程序员都会对这个建议感到愤怒。

不幸的是，修复起来并不容易。语义值从一个堆栈位置传递到另一个堆栈位置，并且没有简单的方法可以知道有多少指针指向给定的字符串，或者何时不再需要该字符串。如果您使用 C++ 而不是 C 作为基础语言，您可以使用 std::string，它将处理所有这些问题以及适当大缓冲区的分配，但代价是做了很多不必要的字符串复制。或者您可以使用指向 std::string 的共享指针，它会为您进行引用计数，同样以一定的运行时成本。

一段时间以来，我的解决方案一直是在词法分析器中维护“内部”字符串的字典——即唯一字符串，并让词法分析器返回一个指向 (const) 独特的字符串。这具有对每个字符串标记进行哈希表查找的成本，但它有效地处理了垃圾收集问题。在解析结束时，可以简单地删除词法分析器及其关联的唯一字符串哈希表。 (当然，如果一个字符串需要比词法分析器存活得更久，它就需要被复制。但在很多情况下，这不是问题。)