zclk.h

Go to the documentation of this file.

// Copyright (c) 2020 Abhishek Mishra
// 
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
 
#ifndef __ZCLK_H__
#define __ZCLK_H__
 
#include "zclk_common.h"
 
#include <coll_arraylist.h>
 
#ifdef LUA_ENABLED
#include <lua.h>
#include <lauxlib.h>
#endif //LUA_ENABLED
 
#include "zclk_table.h"
#include "zclk_dict.h"
#include "zclk_progress.h"
 
#ifdef __cplusplus  
extern "C" {
#endif
 
#define ZCLK_OPTION_HELP_LONG "help"
#define ZCLK_OPTION_HELP_SHORT "h"
#define ZCLK_OPTION_HELP_DESC "Print help for command."
 
typedef enum
{
    ZCLK_RES_IS_RUNNING = -1,
    ZCLK_RES_SUCCESS = 0,
    ZCLK_RES_ERR_UNKNOWN = 1,
    ZCLK_RES_ERR_ALLOC_FAILED = 2,
    ZCLK_RES_ERR_COMMAND_NOT_FOUND = 3,
    ZCLK_RES_ERR_OPTION_NOT_FOUND = 4,
    ZCLK_RES_ERR_ARG_NOT_FOUND = 5,
    ZCLK_RES_ERR_EXTRA_ARGS_FOUND = 6
} zclk_res;
 
typedef enum
{
    ZCLK_TYPE_BOOLEAN = 0,
    ZCLK_TYPE_INT = 1,
    ZCLK_TYPE_DOUBLE = 2,
    ZCLK_TYPE_STRING = 3,
    ZCLK_TYPE_FLAG = 4
} zclk_type;
 
#define ZCLK_BOOL_TRUE  1
#define ZCLK_BOOL_FALSE 0
#define ZCLK_FLAG_ON    1
#define ZCLK_FLAG_OFF   0
 
typedef enum
{
    ZCLK_RESULT_STRING = 0,
    ZCLK_RESULT_TABLE = 1,
    ZCLK_RESULT_DICT = 2,
    ZCLK_RESULT_PROGRESS = 3
} zclk_result_type;
 
typedef struct zclk_val_t
{
    zclk_type type;         
    union {
        int bool_value;     
        int int_value;      
        double dbl_value;   
        char* str_value;    
    } data;                 
} zclk_val;
 
MODULE_API int zclk_val_is_type(zclk_val *val, zclk_type type);
 
#define zclk_val_is_bool(val)       zclk_val_is_type(val, ZCLK_TYPE_BOOLEAN)
 
#define zclk_val_is_int(val)        zclk_val_is_type(val, ZCLK_TYPE_INT)
 
#define zclk_val_is_double(val)     zclk_val_is_type(val, ZCLK_TYPE_DOUBLE)
 
#define zclk_val_is_string(val)     zclk_val_is_type(val, ZCLK_TYPE_STRING)
 
#define zclk_val_is_flag(val)       zclk_val_is_type(val, ZCLK_TYPE_FLAG)
 
MODULE_API int zclk_val_get_bool(zclk_val *val);
 
MODULE_API int zclk_val_get_int(zclk_val *val);
 
MODULE_API double zclk_val_get_double(zclk_val *val);
 
MODULE_API const char* zclk_val_get_string(zclk_val *val);
 
MODULE_API int zclk_val_get_flag(zclk_val *val);
 
MODULE_API void zclk_val_set_bool(zclk_val *val, int bval);
 
MODULE_API void zclk_val_set_int(zclk_val *val, int ival);
 
MODULE_API void zclk_val_set_dobule(zclk_val *val, double dval);
 
MODULE_API void zclk_val_set_string(zclk_val *val, const char* sval);
 
MODULE_API void zclk_val_set_flag(zclk_val *val, int fval);
 
#ifdef LUA_ENABLED
MODULE_API int zclk_val_to_lua(lua_State *L, zclk_val* val);
#endif //LUA_ENABLED
 
MODULE_API zclk_val* new_zclk_val_bool(int bool_val);
 
MODULE_API zclk_val* new_zclk_val_int(int int_val);
 
MODULE_API zclk_val* new_zclk_val_double(double double_val);
 
MODULE_API zclk_val* new_zclk_val_string(const char* string_val);
 
MODULE_API zclk_val* new_zclk_val_flag(int flag_val);
 
#define zclk_flag(v) new_zclk_val_flag(v)
 
#define zclk_boolean(v) new_zclk_val_bool(v)
 
#define zclk_int(v) new_zclk_val_int(v)
 
#define zclk_double(v) new_zclk_val_double(v)
 
#define zclk_string(v) new_zclk_val_string(v)
 
typedef struct zclk_option_t
{
    char* name;             
    char* short_name;       
    zclk_val* val;          
    zclk_val* default_val;  
    char* description;      
} zclk_option;
 
#ifdef LUA_ENABLED
MODULE_API int zclk_option_to_lua(lua_State *L, zclk_option* option);
 
MODULE_API void arraylist_zclk_option_to_lua(lua_State *L, int index, void *data);
#endif //LUA_ENABLED
 
typedef struct zclk_argument_t
{
    char* name;             
    zclk_val* val;          
    zclk_val* default_val;  
    char* description;      
    int optional;           
} zclk_argument;
 
#ifdef LUA_ENABLED
MODULE_API int zclk_argument_to_lua(lua_State *L, zclk_argument* arg);
 
MODULE_API void arraylist_zclk_argument_to_lua(lua_State *L, int index, void *data);
#endif //LUA_ENABLED
 
MODULE_API void zclk_fill_options_in_list(arraylist* optlist, zclk_option* options[]);
 
typedef zclk_res(*zclk_command_output_handler)(zclk_res result_flag,
    zclk_result_type result_type, void* result);
 
// declration to assist in defining command fn
struct zclk_command_t;
 
typedef zclk_res(*zclk_command_fn)(struct zclk_command_t* cmd,
                                        void* handler_args);
 
typedef struct zclk_command_t
{
    char* name;                     
    char* short_name;               
    char* description;              
    arraylist* sub_commands;        
    arraylist* options;             
    arraylist* args;                
    zclk_command_fn handler;        
    zclk_command_output_handler
        error_handler;              
    zclk_command_output_handler
        success_handler;            
    int lua_handler_ref;            
    int lua_udata_ref;              
} zclk_command;
 
MODULE_API zclk_res make_zclk_val(zclk_val** val, zclk_type type);
 
MODULE_API void free_zclk_val(zclk_val* val);
 
MODULE_API void clear_zclk_val(zclk_val* val);
 
MODULE_API void copy_zclk_val(zclk_val* to, zclk_val* from);
 
MODULE_API zclk_res parse_zclk_val(zclk_val* val, char* input);
 
MODULE_API zclk_res make_option(zclk_option** option, const char* name, 
    const char* short_name, zclk_val* val, zclk_val* default_val, 
    const char* description);
 
MODULE_API zclk_option* new_zclk_option(const char* name, 
    const char* short_name, zclk_val* val, zclk_val* default_val, 
    const char* desc);
 
MODULE_API zclk_option *new_zclk_option_bool(const char *name, 
    const char *short_name, int default_val, const char *desc);
MODULE_API zclk_option *new_zclk_option_int(const char *name, 
    const char *short_name, int default_val, const char *desc);
MODULE_API zclk_option *new_zclk_option_double(const char *name, 
    const char *short_name, double default_val, const char *desc);
MODULE_API zclk_option *new_zclk_option_string(const char *name, 
    const char *short_name, const char* default_val, 
    const char *desc);
MODULE_API zclk_option *new_zclk_option_flag(const char *name, 
    const char *short_name, int default_val, const char *desc);
 
MODULE_API const char *zclk_option_get_name(zclk_option *opt);
MODULE_API const char *zclk_option_get_short_name(zclk_option *opt);
MODULE_API const char *zclk_option_get_desc(zclk_option *opt);
 
MODULE_API int zclk_option_get_val_bool(zclk_option *opt);
MODULE_API int zclk_option_get_val_int(zclk_option *opt);
MODULE_API double zclk_option_get_val_double(zclk_option *opt);
MODULE_API const char* zclk_option_get_val_string(zclk_option *opt);
MODULE_API int zclk_option_get_val_flag(zclk_option *opt);
 
MODULE_API int zclk_option_get_default_val_bool(zclk_option *opt);
MODULE_API int zclk_option_get_default_val_int(zclk_option *opt);
MODULE_API double zclk_option_get_default_val_double(zclk_option *opt);
MODULE_API const char* zclk_option_get_default_val_string(zclk_option *opt);
MODULE_API int zclk_option_get_default_val_flag(zclk_option *opt);
 
MODULE_API void free_option(zclk_option* option);
 
MODULE_API zclk_option* get_option_by_name(arraylist* options, 
    const char* name);
 
MODULE_API zclk_res make_argument(zclk_argument** arg, const char* name, 
    zclk_val* val, zclk_val* default_val, const char* desc);
 
MODULE_API zclk_argument* new_zclk_argument(const char* name, zclk_val* val, 
    zclk_val* default_val, const char* desc, int nargs);
 
MODULE_API zclk_argument *new_zclk_argument_bool(const char *name, 
    int default_val, const char *desc, int nargs);
MODULE_API zclk_argument *new_zclk_argument_int(const char *name, 
    int default_val, const char *desc, int nargs);
MODULE_API zclk_argument *new_zclk_argument_double(const char *name, 
    double default_val, const char *desc, int nargs);
MODULE_API zclk_argument *new_zclk_argument_string(const char *name, 
    const char* default_val, const char *desc, int nargs);
MODULE_API zclk_argument *new_zclk_argument_flag(const char *name, 
    int default_val, const char *desc, int nargs);
 
MODULE_API const char *zclk_argument_get_name(zclk_argument *opt);
MODULE_API const char *zclk_argument_get_desc(zclk_argument *opt);
 
MODULE_API int zclk_argument_get_val_bool(zclk_argument *opt);
MODULE_API int zclk_argument_get_val_int(zclk_argument *opt);
MODULE_API double zclk_argument_get_val_double(zclk_argument *opt);
MODULE_API const char* zclk_argument_get_val_string(zclk_argument *opt);
MODULE_API int zclk_argument_get_val_flag(zclk_argument *opt);
 
MODULE_API int zclk_argument_get_default_val_bool(zclk_argument *opt);
MODULE_API int zclk_argument_get_default_val_int(zclk_argument *opt);
MODULE_API double zclk_argument_get_default_val_double(zclk_argument *opt);
MODULE_API const char* zclk_argument_get_default_val_string(zclk_argument *opt);
MODULE_API int zclk_argument_get_default_val_flag(zclk_argument *opt);
 
MODULE_API void free_argument(zclk_argument* arg);
 
MODULE_API zclk_res make_command(zclk_command** command, const char* name, 
    const char* short_name, const char* description, zclk_command_fn handler);
 
MODULE_API zclk_command* new_zclk_command(
                            const char* name, 
                            const char* short_name,
                            const char* description, 
                            zclk_command_fn handler
                        );
 
MODULE_API zclk_res zclk_command_subcommand_add(
                            zclk_command *cmd,
                            zclk_command *subcommand
                        );
 
MODULE_API zclk_res zclk_command_option_add(
                            zclk_command *cmd,
                            zclk_option* option
                        );
 
MODULE_API zclk_res zclk_command_argument_add(
                            zclk_command *cmd,
                            zclk_argument* arg
                        );
 
MODULE_API void zclk_command_bool_option(zclk_command *cmd, const char *name, 
                const char* short_name, const char *desc);
 
MODULE_API void zclk_command_int_option(zclk_command *cmd, const char *name, 
                const char* short_name, int default_val, const char *desc);
 
MODULE_API void zclk_command_double_option(zclk_command *cmd, const char *name, 
                const char* short_name, double default_val, const char *desc);
 
MODULE_API void zclk_command_string_option(zclk_command *cmd, const char *name, 
                const char* short_name, const char* default_val, 
                const char *desc);
 
MODULE_API void zclk_command_flag_option(zclk_command *cmd, const char *name, 
                const char* short_name, const char *desc);
 
MODULE_API void zclk_command_bool_argument(zclk_command *cmd, const char *name, 
                int default_val, const char *desc, int nargs);
 
MODULE_API void zclk_command_int_argument(zclk_command *cmd, const char *name, 
                int default_val, const char *desc, int nargs);
 
MODULE_API void zclk_command_double_argument(zclk_command *cmd, const char *name, 
                double default_val, const char *desc, int nargs);
 
MODULE_API void zclk_command_string_argument(zclk_command *cmd, const char *name, 
                const char* default_val, const char *desc, int nargs);
 
MODULE_API void zclk_command_flag_argument(zclk_command *cmd, const char *name, 
                int default_val, const char *desc, int nargs);
 
MODULE_API zclk_option* zclk_command_get_option(zclk_command *cmd,
    const char *name);
 
MODULE_API zclk_argument* zclk_command_get_argument(zclk_command *cmd,
    const char *name);
 
#define zclk_command_option_foreach(cmd, opt)                               \
        zclk_option *opt = NULL;                                            \
        size_t len##opt = arraylist_length(cmd->options);                   \
        for (size_t i = 0; ((i < len##opt)?                                 \
                            (opt = (zclk_option *)                          \
                                (arraylist_get(cmd->options, i)))           \
                            : 0);                                           \
                    i++)
 
#define zclk_command_argument_foreach(cmd, arg)                             \
        zclk_argument *arg = NULL;                                          \
        size_t len##arg = arraylist_length(cmd->args);                      \
        for (size_t i = 0; ((i < len##arg)?                                 \
                            (arg = (zclk_argument *)                        \
                                (arraylist_get(cmd->args, i)))              \
                            : 0);                                           \
                    i++)
 
MODULE_API zclk_res zclk_command_exec(
    zclk_command *cmd,
    void *exec_args,
    int argc, char *argv[]);
 
MODULE_API void free_command(zclk_command* command);
 
MODULE_API char* get_help_for_command(arraylist* cmds_to_exec);
 
MODULE_API zclk_res help_cmd_handler(arraylist* commands, 
    void* handler_args, int argc, char** argv, 
    zclk_command_output_handler success_handler,
    zclk_command_output_handler error_handler);
 
MODULE_API zclk_res get_help_for(char** help_str, arraylist* commands,
    arraylist* arg_commands);
 
MODULE_API zclk_res exec_command(arraylist* commands, void* handler_args,
    int argc, char** argv);
 
MODULE_API void print_table_result(void* result);
 
MODULE_API zclk_res print_handler(zclk_res result_flag, 
    zclk_result_type res_type,
    void* result);
 
#ifdef __cplusplus 
}
#endif
 
#endif /* __ZCLK_H__ */