| /* |
| * Copyright (c) 2022 Samsung Electronics Co., Ltd. |
| * All Rights Reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * - Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * - Neither the name of the copyright owner, nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #ifndef _OAPV_APP_ARGS_H_ |
| #define _OAPV_APP_ARGS_H_ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "oapv.h" |
| |
| #define ARGS_VAL_TYPE_MANDATORY (1 << 0) /* mandatory or not */ |
| #define ARGS_VAL_TYPE_NONE (1 << 2) /* no value */ |
| #define ARGS_VAL_TYPE_INTEGER (2 << 2) /* integer type value */ |
| #define ARGS_VAL_TYPE_STRING (3 << 2) /* string type value */ |
| #define ARGS_GET_CMD_OPT_VAL_TYPE(x) ((x) & 0x0C) |
| #define ARGS_GET_IS_OPT_TYPE_PPT(x) (((x) >> 1) & 0x01) |
| |
| #define ARGS_END_KEY (0) |
| #define ARGS_NO_KEY (127) |
| #define ARGS_KEY_LONG_CONFIG "config" |
| #define ARGS_MAX_NUM_CONF_FILES (16) |
| |
| #define ARGS_MAX_KEY_LONG (32) |
| |
| typedef struct args_opt { |
| char key; /* option keyword. ex) -f */ |
| char key_long[ARGS_MAX_KEY_LONG]; /* option long keyword, ex) --file */ |
| int val_type; /* value type */ |
| int flag; /* flag to setting or not */ |
| void *val; /* actual value */ |
| char desc[512]; /* description of option */ |
| } args_opt_t; |
| |
| typedef struct args_parser args_parser_t; |
| struct args_parser { |
| void (*release)(args_parser_t *args); |
| int (*parse)(args_parser_t *args, int argc, const char *argv[], char **errstr); |
| int (*get_help)(args_parser_t *args, int idx, char *help); |
| int (*get_str)(args_parser_t *args, char *keyl, char *str, int *flag); |
| int (*get_int)(args_parser_t *args, char *keyl, int *val, int *flag); |
| int (*set_str)(args_parser_t *args, char *keyl, char *str); |
| int (*set_int)(args_parser_t *args, char *keyl, int val); |
| int (*set_flag)(args_parser_t *args, char *keyl, int flag); |
| int (*check_mandatory)(args_parser_t *args, char **err_arg); |
| |
| args_opt_t *opts; |
| int num_option; |
| }; |
| |
| static int args_search_long_key(args_opt_t *opts, const char *key) |
| { |
| args_opt_t *o; |
| int oidx = 0; |
| |
| o = opts; |
| while(o->key != ARGS_END_KEY) { |
| if(!strcmp(key, o->key_long)) { |
| return oidx; |
| } |
| oidx++; |
| o++; |
| } |
| return -1; |
| } |
| |
| static int args_search_short_arg(args_opt_t *ops, const char key) |
| { |
| args_opt_t *o; |
| int oidx = 0; |
| |
| o = ops; |
| |
| while(o->key != ARGS_END_KEY) { |
| if(o->key != ARGS_NO_KEY && o->key == key) { |
| return oidx; |
| } |
| oidx++; |
| o++; |
| } |
| return -1; |
| } |
| |
| static int args_read_value(args_opt_t *ops, const char *argv) |
| { |
| if(argv == NULL || ops->val == NULL) { |
| return -1; |
| } |
| if(argv[0] == '-' && (argv[1] < '0' || argv[1] > '9')) |
| return -1; |
| |
| switch(ARGS_GET_CMD_OPT_VAL_TYPE(ops->val_type)) { |
| case ARGS_VAL_TYPE_INTEGER: |
| *((int *)ops->val) = atoi(argv); |
| break; |
| |
| case ARGS_VAL_TYPE_STRING: |
| strcpy((char *)ops->val, argv); |
| break; |
| |
| default: |
| return -1; |
| } |
| return 0; |
| } |
| |
| static int args_get_arg(args_opt_t *ops, int idx, char *result) |
| { |
| char vtype[32]; |
| char value[512]; |
| args_opt_t *o = ops + idx; |
| |
| switch(ARGS_GET_CMD_OPT_VAL_TYPE(o->val_type)) { |
| case ARGS_VAL_TYPE_INTEGER: |
| strncpy(vtype, "INTEGER", sizeof(vtype) - 1); |
| sprintf(value, "%d", *((int *)o->val)); |
| break; |
| |
| case ARGS_VAL_TYPE_STRING: |
| strncpy(vtype, "STRING", sizeof(vtype) - 1); |
| sprintf(value, "%s", (char *)o->val); |
| break; |
| |
| case ARGS_VAL_TYPE_NONE: |
| default: |
| strncpy(vtype, "FLAG", sizeof(vtype) - 1); |
| sprintf(value, "%d", *((int *)o->val)); |
| break; |
| } |
| |
| if(o->flag) { |
| strcat(value, " (SET)"); |
| } |
| else { |
| strcat(value, " (DEFAULT)"); |
| } |
| |
| sprintf(result, " -%c(--%s) = %s\n : %s", o->key, o->key_long, |
| value, o->desc); |
| |
| return 0; |
| } |
| |
| static int args_parse_int_x_int(char *str, int *num0, int *num1) |
| { |
| char str0_t[64]; |
| int i, cnt0 = 0, cnt1; |
| char *str0, *str1 = NULL; |
| |
| str0 = str; |
| cnt1 = (int)strlen(str); |
| |
| /* find 'x' */ |
| for(i = 0; i < (int)strlen(str); i++) { |
| if(str[i] == 'x' || str[i] == 'X') { |
| str1 = str + i + 1; |
| cnt0 = i; |
| cnt1 = cnt1 - cnt0 - 1; |
| break; |
| } |
| } |
| |
| /* check malformed data */ |
| if(str1 == NULL || cnt0 == 0 || cnt1 == 0) |
| return -1; |
| |
| for(i = 0; i < cnt0; i++) { |
| if(str0[i] < 0x30 || str0[i] > 0x39) |
| return -1; /* not a number */ |
| } |
| for(i = 0; i < cnt1; i++) { |
| if(str1[i] < 0x30 || str1[i] > 0x39) |
| return -1; /* not a number */ |
| } |
| |
| strncpy(str0_t, str0, cnt0); |
| str0_t[cnt0] = '\0'; |
| |
| *num0 = atoi(str0_t); |
| *num1 = atoi(str1); |
| |
| return 0; |
| } |
| |
| static int args_parse_cfg(FILE *fp, args_opt_t *ops, int is_type_ppt) |
| { |
| char *parser; |
| char line[256] = "", tag[50] = "", val[256] = ""; |
| int oidx; |
| |
| while(fgets(line, sizeof(line), fp)) { |
| parser = strchr(line, '#'); |
| if(parser != NULL) |
| *parser = '\0'; |
| |
| parser = strtok(line, "= \t"); |
| if(parser == NULL) |
| continue; |
| strncpy(tag, parser, sizeof(tag) - 1); |
| |
| parser = strtok(NULL, "=\n"); |
| if(parser == NULL) |
| continue; |
| strncpy(val, parser, sizeof(val) - 1); |
| |
| oidx = args_search_long_key(ops, tag); |
| if(oidx < 0) |
| continue; |
| |
| if(ops[oidx].val == NULL) { |
| return -1; |
| } |
| |
| if(ARGS_GET_IS_OPT_TYPE_PPT(ops[oidx].val_type) == is_type_ppt) { |
| if(ARGS_GET_CMD_OPT_VAL_TYPE(ops[oidx].val_type) != ARGS_VAL_TYPE_NONE) { |
| if(args_read_value(ops + oidx, val)) |
| continue; |
| } |
| else { |
| *((int *)ops[oidx].val) = 1; |
| } |
| ops[oidx].flag = 1; |
| } |
| } |
| return 0; |
| } |
| |
| static int args_parse_cmd(int argc, const char *argv[], args_opt_t *ops, |
| int *idx, char **errstr) |
| { |
| int aidx; /* arg index */ |
| int oidx; /* option index */ |
| |
| aidx = *idx + 1; |
| |
| if(aidx >= argc || argv[aidx] == NULL) |
| goto NO_MORE; |
| if(argv[aidx][0] != '-') |
| goto ERR; |
| |
| if(argv[aidx][1] == '-') { |
| /* long option */ |
| oidx = args_search_long_key(ops, argv[aidx] + 2); |
| if(oidx < 0) { |
| *errstr = (char *)argv[aidx]; |
| goto ERR; |
| } |
| } |
| else if(strlen(argv[aidx]) == 2) { |
| /* short option */ |
| oidx = args_search_short_arg(ops, argv[aidx][1]); |
| if(oidx < 0) { |
| *errstr = (char *)argv[aidx]; |
| goto ERR; |
| } |
| } |
| else { |
| goto ERR; |
| } |
| |
| if(ARGS_GET_CMD_OPT_VAL_TYPE(ops[oidx].val_type) != |
| ARGS_VAL_TYPE_NONE) { |
| if(aidx + 1 >= argc) { |
| *errstr = (char *)argv[aidx]; |
| goto ERR; |
| } |
| if(args_read_value(ops + oidx, argv[aidx + 1])) { |
| *errstr = (char *)argv[aidx]; |
| goto ERR; |
| } |
| *idx = *idx + 1; |
| } |
| else { |
| *((int *)ops[oidx].val) = 1; |
| } |
| ops[oidx].flag = 1; |
| *idx = *idx + 1; |
| |
| return ops[oidx].key; |
| |
| NO_MORE: |
| return 0; |
| |
| ERR: |
| return -1; |
| } |
| |
| static int args_set_variable_by_key_long(args_opt_t *opts, char *key_long, void *var) |
| { |
| int idx; |
| char buf[ARGS_MAX_KEY_LONG]; |
| char *ko = key_long; |
| char *kt = buf; |
| |
| /* if long key has "_", convert to "-". */ |
| while(*ko != '\0') { |
| if(*ko == '_') |
| *kt = '-'; |
| else |
| *kt = *ko; |
| |
| ko++; |
| kt++; |
| } |
| *kt = '\0'; |
| |
| idx = args_search_long_key(opts, buf); |
| if(idx < 0) |
| return -1; |
| opts[idx].val = var; |
| return 0; |
| } |
| |
| static int args_set_variable_by_key(args_opt_t *opts, char *key, void *var) |
| { |
| int idx; |
| idx = args_search_short_arg(opts, key[0]); |
| if(idx < 0) |
| return -1; |
| opts[idx].val = var; |
| return 0; |
| } |
| |
| #define ARGS_SET_PARAM_VAR_KEY_LONG(opts, param, key_long) \ |
| args_set_variable_by_key_long(opts, #key_long, (void *)&((param)->key_long)) |
| |
| #define ARGS_SET_PARAM_VAR_KEY(opts, param, key) \ |
| args_set_variable_by_key(opts, #key, (void *)&((param)->key)) |
| |
| static int args_get(args_parser_t *args, char *keyl, void **val, int *flag) |
| { |
| int idx; |
| |
| idx = args_search_long_key(args->opts, keyl); |
| if(idx >= 0) { |
| if(val) |
| *val = args->opts[idx].val; |
| if(flag) |
| *flag = args->opts[idx].flag; |
| return 0; |
| } |
| else { |
| if(val) |
| *val = NULL; /* no value */ |
| if(flag) |
| *flag = 0; /* no set */ |
| return -1; |
| } |
| } |
| |
| static int args_set_str(args_parser_t *args, char *keyl, char *str) |
| { |
| int idx; |
| |
| idx = args_search_long_key(args->opts, keyl); |
| if(idx >= 0) { |
| sprintf((char *)(args->opts[idx].val), "%s", str); |
| args->opts[idx].flag = 1; |
| return 0; |
| } |
| else { |
| return -1; |
| } |
| } |
| |
| static int args_set_int(args_parser_t *args, char *keyl, int val) |
| { |
| int idx; |
| |
| idx = args_search_long_key(args->opts, keyl); |
| if(idx >= 0) { |
| *((int *)(args->opts[idx].val)) = val; |
| args->opts[idx].flag = 1; |
| return 0; |
| } |
| else { |
| return -1; |
| } |
| } |
| |
| static int args_set_flag(args_parser_t *args, char *keyl, int flag) |
| { |
| int idx; |
| |
| idx = args_search_long_key(args->opts, keyl); |
| if(idx >= 0) { |
| args->opts[idx].flag = flag; |
| return 0; |
| } |
| return -1; |
| } |
| |
| static int args_get_str(args_parser_t *args, char *keyl, char *str, int *flag) |
| { |
| char *p = NULL; |
| if(args_get(args, keyl, (void **)&p, flag)) |
| return -1; |
| if(p) { |
| if(str) |
| strcpy(str, p); |
| } |
| return 0; |
| } |
| |
| static int args_get_int(args_parser_t *args, char *keyl, int *val, int *flag) |
| { |
| int *p = NULL; |
| if(args_get(args, keyl, (void **)&p, flag)) |
| return -1; |
| if(p) { |
| *val = *p; |
| } |
| return 0; |
| } |
| |
| static int args_parse(args_parser_t *args, int argc, const char *argv[], |
| char **errstr) |
| { |
| int i, ret = 0, idx = 0; |
| const char *fname_cfg = NULL; |
| FILE *fp; |
| |
| int num_configs = 0; |
| int pos_conf_files[ARGS_MAX_NUM_CONF_FILES]; |
| memset(&pos_conf_files, -1, sizeof(int) * ARGS_MAX_NUM_CONF_FILES); |
| |
| /* config file parsing */ |
| for(i = 1; i < argc; i++) { |
| if(!strcmp(argv[i], "--" ARGS_KEY_LONG_CONFIG)) { |
| if(i + 1 < argc) { |
| num_configs++; |
| pos_conf_files[num_configs - 1] = i + 1; |
| } |
| } |
| } |
| for(int i = 0; i < num_configs; i++) { |
| fname_cfg = argv[pos_conf_files[i]]; |
| if(fname_cfg) { |
| fp = fopen(fname_cfg, "r"); |
| if(fp == NULL) |
| return -1; /* config file error */ |
| |
| if(args_parse_cfg(fp, args->opts, 1)) { |
| fclose(fp); |
| return -1; /* config file error */ |
| } |
| fclose(fp); |
| } |
| } |
| /* command line parsing */ |
| while(1) { |
| ret = args_parse_cmd(argc, argv, args->opts, &idx, errstr); |
| if(ret <= 0) |
| break; |
| } |
| return ret; |
| } |
| |
| static int args_get_help(args_parser_t *args, int idx, char *help) |
| { |
| int optional; |
| char vtype[32]; |
| args_opt_t *o = args->opts + idx; |
| char default_value[256] = { 0 }; |
| |
| switch(ARGS_GET_CMD_OPT_VAL_TYPE(o->val_type)) { |
| case ARGS_VAL_TYPE_INTEGER: |
| strncpy(vtype, "INTEGER", sizeof(vtype) - 1); |
| if(o->val != NULL) |
| sprintf(default_value, " [%d]", *(int *)(o->val)); |
| break; |
| case ARGS_VAL_TYPE_STRING: |
| strncpy(vtype, "STRING", sizeof(vtype) - 1); |
| if(o->val != NULL) |
| sprintf(default_value, " [%s]", strlen((char *)(o->val)) == 0 ? "None" : (char *)(o->val)); |
| break; |
| case ARGS_VAL_TYPE_NONE: |
| default: |
| strncpy(vtype, "FLAG", sizeof(vtype) - 1); |
| if(o->val != NULL) |
| sprintf(default_value, " [%s]", *(int *)(o->val) ? "On" : "Off"); |
| break; |
| } |
| optional = !(o->val_type & ARGS_VAL_TYPE_MANDATORY); |
| |
| if(o->key != ARGS_NO_KEY) { |
| sprintf(help, " -%c, --%s [%s]%s%s\n : %s", o->key, o->key_long, |
| vtype, (optional) ? " (optional)" : "", (optional) ? default_value : "", o->desc); |
| } |
| else { |
| sprintf(help, " --%s [%s]%s%s\n : %s", o->key_long, |
| vtype, (optional) ? " (optional)" : "", (optional) ? default_value : "", o->desc); |
| } |
| |
| return 0; |
| } |
| |
| static int args_check_mandatory(args_parser_t *args, char **err_arg) |
| { |
| args_opt_t *o = args->opts; |
| |
| while(o->key != 0) { |
| if(o->val_type & ARGS_VAL_TYPE_MANDATORY) { |
| if(o->flag == 0) { |
| /* not filled all mandatory argument */ |
| *err_arg = o->key_long; |
| return -1; |
| } |
| } |
| o++; |
| } |
| return 0; |
| } |
| |
| static void args_release(args_parser_t *args) |
| { |
| if(args != NULL) { |
| if(args->opts != NULL) |
| free(args->opts); |
| free(args); |
| } |
| } |
| |
| static args_parser_t *args_create(const args_opt_t *opt_table, int num_opt) |
| { |
| args_parser_t *args = NULL; |
| args_opt_t *opts = NULL; |
| |
| args = (args_parser_t *)malloc(sizeof(args_parser_t)); |
| if(args == NULL) |
| goto ERR; |
| memset(args, 0, sizeof(args_parser_t)); |
| |
| opts = (args_opt_t *)malloc(num_opt * sizeof(args_opt_t)); |
| if(opts == NULL) |
| goto ERR; |
| memcpy(opts, opt_table, num_opt * sizeof(args_opt_t)); |
| args->opts = opts; |
| |
| args->release = args_release; |
| args->parse = args_parse; |
| args->get_help = args_get_help; |
| args->get_str = args_get_str; |
| args->get_int = args_get_int; |
| args->set_str = args_set_str; |
| args->set_int = args_set_int; |
| args->set_flag = args_set_flag; |
| args->check_mandatory = args_check_mandatory; |
| |
| /* find actual number of options */ |
| args->num_option = 0; |
| while(opt_table[args->num_option].key != ARGS_END_KEY) |
| args->num_option++; |
| |
| return args; |
| |
| ERR: |
| free(opts); |
| free(args); |
| return NULL; |
| } |
| |
| #endif /*_OAPV_APP_ARGS_H_ */ |
