/*
* Validate files in the backup with size or CRC.
*/
static bool
pgBackupValidateFiles(parray *files, const char *root, bool size_only)
{
int i;
for (i = 0; i < parray_num(files); i++)
{
struct stat st;
pgFile *file = (pgFile *) parray_get(files, i);
if (interrupted)
elog(ERROR_INTERRUPTED, _("interrupted during validate"));
/* skipped backup while incremental backup */
if (file->write_size == BYTES_INVALID || !S_ISREG(file->mode))
continue;
/* print progress */
elog(LOG, _("(%d/%lu) %s"), i + 1, (unsigned long) parray_num(files),
get_relative_path(file->path, root));
/* always validate file size */
if (stat(file->path, &st) == -1)
{
if (errno == ENOENT)
elog(WARNING, _("backup file \"%s\" vanished"), file->path);
else
elog(ERROR_SYSTEM, _("can't stat backup file \"%s\": %s"),
get_relative_path(file->path, root), strerror(errno));
return false;
}
if (file->write_size != st.st_size)
{
elog(WARNING, _("size of backup file \"%s\" must be %lu but %lu"),
get_relative_path(file->path, root),
(unsigned long) file->write_size,
(unsigned long) st.st_size);
return false;
}
/* validate CRC too */
if (!size_only)
{
pg_crc32 crc;
crc = pgFileGetCRC(file);
if (crc != file->crc)
{
elog(WARNING, _("CRC of backup file \"%s\" must be %X but %X"),
get_relative_path(file->path, root), file->crc, crc);
return false;
}
}
}
return true;
}
gboolean
mkp_project_move (MkpProject *project, const gchar *path)
{
GFile *old_root_file;
GFile *new_file;
gchar *relative;
GHashTableIter iter;
gpointer key;
gpointer value;
AnjutaTokenFile *tfile;
GHashTable* old_hash;
/* Change project root directory */
old_root_file = project->root_file;
project->root_file = g_file_new_for_path (path);
/* Change project root directory in groups */
old_hash = project->groups;
project->groups = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
g_hash_table_iter_init (&iter, old_hash);
while (g_hash_table_iter_next (&iter, &key, &value))
{
MkpGroup *group = (MkpGroup *)value;
relative = get_relative_path (old_root_file, group->base.file);
new_file = g_file_resolve_relative_path (project->root_file, relative);
g_free (relative);
g_object_unref (group->base.file);
group->base.file = new_file;
g_hash_table_insert (project->groups, g_file_get_uri (new_file), group);
}
g_hash_table_destroy (old_hash);
/* Change all files */
old_hash = project->files;
project->files = g_hash_table_new_full (g_file_hash, (GEqualFunc)g_file_equal, g_object_unref, g_object_unref);
g_hash_table_iter_init (&iter, old_hash);
while (g_hash_table_iter_next (&iter, &key, (gpointer *)&tfile))
{
relative = get_relative_path (old_root_file, anjuta_token_file_get_file (tfile));
new_file = g_file_resolve_relative_path (project->root_file, relative);
g_free (relative);
anjuta_token_file_move (tfile, new_file);
g_hash_table_insert (project->files, new_file, tfile);
g_object_unref (key);
}
g_hash_table_steal_all (old_hash);
g_hash_table_destroy (old_hash);
g_object_unref (old_root_file);
return TRUE;
}
static void find_file_recursive(GtkTreeIter *iter, gboolean case_sensitive, gboolean full_path, GPatternSpec *pattern)
{
GtkTreeModel *model = GTK_TREE_MODEL(s_file_store);
GtkTreeIter child;
gboolean iterate;
iterate = gtk_tree_model_iter_children(model, &child, iter);
if (iterate)
{
while (iterate)
{
find_file_recursive(&child, case_sensitive, full_path, pattern);
iterate = gtk_tree_model_iter_next(model, &child);
}
}
else
{
gchar *utf8_name;
if (iter == NULL)
return;
if (full_path)
{
gchar *utf8_path, *utf8_base_path;
utf8_path = build_path(iter);
utf8_base_path = get_project_base_path();
utf8_name = get_relative_path(utf8_base_path, utf8_path);
g_free(utf8_path);
g_free(utf8_base_path);
}
else
gtk_tree_model_get(GTK_TREE_MODEL(model), iter, FILEVIEW_COLUMN_NAME, &utf8_name, -1);
if (!case_sensitive)
SETPTR(utf8_name, g_utf8_strdown(utf8_name, -1));
if (g_pattern_match_string(pattern, utf8_name))
{
gchar *utf8_base_path = get_project_base_path();
gchar *utf8_path, *rel_path;
utf8_path = build_path(iter);
rel_path = get_relative_path(utf8_base_path, utf8_path);
msgwin_msg_add(COLOR_BLACK, -1, NULL, "%s", rel_path ? rel_path : utf8_path);
g_free(utf8_path);
g_free(rel_path);
g_free(utf8_base_path);
}
g_free(utf8_name);
}
}
/* Returns actual_to by calculating the relative path from -> to and
applying that to actual_from. An assumption that actual_from is a
dir is made, and it may or may not end with a '/' */
char const *
get_relocated_path (char const * from, char const * to, char const * actual_from)
{
char const * relative_from_to = get_relative_path (from, to);
char * actual_to = (char *) malloc (strlen(actual_from) + 2 + strlen(relative_from_to));
return actual_to;
}
static void add_item(gpointer name, G_GNUC_UNUSED gpointer value, gpointer user_data)
{
gchar *item;
GSList **lst = (GSList **) user_data;
item = get_relative_path(g_current_project->path, name);
*lst = g_slist_prepend(*lst, item);
}
int path_getrelative(lua_State *L)
{
const char *src = luaL_checkstring(L, -2);
const char *dst = luaL_checkstring(L, -1);
char buffer[PATH_BUFSIZE];
get_relative_path(src, dst, buffer, PATH_BUFSIZE);
lua_pushstring(L, buffer);
return 1;
}
//filemanager
std::string filemanager::to_relative(const std::string& abspath)
{
if(abspath.empty())
return "";
if(!relative_)
return equalize_path(abspath);
return get_relative_path(equalize_path(base_), equalize_path(abspath));
}
static gboolean match(TMTag *tag, const gchar *name, gboolean declaration, gboolean case_sensitive,
MatchType match_type, GPatternSpec *pspec, gchar *utf8_path)
{
const gint forward_types = tm_tag_prototype_t | tm_tag_externvar_t;
gboolean matches = FALSE;
gint type;
type = declaration ? forward_types : tm_tag_max_t - forward_types;
matches = tag->type & type;
if (matches)
{
gchar *name_case;
if (case_sensitive)
name_case = g_strdup(tag->name);
else
name_case = g_utf8_strdown(tag->name, -1);
switch (match_type)
{
case MATCH_FULL:
matches = g_strcmp0(name_case, name) == 0;
break;
case MATCH_PATTERN:
matches = g_pattern_match_string(pspec, name_case);
break;
case MATCH_PREFIX:
matches = g_str_has_prefix(name_case, name);
break;
}
g_free(name_case);
}
if (matches && utf8_path)
{
gchar *utf8_file_name = utils_get_utf8_from_locale(tag->file->file_name);
gchar *relpath;
relpath = get_relative_path(utf8_path, utf8_file_name);
matches = relpath != NULL;
g_free(relpath);
g_free(utf8_file_name);
}
return matches;
}
char *
single_path_relocation(const char *from, const char *to)
{
#if defined(__MINGW32__)
char exe_path[PATH_MAX];
get_executable_path (NULL, &exe_path[0], sizeof(exe_path)/sizeof(exe_path[0]));
if (strrchr (exe_path, '/') != NULL)
{
strrchr (exe_path, '/')[1] = '\0';
}
char * rel_to_datadir = get_relative_path (from, to);
strcat (exe_path, rel_to_datadir);
simplify_path (&exe_path[0]);
return malloc_copy_string(exe_path);
#else
return malloc_copy_string(to);
#endif
}
static void find_tags(const gchar *name, gboolean declaration, gboolean case_sensitive, MatchType match_type, gchar *utf8_path)
{
gchar *utf8_base_path = get_project_base_path();
gchar *locale_base_path = utils_get_locale_from_utf8(utf8_base_path);
GPtrArray *tags_array = geany_data->app->tm_workspace->tags_array;
guint i;
gchar *name_case;
GPatternSpec *pspec;
if (case_sensitive)
name_case = g_strdup(name);
else
name_case = g_utf8_strdown(name, -1);
pspec = g_pattern_spec_new(name_case);
msgwin_set_messages_dir(locale_base_path);
msgwin_clear_tab(MSG_MESSAGE);
for (i = 0; i < tags_array->len; i++) /* TODO: binary search */
{
TMTag *tag = tags_array->pdata[i];
if (match(tag, name_case, declaration, case_sensitive, match_type, pspec, utf8_path))
{
gchar *scopestr = tag->scope ? g_strconcat(tag->scope, "::", NULL) : g_strdup("");
gchar *utf8_fname = utils_get_utf8_from_locale(tag->file->file_name);
gchar *relpath;
relpath = get_relative_path(utf8_base_path, utf8_fname);
msgwin_msg_add(COLOR_BLACK, -1, NULL, "%s:%lu:\n\t[%s]\t %s%s%s", relpath ? relpath : utf8_fname,
tag->line, tm_tag_type_name(tag), scopestr, tag->name, tag->arglist ? tag->arglist : "");
g_free(scopestr);
g_free(relpath);
g_free(utf8_fname);
}
}
msgwin_switch_tab(MSG_MESSAGE, TRUE);
g_free(name_case);
g_pattern_spec_free(pspec);
g_free(utf8_base_path);
g_free(locale_base_path);
}
ProteinsAnchorsSamplingSpace read_protein_anchors_mapping(
multifit::ProteomicsData *prots, const std::string &anchors_prot_map_fn,
int max_paths) {
ProteinsAnchorsSamplingSpace ret(prots);
std::fstream in;
IMP_LOG_TERSE("FN:" << anchors_prot_map_fn << std::endl);
in.open(anchors_prot_map_fn.c_str(), std::fstream::in);
if (!in.good()) {
IMP_WARN(
"Problem opening file " << anchors_prot_map_fn
<< " for reading; returning empty mapping data"
<< std::endl);
in.close();
return ret;
}
std::string line;
// first line should be the anchors line
getline(in, line);
std::string anchors_fn =
get_relative_path(anchors_prot_map_fn, parse_anchors_line(line));
IMP_LOG_TERSE("FN:" << anchors_fn << std::endl);
multifit::AnchorsData anchors_data =
multifit::read_anchors_data(anchors_fn.c_str());
ret.set_anchors(anchors_data);
ret.set_anchors_filename(anchors_fn);
while (!in.eof()) {
if (!getline(in, line)) break;
IMP_LOG_VERBOSE("working on line:" << line);
IMP_USAGE_CHECK(is_protein_line(line), "the line should be a protein line");
boost::tuple<std::string, std::string, IntsList> prot_data =
parse_protein_line(anchors_prot_map_fn, line, max_paths);
ret.set_paths_for_protein(boost::get<0>(prot_data),
boost::get<2>(prot_data));
ret.set_paths_filename_for_protein(boost::get<0>(prot_data),
boost::get<1>(prot_data));
}
return ret;
}
void
get_relative_path_debug (char const * from, char const * to, char const * expected)
{
char const * result = get_relative_path (from, to);
if ( result == NULL )
{
_exit(1);
}
else
{
int ok = (strcmp(result, expected) == 0) ? 1 : 0;
if (ok)
{
printf ("PASS: %s to %s is %s\n", from, to, result);
}
else
{
printf ("FAIL: %s to %s is %s, should be %s\n", from, to, result, expected);
_exit(1);
}
free ((void *)result);
}
}
const osd_directory_entry *zippath_readdir(zippath_directory *directory)
{
const osd_directory_entry *result = NULL;
const zip_file_header *header;
const char *relpath;
const char *separator;
const char *s;
zippath_returned_directory *rdent;
if (!directory->returned_parent)
{
/* first thing's first - return parent directory */
directory->returned_parent = true;
memset(&directory->returned_entry, 0, sizeof(directory->returned_entry));
directory->returned_entry.name = "..";
directory->returned_entry.type = ENTTYPE_DIR;
result = &directory->returned_entry;
}
else if (directory->directory != NULL)
{
/* a normal directory read */
do
{
result = osd_readdir(directory->directory);
}
while((result != NULL) && (!strcmp(result->name, ".") || !strcmp(result->name, "..")));
/* special case - is this entry a ZIP file? if so we need to return it as a "directory" */
if ((result != NULL) && is_zip_file(result->name))
{
/* copy; but change the entry type */
directory->returned_entry = *result;
directory->returned_entry.type = ENTTYPE_DIR;
result = &directory->returned_entry;
}
}
else if (directory->zipfile != NULL)
{
do
{
/* a zip file read */
do
{
if (!directory->called_zip_first)
header = zip_file_first_file(directory->zipfile);
else
header = zip_file_next_file(directory->zipfile);
directory->called_zip_first = true;
relpath = NULL;
}
while((header != NULL) && ((relpath = get_relative_path(directory, header)) == NULL));
if (relpath != NULL)
{
/* we've found a ZIP entry; but this may be an entry deep within the target directory */
for (s = relpath; *s && !is_zip_file_separator(*s); s++)
;
separator = *s ? s : NULL;
if (separator != NULL)
{
/* a nested entry; loop through returned_dirlist to see if we've returned the parent directory */
for (rdent = directory->returned_dirlist; rdent != NULL; rdent = rdent->next)
{
if (!core_strnicmp(rdent->name.c_str(), relpath, separator - relpath))
break;
}
if (rdent == NULL)
{
/* we've found a new directory; add this to returned_dirlist */
rdent = new zippath_returned_directory;
rdent->next = directory->returned_dirlist;
rdent->name.assign(relpath, separator - relpath);
directory->returned_dirlist = rdent;
/* ...and return it */
memset(&directory->returned_entry, 0, sizeof(directory->returned_entry));
directory->returned_entry.name = rdent->name.c_str();
directory->returned_entry.type = ENTTYPE_DIR;
result = &directory->returned_entry;
}
}
else
{
/* a real file */
memset(&directory->returned_entry, 0, sizeof(directory->returned_entry));
directory->returned_entry.name = relpath;
directory->returned_entry.type = ENTTYPE_FILE;
directory->returned_entry.size = header->uncompressed_length;
result = &directory->returned_entry;
}
}
}
while((relpath != NULL) && (result == NULL));
}
return result;
}
static void
amp_group_node_update_preset_variable (AmpGroupNode *group)
{
gchar *path;
AnjutaToken *value;
AmpVariable *var;
GFile *root;
GFile *file;
AnjutaProjectNode *node;
if (group->preset_token != NULL) anjuta_token_free (group->preset_token);
group->preset_token = anjuta_token_new_static (ANJUTA_TOKEN_FILE, NULL);
/* Get project root */
for (node = ANJUTA_PROJECT_NODE (group); anjuta_project_node_parent (node) != NULL; node = anjuta_project_node_parent (node));
root = anjuta_project_node_get_file (node);
/* Set source directory variables */
file = anjuta_project_node_get_file (group);
value = anjuta_token_insert_token_list (FALSE, NULL,
ANJUTA_TOKEN_LIST, NULL,
ANJUTA_TOKEN_ARGUMENT, NULL,
ANJUTA_TOKEN_CONTENT, ".",
NULL);
anjuta_token_append_child (group->preset_token, value);
var = amp_variable_new ("srcdir", 0, value);
g_hash_table_insert (group->variables, var->name, var);
var = amp_variable_new ("builddir", 0, value);
g_hash_table_insert (group->variables, var->name, var);
path = g_file_get_path (file);
value = anjuta_token_insert_token_list (FALSE, NULL,
ANJUTA_TOKEN_LIST, NULL,
ANJUTA_TOKEN_ARGUMENT, NULL,
ANJUTA_TOKEN_CONTENT, path,
NULL);
g_free (path);
anjuta_token_append_child (group->preset_token, value);
var = amp_variable_new ("abs_srcdir", 0, value);
g_hash_table_insert (group->variables, var->name, var);
var = amp_variable_new ("abs_builddir", 0, value);
g_hash_table_insert (group->variables, var->name, var);
path = get_relative_path (file, root);
value = anjuta_token_insert_token_list (FALSE, NULL,
ANJUTA_TOKEN_LIST, NULL,
ANJUTA_TOKEN_ARGUMENT, NULL,
ANJUTA_TOKEN_CONTENT, path,
NULL);
g_free (path);
anjuta_token_append_child (group->preset_token, value);
var = amp_variable_new ("top_srcdir", 0, value);
g_hash_table_insert (group->variables, var->name, var);
var = amp_variable_new ("top_builddir", 0, value);
g_hash_table_insert (group->variables, var->name, var);
path = g_file_get_path (root);
value = anjuta_token_insert_token_list (FALSE, NULL,
ANJUTA_TOKEN_LIST, NULL,
ANJUTA_TOKEN_ARGUMENT, NULL,
ANJUTA_TOKEN_CONTENT, path,
NULL);
g_free (path);
anjuta_token_append_child (group->preset_token, value);
var = amp_variable_new ("abs_top_srcdir", 0, value);
g_hash_table_insert (group->variables, var->name, var);
var = amp_variable_new ("abs_top_builddir", 0, value);
g_hash_table_insert (group->variables, var->name, var);
}
int main(int argc, char *argv[])
{
#define BINDIR "/mingw64/bin"
#define DATADIR "/mingw64/share"
char exe_path[PATH_MAX];
get_executable_path (argv[0], &exe_path[0], sizeof (exe_path) / sizeof (exe_path[0]));
printf ("executable path is %s\n", exe_path);
char * rel_to_datadir = get_relative_path (BINDIR, DATADIR);
if (strrchr (exe_path, '/') != NULL)
{
strrchr (exe_path, '/')[1] = '\0';
}
strcat (exe_path, rel_to_datadir);
simplify_path (&exe_path[0]);
printf("real path of DATADIR is %s\n", exe_path);
if (argc >= 2)
{
get_relative_path_debug (argv[argc-2], argv[argc-1], 0);
}
get_relative_path_debug (NULL, NULL, "./");
get_relative_path_debug ("/mingw64/bin", "/mingw64/etc/pkcs11/pkcs11.conf", "../etc/pkcs11/pkcs11.conf");
get_relative_path_debug ("/a/b/c/d", "/a/b/c", "..");
get_relative_path_debug ("/a/b/c/d/", "/a/b/c/", "../");
get_relative_path_debug ("/", "/", "/");
get_relative_path_debug ("/a/testone/c/d", "/a/testtwo/c", "../../../testtwo/c");
get_relative_path_debug ("/a/testone/c/d/", "/a/testtwo/c/", "../../../testtwo/c/");
get_relative_path_debug ("/home/part2/part3/part4", "/work/proj1/proj2", "../../../../work/proj1/proj2");
simplify_path_debug ("a/b/..", "a");
simplify_path_debug ("a/b/c/../../", "a/");
simplify_path_debug ("a/../a/..", "");
simplify_path_debug ("../a/../a/", "../a/");
simplify_path_debug ("./././", "./");
simplify_path_debug ("/test/", "/test/");
simplify_path_debug (".", ".");
simplify_path_debug ("..", "..");
simplify_path_debug ("../", "../");
simplify_path_debug ("././.", ".");
simplify_path_debug ("../..", "../..");
simplify_path_debug ("/", "/");
simplify_path_debug ("./test/", "./test/");
simplify_path_debug ("./test", "./test");
simplify_path_debug ("/test", "/test");
simplify_path_debug ("../test", "../test");
simplify_path_debug ("../../test", "../../test");
simplify_path_debug ("../test/..", "..");
simplify_path_debug (".././../", "../../");
sanitise_path_debug ("C:\\windows\\path", "C:/windows/path");
sanitise_path_debug ("", "");
sanitise_path_debug ("\\\\", "/");
char const * win_path = X509_get_default_private_dir ();
printf ("%s -> %s\n", X509_PRIVATE_DIR, win_path);
char * trusts = msys2_get_relocated_path_list (TRUST_PATHS);
printf ("%s -> %s\n", TRUST_PATHS, trusts);
free ((void*)trusts);
char * single = msys2_get_relocated_path_list (SINGLE_PATH_LIST);
printf ("%s -> %s\n", SINGLE_PATH_LIST, single);
free ((void*)single);
char *multi = get_relocated_path_list(BINDIR, TRUST_PATHS);
printf ("Source pathlist: %s \n", TRUST_PATHS);
printf ("Real pathlist: %s\n", multi);
free ((void*)multi);
return 0;
}
/* Send file through socket
* @param socket: file descriptor of client
* @param filename: name of the file
* @param position: index of the filename in absolute path
* @param fdout: file descriptor to write
*
* @return: return bytes sended
*/
int send_file(int socket, char filename[], int position, int fdout) {
file_t file;
struct stat stat_filename;
int numb_bytes;
int sended = 0;
char type;
bzero(&file, sizeof(file_t));
get_relative_path(file.name_of_file, filename, position);
stat(filename, &stat_filename);
/* if is a directory, send only the name of the directory */
if (stat_filename.st_mode & S_IFDIR) {
type = (char) DIRECTORY;
dprintf(fdout, "\tSending %s... ", filename);
file.size_string = (unsigned int) strlen(file.name_of_file) + 1;
/* tells server we are sending a directory */
write_to(socket, &type, sizeof(char));
write(socket, &file.size_string, sizeof(file.size_string));
write(socket, &file.name_of_file, (int) strlen(file.name_of_file) + 1);
DIR_S++;
dprintf(fdout, "OK\n");
return 0;
/* if is a file */
} else if (stat_filename.st_mode & S_IFDIR || \
stat_filename.st_mode & S_IFLNK) {
type = (char) FILE;
/* open file to read */
file.fd_file = open(filename, O_RDONLY);
file.size_file = (unsigned int) stat_filename.st_size;
file.size_string = (unsigned int) strlen(file.name_of_file) + 1;
dprintf(fdout, "\tSending %s... ", filename);
/* tells server we are sending a file */
write_to(socket, &type, sizeof(char));
write_to(socket, &file.size_file, sizeof(file.size_file));
write_to(socket, &file.size_string, sizeof(file.size_string));
write_to(socket, &file.name_of_file, (int)strlen(file.name_of_file) + 1);
while (TRUE) {
numb_bytes = sendfile(socket, file.fd_file, NULL, SIZE_BUF);
if (numb_bytes < 0) {
error("ERROR");
return errno;
}
sended += numb_bytes;
if (sended == file.size_file)
break;
}
dprintf(fdout, "OK\n");
/*
printf("\t\tSended %.3f of %.3f kB [%.3f%%]\n",
sended/1000., file.size_file/1000.,
(sended*100.)/file.size_file);
*/
FILES_S++;
close(file.fd_file);
return sended;
}
return -1;
}
char *
get_relocated_path_list(char const * from, char const * to_path_list)
{
char exe_path[MAX_PATH];
char * temp;
get_executable_path (NULL, &exe_path[0], sizeof (exe_path) / sizeof (exe_path[0]));
if ((temp = strrchr (exe_path, '/')) != NULL)
{
temp[1] = '\0';
}
char **arr = NULL;
/* Ask Alexey why he added this. Are we not 100% sure
that we're dealing with unix paths here? */
char split_char = ':';
if (strchr (to_path_list, ';'))
{
split_char = ';';
}
size_t count = split_path_list (to_path_list, split_char, &arr);
int result_size = 1 + (count - 1); /* count - 1 is for ; delim. */
size_t exe_path_size = strlen (exe_path);
size_t i;
/* Space required is:
count * (exe_path_size + strlen (rel_to_datadir))
rel_to_datadir upper bound is:
(count * strlen (from)) + (3 * num_slashes (from))
+ strlen(arr[i]) + 1.
.. pathalogically num_slashes (from) is strlen (from)
(from = ////////) */
size_t space_required = (count * (exe_path_size + 4 * strlen (from))) + count - 1;
for (i = 0; i < count; ++i)
{
space_required += strlen (arr[i]);
}
char * scratch = (char *) alloca (space_required);
if (scratch == NULL)
return NULL;
for (i = 0; i < count; ++i)
{
char * rel_to_datadir = get_relative_path (from, arr[i]);
scratch[0] = '\0';
arr[i] = scratch;
strcat (scratch, exe_path);
strcat (scratch, rel_to_datadir);
simplify_path (arr[i]);
size_t arr_i_size = strlen (arr[i]);
result_size += arr_i_size;
scratch = arr[i] + arr_i_size + 1;
}
char * result = (char *) malloc (result_size);
if (result == NULL)
{
return NULL;
}
result[0] = '\0';
for (i = 0; i < count; ++i)
{
strcat (result, arr[i]);
if (i != count-1)
{
#if defined(_WIN32)
strcat (result, ";");
#else
strcat (result, ":");
#endif
}
}
free ((void*)arr);
return result;
}
gboolean
amp_source_node_create_token (AmpProject *project, AmpSourceNode *source, GError **error)
{
AmpGroupNode *group;
AmpTargetNode *target;
AnjutaProjectNode *sibling;
gboolean after;
AnjutaToken *token;
AnjutaToken *prev;
AnjutaToken *args;
gchar *relative_name;
/* Get parent target */
target = AMP_TARGET_NODE (anjuta_project_node_parent_type (ANJUTA_PROJECT_NODE (source), ANJUTA_PROJECT_TARGET));
if (target == NULL) return FALSE;
group = AMP_GROUP_NODE (anjuta_project_node_parent_type (ANJUTA_PROJECT_NODE (target), ANJUTA_PROJECT_GROUP));
relative_name = get_relative_path (anjuta_project_node_get_file (ANJUTA_PROJECT_NODE (group)), anjuta_project_node_get_file (ANJUTA_PROJECT_NODE (source)));
/* Add in Makefile.am */
/* Find a sibling if possible */
after = TRUE;
for (sibling = anjuta_project_node_prev_sibling (ANJUTA_PROJECT_NODE (source)); sibling != NULL; sibling = anjuta_project_node_prev_sibling (sibling))
{
if (anjuta_project_node_get_node_type (sibling) == ANJUTA_PROJECT_SOURCE)
{
break;
}
else if (anjuta_project_node_get_node_type (sibling) == ANJUTA_PROJECT_OBJECT)
{
sibling = anjuta_project_node_first_child (sibling);
break;
}
}
if (sibling == NULL)
{
after = FALSE;
for (sibling = anjuta_project_node_next_sibling (ANJUTA_PROJECT_NODE (source)); sibling != NULL; sibling = anjuta_project_node_next_sibling (sibling))
{
if (anjuta_project_node_get_node_type (sibling) == ANJUTA_PROJECT_SOURCE)
{
break;
}
else if (anjuta_project_node_get_node_type (sibling) == ANJUTA_PROJECT_OBJECT)
{
sibling = anjuta_project_node_first_child (sibling);
break;
}
}
}
if (sibling == NULL)
{
after = TRUE;
prev = NULL;
args = NULL;
}
else
{
prev = amp_source_node_get_token (AMP_SOURCE_NODE (sibling));
args = anjuta_token_list (prev);
}
/* Check if a valid source variable is already defined */
if (args == NULL)
{
GList *last;
for (last = amp_target_node_get_token (target, AM_TOKEN__SOURCES); last != NULL; last = g_list_next (last))
{
args = anjuta_token_last_item ((AnjutaToken *)last->data);
break;
}
if (last == NULL)
{
for (last = amp_target_node_get_token (target, AM_TOKEN__DATA); last != NULL; last = g_list_next (last))
{
args = anjuta_token_last_item ((AnjutaToken *)last->data);
break;
}
}
}
if (args == NULL)
{
gchar *target_var;
gchar *canon_name;
AnjutaToken *var;
canon_name = canonicalize_automake_variable (anjuta_project_node_get_name (ANJUTA_PROJECT_NODE (target)));
target_var = g_strconcat (canon_name, "_SOURCES", NULL);
var = anjuta_token_find_target_property_position (target, AM_TOKEN__SOURCES);
if (var == NULL)
var = anjuta_token_find_target_property_position (target, AM_TOKEN__DATA);
args = anjuta_token_insert_token_list (FALSE, var,
ANJUTA_TOKEN_LIST, NULL,
ANJUTA_TOKEN_NAME, target_var,
ANJUTA_TOKEN_SPACE, " ",
ANJUTA_TOKEN_OPERATOR, "=",
ANJUTA_TOKEN_LIST, NULL,
ANJUTA_TOKEN_SPACE, " ",
NULL);
args = anjuta_token_last_item (args);
g_free (target_var);
}
if (args != NULL)
{
AnjutaTokenStyle *style;
style = anjuta_token_style_new_from_base (project->am_space_list);
anjuta_token_style_update (style, args);
token = anjuta_token_new_string (ANJUTA_TOKEN_NAME | ANJUTA_TOKEN_ADDED, relative_name);
if (after)
{
anjuta_token_insert_word_after (args, prev, token);
}
else
{
anjuta_token_insert_word_before (args, prev, token);
}
/* Try to use the same style than the current target list */
anjuta_token_style_format (style, args);
anjuta_token_style_free (style);
amp_group_node_update_makefile (group, token);
amp_source_node_add_token (source, token);
}
return TRUE;
}
