init()
{
register COLUMN *cp;
register COLUMN *cend;
register char *sp;
length = 0;
maxpos = MAXCOL;
sp = malloc((unsigned) maxpos);
if (sp == NULL)
nospace();
text = sp;
highcol = -1;
maxcol = MAXCOL;
line = (COLUMN *) calloc(maxcol, (unsigned) sizeof(COLUMN));
if (line == NULL)
nospace();
cp = line;
cend = line + (maxcol-1);
while (cp <= cend)
{
cp->width = INITWIDTH;
sp = calloc(INITWIDTH, (unsigned) sizeof(char));
if (sp == NULL)
nospace();
cp->str = sp;
cp++;
}
}
CString* CString_epur(CString* str)
{
char* s = str->str;
size_t u, n = 0;
for (u = 0; s[u]; ++u)
if (nospace(s[u]))
s[n] = s[u], ++n;
else if (n && nospace(s[n - 1]) && nospace(s[u + 1]))
s[n] = ' ', ++n;
s[n] = '\0';
str->size = n;
return str;
}
static int
mime_getprologue(Pax_t* pax, Format_t* fp, register Archive_t* ap, File_t* f, unsigned char* buf, size_t size)
{
register Mime_t* mime;
char* s;
char* t;
size_t n;
s = state.tmp.buffer;
if (paxread(pax, ap, s, (off_t)0, (off_t)MIME_HEADER, 0) <= 0)
return 0;
paxunread(pax, ap, s, MIME_HEADER);
if (s[0] != '-' || s[1] != '-' || !(t = (char*)memchr(s, '\n', MIME_HEADER - 2)) || (t - s + 8) >= MIME_HEADER || strncasecmp(t + 1, "Content", 7))
return 0;
n = t - s + 1;
if (t > s && *(t - 1) == '\r')
t--;
n = t - s;
if (!(mime = newof(0, Mime_t, 1, n)))
{
nospace();
return -1;
}
ap->data = mime;
mime->length = n;
memcpy(mime->magic, s, mime->length);
message((-1, "mime magic `%s'", mime->magic));
paxread(pax, ap, NiL, (off_t)0, n, 0);
return 1;
}
//----------------------------------
// Event EV_EN_CHANGE for ID_FUNCNAME
//----------------------------------
void UserFunc::EvChangeFuncname(void)
{
char sFun[MAXPATHSIZE];
char sArg[MAXPATHSIZE];
m_FuncName->GetText(sFun,sizeof(sFun));
strcpy(sArg,"void");
//
char *p = strchr(sFun,'(');
if(p)
{
*p = NULL;
p++;
if(*p != NULL)
sprintf(sArg,"%s",p);
p = strchr(sArg,')');
if(p)
*p = NULL;
}
//
char s[MAXPATHSIZE];
nospace(sFun,s); strcpy(sFun,s);
onespace(sArg,s); strcpy(sArg,s);
// allow "operator++()" type of functions
if( p== NULL || (strncmp(sFun,"operator",8) != 0 && ValidateSymbol(sFun)) )
{
char s[MAXPATHSIZE];
sprintf(s,"%s(%s)",sFun,sArg);
onespace(s,sFun);
m_FuncName->SetText(sFun);
}
}
void Insert(char *name, int value, List L) { // 插入新变量
Position TmpCell;
TmpCell = malloc(sizeof(struct listnode)); // 申请新变量空间
if (TmpCell == NULL) { // 失败
nospace();
}
// 赋值
TmpCell->name = malloc(sizeof(char)* strlen(name) + 1);
if (TmpCell->name == NULL) {
nospace();
}
strcpy(TmpCell->name, name);
// TmpCell -> name = name;
TmpCell->addr = nowAddr;
nowAddr += 1;
TmpCell->value = value;
TmpCell->Next = L->Next;
L->Next = TmpCell;
}
static int
ar_getprologue(Pax_t* pax, Format_t* fp, register Archive_t* ap, register File_t* f, unsigned char* buf, size_t size)
{
Ar_t* ar;
Ardir_t* dir;
if (!(dir = ardiropen(ap->name, NiL, 0)))
return 0;
if (!(ar = newof(0, Ar_t, 1, 0)))
{
ardirclose(dir);
nospace();
return -1;
}
ap->data = ar;
ar->dir = dir;
ap->type = (char*)dir->meth->name;
return 1;
}
gettxt()
{
register int i;
register char ateol;
register int ch;
register int pos;
i = 0;
ateol = FALSE;
while ( ! ateol)
{
ch = getchar();
if (ch == EOL || ch == EOF)
ateol = TRUE;
else if (ch == TAB)
{
pos = (1 + i/TABSIZE) * TABSIZE;
if (pos > maxpos)
{
maxpos = pos + 10;
text = realloc(text, (unsigned) maxpos);
if (text == NULL)
nospace();
}
while (i < pos)
{
text[i] = BLANK;
i++;
}
}
else if (ch == BS)
{
if (i > 0)
{
i--;
savech(i);
}
}
else if (ch == CR)
{
while (i > 0)
{
i--;
savech(i);
}
}
else if (ch == FF || ch == VTAB)
{
flush();
cc = ch;
i = 0;
}
else
{
if (i >= maxpos)
{
maxpos = i + 10;
text = realloc(text, (unsigned) maxpos);
if (text == NULL)
nospace();
}
text[i] = ch;
i++;
}
}
length = i;
}
static void
rtintinsert(Relation r,
RTSTACK *stk,
IndexTuple ltup,
IndexTuple rtup,
RTSTATE *rtstate)
{
IndexTuple old;
Buffer b;
Page p;
Datum ldatum,
rdatum,
newdatum;
if (stk == NULL)
{
rtnewroot(r, ltup, rtup);
return;
}
b = ReadBuffer(r, stk->rts_blk);
p = BufferGetPage(b);
old = (IndexTuple) PageGetItem(p, PageGetItemId(p, stk->rts_child));
/*
* This is a hack. Right now, we force rtree internal keys to be constant
* size. To fix this, need delete the old key and add both left and right
* for the two new pages. The insertion of left may force a split if the
* new left key is bigger than the old key.
*/
if (IndexTupleSize(old) != IndexTupleSize(ltup))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("variable-length rtree keys are not supported")));
/* install pointer to left child */
memmove(old, ltup, IndexTupleSize(ltup));
if (nospace(p, rtup))
{
newdatum = IndexTupleGetDatum(ltup);
rttighten(r, stk->rts_parent, newdatum,
IndexTupleAttSize(ltup), rtstate);
rtdosplit(r, b, stk->rts_parent, rtup, rtstate);
WriteBuffer(b); /* don't forget to release buffer! - 01/31/94 */
}
else
{
if (PageAddItem(p, (Item) rtup, IndexTupleSize(rtup),
PageGetMaxOffsetNumber(p),
LP_USED) == InvalidOffsetNumber)
elog(ERROR, "failed to add index item to \"%s\"",
RelationGetRelationName(r));
WriteBuffer(b);
ldatum = IndexTupleGetDatum(ltup);
rdatum = IndexTupleGetDatum(rtup);
newdatum = FunctionCall2(&rtstate->unionFn, ldatum, rdatum);
rttighten(r, stk->rts_parent, newdatum,
IndexTupleAttSize(rtup), rtstate);
pfree(DatumGetPointer(newdatum));
}
}
static void
rtdoinsert(Relation r, IndexTuple itup, RTSTATE *rtstate)
{
Page page;
Buffer buffer;
BlockNumber blk;
IndexTuple which;
OffsetNumber l;
RTSTACK *stack;
RTreePageOpaque opaque;
Datum datum;
blk = P_ROOT;
buffer = InvalidBuffer;
stack = NULL;
do
{
/* release the current buffer, read in the next one */
buffer = ReleaseAndReadBuffer(buffer, r, blk);
page = (Page) BufferGetPage(buffer);
opaque = (RTreePageOpaque) PageGetSpecialPointer(page);
if (!(opaque->flags & F_LEAF))
{
RTSTACK *n;
ItemId iid;
n = (RTSTACK *) palloc(sizeof(RTSTACK));
n->rts_parent = stack;
n->rts_blk = blk;
n->rts_child = choose(r, page, itup, rtstate);
stack = n;
iid = PageGetItemId(page, n->rts_child);
which = (IndexTuple) PageGetItem(page, iid);
blk = ItemPointerGetBlockNumber(&(which->t_tid));
}
} while (!(opaque->flags & F_LEAF));
if (nospace(page, itup))
{
/* need to do a split */
rtdosplit(r, buffer, stack, itup, rtstate);
freestack(stack);
WriteBuffer(buffer); /* don't forget to release buffer! */
return;
}
/* add the item and write the buffer */
if (PageIsEmpty(page))
{
l = PageAddItem(page, (Item) itup, IndexTupleSize(itup),
FirstOffsetNumber,
LP_USED);
}
else
{
l = PageAddItem(page, (Item) itup, IndexTupleSize(itup),
OffsetNumberNext(PageGetMaxOffsetNumber(page)),
LP_USED);
}
if (l == InvalidOffsetNumber)
elog(ERROR, "failed to add index item to \"%s\"",
RelationGetRelationName(r));
WriteBuffer(buffer);
datum = IndexTupleGetDatum(itup);
/* now expand the page boundary in the parent to include the new child */
rttighten(r, stack, datum, IndexTupleAttSize(itup), rtstate);
freestack(stack);
}
void
fileout(register Archive_t* ap, register File_t* f)
{
register size_t m;
register ssize_t n;
register off_t c;
int err;
Buffer_t* bp;
if (f->delta.op == DELTA_verify)
ap->selected--;
else if (putheader(ap, f))
{
if (!ap->format->putdata || !(*ap->format->putdata)(&state, ap, f, f->fd))
{
err = 0;
c = f->st->st_size;
while (c > 0)
{
n = m = c > state.buffersize ? state.buffersize : c;
if (!err)
{
if (f->fd >= 0)
{
if ((n = read(f->fd, ap->io->next, m)) < 0 && errno == EIO)
{
static char* buf;
if (!buf)
{
n = 1024 * 8;
error(1, "EIO read error -- falling back to aligned reads");
if (!(buf = malloc(state.buffersize + n)))
nospace();
buf += n - (((ssize_t)buf) & (n - 1));
}
if ((n = read(f->fd, buf, m)) > 0)
memcpy(ap->io->next, buf, n);
}
}
else if (bp = getbuffer(f->fd))
{
memcpy(ap->io->next, bp->next, m);
if (f->extended && ap->convert[SECTION_CONTROL].f2a)
ccmapstr(ap->convert[SECTION_CONTROL].f2a, ap->io->next, m);
bp->next += m;
}
else if (bread(f->ap, ap->io->next, (off_t)0, (off_t)n, 1) <= 0)
n = -1;
}
if (n <= 0)
{
if (n)
error(ERROR_SYSTEM|2, "%s: read error", f->path);
else
error(2, "%s: file size changed", f->path);
memzero(ap->io->next, state.buffersize);
err = 1;
}
else
{
c -= n;
bput(ap, n);
}
}
}
puttrailer(ap, f);
}
if (f->fd >= 0)
closein(ap, f, f->fd);
}
void
copy(register Archive_t* ap, register int (*copyfile)(Ftw_t*))
{
register char* s;
register char* t;
register char* v;
register int c;
unsigned long flags;
char* mode;
char* mtime;
if (ap)
{
deltabase(ap);
if (ap->delta && ap->delta->format != ap->expected && ap->expected)
error(3, "%s: archive format %s does not match requested format %s", ap->name, ap->delta->format->name, ap->expected->name);
if (state.append || state.update)
{
ap->format = ap->delta->format;
if (!(ap->format->flags & APPEND))
error(3, "%s: archive format %s does support append/update", ap->name, ap->format->name);
if (state.update)
ap->update = ap->delta->tab;
ap->delta = 0;
ap->parent = 0;
ap->volume--;
}
putprologue(ap, state.append || state.update);
}
if (state.files)
ftwalk((char*)state.files, copyfile, state.ftwflags|FTW_MULTIPLE, state.exact ? (Ftw_cmp_t)0 : cmpftw);
else
{
sfopen(sfstdin, NiL, "rt");
sfset(sfstdin, SF_SHARE, 0);
mode = state.mode;
mtime = state.mtime;
for (;;)
{
if (s = state.peekfile)
{
state.peekfile = 0;
c = state.peeklen;
}
else if (!(s = sfgetr(sfstdin, '\n', 1)))
break;
else
c = sfvalue(sfstdin) - 1;
sfwrite(state.tmp.lst, s, c);
if (!(s = sfstruse(state.tmp.lst)))
nospace();
flags = state.ftwflags;
if (state.filter.line)
{
if (!(c = *s++))
continue;
state.filter.options = s;
if (!(s = skip(s, c)))
continue;
*s++ = 0;
state.filter.command = s;
if (!(s = skip(s, c)))
continue;
*s++ = 0;
state.filter.path = s;
if (!(s = skip(s, c)))
state.filter.name = state.filter.path;
else
{
*s++ = 0;
state.filter.name = s;
if (s = skip(s, c))
*s = 0;
}
s = state.filter.options;
for (;;)
{
if (t = strchr(s, ','))
*t = 0;
if (v = strchr(s, '='))
{
*v++ = 0;
c = strtol(v, NiL, 0);
}
else
c = 1;
if (s[0] == 'n' && s[1] == 'o')
{
s += 2;
c = !c;
}
if (streq(s, "logical") || streq(s, "physical"))
{
if (s[0] == 'p')
c = !c;
if (c)
flags &= ~(FTW_META|FTW_PHYSICAL);
else
{
flags &= ~(FTW_META);
flags |= FTW_PHYSICAL;
}
}
else if (streq(s, "mode"))
state.mode = v;
else if (streq(s, "mtime"))
state.mtime = v;
if (!t)
break;
s = t + 1;
}
s = state.filter.path;
state.filter.line = *state.filter.name ? 2 : 1;
}
c = *s ? ftwalk(s, copyfile, flags, NiL) : 0;
state.mode = mode;
state.mtime = mtime;
if (c)
{
error(2, "%s: not completely copied", s);
break;
}
}
}
if (ap)
{
deltadelete(ap);
putepilogue(ap);
}
}
void
filein(register Archive_t* ap, register File_t* f)
{
register off_t c;
register int n;
register char* s;
int dfd;
int wfd;
long checksum;
Filter_t* fp;
Proc_t* pp;
Tv_t t1;
Tv_t t2;
struct stat st;
if (f->skip)
goto skip;
else if (state.list)
{
if (fp = filter(ap, f))
{
for (n = 0; s = fp->argv[n]; n++)
{
while (*s)
if (*s++ == '%' && *s == '(')
break;
if (*s)
{
s = fp->argv[n];
listprintf(state.tmp.str, ap, f, s);
if (!(fp->argv[n] = sfstruse(state.tmp.str)))
nospace();
break;
}
}
pp = procopen(*fp->argv, fp->argv, NiL, NiL, PROC_WRITE);
if (s)
fp->argv[n] = s;
if (!pp)
{
error(2, "%s: %s: cannot execute filter %s", ap->name, f->path, *fp->argv);
goto skip;
}
if (!ap->format->getdata || !(*ap->format->getdata)(&state, ap, f, pp->wfd))
{
checksum = 0;
for (c = f->st->st_size; c > 0; c -= n)
{
n = (c > state.buffersize) ? state.buffersize : c;
if (!(s = bget(ap, n, NiL)))
{
error(ERROR_SYSTEM|2, "%s: read error", f->name);
break;
}
if (write(pp->wfd, s, n) != n)
{
error(ERROR_SYSTEM|2, "%s: write error", f->name);
break;
}
if (ap->format->checksum)
checksum = (*ap->format->checksum)(&state, ap, f, s, n, checksum);
}
}
if (ap->format->checksum && checksum != f->checksum)
error(1, "%s: %s checksum error (0x%08x != 0x%08x)", f->name, ap->format->name, checksum, f->checksum);
/*
* explicitly ignore exit status
*/
procclose(pp);
return;
}
listentry(f);
goto skip;
}
else switch (f->delta.op)
{
case DELTA_create:
if (f->delta.base)
error(3, "%s: base archive mismatch [%s#%d]", f->name, __FILE__, __LINE__);
if (ap->delta->format->flags & PSEUDO)
goto regular;
if ((wfd = openout(ap, f)) < 0)
goto skip;
else
paxdelta(NiL, ap, f, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_OUTPUT|DELTA_COUNT, wfd, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ap, f->st->st_size, 0);
break;
case DELTA_update:
if (!f->delta.base || (unsigned long)f->delta.base->mtime.tv_sec >= (unsigned long)f->st->st_mtime)
error(3, "%s: base archive mismatch [%s#%d]", f->name, __FILE__, __LINE__);
c = f->st->st_size;
if ((wfd = openout(ap, f)) < 0)
goto skip;
if (state.ordered)
{
if (!f->delta.base->uncompressed)
paxdelta(NiL, ap, f, DELTA_SRC|DELTA_BIO|DELTA_SIZE, ap->delta->base, f->delta.base->size, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_OUTPUT|DELTA_COUNT, wfd, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ap, c, 0);
else if (!paxdelta(NiL, ap, f, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ap->delta->base, f->delta.base->size, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &dfd, 0))
paxdelta(NiL, ap, f, DELTA_SRC|DELTA_FD|DELTA_SIZE|DELTA_FREE, dfd, f->delta.base->uncompressed, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_OUTPUT|DELTA_COUNT, wfd, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ap, c, 0);
}
else if (!f->delta.base->uncompressed)
paxdelta(NiL, ap, f, DELTA_SRC|DELTA_FD|DELTA_OFFSET|DELTA_SIZE, ap->delta->base->io->fd, f->delta.base->offset, f->delta.base->size, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_OUTPUT|DELTA_COUNT, wfd, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ap, c, 0);
else if (!paxdelta(NiL, ap, f, DELTA_DEL|DELTA_FD|DELTA_OFFSET|DELTA_SIZE, ap->delta->base->io->fd, f->delta.base->offset, f->delta.base->size, DELTA_TAR|DELTA_TEMP|DELTA_OUTPUT, &dfd, 0))
paxdelta(NiL, ap, f, DELTA_SRC|DELTA_FD|DELTA_SIZE|DELTA_FREE, dfd, f->delta.base->uncompressed, DELTA_TAR|DELTA_FD|DELTA_FREE|DELTA_OUTPUT|DELTA_COUNT, wfd, DELTA_DEL|DELTA_BIO|DELTA_SIZE, ap, c, 0);
break;
case DELTA_verify:
if (!f->delta.base || f->delta.base->mtime.tv_sec != f->st->st_mtime)
error(3, "%s: base archive mismatch [%s#%d]", f->name, __FILE__, __LINE__);
if ((*state.statf)(f->name, &st))
error(2, "%s: not copied from base archive", f->name);
else if (st.st_size != f->delta.base->size || state.modtime && tvcmp(tvmtime(&t1, &st), tvmtime(&t2, f->st)))
error(1, "%s: changed from base archive", f->name);
break;
case DELTA_delete:
if (!f->delta.base)
error(3, "%s: base archive mismatch [%s#%d]", f->name, __FILE__, __LINE__);
/*FALLTHROUGH*/
default:
regular:
wfd = openout(ap, f);
if (wfd >= 0)
{
holeinit(wfd);
if (!ap->format->getdata || !(*ap->format->getdata)(&state, ap, f, wfd))
{
checksum = 0;
for (c = f->st->st_size; c > 0; c -= n)
{
n = (c > state.buffersize) ? state.buffersize : c;
if (!(s = bget(ap, n, NiL)))
{
error(ERROR_SYSTEM|2, "%s: read error", f->name);
break;
}
if (holewrite(wfd, s, n) != n)
{
error(ERROR_SYSTEM|2, "%s: write error", f->name);
break;
}
if (ap->format->checksum)
checksum = (*ap->format->checksum)(&state, ap, f, s, n, checksum);
}
}
holedone(wfd);
closeout(ap, f, wfd);
setfile(ap, f);
if (ap->format->checksum && checksum != f->checksum)
error(1, "%s: %s checksum error (0x%08x != 0x%08x)", f->name, ap->format->name, checksum, f->checksum);
}
else if (ap->format->getdata)
(*ap->format->getdata)(&state, ap, f, wfd);
else
{
if (wfd < -1)
listentry(f);
goto skip;
}
break;
}
listentry(f);
return;
skip:
fileskip(ap, f);
}
QDeclarativeInfo::QDeclarativeInfo(QDeclarativeInfoPrivate *p)
: QDebug(&p->buffer), d(p)
{
nospace();
}
QQmlInfo::QQmlInfo(QQmlInfoPrivate *p)
: QDebug(&p->buffer), d(p)
{
nospace();
}
