c语言create作用,create.c · 在水一钫/中文编程语言项目（无极解释器） - Gitee.com...

#include "MEM.h"

#include "DBG.h"

#include "wuji.h"

static FunctionDefinition *

create_function_definition(char *identifier, ParameterList *parameter_list,

WJ_Boolean is_closure, Block *block)

{

FunctionDefinition *f;

f = wj_malloc(sizeof(FunctionDefinition));

f->name = identifier;

f->type = WUJI_FUNCTION_DEFINITION;

f->is_closure = is_closure;

f->u.wuji_f.parameter = parameter_list;

f->u.wuji_f.block = block;

return f;

}

void

wj_function_define(char *identifier, ParameterList *parameter_list,

Block *block)

{

FunctionDefinition *f;

WJ_Interpreter *inter;

if (wj_search_function(identifier)) {

wj_compile_error(FUNCTION_MULTIPLE_DEFINE_ERR,

STRING_MESSAGE_ARGUMENT, "name", identifier,

MESSAGE_ARGUMENT_END);

return;

}

inter = wj_get_current_interpreter();

f = wj_malloc(sizeof(FunctionDefinition));

f->name = identifier;

f->type = WUJI_FUNCTION_DEFINITION;

f->u.wuji_f.parameter = parameter_list;

f->u.wuji_f.block = block;

f->next = inter->function_list;

inter->function_list = f;

}

ParameterList *

wj_create_parameter(char *identifier)

{

ParameterList *p;

p = wj_malloc(sizeof(ParameterList));

p->name = identifier;

p->next = NULL;

return p;

}

ParameterList *

wj_chain_parameter(ParameterList *list, char *identifier)

{

ParameterList *pos;

for (pos = list; pos->next; pos = pos->next)

;

pos->next = wj_create_parameter(identifier);

return list;

}

ArgumentList *

wj_create_argument_list(Expression *expression)

{

ArgumentList *al;

al = wj_malloc(sizeof(ArgumentList));

al->expression = expression;

al->next = NULL;

return al;

}

ArgumentList *

wj_chain_argument_list(ArgumentList *list, Expression *expr)

{

ArgumentList *pos;

for (pos = list; pos->next; pos = pos->next)

;

pos->next = wj_create_argument_list(expr);

return list;

}

ExpressionList *

wj_create_expression_list(Expression *expression)

{

ExpressionList *el;

el = wj_malloc(sizeof(ExpressionList));

el->expression = expression;

el->next = NULL;

return el;

}

ExpressionList *

wj_chain_expression_list(ExpressionList *list, Expression *expr)

{

ExpressionList *pos;

for (pos = list; pos->next; pos = pos->next)

;

pos->next = wj_create_expression_list(expr);

return list;

}

StatementList *

wj_create_statement_list(Statement *statement)

{

StatementList *sl;

sl = wj_malloc(sizeof(StatementList));

sl->statement = statement;

sl->next = NULL;

return sl;

}

StatementList *

wj_chain_statement_list(StatementList *list, Statement *statement)

{

StatementList *pos;

if (list == NULL)

return wj_create_statement_list(statement);

for (pos = list; pos->next; pos = pos->next)

;

pos->next = wj_create_statement_list(statement);

return list;

}

Expression *

wj_alloc_expression(ExpressionType type)

{

Expression *exp;

exp = wj_malloc(sizeof(Expression));

exp->type = type;

exp->line_number = wj_get_current_interpreter()->current_line_number;

return exp;

}

/* 创建表达式 */

/* Expression * */

/* wj_create_assign_expression(Expression *left, Expression *operand) */

/* { */

/* Expression *exp; */

/* exp = wj_alloc_expression(ASSIGN_EXPRESSION); */

/* exp->u.assign_expression.left = left; */

/* exp->u.assign_expression.operand = operand; */

/* return exp; */

/* } */

Expression *

wj_create_comma_expression(Expression *left, Expression *right)

{

Expression *exp;

exp = wj_alloc_expression(COMMA_EXPRESSION);

exp->u.comma.left = left;

exp->u.comma.right = right;

return exp;

}

Expression *

wj_create_assign_expression(WJ_Boolean is_final, Expression *left,

AssignmentOperator operator, Expression *operand)

{

Expression *exp;

exp = wj_alloc_expression(ASSIGN_EXPRESSION);

if (is_final) {

if (left->type == INDEX_EXPRESSION) {

wj_compile_error(ARRAY_ELEMENT_CAN_NOT_BE_FINAL_ERR,

MESSAGE_ARGUMENT_END);

} else if (operator != NORMAL_ASSIGN) {

wj_compile_error(COMPLEX_ASSIGNMENT_OPERATOR_TO_FINAL_ERR,

MESSAGE_ARGUMENT_END);

}

}

exp->u.assign_expression.is_final = is_final;

exp->u.assign_expression.left = left;

exp->u.assign_expression.operator = operator;

exp->u.assign_expression.operand = operand;

return exp;

}

static Expression

convert_value_to_expression(WJ_Value *v)

{

Expression expr;

if (v->type == WJ_INT_VALUE) {

expr.type = INT_EXPRESSION;

expr.u.int_value = v->u.int_value;

} else if (v->type == WJ_DOUBLE_VALUE) {

expr.type = DOUBLE_EXPRESSION;

expr.u.double_value = v->u.double_value;

} else {

DBG_assert(v->type == WJ_BOOLEAN_VALUE,

("v->type..%d\n", v->type));

expr.type = BOOLEAN_EXPRESSION;

expr.u.boolean_value = v->u.boolean_value;

}

return expr;

}

/* 创建逻辑表达式 && || */

Expression *

wj_create_binary_expression(ExpressionType operator,

Expression *left, Expression *right)

{

if ((left->type == INT_EXPRESSION

|| left->type == DOUBLE_EXPRESSION)

&& (right->type == INT_EXPRESSION

|| right->type == DOUBLE_EXPRESSION)) {

WJ_Value v;

v = wj_eval_binary_expression(wj_get_current_interpreter(),

NULL, operator, left, right);

/* Overwriting left hand expression. */

*left = convert_value_to_expression(&v);

return left;

} else {

Expression *exp;

exp = wj_alloc_expression(operator);

exp->u.binary_expression.left = left;

exp->u.binary_expression.right = right;

return exp;

}

}

Expression *

wj_create_minus_expression(Expression *operand)

{

if (operand->type == INT_EXPRESSION

|| operand->type == DOUBLE_EXPRESSION) {

WJ_Value v;

v = wj_eval_minus_expression(wj_get_current_interpreter(),

NULL, operand);

/* Notice! Overwriting operand expression. */

*operand = convert_value_to_expression(&v);

return operand;

} else {

Expression *exp;

exp = wj_alloc_expression(MINUS_EXPRESSION);

exp->u.minus_expression = operand;

return exp;

}

}

Expression *

wj_create_logical_not_expression(Expression *operand)

{

Expression *exp;

exp = wj_alloc_expression(LOGICAL_NOT_EXPRESSION);

exp->u.logical_not = operand;

return exp;

}

Expression *

wj_create_index_expression(Expression *array, Expression *index)

{

Expression *exp;

exp = wj_alloc_expression(INDEX_EXPRESSION);

exp->u.index_expression.array = array;

exp->u.index_expression.index = index;

return exp;

}

Expression *

wj_create_incdec_expression(Expression *operand, ExpressionType inc_or_dec)

{

Expression *exp;

exp = wj_alloc_expression(inc_or_dec);

exp->u.inc_dec.operand = operand;

return exp;

}

Expression *

wj_create_identifier_expression(char *identifier)

{

Expression *exp;

exp = wj_alloc_expression(IDENTIFIER_EXPRESSION);

exp->u.identifier = identifier;

return exp;

}

Expression *

wj_create_function_call_expression(Expression *func_name, ArgumentList *argument)

{

Expression *exp;

exp = wj_alloc_expression(FUNCTION_CALL_EXPRESSION);

exp->u.function_call_expression.function = func_name;

exp->u.function_call_expression.argument = argument;

return exp;

}

Expression *

wj_create_member_expression(Expression *expression, char *member_name)

{

Expression *exp;

exp = wj_alloc_expression(MEMBER_EXPRESSION);

exp->u.member_expression.expression = expression;

exp->u.member_expression.member_name = member_name;

return exp;

}

/* Expression * */

/* wj_create_method_call_expression(Expression *expression, */

/* char *method_name, ArgumentList *argument) */

/* { */

/* Expression *exp; */

/* exp = wj_alloc_expression(METHOD_CALL_EXPRESSION); */

/* exp->u.method_call_expression.expression = expression; */

/* exp->u.method_call_expression.identifier = method_name; */

/* exp->u.method_call_expression.argument = argument; */

/* return exp; */

/* } */

Expression *

wj_create_boolean_expression(WJ_Boolean value)

{

Expression *exp;

exp = wj_alloc_expression(BOOLEAN_EXPRESSION);

exp->u.boolean_value = value;

return exp;

}

Expression *

wj_create_null_expression(void)

{

Expression *exp;

exp = wj_alloc_expression(NULL_EXPRESSION);

return exp;

}

Expression *

wj_create_array_expression(ExpressionList *list)

{

Expression *exp;

exp = wj_alloc_expression(ARRAY_EXPRESSION);

exp->u.array_literal = list;

return exp;

}

Expression *

wj_create_closure_definition(char *identifier,

ParameterList *parameter_list,

Block *block)

{

Expression *exp;

exp = wj_alloc_expression(CLOSURE_EXPRESSION);

exp->u.closure.function_definition

= create_function_definition(identifier, parameter_list, WJ_TRUE, block);

return exp;

}

static Statement *

alloc_statement(StatementType type)

{

Statement *st;

st = wj_malloc(sizeof(Statement));

st->type = type;

st->line_number = wj_get_current_interpreter()->current_line_number;

return st;

}

Statement *

wj_create_global_statement(IdentifierList *identifier_list)

{

Statement *st;

st = alloc_statement(GLOBAL_STATEMENT);

st->u.global_s.identifier_list = identifier_list;

return st;

}

IdentifierList *

wj_create_global_identifier(char *identifier)

{

IdentifierList *i_list;

i_list = wj_malloc(sizeof(IdentifierList));

i_list->name = identifier;

i_list->next = NULL;

return i_list;

}

IdentifierList *

wj_chain_identifier(IdentifierList *list, char *identifier)

{

IdentifierList *pos;

for (pos = list; pos->next; pos = pos->next)

;

pos->next = wj_create_global_identifier(identifier);

return list;

}

Statement *

wj_create_if_statement(Expression *condition,

Block *then_block, Elsif *elsif_list,

Block *else_block)

{

Statement *st;

st = alloc_statement(IF_STATEMENT);

st->u.if_s.condition = condition;

st->u.if_s.then_block = then_block;

st->u.if_s.elsif_list = elsif_list;

st->u.if_s.else_block = else_block;

return st;

}

Elsif *

wj_chain_elsif_list(Elsif *list, Elsif *add)

{

Elsif *pos;

for (pos = list; pos->next; pos = pos->next)

;

pos->next = add;

return list;

}

Elsif *

wj_create_elsif(Expression *expr, Block *block)

{

Elsif *ei;

ei = wj_malloc(sizeof(Elsif));

ei->condition = expr;

ei->block = block;

ei->next = NULL;

return ei;

}

Statement *

wj_create_while_statement(Expression *condition, Block *block)

{

Statement *st;

st = alloc_statement(WHILE_STATEMENT);

st->u.while_s.condition = condition;

st->u.while_s.block = block;

return st;

}

Statement *

wj_create_for_statement(Expression *init, Expression *cond,

Expression *post, Block *block)

{

Statement *st;

st = alloc_statement(FOR_STATEMENT);

st->u.for_s.init = init;

st->u.for_s.condition = cond;

st->u.for_s.post = post;

st->u.for_s.block = block;

return st;

}

Statement *

wj_create_foreach_statement(char *label, char *variable,

Expression *collection, Block *block)

{

Statement *st;

st = alloc_statement(FOREACH_STATEMENT);

st->u.foreach_s.label = label;

st->u.foreach_s.variable = variable;

st->u.foreach_s.collection = collection;

st->u.foreach_s.block = block;

return st;

}

Block *

wj_create_block(StatementList *statement_list)

{

Block *block;

block = wj_malloc(sizeof(Block));

block->statement_list = statement_list;

return block;

}

Statement *

wj_create_expression_statement(Expression *expression)

{

Statement *st;

st = alloc_statement(EXPRESSION_STATEMENT);

st->u.expression_s = expression;

return st;

}

Statement *

wj_create_return_statement(Expression *expression)

{

Statement *st;

st = alloc_statement(RETURN_STATEMENT);

st->u.return_s.return_value = expression;

return st;

}

Statement *wj_create_break_statement(void)

{

return alloc_statement(BREAK_STATEMENT);

}

Statement *wj_create_continue_statement(void)

{

return alloc_statement(CONTINUE_STATEMENT);

}

Statement *wj_create_try_statement(Block *try_block, char *exception,

Block *catch_block, Block *finally_block)

{

Statement *st;

st = alloc_statement(TRY_STATEMENT);

st->u.try_s.try_block = try_block;

st->u.try_s.catch_block = catch_block;

st->u.try_s.exception = exception;

st->u.try_s.finally_block = finally_block;

return st;

}

Statement *wj_create_throw_statement(Expression *expression)

{

Statement *st;

st = alloc_statement(THROW_STATEMENT);

st->u.throw_s.exception = expression;

return st;

}

一键复制

编辑

Web IDE

原始数据

按行查看

历史