root/crowbar.h

INCLUDED FROM

DEFINITIONS

1. PARSE_ERR
2. CHARACTER_INVALID_ERR
3. FUNCTION_MULTIPLE_DEFINE_ERR
4. COMPILE_ERROR_COUNT_PLUS_1
5. CompileError
6. VARIABLE_NOT_FOUND_ERR
7. ARGUMENT_TOO_MANY_ERR
8. ARGUMENT_TOO_FEW_ERR
9. NOT_BOOLEAN_TYPE_ERR
10. MINUS_OPERAND_TYPE_ERR
11. STRING_OPERATOR_ERR
12. BAD_OPERAND_TYPE_ERR
13. LOGICAL_OP_DOUBLE_OPERAND_ERR
14. LOGICAL_OP_INTEGER_OPERAND_ERR
15. NOT_BOOLEAN_OPERATOR_ERR
16. NOT_NULL_OPERATOR_ERR
17. NOT_LVALUE_ERR
18. INDEX_OPERAND_NOT_ARRAY_ERR
19. INDEX_OPERAND_NOT_INT_ERR
20. ARRAY_INDEX_OUT_OF_BOUNDS_ERR
21. NO_SUCH_METHOD_ERR
22. INC_DEC_OPERAND_TYPE_ERR
23. INC_DEC_OPERAND_NOT_EXIST_ERR
24. NOT_FUNCTION_ERR
25. NOT_OBJECT_MEMBER_UPDATE_ERR
26. NOT_OBJECT_MEMBER_ASSIGN_ERR
27. NO_SUCH_MEMBER_ERR
28. NO_MEMBER_TYPE_ERR
29. BAD_OPERATOR_FOR_STRING_ERR
30. DIVISION_BY_ZERO_ERR
31. GLOBAL_VARIABLE_NOT_FOUND_ERR
32. GLOBAL_STATEMENT_IN_TOPLEVEL_ERR
33. FUNCTION_EXISTS_ERR
34. ARRAY_RESIZE_ARGUMENT_ERR
35. ARRAY_INSERT_ARGUMENT_ERR
36. ARRAY_REMOVE_ARGUMENT_ERR
37. STRING_POS_OUT_OF_BOUNDS_ERR
38. STRING_SUBSTR_LEN_ERR
39. STRING_SUBSTR_ARGUMENT_ERR
40. EXCEPTION_HAS_NO_STACK_TRACE_ERR
41. STACK_TRACE_IS_NOT_ARRAY_ERR
42. RUNTIME_ERROR_COUNT_PLUS_1
43. RuntimeError
44. MessageFormat
45. BOOLEAN_EXPRESSION
46. INT_EXPRESSION
47. DOUBLE_EXPRESSION
48. STRING_EXPRESSION
49. IDENTIFIER_EXPRESSION
50. COMMA_EXPRESSION
51. ASSIGN_EXPRESSION
52. ADD_EXPRESSION
53. SUB_EXPRESSION
54. MUL_EXPRESSION
55. DIV_EXPRESSION
56. MOD_EXPRESSION
57. EQ_EXPRESSION
58. NE_EXPRESSION
59. GT_EXPRESSION
60. GE_EXPRESSION
61. LT_EXPRESSION
62. LE_EXPRESSION
63. LOGICAL_AND_EXPRESSION
64. LOGICAL_OR_EXPRESSION
65. MINUS_EXPRESSION
66. LOGICAL_NOT_EXPRESSION
67. FUNCTION_CALL_EXPRESSION
68. MEMBER_EXPRESSION
69. NULL_EXPRESSION
70. ARRAY_EXPRESSION
71. INDEX_EXPRESSION
72. INCREMENT_EXPRESSION
73. DECREMENT_EXPRESSION
74. CLOSURE_EXPRESSION
75. EXPRESSION_TYPE_COUNT_PLUS_1
76. ExpressionType
77. CommaExpression
78. NORMAL_ASSIGN
79. ADD_ASSIGN
80. SUB_ASSIGN
81. MUL_ASSIGN
82. DIV_ASSIGN
83. MOD_ASSIGN
84. AssignmentOperator
85. AssignExpression
86. BinaryExpression
87. FunctionCallExpression
88. ExpressionList
89. IndexExpression
90. MemberExpression
91. IncrementOrDecrement
92. ClosureExpression
93. StatementList
94. Block
95. IdentifierList
96. GlobalStatement
97. Elsif
98. IfStatement
99. WhileStatement
100. ForStatement
101. ReturnStatement
102. TryStatement
103. EXPRESSION_STATEMENT
104. GLOBAL_STATEMENT
105. IF_STATEMENT
106. WHILE_STATEMENT
107. FOR_STATEMENT
108. RETURN_STATEMENT
109. BREAK_STATEMENT
110. CONTINUE_STATEMENT
111. TRY_STATEMENT
112. STATEMENT_TYPE_COUNT_PLUS_1
113. StatementType
114. ParameterList
115. CROWBAR_FUNCTION_DEFINITION
116. NATIVE_FUNCTION_DEFINITION
117. FUNCTION_DEFINITION_TYPE_COUNT_PLUS_1
118. FunctionDefinitionType
119. Variable
120. NORMAL_STATEMENT_RESULT
121. RETURN_STATEMENT_RESULT
122. BREAK_STATEMENT_RESULT
123. CONTINUE_STATEMENT_RESULT
124. STATEMENT_RESULT_TYPE_COUNT_PLUS_1
125. StatementResultType
126. StatementResult
127. GlobalVariableRef
128. Stack
129. Heap
130. RecoveryEnvironment
131. AssocMember
132. ScopeChain
133. NativePointer
134. ARRAY_OBJECT
135. STRING_OBJECT
136. ASSOC_OBJECT
137. SCOPE_CHAIN_OBJECT
138. NATIVE_POINTER_OBJECT
139. OBJECT_TYPE_COUNT_PLUS_1
140. ObjectType
141. VString

#ifndef PRIVATE_CROWBAR_H_INCLUDED
#define PRIVATE_CROWBAR_H_INCLUDED
#include <stdio.h>
#include <setjmp.h>
#include "MEM.h"
#include "CRB.h"
#include "CRB_dev.h"

#define smaller(a, b) ((a) < (b) ? (a) : (b))
#define larger(a, b) ((a) > (b) ? (a) : (b))

#define MESSAGE_ARGUMENT_MAX    (256)
#define LINE_BUF_SIZE           (1024)
#define STACK_ALLOC_SIZE        (256)
#define ARRAY_ALLOC_SIZE        (256)
#define HEAP_THRESHOLD_SIZE     (1024 * 256)
#define LONGJMP_ARG             (1)

#define EXCEPTION_MEMBER_MESSAGE        ("message")
#define EXCEPTION_MEMBER_STACK_TRACE    ("stack_trace")
#define EXCEPTION_MEMBER_LINE_NUMBER    ("line_number")
#define EXCEPTION_MEMBER_FUNCTION_NAME  ("function_name")

#define ARRAY_SIZE(array)  (sizeof(array) / sizeof((array)[0]))

typedef enum {
    PARSE_ERR = 1,
    CHARACTER_INVALID_ERR,
    FUNCTION_MULTIPLE_DEFINE_ERR,
    COMPILE_ERROR_COUNT_PLUS_1
} CompileError;

typedef enum {
    VARIABLE_NOT_FOUND_ERR = 1,
    ARGUMENT_TOO_MANY_ERR,
    ARGUMENT_TOO_FEW_ERR,
    NOT_BOOLEAN_TYPE_ERR,
    MINUS_OPERAND_TYPE_ERR,
    STRING_OPERATOR_ERR,
    BAD_OPERAND_TYPE_ERR,
    LOGICAL_OP_DOUBLE_OPERAND_ERR,
    LOGICAL_OP_INTEGER_OPERAND_ERR,
    NOT_BOOLEAN_OPERATOR_ERR,
    NOT_NULL_OPERATOR_ERR,
    NOT_LVALUE_ERR,
    INDEX_OPERAND_NOT_ARRAY_ERR,
    INDEX_OPERAND_NOT_INT_ERR,
    ARRAY_INDEX_OUT_OF_BOUNDS_ERR,
    NO_SUCH_METHOD_ERR,
    INC_DEC_OPERAND_TYPE_ERR,
    INC_DEC_OPERAND_NOT_EXIST_ERR,
    NOT_FUNCTION_ERR,
    NOT_OBJECT_MEMBER_UPDATE_ERR,
    NOT_OBJECT_MEMBER_ASSIGN_ERR,
    NO_SUCH_MEMBER_ERR,
    NO_MEMBER_TYPE_ERR,
    BAD_OPERATOR_FOR_STRING_ERR,
    DIVISION_BY_ZERO_ERR,
    GLOBAL_VARIABLE_NOT_FOUND_ERR,
    GLOBAL_STATEMENT_IN_TOPLEVEL_ERR,
    FUNCTION_EXISTS_ERR,
    ARRAY_RESIZE_ARGUMENT_ERR,
    ARRAY_INSERT_ARGUMENT_ERR,
    ARRAY_REMOVE_ARGUMENT_ERR,
    STRING_POS_OUT_OF_BOUNDS_ERR,
    STRING_SUBSTR_LEN_ERR,
    STRING_SUBSTR_ARGUMENT_ERR,
    EXCEPTION_HAS_NO_STACK_TRACE_ERR,
    STACK_TRACE_IS_NOT_ARRAY_ERR,
    RUNTIME_ERROR_COUNT_PLUS_1
} RuntimeError;


typedef struct {
    char *format;
} MessageFormat;

typedef struct Expression_tag Expression;

typedef enum {
    BOOLEAN_EXPRESSION = 1,
    INT_EXPRESSION,
    DOUBLE_EXPRESSION,
    STRING_EXPRESSION,
    IDENTIFIER_EXPRESSION,
    COMMA_EXPRESSION,
    ASSIGN_EXPRESSION,
    ADD_EXPRESSION,
    SUB_EXPRESSION,
    MUL_EXPRESSION,
    DIV_EXPRESSION,
    MOD_EXPRESSION,
    EQ_EXPRESSION,
    NE_EXPRESSION,
    GT_EXPRESSION,
    GE_EXPRESSION,
    LT_EXPRESSION,
    LE_EXPRESSION,
    LOGICAL_AND_EXPRESSION,
    LOGICAL_OR_EXPRESSION,
    MINUS_EXPRESSION,
    LOGICAL_NOT_EXPRESSION,
    FUNCTION_CALL_EXPRESSION,
    MEMBER_EXPRESSION,
    NULL_EXPRESSION,
    ARRAY_EXPRESSION,
    INDEX_EXPRESSION,
    INCREMENT_EXPRESSION,
    DECREMENT_EXPRESSION,
    CLOSURE_EXPRESSION,
    EXPRESSION_TYPE_COUNT_PLUS_1
} ExpressionType;

#define crb_is_numeric_type(type)\
  ((type) == CRB_INT_VALUE || (type) == CRB_DOUBLE_VALUE)
#define crb_is_math_operator(operator) \
  ((operator) == ADD_EXPRESSION || (operator) == SUB_EXPRESSION\
   || (operator) == MUL_EXPRESSION || (operator) == DIV_EXPRESSION\
   || (operator) == MOD_EXPRESSION)

#define crb_is_compare_operator(operator) \
  ((operator) == EQ_EXPRESSION || (operator) == NE_EXPRESSION\
   || (operator) == GT_EXPRESSION || (operator) == GE_EXPRESSION\
   || (operator) == LT_EXPRESSION || (operator) == LE_EXPRESSION)

#define crb_is_logical_operator(operator) \
  ((operator) == LOGICAL_AND_EXPRESSION || (operator) == LOGICAL_OR_EXPRESSION)

typedef struct ArgumentList_tag {
    Expression *expression;
    struct ArgumentList_tag *next;
} ArgumentList;

typedef struct {
    Expression  *left;
    Expression  *right;
} CommaExpression;

typedef enum {
    NORMAL_ASSIGN = 1,
    ADD_ASSIGN,
    SUB_ASSIGN,
    MUL_ASSIGN,
    DIV_ASSIGN,
    MOD_ASSIGN,
} AssignmentOperator;

typedef struct {
    AssignmentOperator  operator;
    Expression  *left;
    Expression  *operand;
} AssignExpression;

typedef struct {
    Expression  *left;
    Expression  *right;
} BinaryExpression;

typedef struct {
    Expression          *function;
    ArgumentList        *argument;
} FunctionCallExpression;

typedef struct ExpressionList_tag {
    Expression          *expression;
    struct ExpressionList_tag   *next;
} ExpressionList;

typedef struct {
    Expression  *array;
    Expression  *index;
} IndexExpression;

typedef struct {
    Expression          *expression;
    char                *member_name;
} MemberExpression;

typedef struct {
    Expression  *operand;
} IncrementOrDecrement;

typedef struct {
    CRB_FunctionDefinition *function_definition;
} ClosureExpression;

struct Expression_tag {
    ExpressionType type;
    int line_number;
    union {
        CRB_Boolean             boolean_value;
        int                     int_value;
        double                  double_value;
        char                    *string_value;
        char                    *identifier;
        CommaExpression         comma;
        AssignExpression        assign_expression;
        BinaryExpression        binary_expression;
        Expression              *minus_expression;
        Expression              *logical_not;
        FunctionCallExpression  function_call_expression;
        MemberExpression        member_expression;
        ExpressionList          *array_literal;
        IndexExpression         index_expression;
        IncrementOrDecrement    inc_dec;
        ClosureExpression       closure;
    } u;
};

typedef struct Statement_tag Statement;

typedef struct StatementList_tag {
    Statement   *statement;
    struct StatementList_tag    *next;
} StatementList;

typedef struct {
    StatementList       *statement_list;
} Block;

typedef struct IdentifierList_tag {
    char        *name;
    struct IdentifierList_tag   *next;
} IdentifierList;

typedef struct {
    IdentifierList      *identifier_list;
} GlobalStatement;

typedef struct Elsif_tag {
    Expression  *condition;
    Block       *block;
    struct Elsif_tag    *next;
} Elsif;

typedef struct {
    Expression  *condition;
    Block       *then_block;
    Elsif       *elsif_list;
    Block       *else_block;
} IfStatement;

typedef struct {
    Expression  *condition;
    Block       *block;
} WhileStatement;

typedef struct {
    Expression  *init;
    Expression  *condition;
    Expression  *post;
    Block       *block;
} ForStatement;

typedef struct {
    Expression *return_value;
} ReturnStatement;

typedef struct {
    Block       *try_block;
    Block       *catch_block;
    char        *exception;
    Block       *finally_block;
} TryStatement;

typedef enum {
    EXPRESSION_STATEMENT = 1,
    GLOBAL_STATEMENT,
    IF_STATEMENT,
    WHILE_STATEMENT,
    FOR_STATEMENT,
    RETURN_STATEMENT,
    BREAK_STATEMENT,
    CONTINUE_STATEMENT,
    TRY_STATEMENT,
    STATEMENT_TYPE_COUNT_PLUS_1
} StatementType;

struct Statement_tag {
    StatementType       type;
    int                 line_number;
    union {
        Expression      *expression_s;
        GlobalStatement global_s;
        IfStatement     if_s;
        WhileStatement  while_s;
        ForStatement    for_s;
        ReturnStatement return_s;
        TryStatement    try_s;
    } u;
};

typedef struct ParameterList_tag {
    char        *name;
    struct ParameterList_tag *next;
} ParameterList;

typedef enum {
    CROWBAR_FUNCTION_DEFINITION = 1,
    NATIVE_FUNCTION_DEFINITION,
    FUNCTION_DEFINITION_TYPE_COUNT_PLUS_1
} FunctionDefinitionType;

struct CRB_FunctionDefinition_tag {
    char                *name;
    FunctionDefinitionType      type;
    CRB_Boolean         is_closure;
    union {
        struct {
            ParameterList       *parameter;
            Block               *block;
        } crowbar_f;
        struct {
            CRB_NativeFunctionProc      *proc;
        } native_f;
    } u;
    struct CRB_FunctionDefinition_tag   *next;
};

typedef struct Variable_tag {
    char        *name;
    CRB_Value   value;
    struct Variable_tag *next;
} Variable;

typedef enum {
    NORMAL_STATEMENT_RESULT = 1,
    RETURN_STATEMENT_RESULT,
    BREAK_STATEMENT_RESULT,
    CONTINUE_STATEMENT_RESULT,
    STATEMENT_RESULT_TYPE_COUNT_PLUS_1
} StatementResultType;

typedef struct {
    StatementResultType type;
    union {
        CRB_Value       return_value;
    } u;
} StatementResult;

typedef struct GlobalVariableRef_tag {
    char        *name;
    CRB_Value   *value;
    struct GlobalVariableRef_tag *next;
} GlobalVariableRef;

struct CRB_LocalEnvironment_tag {
    char                *current_function_name;
    CRB_Object          *variable;      /* ScopeChain */
    GlobalVariableRef   *global_variable;
    struct CRB_LocalEnvironment_tag     *next;
};

typedef struct {
    int         stack_alloc_size;
    int         stack_pointer;
    CRB_Value   *stack;
} Stack;

typedef struct {
    int         current_heap_size;
    int         current_threshold;
    CRB_Object  *header;
} Heap;

typedef struct {
    jmp_buf     environment;
} RecoveryEnvironment;

struct CRB_Interpreter_tag {
    MEM_Storage         interpreter_storage;
    MEM_Storage         execute_storage;
    Variable            *variable;
    CRB_FunctionDefinition      *function_list;
    StatementList       *statement_list;
    int                 current_line_number;
    Stack               stack;
    Heap                heap;
    CRB_LocalEnvironment        *top_environment;
    CRB_Object          *current_exception;
    RecoveryEnvironment current_recovery_environment;
};

struct CRB_Array_tag {
    int         size;
    int         alloc_size;
    CRB_Value   *array;
};

struct CRB_String_tag {
    CRB_Boolean is_literal;
    char        *string;
};

typedef struct {
    char        *name;
    CRB_Value   value;
} AssocMember;

struct CRB_Assoc_tag {
    int         member_count;
    AssocMember *member;
};

typedef struct {
    CRB_Object  *frame; /* CRB_Assoc */
    CRB_Object  *next;  /* ScopeChain */
} ScopeChain;

typedef struct {
    void                        *pointer;
    CRB_NativePointerInfo       *info;
} NativePointer;

typedef enum {
    ARRAY_OBJECT = 1,
    STRING_OBJECT,
    ASSOC_OBJECT,
    SCOPE_CHAIN_OBJECT,
    NATIVE_POINTER_OBJECT,
    OBJECT_TYPE_COUNT_PLUS_1
} ObjectType;

#define crb_is_object_value(type) \
  ((type) == CRB_STRING_VALUE || (type) == CRB_ARRAY_VALUE\
   || (type) == CRB_ASSOC_VALUE || (type) == CRB_NATIVE_POINTER_VALUE)

struct CRB_Object_tag {
    ObjectType  type;
    unsigned int        marked:1;
    union {
        CRB_Array       array;
        CRB_String      string;
        CRB_Assoc       assoc;
        ScopeChain      scope_chain;
        NativePointer   native_pointer;
    } u;
    struct CRB_Object_tag *prev;
    struct CRB_Object_tag *next;
};

typedef struct {
    char        *string;
} VString;

/* create.c */
void crb_function_define(char *identifier, ParameterList *parameter_list,
                         Block *block);
ParameterList *crb_create_parameter(char *identifier);
ParameterList *crb_chain_parameter(ParameterList *list,
                                   char *identifier);
ArgumentList *crb_create_argument_list(Expression *expression);
ArgumentList *crb_chain_argument_list(ArgumentList *list, Expression *expr);
ExpressionList *crb_create_expression_list(Expression *expression);
ExpressionList *crb_chain_expression_list(ExpressionList *list,
                                        Expression *expr);
StatementList *crb_create_statement_list(Statement *statement);
StatementList *crb_chain_statement_list(StatementList *list,
                                        Statement *statement);
Expression *crb_alloc_expression(ExpressionType type);
Expression *crb_create_comma_expression(Expression *left, Expression *right);
Expression *crb_create_assign_expression(Expression *left,
                                         AssignmentOperator operator,
                                         Expression *operand);
Expression *crb_create_binary_expression(ExpressionType operator,
                                         Expression *left,
                                         Expression *right);
Expression *crb_create_minus_expression(Expression *operand);
Expression *crb_create_logical_not_expression(Expression *operand);
Expression *crb_create_index_expression(Expression *array, Expression *index);
Expression *crb_create_incdec_expression(Expression *operand,
                                         ExpressionType inc_or_dec);
Expression *crb_create_identifier_expression(char *identifier);
Expression *crb_create_function_call_expression(Expression *function,
                                                ArgumentList *argument);
Expression *crb_create_member_expression(Expression *expression,
                                         char *member_name);
Expression *crb_create_boolean_expression(CRB_Boolean value);
Expression *crb_create_null_expression(void);
Expression *crb_create_array_expression(ExpressionList *list);
Expression *crb_create_closure_definition(char *identifier,
                                          ParameterList *parameter_list,
                                          Block *block);
Statement *crb_create_global_statement(IdentifierList *identifier_list);
IdentifierList *crb_create_global_identifier(char *identifier);
IdentifierList *crb_chain_identifier(IdentifierList *list, char *identifier);
Statement *crb_create_if_statement(Expression *condition,
                                    Block *then_block, Elsif *elsif_list,
                                    Block *else_block);
Elsif *crb_chain_elsif_list(Elsif *list, Elsif *add);
Elsif *crb_create_elsif(Expression *expr, Block *block);
Statement *crb_create_while_statement(Expression *condition, Block *block);
Statement *crb_create_for_statement(Expression *init, Expression *cond,
                                    Expression *post, Block *block);
Block *crb_create_block(StatementList *statement_list);
Statement *crb_create_expression_statement(Expression *expression);
Statement *crb_create_return_statement(Expression *expression);
Statement *crb_create_break_statement(void);
Statement *crb_create_continue_statement(void);
Statement *crb_create_try_statement(Block *try_block, char *exception,
                                    Block *catch_block, Block *finally_block);

/* string.c */
char *crb_create_identifier(char *str);
void crb_open_string_literal(void);
void crb_add_string_literal(int letter);
void crb_reset_string_literal_buffer(void);
char *crb_close_string_literal(void);

/* execute.c */
StatementResult
crb_execute_statement_list(CRB_Interpreter *inter,
                           CRB_LocalEnvironment *env, StatementList *list);

/* eval.c */
int crb_get_stack_pointer(CRB_Interpreter *inter);
void crb_set_stack_pointer(CRB_Interpreter *inter, int stack_pointer);
CRB_Value *crb_get_identifier_lvalue(CRB_Interpreter *inter,
                                     CRB_LocalEnvironment *env,
                                     char *identifier);
CRB_Value crb_eval_binary_expression(CRB_Interpreter *inter,
                                 CRB_LocalEnvironment *env,
                                 ExpressionType operator,
                                 Expression *left, Expression *right);
CRB_Value crb_eval_minus_expression(CRB_Interpreter *inter,
                                    CRB_LocalEnvironment *env,
                                    Expression *operand);
CRB_Value crb_eval_expression(CRB_Interpreter *inter,
                          CRB_LocalEnvironment *env, Expression *expr);

/* heap.c */
CRB_Object *crb_create_scope_chain(CRB_Interpreter *inter);
CRB_Object *crb_create_stack_trace_line(CRB_Interpreter *inter,
                                        CRB_LocalEnvironment *env,
                                        int line_number);
void crb_garbage_collect(CRB_Interpreter *inter);


/* util.c */
CRB_Interpreter *crb_get_current_interpreter(void);
void crb_set_current_interpreter(CRB_Interpreter *inter);
void *crb_malloc(size_t size);
void *crb_execute_malloc(CRB_Interpreter *inter, size_t size);
CRB_Value *crb_search_local_variable(CRB_LocalEnvironment *env,
                                 char *identifier);
CRB_Value *
crb_search_global_variable(CRB_Interpreter *inter, char *identifier);
CRB_Value *crb_search_local_variable(CRB_LocalEnvironment *env,
                                 char *identifier);
void crb_add_local_variable(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
                            char *identifier, CRB_Value *value);
void crb_add_global_variable(CRB_Interpreter *inter, char *identifier,
                             CRB_Value *value);
CRB_NativeFunctionProc *
crb_search_native_function(CRB_Interpreter *inter, char *name);
CRB_FunctionDefinition *crb_search_function(CRB_Interpreter *inter,
                                            char *name);
CRB_FunctionDefinition *crb_search_function_in_compile(char *name);
char *crb_get_operator_string(ExpressionType type);
void crb_vstr_clear(VString *v);
void crb_vstr_append_string(VString *v, char *str);
void crb_vstr_append_character(VString *v, int ch);

/* error.c */
void crb_compile_error(CompileError id, ...);
void crb_runtime_error(CRB_Interpreter *inter, CRB_LocalEnvironment *env,
                       int line_number, RuntimeError id, ...);

/* native.c */
CRB_Value crb_nv_print_proc(CRB_Interpreter *interpreter,
                            CRB_LocalEnvironment *env,
                            int arg_count, CRB_Value *args);
CRB_Value crb_nv_fopen_proc(CRB_Interpreter *interpreter,
                            CRB_LocalEnvironment *env,
                            int arg_count, CRB_Value *args);
CRB_Value crb_nv_fclose_proc(CRB_Interpreter *interpreter,
                             CRB_LocalEnvironment *env,
                             int arg_count, CRB_Value *args);
CRB_Value crb_nv_fgets_proc(CRB_Interpreter *interpreter,
                            CRB_LocalEnvironment *env,
                            int arg_count, CRB_Value *args);
CRB_Value crb_nv_fputs_proc(CRB_Interpreter *interpreter,
                            CRB_LocalEnvironment *env,
                            int arg_count, CRB_Value *args);
CRB_Value crb_nv_new_array_proc(CRB_Interpreter *interpreter,
                                CRB_LocalEnvironment *env,
                                int arg_count, CRB_Value *args);
CRB_Value crb_nv_new_object_proc(CRB_Interpreter *interpreter,
                                 CRB_LocalEnvironment *env,
                                 int arg_count, CRB_Value *args);

#endif /* PRIVATE_CROWBAR_H_INCLUDED */