wordsplit_perror (wsp);
return ec;
}
-
+
static int
_wsplt_nomem (struct wordsplit *wsp)
{
unsigned flags, int finalize)
{
int rc;
-
+
wss->ws_delim = wsp->ws_delim;
wss->ws_debug = wsp->ws_debug;
wss->ws_error = wsp->ws_error;
}
wss->ws_options = wsp->ws_options;
-
+
flags |= WRDSF_DELIM
| WRDSF_ALLOC_DIE
| WRDSF_ERROR
}
char wordsplit_c_escape_tab[] = "\\\\\"\"a\ab\bf\fn\nr\rt\tv\v";
-
+
static int
wordsplit_init (struct wordsplit *wsp, const char *input, size_t len,
unsigned flags)
{
wsp->ws_escape[WRDSX_WORD] = wordsplit_c_escape_tab;
wsp->ws_escape[WRDSX_QUOTE] = wordsplit_c_escape_tab;
- wsp->ws_options |= WRDSO_OESC_QUOTE | WRDSO_OESC_WORD
+ wsp->ws_options |= WRDSO_OESC_QUOTE | WRDSO_OESC_WORD
| WRDSO_XESC_QUOTE | WRDSO_XESC_WORD;
}
else
wsp->ws_options |= WRDSO_BSKEEP_QUOTE;
}
}
-
+
wsp->ws_endp = 0;
wsp->ws_wordi = 0;
if (wsp->ws_flags & WRDSF_REUSE)
wordsplit_free_nodes (wsp);
wsp->ws_head = wsp->ws_tail = NULL;
-
+
wordsplit_init0 (wsp);
-
+
return 0;
}
return p->v.segm.end - p->v.segm.beg;
}
-static int
-wsnode_new (struct wordsplit *wsp, struct wordsplit_node **pnode)
+static struct wordsplit_node *
+wsnode_new (struct wordsplit *wsp)
{
struct wordsplit_node *node = calloc (1, sizeof (*node));
if (!node)
- return _wsplt_nomem (wsp);
- *pnode = node;
- return 0;
+ _wsplt_nomem (wsp);
+ return node;
}
static void
static int
wordsplit_add_segm (struct wordsplit *wsp, size_t beg, size_t end, int flg)
{
- struct wordsplit_node *node;
- int rc;
-
if (end == beg && !(flg & _WSNF_EMPTYOK))
return 0;
- rc = wsnode_new (wsp, &node);
- if (rc)
- return rc;
+ struct wordsplit_node *node = wsnode_new (wsp);
+ if (!node)
+ return 1;
node->flags = flg & ~(_WSNF_WORD | _WSNF_EMPTYOK);
node->v.segm.beg = beg;
node->v.segm.end = end;
if (!(node->flags & _WSNF_JOIN))
return 0;
-
+
for (p = node; p && (p->flags & _WSNF_JOIN); p = p->next)
{
len += wsnode_len (p);
Nodes of type _WSNF_DELIM get inserted to the node list if either
WRDSF_RETURN_DELIMS flag or WRDSO_MAXWORDS option is set.
-
+
The following cases should be distinguished:
1. If both WRDSF_SQUEEZE_DELIMS and WRDSF_RETURN_DELIMS are set, compress
continue;
}
}
- else
+ else
{
if (delim)
{
struct wordsplit_node *node,
size_t beg, size_t len, int flg)
{
- struct wordsplit_node *newnode;
if (len == 0)
return 0;
- if (wsnode_new (wsp, &newnode))
+ struct wordsplit_node *newnode = wsnode_new (wsp);
+ if (!newnode)
return 1;
wsnode_insert (wsp, newnode, *ptail, 0);
if (node->flags & _WSNF_WORD)
break;
}
break;
-
+
case '"':
state = st_dquote;
break;
{
int n = (wsp->ws_flags & WRDSF_ENV_KV) ? 2 : 1;
char *v;
-
+
if (wsp->ws_envidx + n >= wsp->ws_envsiz)
{
size_t sz;
for (; wsp->ws_env[i]; i++)
;
}
-
+
sz = i + n + 1;
newenv = calloc (sz, sizeof(newenv[0]));
}
}
newenv[j] = NULL;
-
+
wsp->ws_envbuf = newenv;
wsp->ws_envidx = i;
wsp->ws_envsiz = sz;
wsp->ws_env = (const char**) wsp->ws_envbuf;
}
}
-
+
if (wsp->ws_flags & WRDSF_ENV_KV)
{
/* A key-value pair environment */
const char *start = str - 1;
int rc;
struct wordsplit ws;
-
+
if (ISVARBEG (str[0]))
{
for (i = 1; i < len; i++)
if (str[i] == ':')
{
size_t j;
-
+
defstr = str + i + 1;
if (find_closing_paren (str, i + 1, len, &j, "{}"))
return _wsplt_seterr (wsp, WRDSE_CBRACE);
else if (strchr ("-+?=", str[i]))
{
size_t j;
-
+
defstr = str + i;
if (find_closing_paren (str, i, len, &j, "{}"))
return _wsplt_seterr (wsp, WRDSE_CBRACE);
}
else
{
- if (wsnode_new (wsp, &newnode))
+ newnode = wsnode_new (wsp);
+ if (!newnode)
return 1;
wsnode_insert (wsp, newnode, *ptail, 0);
*ptail = newnode;
rc = WRDSE_UNDEF;
}
}
-
+
switch (rc)
{
case WRDSE_OK:
wordsplit_free (&ws);
}
break;
-
+
case WRDSE_UNDEF:
if (defstr)
{
value = ws.ws_wordv[0];
ws.ws_wordv[0] = NULL;
wordsplit_free (&ws);
-
+
if (defstr[-1] == '=')
wsplt_assign_var (wsp, str, i, value);
}
- else
+ else
{
if (*defstr == '?')
{
}
}
break;
-
+
case WRDSE_NOSPACE:
return _wsplt_nomem (wsp);
{
if (flg & _WSNF_QUOTE)
{
- if (wsnode_new (wsp, &newnode))
+ newnode = wsnode_new (wsp);
+ if (!newnode)
{
free (value);
return 1;
{
free (value);
/* Empty string is a special case */
- if (wsnode_new (wsp, &newnode))
+ newnode = wsnode_new (wsp);
+ if (!newnode)
return 1;
wsnode_insert (wsp, newnode, *ptail, 0);
*ptail = newnode;
{
struct wordsplit ws;
int rc;
-
+
rc = _wsplt_subsplit (wsp, &ws, value, strlen (value),
WRDSF_NOVAR | WRDSF_NOCMD |
WRDSF_QUOTE
{
size_t size = *pend - start + 1;
- if (wsnode_new (wsp, &newnode))
+ newnode = wsnode_new (wsp);
+ if (!newnode)
return 1;
wsnode_insert (wsp, newnode, *ptail, 0);
*ptail = newnode;
}
else
{
- if (wsnode_new (wsp, &newnode))
+ newnode = wsnode_new (wsp);
+ if (!newnode)
return 1;
wsnode_insert (wsp, newnode, *ptail, 0);
*ptail = newnode;
}
return 0;
}
-
+
/* Remove NULL nodes from the list */
static void
wsnode_nullelim (struct wordsplit *wsp)
size_t j;
char *value;
struct wordsplit_node *newnode;
-
+
str++;
len--;
}
else
rc = wsp->ws_command (&value, str, j, NULL, wsp->ws_closure);
-
+
if (rc == WRDSE_NOSPACE)
return _wsplt_nomem (wsp);
else if (rc)
{
if (flg & _WSNF_QUOTE)
{
- if (wsnode_new (wsp, &newnode))
+ newnode = wsnode_new (wsp);
+ if (!newnode)
return 1;
wsnode_insert (wsp, newnode, *ptail, 0);
*ptail = newnode;
{
free (value);
/* Empty string is a special case */
- if (wsnode_new (wsp, &newnode))
+ newnode = wsnode_new (wsp);
+ if (!newnode)
return 1;
wsnode_insert (wsp, newnode, *ptail, 0);
*ptail = newnode;
}
else
{
- if (wsnode_new (wsp, &newnode))
+ newnode = wsnode_new (wsp);
+ if (!newnode)
return 1;
wsnode_insert (wsp, newnode, *ptail, 0);
*ptail = newnode;
;
p->v.segm.beg = n;
}
-
+
while (p->next && (p->flags & _WSNF_JOIN))
p = p->next;
-
+
if (p->flags & _WSNF_QUOTE)
continue;
-
+
/* Trim trailing whitespace */
for (n = p->v.segm.end;
n > p->v.segm.beg && ISWS (wsp->ws_input[n - 1]); n--);
struct wordsplit_node *p;
char *uname = NULL;
size_t usize = 0;
-
+
for (p = wsp->ws_head; p; p = p->next)
{
const char *str;
size_t slen = wsnode_len (p);
struct passwd *pw;
char *newstr;
-
+
for (i = 1; i < slen && str[i] != '/'; i++)
;
if (i == slen)
if (wsp->ws_options & WRDSO_DOTGLOB)
flags = GLOB_PERIOD;
#endif
-
+
for (p = wsp->ws_head; p; p = next)
{
const char *str;
glob_t g;
struct wordsplit_node *prev;
char *pattern;
-
+
pattern = malloc (slen + 1);
if (!pattern)
return _wsplt_nomem (wsp);
memcpy (pattern, str, slen);
pattern[slen] = 0;
-
+
switch (glob (pattern, flags, NULL, &g))
{
case 0:
free (pattern);
break;
-
+
case GLOB_NOSPACE:
free (pattern);
return _wsplt_nomem (wsp);
-
+
case GLOB_NOMATCH:
if (wsp->ws_options & WRDSO_NULLGLOB)
{
}
free (pattern);
continue;
-
+
default:
free (pattern);
return _wsplt_seterr (wsp, WRDSE_GLOBERR);
prev = p;
for (i = 0; i < g.gl_pathc; i++)
{
- struct wordsplit_node *newnode;
+ struct wordsplit_node *newnode = wsnode_new (wsp);
char *newstr;
-
- if (wsnode_new (wsp, &newnode))
+
+ if (!newnode)
return 1;
newstr = strdup (g.gl_pathv[i]);
if (!newstr)
int join = 0;
unsigned flags = 0;
struct wordsplit_node *np = wsp->ws_tail;
-
+
size_t i = start;
if (i >= len)
wsp->ws_endp = i;
if (wsp->ws_flags & WRDSF_INCREMENTAL)
return _WRDS_EOF;
-
+
if (consume_all)
{
if (!np)
np = np->next;
}
}
-
+
return _WRDS_OK;
}
if (wsp->ws_flags & WRDSF_SHOWDBG)
wsp->ws_debug (_("(%02d) Input:%.*s;"),
wsp->ws_lvl, (int) wsp->ws_len, wsp->ws_input);
-
+
if ((wsp->ws_flags & WRDSF_NOSPLIT)
|| ((wsp->ws_options & WRDSO_MAXWORDS)
&& wsp->ws_wordi + 1 == wsp->ws_maxwords))
}
int
-wordsplit_len (const char *command, size_t length, struct wordsplit *wsp,
+wordsplit_len (const char *command, size_t length, struct wordsplit *wsp,
unsigned flags)
{
return wordsplit_run (command, length, wsp, flags, 0);
wsp->ws_error ("%s", wordsplit_strerror (wsp));
}
}
-
data->change_dir = chdir_current;
data->cntx_name = NULL;
if (st)
- assign_string (&data->cntx_name, st->cntx_name);
+ assign_string_or_null (&data->cntx_name, st->cntx_name);
if (st && st->acls_a_ptr)
{
data->acls_a_ptr = xmemdup (st->acls_a_ptr, st->acls_a_len + 1);
first. If it doesn't exist, there is no matching entry in the list.
Otherwise, look for the entry in list which has the matching dev
and ino numbers.
-
+
This approach avoids scanning the singly-linked list in obvious cases
and does not rely on comparing file names, which may differ for
various reasons (e.g. relative vs. absolute file names).
if (!delayed_link_head)
return NULL;
-
+
if (fstatat (chdir_fd, name, &st, AT_SYMLINK_NOFOLLOW))
{
if (errno != ENOENT)
stat_error (name);
return NULL;
}
-
+
for (dl = delayed_link_head; dl; dl = dl->next)
{
if (dl->dev == st.st_dev && dl->ino == st.st_ino)
}
return dl;
}
-
+
/* Create a placeholder file with name FILE_NAME, which will be
replaced after other extraction is done by a symbolic link if
IS_SYMLINK is true, and by a hard link otherwise. Set
*/
return 0;
}
-
+
switch (maybe_recoverable (file_name, false, interdir_made))
{
case RECOVER_OK:
p->sources->next = 0;
strcpy (p->sources->string, file_name);
p->cntx_name = NULL;
- assign_string (&p->cntx_name, current_stat_info.cntx_name);
+ assign_string_or_null (&p->cntx_name, current_stat_info.cntx_name);
p->acls_a_ptr = NULL;
p->acls_a_len = 0;
p->acls_d_ptr = NULL;
char const *link_name;
int rc;
struct delayed_link *dl;
-
+
link_name = current_stat_info.link_name;
if (! absolute_names_option && contains_dot_dot (link_name))
dl = find_delayed_link_source (link_name);
if (dl)
return create_placeholder_file (file_name, false, &interdir_made, dl);
-
+
do
{
struct stat st1, st2;
case GNUTYPE_VOLHDR:
return false;
-
+
case GNUTYPE_MULTIVOL:
ERROR ((0, 0,
_("%s: Cannot extract -- file is continued from another volume"),
}
}
*fun = extractor;
-
+
return true;
}
/* Assign STRING to a copy of VALUE if not zero, or to zero. If
STRING was nonzero, it is freed first. */
+void
+assign_string_or_null (char **string, const char *value)
+{
+ if (value)
+ assign_string (string, value);
+ else
+ assign_null (string);
+}
+
void
assign_string (char **string, const char *value)
{
free (*string);
- *string = value ? xstrdup (value) : 0;
+ *string = xstrdup (value);
+}
+
+void
+assign_null (char **string)
+{
+ char *old = *string;
+ *string = NULL;
+ free (old);
}
void
p[l] = 0;
*string = p;
}
+ else
+ *string = NULL;
}
#if 0
possible, real problems are unlikely. Doing any better would require a
convention, GNU-wide, for all programs doing backups. */
- assign_string (&after_backup_name, 0);
+ assign_null (&after_backup_name);
/* Check if we really need to backup the file. */
ERROR ((0, e, _("%s: Cannot rename to %s"),
quotearg_colon (before_backup_name),
quote_n (1, after_backup_name)));
- assign_string (&after_backup_name, 0);
+ assign_null (&after_backup_name);
return false;
}
}
fprintf (stdlis, _("Renaming %s back to %s\n"),
quote_n (0, after_backup_name),
quote_n (1, before_backup_name));
- assign_string (&after_backup_name, 0);
+ assign_null (&after_backup_name);
}
}
{
int i;
int save_cwdi = chdir_current;
-
+
for (i = idx; i >= 0; i--)
if (wd[i].abspath)
break;
-
+
while (++i <= idx)
{
chdir_do (i);
chdir_do (save_cwdi);
}
-
+
return wd[idx].abspath;
}
\f
projects / thirdparty / tar.git / commitdiff
