示例#1
0
/* exported interface documented in nsgenbind-ast.h */
struct genbind_node *
genbind_node_find_type_type(struct genbind_node *node,
			     struct genbind_node *prev,
			     enum genbind_node_type type,
			     const char *ident)
{
	struct genbind_node *found_node;
	struct genbind_node *ident_node;

	found_node = genbind_node_find_type(node, prev, type);


	while (found_node != NULL) {
		/* look for a type node  */
		ident_node = genbind_node_find_type(genbind_node_getnode(found_node),
					       NULL,
					       GENBIND_NODE_TYPE_TYPE);
		if (ident_node != NULL) {
			if (strcmp(ident_node->r.text, ident) == 0)
				break;
		}

		/* look for next matching node */
		found_node = genbind_node_find_type(node, found_node, type);
	}
	return found_node;
}
示例#2
0
/* exported interface documented in nsgenbind-ast.h */
struct genbind_node *
genbind_node_find_method(struct genbind_node *node,
                         struct genbind_node *prev,
                         enum genbind_method_type methodtype)
{
        struct genbind_node *res_node;

        res_node = genbind_node_find_type(
                genbind_node_getnode(node),
                prev, GENBIND_NODE_TYPE_METHOD);
        while (res_node != NULL) {
                struct genbind_node *type_node;
                enum genbind_method_type *type;

                type_node = genbind_node_find_type(
                        genbind_node_getnode(res_node),
                        NULL, GENBIND_NODE_TYPE_METHOD_TYPE);

                type = (enum genbind_method_type *)genbind_node_getint(type_node);
                if (*type == methodtype) {
                        break;
                }

                res_node = genbind_node_find_type(
                        genbind_node_getnode(node),
                        res_node, GENBIND_NODE_TYPE_METHOD);
        }

        return res_node;
}
示例#3
0
/**
 * get the type of binding
 */
static enum bindingtype_e genbind_get_type(struct genbind_node *node)
{
        struct genbind_node *binding_node;
        const char *binding_type;

        binding_node = genbind_node_find_type(node,
                                              NULL,
                                              GENBIND_NODE_TYPE_BINDING);
        if (binding_node == NULL) {
            /* binding entry is missing which is invalid */
            return BINDINGTYPE_UNKNOWN;
        }

        binding_type = genbind_node_gettext(
                genbind_node_find_type(
                        genbind_node_getnode(binding_node),
                        NULL,
                        GENBIND_NODE_TYPE_NAME));
        if (binding_type == NULL) {
                fprintf(stderr, "Error: missing binding type\n");
                return BINDINGTYPE_UNKNOWN;
        }

        if (strcmp(binding_type, "jsapi_libdom") == 0) {
                return BINDINGTYPE_JSAPI_LIBDOM;
        }

        if (strcmp(binding_type, "duk_libdom") == 0) {
                return BINDINGTYPE_DUK_LIBDOM;
        }

        fprintf(stderr, "Error: unsupported binding type \"%s\"\n", binding_type);

        return BINDINGTYPE_UNKNOWN;
}
示例#4
0
/* exported interface documented in nsgenbind-ast.h */
struct genbind_node *
genbind_node_find_method_ident(struct genbind_node *node,
                               struct genbind_node *prev,
                               enum genbind_method_type nodetype,
                               const char *ident)
{
        struct genbind_node *res_node;
        char *method_ident;

        res_node = genbind_node_find_method(node, prev, nodetype);
        while (res_node != NULL) {
              method_ident = genbind_node_gettext(
                      genbind_node_find_type(
                              genbind_node_getnode(res_node),
                              NULL,
                              GENBIND_NODE_TYPE_IDENT));

              if ((ident != NULL) &&
                  (method_ident != NULL) &&
                  strcmp(ident, method_ident) == 0) {
                      break;
              }

              res_node = genbind_node_find_method(node, res_node, nodetype);
        }
        return res_node;
}
示例#5
0
static int genbind_load_idl(struct genbind_node *genbind,
                            struct webidl_node **webidl_out)
{
        int res;
        struct genbind_node *binding_node;

        binding_node = genbind_node_find_type(genbind, NULL,
                                              GENBIND_NODE_TYPE_BINDING);

	/* walk AST and load any web IDL files required */
	res = genbind_node_foreach_type(
                genbind_node_getnode(binding_node),
                GENBIND_NODE_TYPE_WEBIDL,
                webidl_file_cb,
                webidl_out);
	if (res != 0) {
		fprintf(stderr, "Error: failed reading Web IDL\n");
		return -1;
	}

        /* implements are implemented as mixins so intercalate them */
        res = webidl_intercalate_implements(*webidl_out);
	if (res != 0) {
		fprintf(stderr, "Error: Failed to intercalate implements\n");
		return -1;
	}

        return 0;
}
示例#6
0
/* exported interface documented in nsgenbind-ast.h */
struct genbind_node *
genbind_node_find_type_ident(struct genbind_node *node,
                             struct genbind_node *prev,
                             enum genbind_node_type type,
                             const char *ident)
{
        struct genbind_node *found_node;
        struct genbind_node *ident_node;

        if (ident == NULL) {
                return NULL;
        }

        found_node = genbind_node_find_type(node, prev, type);

        while (found_node != NULL) {
                /* look for an ident node  */
                ident_node = genbind_node_find_type(
                        genbind_node_getnode(found_node),
                        NULL,
                        GENBIND_NODE_TYPE_IDENT);

                while (ident_node != NULL) {
                        /* check for matching text */
                        if (strcmp(ident_node->r.text, ident) == 0) {
                                return found_node;
                        }

                        ident_node = genbind_node_find_type(
                                genbind_node_getnode(found_node),
                                ident_node,
                                GENBIND_NODE_TYPE_IDENT);
                }


                /* look for next matching node */
                found_node = genbind_node_find_type(node, found_node, type);
        }
        return found_node;
}