trunk/npl/npl.h

#ifndef _NPL_H
#define _NPL_H

#include "nplc.h"
#include <wchar.h>

// 指定の構造体(T)からメンバ(m)までのオフセットを返す
#define NPL_OFFSET(T, m) ((size_t)(&((T*)NULL)->m))

// キャストマクロを作るために内部的に使用するマクロ
#define _NPL_CAST(ct, x, t) \
        ((ct*)_npl_cast( \
                (void*)x, t, \
                __FILE__, __func__, __LINE__))

#define NPL_HEAD(x) ((npl_head_t*)x)

// 型情報付き構造体型キャストマクロ
#define NPL_STRUCT(x) _NPL_CAST(npl_struct_t, x, npl_struct_type)
#define NPL_ARGS(x) _NPL_CAST(npl_args_t, x, npl_args_type)
#define NPL_STATE_EVENT(x) \
        _NPL_CAST(npl_state_event_t, x, npl_state_event_type)
#define NPL_CMD_EVENT(x) _NPL_CAST(npl_cmd_event_t, x, npl_cmd_event_type)

// インターフェイス型キャストマクロ
#define NPL_IFACE(x) _NPL_CAST(npl_iface_t, x, npl_iface_type)

// uniface型キャストマクロ
#define NPL_UNIFACE(x) _NPL_CAST(npl_uniface_t, x, npl_uniface_type)
#define NPL_STREAM(x) _NPL_CAST(npl_stream_t, x, npl_stream_type)
#define NPL_IPTR(x) _NPL_CAST(npl_iptr_t, x, npl_iptr_type)
#define NPL_ISTATE(x) _NPL_CAST(npl_istate_t, x, npl_istate_type)

// オブジェクト型キャストマクロ
#define NPL_OBJECT(x) _NPL_CAST(npl_object_t, x, npl_object_type)
#define NPL_TYPE(x) _NPL_CAST(npl_type_t, x, npl_type_type)
#define NPL_CHUNK(x) _NPL_CAST(npl_chunk_t, x, npl_chunk_type)
#define NPL_DEF(x) _NPL_CAST(npl_def_t, x, npl_def_type)
#define NPL_VALUE(x) _NPL_CAST(npl_value_t, x, npl_value_type)
#define NPL_STR(x) _NPL_CAST(npl_str_t, x, npl_str_type)
#define NPL_MBSTR(x) _NPL_CAST(npl_mbstr_t, x, npl_mbstr_type)
#define NPL_VAR(x) _NPL_CAST(npl_var_t, x, npl_var_type)
#define NPL_PTR(x) _NPL_CAST(npl_ptr_t, x, npl_ptr_type)
#define NPL_TUPLE(x) _NPL_CAST(npl_tuple_t, x, npl_tuple_type)
#define NPL_BUFFER(x) _NPL_CAST(npl_buffer_t, x, npl_buffer_type)
#define NPL_LIST(x) _NPL_CAST(npl_list_t, x, npl_list_type)
#define NPL_DICT(x) _NPL_CAST(npl_dict_t, x, npl_dict_type)
#define NPL_FUNC(x) _NPL_CAST(npl_func_t, x, npl_func_type)
#define NPL_LISTENER(x) _NPL_CAST(npl_listener_t, x, npl_listener_type)
#define NPL_VSTACK(x) _NPL_CAST(npl_vstack_t, x, npl_vstack_type)
#define NPL_STATE(x) _NPL_CAST(npl_state_t, x, npl_state_type)
#define NPL_FILE(x) _NPL_CAST(npl_file_t, x, npl_file_type)
#define NPL_CMD(x) _NPL_CAST(npl_cmd_t, x, npl_cmd_type)

// 基本データ型
typedef signed char npl_s8_t;
typedef signed short npl_s16_t;
typedef signed long npl_s32_t;
typedef signed long long npl_s64_t;
typedef unsigned char npl_u8_t;
typedef unsigned short npl_u16_t;
typedef unsigned long npl_u32_t;
typedef unsigned long long npl_u64_t;
typedef void* npl_addr_t;
typedef double npl_float_t;

// 構造体、列挙型
typedef enum npl_bool_t npl_bool_t;
typedef unsigned char npl_byte_t;
typedef union npl_reg_t npl_reg_t;
typedef enum npl_token_type_t npl_token_type_t;
typedef struct npl_vfunc_t npl_vfunc_t;
typedef struct npl_head_t npl_head_t;
typedef struct npl_member_t npl_member_t;
typedef enum npl_class_type_t npl_class_type_t;
typedef unsigned long npl_type_flag_t;
typedef enum npl_state_event_type_t npl_state_event_type_t;
typedef enum npl_cmd_event_type_t npl_cmd_event_type_t;
typedef struct npl_uniface_list_t npl_uniface_list_t;
typedef unsigned long npl_var_flag_t;
typedef struct npl_token_t npl_token_t;
typedef enum npl_func_type_t npl_func_type_t;
typedef struct npl_command_list_t npl_command_list_t;

// 組込み型構造体
typedef struct npl_mod_t npl_mod_t;
typedef struct npl_type_t npl_type_t;
typedef struct npl_val_t npl_val_t;
typedef struct npl_buf_t npl_buf_t;
typedef struct npl_cbuf_t npl_cbuf_t;
typedef struct npl_sbuf_t npl_sbuf_t;
typedef struct npl_stack_t npl_stack_t;
typedef struct npl_vmi_t npl_vmi_t;
typedef struct npl_vm_t npl_vm_t;
typedef struct npl_vt_t npl_vt_t;
typedef struct npl_source_t npl_source_t;
typedef struct npl_cmdi_t npl_cmdi_t;

// 型情報付き構造体
typedef struct npl_struct_t npl_struct_t;
typedef struct npl_args_t npl_args_t;
typedef struct npl_state_event_t npl_state_event_t;
typedef struct npl_cmd_event_t npl_cmd_event_t;

// インターフェイス
typedef struct npl_iface_t npl_iface_t;

// unifaces
typedef struct npl_uniface_t npl_uniface_t;
typedef struct npl_stream_t npl_stream_t;
typedef struct npl_iptr_t npl_iptr_t;
typedef struct npl_istate_t npl_istate_t;

// オブジェクト型
typedef struct npl_object_t npl_object_t;
typedef struct npl_chunk_t npl_chunk_t;
typedef struct npl_def_t npl_def_t;
typedef struct npl_value_t npl_value_t;
typedef struct npl_str_t npl_str_t;
typedef struct npl_mbstr_t npl_mbstr_t;
typedef struct npl_var_t npl_var_t;
typedef struct npl_ptr_t npl_ptr_t;
typedef struct npl_tuple_t npl_tuple_t;
typedef struct npl_buffer_t npl_buffer_t;
typedef struct npl_list_t npl_list_t;
typedef struct npl_dict_t npl_dict_t;
typedef struct npl_func_t npl_func_t;
typedef struct npl_listener_t npl_listener_t;
typedef struct npl_vstack_t npl_vstack_t;
typedef struct npl_state_t npl_state_t;
typedef struct npl_file_t npl_file_t;
typedef struct npl_cmd_t npl_cmd_t;

// C関数型
typedef void (*npl_listener_func_t)(
        npl_object_t *object,
        npl_object_t *sender,
        npl_args_t *args);
typedef int (*npl_cmd_func_t)(npl_cmd_t *cmd, size_t argc, wchar_t *argv[]);


// グローバルな関数
int npl_init(void);
int npl_final(void);
char* npl_convert_to_mbs(const wchar_t *s);
wchar_t* npl_convert_to_wcs(const char *s);
int npl_add(size_t a, size_t b, size_t *r);
int npl_sub(size_t a, size_t b, size_t *r);
int npl_mul(size_t a, size_t b, size_t *r);

void* _npl_cast(
        void *p,
        npl_type_t *type,
        const char *file_name,
        const char *func_name,
        unsigned int line_no);

// NPLライブラリ・モジュール
extern npl_mod_t _npl_module;

extern npl_mod_t *npl_module;

// 基本値の型情報
extern npl_type_t _npl_unset_type;
extern npl_type_t _npl_bool_type;
extern npl_type_t _npl_byte_type;
extern npl_type_t _npl_size_type;
extern npl_type_t _npl_int_type;
extern npl_type_t _npl_uint_type;
extern npl_type_t _npl_long_type;
extern npl_type_t _npl_ulong_type;
extern npl_type_t _npl_float_type;
extern npl_type_t _npl_wchar_type;
extern npl_type_t _npl_mbchar_type;
extern npl_type_t _npl_ws_type;
extern npl_type_t _npl_mbs_type;
extern npl_type_t _npl_type_type;

extern npl_type_t *npl_unset_type;
extern npl_type_t *npl_bool_type;
extern npl_type_t *npl_byte_type;
extern npl_type_t *npl_size_type;
extern npl_type_t *npl_int_type;
extern npl_type_t *npl_uint_type;
extern npl_type_t *npl_long_type;
extern npl_type_t *npl_ulong_type;
extern npl_type_t *npl_float_type;
extern npl_type_t *npl_wchar_type;
extern npl_type_t *npl_mbchar_type;
extern npl_type_t *npl_ws_type;
extern npl_type_t *npl_mbs_type;
extern npl_type_t *npl_type_type;

// 構造体の型情報
extern npl_type_t _npl_struct_type;
extern npl_type_t _npl_args_type;
extern npl_type_t _npl_state_event_type;
extern npl_type_t _npl_cmd_event_type;

extern npl_type_t *npl_struct_type;
extern npl_type_t *npl_args_type;
extern npl_type_t *npl_state_event_type;
extern npl_type_t *npl_cmd_event_type;

// インターフェースの型情報
extern npl_type_t _npl_iface_type;

extern npl_type_t *npl_iface_type;

// uniface型情報
extern npl_type_t _npl_uniface_type;
extern npl_type_t _npl_stream_type;
extern npl_type_t _npl_iptr_type;
extern npl_type_t _npl_istate_type;

extern npl_type_t *npl_uniface_type;
extern npl_type_t *npl_stream_type;
extern npl_type_t *npl_iptr_type;
extern npl_type_t *npl_istate_type;

// オブジェクトの型情報
extern npl_type_t _npl_object_type;
extern npl_type_t _npl_chunk_type;
extern npl_type_t _npl_def_type;
extern npl_type_t _npl_value_type;
extern npl_type_t _npl_str_type;
extern npl_type_t _npl_mbstr_type;
extern npl_type_t _npl_var_type;
extern npl_type_t _npl_ptr_type;
extern npl_type_t _npl_tuple_type;
extern npl_type_t _npl_buffer_type;
extern npl_type_t _npl_list_type;
extern npl_type_t _npl_dict_type;
extern npl_type_t _npl_func_type;
extern npl_type_t _npl_listener_type;
extern npl_type_t _npl_vstack_type;
extern npl_type_t _npl_state_type;
extern npl_type_t _npl_file_type;
extern npl_type_t _npl_cmd_type;

extern npl_type_t *npl_object_type;
extern npl_type_t *npl_chunk_type;
extern npl_type_t *npl_def_type;
extern npl_type_t *npl_value_type;
extern npl_type_t *npl_str_type;
extern npl_type_t *npl_mbstr_type;
extern npl_type_t *npl_var_type;
extern npl_type_t *npl_ptr_type;
extern npl_type_t *npl_tuple_type;
extern npl_type_t *npl_buffer_type;
extern npl_type_t *npl_list_type;
extern npl_type_t *npl_dict_type;
extern npl_type_t *npl_func_type;
extern npl_type_t *npl_listener_type;
extern npl_type_t *npl_vstack_type;
extern npl_type_t *npl_state_type;
extern npl_type_t *npl_file_type;
extern npl_type_t *npl_cmd_type;

// bool
enum npl_bool_t {
        NPL_FALSE = 0,
        NPL_TRUE,
};

// reg (register)
union npl_reg_t {
        npl_s8_t s8;
        npl_s16_t s16;
        npl_s32_t s32;
        npl_s64_t s64;
        npl_u8_t u8;
        npl_u16_t u16;
        npl_u32_t u32;
        npl_u64_t u64;
        npl_addr_t addr;
        npl_float_t f;
};

// token
// 汎用的な予め定義されるトークン。
enum npl_token_type_t {
        NPL_TT_NULL = 0,

        NPL_TT_ID,
        NPL_TT_NUMBER,
        NPL_TT_CHARACTER,
        NPL_TT_STRING,
        NPL_TT_KEYWORD,

        NPL_TT_PLUS,    // +
        NPL_TT_MINUS,   // -
        NPL_TT_MUL,     // *
        NPL_TT_DIV,     // /
        NPL_TT_MOD,     // %
        NPL_TT_HAT,     // ^
        NPL_TT_TILDE,   // ~

        NPL_TT_QUESTION,     // ?
        NPL_TT_QUESTION2,    // ??
        NPL_TT_EXCLAMATION,  // !
        NPL_TT_EXCLAMATION2, // !!
        NPL_TT_SHARP,        // #
        NPL_TT_SHARP2,       // ##
        NPL_TT_DOLLAR,       // $
        NPL_TT_DOLLAR2,      // $$
        NPL_TT_AT,           // @
        NPL_TT_AT2,          // @@
        NPL_TT_AMP,          // &
        NPL_TT_AMP2,         // &&
        NPL_TT_BAR,          // |
        NPL_TT_BAR2,         // ||
        NPL_TT_DOT,          // .
        NPL_TT_DOT2,         // ..
        NPL_TT_COLON,        // :
        NPL_TT_COLON2,       // ::
        NPL_TT_COMMA,        // ,
        NPL_TT_SEMICOLON,    // ;
        NPL_TT_UNDARBAR,     // _

        NPL_TT_PLUS_PLUS,    // ++
        NPL_TT_MINUS_MINUS,  // --
        NPL_TT_MUL_MUL,      // **
        NPL_TT_MOD_MOD,      // %%
        NPL_TT_LSHIFT,       // <<
        NPL_TT_RSHIFT,       // >>
        NPL_TT_ARROW,        // ->

        NPL_TT_EQ,              // =
        NPL_TT_EQEQ,            // ==
        NPL_TT_NEQ,             // !=
        NPL_TT_EQEQEQ,          // ===
        NPL_TT_NEQEQ,           // !==
        NPL_TT_LT,              // <
        NPL_TT_GT,              // >
        NPL_TT_LE,              // <=
        NPL_TT_GE,              // >=
        NPL_TT_PLUS_EQ,         // +=
        NPL_TT_MINUS_EQ,        // -=
        NPL_TT_MUL_EQ,          // *=
        NPL_TT_DIV_EQ,          // /=
        NPL_TT_MOD_EQ,          // %=
        NPL_TT_COLON_EQ,        // :=
        NPL_TT_COLON_COLON_EQ,  // ::=
        NPL_TT_AMP_EQ,          // &=
        NPL_TT_BAR_EQ,          // |=
        NPL_TT_QUESTION_EQ,     // ?=
        NPL_TT_LSHIFT_EQ,       // <<=
        NPL_TT_RSHIFT_EQ,       // >>=

        NPL_TT_LPAR,      // (
        NPL_TT_RPAR,      // )
        NPL_TT_LBRACE,    // {
        NPL_TT_RBRACE,    // }
        NPL_TT_LBRACKET,  // [
        NPL_TT_RBRACKET,  // ]
};

// vfunc （仮想関数（オーバーライド可能な関数））
struct npl_vfunc_t {
        void *vfn;  // 仮想関数のアドレス
        void *fn;   // 呼び出す関数のアドレス
};

// mod
struct npl_mod_t {
        npl_type_t **types;
};

// member (クラスメンバ情報）
struct npl_member_t {
        npl_type_t *type;  // メンバ型、メソッドの返り値型
        npl_type_t **args;  // メソッドの引数型リスト
        wchar_t *name;
        size_t offset;
        int (*setter)(npl_head_t *head, npl_val_t *val);
        int (*getter)(npl_head_t *head, npl_val_t *val_r);
        int (*method)(npl_head_t *head, npl_vm_t *vm);
};

// type
enum npl_class_type_t {
        NPL_CT_OBJECT,
        NPL_CT_STRUCT,
        NPL_CT_IFACE,
        NPL_CT_UNIFACE,
        NPL_CT_UNSET,
        NPL_CT_BOOL,
        NPL_CT_BYTE,
        NPL_CT_SIZE,
        NPL_CT_INT,
        NPL_CT_UINT,
        NPL_CT_LONG,
        NPL_CT_ULONG,
        NPL_CT_FLOAT,
        NPL_CT_WCHAR,
        NPL_CT_MBCHAR,
        NPL_CT_WS,
        NPL_CT_MBS,
        NPL_CT_TYPE,
};

struct npl_type_t {
        void (*destructor)(void *p);
        npl_class_type_t ctype;
        wchar_t *name;
        npl_type_t *parent;
        size_t size;
        npl_member_t *members;
        npl_vfunc_t *vfuncs;  // 配列
        npl_type_t **ifaces;
        npl_uniface_list_t *unifaces;  // 配列
};

int npl_type_check(npl_type_t *type, npl_type_t *base);
wchar_t* npl_type_name(npl_type_t *type);
void* npl_type_vfn(npl_type_t *type, void *vfn);
size_t npl_type_uniface_list_size(npl_type_t *type);
npl_uniface_list_t* npl_type_uniface_list(npl_type_t *type, size_t i);

// val
struct npl_val_t {
        npl_type_t *type;
        union {
                npl_object_t *object;
                npl_iface_t *iface;
                npl_uniface_t *uniface;
                npl_bool_t b;
                npl_byte_t byte;
                size_t size;
                int i;
                unsigned int u;
                long long l;
                unsigned long long ul;
                double f;
                wchar_t wc;
                char mbc;
                wchar_t *ws;
                char *mbs;
                npl_type_t *t;
        };
};

void npl_val_unset(npl_val_t *val);
void npl_val_init(npl_val_t *val);
void npl_val_copy(npl_val_t *dest, npl_val_t *src);
void npl_val_move(npl_val_t *dest, npl_val_t *src);
int npl_val_check(npl_val_t *val, npl_type_t *base);

void npl_val_set_object(npl_val_t *val, npl_object_t *object);
void npl_val_set_iface(npl_val_t *val, npl_iface_t *iface);
void npl_val_set_uniface(npl_val_t *val, npl_uniface_t *uniface);
void npl_val_set_null(npl_val_t *val);
void npl_val_set_bool(npl_val_t *val, npl_bool_t b);
void npl_val_set_byte(npl_val_t *val, npl_byte_t byte);
void npl_val_set_size(npl_val_t *val, size_t size);
void npl_val_set_int(npl_val_t *val, int i);
void npl_val_set_uint(npl_val_t *val, unsigned int u);
void npl_val_set_long(npl_val_t *val, long long l);
void npl_val_set_ulong(npl_val_t *val, unsigned long long ul);
void npl_val_set_float(npl_val_t *val, double f);
void npl_val_set_wchar(npl_val_t *val, wchar_t wc);
void npl_val_set_mbchar(npl_val_t *val, char mbc);
void npl_val_set_ws(npl_val_t *val, wchar_t *ws);
void npl_val_set_mbs(npl_val_t *val, char *mbs);
void npl_val_set_type(npl_val_t *val, npl_type_t *t);

// head
struct npl_head_t {
        npl_type_t *type;
};

npl_member_t* npl_member(npl_head_t *head, const wchar_t *name);
void* npl_member_addr(npl_head_t *head, npl_member_t *m);
int npl_set(npl_head_t *head, npl_member_t *m, npl_val_t *val);
int npl_get(npl_head_t *head, npl_member_t *m, npl_val_t *val_r);
int npl_call(npl_head_t *head, npl_member_t *m, npl_vm_t *vm);

// struct
struct npl_struct_t {
        npl_type_t *type;
};

void npl_struct_init(void *ptr, npl_type_t *type);
void npl_struct_final(npl_struct_t *s);
int npl_struct_check(npl_struct_t *s, npl_type_t *base);

// args
struct npl_args_t {
        npl_struct_t s;
};

int npl_args_init(npl_args_t *args);
int npl_args_check(npl_args_t *args, npl_type_t *base);

// state_event
enum npl_state_event_type_t {
        NPL_SE_DEBUG,
        NPL_SE_WARNING,
        NPL_SE_ERROR,
};

struct npl_state_event_t {
        npl_args_t args;
        npl_state_event_type_t type;
        const wchar_t *message;
};

int npl_state_event_init(npl_state_event_t *args);

// cmd_event
enum npl_cmd_event_type_t {
        NPL_CE_DUMP_ARGV,
        NPL_CE_UNKNOWN_COMMAND,
        NPL_CE_FAILED,
};

struct npl_cmd_event_t {
        npl_args_t args;
        npl_cmd_event_type_t type;
        npl_cmd_t *cmd;
};

int npl_cmd_event_init(npl_cmd_event_t *args);

// uniface_list
struct npl_uniface_list_t {
        npl_type_t *type;
        size_t offset;
};

// uniface
struct npl_uniface_t {
        npl_type_t *type;
        npl_object_t *object;
};

void npl_uniface_init(
        void *u,
        npl_type_t *type,
        npl_object_t *object);
void npl_uniface_final(npl_uniface_t *u);
void npl_uniface_ref(npl_uniface_t *u);
void npl_uniface_unref(npl_uniface_t *u);
void npl_uniface_destroy(npl_uniface_t *u);
int npl_uniface_check(npl_uniface_t *u, npl_type_t *base);

// stream
struct npl_stream_t {
        npl_uniface_t uniface;
        void (*stream_print)(npl_stream_t *stream, wchar_t *str);
        void (*stream_read)(npl_stream_t *stream, wchar_t *buf, int n);
        void (*stream_readline)(npl_stream_t *stream, npl_sbuf_t *sbuf);
        int (*stream_error)(npl_stream_t *stream);
        int (*stream_eof)(npl_stream_t *stream);
};

int npl_stream_init(npl_stream_t *stream);
void npl_stream_print(npl_stream_t *stream, wchar_t *str);
void npl_stream_read(npl_stream_t *stream, wchar_t *buf, int n);
void npl_stream_readline(npl_stream_t *stream, npl_sbuf_t *sbuf);
int npl_stream_error(npl_stream_t *stream);
int npl_stream_eof(npl_stream_t *stream);

// iptr
struct npl_iptr_t {
        npl_uniface_t uniface;
        npl_buf_t *ptr_table;
        size_t size;
        size_t len;
};

int npl_iptr_init(npl_iptr_t *iptr, size_t size, size_t len);

void* npl_iptr_get(npl_iptr_t *iptr, size_t index);
int npl_iptr_is_enable(npl_iptr_t *iptr, size_t index);

// object class
struct npl_object_t {
        npl_type_t *type;
        size_t ref_count;
};

void npl_object_init(void *object, npl_type_t *type);
npl_object_t* npl_object_alloc(npl_type_t *type);
npl_object_t* npl_object_new(void);
void npl_object_ref(npl_object_t *object);
void npl_object_unref(npl_object_t *object);
int npl_object_check(npl_object_t *object, npl_type_t *base);
void* npl_object_vfn(npl_object_t *object, void *vfn);
void npl_object_destroy(npl_object_t *object);

npl_str_t* npl_object_to_str(npl_object_t *object);
wchar_t* npl_object_name(npl_object_t *object);
npl_uniface_t* npl_object_get_uniface(
        npl_object_t *object,
        npl_type_t *utype);

// iface interface
struct npl_iface_t {
        npl_object_t object;
};

void npl_iface_ref(npl_iface_t *iface);
void npl_iface_unref(npl_iface_t *iface);
void npl_iface_destroy(npl_iface_t *iface);
void* npl_iface_vfn(npl_iface_t *iface, void *vfn);

// buf
struct npl_buf_t {
        void *buf;
        size_t bytes;
};

int npl_buf_init(npl_buf_t *buf, size_t bytes);
void npl_buf_final(npl_buf_t *buf);
size_t npl_buf_size(npl_buf_t *buf);
void* npl_buf_get_buffer(npl_buf_t *buf, size_t offset);
void npl_buf_clear(npl_buf_t *buf);
int npl_buf_expand(npl_buf_t *buf, size_t bytes);
int npl_buf_reduce(npl_buf_t *buf, size_t bytes);

// cbuf
struct npl_cbuf_t {
        void *cbuf;
        size_t size;
        size_t len;
};

int npl_cbuf_init(npl_cbuf_t *cbuf, size_t size, size_t len);
void npl_cbuf_final(npl_cbuf_t *cbuf);
size_t npl_cbuf_size(npl_cbuf_t *cbuf);
size_t npl_cbuf_len(npl_cbuf_t *cbuf);
void* npl_cbuf_get_buffer(npl_cbuf_t *cbuf);
void* npl_cbuf_get(npl_cbuf_t *cbuf, size_t i);
void npl_cbuf_clear(npl_cbuf_t *cbuf);
int npl_cbuf_expand(npl_cbuf_t *cbuf, size_t n);
int npl_cbuf_reduce(npl_cbuf_t *cbuf, size_t len);

// sbuf
struct npl_sbuf_t {
        npl_cbuf_t cbuf;
        size_t pos;
};

int npl_sbuf_init(npl_sbuf_t *sb);
void npl_sbuf_final(npl_sbuf_t *sb);
void npl_sbuf_rewind(npl_sbuf_t *sb);
int npl_sbuf_add(npl_sbuf_t *sb, const wchar_t *s);
int npl_sbuf_put(npl_sbuf_t *sb, wchar_t ch);
size_t npl_sbuf_size(npl_sbuf_t *sb);
wchar_t* npl_sbuf_get_buffer(npl_sbuf_t *sb);
size_t npl_sbuf_len(npl_sbuf_t *sb);
void npl_sbuf_clear(npl_sbuf_t *sb);
int npl_sbuf_expand(npl_sbuf_t *sb, size_t n);
int npl_sbuf_reduce(npl_sbuf_t *sb, size_t len);
int npl_sbuf_copy(npl_sbuf_t *dest, npl_sbuf_t *src);

// buffer class
// （バイト列データ）
struct npl_buffer_t {
        npl_object_t object;
        npl_buf_t buf;
        size_t bytes;
};

int npl_buffer_init(npl_buffer_t *buffer);
npl_buffer_t* npl_buffer_new(void);
void npl_buffer_clear(npl_buffer_t *buffer);
int npl_buffer_add(npl_buffer_t *buffer, size_t n, void *p);
void* npl_buffer_get(npl_buffer_t *buffer, size_t offset);
size_t npl_buffer_size(npl_buffer_t *buffer);

// list class
npl_list_t* npl_list_new(void);
void npl_list_clear(npl_list_t *list);
int npl_list_prepend(npl_list_t *list, npl_object_t *object);
int npl_list_append(npl_list_t *list, npl_object_t *object);
int npl_list_insert(npl_list_t *list, size_t i, npl_object_t *object);
size_t npl_list_len(npl_list_t *list);
npl_object_t* npl_list_get(npl_list_t *list, size_t i);
void npl_list_delete(npl_list_t *list, size_t i);

// dict class
struct npl_dict_t {
        npl_object_t object;
        npl_cbuf_t dict;
        size_t pos;
};

int npl_dict_init(npl_dict_t *d);
npl_dict_t* npl_dict_new(void);
int npl_dict_set(npl_dict_t *d, wchar_t *name, npl_object_t *object);
npl_object_t* npl_dict_get(npl_dict_t *d, wchar_t *name);

// chunk class
struct npl_chunk_t {
        npl_object_t object;
        size_t bytes;
        void *chunk;
};

npl_chunk_t* npl_chunk_alloc(npl_type_t *type, size_t bytes);

// def class
struct npl_def_t {
        npl_chunk_t chunk;
        npl_object_t *p;
};

npl_def_t* npl_def_new(wchar_t *name);
wchar_t* npl_def_name(npl_def_t *def);
void npl_def_set(npl_def_t *def, npl_object_t *object);
npl_object_t* npl_def_get(npl_def_t *def);

// value class
struct npl_value_t {
        npl_object_t object;
        npl_val_t val;
};

int npl_value_init(npl_value_t *value);
npl_value_t* npl_value_new(void);
npl_val_t* npl_value_get(npl_value_t *value);

// str class
// str はワイド文字の文字列。
struct npl_str_t {
        npl_chunk_t chunk;
};

npl_str_t* npl_str_new(const wchar_t *s);
npl_str_t* npl_str_new_from_mbs(const char *s);
wchar_t* npl_str_get(npl_str_t *s);

// mbstr class
// mbstr はマルチバイト文字の文字列。
struct npl_mbstr_t {
        npl_chunk_t chunk;
};

npl_mbstr_t* npl_mbstr_new(const char *s);
npl_mbstr_t* npl_mbstr_new_from_wcs(const wchar_t *s);
char* npl_mbstr_get(npl_mbstr_t *str);

// var class

#define NPL_VF_IMMUTABLE (1<<0)
        // 値変更不可

struct npl_var_t {
        npl_chunk_t chunk;  // チャンクを名前に充てる
        npl_type_t *type;
        npl_var_flag_t flag;
        npl_val_t val;  // 変数の値
};

npl_var_t* npl_var_new(const wchar_t *name);
wchar_t* npl_var_name(npl_var_t *var);
int npl_var_set_type(npl_var_t *var, npl_type_t *type);
void npl_var_set_immutable(npl_var_t *var);
void npl_var_unset(npl_var_t *var);

int npl_var_check(npl_var_t *var, npl_type_t *base);
int npl_var_set_object(npl_var_t *var, npl_object_t *object);
int npl_var_set_iface(npl_var_t *var, npl_iface_t *iface);
int npl_var_set_uniface(npl_var_t *var, npl_uniface_t *uniface);
int npl_var_set_null(npl_var_t *var);
int npl_var_set_bool(npl_var_t *var, npl_bool_t b);
int npl_var_set_byte(npl_var_t *var, npl_byte_t byte);
int npl_var_set_size(npl_var_t *var, size_t size);
int npl_var_set_int(npl_var_t *var, int i);
int npl_var_set_uint(npl_var_t *var, unsigned int u);
int npl_var_set_long(npl_var_t *var, long long l);
int npl_var_set_ulong(npl_var_t *var, unsigned long long ul);
int npl_var_set_float(npl_var_t *var, double f);
int npl_var_set_wchar(npl_var_t *var, wchar_t wc);
int npl_var_set_mbchar(npl_var_t *var, char mbc);

// ptr class (ポインタ)
struct npl_ptr_t {
        npl_object_t object;
        npl_iptr_t *iptr;
        size_t index;
};

// tuple class
struct npl_tuple_t {
        npl_chunk_t chunk;
        size_t len;
        npl_val_t *val;
};

npl_tuple_t* npl_tuple_new(size_t len);
size_t npl_tuple_len(npl_tuple_t *tuple);

// vm opcode
#define NPL_OP_NOP 0
#define NPL_OP_BREAK 1
#define NPL_OP_END 2
#define NPL_OP_SETP 3
#define NPL_OP_ADDP 4
#define NPL_OP_STORE 5
#define NPL_OP_LOAD 6
#define NPL_OP_SET 7
#define NPL_OP_PUSH 8
#define NPL_OP_POP 9

// vmi (virtual machine interpreter)
struct npl_vmi_t {
        void *code;
        size_t pc;  // program counter
};

npl_u8_t npl_vmi_u8(npl_vmi_t *vmi);
npl_u16_t npl_vmi_u16(npl_vmi_t *vmi);
npl_u32_t npl_vmi_u32(npl_vmi_t *vmi);
npl_u64_t npl_vmi_u64(npl_vmi_t *vmi);
npl_s8_t npl_vmi_s8(npl_vmi_t *vmi);
npl_s16_t npl_vmi_s16(npl_vmi_t *vmi);
npl_s32_t npl_vmi_s32(npl_vmi_t *vmi);
npl_s64_t npl_vmi_s64(npl_vmi_t *vmi);
npl_addr_t npl_vmi_addr(npl_vmi_t *vmi);
npl_float_t npl_vmi_float(npl_vmi_t *vmi);

// vm (virtual machine)
struct npl_vm_t {
        void *ptr[2];
        void *obj;
        void *var;
        npl_buf_t stack;
        size_t sp;  // stack pointer
        npl_vmi_t vmi;
};

int npl_vm_init(npl_vm_t *vm);
void npl_vm_final(npl_vm_t *vm);
void npl_vm_clear(npl_vm_t *vm);
npl_u8_t npl_vm_exec(npl_vm_t *vm);

// func class
enum npl_func_type_t {
        NPL_FNT_LISTENER,
};

struct npl_func_t {
        npl_chunk_t chunk;
        npl_func_type_t type;
        npl_object_t *this_ptr;
        union {
                npl_listener_func_t fn_lst;
        };
};

npl_func_t* npl_func_new_listener(
        npl_object_t *this_ptr,
        npl_listener_func_t fn_lst);
void npl_func_call_listener(
        npl_func_t *fn,
        npl_object_t *sender,
        npl_args_t *args);

// listener class
struct npl_listener_t {
        npl_object_t object;
        npl_cbuf_t _cbuf;
        size_t n;
};

int npl_listener_init(npl_listener_t *lst);
npl_listener_t* npl_listener_new(void);
int npl_listener_add(
        npl_listener_t *lst,
        npl_object_t *object,
        npl_listener_func_t func);
int npl_listener_add_func(npl_listener_t *lst, npl_func_t *fn);
void npl_listener_call(
        npl_listener_t *lst,
        npl_object_t *sender,
        npl_args_t *args);
void npl_listener_remove(npl_listener_t *lst, npl_object_t *object);
void npl_listener_remove_func(npl_listener_t *lst, npl_func_t *fn);
void npl_listener_clear(npl_listener_t *lst);

// stack
struct npl_stack_t {
        npl_cbuf_t stack;
        size_t count;
};

int npl_stack_init(npl_stack_t *s);
void npl_stack_final(npl_stack_t *s);
int npl_stack_push(npl_stack_t *s, npl_object_t *object);
npl_object_t* npl_stack_pop(npl_stack_t *s);
npl_object_t* npl_stack_get(npl_stack_t *s, size_t i);
void npl_stack_remove(npl_stack_t *s, size_t n);

// vstack class
struct npl_vstack_t {
        npl_object_t object;
        npl_stack_t stack;
        npl_vstack_t *prev;
        npl_vstack_t *parent;
};

int npl_vstack_init(npl_vstack_t *vs);
npl_vstack_t* npl_vstack_new(void);

// vt
struct npl_vt_t {
        npl_vstack_t *current;
};

int npl_vt_init(npl_vt_t *vt);
void npl_vt_final(npl_vt_t *vt);
int npl_vt_enter(npl_vt_t *vt);
int npl_vt_enter_func(npl_vt_t *vt, const wchar_t *name);
int npl_vt_leave(npl_vt_t *vt);
npl_var_t* npl_vt_add(npl_vt_t *vt, const wchar_t *name);
npl_var_t* npl_vt_find(npl_vt_t *vt, const wchar_t *name);

// source
#define NPL_SOURCE_BUFFER_SIZE 256

struct npl_source_t {
        wchar_t buf1[NPL_SOURCE_BUFFER_SIZE];
        wchar_t buf2[NPL_SOURCE_BUFFER_SIZE];
        wchar_t *_p_read, *_p_write;
        wchar_t *buf;  // 内容の読み出しには、こちらを使用する
        int done;
};

int npl_source_init(npl_source_t *src);
void npl_source_final(npl_source_t *src);
void npl_source_get_read_buffer(npl_source_t *src, wchar_t **r);
wchar_t* npl_source_get_write_buffer(npl_source_t *src);
void npl_source_swap(npl_source_t *src);
void npl_source_done(npl_source_t *src);
int npl_source_is_buffered(npl_source_t *src);

// istate
struct npl_istate_t {
        npl_uniface_t uniface;
        npl_vt_t _vt;
        int running;
        int break_flag;
        int (*istate_do)(npl_istate_t *ist);
};

int npl_istate_init(npl_istate_t *ist);
int npl_istate_do(npl_istate_t *ist);
void npl_istate_quit(npl_istate_t *ist);
void npl_istate_break(npl_istate_t *ist);
npl_var_t* npl_istate_add_var(npl_istate_t *ist, const wchar_t *name);
npl_var_t* npl_istate_find_var(npl_istate_t *ist, const wchar_t *name);

// state class
struct npl_state_t {
        npl_object_t object;
        npl_istate_t istate;
        npl_listener_t *_state_event;
};

int npl_state_init(npl_state_t *state);
npl_state_t* npl_state_new(void);
int npl_state_add_listener(
        npl_state_t *state,
        npl_object_t *object,
        npl_listener_func_t func);

// state events
void npl_state_debug(npl_state_t *state, const wchar_t *ws);
void npl_state_warning(npl_state_t *state, const wchar_t *ws);
void npl_state_error(npl_state_t *state, const wchar_t *ws);

// file class
struct npl_file_t {
        npl_object_t object;
        npl_stream_t stream;
        void *fp;
};

int npl_file_init(npl_file_t *file, void *fp);
npl_file_t* npl_file_new(void *fp);
npl_file_t* npl_file_open(wchar_t *filename, wchar_t *mode);
npl_file_t* npl_file_stdout(void);
npl_file_t* npl_file_stdin(void);
npl_file_t* npl_file_stderr(void);
void npl_file_close(npl_file_t *file);

// cmd
struct npl_command_list_t {
        const wchar_t *name;
        npl_cmd_func_t func;
};

struct npl_cmd_t {
        npl_state_t state;
        npl_command_list_t *commands[8];  // 静的配列のみ
        size_t _commands_len;
        npl_cmdi_t *ci;

        // flags
        int f_dump_argv;
};

int npl_cmd_init(npl_cmd_t *cmd);
npl_cmd_t* npl_cmd_new(void);
int npl_cmd_add_listener(
        npl_cmd_t *cmd,
        npl_object_t *object,
        npl_listener_func_t func);
void npl_cmd_quit(npl_cmd_t *cmd);
int npl_cmd_is_done(npl_cmd_t *cmd);
int npl_cmd_add_command_list(npl_cmd_t *cmd, npl_command_list_t *list);
int npl_cmd_push_cmdi(npl_cmd_t *cmd, npl_cmdi_t *ci);
void npl_cmd_pop_cmdi(npl_cmd_t *cmd);
int npl_cmd_do(npl_cmd_t *cmd);

npl_var_t* npl_cmd_get_var(npl_cmd_t *cmd, wchar_t *name);
wchar_t* npl_cmd_get_str(npl_cmd_t *cmd, wchar_t *name);
npl_file_t* npl_cmd_get_file(npl_cmd_t *cmd, wchar_t *name);

int npl_cmd_set_object(npl_cmd_t *cmd, wchar_t *name, npl_object_t *object);
int npl_cmd_set_iface(npl_cmd_t *cmd, wchar_t *name, npl_iface_t *iface);
int npl_cmd_set_uniface(
        npl_cmd_t *cmd,
        wchar_t *name,
        npl_uniface_t *uniface);
int npl_cmd_set_null(npl_cmd_t *cmd, wchar_t *name);
int npl_cmd_set_bool(npl_cmd_t *cmd, wchar_t *name, npl_bool_t b);
int npl_cmd_set_byte(npl_cmd_t *cmd, wchar_t *name, npl_byte_t byte);
int npl_cmd_set_size(npl_cmd_t *cmd, wchar_t *name, size_t size);
int npl_cmd_set_int(npl_cmd_t *cmd, wchar_t *name, int i);
int npl_cmd_set_uint(npl_cmd_t *cmd, wchar_t *name, unsigned int u);
int npl_cmd_set_long(npl_cmd_t *cmd, wchar_t *name, long long l);
int npl_cmd_set_ulong(npl_cmd_t *cmd, wchar_t *name, unsigned long long ul);
int npl_cmd_set_float(npl_cmd_t *cmd, wchar_t *name, double f);
int npl_cmd_set_wchar(npl_cmd_t *cmd, wchar_t *name, wchar_t wc);
int npl_cmd_set_mbchar(npl_cmd_t *cmd, wchar_t *name, char mbc);
int npl_cmd_set_str(npl_cmd_t *cmd, wchar_t *name, wchar_t *ws);
int npl_cmd_set_file(npl_cmd_t *cmd, wchar_t *name, npl_file_t *file);

// cmd events
void npl_cmd_dump_argv(npl_cmd_t *cmd);
void npl_cmd_unknown_command(npl_cmd_t *cmd);
void npl_cmd_failed(npl_cmd_t *cmd);

// cmdi (cmd interpreter data)
struct npl_cmdi_t {
        npl_cmdi_t *prev;
        npl_cbuf_t _argv;
        npl_sbuf_t _cmd_buf;
        npl_source_t src;
        int lf;  // 改行
        int sq, dq;  // シングル・ダブルクォート
        int es;  // エスケープ・シーケンス
        int comment;  // コメント

        size_t argc;
        wchar_t **argv;
        npl_var_t *result;
};

int npl_cmdi_init(npl_cmdi_t *ci);
void npl_cmdi_final(npl_cmdi_t *ci);

#endif /* _NPL_H */
