wsstree.c File Reference

#include "wsint.h"
#include "wsgram.h"

Go to the source code of this file.

Functions
WsVarDec *	ws_variable_declaration (WsCompilerPtr compiler, char *name, WsExpression *expr)
WsFormalParm *	ws_formal_parameter (WsCompilerPtr compiler, WsUInt32 line, char *name)
WsList *	ws_list_new (WsCompiler *compiler)
void	ws_list_append (WsCompiler *compiler, WsList *list, void *value)
static void	variable_hash_destructor (void *item, void *context)
WsHashPtr	ws_variable_hash_create (void)
WsNamespace *	ws_variable_define (WsCompilerPtr compiler, WsUInt32 line, WsBool variablep, char *name)
WsNamespace *	ws_variable_lookup (WsCompilerPtr compiler, char *name)
static void	pragma_use_hash_destructor (void *item, void *context)
WsHashPtr	ws_pragma_use_hash_create (void)
void	ws_pragma_use (WsCompilerPtr compiler, WsUInt32 line, char *identifier, WsUtf8String *url)
WsPragmaMetaBody *	ws_pragma_meta_body (WsCompilerPtr compiler, WsUtf8String *property_name, WsUtf8String *content, WsUtf8String *scheme)
void	ws_pragma_meta_body_free (WsCompilerPtr compiler, WsPragmaMetaBody *mb)
static void	function_hash_destructor (void *item, void *context)
WsHashPtr	ws_function_hash_create (void)
WsFunctionHash *	ws_function_hash (WsCompilerPtr compiler, char *name)
void	ws_function (WsCompiler *compiler, WsBool externp, char *name, WsUInt32 line, WsList *params, WsList *block)
void	ws_expr_linearize (WsCompiler *compiler, WsExpression *expr)
static WsExpression *	expr_alloc (WsCompiler *compiler, WsExpressionType type, WsUInt32 line)
WsExpression *	ws_expr_comma (WsCompilerPtr compiler, WsUInt32 line, WsExpression *left, WsExpression *right)
WsExpression *	ws_expr_assign (WsCompilerPtr compiler, WsUInt32 line, char *identifier, int op, WsExpression *expr)
WsExpression *	ws_expr_conditional (WsCompilerPtr compiler, WsUInt32 line, WsExpression *e_cond, WsExpression *e_then, WsExpression *e_else)
WsExpression *	ws_expr_logical (WsCompilerPtr compiler, WsUInt32 line, int type, WsExpression *left, WsExpression *right)
WsExpression *	ws_expr_binary (WsCompilerPtr compiler, WsUInt32 line, int type, WsExpression *left, WsExpression *right)
WsExpression *	ws_expr_unary (WsCompilerPtr compiler, WsUInt32 line, int type, WsExpression *expression)
WsExpression *	ws_expr_unary_var (WsCompilerPtr compiler, WsUInt32 line, WsBool addp, char *variable)
WsExpression *	ws_expr_postfix_var (WsCompilerPtr compiler, WsUInt32 line, WsBool addp, char *variable)
WsExpression *	ws_expr_call (WsCompiler *compiler, WsUInt32 line, int type, char *base, char *name, WsList *arguments)
WsExpression *	ws_expr_symbol (WsCompiler *compiler, WsUInt32 line, char *identifier)
WsExpression *	ws_expr_const_invalid (WsCompiler *compiler, WsUInt32 line)
WsExpression *	ws_expr_const_true (WsCompiler *compiler, WsUInt32 line)
WsExpression *	ws_expr_const_false (WsCompiler *compiler, WsUInt32 line)
WsExpression *	ws_expr_const_integer (WsCompiler *compiler, WsUInt32 line, WsUInt32 ival)
WsExpression *	ws_expr_const_float (WsCompiler *compiler, WsUInt32 line, WsFloat fval)
WsExpression *	ws_expr_const_string (WsCompiler *compiler, WsUInt32 line, WsUtf8String *string)
static void	linearize_variable_init (WsCompiler *compiler, WsList *list, WsUInt32 line)
void	ws_stmt_linearize (WsCompiler *compiler, WsStatement *stmt)
static WsStatement *	stmt_alloc (WsCompiler *compiler, WsStatementType type, WsUInt32 first_line, WsUInt32 last_line)
WsStatement *	ws_stmt_block (WsCompiler *compiler, WsUInt32 fline, WsUInt32 lline, WsList *block)
WsStatement *	ws_stmt_variable (WsCompilerPtr compiler, WsUInt32 line, WsList *variables)
WsStatement *	ws_stmt_empty (WsCompiler *compiler, WsUInt32 line)
WsStatement *	ws_stmt_expr (WsCompiler *compiler, WsUInt32 line, WsExpression *expr)
WsStatement *	ws_stmt_if (WsCompiler *compiler, WsUInt32 line, WsExpression *expr, WsStatement *s_then, WsStatement *s_else)
WsStatement *	ws_stmt_for (WsCompilerPtr compiler, WsUInt32 line, WsList *init, WsExpression *e1, WsExpression *e2, WsExpression *e3, WsStatement *stmt_body)
WsStatement *	ws_stmt_while (WsCompiler *compiler, WsUInt32 line, WsExpression *expr, WsStatement *stmt_arg)
WsStatement *	ws_stmt_continue (WsCompiler *compiler, WsUInt32 line)
WsStatement *	ws_stmt_break (WsCompiler *compiler, WsUInt32 line)
WsStatement *	ws_stmt_return (WsCompilerPtr compiler, WsUInt32 line, WsExpression *expr)

Function Documentation

expr_alloc()

static WsExpression* expr_alloc ( WsCompiler *  compiler, WsExpressionType  type, WsUInt32  line  )

static

Definition at line 873 of file wsstree.c.

References WsExpressionRec::line, WsCompilerRec::pool_stree, type, WsExpressionRec::type, ws_error_memory(), and ws_f_calloc().

Referenced by ws_expr_assign(), ws_expr_binary(), ws_expr_call(), ws_expr_comma(), ws_expr_conditional(), ws_expr_const_false(), ws_expr_const_float(), ws_expr_const_integer(), ws_expr_const_invalid(), ws_expr_const_string(), ws_expr_const_true(), ws_expr_logical(), ws_expr_postfix_var(), ws_expr_symbol(), ws_expr_unary(), and ws_expr_unary_var().

{
    WsExpression *expr = ws_f_calloc(compiler->pool_stree, 1, sizeof(*expr));

    if (expr == NULL)
        ws_error_memory(compiler);
    else {
        expr->type = type;
        expr->line = line;
    }

    return expr;
}

function_hash_destructor()

static void function_hash_destructor ( void *  item, void *  context  )

static

Definition at line 306 of file wsstree.c.

References ws_free().

Referenced by ws_function_hash_create().

{
    ws_free(item);
}

linearize_variable_init()

static void linearize_variable_init ( WsCompiler *  compiler, WsList *  list, WsUInt32  line  )

static

Definition at line 1133 of file wsstree.c.

References WsListItemRec::data, WsVarDecRec::expr, WsListRec::head, WsVarDecRec::name, WsListItemRec::next, WsNamespaceRec::vindex, ws_asm_link(), WS_ASM_P_STORE_VAR, ws_asm_variable(), ws_expr_linearize(), WS_TRUE, and ws_variable_define().

Referenced by ws_stmt_linearize().

{
    WsNamespace *ns;
    WsListItem *li;

    /* For each variable, declared with this list. */
    for (li = list->head; li; li = li->next) {
        WsVarDec *vardec = li->data;

        ns = ws_variable_define(compiler, line, WS_TRUE, vardec->name);
        if (ns && vardec->expr) {
            ws_expr_linearize(compiler, vardec->expr);

            /* Emit an instruction to store the initialization
               value to the variable. */
            ws_asm_link(compiler,
                        ws_asm_variable(compiler, line, WS_ASM_P_STORE_VAR,
                                        ns->vindex));
        }
    }
}

pragma_use_hash_destructor()

static void pragma_use_hash_destructor ( void *  item, void *  context  )

static

Definition at line 208 of file wsstree.c.

References ws_free().

Referenced by ws_pragma_use_hash_create().

{
    ws_free(item);
}

stmt_alloc()

static WsStatement* stmt_alloc ( WsCompiler *  compiler, WsStatementType  type, WsUInt32  first_line, WsUInt32  last_line  )

static

Definition at line 1372 of file wsstree.c.

References WsStatementRec::first_line, WsStatementRec::last_line, WsCompilerRec::pool_stree, type, WsStatementRec::type, ws_error_memory(), and ws_f_calloc().

Referenced by ws_stmt_block(), ws_stmt_break(), ws_stmt_continue(), ws_stmt_empty(), ws_stmt_expr(), ws_stmt_for(), ws_stmt_if(), ws_stmt_return(), ws_stmt_variable(), and ws_stmt_while().

{
    WsStatement *stmt = ws_f_calloc(compiler->pool_stree, 1, sizeof(*stmt));

    if (stmt == NULL)
        ws_error_memory(compiler);
    else {
        stmt->type = type;
        stmt->first_line = first_line;
        stmt->last_line = last_line;
    }

    return stmt;
}

variable_hash_destructor()

static void variable_hash_destructor ( void *  item, void *  context  )

static

Definition at line 148 of file wsstree.c.

References ws_free().

Referenced by ws_variable_hash_create().

{
    ws_free(item);
}

ws_expr_assign()

WsExpression* ws_expr_assign	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		char *	identifier,
		int	op,
		WsExpression *	expr
	)

Definition at line 903 of file wsstree.c.

References WsExpressionRec::assign, expr_alloc(), WsCompilerRec::pool_stree, WsExpressionRec::u, ws_error_memory(), WS_EXPR_ASSIGN, ws_f_strdup(), and ws_lexer_free_block().

Referenced by yyparse().

{
    WsExpression *e = expr_alloc(compiler, WS_EXPR_ASSIGN, line);

    if (e) {
        e->u.assign.identifier = ws_f_strdup(compiler->pool_stree, identifier);
        if (e->u.assign.identifier == NULL)
            ws_error_memory(compiler);

        e->u.assign.op = op;
        e->u.assign.expr = expr;
    }

    /* Free the identifier symbol since it allocated from the system
       heap. */
    ws_lexer_free_block(compiler, identifier);

    return e;
}

ws_expr_binary()

WsExpression* ws_expr_binary	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		int	type,
		WsExpression *	left,
		WsExpression *	right
	)

Definition at line 956 of file wsstree.c.

References WsExpressionRec::binary, expr_alloc(), type, WsExpressionRec::u, and WS_EXPR_BINARY.

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_BINARY, line);

    if (expr) {
        expr->u.binary.type = type;
        expr->u.binary.left = left;
        expr->u.binary.right = right;
    }

    return expr;
}

ws_expr_call()

WsExpression* ws_expr_call	(	WsCompiler *	compiler,
		WsUInt32	line,
		int	type,
		char *	base,
		char *	name,
		WsList *	arguments
	)

Definition at line 1028 of file wsstree.c.

References WsExpressionRec::call, expr_alloc(), name, WsCompilerRec::pool_stree, type, WsExpressionRec::u, ws_error_memory(), WS_EXPR_CALL, ws_f_strdup(), and ws_lexer_free_block().

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_CALL, line);

    if (expr) {
        expr->u.call.type = type;
        expr->u.call.base = ws_f_strdup(compiler->pool_stree, base);
        expr->u.call.name = ws_f_strdup(compiler->pool_stree, name);
        expr->u.call.arguments = arguments;

        if ((base && expr->u.call.base == NULL)
            || (name && expr->u.call.name == NULL))
            ws_error_memory(compiler);
    }

    ws_lexer_free_block(compiler, base);
    ws_lexer_free_block(compiler, name);

    return expr;
}

ws_expr_comma()

WsExpression* ws_expr_comma	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsExpression *	left,
		WsExpression *	right
	)

Definition at line 889 of file wsstree.c.

References WsExpressionRec::comma, expr_alloc(), WsExpressionRec::u, and WS_EXPR_COMMA.

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_COMMA, line);

    if (expr) {
        expr->u.comma.left = left;
        expr->u.comma.right = right;
    }

    return expr;
}

ws_expr_conditional()

WsExpression* ws_expr_conditional	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsExpression *	e_cond,
		WsExpression *	e_then,
		WsExpression *	e_else
	)

Definition at line 925 of file wsstree.c.

References WsExpressionRec::conditional, expr_alloc(), WsExpressionRec::u, and WS_EXPR_CONDITIONAL.

Referenced by yyparse().

{
    WsExpression *e = expr_alloc(compiler, WS_EXPR_CONDITIONAL, line);

    if (e) {
        e->u.conditional.e_cond = e_cond;
        e->u.conditional.e_then = e_then;
        e->u.conditional.e_else = e_else;
    }

    return e;
}

ws_expr_const_false()

WsExpression* ws_expr_const_false	(	WsCompiler *	compiler,
		WsUInt32	line
	)

Definition at line 1080 of file wsstree.c.

References expr_alloc(), and WS_EXPR_CONST_FALSE.

Referenced by yyparse().

{
    return expr_alloc(compiler, WS_EXPR_CONST_FALSE, line);
}

ws_expr_const_float()

WsExpression* ws_expr_const_float	(	WsCompiler *	compiler,
		WsUInt32	line,
		WsFloat	fval
	)

Definition at line 1100 of file wsstree.c.

References expr_alloc(), WsExpressionRec::fval, WsExpressionRec::u, and WS_EXPR_CONST_FLOAT.

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_CONST_FLOAT, line);

    if (expr)
        expr->u.fval = fval;

    return expr;
}

ws_expr_const_integer()

WsExpression* ws_expr_const_integer	(	WsCompiler *	compiler,
		WsUInt32	line,
		WsUInt32	ival
	)

Definition at line 1086 of file wsstree.c.

References expr_alloc(), WsExpressionRec::integer, WsExpressionRec::u, and WS_EXPR_CONST_INTEGER.

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_CONST_INTEGER, line);

    if (expr) {
        expr->u.integer.sign = 1;
        expr->u.integer.ival = ival;
    }

    return expr;
}

ws_expr_const_invalid()

WsExpression* ws_expr_const_invalid	(	WsCompiler *	compiler,
		WsUInt32	line
	)

Definition at line 1068 of file wsstree.c.

References expr_alloc(), and WS_EXPR_CONST_INVALID.

Referenced by yyparse().

{
    return expr_alloc(compiler, WS_EXPR_CONST_INVALID, line);
}

ws_expr_const_string()

WsExpression* ws_expr_const_string	(	WsCompiler *	compiler,
		WsUInt32	line,
		WsUtf8String *	string
	)

Definition at line 1112 of file wsstree.c.

References WsUtf8StringRec::data, expr_alloc(), WsUtf8StringRec::len, WsCompilerRec::pool_stree, WsExpressionRec::string, WsExpressionRec::u, ws_error_memory(), WS_EXPR_CONST_STRING, ws_f_memdup(), and ws_lexer_free_utf8().

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_CONST_STRING, line);

    if (expr) {
        expr->u.string.len = string->len;
        expr->u.string.data = ws_f_memdup(compiler->pool_stree,
                                          string->data, string->len);
        if (expr->u.string.data == NULL)
            ws_error_memory(compiler);
    }

    ws_lexer_free_utf8(compiler, string);

    return expr;
}

ws_expr_const_true()

WsExpression* ws_expr_const_true	(	WsCompiler *	compiler,
		WsUInt32	line
	)

Definition at line 1074 of file wsstree.c.

References expr_alloc(), and WS_EXPR_CONST_TRUE.

Referenced by yyparse().

{
    return expr_alloc(compiler, WS_EXPR_CONST_TRUE, line);
}

ws_expr_linearize()

void ws_expr_linearize	(	WsCompiler *	compiler,
		WsExpression *	expr
	)

Definition at line 395 of file wsstree.c.

References WsExpressionRec::assign, WsCompilerRec::bc, WsExpressionRec::binary, WsExpressionRec::call, WsExpressionRec::comma, WsExpressionRec::conditional, WsListItemRec::data, WsUtf8StringRec::data, WsFunctionHashRec::defined, WsFunctionHashRec::findex, WsCompilerRec::functions, WsExpressionRec::fval, WsExpressionRec::integer, WsUtf8StringRec::len, WsExpressionRec::line, WsExpressionRec::logical, WsListItemRec::next, WsListRec::num_items, WsFunctionRec::params, WsExpressionRec::postfix_var, WsCompilerRec::pragma_use_hash, WsExpressionRec::string, WsExpressionRec::symbol, tADDA, tANDA, tDIVA, tIDIVA, tLSHIFTA, tMULA, tORA, tREMA, tRSSHIFTA, tRSZSHIFTA, tSUBA, tXORA, WsExpressionRec::type, WsExpressionRec::u, WsExpressionRec::unary, WsExpressionRec::unary_var, WsPragmaUseRec::urlindex, WsNamespaceRec::vindex, WS_ASM_ADD, WS_ASM_ADD_ASG, WS_ASM_B_AND, WS_ASM_B_LSHIFT, WS_ASM_B_OR, WS_ASM_B_RSSHIFT, WS_ASM_B_RSZSHIFT, WS_ASM_B_XOR, ws_asm_branch(), ws_asm_call(), ws_asm_call_lib(), ws_asm_call_url(), WS_ASM_CONST_0, WS_ASM_CONST_1, WS_ASM_CONST_ES, WS_ASM_CONST_FALSE, WS_ASM_CONST_INVALID, WS_ASM_CONST_TRUE, WS_ASM_DECR_VAR, WS_ASM_DIV, WS_ASM_IDIV, ws_asm_ins(), ws_asm_label(), ws_asm_link(), ws_asm_load_const(), WS_ASM_MUL, WS_ASM_P_INCR_VAR, WS_ASM_P_JUMP, WS_ASM_P_LOAD_VAR, WS_ASM_P_STORE_VAR, WS_ASM_P_TJUMP, WS_ASM_POP, WS_ASM_REM, WS_ASM_SUB, WS_ASM_SUB_ASG, WS_ASM_TOBOOL, ws_asm_variable(), ws_bc_add_const_float(), ws_bc_add_const_int(), ws_bc_add_const_utf8_string(), ws_error_memory(), WS_EXPR_ASSIGN, WS_EXPR_BINARY, WS_EXPR_CALL, WS_EXPR_COMMA, WS_EXPR_CONDITIONAL, WS_EXPR_CONST_FALSE, WS_EXPR_CONST_FLOAT, WS_EXPR_CONST_INTEGER, WS_EXPR_CONST_INVALID, WS_EXPR_CONST_STRING, WS_EXPR_CONST_TRUE, WS_EXPR_LOGICAL, WS_EXPR_POSTFIX_VAR, WS_EXPR_SYMBOL, WS_EXPR_UNARY, WS_EXPR_UNARY_VAR, ws_fatal(), ws_function_hash(), ws_hash_get(), WS_INT32_MAX, ws_src_error(), ws_stdlib_function(), and ws_variable_lookup().

Referenced by linearize_variable_init(), and ws_stmt_linearize().

{
    WsListItem *li;
    WsAsmIns *ins;

    switch (expr->type) {
    case WS_EXPR_COMMA:
        /* Linearize left. */
        ws_expr_linearize(compiler, expr->u.comma.left);

        /* Pop its result. */
        ws_asm_link(compiler, ws_asm_ins(compiler, expr->line, WS_ASM_POP));

        /* Linearize right */
        ws_expr_linearize(compiler, expr->u.comma.right);
        break;

    case WS_EXPR_ASSIGN:
        {
            WsNamespace *ns = ws_variable_lookup(compiler,
                                                 expr->u.assign.identifier);

            if (ns == NULL) {
                /* Unknown identifier. */
                ws_src_error(compiler, expr->line, "unknown variable `%s'",
                             expr->u.symbol);
                return;
            }

            if (expr->u.assign.op == '=') {
                /* Evaluate the expression. */
                ws_expr_linearize(compiler, expr->u.assign.expr);

                /* Store the value to the variable. */
                ws_asm_link(compiler,
                            ws_asm_variable(compiler, expr->line,
                                            WS_ASM_P_STORE_VAR, ns->vindex));
            } else if (expr->u.assign.op == tADDA) {
                /* Linearize the expression. */
                ws_expr_linearize(compiler, expr->u.assign.expr);

                /* Add it to the variable. */
                ws_asm_link(compiler,
                            ws_asm_variable(compiler, expr->line,
                                            WS_ASM_ADD_ASG, ns->vindex));
            } else if (expr->u.assign.op == tSUBA) {
                /* Linearize the expression. */
                ws_expr_linearize(compiler, expr->u.assign.expr);

                /* Substract it from the variable. */
                ws_asm_link(compiler,
                            ws_asm_variable(compiler, expr->line,
                                            WS_ASM_SUB_ASG, ns->vindex));
            } else {
                /* Load the old value from the variable. */
                ws_asm_link(compiler,
                            ws_asm_variable(compiler, expr->line,
                                            WS_ASM_P_LOAD_VAR, ns->vindex));

                /* Evaluate the expression. */
                ws_expr_linearize(compiler, expr->u.assign.expr);

                /* Perform the operand. */
                ins = NULL;
                switch (expr->u.assign.op) {
                case tMULA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_MUL);
                    break;

                case tDIVA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_DIV);
                    break;

                case tREMA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_REM);
                    break;

                case tADDA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_ADD);
                    break;

                case tSUBA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_SUB);
                    break;

                case tLSHIFTA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_B_LSHIFT);
                    break;

                case tRSSHIFTA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_B_RSSHIFT);
                    break;

                case tRSZSHIFTA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_B_RSZSHIFT);
                    break;

                case tANDA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_B_AND);
                    break;

                case tXORA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_B_XOR);
                    break;

                case tORA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_B_OR);
                    break;

                case tIDIVA:
                    ins = ws_asm_ins(compiler, expr->line, WS_ASM_IDIV);
                    break;

                default:
                    ws_fatal("ws_expr_linearize(): unknown assignment operand %x",
                             expr->u.assign.op);
                    break;
                }
                ws_asm_link(compiler, ins);

                /* Store the value to the variable. */
                ws_asm_link(compiler,
                            ws_asm_variable(compiler, expr->line,
                                            WS_ASM_P_STORE_VAR, ns->vindex));
            }
            /* The value of the assignment expression is the value
               assigned.  So, we must load the value from the variable.
               This would also be a good place for the `dup' operand but
               we lose since we don't have it. */
            ws_asm_link(compiler, ws_asm_variable(compiler, expr->line,
                                                  WS_ASM_P_LOAD_VAR, ns->vindex));
        }
        break;

    case WS_EXPR_CONDITIONAL:
        {
            WsAsmIns *l_else = ws_asm_label(compiler, expr->line);
            WsAsmIns *l_end = ws_asm_label(compiler, expr->line);

            /* Linearize condition. */
            ws_expr_linearize(compiler, expr->u.conditional.e_cond);

            /* If the result if false, jump to the else-branch. */
            ws_asm_link(compiler, ws_asm_branch(compiler, expr->line,
                                                WS_ASM_P_TJUMP, l_else));

            /* Linearize the then-expression and jump out. */
            ws_expr_linearize(compiler, expr->u.conditional.e_then);
            ws_asm_link(compiler, ws_asm_branch(compiler, expr->line,
                                                WS_ASM_P_JUMP, l_end));

            /* The else-branch. */
            ws_asm_link(compiler, l_else);
            ws_expr_linearize(compiler, expr->u.conditional.e_else);

            /* Insert the end label. */
            ws_asm_link(compiler, l_end);
        }
        break;

    case WS_EXPR_LOGICAL:
        {
            WsAsmIns *l_out = ws_asm_label(compiler, expr->line);

            /* Linearize the left-hand size expression. */
            ws_expr_linearize(compiler, expr->u.logical.left);

            /* Short-circuit check.  The type of the logical expression is
                      the short-circuit byte-code operand. */
            ws_asm_link(compiler, ws_asm_ins(compiler, expr->line,
                                             expr->u.logical.type));
            ws_asm_link(compiler, ws_asm_branch(compiler, expr->line,
                                                WS_ASM_P_TJUMP, l_out));

            /* Linearize the right-hand size expression. */
            ws_expr_linearize(compiler, expr->u.logical.right);

            /* The result of a logical expression should be boolean.
             * Control statements do automatic conversion, but typeof()
         * does not. */
            ws_asm_link(compiler, ws_asm_ins(compiler, expr->line,
                                         WS_ASM_TOBOOL));

            /* Insert the end label. */
            ws_asm_link(compiler, l_out);
        }
        break;

    case WS_EXPR_BINARY:
        /* Linearize left and right. */
        ws_expr_linearize(compiler, expr->u.binary.left);
        ws_expr_linearize(compiler, expr->u.binary.right);

        /* The type of the binary expression is the byte-code opcode. */
        ws_asm_link(compiler, ws_asm_ins(compiler, expr->line,
                                         expr->u.binary.type));
        break;

    case WS_EXPR_UNARY:
        /* Linearize the expression. */
        ws_expr_linearize(compiler, expr->u.unary.expr);

        /* The type of the unary expression is the byte-code opcode. */
        ws_asm_link(compiler, ws_asm_ins(compiler, expr->line,
                                         expr->u.unary.type));
        break;

    case WS_EXPR_UNARY_VAR:
        {
            WsNamespace *ns = ws_variable_lookup(compiler,
                                                 expr->u.unary_var.variable);
            if (ns == NULL) {
                /* An unknown identifier. */
                ws_src_error(compiler, expr->line, "unknown variable `%s'",
                             expr->u.unary_var.variable);
                return;
            }

            /* First, do the operation. */
            if (expr->u.unary_var.addp)
                ws_asm_link(compiler,
                            ws_asm_variable(compiler, expr->line, WS_ASM_P_INCR_VAR,
                                            ns->vindex));
            else
                ws_asm_link(compiler,
                            ws_asm_variable(compiler, expr->line, WS_ASM_DECR_VAR,
                                            ns->vindex));

            /* Second, load the new value of the variable. */
            ws_asm_link(compiler, ws_asm_variable(compiler, expr->line,
                                                  WS_ASM_P_LOAD_VAR, ns->vindex));
        }
        break;

    case WS_EXPR_POSTFIX_VAR:
        {
            WsNamespace *ns = ws_variable_lookup(compiler,
                                                 expr->u.postfix_var.variable);
            if (ns == NULL) {
                /* An unknown identifier. */
                ws_src_error(compiler, expr->line, "unknown variable `%s'",
                             expr->u.postfix_var.variable);
                return;
            }

            /* First, load the old value of the variable. */
            ws_asm_link(compiler, ws_asm_variable(compiler, expr->line,
                                                  WS_ASM_P_LOAD_VAR, ns->vindex));

            /* Second, do the operation. */
            if (expr->u.unary_var.addp)
                ws_asm_link(compiler,
                            ws_asm_variable(compiler, expr->line, WS_ASM_P_INCR_VAR,
                                            ns->vindex));
            else
                ws_asm_link(compiler,
                            ws_asm_variable(compiler, expr->line, WS_ASM_DECR_VAR,
                                            ns->vindex));
        }
        break;

    case WS_EXPR_CALL:
        /* First, evaluate the arguments. */
        for (li = expr->u.call.arguments->head; li; li = li->next)
            ws_expr_linearize(compiler, li->data);

        /* Second, emit the call instruction. */
        switch (expr->u.call.type) {
        case ' ':       /* LocalScriptFunctionCall */
            {
                WsFunctionHash *f = ws_function_hash(compiler, expr->u.call.name);

                if (f == NULL || !f->defined)
                {
                    ws_src_error(compiler, expr->line,
                                 "unknown local function `%s'",
                                 expr->u.call.name);
                    return;
                }

                /* Check that the function is called with correct amount
                          of arguments. */
                if (expr->u.call.arguments->num_items
                    != compiler->functions[f->findex].params->num_items)
                {
                    ws_src_error(compiler, expr->line,
                                 "invalid amount of arguments for `%s': "
                                 "expected %u, got %u",
                                 expr->u.call.name,
                                 compiler->functions[f->findex].params->num_items,
                                 expr->u.call.arguments->num_items);
                    return;
                }

                /* Emit assembler. */
                ws_asm_link(compiler, ws_asm_call(compiler, expr->line,
                                                  f->findex));
            }
            break;

        case '#':       /* ExternalScriptFunctionCall */
            {
                WsPragmaUse *use = ws_hash_get(compiler->pragma_use_hash,
                                               expr->u.call.base);
                WsUInt16 findex;

                if (use == NULL)
                {
                    ws_src_error(compiler, expr->line,
                                 "unknown external compilation unit `%s'",
                                 expr->u.call.base);
                    return;
                }

                /* Insert the function name to the byte-code pool. */
                if (!ws_bc_add_const_utf8_string(
                        compiler->bc, &findex,
                        (unsigned char *) expr->u.call.name,
                        strlen(expr->u.call.name)))
                {
                    ws_error_memory(compiler);
                    return;
                }

                /* Emit assembler. */
                ws_asm_link(compiler,
                            ws_asm_call_url(compiler, expr->line,
                                            findex, use->urlindex,
                                            expr->u.call.arguments->num_items));
            }
            break;

        case '.':       /* LibraryFunctionCall */
            {
                WsUInt16 lindex;
                WsUInt8 findex;
                WsUInt8 num_args;
                WsBool lindex_found;
                WsBool findex_found;

                if (!ws_stdlib_function(expr->u.call.base, expr->u.call.name,
                                        &lindex, &findex, &num_args,
                                        &lindex_found, &findex_found))
                {
                    if (!lindex_found)
                        ws_src_error(compiler, expr->line,
                                     "unknown system library `%s'",
                                     expr->u.call.base);
                    else
                        ws_src_error(compiler, expr->line,
                                     "unknown library function `%s.%s'",
                                     expr->u.call.base, expr->u.call.name);

                    return;
                }
                /* Check the argument count. */
                if (expr->u.call.arguments->num_items != num_args)
                {
                    ws_src_error(compiler, expr->line,
                                 "invalid amount of arguments for `%s.%s': "
                                 "expected %u, got %u",
                                 expr->u.call.base, expr->u.call.name,
                                 num_args, expr->u.call.arguments->num_items);
                    return;
                }

                /* Emit assembler. */
                ws_asm_link(compiler, ws_asm_call_lib(compiler, expr->line, findex,
                                                      lindex));
            }
            break;

        default:
            ws_fatal("ws_expr_linearize(): unknown call expression type %x",
                     expr->u.call.type);
            break;
        }
        break;

    case WS_EXPR_SYMBOL:
        {
            WsNamespace *ns = ws_variable_lookup(compiler, expr->u.symbol);

            if (ns == NULL) {
                /* An unknown identifier. */
                ws_src_error(compiler, expr->line, "unknown variable `%s'",
                             expr->u.symbol);
                return;
            }

            /* Create a load instruction for the variable. */
            ws_asm_link(compiler, ws_asm_variable(compiler, expr->line,
                                                  WS_ASM_P_LOAD_VAR, ns->vindex));
        }
        break;

    case WS_EXPR_CONST_INVALID:
        ws_asm_link(compiler, ws_asm_ins(compiler, expr->line,
                                         WS_ASM_CONST_INVALID));
        break;

    case WS_EXPR_CONST_TRUE:
        ws_asm_link(compiler, ws_asm_ins(compiler, expr->line,
                                         WS_ASM_CONST_TRUE));
        break;

    case WS_EXPR_CONST_FALSE:
        ws_asm_link(compiler, ws_asm_ins(compiler, expr->line,
                                         WS_ASM_CONST_FALSE));
        break;


    case WS_EXPR_CONST_INTEGER:
        if (expr->u.integer.ival == 0)
            ins = ws_asm_ins(compiler, expr->line, WS_ASM_CONST_0);
        else if (expr->u.integer.ival == 1 && expr->u.integer.sign == 1)
            ins = ws_asm_ins(compiler, expr->line, WS_ASM_CONST_1);
        else {
            WsUInt16 cindex;
        WsInt32 ival;

            if (expr->u.integer.sign >= 0) {
        if (expr->u.integer.ival > (WsUInt32) WS_INT32_MAX)
            ws_src_error(compiler, expr->line,
                                 "integer literal too large");
                ival = expr->u.integer.ival;
        } else {
                if (expr->u.integer.ival > (WsUInt32) WS_INT32_MAX + 1)
            ws_src_error(compiler, expr->line, "integer too small");
                ival = - (WsInt32) expr->u.integer.ival;
        }

            if (!ws_bc_add_const_int(compiler->bc, &cindex, ival)) {
                ws_error_memory(compiler);
                return;
            }
            ins = ws_asm_load_const(compiler, expr->line, cindex);
        }

        ws_asm_link(compiler, ins);
        break;

    case WS_EXPR_CONST_FLOAT:
        {
            WsUInt16 cindex;

            if (!ws_bc_add_const_float(compiler->bc, &cindex, expr->u.fval)) {
                ws_error_memory(compiler);
                return;
            }

            ws_asm_link(compiler, ws_asm_load_const(compiler, expr->line, cindex));
        }
        break;

    case WS_EXPR_CONST_STRING:
        if (expr->u.string.len == 0)
            ins = ws_asm_ins(compiler, expr->line, WS_ASM_CONST_ES);
        else {
            WsUInt16 cindex;

            if (!ws_bc_add_const_utf8_string(compiler->bc, &cindex,
                                             expr->u.string.data,
                                             expr->u.string.len)) {
                ws_error_memory(compiler);
                return;
            }
            ins = ws_asm_load_const(compiler, expr->line, cindex);
        }

        ws_asm_link(compiler, ins);
        break;
    }
}

ws_expr_logical()

WsExpression* ws_expr_logical	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		int	type,
		WsExpression *	left,
		WsExpression *	right
	)

Definition at line 941 of file wsstree.c.

References expr_alloc(), WsExpressionRec::logical, type, WsExpressionRec::u, and WS_EXPR_LOGICAL.

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_LOGICAL, line);

    if (expr) {
        expr->u.logical.type = type;
        expr->u.logical.left = left;
        expr->u.logical.right = right;
    }

    return expr;
}

ws_expr_postfix_var()

WsExpression* ws_expr_postfix_var	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsBool	addp,
		char *	variable
	)

Definition at line 1010 of file wsstree.c.

References expr_alloc(), WsCompilerRec::pool_stree, WsExpressionRec::postfix_var, WsExpressionRec::u, ws_error_memory(), WS_EXPR_POSTFIX_VAR, ws_f_strdup(), and ws_lexer_free_block().

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_POSTFIX_VAR, line);

    if (expr) {
        expr->u.postfix_var.addp = addp;
        expr->u.postfix_var.variable = ws_f_strdup(compiler->pool_stree,
                                       variable);
        if (expr->u.postfix_var.variable == NULL)
            ws_error_memory(compiler);
    }
    ws_lexer_free_block(compiler, variable);

    return expr;
}

ws_expr_symbol()

WsExpression* ws_expr_symbol	(	WsCompiler *	compiler,
		WsUInt32	line,
		char *	identifier
	)

Definition at line 1051 of file wsstree.c.

References expr_alloc(), WsCompilerRec::pool_stree, WsExpressionRec::symbol, WsExpressionRec::u, ws_error_memory(), WS_EXPR_SYMBOL, ws_f_strdup(), and ws_lexer_free_block().

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_SYMBOL, line);

    if (expr) {
        expr->u.symbol = ws_f_strdup(compiler->pool_stree, identifier);
        if (expr->u.symbol == NULL)
            ws_error_memory(compiler);
    }

    ws_lexer_free_block(compiler, identifier);

    return expr;
}

ws_expr_unary()

WsExpression* ws_expr_unary	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		int	type,
		WsExpression *	expression
	)

Definition at line 971 of file wsstree.c.

References expr_alloc(), WsExpressionRec::integer, type, WsExpressionRec::type, WsExpressionRec::u, WsExpressionRec::unary, WS_ASM_UMINUS, WS_EXPR_CONST_INTEGER, and WS_EXPR_UNARY.

Referenced by yyparse().

{
    WsExpression *expr;

    /* Handle negative integers here as a special case of constant folding,
     * in order to get -2147483648 right. */
    if (type == WS_ASM_UMINUS && expression->type == WS_EXPR_CONST_INTEGER) {
        expression->u.integer.sign = - expression->u.integer.sign;
        return expression;
    }

    expr = expr_alloc(compiler, WS_EXPR_UNARY, line);
    if (expr) {
        expr->u.unary.type = type;
        expr->u.unary.expr = expression;
    }

    return expr;
}

ws_expr_unary_var()

WsExpression* ws_expr_unary_var	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsBool	addp,
		char *	variable
	)

Definition at line 993 of file wsstree.c.

References expr_alloc(), WsCompilerRec::pool_stree, WsExpressionRec::u, WsExpressionRec::unary_var, ws_error_memory(), WS_EXPR_UNARY_VAR, ws_f_strdup(), and ws_lexer_free_block().

Referenced by yyparse().

{
    WsExpression *expr = expr_alloc(compiler, WS_EXPR_UNARY_VAR, line);

    if (expr) {
        expr->u.unary_var.addp = addp;
        expr->u.unary_var.variable = ws_f_strdup(compiler->pool_stree, variable);
        if (expr->u.unary_var.variable == NULL)
            ws_error_memory(compiler);
    }
    ws_lexer_free_block(compiler, variable);

    return expr;
}

ws_formal_parameter()

WsFormalParm* ws_formal_parameter	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		char *	name
	)

Definition at line 93 of file wsstree.c.

References parm::name, name, WsCompilerRec::pool_stree, ws_error_memory(), and ws_f_malloc().

Referenced by yyparse().

{
    WsFormalParm *parm = ws_f_malloc(compiler->pool_stree, sizeof(*parm));

    if (parm == NULL)
        ws_error_memory(compiler);
    else {
        parm->line = line;
        parm->name = name;
    }

    return parm;
}

ws_function()

void ws_function	(	WsCompiler *	compiler,
		WsBool	externp,
		char *	name,
		WsUInt32	line,
		WsList *	params,
		WsList *	block
	)

Definition at line 343 of file wsstree.c.

References WsFunctionRec::block, WsFunctionHashRec::defined, WsFunctionRec::externp, WsFunctionRec::findex, WsFunctionHashRec::findex, WsCompilerRec::functions, WsFunctionRec::line, WsFunctionRec::name, name, WsCompilerRec::num_extern_functions, WsCompilerRec::num_functions, WsCompilerRec::num_local_functions, WsFunctionRec::params, ws_error_memory(), ws_free(), ws_function_hash(), ws_realloc(), ws_src_error(), and WS_TRUE.

Referenced by yyparse().

{
    WsFunctionHash *hash;
    WsFunction *f = ws_realloc(compiler->functions,
                               ((compiler->num_functions + 1)
                                * sizeof(WsFunction)));

    if (f == NULL) {
        ws_free(name);
        ws_error_memory(compiler);
        return;
    }

    if (externp)
        compiler->num_extern_functions++;
    else
        compiler->num_local_functions++;

    compiler->functions = f;
    f = &compiler->functions[compiler->num_functions];

    f->findex = compiler->num_functions++;

    f->externp = externp;
    f->name = name;
    f->line = line;
    f->params = params;
    f->block = block;

    /* Update the function name hash. */

    hash = ws_function_hash(compiler, name);
    if (hash == NULL) {
        ws_error_memory(compiler);
        return;
    }

    if (hash->defined) {
        ws_src_error(compiler, line, "redefinition of `%s'", name);
        ws_src_error(compiler,
                     compiler->functions[hash->findex].line,
                     "`%s' previously defined here", name);
        return;
    }

    hash->defined = WS_TRUE;
    hash->findex = f->findex;
}

ws_function_hash()

WsFunctionHash* ws_function_hash	(	WsCompilerPtr	compiler,
		char *	name
	)

Definition at line 318 of file wsstree.c.

References WsCompilerRec::functions_hash, name, ws_calloc(), ws_error_memory(), ws_free(), ws_hash_get(), and ws_hash_put().

Referenced by compile_stream(), ws_expr_linearize(), ws_function(), and yyparse().

{
    WsFunctionHash *i = ws_hash_get(compiler->functions_hash, name);

    if (i)
        return i;

    /* Must create a new mapping. */

    i = ws_calloc(1, sizeof(*i));
    if (i == NULL) {
        ws_error_memory(compiler);
        return NULL;
    }

    if (!ws_hash_put(compiler->functions_hash, name, i)) {
        ws_free(i);
        ws_error_memory(compiler);
        return NULL;
    }

    return i;
}

ws_function_hash_create()

WsHashPtr ws_function_hash_create

(

void

)

Definition at line 312 of file wsstree.c.

References function_hash_destructor(), and ws_hash_create().

Referenced by compile_stream().

{
    return ws_hash_create(function_hash_destructor, NULL);
}

ws_list_append()

void ws_list_append	(	WsCompiler *	compiler,
		WsList *	list,
		void *	value
	)

Definition at line 121 of file wsstree.c.

References WsListItemRec::data, WsListRec::head, WsListItemRec::next, WsListRec::num_items, WsCompilerRec::pool_stree, WsListRec::tail, ws_error_memory(), and ws_f_calloc().

Referenced by yyparse().

{
    WsListItem *item;

    if (list == NULL)
        /* A recovery code for previous memory allocation problems. */
        return;

    item = ws_f_calloc(compiler->pool_stree, 1, sizeof(*item));
    if (item == NULL) {
        ws_error_memory(compiler);
        return;
    }

    item->data = value;

    if (list->tail) {
        list->tail->next = item;
        list->tail = item;
    } else
        list->head = list->tail = item;

    list->num_items++;
}

ws_list_new()

WsList* ws_list_new

(

WsCompiler *

compiler

)

Definition at line 110 of file wsstree.c.

References WsCompilerRec::pool_stree, ws_error_memory(), and ws_f_calloc().

Referenced by yyparse().

{
    WsList *list = ws_f_calloc(compiler->pool_stree, 1, sizeof(*list));

    if (list == NULL)
        ws_error_memory(compiler);

    return list;
}

ws_pragma_meta_body()

WsPragmaMetaBody* ws_pragma_meta_body	(	WsCompilerPtr	compiler,
		WsUtf8String *	property_name,
		WsUtf8String *	content,
		WsUtf8String *	scheme
	)

Definition at line 271 of file wsstree.c.

References content, WsPragmaMetaBodyRec::content, WsPragmaMetaBodyRec::property_name, WsPragmaMetaBodyRec::scheme, ws_calloc(), and ws_error_memory().

Referenced by yyparse().

{
    WsPragmaMetaBody *mb = ws_calloc(1, sizeof(*mb));

    if (mb == NULL) {
        ws_error_memory(compiler);
        return NULL;
    }

    mb->property_name = property_name;
    mb->content = content;
    mb->scheme = scheme;

    return mb;
}

ws_pragma_meta_body_free()

void ws_pragma_meta_body_free	(	WsCompilerPtr	compiler,
		WsPragmaMetaBody *	mb
	)

Definition at line 291 of file wsstree.c.

References WsPragmaMetaBodyRec::content, WsPragmaMetaBodyRec::property_name, WsPragmaMetaBodyRec::scheme, ws_free(), and ws_lexer_free_utf8().

Referenced by yyparse().

{
    if (mb == NULL)
        return;

    ws_lexer_free_utf8(compiler, mb->property_name);
    ws_lexer_free_utf8(compiler, mb->content);
    ws_lexer_free_utf8(compiler, mb->scheme);

    ws_free(mb);
}

ws_pragma_use()

void ws_pragma_use	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		char *	identifier,
		WsUtf8String *	url
	)

Definition at line 220 of file wsstree.c.

References WsCompilerRec::bc, Octstr::data, error(), Octstr::len, WsPragmaUseRec::line, WsCompilerRec::pragma_use_hash, url, WsPragmaUseRec::urlindex, ws_bc_add_const_utf8_string(), ws_calloc(), ws_error_memory(), ws_free(), ws_hash_get(), ws_hash_put(), ws_lexer_free_block(), ws_lexer_free_utf8(), and ws_src_error().

Referenced by yyparse().

{
    WsPragmaUse *u = ws_calloc(1, sizeof(*u));
    WsPragmaUse *uold;

    /* Do we already know this pragma? */
    uold = ws_hash_get(compiler->pragma_use_hash, identifier);
    if (uold) {
        ws_src_error(compiler, line, "redefinition of pragma `%s'", identifier);
        ws_src_error(compiler, uold->line, "`%s' previously defined here",
                     identifier);
        goto error_cleanup;
    }

    if (u == NULL)
        goto error;

    u->line = line;

    /* Insert the URL to the byte-code module. */
    if (!ws_bc_add_const_utf8_string(compiler->bc, &u->urlindex, url->data,
                                     url->len))
        goto error;

    /* Add it to the use pragma hash. */
    if (!ws_hash_put(compiler->pragma_use_hash, identifier, u))
        goto error;

    /* Cleanup. */

    ws_lexer_free_block(compiler, identifier);
    ws_lexer_free_utf8(compiler, url);

    return;

    /* Error handling. */

error:

    ws_error_memory(compiler);

error_cleanup:

    ws_free(u);
    ws_lexer_free_block(compiler, identifier);
    ws_lexer_free_utf8(compiler, url);
}

ws_pragma_use_hash_create()

WsHashPtr ws_pragma_use_hash_create

(

void

)

Definition at line 214 of file wsstree.c.

References pragma_use_hash_destructor(), and ws_hash_create().

Referenced by compile_stream().

{
    return ws_hash_create(pragma_use_hash_destructor, NULL);
}

ws_stmt_block()

WsStatement* ws_stmt_block	(	WsCompiler *	compiler,
		WsUInt32	fline,
		WsUInt32	lline,
		WsList *	block
	)

Definition at line 1389 of file wsstree.c.

References WsStatementRec::block, stmt_alloc(), WsStatementRec::u, and WS_STMT_BLOCK.

Referenced by yyparse().

{
    WsStatement *stmt = stmt_alloc(compiler, WS_STMT_BLOCK, fline, lline);

    if (stmt)
        stmt->u.block = block;

    return stmt;
}

ws_stmt_break()

WsStatement* ws_stmt_break	(	WsCompiler *	compiler,
		WsUInt32	line
	)

Definition at line 1485 of file wsstree.c.

References stmt_alloc(), and WS_STMT_BREAK.

Referenced by yyparse().

{
    return stmt_alloc(compiler, WS_STMT_BREAK, line, line);
}

ws_stmt_continue()

WsStatement* ws_stmt_continue	(	WsCompiler *	compiler,
		WsUInt32	line
	)

Definition at line 1479 of file wsstree.c.

References stmt_alloc(), and WS_STMT_CONTINUE.

Referenced by yyparse().

{
    return stmt_alloc(compiler, WS_STMT_CONTINUE, line, line);
}

ws_stmt_empty()

WsStatement* ws_stmt_empty	(	WsCompiler *	compiler,
		WsUInt32	line
	)

Definition at line 1413 of file wsstree.c.

References stmt_alloc(), and WS_STMT_EMPTY.

Referenced by yyparse().

{
    return stmt_alloc(compiler, WS_STMT_EMPTY, line, line);
}

ws_stmt_expr()

WsStatement* ws_stmt_expr	(	WsCompiler *	compiler,
		WsUInt32	line,
		WsExpression *	expr
	)

Definition at line 1419 of file wsstree.c.

References WsStatementRec::expr, stmt_alloc(), WsStatementRec::u, and WS_STMT_EXPR.

Referenced by yyparse().

{
    WsStatement *stmt = stmt_alloc(compiler, WS_STMT_EXPR, line, line);

    if (stmt)
        stmt->u.expr = expr;

    return stmt;
}

ws_stmt_for()

WsStatement* ws_stmt_for	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsList *	init,
		WsExpression *	e1,
		WsExpression *	e2,
		WsExpression *	e3,
		WsStatement *	stmt_body
	)

Definition at line 1447 of file wsstree.c.

References init, WsStatementRec::s_for, stmt_alloc(), WsStatementRec::u, and WS_STMT_FOR.

Referenced by yyparse().

{
    WsStatement *stmt = stmt_alloc(compiler, WS_STMT_FOR, line, line);

    if (stmt) {
        stmt->u.s_for.init = init;
        stmt->u.s_for.e1 = e1;
        stmt->u.s_for.e2 = e2;
        stmt->u.s_for.e3 = e3;
        stmt->u.s_for.stmt = stmt_body;
    }

    return stmt;
}

ws_stmt_if()

WsStatement* ws_stmt_if	(	WsCompiler *	compiler,
		WsUInt32	line,
		WsExpression *	expr,
		WsStatement *	s_then,
		WsStatement *	s_else
	)

Definition at line 1431 of file wsstree.c.

References WsStatementRec::s_if, stmt_alloc(), WsStatementRec::u, and WS_STMT_IF.

Referenced by yyparse().

{
    WsStatement *stmt = stmt_alloc(compiler, WS_STMT_IF, line, line);

    if (stmt) {
        stmt->u.s_if.expr = expr;
        stmt->u.s_if.s_then = s_then;
        stmt->u.s_if.s_else = s_else;
    }

    return stmt;
}

ws_stmt_linearize()

void ws_stmt_linearize	(	WsCompiler *	compiler,
		WsStatement *	stmt
	)

Definition at line 1157 of file wsstree.c.

References WsStatementRec::block, WsCompilerRec::cont_break, WsListItemRec::data, WsStatementRec::expr, WsStatementRec::first_line, WsListRec::head, WsContBreakRec::l_break, WsContBreakRec::l_cont, WsStatementRec::last_line, linearize_variable_init(), WsListItemRec::next, WsContBreakRec::next, WsCompilerRec::pool_stree, WsStatementRec::s_for, WsStatementRec::s_if, WsStatementRec::s_while, WsStatementRec::type, WsStatementRec::u, WsStatementRec::var, ws_asm_branch(), ws_asm_ins(), ws_asm_label(), ws_asm_link(), WS_ASM_P_JUMP, WS_ASM_P_TJUMP, WS_ASM_POP, WS_ASM_RETURN, WS_ASM_RETURN_ES, ws_error_memory(), ws_expr_linearize(), ws_f_calloc(), ws_src_error(), WS_STMT_BLOCK, WS_STMT_BREAK, WS_STMT_CONTINUE, WS_STMT_EMPTY, WS_STMT_EXPR, WS_STMT_FOR, WS_STMT_IF, WS_STMT_RETURN, WS_STMT_VARIABLE, and WS_STMT_WHILE.

Referenced by compile_stream().

{
    WsListItem *li;
    WsAsmIns *ins;

    switch (stmt->type) {
    case WS_STMT_BLOCK:
        for (li = stmt->u.block->head; li; li = li->next)
            ws_stmt_linearize(compiler, li->data);
        break;

    case WS_STMT_VARIABLE:
        linearize_variable_init(compiler, stmt->u.var, stmt->first_line);
        break;

    case WS_STMT_EMPTY:
        /* Nothing here. */
        break;

    case WS_STMT_EXPR:
        ws_expr_linearize(compiler, stmt->u.expr);

        /* Pop the expressions result from the stack.  Otherwise loops
           could eventually cause stack overflows. */
        ws_asm_link(compiler, ws_asm_ins(compiler, stmt->last_line, WS_ASM_POP));
        break;

    case WS_STMT_IF:
        {
            WsAsmIns *l_else = ws_asm_label(compiler,
                                            (stmt->u.s_if.s_else
                                             ? stmt->u.s_if.s_else->first_line
                                             : stmt->last_line));
            WsAsmIns *l_end = ws_asm_label(compiler, stmt->last_line);

            /* Linearize the expression. */
            ws_expr_linearize(compiler, stmt->u.s_if.expr);

            /* If the result is false, jump to the else-branch. */
            ws_asm_link(compiler, ws_asm_branch(compiler, stmt->first_line,
                                                WS_ASM_P_TJUMP, l_else));

            /* Else, execute the then-branch and jump to the end. */
            ws_stmt_linearize(compiler, stmt->u.s_if.s_then);
            ws_asm_link(compiler, ws_asm_branch(compiler, stmt->last_line,
                                                WS_ASM_P_JUMP, l_end));

            /* Then else-branch. */
            ws_asm_link(compiler, l_else);

            /* Linearize the else-branch if it is present. */
            if (stmt->u.s_if.s_else)
                ws_stmt_linearize(compiler, stmt->u.s_if.s_else);

            /* Insert the end label. */
            ws_asm_link(compiler, l_end);
        }
        break;

    case WS_STMT_FOR:
        {
            WsAsmIns *l_loop = ws_asm_label(compiler, stmt->first_line);
            WsAsmIns *l_cont = ws_asm_label(compiler, stmt->first_line);
            WsAsmIns *l_break = ws_asm_label(compiler, stmt->first_line);
            WsContBreak *cb;

            /* Store the labels to the compiler. */

            cb = ws_f_calloc(compiler->pool_stree, 1, sizeof(*cb));
            if (cb == NULL) {
                ws_error_memory(compiler);
                return;
            }

            cb->next = compiler->cont_break;
            compiler->cont_break = cb;

            cb->l_cont = l_cont;
            cb->l_break = l_break;

            /* Linearize the possible init code. */
            if (stmt->u.s_for.init)
                linearize_variable_init(compiler, stmt->u.s_for.init,
                                        stmt->first_line);
            else if (stmt->u.s_for.e1) {
                /* Linearize the init. */
                ws_expr_linearize(compiler, stmt->u.s_for.e1);

                /* Pop the result. */
                ws_asm_link(compiler, ws_asm_ins(compiler, stmt->first_line,
                                                 WS_ASM_POP));
            }

            /* Insert the loop label. */
            ws_asm_link(compiler, l_loop);

            /* Linearize the condition. */
            if (stmt->u.s_for.e2) {
                ws_expr_linearize(compiler, stmt->u.s_for.e2);

                /* If false, jump out. */
                ws_asm_link(compiler, ws_asm_branch(compiler, stmt->first_line,
                                                    WS_ASM_P_TJUMP, l_break));
            }

            /* Linearize the body statement. */
            ws_stmt_linearize(compiler, stmt->u.s_for.stmt);

            /* Link the continue label. */
            ws_asm_link(compiler, l_cont);

            /* Linearize the update expression. */
            if (stmt->u.s_for.e3) {
                ws_expr_linearize(compiler, stmt->u.s_for.e3);

                /* Pop the result. */
                ws_asm_link(compiler, ws_asm_ins(compiler, stmt->first_line,
                                                 WS_ASM_POP));
            }

            /* Jump to the loop label to check the condition. */
            ws_asm_link(compiler, ws_asm_branch(compiler, stmt->last_line,
                                                WS_ASM_P_JUMP, l_loop));

            /* Insert the break label. */
            ws_asm_link(compiler, l_break);

            /* Pop the cont-break block. */
            compiler->cont_break = compiler->cont_break->next;
        }
        break;

    case WS_STMT_WHILE:
        {
            WsAsmIns *l_cont = ws_asm_label(compiler, stmt->first_line);
            WsAsmIns *l_break = ws_asm_label(compiler,
                                             stmt->u.s_while.stmt->last_line);
            WsContBreak *cb;

            /* Store the labels to the compiler. */

            cb = ws_f_calloc(compiler->pool_stree, 1, sizeof(*cb));
            if (cb == NULL) {
                ws_error_memory(compiler);
                return;
            }

            cb->next = compiler->cont_break;
            compiler->cont_break = cb;

            cb->l_cont = l_cont;
            cb->l_break = l_break;

            /* Insert the continue label. */
            ws_asm_link(compiler, l_cont);

            /* Linearize the expression. */
            ws_expr_linearize(compiler, stmt->u.s_while.expr);

            /* If false, jump out. */
            ws_asm_link(compiler, ws_asm_branch(compiler, stmt->first_line,
                                                WS_ASM_P_TJUMP, l_break));

            /* Linearize the body statement. */
            ws_stmt_linearize(compiler, stmt->u.s_while.stmt);

            /* And jump to the continue label to check the expression. */
            ws_asm_link(compiler, ws_asm_branch(compiler, stmt->last_line,
                                                WS_ASM_P_JUMP, l_cont));

            /* Insert the break label. */
            ws_asm_link(compiler, l_break);

            /* Pop the cont-break block. */
            compiler->cont_break = compiler->cont_break->next;
        }
        break;

    case WS_STMT_CONTINUE:
        if (compiler->cont_break == NULL)
            ws_src_error(compiler, stmt->first_line,
                         "continue statement not within a loop");

        ws_asm_link(compiler, ws_asm_branch(compiler, stmt->first_line,
                                            WS_ASM_P_JUMP,
                                            compiler->cont_break->l_cont));
        break;

    case WS_STMT_BREAK:
        if (compiler->cont_break == NULL)
            ws_src_error(compiler, stmt->first_line,
                         "break statement not within a loop");

        ws_asm_link(compiler, ws_asm_branch(compiler, stmt->first_line,
                                            WS_ASM_P_JUMP,
                                            compiler->cont_break->l_break));
        break;

    case WS_STMT_RETURN:
        if (stmt->u.expr) {
            /* Linearize the return value and return it. */
            ws_expr_linearize(compiler, stmt->u.expr);
            ins = ws_asm_ins(compiler, stmt->first_line, WS_ASM_RETURN);
        } else
            /* Return an empty string. */
            ins = ws_asm_ins(compiler, stmt->first_line, WS_ASM_RETURN_ES);

        ws_asm_link(compiler, ins);
        break;
    }
}

ws_stmt_return()

WsStatement* ws_stmt_return	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsExpression *	expr
	)

Definition at line 1491 of file wsstree.c.

References WsStatementRec::expr, stmt_alloc(), WsStatementRec::u, and WS_STMT_RETURN.

Referenced by yyparse().

{
    WsStatement *stmt = stmt_alloc(compiler, WS_STMT_RETURN, line, line);

    if (stmt)
        stmt->u.expr = expr;

    return stmt;
}

ws_stmt_variable()

WsStatement* ws_stmt_variable	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsList *	variables
	)

Definition at line 1401 of file wsstree.c.

References stmt_alloc(), WsStatementRec::u, WsStatementRec::var, and WS_STMT_VARIABLE.

Referenced by yyparse().

{
    WsStatement *stmt = stmt_alloc(compiler, WS_STMT_VARIABLE, line, line);

    if (stmt)
        stmt->u.var = variables;

    return stmt;
}

ws_stmt_while()

WsStatement* ws_stmt_while	(	WsCompiler *	compiler,
		WsUInt32	line,
		WsExpression *	expr,
		WsStatement *	stmt_arg
	)

Definition at line 1465 of file wsstree.c.

References WsStatementRec::s_while, stmt_alloc(), WsStatementRec::u, and WS_STMT_WHILE.

Referenced by yyparse().

{
    WsStatement *stmt = stmt_alloc(compiler, WS_STMT_WHILE, line, line);

    if (stmt) {
        stmt->u.s_while.expr = expr;
        stmt->u.s_while.stmt = stmt_arg;
    }

    return stmt;
}

ws_variable_declaration()

WsVarDec* ws_variable_declaration	(	WsCompilerPtr	compiler,
		char *	name,
		WsExpression *	expr
	)

Definition at line 78 of file wsstree.c.

References WsVarDecRec::expr, name, WsVarDecRec::name, WsCompilerRec::pool_stree, ws_error_memory(), and ws_f_malloc().

Referenced by yyparse().

{
    WsVarDec *vardec = ws_f_malloc(compiler->pool_stree, sizeof(*vardec));

    if (vardec == NULL)
        ws_error_memory(compiler);
    else {
        vardec->name = name;
        vardec->expr = expr;
    }

    return vardec;
}

ws_variable_define()

WsNamespace* ws_variable_define	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsBool	variablep,
		char *	name
	)

Definition at line 160 of file wsstree.c.

References WsNamespaceRec::line, name, WsCompilerRec::next_vindex, WsCompilerRec::variables_hash, WsNamespaceRec::vindex, ws_calloc(), ws_error_memory(), ws_free(), ws_hash_get(), ws_hash_put(), and ws_src_error().

Referenced by compile_stream(), and linearize_variable_init().

{
    WsNamespace *ns;

    /* Is the symbol already defined? */
    ns = ws_hash_get(compiler->variables_hash, name);
    if (ns) {
        ws_src_error(compiler, line, "redeclaration of `%s'", name);
        ws_src_error(compiler, ns->line, "`%s' previously declared here", name);
        return NULL;
    }

    /* Can we still define more variables? */
    if (compiler->next_vindex > 255) {
        /* No we can't. */
        ws_src_error(compiler, line, "too many local variables");
        return NULL;
    }

    ns = ws_calloc(1, sizeof(*ns));
    if (ns == NULL) {
        ws_error_memory(compiler);
        return NULL;
    }

    ns->line = line;
    ns->vindex = compiler->next_vindex++;

    if (!ws_hash_put(compiler->variables_hash, name, ns)) {
        ws_free(ns);
        ws_error_memory(compiler);
        return NULL;
    }

    return ns;
}

ws_variable_hash_create()

WsHashPtr ws_variable_hash_create

(

void

)

Definition at line 154 of file wsstree.c.

References variable_hash_destructor(), and ws_hash_create().

Referenced by compile_stream().

{
    return ws_hash_create(variable_hash_destructor, NULL);
}

ws_variable_lookup()

WsNamespace* ws_variable_lookup	(	WsCompilerPtr	compiler,
		char *	name
	)

Definition at line 199 of file wsstree.c.

References name, WsCompilerRec::variables_hash, and ws_hash_get().

Referenced by ws_expr_linearize().

{
    return ws_hash_get(compiler->variables_hash, name);
}