static gboolean
dir_project_list_directory (DirProject *project, DirGroup* parent, GError **error)
{
gboolean ok;
GFileEnumerator *enumerator;
enumerator = g_file_enumerate_children (DIR_GROUP_DATA (parent)->base.directory,
G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL,
error);
ok = enumerator != NULL;
if (ok)
{
GFileInfo *info;
while ((info = g_file_enumerator_next_file (enumerator, NULL, error)) != NULL)
{
const gchar *name;
GFile *file;
name = g_file_info_get_name (info);
file = g_file_get_child (DIR_GROUP_DATA (parent)->base.directory, name);
g_object_unref (info);
/* Check if file is a source */
if (!dir_pattern_stack_is_match (project->sources, file)) continue;
if (g_file_query_file_type (file, G_FILE_QUERY_INFO_NONE, NULL) == G_FILE_TYPE_DIRECTORY)
{
/* Create a group for directory */
DirGroup *group;
group = dir_group_new (file);
g_hash_table_insert (project->groups, g_file_get_uri (file), group);
anjuta_project_node_append (parent, group);
ok = dir_project_list_directory (project, group, error);
if (!ok) break;
}
else
{
/* Create a source for files */
DirSource *source;
source = dir_source_new (file);
anjuta_project_node_append (parent, source);
}
}
g_file_enumerator_close (enumerator, NULL, NULL);
g_object_unref (enumerator);
}
return ok;
}
static gboolean
amp_package_node_load (AmpNode *node, AmpNode *parent, AmpProject *project, GError **error)
{
GList* deps;
GList* dep;
GList* include_dirs = NULL;
deps = anjuta_pkg_config_list_dependencies (anjuta_project_node_get_name (ANJUTA_PROJECT_NODE (node)),
error);
for (dep = deps; dep != NULL; dep = g_list_next (dep))
{
/* Create a package node for the depedencies */
AnjutaProjectNode *pkg;
pkg = ANJUTA_PROJECT_NODE (amp_package_node_new (dep->data));
anjuta_project_node_append (ANJUTA_PROJECT_NODE (node), pkg);
}
anjuta_util_glist_strings_free (deps);
if (*error != NULL)
{
g_warning ("Error getting dependencies: %s", (*error)->message);
g_error_free (*error);
*error = NULL;
}
if ((include_dirs = anjuta_pkg_config_get_directories (anjuta_project_node_get_name (ANJUTA_PROJECT_NODE (node)),
TRUE, error)))
{
GList* include_dir;
for (include_dir = include_dirs; include_dir != NULL; include_dir = g_list_next (include_dir))
{
GList* children = NULL;
GList* file = NULL;
GFile* dir = g_file_new_for_path (include_dir->data);
anjuta_util_list_all_dir_children (&children, dir);
for (file = g_list_first (children); file != NULL; file = g_list_next (file))
{
/* Create a source for files */
AnjutaProjectNode *source;
source = amp_node_new_valid (ANJUTA_PROJECT_NODE (parent), ANJUTA_PROJECT_SOURCE, (GFile *)file->data, NULL, NULL);
anjuta_project_node_append (ANJUTA_PROJECT_NODE (node), source);
g_object_unref ((GObject *)file->data);
}
g_list_free (children);
g_object_unref (dir);
}
}
anjuta_util_glist_strings_free (include_dirs);
return TRUE;
}
gboolean
mkp_project_reload (MkpProject *project, GError **error)
{
GFile *root_file;
GFile *make_file;
const gchar **makefile;
MkpGroup *group;
gboolean ok = TRUE;
/* Unload current project */
root_file = g_object_ref (project->root_file);
mkp_project_unload (project);
project->root_file = root_file;
DEBUG_PRINT ("reload project %p root file %p", project, project->root_file);
/* shortcut hash tables */
project->groups = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
project->files = g_hash_table_new_full (g_file_hash, (GEqualFunc)g_file_equal, g_object_unref, g_object_unref);
project->variables = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify)mkp_variable_free);
/* Initialize rules data */
mkp_project_init_rules (project);
/* Initialize list styles */
project->space_list = anjuta_token_style_new (NULL, " ", "\n", NULL, 0);
project->arg_list = anjuta_token_style_new (NULL, ", ", ",\n ", ")", 0);
/* Find make file */
for (makefile = valid_makefiles; *makefile != NULL; makefile++)
{
if (file_type (root_file, *makefile) == G_FILE_TYPE_REGULAR)
{
make_file = g_file_get_child (root_file, *makefile);
break;
}
}
if (make_file == NULL)
{
g_set_error (error, IANJUTA_PROJECT_ERROR,
IANJUTA_PROJECT_ERROR_DOESNT_EXIST,
_("Project doesn't exist or invalid path"));
return FALSE;
}
/* Create group */
group = MKP_GROUP(mkp_group_new (root_file));
anjuta_project_node_append (ANJUTA_PROJECT_NODE(project), ANJUTA_PROJECT_NODE(group));
g_hash_table_insert (project->groups, g_file_get_uri (root_file), group);
/* Parse make file */
project_load_makefile (project, make_file, group, error);
g_object_unref (make_file);
monitors_setup (project);
return ok;
}
AnjutaTokenFile*
amp_group_node_set_makefile (AmpGroupNode *group, GFile *makefile, AmpProject *project)
{
if (group->makefile != NULL) g_object_unref (group->makefile);
if (group->tfile != NULL) anjuta_token_file_free (group->tfile);
if (makefile != NULL)
{
AnjutaToken *token;
AmpAmScanner *scanner;
AnjutaProjectNode *source;
group->makefile = g_object_ref (makefile);
group->tfile = anjuta_token_file_new (makefile);
source = amp_source_node_new (makefile, ANJUTA_PROJECT_PROJECT | ANJUTA_PROJECT_FRAME | ANJUTA_PROJECT_READ_ONLY);
anjuta_project_node_append (ANJUTA_PROJECT_NODE (group), source);
token = anjuta_token_file_load (group->tfile, NULL);
amp_project_add_file (project, makefile, group->tfile);
amp_group_node_update_preset_variable (group);
scanner = amp_am_scanner_new (project, group);
group->make_token = amp_am_scanner_parse_token (scanner, anjuta_token_new_static (ANJUTA_TOKEN_FILE, NULL), token, makefile, NULL);
amp_am_scanner_free (scanner);
group->monitor = g_file_monitor_file (makefile,
G_FILE_MONITOR_NONE,
NULL,
NULL);
if (group->monitor != NULL)
{
g_signal_connect (G_OBJECT (group->monitor),
"changed",
G_CALLBACK (on_group_monitor_changed),
group);
}
}
else
{
group->makefile = NULL;
group->tfile = NULL;
group->make_token = NULL;
if (group->monitor) g_object_unref (group->monitor);
group->monitor = NULL;
}
return group->tfile;
}
/* Find if pkg-config modules are used in group targets */
static gboolean
project_load_group_module (AmpProject *project, AmpGroupNode *group)
{
AnjutaProjectNode *target;
AnjutaProjectProperty *prop;
gchar **group_cpp = NULL;
prop = amp_node_get_property_from_token (ANJUTA_PROJECT_NODE (group), AM_TOKEN__CPPFLAGS, 0);
if (prop && (prop->value != NULL)) group_cpp = g_strsplit_set (prop->value, " \t", 0);
/* Check all targets */
for (target = anjuta_project_node_first_child (ANJUTA_PROJECT_NODE (group)); target != NULL; target = anjuta_project_node_next_sibling (target))
{
gint type = anjuta_project_node_get_full_type (target) & (ANJUTA_PROJECT_ID_MASK | ANJUTA_PROJECT_TYPE_MASK);
gchar **target_lib = NULL;
gchar **target_cpp = NULL;
prop = NULL;
switch (type)
{
case ANJUTA_PROJECT_TARGET | ANJUTA_PROJECT_PROGRAM:
prop = amp_node_get_property_from_token (target, AM_TOKEN_TARGET_LDADD, 0);
break;
case ANJUTA_PROJECT_TARGET | ANJUTA_PROJECT_STATICLIB:
case ANJUTA_PROJECT_TARGET | ANJUTA_PROJECT_SHAREDLIB:
case ANJUTA_PROJECT_TARGET | ANJUTA_PROJECT_LT_MODULE:
prop = amp_node_get_property_from_token (target, AM_TOKEN_TARGET_LIBADD, 0);
break;
default:
break;
}
if (prop && (prop->value != NULL)) target_lib = g_strsplit_set (prop->value, " \t", 0);
/* Check if targets use libraries */
if (target_lib != NULL)
{
AnjutaProjectNode *module;
prop = amp_node_get_property_from_token (target, AM_TOKEN_TARGET_CPPFLAGS, 0);
if (prop && (prop->value != NULL)) target_cpp = g_strsplit_set (prop->value, " \t", 0);
for (module = anjuta_project_node_first_child (ANJUTA_PROJECT_NODE (project)); module != NULL; module = anjuta_project_node_next_sibling (module))
{
if (anjuta_project_node_get_node_type (module) == ANJUTA_PROJECT_MODULE)
{
const gchar *name = anjuta_project_node_get_name (module);
gchar *lib_flags = g_strconcat ("$(", name, "_LIBS)", NULL);
gchar **flags;
for (flags = target_lib; *flags != NULL; flags++)
{
if (strcmp (*flags, lib_flags) == 0)
{
gchar *cpp_flags = g_strconcat ("$(", name, "_CFLAGS)", NULL);
gchar **cflags;
gboolean found = FALSE;
if (group_cpp != NULL)
{
for (cflags = group_cpp; *cflags != NULL; cflags++)
{
if (strcmp (*cflags, cpp_flags) == 0)
{
found = TRUE;
break;
}
}
}
if ((target_cpp != NULL) && !found)
{
for (cflags = target_cpp; *cflags != NULL; cflags++)
{
if (strcmp (*cflags, cpp_flags) == 0)
{
found = TRUE;
break;
}
}
}
if (found)
{
/* Add new module */
AnjutaProjectNode *new_module;
new_module = amp_node_new_valid (target, ANJUTA_PROJECT_MODULE, NULL, name, NULL);
anjuta_project_node_append (target, new_module);
}
g_free (cpp_flags);
}
}
g_free (lib_flags);
}
}
g_strfreev (target_cpp);
g_strfreev (target_lib);
}
}
g_strfreev (group_cpp);
return TRUE;
}
void
mkp_project_enumerate_targets (MkpProject *project, AnjutaProjectNode *parent)
{
GHashTableIter iter;
gpointer key;
MkpRule *rule;
/* Check pattern rules */
for (g_hash_table_iter_init (&iter, project->rules); g_hash_table_iter_next (&iter, (gpointer)&key, (gpointer)&rule);)
{
if (rule->phony) continue;
if (g_hash_table_lookup (project->suffix, rule->name))
{
/* Single suffix rule */
rule->pattern = TRUE;
rule->part = NULL;
}
else
{
GString *pattern = g_string_sized_new (16);
GList *suffix;
GList *src;
/* Check double suffix rule */
suffix = g_hash_table_get_keys (project->suffix);
for (src = g_list_first (suffix); src != NULL; src = g_list_next (src))
{
GList *obj;
for (obj = g_list_first (suffix); obj != NULL; obj = g_list_next (obj))
{
g_string_assign (pattern, src->data);
g_string_append (pattern, obj->data);
if (strcmp (pattern->str, rule->name) == 0)
{
rule->pattern = TRUE;
rule->part = rule->name + strlen (src->data);
break;
}
}
if (rule->pattern) break;
}
g_string_free (pattern, TRUE);
g_list_free (suffix);
}
}
/* Create new target */
for (g_hash_table_iter_init (&iter, project->rules); g_hash_table_iter_next (&iter, (gpointer)&key, (gpointer)&rule);)
{
MkpTarget *target;
AnjutaToken *prerequisite;
AnjutaToken *arg;
//g_message ("rule =%s=", rule->name);
if (rule->phony || rule->pattern) continue;
/* Create target */
target = MKP_TARGET(mkp_target_new (rule->name, ANJUTA_PROJECT_UNKNOWN));
mkp_target_add_token (target, rule->rule);
anjuta_project_node_append (parent, ANJUTA_PROJECT_NODE(target));
/* Get prerequisite */
prerequisite = anjuta_token_first_word (rule->rule);
if (prerequisite != NULL) prerequisite = anjuta_token_next_word (prerequisite);
if (prerequisite != NULL) prerequisite = anjuta_token_next_word (prerequisite);
/* Add prerequisite */
for (arg = anjuta_token_first_word (prerequisite); arg != NULL; arg = anjuta_token_next_word (arg))
{
AnjutaProjectNode *node;
gchar *name;
GList *dependencies;
name = anjuta_token_evaluate (arg);
if (name != NULL)
{
name = g_strstrip (name);
dependencies = mkp_project_find_dependencies (project, name, parent, 0);
if (dependencies == NULL)
{
/* Add only one object node */
node = mkp_object_new (name);
node->type = ANJUTA_PROJECT_OBJECT | ANJUTA_PROJECT_PROJECT;
anjuta_project_node_append (ANJUTA_PROJECT_NODE(target), ANJUTA_PROJECT_NODE(node));
g_free (name);
}
else
{
GFile *src_file;
gchar *name;
AnjutaProjectNode *parent = (AnjutaProjectNode *)target;
while (g_list_next (dependencies) != NULL)
{
/* Create object nodes */
name = (gchar *)dependencies->data;
node = mkp_object_new (name);
node->type = ANJUTA_PROJECT_OBJECT | ANJUTA_PROJECT_PROJECT;
anjuta_project_node_append (parent, node);
g_free (name);
parent = node;
dependencies = g_list_delete_link (dependencies, dependencies);
}
/* Create source node */
name = (gchar *)dependencies->data;
src_file = g_file_get_child (project->root_file, name);
node = mkp_source_new (src_file);
node->type = ANJUTA_PROJECT_SOURCE | ANJUTA_PROJECT_PROJECT;
g_object_unref (src_file);
anjuta_project_node_append (parent, node);
g_free (name);
g_list_free (dependencies);
}
}
}
}
}
