wsstree.h File Reference

Go to the source code of this file.

Data Structures
struct	WsListItemRec
struct	WsListRec
struct	WsNamespaceRec
struct	WsPragmaUseRec
struct	WsPragmaMetaBodyRec
struct	WsFunctionRec
struct	WsFunctionHashRec
struct	WsExpressionRec
struct	WsVarDecRec
struct	WsFormalParmRec
struct	WsStatementRec

Typedefs
typedef struct WsListItemRec	WsListItem
typedef struct WsListRec	WsList
typedef struct WsNamespaceRec	WsNamespace
typedef struct WsPragmaUseRec	WsPragmaUse
typedef struct WsPragmaMetaBodyRec	WsPragmaMetaBody
typedef struct WsFunctionRec	WsFunction
typedef struct WsFunctionHashRec	WsFunctionHash
typedef struct WsExpressionRec	WsExpression
typedef struct WsVarDecRec	WsVarDec
typedef struct WsFormalParmRec	WsFormalParm
typedef struct WsStatementRec	WsStatement

Enumerations
enum	WsExpressionType {   WS_EXPR_COMMA, WS_EXPR_ASSIGN, WS_EXPR_CONDITIONAL, WS_EXPR_LOGICAL,   WS_EXPR_BINARY, WS_EXPR_UNARY, WS_EXPR_UNARY_VAR, WS_EXPR_POSTFIX_VAR,   WS_EXPR_CALL, WS_EXPR_SYMBOL, WS_EXPR_CONST_INVALID, WS_EXPR_CONST_TRUE,   WS_EXPR_CONST_FALSE, WS_EXPR_CONST_INTEGER, WS_EXPR_CONST_FLOAT, WS_EXPR_CONST_STRING }
enum	WsStatementType {   WS_STMT_BLOCK, WS_STMT_VARIABLE, WS_STMT_EMPTY, WS_STMT_EXPR,   WS_STMT_IF, WS_STMT_FOR, WS_STMT_WHILE, WS_STMT_CONTINUE,   WS_STMT_BREAK, WS_STMT_RETURN }

Functions
WsList *	ws_list_new (WsCompilerPtr compiler)
void	ws_list_append (WsCompilerPtr compiler, WsList *list, void *value)
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)
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)
WsHashPtr	ws_function_hash_create (void)
WsFunctionHash *	ws_function_hash (WsCompilerPtr compiler, char *name)
void	ws_function (WsCompilerPtr compiler, WsBool externp, char *name, WsUInt32 line, WsList *params, WsList *block)
void	ws_expr_linearize (WsCompilerPtr compiler, WsExpression *expr)
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 *expr)
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 (WsCompilerPtr compiler, WsUInt32 linenum, int type, char *base, char *name, WsList *arguments)
WsExpression *	ws_expr_symbol (WsCompilerPtr compiler, WsUInt32 linenum, char *identifier)
WsExpression *	ws_expr_const_invalid (WsCompilerPtr compiler, WsUInt32 linenum)
WsExpression *	ws_expr_const_true (WsCompilerPtr compiler, WsUInt32 linenum)
WsExpression *	ws_expr_const_false (WsCompilerPtr compiler, WsUInt32 linenum)
WsExpression *	ws_expr_const_integer (WsCompilerPtr compiler, WsUInt32 linenum, WsUInt32 ival)
WsExpression *	ws_expr_const_float (WsCompilerPtr compiler, WsUInt32 linenum, WsFloat fval)
WsExpression *	ws_expr_const_string (WsCompilerPtr compiler, WsUInt32 linenum, WsUtf8String *string)
WsVarDec *	ws_variable_declaration (WsCompilerPtr compiler, char *name, WsExpression *expr)
WsFormalParm *	ws_formal_parameter (WsCompilerPtr compiler, WsUInt32 line, char *name)
void	ws_stmt_linearize (WsCompilerPtr compiler, WsStatement *stmt)
WsStatement *	ws_stmt_block (WsCompilerPtr compiler, WsUInt32 first_line, WsUInt32 last_line, WsList *block)
WsStatement *	ws_stmt_variable (WsCompilerPtr compiler, WsUInt32 line, WsList *variables)
WsStatement *	ws_stmt_empty (WsCompilerPtr compiler, WsUInt32 line)
WsStatement *	ws_stmt_expr (WsCompilerPtr compiler, WsUInt32 line, WsExpression *expr)
WsStatement *	ws_stmt_if (WsCompilerPtr 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)
WsStatement *	ws_stmt_while (WsCompilerPtr compiler, WsUInt32 line, WsExpression *expr, WsStatement *stmt)
WsStatement *	ws_stmt_continue (WsCompilerPtr compiler, WsUInt32 line)
WsStatement *	ws_stmt_break (WsCompilerPtr compiler, WsUInt32 line)
WsStatement *	ws_stmt_return (WsCompilerPtr compiler, WsUInt32 line, WsExpression *expr)

Typedef Documentation

WsExpression

typedef struct WsExpressionRec WsExpression

Definition at line 389 of file wsstree.h.

WsFormalParm

typedef struct WsFormalParmRec WsFormalParm

Definition at line 496 of file wsstree.h.

WsFunction

typedef struct WsFunctionRec WsFunction

Definition at line 209 of file wsstree.h.

WsFunctionHash

typedef struct WsFunctionHashRec WsFunctionHash

Definition at line 225 of file wsstree.h.

WsList

typedef struct WsListRec WsList

Definition at line 99 of file wsstree.h.

WsListItem

typedef struct WsListItemRec WsListItem

Definition at line 83 of file wsstree.h.

WsNamespace

typedef struct WsNamespaceRec WsNamespace

Definition at line 122 of file wsstree.h.

WsPragmaMetaBody

typedef struct WsPragmaMetaBodyRec WsPragmaMetaBody

Definition at line 181 of file wsstree.h.

WsPragmaUse

typedef struct WsPragmaUseRec WsPragmaUse

Definition at line 156 of file wsstree.h.

WsStatement

typedef struct WsStatementRec WsStatement

Definition at line 560 of file wsstree.h.

WsVarDec

typedef struct WsVarDecRec WsVarDec

Definition at line 483 of file wsstree.h.

Enumeration Type Documentation

WsExpressionType

enum WsExpressionType

Enumerator
WS_EXPR_COMMA
WS_EXPR_ASSIGN
WS_EXPR_CONDITIONAL
WS_EXPR_LOGICAL
WS_EXPR_BINARY
WS_EXPR_UNARY
WS_EXPR_UNARY_VAR
WS_EXPR_POSTFIX_VAR
WS_EXPR_CALL
WS_EXPR_SYMBOL
WS_EXPR_CONST_INVALID
WS_EXPR_CONST_TRUE
WS_EXPR_CONST_FALSE
WS_EXPR_CONST_INTEGER
WS_EXPR_CONST_FLOAT
WS_EXPR_CONST_STRING

Definition at line 251 of file wsstree.h.

{
    WS_EXPR_COMMA,
    WS_EXPR_ASSIGN,
    WS_EXPR_CONDITIONAL,
    WS_EXPR_LOGICAL,
    WS_EXPR_BINARY,
    WS_EXPR_UNARY,
    WS_EXPR_UNARY_VAR,
    WS_EXPR_POSTFIX_VAR,
    WS_EXPR_CALL,
    WS_EXPR_SYMBOL,
    WS_EXPR_CONST_INVALID,
    WS_EXPR_CONST_TRUE,
    WS_EXPR_CONST_FALSE,
    WS_EXPR_CONST_INTEGER,
    WS_EXPR_CONST_FLOAT,
    WS_EXPR_CONST_STRING
} WsExpressionType;

WsStatementType

enum WsStatementType

Enumerator
WS_STMT_BLOCK
WS_STMT_VARIABLE
WS_STMT_EMPTY
WS_STMT_EXPR
WS_STMT_IF
WS_STMT_FOR
WS_STMT_WHILE
WS_STMT_CONTINUE
WS_STMT_BREAK
WS_STMT_RETURN

Definition at line 506 of file wsstree.h.

{
    WS_STMT_BLOCK,
    WS_STMT_VARIABLE,
    WS_STMT_EMPTY,
    WS_STMT_EXPR,
    WS_STMT_IF,
    WS_STMT_FOR,
    WS_STMT_WHILE,
    WS_STMT_CONTINUE,
    WS_STMT_BREAK,
    WS_STMT_RETURN
} WsStatementType;

Function Documentation

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	(	WsCompilerPtr	compiler,
		WsUInt32	linenum,
		int	type,
		char *	base,
		char *	name,
		WsList *	arguments
	)

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	(	WsCompilerPtr	compiler,
		WsUInt32	linenum
	)

ws_expr_const_float()

WsExpression* ws_expr_const_float	(	WsCompilerPtr	compiler,
		WsUInt32	linenum,
		WsFloat	fval
	)

ws_expr_const_integer()

WsExpression* ws_expr_const_integer	(	WsCompilerPtr	compiler,
		WsUInt32	linenum,
		WsUInt32	ival
	)

ws_expr_const_invalid()

WsExpression* ws_expr_const_invalid	(	WsCompilerPtr	compiler,
		WsUInt32	linenum
	)

ws_expr_const_string()

WsExpression* ws_expr_const_string	(	WsCompilerPtr	compiler,
		WsUInt32	linenum,
		WsUtf8String *	string
	)

ws_expr_const_true()

WsExpression* ws_expr_const_true	(	WsCompilerPtr	compiler,
		WsUInt32	linenum
	)

ws_expr_linearize()

void ws_expr_linearize	(	WsCompilerPtr	compiler,
		WsExpression *	expr
	)

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	(	WsCompilerPtr	compiler,
		WsUInt32	linenum,
		char *	identifier
	)

ws_expr_unary()

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

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	(	WsCompilerPtr	compiler,
		WsBool	externp,
		char *	name,
		WsUInt32	line,
		WsList *	params,
		WsList *	block
	)

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	(	WsCompilerPtr	compiler,
		WsList *	list,
		void *	value
	)

ws_list_new()

WsList* ws_list_new

(

WsCompilerPtr

compiler

)

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	(	WsCompilerPtr	compiler,
		WsUInt32	first_line,
		WsUInt32	last_line,
		WsList *	block
	)

ws_stmt_break()

WsStatement* ws_stmt_break	(	WsCompilerPtr	compiler,
		WsUInt32	line
	)

ws_stmt_continue()

WsStatement* ws_stmt_continue	(	WsCompilerPtr	compiler,
		WsUInt32	line
	)

ws_stmt_empty()

WsStatement* ws_stmt_empty	(	WsCompilerPtr	compiler,
		WsUInt32	line
	)

ws_stmt_expr()

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

ws_stmt_for()

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

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	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsExpression *	expr,
		WsStatement *	s_then,
		WsStatement *	s_else
	)

ws_stmt_linearize()

void ws_stmt_linearize	(	WsCompilerPtr	compiler,
		WsStatement *	stmt
	)

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	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		WsExpression *	expr,
		WsStatement *	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);
}