ODL Parser

Collaboration diagram for ODL Parser:

Modules
	ODL Parser Configuration Options
	Connection management
	ODL Parser MIBS

Data Structures
struct	_amxo_parser
	The ODL parser structure. More...

Functions
const char *	amxo_lib_version (void)
	Returns the version of lib amxo. More...
int	amxo_parser_init (amxo_parser_t *parser)
	Initializes a new odl parser instance. More...
void	amxo_parser_clean (amxo_parser_t *parser)
	Cleans up the odl parser instance. More...
int	amxo_parser_new (amxo_parser_t **parser)
	Allocates memory for a new parser instance on the heap and initializes the odl parser. More...
void	amxo_parser_delete (amxo_parser_t **parser)
	Cleans the odl parser content and frees the allocated memory. More...
int	amxo_parser_parse_fd (amxo_parser_t *parser, int fd, amxd_object_t *object)
	Parses an odl file. More...
int	amxo_parser_parse_file (amxo_parser_t *parser, const char *file_path, amxd_object_t *object)
	Parses an odl file. More...
int	amxo_parser_parse_string (amxo_parser_t *parser, const char *text, amxd_object_t *object)
	Parses a string containing a valid ODL part. More...
static amxd_status_t	amxo_parser_get_status (amxo_parser_t *parser)
	Get the status of the odl parser. More...
static const char *	amxo_parser_get_message (amxo_parser_t *parser)
	Get the failure message in human readable form. More...
static const char *	amxo_parser_get_file (amxo_parser_t *parser)
	Get the current file name that is being parsed. More...
static uint32_t	amxo_parser_get_line (amxo_parser_t *parser)
	Get the current line number that is being parsed. More...
int	amxo_parser_add_entry_point (amxo_parser_t *parser, amxo_entry_point_t fn)
	Adds an entry point function. More...
int	amxo_parser_invoke_entry_points (amxo_parser_t *parser, amxd_dm_t *dm, int reason)
	Invokes all registered entry points. More...
int	amxo_parser_rinvoke_entry_points (amxo_parser_t *parser, amxd_dm_t *dm, int reason)
	Invokes all registered entry points in reversed order. More...
int	amxo_parser_start_synchronize (amxo_parser_t *parser)
	Start all object and parameter synchronizations that were declared in the loaded odl files. More...
void	amxo_parser_stop_synchronize (amxo_parser_t *parser)
	Stop all object and parameter synchronizations that were declared in odl files. More...
amxs_sync_ctx_t *	amxo_parser_new_sync_ctx (const char *sync_template, const char *object_a, const char *object_b)
	Create a new synchronization context from a synchronization template. More...
amxc_llist_t *	amxo_parser_get_connections (amxo_parser_t *parser)
	Get a list of the current connections of the application. More...
amxc_llist_t *	amxo_parser_get_listeners (amxo_parser_t *parser)
	Get of the current listen sockets of the application. More...

Detailed Description

Ambiorix ODL parser API

Defining a data model pure in code is not a pleasant job and very repititive. Using an ODL file makes this job a lot easier.

The odl parser will read the file and create the data model as described in that file. The parser can resolve data model function using function resolvers, see Function resolvers

Function Documentation

amxo_lib_version()

const char* amxo_lib_version

(

void

)

Returns the version of lib amxo.

Returns the version of lib amxo in string format X.Y.Z, where X is the major, Y is the minor and Z is the build number.

Returns

a zero terminated string

Definition at line 58 of file amxo_version.c.

                                   {
    return AMXO_VERSION;
}

amxo_parser_add_entry_point()

int amxo_parser_add_entry_point	(	amxo_parser_t *	parser,
		amxo_entry_point_t	fn
	)

Adds an entry point function.

The parser itself will not call entry points, but will add entry-points if defined in the odl.

Any application or library can add extra entry points to the parser.

It is up to the application or library that initiates the odl parsing to invoke the entry points, see amxo_parser_invoke_entry_points

Entry point functions must comply with the following signature:

typedef int (*amxo_entry_point_t) (int reason,
                                   amxd_dm_t *dm,
                                   amxo_parser_t *parser);

Parameters

parser	the odl parser instance
fn	a valid function pointer (can not be NULL)

Returns

Returns 0 when success, any other value indicates failure.

Definition at line 459 of file amxo_parser_main.c.

                                                       {
    int retval = -1;
    amxo_entry_t* ep = NULL;
    when_null(parser, exit);
    when_null(fn, exit);
 
    if(parser->entry_points == NULL) {
        retval = amxc_llist_new(&parser->entry_points);
        when_null(parser->entry_points, exit);
    }
 
    amxc_llist_for_each(it, parser->entry_points) {
        ep = amxc_llist_it_get_data(it, amxo_entry_t, it);
        if(ep->entry_point == fn) {
            retval = 0;
            goto exit;
        }
    }
 
    ep = (amxo_entry_t*) calloc(1, sizeof(amxo_entry_t));
    when_null(ep, exit);
 
    ep->entry_point = fn;
    amxc_llist_append(parser->entry_points, &ep->it);
    retval = 0;
 
exit:
    if(retval != 0) {
        free(ep);
    }
    return retval;
}

amxo_parser_clean()

void amxo_parser_clean

(

amxo_parser_t *

parser

)

Cleans up the odl parser instance.

When done parsing odl files, the parser content must be cleaned.

Note

Failing to clean the odl parser content could lead to memory leaks.

int load_data_model(amxd_dm_t *dm) {
    int retval = 0;
    amxo_parser_t parser;
    amxd_object_t *root = amxd_dm_get_root(dm);
 
    amxo_parser_init(&parser);
    retval = amxo_parser_parse_file(&parser, "my_dm_def.odl", root);
    amxo_parser_clean(&parser);
 
    return retval;
}

Parameters

parser

pointer to an odl parser instance

Definition at line 238 of file amxo_parser_main.c.

                                              {
    when_null(parser, exit);
 
    parser->fd = -1;
    parser->object = NULL;
    parser->param = NULL;
    parser->func = NULL;
    parser->status = amxd_status_ok;
    parser->resolved_fn = NULL;
 
    amxc_rbuffer_clean(&parser->rbuffer);
    amxc_string_clean(&parser->msg);
    amxc_astack_clean(&parser->object_stack, NULL);
    amxc_llist_clean(&parser->event_list, amxo_parser_free_event);
    amxc_llist_clean(&parser->global_config, amxc_string_list_it_free);
 
    amxo_parser_clean_resolvers(parser);
    if(parser->resolvers != NULL) {
        amxc_htable_delete(&parser->resolvers, NULL);
    }
 
    amxc_llist_delete(&parser->hooks, NULL);
    amxc_var_clean(&parser->config);
    amxc_var_delete(&parser->include_stack);
    amxc_llist_delete(&parser->entry_points, amxo_parser_entry_point_free);
    amxc_llist_clean(&parser->function_names, amxc_string_list_it_free);
    amxc_htable_clean(&parser->mibs, amxo_parser_del_mib_info);
    if(parser->sync_contexts != NULL) {
        amxc_llist_delete(&parser->sync_contexts, amxo_parser_del_sync_data);
    }
    amxc_var_delete(&parser->post_includes);
 
exit:
    return;
}

amxo_parser_delete()

void amxo_parser_delete

(

amxo_parser_t **

parser

)

Cleans the odl parser content and frees the allocated memory.

When done parsing odl files, the parser content must be deleted.

Note

Only use this function when the parser was created with amxo_parser_new

Failing to delete the odl parser will lead to memory leaks.

int load_data_model(amxd_dm_t *dm) {
    int retval = 0;
    amxo_parser_t *parser = NULL;
    amxd_object_t *root = amxd_dm_get_root(dm);
 
    amxo_parser_new(&parser);
    retval = amxo_parser_parse_file(parser, "my_dm_def.odl", root);
    amxo_parser_delete(parser);
 
    return retval;
}

Parameters

parser

pointer to a pointer to an odl parser instance

Definition at line 292 of file amxo_parser_main.c.

                                                {
    when_null(parser, exit);
    when_null(*parser, exit);
 
    amxo_parser_clean(*parser);
    free(*parser);
    *parser = NULL;
 
exit:
    return;
}

amxo_parser_get_connections()

amxc_llist_t* amxo_parser_get_connections

(

amxo_parser_t *

parser

)

Get a list of the current connections of the application.

This function is deprecated use amxp_connection_get_connections instead.

Parameters

parser

the odl parser instance

Returns

A list with all active socket connections.

amxo_parser_get_file()

static const char* amxo_parser_get_file ( amxo_parser_t *  parser )

inlinestatic

Get the current file name that is being parsed.

During parsing (in parser hooks) you can get the file name of the current file being parsed.

if a string is being parser - see amxo_parser_parse_string - or parsing is started with a file descriptor - see amxo_parser_parse_fd - this function will return the string "<unknown>".

When parsing fails it will return the top level file name, and not the file name where the error occured, in case of included odl files.

Parameters

parser

the odl parser instance

Returns

The file name being parsed or the string "<unknown>" when no file name is available.

Definition at line 484 of file amxo.h.

                                                        {
    return parser == NULL ? NULL : parser->file;
}

amxo_parser_get_line()

static uint32_t amxo_parser_get_line ( amxo_parser_t *  parser )

inlinestatic

Get the current line number that is being parsed.

During parsing (in parser hooks) you can get the line number of the current file being parsed.

When parsing fails it will return the top line number of the top level file, in case of included odl files.

Parameters

parser

the odl parser instance

Returns

The current line number.

Definition at line 505 of file amxo.h.

                                                     {
    return parser == NULL ? 0 : parser->line;
}

amxo_parser_get_listeners()

amxc_llist_t* amxo_parser_get_listeners

(

amxo_parser_t *

parser

)

Get of the current listen sockets of the application.

This function is deprecated use amxp_connection_get_listeners instead.

Parameters

parser

the odl parser instance

Returns

A list with all open listen sockets.

amxo_parser_get_message()

static const char* amxo_parser_get_message ( amxo_parser_t *  parser )

inlinestatic

Get the failure message in human readable form.

When parsing fails the message can provide more information about the failure reason.

When parsing was successful or when no parsing was done a NULL pointer is returned.

Typically this function is called when parsing has failed.

The messages is reset to NULL when starting a new parse using amxo_parser_parse_file, amxo_parser_parse_fd or amxo_parser_parse_string, or when calling amxo_parser_clean

int load_data_model(amxd_dm_t *dm) {
    int retval = 0;
    amxo_parser_t parser;
    amxd_object_t *root = amxd_dm_get_root(dm);
 
    amxo_parser_init(&parser);
    retval = amxo_parser_parse_file(&parser, "my_dm_def.odl", root);
    if (retval != 0) {
        printf("ODL parsing failed - message = %s\n", amxo_parser_get_message(parser));
    }
    amxo_parser_clean(&parser);
 
    return retval;
}

Parameters

parser

the odl parser instance

Returns

The human readable failure message or NULL when there is no message available

Definition at line 458 of file amxo.h.

                                                           {
    return parser == NULL ? NULL : amxc_string_get(&parser->msg, 0);
}

amxo_parser_get_status()

static amxd_status_t amxo_parser_get_status ( amxo_parser_t *  parser )

inlinestatic

Get the status of the odl parser.

When parsing fails the status can provide more information about the failure reason.

The status is reset to amxd_status_ok when starting a new parse using amxo_parser_parse_file, amxo_parser_parse_fd or amxo_parser_parse_string, or when calling amxo_parser_clean

Typically this function is called when parsing has failed.

int load_data_model(amxd_dm_t *dm) {
    int retval = 0;
    amxo_parser_t parser;
    amxd_object_t *root = amxd_dm_get_root(dm);
 
    amxo_parser_init(&parser);
    retval = amxo_parser_parse_file(&parser, "my_dm_def.odl", root);
    if (retval != 0) {
        printf("ODL parsing failed - status = %d\n", amxo_parser_get_status(parser));
    }
    amxo_parser_clean(&parser);
 
    return retval;
}

Parameters

parser

the odl parser instance

Returns

Returns the status of the parser.

Definition at line 414 of file amxo.h.

                                                            {
    return parser == NULL ? amxd_status_ok : parser->status;
}

amxo_parser_init()

int amxo_parser_init

(

amxo_parser_t *

parser

)

Initializes a new odl parser instance.

Before using an odl parser, it must be initialized. This function is typically called when the parser is declared on the stack.

When done parsing ODL files, a clean-up of the parser content must be done using amxo_parser_clean.

A odl parser instance can be used multiple times, there is no need for a new parser instance to parse another odl file. the same instance can be re-used.

Note

Failing to clean the odl parser content could lead to memory leaks.

int load_data_model(amxd_dm_t *dm) {
    int retval = 0;
    amxo_parser_t parser;
    amxd_object_t *root = amxd_dm_get_root(dm);
 
    amxo_parser_init(&parser);
    retval = amxo_parser_parse_file(&parser, "my_dm_definition.odl", root);
    amxo_parser_clean(&parser);
 
    return retval;
}

Parameters

parser

pointer to an odl parser instance

Returns

0 when successful, otherwise an error code

Definition at line 219 of file amxo_parser_main.c.

                                            {
    int retval = -1;
    amxc_var_t* inc_dirs = NULL;
    when_null(parser, exit);
 
    amxo_parser_child_init(parser);
 
    amxc_var_set_type(&parser->config, AMXC_VAR_ID_HTABLE);
    inc_dirs = amxc_var_add_key(amxc_llist_t, &parser->config, "include-dirs", NULL);
    amxc_var_add(cstring_t, inc_dirs, ".");
 
    amxo_parser_init_resolvers(parser);
 
    retval = 0;
 
exit:
    return retval;
}

amxo_parser_invoke_entry_points()

int amxo_parser_invoke_entry_points	(	amxo_parser_t *	parser,
		amxd_dm_t *	dm,
		int	reason
	)

Invokes all registered entry points.

In an odl file entry-points can be defined. Any application or library can register extra entry-points using amxo_parser_add_entry_point.

It is up to the application to invoke these entry-point functions, the parser itself will not call them at any time.

Provide a well defined reason identifier when invoking the entry point functions. The ODL parser library defines two reasons:

• AMXO_START
• AMXO_END

If one of the entry points returns a failure (not 0), the other entry points are still called.

If all entry points are executed successfull and post-include files are available these will be loaded as well.

Parameters

parser	the odl parser instance
dm	pointer to the data model
reason	a reason identifier

Returns

Returns 0 when success. A possitive number indicates the number of failed entry points. A negative number indicates failre on the parser side.

Definition at line 493 of file amxo_parser_main.c.

                                                {
    int retval = -1;
    int fail_count = 0;
    bool dm_eventing_enabled = true;
    when_null(parser, exit);
    when_null(dm, exit);
 
    if(parser->entry_points != NULL) {
        amxc_llist_for_each(it, parser->entry_points) {
            amxo_entry_t* ep = amxc_llist_it_get_data(it, amxo_entry_t, it);
            retval = ep->entry_point(reason, dm, parser);
            if(retval != 0) {
                fail_count++;
            }
        }
    }
 
    retval = fail_count;
    when_true(fail_count > 0, exit);
 
    when_true(parser->post_includes == NULL, exit);
 
    while(amxp_signal_read() == 0) {
    }
 
    dm_eventing_enabled = GET_BOOL(&parser->config, "dm-eventing-enabled");
    amxp_sigmngr_enable(&dm->sigmngr, dm_eventing_enabled);
    amxc_var_for_each(var, parser->post_includes) {
        const char* file = amxc_var_constcast(cstring_t, var);
        if(amxo_parser_parse_file(parser, file, amxd_dm_get_root(dm)) != 0) {
            fail_count++;
        }
        amxc_var_delete(&var);
    }
    amxp_sigmngr_enable(&dm->sigmngr, true);
 
    retval = fail_count;
 
exit:
    return retval;
}

amxo_parser_new()

int amxo_parser_new

(

amxo_parser_t **

parser

)

Allocates memory for a new parser instance on the heap and initializes the odl parser.

Before using an odl parser, it must be created and initialized. This function is typically called when the parser must be allocated on the heap.

When done parsing ODL files, a clean-up of the parser content can be done using amxo_parser_clean. Or when the parser is not needed anymore it can be deleted using amxo_parser_delete

A odl parser instance can be used multiple times, there is no need for a new parser instance to parse another odl file. the same instance can be re-used.

Note

Failing to delete the odl parser will lead to memory leaks.

int load_data_model(amxd_dm_t *dm) {
    int retval = 0;
    amxo_parser_t *parser = NULL;
    amxd_object_t *root = amxd_dm_get_root(dm);
 
    amxo_parser_new(&parser);
    retval = amxo_parser_parse_file(parser, "my_dm_def.odl", root);
    amxo_parser_delete(parser);
 
    return retval;
}

Parameters

parser

pointer to a pointer to an odl parser instance

Returns

0 when successful, otherwise an error code

Definition at line 274 of file amxo_parser_main.c.

                                            {
    int retval = -1;
    when_null(parser, exit);
 
    *parser = (amxo_parser_t*) calloc(1, sizeof(amxo_parser_t));
    when_null((*parser), exit);
 
    retval = amxo_parser_init(*parser);
 
exit:
    if((retval != 0) && (*parser != NULL)) {
        amxo_parser_clean(*parser);
        free(*parser);
        *parser = NULL;
    }
    return retval;
}

amxo_parser_new_sync_ctx()

amxs_sync_ctx_t* amxo_parser_new_sync_ctx	(	const char *	sync_template,
		const char *	object_a,
		const char *	object_b
	)

Create a new synchronization context from a synchronization template.

The paths provided to this function must match (at supported data model level) with the paths set in the template.

The paths provided must both point to existing objects, if one of them does not exist, creation of the new context fails.

Parameters

template	the synchronization template name
object_a	the path that must be used as path A in the new synchronization context
object_b	the path that must be used as path B in the new synchronization context

Returns

• NULL if failed to create the synchronization context.
• New synchronization context

Definition at line 592 of file amxo_parser_main.c.

                                                                {
    amxs_sync_ctx_t* templ = NULL;
    amxs_sync_ctx_t* ctx = NULL;
    amxs_status_t status = amxs_status_ok;
 
    templ = amxo_parser_sync_get(sync_template);
    status = amxs_sync_ctx_copy(&ctx, templ, NULL);
    when_failed(status, exit);
 
    status = amxs_sync_ctx_set_paths(ctx, object_a, object_b);
 
exit:
    if(status != amxs_status_ok) {
        amxs_sync_ctx_delete(&ctx);
    }
    return ctx;
}

amxo_parser_parse_fd()

int amxo_parser_parse_fd	(	amxo_parser_t *	parser,
		int	fd,
		amxd_object_t *	object
	)

Parses an odl file.

Reads and parses the odl file. During parsing of the odl file a data model is created or changed.

Objects will be added as a child of the provided data model object. Typically the data model root object will be used.

int load_data_model(amxd_dm_t *dm) {
    int retval = 0;
    amxo_parser_t parser;
    amxd_object_t *root = amxd_dm_get_root(dm);
    int fd = -1;
 
    fd = open(my_dm_def.odl, O_RDONLY);
    if (fd != -1) {
        amxo_parser_init(&parser);
        retval = amxo_parser_parse_fd(&parser, fd, root);
        amxo_parser_clean(&parser);
    }
    return retval;
}

Parameters

parser	the odl parser instance
fd	Valid file descriptor
object	the root object. All new objects defined in the odl file will by added in this object

Returns

On success 0 is returned, 1 on failure. When parsing failed, more information about the reason can be found in the status field or message field. Use amxo_parser_get_status and amxo_parser_get_message respectivily.

Definition at line 304 of file amxo_parser_main.c.

                                                {
    int retval = -1;
    struct rlimit nofile = { 0, 0 };
    when_null(parser, exit);
    when_null(object, exit);
 
    when_failed(getrlimit(RLIMIT_NOFILE, &nofile), exit);
 
    when_true(fd < 0 || (rlim_t) llabs(fd) > nofile.rlim_max, exit);
    when_failed(fcntl((int) llabs(fd), F_GETFD), exit);
 
    amxo_hooks_start(parser);
    retval = amxo_parser_parse_fd_internal(parser, fd, object);
    amxc_llist_clean(&parser->global_config, amxc_string_list_it_free);
    amxo_hooks_end(parser);
 
    amxo_parser_send_events(parser, amxd_object_get_dm(object));
 
exit:
    return retval;
}

amxo_parser_parse_file()

int amxo_parser_parse_file	(	amxo_parser_t *	parser,
		const char *	file_path,
		amxd_object_t *	object
	)

Parses an odl file.

Opens the odl file and parses it. During parsing of the odl file a data model is created or changed.

Objects will be added as a child of the provided data model object. Typically the data model root object will be used.

This function changes the current working directory while parsing the odl file. During the parsing process the current working directory is set to the odl's file directory. The current working directory is reset to the orignal when parsing is done (success or failure). All include files (without path) are always searched in the current working directory

If this behaviour is unwanted, use amxo_parser_parse_fd instead.

int load_data_model(amxd_dm_t *dm) {
    int retval = 0;
    amxo_parser_t parser;
    amxd_object_t *root = amxd_dm_get_root(dm);
 
    amxo_parser_init(&parser);
    retval = amxo_parser_parse_file(&parser, "my_dm_def.odl", root);
    amxo_parser_clean(&parser);
 
    return retval;
}

Parameters

parser	the odl parser instance
file_path	full or relative path to an odl file
object	the root object. All new objects defined in the odl file will by added in this object

Returns

On success 0 is returned, 1 on failure. When parsing failed, more information about the reason can be found in the status field or message field. Use amxo_parser_get_status and amxo_parser_get_message respectivily.

Definition at line 328 of file amxo_parser_main.c.

                                                  {
    int retval = -1;
    char* current_wd = getcwd(NULL, 0);
    char* real_path = NULL;
    char* dir_name = NULL;
    amxc_string_t res_file_path;
    amxc_string_init(&res_file_path, 0);
 
    when_null(parser, exit);
    when_str_empty(file_path, exit);
    when_null(object, exit);
 
    if(amxc_string_set_resolved(&res_file_path, file_path, &parser->config) > 0) {
        file_path = amxc_string_get(&res_file_path, 0);
    }
 
    real_path = realpath(file_path, NULL);
    if(real_path != NULL) {
        dir_name = dirname(real_path);
        when_true(chdir(dir_name) == -1, exit);
        if(dir_name[1] != 0) {
            dir_name[strlen(dir_name)] = '/';
        } else {
            free(real_path);
            real_path = realpath(file_path, NULL);
        }
    }
 
    parser->file = (real_path == NULL) ? file_path : real_path;
    amxo_hooks_start(parser);
    retval = amxo_parser_parse_file_impl(parser,
                                         real_path == NULL ? file_path : real_path,
                                         object);
    amxc_llist_clean(&parser->global_config, amxc_string_list_it_free);
    amxo_hooks_end(parser);
 
    amxo_parser_send_events(parser, amxd_object_get_dm(object));
 
    if(real_path != NULL) {
        when_true(chdir(current_wd) == -1, exit);
    }
 
exit:
    amxc_string_clean(&res_file_path);
    free(current_wd);
    free(real_path);
    return retval;
}

amxo_parser_parse_string()

int amxo_parser_parse_string	(	amxo_parser_t *	parser,
		const char *	text,
		amxd_object_t *	object
	)

Parses a string containing a valid ODL part.

Parses the provided string. During parsing of the odl string a data model is created or changed.

Objects will be added as a child of the provided data model object. Typically the data model root object will be used.

int load_data_model(amxd_dm_t *dm) {
    int retval = 0;
    amxo_parser_t parser;
    amxd_object_t *root = amxd_dm_get_root(dm);
 
    amxo_parser_init(&parser);
    retval = amxo_parser_parse_string(&parser, "include \"my_dm_def.odl\"", root);
    amxo_parser_clean(&parser);
 
    return retval;
}

Parameters

parser	the odl parser instance
text	A string containing an odl part
object	the root object. All new objects defined in the odl file will by added in this object

Returns

On success 0 is returned, 1 on failure. When parsing failed, more information about the reason can be found in the status field or message field. Use amxo_parser_get_status and amxo_parser_get_message respectivily.

Definition at line 379 of file amxo_parser_main.c.

                                                    {
    int retval = -1;
    when_null(parser, exit);
    when_null(object, exit);
    when_str_empty(text, exit);
 
    amxc_rbuffer_write(&parser->rbuffer, text, strlen(text));
    parser->object = object;
    parser->reader = amxo_parser_string_reader;
    parser->status = amxd_status_ok;
 
    amxo_hooks_start(parser);
    amxc_string_reset(&parser->msg);
    amxo_parser_create_lex(parser);
    retval = yyparse(parser->scanner);
    amxo_parser_destroy_lex(parser);
    amxo_hooks_end(parser);
 
    amxo_parser_sync_remove_invalid(parser);
 
    amxo_parser_send_events(parser, amxd_object_get_dm(object));
 
    amxc_rbuffer_clean(&parser->rbuffer);
    parser->object = NULL;
 
exit:
    return retval;
}

amxo_parser_rinvoke_entry_points()

int amxo_parser_rinvoke_entry_points	(	amxo_parser_t *	parser,
		amxd_dm_t *	dm,
		int	reason
	)

Invokes all registered entry points in reversed order.

In an odl file entry-points can be defined. Any application or library can register extra entry-points using amxo_parser_add_entry_point.

It is up to the application to invoke these entry-point functions, the parser itself will not call them at any time.

Provide a well defined reason identifier when invoking the entry point functions. The ODL parser library defines two reasons:

• AMXO_START
• AMXO_END

If one of the entry points returns a failure (not 0), the other entry points are still called.

Parameters

parser	the odl parser instance
dm	pointer to the data model
reason	a reason identifier

Returns

Returns 0 when success. A possitive number indicates the number of failed entry points. A negative number indicates failure on the parser side.

Definition at line 537 of file amxo_parser_main.c.

                                                 {
    int retval = -1;
    int fail_count = 0;
    when_null(parser, exit);
    when_null(dm, exit);
 
    if(parser->entry_points != NULL) {
        amxc_llist_for_each_reverse(it, parser->entry_points) {
            amxo_entry_t* ep = amxc_llist_it_get_data(it, amxo_entry_t, it);
            retval = ep->entry_point(reason, dm, parser);
            if(retval != 0) {
                fail_count++;
            }
        }
    }
 
    retval = fail_count;
 
exit:
    return retval;
}

amxo_parser_start_synchronize()

int amxo_parser_start_synchronize

(

amxo_parser_t *

parser

)

Start all object and parameter synchronizations that were declared in the loaded odl files.

In an odl file object and parameter synchronization can be set up. All the synchronization contexts declared in odl files will be managed by the parser.

This function will initialize and start the synchronization. Stopping the synchronizations managed by the parser is done using amxo_parser_stop_synchronize.

The function can be called multiple times, without having any effect on already running synchronizations. This will allow the load of other odl files that add extra object and parameter synchronizations.

If no synchronizations were declared in the odl file, this function will have no effect.

Note

Declared synchronizations will fail if one of the synchronization objects is not available in any data model.

Parameters

parser

the odl parser instance

Returns

Returns 0 when success. Any other value indicates the number of synchronization contexts that failed to start.

Definition at line 561 of file amxo_parser_main.c.

                                                         {
    int status = 0;
    int fail_count = 0;
    when_null(parser, exit);
 
    if(parser->sync_contexts != NULL) {
        amxc_llist_for_each(it, parser->sync_contexts) {
            status = amxo_parser_start_sync(it);
            if(status != 0) {
                fail_count++;
            }
        }
    }
 
exit:
    return fail_count;
}

amxo_parser_stop_synchronize()

void amxo_parser_stop_synchronize

(

amxo_parser_t *

parser

)

Stop all object and parameter synchronizations that were declared in odl files.

In an odl file object and parameter synchronization can be set up. Calling this will stop all the synchronization contexts that were declared in odl files.

If all synchronizations that were declared in odl files are already stopped, this function will have no effect.

If no synchronizations were declared in the odl file, this function will have no effect.

Parameters

parser

the odl parser instance

Definition at line 579 of file amxo_parser_main.c.

                                                         {
    when_null(parser, exit);
 
    if(parser->sync_contexts != NULL) {
        amxc_llist_for_each(it, parser->sync_contexts) {
            amxo_parser_stop_sync(it);
        }
    }
 
exit:
    return;
}