verilog-y

將Verilog設計轉成VHDL設計的程式

	{
		fprintf(debug,"case_item: VL_DEFAULT ':' statement_or_null\n");
		t->dec();
	}
	| VL_DEFAULT statement_or_null
	{
		fprintf(debug,"case_item: VL_DEFAULT statement_or_null\n");
	}
	;

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

list_of_register_variables
        : register_variable
          {
		fprintf(debug,"register_variable_list: register_variable\n");
		$$=new List();$$->add((void*)$1);
          }
        | list_of_register_variables ',' register_variable
          {
		$1->add((void*)$3);$$=$1;
          }
        ;
        
register_variable
        : name_of_register
          {
		fprintf(debug,"register_variable: name_of_register\n");
		$$=(RVarP)calloc(1,sizeof(RVar));
		$$->tip=REGISTER;
		$$->name=$1;
		$$->extra=NULL;
          }
        | name_of_memory '[' constant_expression ':' constant_expression ']'
          {
		fprintf(debug,"register_variable: name_of_memory '[' constant_expression ':' constant_expression ']'\n");
		$$=(RVarP)calloc(1,sizeof(RVar));
		$$->tip=MEMORY;
		$$->name=$1;
		char *ptr=(char*)calloc(1+strlen($3)+1+strlen(" to ")+1+strlen($5)+1,sizeof(char));
		strcpy(ptr,"(");strcat(ptr,$3);strcat(ptr," to ");strcat(ptr,$5);strcat(ptr,")");
		$$->extra=ptr;
          }
        ;

name_of_register
        : VL_ID
          {
		fprintf(debug,"name_of_register: VL_ID\n");
		$$=$1;
          }
        ;

name_of_memory
        : VL_ID
          {
		fprintf(debug,"name_of_memory: VL_ID\n");
		$$=$1;
          }
        ;

name_of_variable
	: VL_ID
	{
		$$=$1;
	};


list_of_variables
	: name_of_variable
	{
		fprintf(debug,"list_of_variables: name_of_variable\n");
		$$=new List();
		$$->add((void*)$1);
	}
	| list_of_variables ',' name_of_variable
	{
		fprintf(debug,"list_of_variables: list_of_variables ',' name_of_variable\n");
		$1->add((void*)$3);
		$$=$1;
	};

range_opt
        : /* empty */
          {
              	fprintf(debug,"range_opt:\n");
		$$=(char*)calloc(1,sizeof(char));
		$$[0]='\0';
	  }
        | range
          {
              	fprintf(debug,"range_opt: range\n");
		$$=$1;
          }
        ;

range
        : '[' constant_expression ':' constant_expression ']'
          {
		fprintf(debug,"range: '[' constant_expression ':' constant_expression ']'\n");
		char *ptr=(char*)calloc(strlen($2)+strlen($4)+10,sizeof(char));
		strcpy(ptr,"(");strcat(ptr,$2);strcat(ptr," downto ");strcat(ptr,$4);strcat(ptr,")");
		$$=ptr;
          }
        ;

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

lvalue
	: identifier
	{
		fprintf(debug,"lvalue: identifier\n");
		$$=$1;

	}
	| identifier '[' expression ']'
	{
		fprintf(debug,"lvalue: identifier [expression]\n");
		$$=(char*)calloc(strlen($1)+strlen($3)+3,sizeof(char));
		strcpy($$,$1);strcat($$,"(");strcat($$,$3);strcat($$,")");
	}
	| identifier '[' constant_expression ':' constant_expression ']'
	{
		fprintf(debug,"lvalue: identifier [ constant_expression : constant_expression ]\n");
		$$=(char*)calloc(strlen($1)+strlen($3)+strlen(" downto ")+strlen($5)+3,sizeof(char));
		strcpy($$,$1);strcat($$,"(");
		strcat($$,$3);strcat($$," downto ");strcat($$,$5);strcat($$,")");
	}
	;


expressions
	: expression
	{
		$$=new List();
		$$->add((void*)$1);
	}
	| expressions ',' expression
	{
		$1->add((void*)$3);
		$$=$1;
	}
	;

constant_expression
	: expression
	{
		$$=$1;
	}
	;

expression
        : primary
          {
		fprintf(debug,"expression: primary\n");
		$$=$1;
	  }
        | '+' expression %prec VL_UNARYOPERATOR
          {
		fprintf(debug,"expression: '+' expression VL_UNARYOPERATOR\n");
		$$=expres3("+",$2,"");
	  } 
        | '-' expression %prec VL_UNARYOPERATOR
          {
		fprintf(debug,"expression: '-' expression VL_UNARYOPERATOR\n");
		$$=expres3("-",$2,"");
	  }
        | '!' expression %prec VL_UNARYOPERATOR
          {
		fprintf(debug,"expression: '!' expression VL_UNARYOPERATOR\n");
		$$=expres3(" not ", $2,"");
	  }
        | '~' expression %prec VL_UNARYOPERATOR
          {
		fprintf(debug,"expression: '~' expression VL_UNARYOPERATOR\n");
		$$=expres3(" not ", $2, ""); 
	  }
        | '&' expression %prec VL_UNARYOPERATOR
          {
		unary_and++;
		dumm_test($2);
		$$=expres3(" verilog_unary_and(", $2, ") ");
		fprintf(debug,"expression: '&' expression VL_UNARYOPERATOR\n");
	  }
        | '|' expression %prec VL_UNARYOPERATOR
          {
		unary_or++;
		dumm_test($2);
		$$=expres3(" verilog_unary_or(", $2, ") ");
		fprintf(debug,"expression: '|' expression VL_UNARYOPERATOR\n");
	  }
        | VL_LOGNAND expression %prec VL_UNARYOPERATOR
          {
		unary_nand++;
		dumm_test($2);
		$$=expres3(" verilog_unary_nand(", $2, ") ");
		fprintf(debug,"expression: VL_LOGNAND expression VL_UNARYOPERATOR\n");
	  }
        | VL_LOGNOR expression %prec VL_UNARYOPERATOR
          {
		unary_nor++;
		dumm_test($2);
		$$=expres3(" verilog_unary_nor(", $2, ") ");
		fprintf(debug,"expression: VL_LOGNOR expression VL_UNARYOPERATOR\n");
	  }
        | VL_LOGXNOR expression %prec VL_UNARYOPERATOR
          {
		unary_nxor++;
		dumm_test($2);
		$$=expres3(" verilog_unary_xnor(", $2, ") ");
		fprintf(debug,"expression: VL_LOGXNOR expression VL_UNARYOPERATOR\n");
	  }
        | expression '+' expression
          {
		fprintf(debug,"expression: expression '+' expression\n");
		$$=expres3($1," + ",$3);
	  }
        | expression '-' expression
          {
	      	fprintf(debug,"expression: expression '-' expression\n");	
		$$=expres3($1," - ",$3);
	  }
        | expression '*' expression
          {
	      	fprintf(debug,"expression: expression '*' expression\n");
		$$=expres3($1," * ",$3);	
	  }
        | expression '/' expression
          {
	      	fprintf(debug,"expression: expression '/' expression\n");
		$$=expres3($1," / ",$3);
	  }
        | expression '%' expression
          {
		fprintf(debug,"expression: expression '%' expression\n");
		$$=expres3($1," rem ",$3);
	  }
        | expression VL_LOGEQUALITY expression
          {
		fprintf(debug,"expression: expression VL_LOgEQUALITY expression\n");
		$$=expres3($1," = ",$3);
	  }
        | expression VL_LOGINEQUALITY expression
          {
		fprintf(debug,"expression: expression VL_LOGINEQUALITY expression\n");
		$$=expres3($1," /= ",$3);
	  }
        | expression VL_CASEEQUALITY expression
          {
		fprintf(debug,"expression: expression VL_CASEEQUALITY expression\n");
		$$=expres3($1," = ",$3);
	  }
        | expression VL_CASEINEQUALITY expression
          {
		fprintf(debug,"expression: expression VL_CASEINEQUALITY expression\n");
		$$=expres3($1," /= ",$3);
	  }
        | expression VL_LOGAND expression
          {
		fprintf(debug,"expression: expression VL_LOGAND expression\n");
		$$=expres3($1," and ",$3);
	  }
        | expression VL_LOGOR expression
          {
		fprintf(debug,"expression: expression VL_LOGOR expression\n");
		$$=expres3($1," or ",$3);
	  }
        | expression '<' expression
          {
		fprintf(debug,"expression: expression '<' expression\n");
		$$ = expres3($1," < ",$3);
	  }
        | expression '>' expression
          {
		fprintf(debug,"expression: expression '>' expression\n");
		$$=expres3($1," > ",$3);
	  }
        | expression '&' expression
          {
		fprintf(debug,"expression: expression '&' expression\n");
		$$ = expres3($1, " and ", $3);
	  }
        | expression '|' expression
          {
		fprintf(debug,"expression: expression '|' expression\n");
		$$ = expres3($1, " or ", $3);
	  }
        | expression '^' expression
          {
		fprintf(debug,"expression: expression '^' expression\n");
		$$ = expres3($1, " xor ", $3);
	  }
        | expression VL_LEQ expression
          {
		fprintf(debug,"expression: expression VL_LEQ expression\n");
		$$ = expres3($1, " <= ", $3);
	  }
        | expression VL_NBASSIGN expression
          {
		fprintf(debug,"expression: expression VL_LEQ expression\n");
		$$ = expres3($1, " = ", $3);
	  }
        | expression VL_GEQ expression
          {
		fprintf(debug,"expression: expression VL_GEQ expression\n");
		$$ = expres3($1, " >= ", $3);
	  }
        | expression VL_LSHIFT expression
          {
		shift_l++;
		dumm_test($1);
		$$=expres3(expres3(" verilog_left_shift(", $1," , "),$3,")");
		fprintf(debug,"expression: expression VL_LSHIFT expression\n");
	  }
        | expression VL_RSHIFT expression
          {
		shift_r++;
		dumm_test($1);
		$$=expres3(expres3(" verilog_right_shift(", $1," , "),$3,") ");
		fprintf(debug,"expression: expression VL_RSHIFT expression\n");
	  }
        | expression VL_LOGXNOR expression
          {
		fprintf(debug,"expression: expression VL_LOGXNOR expression\n");
		$$ = expres3($1, " xnor ", $3);
	  }
	| '(' expression ')'
	  {
		fprintf(debug,"expression: ( expression )\n");
		$$ = expres3("(", $2, ")"); 
	  }
        ;

primary
        : VL_INUMBER
         {
		fprintf(debug,"primary: VL_INUMBER\n");
		$$=$1;
	  }
	| VL_BNUMBER
	{
		fprintf(debug,"primary: VL_BNUMBER\n");
		$$=$1;
	}
        | VL_RNUMBER
          {
		fprintf(debug,"primary: VL_RNUMBER\n");
	  }
        | VL_ONUMBER
          {
		fprintf(debug,"primary: VL_ONUMBER\n");
		$$=$1;
	  }
	| VL_DNUMBER
          {
		fprintf(debug,"primary: VL_DNUMBER\n");
		$$=$1;
	  }
	| VL_HNUMBER
          {
		fprintf(debug,"primary: VL_HNUMBER\n");
		$$=$1;
	  }
	| identifier
          {
		fprintf(debug,"primary: identifier\n");
		$$=$1;
	  }
        | identifier '[' expression ']'
          {
		fprintf(debug,"primary: identifier '[' expression ']'\n");
		$$=(char*)calloc(strlen($1)+strlen($3)+3,sizeof(char));
		strcpy($$,$1);strcat($$,"(");strcat($$,$3);strcat($$,")");

	  }
        | identifier '[' constant_expression ':'  constant_expression ']'
          {
		fprintf(debug,"primary: identifier '[' constant_expression ':' constant_expression ']'\n");
		$$=(char*)calloc(strlen($1)+strlen($3)+strlen(" downto ")+strlen($5)+3,sizeof(char));
		strcpy($$,$1);strcat($$,"(");
		strcat($$,$3);strcat($$," downto ");strcat($$,$5);strcat($$,")");
	  }
        ;

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

identifier
        : VL_ID
          {
		fprintf(debug,"identifier: VL_ID:\n");
		$$=$1;
          }
        ;

delay_control
	: '#' VL_INUMBER
	{
		
	}
	| '#' VL_RNUMBER
	{
		
	}
/*
	| '#' identifier
	| '#' mintypmax_expression
 */
	;
event_control
	: '@' identifier
	{
		fprintf(debug,"event_control: '@' identifier\n");
		$$=expres3($2,"'","event");
	}
	| '@' '(' event_expression ')'
	{
		fprintf(debug,"event_control: '@' '(' event_expression ')'\n");
		//$$=expres3("(",$3,")");
		$$=$3;
	}
	;

event_expression
	: expression
	{
		fprintf(debug,"event_expression: expression\n");
		$$=expres3($1,"'","event");
	
	}
	| VL_POSEDGE scalar_event_expression
	{
		fprintf(debug,"event_expression: VL_POSEDGE scalar_event_expression\n");
		char *b1=expres2("(",$2);
		char *b3=expres2(edge_event($2)," = '1')");
		$$=expres3(b1," and ",b3);
	}
	| VL_NEGEDGE scalar_event_expression
	{
		fprintf(debug,"event_expression: VL_NEGEDGE scalar_event_expression\n");
		char *b1=expres2("(",$2);
		char *b3=expres2(edge_event($2)," = '0')");
		$$=expres3(b1," and ",b3);
	}
	| event_expression VL_OR event_expression
	{
		fprintf(debug,"event_expression: event_expression VL_OR event_expression\n");
		$$=expres3($1," or ",$3);
	}
	;

scalar_event_expression
	: expression
	{
		fprintf(debug,"scalar_event_expression: expression\n");
		$$=expres2($1,"'event");
	}
	;
%%

void yyerror(const char *s)
{
	fprintf(stderr,"Sintactic error: %s\n",s);
	fflush(debug);
	fclose(debug);
}

char *beginproc()
{
	static int index=0;
	t=new Tab;
	char *name=(char*)calloc(15,sizeof(char));
	//char *name=(char*)malloc(15*sizeof(char));
	strcpy(name,"file");
	name[4]='a'+index;
	name[5]='\0';
	strcat(name,".t_v2v");
	fp=fopen(name,"w");
	index++;
	return name;
}

void endproc()
{
	if(t!=NULL)delete(t);
	if(fp!=NULL){
		fflush(fp);
		fclose(fp);
	}
}

void execute(char *f_input,char *f_output,char *f_debug)
{
  unlink(f_debug);
  debug=fopen(f_debug,"w");
  //debug=stdout;
  yyin=fopen(f_input,"r");
  output=fopen(f_output,"w");
  yyparse();
  fclose(debug);
  fclose(yyin);
  fclose(output);
}