8164
|
1
|
|
2 #ifndef NEW_CONFIG
|
|
3 #warning "Including m_option.h but NEW_CONFIG is disabled"
|
|
4 #else
|
|
5
|
|
6 typedef struct m_option_type m_option_type_t;
|
|
7 typedef struct m_option m_option_t;
|
|
8
|
|
9 ///////////////////////////// Options types declarations ////////////////////////////
|
|
10
|
|
11 // Simple types
|
|
12 extern m_option_type_t m_option_type_flag;
|
|
13 extern m_option_type_t m_option_type_int;
|
|
14 extern m_option_type_t m_option_type_float;
|
|
15 extern m_option_type_t m_option_type_string;
|
|
16 extern m_option_type_t m_option_type_string_list;
|
|
17 extern m_option_type_t m_option_type_position;
|
|
18
|
|
19 extern m_option_type_t m_option_type_print;
|
|
20 extern m_option_type_t m_option_type_subconfig;
|
|
21 extern m_option_type_t m_option_type_imgfmt;
|
|
22
|
|
23 // Func based types
|
|
24 extern m_option_type_t m_option_type_func_full;
|
|
25 extern m_option_type_t m_option_type_func_param;
|
|
26 extern m_option_type_t m_option_type_func;
|
|
27
|
|
28 typedef void (*m_opt_default_func_t)(m_option_t *, char*);
|
|
29 typedef int (*m_opt_func_full_t)(m_option_t *, char *, char *);
|
|
30 typedef int (*m_opt_func_param_t)(m_option_t *, char *);
|
|
31 typedef int (*m_opt_func_t)(m_option_t *);
|
|
32 ///////////// Backward compat
|
|
33 typedef m_opt_default_func_t cfg_default_func_t;
|
|
34 typedef m_opt_func_full_t cfg_func_arg_param_t;
|
|
35 typedef m_opt_func_param_t cfg_func_param_t;
|
|
36 typedef m_opt_func_t cfg_func_t;
|
|
37
|
|
38 // Track/Chapter range
|
|
39 // accept range in the form 1[hh:mm:ss.zz]-5[hh:mm:ss.zz]
|
|
40 // ommited fields are assumed to be 0
|
|
41 // Not finished !!!!
|
|
42 typedef struct {
|
|
43 int idx; // in the e.g 1 or 5
|
|
44 unsigned int seconds; // hh:mm:ss converted in seconds
|
|
45 unsigned int sectors; // zz
|
|
46 } m_play_pos_t;
|
|
47
|
|
48 typedef struct {
|
|
49 m_play_pos_t start;
|
|
50 m_play_pos_t end;
|
|
51 } m_span_t;
|
|
52 extern m_option_type_t m_option_type_span;
|
|
53
|
|
54 // Don't be stupid keep tho old names ;-)
|
|
55 #define CONF_TYPE_FLAG (&m_option_type_flag)
|
|
56 #define CONF_TYPE_INT (&m_option_type_int)
|
|
57 #define CONF_TYPE_FLOAT (&m_option_type_float)
|
|
58 #define CONF_TYPE_STRING (&m_option_type_string)
|
|
59 #define CONF_TYPE_FUNC (&m_option_type_func)
|
|
60 #define CONF_TYPE_FUNC_PARAM (&m_option_type_func_param)
|
|
61 #define CONF_TYPE_PRINT (&m_option_type_print)
|
|
62 #define CONF_TYPE_FUNC_FULL (&m_option_type_func_full)
|
|
63 #define CONF_TYPE_SUBCONFIG (&m_option_type_subconfig)
|
|
64 #define CONF_TYPE_STRING_LIST (&m_option_type_string_list)
|
|
65 #define CONF_TYPE_POSITION (&m_option_type_position)
|
|
66 #define CONF_TYPE_IMGFMT (&m_option_type_imgfmt)
|
|
67 #define CONF_TYPE_SPAN (&m_option_type_span)
|
|
68
|
|
69
|
|
70 /////////////////////////////////////////////////////////////////////////////////////////////
|
|
71
|
|
72 struct m_option_type {
|
|
73 char* name;
|
|
74 char* comments; // syntax desc, etc
|
|
75 unsigned int size; // size needed for a save slot
|
|
76 unsigned int flags;
|
|
77
|
|
78 // parse is the only requiered function all others can be NULL
|
|
79 // If dst if non-NULL it should create/update the save slot
|
|
80 // If dst is NULL it should just test the validity of the arg if possible
|
|
81 // Src tell from where come this setting (ie cfg file, command line, playlist, ....
|
|
82 // It should return 1 if param was used, 0 if not.
|
|
83 // On error it must return 1 of the error code below
|
|
84 int (*parse)(m_option_t* opt,char *name, char *param, void* dst, int src);
|
|
85 // Print back a value in human form
|
|
86 char* (*print)(m_option_t* opt, void* val);
|
|
87
|
|
88 // These 3 will be a memcpy in 50% of the case, it's called to save/restore the status of
|
|
89 // the var it's there for complex type like CONF_TYPE_FUNC*
|
|
90 // update a save slot (dst) from the current value in the prog (src)
|
|
91 void (*save)(m_option_t* opt,void* dst, void* src);
|
|
92 // set the current value (dst) from a save slot
|
|
93 void (*set)(m_option_t* opt,void* dst, void* src);
|
|
94 // Copy betewen 2 slot (if NULL and size > 0 a memcpy will be used
|
|
95 void (*copy)(m_option_t* opt,void* dst, void* src);
|
|
96 // Free the data allocated for a save slot if needed
|
|
97 void (*free)(void* dst);
|
|
98 };
|
|
99
|
|
100 /// This is the same thing as a struct config it have been renamed
|
|
101 /// to remove this config_t, m_config_t mess. Sorry about that,
|
|
102 /// config_t is still provided for backward compat.
|
|
103 struct m_option {
|
|
104 char *name;
|
|
105 void *p;
|
|
106 m_option_type_t* type;
|
|
107 unsigned int flags;
|
|
108 float min,max;
|
|
109 // This used to be function pointer to hold a 'reverse to defaults' func.
|
|
110 // Nom it can be used to pass any type of extra args.
|
|
111 // Passing a 'default func' is still valid for all func based option types
|
|
112 void* priv; // Type dependent data (for all kind of extended setting)
|
|
113 };
|
|
114
|
|
115
|
|
116 //////////////////////////////// Option flags /////////////////////////////////
|
|
117
|
|
118 // Option flags
|
|
119 #define M_OPT_MIN (1<<0)
|
|
120 #define M_OPT_MAX (1<<1)
|
|
121 #define M_OPT_RANGE (M_OPT_MIN|M_OPT_MAX)
|
|
122 #define M_OPT_NOCFG (1<<2)
|
|
123 #define M_OPT_NOCMD (1<<3)
|
|
124 // This option is global : it won't be saved on push and the command
|
|
125 // line parser will set it when it's parsed (ie. it won't be set later)
|
|
126 // e.g options : -v, -quiet
|
|
127 #define M_OPT_GLOBAL (1<<4)
|
|
128 // Do not save this option : it won't be saved on push but the command
|
|
129 // line parser will put it with it's entry (ie : it may be set later)
|
|
130 // e.g options : -include
|
|
131 #define M_OPT_NOSAVE (1<<5)
|
|
132 // Emulate old behaviour by pushing the option only if it was set by the user
|
|
133 #define M_OPT_OLD (1<<6)
|
|
134
|
|
135
|
|
136 ///////////////////////////// Option type flags ///////////////////////////////////
|
|
137
|
|
138 // These flags are for the parsers. The description here apply to the m_config_t
|
|
139 // based parsers (ie. cmd line and config file parsers)
|
|
140 // Some parser will refuse option types that have some of these flags
|
|
141
|
|
142 // This flag is used for the subconfig
|
|
143 // When this flag is set, opt->p should point to another m_option_t array
|
|
144 // Only the parse function will be called. If dst is set, it should create/update
|
|
145 // an array of char* containg opt/val pairs.
|
|
146 // Then the options in the child array will then be set automaticly.
|
|
147 // You can only affect the way suboption are parsed.
|
|
148 // Also note that suboptions may be directly accessed by using -option:subopt blah :-)
|
|
149 #define M_OPT_TYPE_HAS_CHILD (1<<0)
|
|
150 // If this flag is set the option type support option name with * at the end (used for -aa*)
|
|
151 // This only affect the option name matching, the option type have to implement
|
|
152 // the needed stuff.
|
|
153 #define M_OPT_TYPE_ALLOW_WILDCARD (1<<1)
|
|
154 // This flag indicate that the data is dynamicly allocated (opt->p point to a pointer)
|
|
155 // It enable a little hack wich replace the initial value by a dynamic copy
|
|
156 // in case the initial value is staticly allocated (pretty common with strings)
|
|
157 #define M_OPT_TYPE_DYNAMIC (1<<2)
|
|
158 /// If this is set the parse function doesn't directly return
|
|
159 // the wanted thing. Options use this if for some reasons they have to wait
|
|
160 // until the set call to be able to correctly set the target var.
|
|
161 // So for those types you have to first parse and then set the target var
|
|
162 // If this flag isn't set you can parse directly to the target var
|
|
163 // It's used for the callback based option as the callback call may append
|
|
164 // later on.
|
|
165 #define M_OPT_TYPE_INDIRECT (1<<3)
|
|
166
|
|
167
|
|
168 ///////////////////////////// Parser flags ////////////////////////////////////////
|
|
169
|
|
170 // Config mode : some parser type behave differently depending
|
|
171 // on config->mode value wich is passed in the src param of parse()
|
|
172 #define M_CONFIG_FILE 0
|
|
173 #define M_COMMAND_LINE 1
|
|
174
|
|
175 // Option parser error code
|
|
176 #define M_OPT_UNKNOW -1
|
|
177 #define M_OPT_MISSING_PARAM -2
|
|
178 #define M_OPT_INVALID -3
|
|
179 #define M_OPT_OUT_OF_RANGE -4
|
|
180 #define M_OPT_PARSER_ERR -5
|
|
181
|
|
182
|
|
183 inline static int
|
|
184 m_option_parse(m_option_t* opt,char *name, char *param, void* dst, int src) {
|
|
185 return opt->type->parse(opt,name,param,dst,src);
|
|
186 }
|
|
187
|
|
188 inline static char*
|
|
189 m_option_print(m_option_t* opt, void* val_ptr) {
|
|
190 if(opt->type->print)
|
|
191 return opt->type->print(opt,val_ptr);
|
|
192 else
|
8168
|
193 return (char*)-1;
|
8164
|
194 }
|
|
195
|
|
196 inline static void
|
|
197 m_option_save(m_option_t* opt,void* dst, void* src) {
|
|
198 if(opt->type->save)
|
|
199 opt->type->save(opt,dst,src);
|
|
200 }
|
|
201
|
|
202 inline static void
|
|
203 m_option_set(m_option_t* opt,void* dst, void* src) {
|
|
204 if(opt->type->set)
|
|
205 opt->type->set(opt,dst,src);
|
|
206 }
|
|
207
|
|
208 inline static void
|
|
209 m_option_copy(m_option_t* opt,void* dst, void* src) {
|
|
210 if(opt->type->copy)
|
|
211 opt->type->set(opt,dst,src);
|
|
212 else if(opt->type->size > 0)
|
|
213 memcpy(dst,src,opt->type->size);
|
|
214 }
|
|
215
|
|
216 inline static void
|
|
217 m_option_free(m_option_t* opt,void* dst) {
|
|
218 if(opt->type->free)
|
|
219 opt->type->free(dst);
|
|
220 }
|
|
221
|
|
222 #endif
|