verilog_expr.c

/*
** HDL4SE: 软件Verilog综合仿真平台
** Copyright (C) 2021-2021, raoxianhong<raoxianhong@163.net>
** LCOM: 轻量级组件对象模型
** Copyright (C) 2021-2021, raoxianhong<raoxianhong@163.net>
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are met:
**
** * Redistributions of source code must retain the above copyright notice,
**   this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright notice,
**   this list of conditions and the following disclaimer in the documentation
**   and/or other materials provided with the distribution.
** * The name of the author may be used to endorse or promote products
**   derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
** THE POSSIBILITY OF SUCH DAMAGE.
*/

/*
* verilog_expr.c
  修改记录：
    202106021610: rxh, initial version
	202106061502: rxh, modify from expr to expr
*/
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

#include "object.h"
#include "dlist.h"
#include "bignumber.h"
#include "conststring.h"
#include "verilog_parsetree.h"
#include "verilog_module.h"
#include "verilog_varsel.h"
#define IMPLEMENT_GUID
#include "verilog_expr.h"
#undef IMPLEMENT_GUID

typedef struct _sExpr {
	OBJECT_HEADER
	INTERFACE_DECLARE(IVerilogNode)
	VERILOGNODE_VARDECLARE
	DLIST_VARDECLARE

	verilogExpr data;
}sExpr;

OBJECT_FUNCDECLARE(expr, CLSID_VERILOG_EXPR);

VERILOGNODE_FUNCDECLARE(expr, CLSID_VERILOG_EXPR, sExpr);
DLIST_FUNCIMPL(expr, CLSID_VERILOG_EXPR, sExpr);
OBJECT_FUNCIMPL(expr, sExpr, CLSID_VERILOG_EXPR);

QUERYINTERFACE_BEGIN(expr, CLSID_VERILOG_EXPR)
QUERYINTERFACE_ITEM(IID_VERILOG_NODE, IVerilogNode, sExpr)
QUERYINTERFACE_ITEM(IID_DLIST, IDList, sExpr)
QUERYINTERFACE_END

static const char *exprModuleInfo()
{
	return "1.1.0-20210606.1504 Expression ";
}

static int exprCreate(const PARAMITEM * pParams, int paramcount, HOBJECT * pObject)
{
	sExpr * pobj;
	pobj = (sExpr *)malloc(sizeof(sExpr));
	if (pobj == NULL)
		return -1;

	memset(pobj, 0, sizeof(sExpr));
	
	*pObject = 0;
	DLIST_VARINIT(pobj, expr);
	VERILOGNODE_VARINIT(pobj, CLSID_VERILOG_EXPR);
	INTERFACE_INIT(IVerilogNode, pobj, expr, verilognode);
  	
	/*返回生成的对象*/
	OBJECT_RETURN_GEN(expr, pobj, pObject, CLSID_VERILOG_EXPR);
	return EIID_OK;
}


static void exprDestroy(HOBJECT object)
{
	sExpr * pobj;
	pobj = (sExpr *)objectThis(object);
	objectRelease(pobj->data.value);
	objectRelease(pobj->data.expr0);
	objectRelease(pobj->data.expr1);
	objectRelease(pobj->data.expr2);
	objectRelease(pobj->data.range0);
	objectRelease(pobj->data.range1);
	dlistRemoveAll(pobj->data.attributes);
	objectRelease(pobj->data.attributes);
	dlistRemoveAll(pobj->data.elementselect);
	objectRelease(pobj->data.elementselect);
	free(pobj);
}

/*
    功能：判断对象是否是一个有效对象
    参数：
        object -- 对象数据指针
    返回值：
        0 -- 对象是无效的
        1 -- 对象是有效的
*/
static int exprValid(HOBJECT object)
{
    return 1;
}

static int output_operator(FILE* pFile, int opt, int op)
{
	fprintf(pFile, operator_name[op]);
	return 0;
}


static int output_attributes(FILE* pFile, int opt, sExpr* pobj)
{
	if (dlistItemCount(pobj->data.attributes) > 0) {
		fprintf(pFile, "(* ");
		verilog_dump_node_list(pobj->data.attributes, pFile, opt, ", ", 5);
		fprintf(pFile, " *) ");
	}
	return 0;
}

static int expr_verilognode_dump(HOBJECT object, FILE * pFile, int opt)
{
	sExpr * pobj;
	pobj = (sExpr *)objectThis(object);
	switch (pobj->data.exprtype) {
		case EXPRTYPE_NUMBER:
		case EXPRTYPE_STRING:
			fprintf(pFile, conststringFromVar(pobj->data.value));
			break;
		case EXPRTYPE_PARAM:
		case EXPRTYPE_LOCALPARAM:
			fprintf(pFile, conststringFromVar(pobj->data.value));
			break;
		case EXPRTYPE_BINOP:
			objectCall2(pobj->data.expr0, dump, pFile, opt);
			output_operator(pFile, opt, pobj->data.op);
			output_attributes(pFile, opt, pobj);
			objectCall2(pobj->data.expr1, dump, pFile, opt);
			break;
		case EXPRTYPE_UNOP:
			output_operator(pFile, opt, pobj->data.op);
			output_attributes(pFile, opt, pobj);
			objectCall2(pobj->data.expr0, dump, pFile, opt);
			break;
		case EXPRTYPE_IFOP:
			objectCall2(pobj->data.expr0, dump, pFile, opt);
			fprintf(pFile, "?");
			output_attributes(pFile, opt, pobj);
			objectCall2(pobj->data.expr1, dump, pFile, opt);
			fprintf(pFile, ":");
			objectCall2(pobj->data.expr2, dump, pFile, opt);
			break;
		case EXPRTYPE_HIERARCHICAL_IDENT:
			if (dlistItemCount(pobj->data.elementselect) > 0) {
				verilog_dump_node_list(pobj->data.elementselect, pFile, opt, ".", 5);
			}
			break;
		default:
			fprintf(pFile, "<type=%d>", pobj->data.exprtype);
			break;
	}
	return 0;
}

static int expr_calc_binop(int op, IBigNumber** dst, IBigNumber** src0, IBigNumber** src1)
{
	switch (op) {
	case OP_L_NOT: return -1;
	case OP_B_NOT: return -1;
	case OP_B_AND: return -1;
	case OP_B_NAND: return -1;
	case OP_B_OR: return -1;
	case OP_B_NOR: return -1;
	case OP_B_XOR: return -1;
	case OP_B_EQU: return -1;
	case OP_PLUS: objectCall2(dst, Add, src0, src1); return 0;
	case OP_MINUS: objectCall2(dst, Sub, src0, src1); return 0;
	case OP_MUL: objectCall2(dst, Mul, src0, src1); return 0;
	case OP_DIV: return -1;
	case OP_MOD: return -1;
	case OP_POW: return -1;
	case OP_L_EQ: return -1;
	case OP_L_NEQ: return -1;
	case OP_C_EQ: return -1;
	case OP_C_NEQ: return -1;
	case OP_L_AND: return -1;
	case OP_L_OR: return -1;
	case OP_LT: return -1;
	case OP_LTE: return -1;
	case OP_GT: return -1;
	case OP_GTE: return -1;
	case OP_LSR: return -1;
	case OP_LSL: return -1;
	case OP_ASR: return -1;
	case OP_ASL: return -1;
	}
	return -1;
}

static int expr_calc_unop(int op, IBigNumber** dst, IBigNumber** src)
{
	switch (op) {
	case OP_L_NOT: return -1;
	case OP_B_NOT: return -1;
	case OP_B_AND: return -1;
	case OP_B_NAND: return -1;
	case OP_B_OR: return -1;
	case OP_B_NOR: return -1;
	case OP_B_XOR: return -1;
	case OP_B_EQU: return -1;
	case OP_PLUS: 
		if (dst != src)
			objectCall1(dst, Assign, src); 
		return 0;
	case OP_MINUS: 
		objectCall1(dst, Neg, src); 
		return 0;
	}
	return -1;
}

static int expr_setto_number(sExpr* pobj, IBigNumber** number)
{
	objectRelease(pobj->data.bignumber);
	pobj->data.bignumber = NULL;
	if (0 == objectQueryInterface(number, IID_BIGNUMBER, &pobj->data.bignumber)) {
		pobj->data.exprtype = EXPRTYPE_BIGNUMBER;
	}
	return 0;
}

static int expr_verilognode_procheck(HOBJECT object, HOBJECT module, void * param)
{
	sExpr* pobj;
	pobj = (sExpr*)objectThis(object);
	switch (pobj->data.exprtype) {
	case EXPRTYPE_NUMBER:
	{
		int ret = 0;
		IBigNumber** number = NULL;
		number = bigintegerCreate(32);
		if (0 != objectCall3(number, AssignStr, pobj->data.value->string, NULL, 1)) {
			goto endof_number;
		}
		if (0 != expr_setto_number(pobj, number)) {
			goto endof_number;
		}
		ret = 1;
	endof_number:
		objectRelease(number);
		return ret;
	}
	case EXPRTYPE_BIGNUMBER:
		return 1;
	case EXPRTYPE_STRING:
		return 0;
		break;
	case EXPRTYPE_PARAM:
	case EXPRTYPE_LOCALPARAM:
		return 0;
		break;
	case EXPRTYPE_BINOP:
	{
		int cancalc = 0;
		IBigNumber** left = NULL;
		IBigNumber** right = NULL;
		verilogExpr* pexpr;
		if (1 != objectCall2(pobj->data.expr0, procheck, module, param))
			return 0;
		if (1 != objectCall2(pobj->data.expr1, procheck, module, param))
			return 0;
		left = bigintegerCreate(32);
		pexpr = verilogExprGetData(pobj->data.expr0);
		if (pexpr == NULL)
			goto endofbinop;
		if (pexpr->exprtype != EXPRTYPE_BIGNUMBER)
			goto endofbinop;
		if (0 != objectCall1(left, Clone, pexpr->bignumber))
			goto endofbinop;
		right = bigintegerCreate(32);
		pexpr = verilogExprGetData(pobj->data.expr1);
		if (pexpr == NULL) 
			goto endofbinop;
		if (pexpr->exprtype != EXPRTYPE_BIGNUMBER)
			goto endofbinop;
		if (0 != objectCall1(right, Clone, pexpr->bignumber))
			goto endofbinop;
		if (0 != expr_calc_binop(pobj->data.op, left, left, right))
			goto endofbinop;
		if (0 != expr_setto_number(pobj, left)) {
			goto endofbinop;
		}
		cancalc = 1;
	endofbinop:
		objectRelease(left);
		objectRelease(right);
		return cancalc;
	}
		break;
	case EXPRTYPE_UNOP:
	{
		int cancalc = 0;
		IBigNumber** left = NULL;
		verilogExpr* pexpr;
		if (1 != objectCall2(pobj->data.expr0, procheck, module, param))
			return 0;
		left = bigintegerCreate(32);
		pexpr = verilogExprGetData(pobj->data.expr0);
		if (pexpr == NULL)
			goto endofunop;
		if (pexpr->exprtype != EXPRTYPE_BIGNUMBER)
			goto endofunop;
		if (0 != objectCall1(left, Clone, pexpr->bignumber))
			goto endofunop;
		if (0 != expr_calc_unop(pobj->data.op, left, left))
			goto endofunop;
		if (0 != expr_setto_number(pobj, left)) {
			goto endofunop;
		}
		cancalc = 1;
	endofunop:
		objectRelease(left);
		return cancalc;
	}
	break;
	case EXPRTYPE_IFOP:
		break;
	case EXPRTYPE_HIERARCHICAL_IDENT:
		break;
	default:
		break;
	}
	return 0;
}

static int expr_verilognode_gencode(HOBJECT object, FILE * pFile, const char * modulename, void * opt)
{
	sExpr* pobj;
	pobj = (sExpr*)objectThis(object);
	return 0;
}

HOBJECT verilogparseCreateExpr(
	int exprtype,
	IConstStringVar* value,
	HOBJECT range0,
	HOBJECT range1,
	int op,
	HOBJECT expr0,
	HOBJECT expr1,
	HOBJECT expr2,
	IDListVarPtr attributes,
	IDListVarPtr elementselect
)
{
	HOBJECT expr = NULL;
	sExpr * pobj;
	A_u_t_o_registor_expr();
	objectCreate(CLSID_VERILOG_EXPR, NULL, 0, &expr);
	if (expr == NULL)
		return NULL;
	pobj = (sExpr *)objectThis(expr);
	objectQueryInterface(value, IID_CONSTSTRING, (void**)&pobj->data.value);
	pobj->data.exprtype = exprtype;
	pobj->data.op = op;
	pobj->data.attributes = attributes;
	pobj->data.elementselect = elementselect;
	objectQueryInterface(expr0, IID_VERILOG_NODE, (void**)&pobj->data.expr0);
	objectRelease(expr0);
	objectQueryInterface(expr1, IID_VERILOG_NODE, (void**)&pobj->data.expr1);
	objectRelease(expr1);
	objectQueryInterface(expr2, IID_VERILOG_NODE, (void**)&pobj->data.expr2);
	objectRelease(expr2);
	objectQueryInterface(range0, IID_VERILOG_NODE, (void**)&pobj->data.range0);
	objectRelease(range0);
	objectQueryInterface(range1, IID_VERILOG_NODE, (void**)&pobj->data.range1);
	objectRelease(range1);
	return expr;
}

verilogExpr* verilogExprGetData(HOBJECT object)
{
	sExpr* pobj;
	if (!(objectIsClass(object, CLSID_VERILOG_EXPR)))
		return NULL;
	pobj = (sExpr*)objectThis(object);
	return &pobj->data;
}

int verilogparseGenConstExpr(FILE* pFile, const char* pre, HOBJECT expr, HOBJECT module)
{
	int count;
	sExpr* pobj;
	pobj = (sExpr*)objectThis(expr);
	if (pobj == NULL)
		return 0;
	count = 1;
	switch (pobj->data.exprtype) {
	case EXPRTYPE_NUMBER:
	{
		fprintf(pFile, "%s{.exprtype=EXPRTYPE_NUMBER, .value=\"%s\" }, \n", pre, pobj->data.value->string);
		break;
	}
	case EXPRTYPE_BIGNUMBER:
	{
		objectCall3(pobj->data.bignumber, GetStr, 16, hdl4se_parse_logbuf(), 1024);
		fprintf(pFile, "%s{.exprtype=EXPRTYPE_NUMBER, .value=\"%s\" }, \n", pre, hdl4se_parse_logbuf());
		break;
	}
	case EXPRTYPE_STRING:
	{
		fprintf(pFile, "%s{.exprtype=EXPRTYPE_STRING, .value=%s},\n", pre, pobj->data.value->string);
		break;
	}
	case EXPRTYPE_PARAM:
	{
		fprintf(pFile, "%s{.exprtype=EXPRTYPE_PARAM, .index=%d},/* %s */\n", pre, verilogModuleGetParamIndex(module, pobj->data.value->string), pobj->data.value->string);
		break;
	}
	case EXPRTYPE_LOCALPARAM:
	{
		fprintf(pFile, "%s{.exprtype=EXPRTYPE_LOCALPARAM, .index=%d},/* %s */\n", pre, verilogModuleGetLocalParamIndex(module, pobj->data.value->string), pobj->data.value->string);
		break;
	}
	case EXPRTYPE_BINOP:
	{
		count = verilogparseGenConstExpr(pFile, pre, pobj->data.expr0, module);
		count += verilogparseGenConstExpr(pFile, pre, pobj->data.expr1, module);
		fprintf(pFile, "%s{.exprtype=EXPRTYPE_BINOP, .op=%s},\n", pre, OPERATOR_name[pobj->data.op]);
		count++;
		break;
	}
	case EXPRTYPE_UNOP:
	{
		count = verilogparseGenConstExpr(pFile, pre, pobj->data.expr0, module);
		fprintf(pFile, "%s{.exprtype=EXPRTYPE_UNOP, .op=%s},\n", pre, OPERATOR_name[pobj->data.op]);
		count++;
		break;
	}
	case EXPRTYPE_IFOP:
	{
		count = verilogparseGenConstExpr(pFile, pre, pobj->data.expr0, module);
		count += verilogparseGenConstExpr(pFile, pre, pobj->data.expr1, module);
		count += verilogparseGenConstExpr(pFile, pre, pobj->data.expr2, module);
		fprintf(pFile, "%s{.exprtype=EXPRTYPE_IFOP, .op=0},\n", pre);
		count++;
		break;
	}
	case EXPRTYPE_HIERARCHICAL_IDENT:
	{
		int index = -1;
		/* 目前只取第一个名称 */
		verilogVarSel* select;
		select = verilogVarSelGetData(pobj->data.elementselect->__dlist_pNext);
		if (select != NULL) {
			index = verilogModuleGetParamIndex(module, select->name->string);
		}
		if (index >= 0)
			fprintf(pFile, "%s{.exprtype=EXPRTYPE_PARAM, .index=%d},/* %s */\n", pre, index, select->name->string);
		else 
			fprintf(pFile, "%s{error: can not find parameter %s}\n", pre, select->name->string);
		break;
	}
	default:
	{
		fprintf(pFile, "%s error type %d,\n", pre, pobj->data.exprtype);
		count = 0;
		break; 
	}
	}
	return count;
}