*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
*/
#include <babeltrace/format.h>
static
struct declaration *
- lookup_declaration_scope(GQuark declaration_name,
+ bt_lookup_declaration_scope(GQuark declaration_name,
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->typedef_declarations,
(gconstpointer) (unsigned long) declaration_name);
}
-struct declaration *lookup_declaration(GQuark declaration_name,
+struct declaration *bt_lookup_declaration(GQuark declaration_name,
struct declaration_scope *scope)
{
struct declaration *declaration;
while (scope) {
- declaration = lookup_declaration_scope(declaration_name,
+ declaration = bt_lookup_declaration_scope(declaration_name,
scope);
if (declaration)
return declaration;
return NULL;
}
-int register_declaration(GQuark name, struct declaration *declaration,
+int bt_register_declaration(GQuark name, struct declaration *declaration,
struct declaration_scope *scope)
{
if (!name)
return -EPERM;
/* Only lookup in local scope */
- if (lookup_declaration_scope(name, scope))
+ if (bt_lookup_declaration_scope(name, scope))
return -EEXIST;
g_hash_table_insert(scope->typedef_declarations,
(gpointer) (unsigned long) name,
declaration);
- declaration_ref(declaration);
+ bt_declaration_ref(declaration);
return 0;
}
static int is_path_child_of(GArray *path, GArray *maybe_parent)
{
- int i, ret;
+ int ret;
if (babeltrace_debug) {
- int need_dot = 0;
+ int i, need_dot = 0;
printf_debug("Is path \"");
for (i = 0; i < path->len; need_dot = 1, i++)
return 0;
}
-void declaration_ref(struct declaration *declaration)
+void bt_declaration_ref(struct declaration *declaration)
{
declaration->ref++;
}
-void declaration_unref(struct declaration *declaration)
+void bt_declaration_unref(struct declaration *declaration)
{
if (!declaration)
return;
declaration->declaration_free(declaration);
}
-void definition_ref(struct definition *definition)
+void bt_definition_ref(struct definition *definition)
{
definition->ref++;
}
-void definition_unref(struct definition *definition)
+void bt_definition_unref(struct definition *definition)
{
if (!definition)
return;
}
struct declaration_scope *
- new_declaration_scope(struct declaration_scope *parent_scope)
+ bt_new_declaration_scope(struct declaration_scope *parent_scope)
{
struct declaration_scope *scope = g_new(struct declaration_scope, 1);
scope->typedef_declarations = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL,
- (GDestroyNotify) declaration_unref);
+ (GDestroyNotify) bt_declaration_unref);
scope->struct_declarations = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL,
- (GDestroyNotify) declaration_unref);
+ (GDestroyNotify) bt_declaration_unref);
scope->variant_declarations = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL,
- (GDestroyNotify) declaration_unref);
+ (GDestroyNotify) bt_declaration_unref);
scope->enum_declarations = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL,
- (GDestroyNotify) declaration_unref);
+ (GDestroyNotify) bt_declaration_unref);
scope->parent_scope = parent_scope;
return scope;
}
-void free_declaration_scope(struct declaration_scope *scope)
+void bt_free_declaration_scope(struct declaration_scope *scope)
{
g_hash_table_destroy(scope->enum_declarations);
g_hash_table_destroy(scope->variant_declarations);
}
static
-struct declaration_struct *lookup_struct_declaration_scope(GQuark struct_name,
+struct declaration_struct *bt_lookup_struct_declaration_scope(GQuark struct_name,
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->struct_declarations,
(gconstpointer) (unsigned long) struct_name);
}
-struct declaration_struct *lookup_struct_declaration(GQuark struct_name,
+struct declaration_struct *bt_lookup_struct_declaration(GQuark struct_name,
struct declaration_scope *scope)
{
struct declaration_struct *declaration;
while (scope) {
- declaration = lookup_struct_declaration_scope(struct_name, scope);
+ declaration = bt_lookup_struct_declaration_scope(struct_name, scope);
if (declaration)
return declaration;
scope = scope->parent_scope;
return NULL;
}
-int register_struct_declaration(GQuark struct_name,
+int bt_register_struct_declaration(GQuark struct_name,
struct declaration_struct *struct_declaration,
struct declaration_scope *scope)
{
return -EPERM;
/* Only lookup in local scope */
- if (lookup_struct_declaration_scope(struct_name, scope))
+ if (bt_lookup_struct_declaration_scope(struct_name, scope))
return -EEXIST;
g_hash_table_insert(scope->struct_declarations,
(gpointer) (unsigned long) struct_name,
struct_declaration);
- declaration_ref(&struct_declaration->p);
+ bt_declaration_ref(&struct_declaration->p);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("struct ", struct_name);
- ret = register_declaration(prefix_name, &struct_declaration->p, scope);
+ ret = bt_register_declaration(prefix_name, &struct_declaration->p, scope);
assert(!ret);
return 0;
}
static
struct declaration_untagged_variant *
- lookup_variant_declaration_scope(GQuark variant_name,
+ bt_lookup_variant_declaration_scope(GQuark variant_name,
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->variant_declarations,
}
struct declaration_untagged_variant *
- lookup_variant_declaration(GQuark variant_name,
+ bt_lookup_variant_declaration(GQuark variant_name,
struct declaration_scope *scope)
{
struct declaration_untagged_variant *declaration;
while (scope) {
- declaration = lookup_variant_declaration_scope(variant_name, scope);
+ declaration = bt_lookup_variant_declaration_scope(variant_name, scope);
if (declaration)
return declaration;
scope = scope->parent_scope;
return NULL;
}
-int register_variant_declaration(GQuark variant_name,
+int bt_register_variant_declaration(GQuark variant_name,
struct declaration_untagged_variant *untagged_variant_declaration,
struct declaration_scope *scope)
{
return -EPERM;
/* Only lookup in local scope */
- if (lookup_variant_declaration_scope(variant_name, scope))
+ if (bt_lookup_variant_declaration_scope(variant_name, scope))
return -EEXIST;
g_hash_table_insert(scope->variant_declarations,
(gpointer) (unsigned long) variant_name,
untagged_variant_declaration);
- declaration_ref(&untagged_variant_declaration->p);
+ bt_declaration_ref(&untagged_variant_declaration->p);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("variant ", variant_name);
- ret = register_declaration(prefix_name,
+ ret = bt_register_declaration(prefix_name,
&untagged_variant_declaration->p, scope);
assert(!ret);
return 0;
static
struct declaration_enum *
- lookup_enum_declaration_scope(GQuark enum_name,
+ bt_lookup_enum_declaration_scope(GQuark enum_name,
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->enum_declarations,
}
struct declaration_enum *
- lookup_enum_declaration(GQuark enum_name,
+ bt_lookup_enum_declaration(GQuark enum_name,
struct declaration_scope *scope)
{
struct declaration_enum *declaration;
while (scope) {
- declaration = lookup_enum_declaration_scope(enum_name, scope);
+ declaration = bt_lookup_enum_declaration_scope(enum_name, scope);
if (declaration)
return declaration;
scope = scope->parent_scope;
return NULL;
}
-int register_enum_declaration(GQuark enum_name,
+int bt_register_enum_declaration(GQuark enum_name,
struct declaration_enum *enum_declaration,
struct declaration_scope *scope)
{
return -EPERM;
/* Only lookup in local scope */
- if (lookup_enum_declaration_scope(enum_name, scope))
+ if (bt_lookup_enum_declaration_scope(enum_name, scope))
return -EEXIST;
g_hash_table_insert(scope->enum_declarations,
(gpointer) (unsigned long) enum_name,
enum_declaration);
- declaration_ref(&enum_declaration->p);
+ bt_declaration_ref(&enum_declaration->p);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("enum ", enum_name);
- ret = register_declaration(prefix_name, &enum_declaration->p, scope);
+ ret = bt_register_declaration(prefix_name, &enum_declaration->p, scope);
assert(!ret);
return 0;
}
GQuark path;
GString *str;
gchar *c_str;
- int i;
int need_dot = 0;
str = g_string_new("");
g_string_append(str, root_name);
need_dot = 1;
} else if (parent_scope) {
+ int i;
+
for (i = 0; i < parent_scope->scope_path->len; i++) {
GQuark q = g_array_index(parent_scope->scope_path,
GQuark, i);
if (root_name) {
scope = _new_definition_scope(parent_scope, 0);
- append_scope_path(root_name, scope->scope_path);
+ bt_append_scope_path(root_name, scope->scope_path);
} else {
int scope_path_len = 1;
/*
* in: path (dot separated), out: q (GArray of GQuark)
*/
-void append_scope_path(const char *path, GArray *q)
+void bt_append_scope_path(const char *path, GArray *q)
{
const char *ptrbegin, *ptrend = path;
GQuark quark;
return lookup_integer;
}
-struct definition_enum *lookup_enum(const struct definition *definition,
+struct definition_enum *bt_lookup_enum(const struct definition *definition,
const char *field_name,
int signedness)
{
projects / babeltrace.git / blobdiff