bool CompilerInterface::restrictArgs(const char* selected_source,Argv &backup_args )
{
FUNCTION_TRACE;
int i;
backup_args=param_args();
Argv new_args;
for (i=0;i<backup_args.argc();i++)
{
const char *file=backup_args[i];
if (!isSource(file) || filename_strcmp(selected_source,file)==0)
new_args.append(file);
}
setArgs(new_args);
return true;
}
/**
* open an => ZZIP_FILE from an already open => ZZIP_DIR handle. Since
* we have a chance to reuse a cached => buf32k and => ZZIP_FILE memchunk
* this is the best choice to unpack multiple files.
*
* Note: the zlib supports 2..15 bit windowsize, hence we provide a 32k
* memchunk here... just to be safe.
*
* On error it returns null and sets errcode in the ZZIP_DIR.
*/
ZZIP_FILE *
zzip_file_open(ZZIP_DIR * dir, zzip_char_t * name, int o_mode)
{
auto int self;
zzip_error_t err = 0;
struct zzip_file *fp = 0;
struct zzip_dir_hdr *hdr = dir->hdr0;
int (*filename_strcmp) (zzip_char_t *, zzip_char_t *);
zzip_char_t* (*filename_basename)(zzip_char_t*);
filename_strcmp = (o_mode & ZZIP_CASELESS) ? dirsep_strcasecmp : strcmp;
filename_basename = (o_mode & ZZIP_CASELESS) ? dirsep_basename : strrchr_basename;
if (! dir)
return NULL;
if (! dir->fd || dir->fd == -1)
{ /* dir->errcode = EBADF; */ return NULL; }
if (! hdr)
{ /* dir->errcode = ENOENT; */ return NULL; }
if (o_mode & ZZIP_NOPATHS)
name = filename_basename(name);
while (1)
{
register zzip_char_t *hdr_name = hdr->d_name;
if (o_mode & ZZIP_NOPATHS)
hdr_name = filename_basename(hdr_name);
HINT4("name='%s', compr=%d, size=%d\n",
hdr->d_name, hdr->d_compr, hdr->d_usize);
if (! filename_strcmp(hdr_name, name))
{
switch (hdr->d_compr)
{
case 0: /* store */
case 8: /* inflate */
break;
default:
{ /*err = ZZIP_UNSUPP_COMPR; */ goto error; }
}
if (dir->cache.locked == NULL)
dir->cache.locked = &self;
if (dir->cache.locked == &self && dir->cache.fp)
{
fp = dir->cache.fp;
dir->cache.fp = NULL;
/* memset(zfp, 0, sizeof *fp); cleared in zzip_file_close() */
} else
{
if (! (fp = (ZZIP_FILE *) calloc(1, sizeof(*fp))))
{ /* err = ZZIP_OUTOFMEM; */ goto error; }
}
fp->dir = dir;
fp->io = dir->io;
dir->refcount++;
if (dir->cache.locked == &self && dir->cache.buf32k)
{
fp->buf32k = dir->cache.buf32k;
dir->cache.buf32k = NULL;
} else
{
if (! (fp->buf32k = (char *) malloc(ZZIP_32K)))
{ /* err = ZZIP_OUTOFMEM; */ goto error; }
}
if (dir->cache.locked == &self)
dir->cache.locked = NULL;
/*
* In order to support simultaneous open files in one zip archive
* we'll fix the fd offset when opening new file/changing which
* file to read...
*/
if (zzip_file_saveoffset(dir->currentfp) < 0)
{ /* err = ZZIP_DIR_SEEK; */ goto error; }
fp->offset = hdr->d_off;
dir->currentfp = fp;
if (dir->io->fd.seeks(dir->fd, hdr->d_off, SEEK_SET) < 0)
{ /* err = ZZIP_DIR_SEEK; */ goto error; }
{
/* skip local header - should test tons of other info,
* but trust that those are correct */
zzip_ssize_t dataoff;
struct zzip_file_header *p = (void *) fp->buf32k;
dataoff = dir->io->fd.read(dir->fd, (void *) p, sizeof(*p));
if (dataoff < (zzip_ssize_t) sizeof(*p))
{ /* err = ZZIP_DIR_READ; */ goto error; }
if (! zzip_file_header_check_magic(p)) /* PK\3\4 */
{ /* err = ZZIP_CORRUPTED; */ goto error; }
dataoff = zzip_file_header_sizeof_tail(p);
if (dir->io->fd.seeks(dir->fd, dataoff, SEEK_CUR) < 0)
{ /* err = ZZIP_DIR_SEEK; */ goto error; }
fp->dataoffset = dir->io->fd.tells(dir->fd);
fp->usize = hdr->d_usize;
fp->csize = hdr->d_csize;
}
err = zzip_inflate_init(fp, hdr);
if (err)
goto error;
return fp;
} else
{
if (hdr->d_reclen == 0)
break;
hdr = (struct zzip_dir_hdr *) ((char *) hdr + hdr->d_reclen);
} /*filename_strcmp */
} /*forever */
#ifdef ZZIP_DISABLED
dir->errcode = ZZIP_ENOENT;
#endif /* ZZIP_DISABLED */
return NULL;
error:
if (fp)
zzip_file_close(fp);
#ifdef ZZIP_DISABLED
dir->errcode = err;
#endif /* ZZIP_DISABLED */
return NULL;
}
