5 /// m_option allows to parse, print and copy data of various types.
6 /// It is the base of the \ref OptionsStruct, \ref Config and
7 /// \ref Properties APIs.
12 /// \ingroup OptionTypes
13 typedef struct m_option_type m_option_type_t
;
14 typedef struct m_option m_option_t
;
17 /// \defgroup OptionTypes Options types
21 ///////////////////////////// Options types declarations ////////////////////////////
24 extern m_option_type_t m_option_type_flag
;
25 extern m_option_type_t m_option_type_int
;
26 extern m_option_type_t m_option_type_float
;
27 extern m_option_type_t m_option_type_double
;
28 extern m_option_type_t m_option_type_string
;
29 extern m_option_type_t m_option_type_string_list
;
30 extern m_option_type_t m_option_type_position
;
31 extern m_option_type_t m_option_type_time_size
;
33 extern m_option_type_t m_option_type_print
;
34 extern m_option_type_t m_option_type_print_indirect
;
35 extern m_option_type_t m_option_type_print_func
;
36 extern m_option_type_t m_option_type_subconfig
;
37 extern m_option_type_t m_option_type_imgfmt
;
38 extern m_option_type_t m_option_type_afmt
;
41 extern m_option_type_t m_option_type_func_full
;
42 extern m_option_type_t m_option_type_func_param
;
43 extern m_option_type_t m_option_type_func
;
45 /// Callback used to reset func options.
46 typedef void (*m_opt_default_func_t
)(m_option_t
*, char*);
48 /// Callback used by m_option_type_func_full options.
49 typedef int (*m_opt_func_full_t
)(m_option_t
*, char *, char *);
51 /// Callback used by m_option_type_func_param options.
52 typedef int (*m_opt_func_param_t
)(m_option_t
*, char *);
54 /// Callback used by m_option_type_func options.
55 typedef int (*m_opt_func_t
)(m_option_t
*);
57 // Backwards compatibility
58 typedef m_opt_default_func_t cfg_default_func_t
;
59 typedef m_opt_func_full_t cfg_func_arg_param_t
;
60 typedef m_opt_func_param_t cfg_func_param_t
;
61 typedef m_opt_func_t cfg_func_t
;
71 /// Extra definition needed for \ref m_option_type_obj_settings_list options.
73 /// Pointer to an array of pointer to some object type description struct.
75 /// Offset of the object type name (char*) in the description struct.
77 /// Offset of the object type info string (char*) in the description struct.
79 /// \brief Offset of the object type parameter description (\ref m_struct_st)
80 /// in the description struct.
84 /// The data type used by \ref m_option_type_obj_settings_list.
85 typedef struct m_obj_settings
{
86 /// Type of the object.
88 /// NULL terminated array of parameter/value pairs.
92 /// A parser to set up a list of objects.
93 /** It creates a NULL terminated array \ref m_obj_settings. The option priv
94 * field (\ref m_option::priv) must point to a \ref m_obj_list_t describing
95 * the available object types.
97 extern m_option_type_t m_option_type_obj_settings_list
;
99 /// Extra definition needed for \ref m_option_type_obj_presets options.
101 /// Description of the struct holding the presets.
102 struct m_struct_st
* in_desc
;
103 /// Description of the struct that should be set by the presets.
104 struct m_struct_st
* out_desc
;
105 /// Pointer to an array of structs defining the various presets.
107 /// Offset of the preset's name inside the in_struct.
111 /// Set several fields in a struct at once.
112 /** For this two struct descriptions are used. One for the struct holding the
113 * preset and one for the struct beeing set. Every field present in both
114 * structs will be copied from the preset struct to the destination one.
115 * The option priv field (\ref m_option::priv) must point to a correctly
116 * filled \ref m_obj_presets_t.
118 extern m_option_type_t m_option_type_obj_presets
;
120 /// Parse an URL into a struct.
121 /** The option priv field (\ref m_option::priv) must point to a
122 * \ref m_struct_st describing which fields of the URL must be used.
124 extern m_option_type_t m_option_type_custom_url
;
126 /// Extra definition needed for \ref m_option_type_obj_params options.
128 /// Field descriptions.
129 struct m_struct_st
* desc
;
130 /// Field separator to use.
134 /// Parse a set of parameters.
135 /** Parameters are separated by the given separator and each one
136 * successively sets a field from the struct. The option priv field
137 * (\ref m_option::priv) must point to a \ref m_obj_params_t.
139 extern m_option_type_t m_option_type_obj_params
;
145 /// Ready made settings to parse a \ref m_span_t with a start-end syntax.
146 extern m_obj_params_t m_span_params_def
;
149 // FIXME: backward compatibility
150 #define CONF_TYPE_FLAG (&m_option_type_flag)
151 #define CONF_TYPE_INT (&m_option_type_int)
152 #define CONF_TYPE_FLOAT (&m_option_type_float)
153 #define CONF_TYPE_DOUBLE (&m_option_type_double)
154 #define CONF_TYPE_STRING (&m_option_type_string)
155 #define CONF_TYPE_FUNC (&m_option_type_func)
156 #define CONF_TYPE_FUNC_PARAM (&m_option_type_func_param)
157 #define CONF_TYPE_PRINT (&m_option_type_print)
158 #define CONF_TYPE_PRINT_INDIRECT (&m_option_type_print_indirect)
159 #define CONF_TYPE_PRINT_FUNC (&m_option_type_print_func)
160 #define CONF_TYPE_FUNC_FULL (&m_option_type_func_full)
161 #define CONF_TYPE_SUBCONFIG (&m_option_type_subconfig)
162 #define CONF_TYPE_STRING_LIST (&m_option_type_string_list)
163 #define CONF_TYPE_POSITION (&m_option_type_position)
164 #define CONF_TYPE_IMGFMT (&m_option_type_imgfmt)
165 #define CONF_TYPE_AFMT (&m_option_type_afmt)
166 #define CONF_TYPE_SPAN (&m_option_type_span)
167 #define CONF_TYPE_OBJ_SETTINGS_LIST (&m_option_type_obj_settings_list)
168 #define CONF_TYPE_OBJ_PRESETS (&m_option_type_obj_presets)
169 #define CONF_TYPE_CUSTOM_URL (&m_option_type_custom_url)
170 #define CONF_TYPE_OBJ_PARAMS (&m_option_type_obj_params)
171 #define CONF_TYPE_TIME_SIZE (&m_option_type_time_size)
173 /////////////////////////////////////////////////////////////////////////////////////////////
175 /// Option type description
176 struct m_option_type
{
178 /// Syntax description, etc
180 /// Size needed for the data.
182 /// See \ref OptionTypeFlags.
185 /// Parse the data from a string.
186 /** It is the only required function, all others can be NULL.
188 * \param opt The option that is parsed.
189 * \param name The full option name.
190 * \param param The parameter to parse.
191 * \param dst Pointer to the memory where the data should be written.
192 * If NULL the parameter validity should still be checked.
193 * \param src Source of the option, see \ref OptionParserModes.
194 * \return On error a negative value is returned, on success the number of arguments
195 * consumed. For details see \ref OptionParserReturn.
197 int (*parse
)(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
);
199 /// Print back a value in string form.
200 /** \param opt The option to print.
201 * \param val Pointer to the memory holding the data to be printed.
202 * \return An allocated string containing the text value or (void*)-1
205 char* (*print
)(m_option_t
* opt
, void* val
);
208 * These functions are called to save/set/restore the status of the
209 * variables. The difference between the 3 only matters for types like
210 * \ref m_option_type_func where 'setting' needs to do more than just
215 /// Update a save slot (dst) from the current value in the program (src).
216 /** \param opt The option to copy.
217 * \param dst Pointer to the destination memory.
218 * \param src Pointer to the source memory.
220 void (*save
)(m_option_t
* opt
,void* dst
, void* src
);
222 /// Set the value in the program (dst) from a save slot.
223 /** \param opt The option to copy.
224 * \param dst Pointer to the destination memory.
225 * \param src Pointer to the source memory.
227 void (*set
)(m_option_t
* opt
,void* dst
, void* src
);
229 /// Copy the data between two save slots. If NULL and size is > 0 a memcpy will be used.
230 /** \param opt The option to copy.
231 * \param dst Pointer to the destination memory.
232 * \param src Pointer to the source memory.
234 void (*copy
)(m_option_t
* opt
,void* dst
, void* src
);
237 /// Free the data allocated for a save slot.
238 /** This is only needed for dynamic types like strings.
239 * \param dst Pointer to the data, usually a pointer that should be freed and
242 void (*free
)(void* dst
);
247 /// Option description
254 /// Reserved for higher level APIs, it shouldn't be used by parsers.
255 /** The suboption parser and func types do use it. They should instead
256 * use the priv field but this was inherited from older versions of the
262 m_option_type_t
* type
;
264 /// See \ref OptionFlags.
267 /// \brief Mostly useful for numeric types, the \ref M_OPT_MIN flags must
271 /// \brief Mostly useful for numeric types, the \ref M_OPT_MAX flags must
275 /// Type dependent data (for all kinds of extended settings).
276 /** This used to be a function pointer to hold a 'reverse to defaults' func.
277 * Now it can be used to pass any type of extra args needed by the parser.
278 * Passing a 'default func' is still valid for all func based option types.
284 /// \defgroup OptionFlags Option flags
287 /// The option has a minimum set in \ref m_option::min.
288 #define M_OPT_MIN (1<<0)
290 /// The option has a maximum set in \ref m_option::max.
291 #define M_OPT_MAX (1<<1)
293 /// The option has a minimum and maximum in \ref m_option::min and \ref m_option::max.
294 #define M_OPT_RANGE (M_OPT_MIN|M_OPT_MAX)
296 /// The option is forbidden in config files.
297 #define M_OPT_NOCFG (1<<2)
299 /// The option is forbidden on the command line.
300 #define M_OPT_NOCMD (1<<3)
302 /// The option is global in the \ref Config.
303 /** It won't be saved on push and the command line parser will set it when
304 * it's parsed (i.e. it won't be set later)
305 * e.g options : -v, -quiet
307 #define M_OPT_GLOBAL (1<<4)
309 /// The \ref Config won't save this option on push.
310 /** It won't be saved on push but the command line parser will add it with
311 * its entry (i.e. it may be set later)
312 * e.g options : -include
314 #define M_OPT_NOSAVE (1<<5)
316 /// \brief The \ref Config will emulate the old behavior by pushing the
317 /// option only if it was set by the user.
318 #define M_OPT_OLD (1<<6)
320 /// \defgroup OldOptionFlags Backward compatibility
322 /// These are kept for compatibility with older code.
324 #define CONF_MIN M_OPT_MIN
325 #define CONF_MAX M_OPT_MAX
326 #define CONF_RANGE M_OPT_RANGE
327 #define CONF_NOCFG M_OPT_NOCFG
328 #define CONF_NOCMD M_OPT_NOCMD
329 #define CONF_GLOBAL M_OPT_GLOBAL
330 #define CONF_NOSAVE M_OPT_NOSAVE
331 #define CONF_OLD M_OPT_OLD
336 /// \defgroup OptionTypeFlags Option type flags
337 /// \ingroup OptionTypes
339 /// These flags are used to describe special parser capabilities or behavior.
343 /// Suboption parser flag.
344 /** When this flag is set, m_option::p should point to another m_option
345 * array. Only the parse function will be called. If dst is set, it should
346 * create/update an array of char* containg opt/val pairs. The options in
347 * the child array will then be set automatically by the \ref Config.
348 * Also note that suboptions may be directly accessed by using
349 * -option:subopt blah.
351 #define M_OPT_TYPE_HAS_CHILD (1<<0)
353 /// Wildcard matching flag.
354 /** If set the option type has a use for option names ending with a *
355 * (used for -aa*), this only affects the option name matching.
357 #define M_OPT_TYPE_ALLOW_WILDCARD (1<<1)
359 /// Dynamic data type.
360 /** This flag indicates that the data is dynamically allocated (m_option::p
361 * points to a pointer). It enables a little hack in the \ref Config wich
362 * replaces the initial value of such variables with a dynamic copy in case
363 * the initial value is statically allocated (pretty common with strings).
365 #define M_OPT_TYPE_DYNAMIC (1<<2)
367 /// Indirect option type.
368 /** If this is set the parse function doesn't directly return
369 * the wanted thing. Options use this if for some reasons they have to wait
370 * until the set call to be able to correctly set the target var.
371 * So for those types new values must first be parsed, then set to the target
372 * var. If this flag isn't set then new values can be parsed directly to the
373 * target var. It's used by the callback-based options as the callback call
374 * may append later on.
376 #define M_OPT_TYPE_INDIRECT (1<<3)
380 ///////////////////////////// Parser flags ////////////////////////////////////////
382 /// \defgroup OptionParserModes Option parser modes
385 /// Some parsers behave differently depending on the mode passed in the src
386 /// parameter of m_option_type::parse. For example the flag type doesn't take
387 /// an argument when parsing from the command line.
390 /// Set when parsing from a config file.
391 #define M_CONFIG_FILE 0
392 /// Set when parsing command line arguments.
393 #define M_COMMAND_LINE 1
397 /// \defgroup OptionParserReturn Option parser return code
400 /// On success parsers return the number of arguments consumed: 0 or 1.
402 /// To indicate that MPlayer should exit without playing anything,
403 /// parsers return M_OPT_EXIT minus the number of parameters they
404 /// consumed: \ref M_OPT_EXIT or \ref M_OPT_EXIT-1.
406 /// On error one of the following (negative) error codes is returned:
409 /// For use by higher level APIs when the option name is invalid.
410 #define M_OPT_UNKNOWN -1
412 /// Returned when a parameter is needed but wasn't provided.
413 #define M_OPT_MISSING_PARAM -2
415 /// Returned when the given parameter couldn't be parsed.
416 #define M_OPT_INVALID -3
418 /// \brief Returned if the value is "out of range". The exact meaning may
419 /// vary from type to type.
420 #define M_OPT_OUT_OF_RANGE -4
422 /// Returned if the parser failed for any other reason than a bad parameter.
423 #define M_OPT_PARSER_ERR -5
425 /// Returned when MPlayer should exit. Used by various help stuff.
426 /** M_OPT_EXIT must be the lowest number on this list.
428 #define M_OPT_EXIT -6
430 /// \defgroup OldOptionParserReturn Backward compatibility
432 /// These are kept for compatibility with older code.
435 #define ERR_NOT_AN_OPTION M_OPT_UNKNOWN
436 #define ERR_MISSING_PARAM M_OPT_MISSING_PARAM
437 #define ERR_OUT_OF_RANGE M_OPT_OUT_OF_RANGE
438 #define ERR_FUNC_ERR M_OPT_PARSER_ERR
443 /// Find the option matching the given name in the list.
445 * This function takes the possible wildcards into account (see
446 * \ref M_OPT_TYPE_ALLOW_WILDCARD).
448 * \param list Pointer to an array of \ref m_option.
449 * \param name Name of the option.
450 * \return The matching option or NULL.
452 m_option_t
* m_option_list_find(m_option_t
* list
,const char* name
);
454 /// Helper to parse options, see \ref m_option_type::parse.
456 m_option_parse(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
457 return opt
->type
->parse(opt
,name
,param
,dst
,src
);
460 /// Helper to print options, see \ref m_option_type::print.
462 m_option_print(m_option_t
* opt
, void* val_ptr
) {
464 return opt
->type
->print(opt
,val_ptr
);
469 /// Helper around \ref m_option_type::save.
471 m_option_save(m_option_t
* opt
,void* dst
, void* src
) {
473 opt
->type
->save(opt
,dst
,src
);
476 /// Helper around \ref m_option_type::set.
478 m_option_set(m_option_t
* opt
,void* dst
, void* src
) {
480 opt
->type
->set(opt
,dst
,src
);
483 /// Helper around \ref m_option_type::copy.
485 m_option_copy(m_option_t
* opt
,void* dst
, void* src
) {
487 opt
->type
->copy(opt
,dst
,src
);
488 else if(opt
->type
->size
> 0)
489 memcpy(dst
,src
,opt
->type
->size
);
492 /// Helper around \ref m_option_type::free.
494 m_option_free(m_option_t
* opt
,void* dst
) {
496 opt
->type
->free(dst
);
501 #endif /* _M_OPTION_H */