示例#1
0
void NXCloseMemory(register NXStream *s, int option)
{
    int userBuf;
    int isCheapStream;

    _NXVerifyStream(s);
    verify_memory_stream(s);
    isCheapStream = (s->functions == &cheap_functions) ? 1:0;
    userBuf = (s->flags & NX_USER_OWNS_BUF) != 0;
    if (!userBuf) {
	switch (option) {
	    case NX_FREEBUFFER:
		if (isCheapStream && s->buf_size < MAX_MALLOC)
		    free(s->buf_base);
		else {
		    kern_return_t ret = vm_deallocate(mach_task_self(),
			(vm_offset_t)s->buf_base, (vm_size_t)s->buf_size);
		    if (ret != KERN_SUCCESS)
			NX_RAISE(NX_streamVMError, s, (void *)ret);
		}
		break;
	    case NX_TRUNCATEBUFFER:
		if (!isCheapStream || s->buf_size >= MAX_MALLOC)
		    memory_close(s);
		break;
	    case NX_SAVEBUFFER: break;
	}
    }
    NXStreamDestroy(s);
}
示例#2
0
void NXSeek(register NXStream *s, long offset, int ptrname)
{
    long curPos;

    _NXVerifyStream(s);
    curPos = NXTell(s);
    if (curPos > s->eof)
        s->eof = curPos;
    switch (ptrname) {
    case NX_FROMSTART:
        break;
    case NX_FROMCURRENT:
        offset += NXTell(s);
        break;
    case NX_FROMEND:
        offset += s->eof;
        break;
    default:
        NX_RAISE( NX_illegalSeek, s, 0 );
    }
    if (   offset < 0
//	|| !(s->flags&NX_CANSEEK)	*** This breaks too much code ***
            || (   (s->flags & NX_READFLAG)
                   && !(s->flags & NX_CANWRITE)
                   && (offset > s->eof)) )
        NX_RAISE( NX_illegalSeek, s, 0 );
    if (s->flags & NX_EOS && offset < s->eof)
        s->flags &= ~NX_EOS;
    else if (offset >= s->eof)
        s->flags |= NX_EOS;
    s->functions->seek(s, offset);
}
示例#3
0
int NXSaveToFile(register NXStream *s, const char *name )
{
    int             fd;
    char           *buf;
    int             len, max, retval;

    _NXVerifyStream(s);
    verify_memory_stream(s);
    fd = open(name, O_WRONLY | O_CREAT, 0666);
    if (fd >= 0) {
	NXGetMemoryBuffer(s, &buf, &len, &max);
	retval = write(fd, buf, len);
	if (retval < 0)
	    return retval;
	retval = ftruncate(fd, len);
	if (retval < 0)
	    return retval;
	retval = fsync(fd);
	if (retval < 0)
	    return retval;
	retval = close(fd);
	if (retval < 0)
	    return retval;
    } else
	return -1;
    return 0;
}
示例#4
0
void NXClose(register NXStream *s)
{
    _NXVerifyStream(s);
    if (s->flags & NX_WRITEFLAG)
        (void)NXFlush(s);
    s->functions->destroy(s);
    NXStreamDestroy(s);
}
示例#5
0
extern int _NXStreamFlushBuffer(NXStream *s, unsigned char c)
{
    _NXVerifyStream(s);
    s->buf_left++;		/* compensate for NXPutc */
    (void)NXFlush(s);
    *s->buf_ptr++ = c;
    s->buf_left--;
    return (int)c;
}
示例#6
0
void
NXPrintf(NXStream *stream, const char *format, ...)
{
    va_list ap;

    _NXVerifyStream(stream);
    va_start(ap, format);
    NXVPrintf(stream, format, ap);
    va_end(ap);
}
示例#7
0
void NXGetMemoryBuffer(NXStream *s, char **addr, int *len, int *maxlen)
{
    int bufSize = s->buf_size - s->buf_left;
    
    _NXVerifyStream(s);
    verify_memory_stream(s);
    *addr = (char *)s->buf_base;
    *len = ((s->flags&NX_READFLAG) || (bufSize <= s->eof)) ? s->eof : bufSize;
    *maxlen = s->buf_size;
}
示例#8
0
int NXScanf(NXStream *stream, const char *format, ...)
{
    va_list ap;
    int	ret;

    _NXVerifyStream(stream);
    va_start(ap, format);
    ret = NXVScanf(stream, format, ap);
    va_end(ap);
    return ret;
}
示例#9
0
long NXTell(register NXStream *s)
{
    _NXVerifyStream(s);
    if (s->flags & NX_READFLAG) {
        return s->offset + (s->buf_ptr - s->buf_base);
    } else if (s->flags & NX_WRITEFLAG) {
        return s->offset + s->buf_size - s->buf_left;
    } else {
        fprintf(stderr, "Stream is neither readable nor writable in NXTell\n");
        return -1;
    }
}
示例#10
0
void NXUngetc(register NXStream *s)
{
    _NXVerifyStream(s);
    if (NXTell(s) > 0) {
        if (s->buf_ptr == s->buf_base)
            fprintf(stderr, "Assertion failed: NXUngetc: last character read unknown\n");
        else if (!(s->flags & NX_EOS)) {
            s->buf_left++;
            s->buf_ptr--;
        }
    }
}
示例#11
0
extern int _NXStreamChangeBuffer(NXStream *s, unsigned char ch)
{
    int wasReading;

    _NXVerifyStream(s);
    wasReading = (s->flags & NX_READFLAG);
    NXChangeBuffer(s);
    if (wasReading)
	NXPutc(s, ch);
    else
	ch = NXGetc(s);
    return ((int)(ch));
}
示例#12
0
extern int _NXStreamFillBuffer(NXStream *s)
{
    int             n;

    _NXVerifyStream(s);
    if (s->flags & NX_EOS)
	return -1;
    if (s->buf_left < 0)
	s->buf_left = 0;
    n = NXFill(s);
    if (n <= 0) {
	s->flags |= NX_EOS;
	return -1;
    }
    s->buf_left--;
    return ((int)((*(s->buf_ptr++)) & 0xff));
}
示例#13
0
__private_extern__
int NXDefaultWrite(NXStream *s, const void *buf, int count)
{
    register int n;
    int total = count;
    int curPos;
    const char * volatile bufPtr = buf;
    NXHandler exception;

    _NXVerifyStream(s);
 /*
  * Loop until copying complete. 
  */
    exception.code = 0;
    if (s->flags & NX_READFLAG) 
	NXChangeBuffer(s);
    while (count > 0) {
    /*
     * Flush buffer if necessary. 
     */
	if (s->buf_left == 0) {
	    NX_DURING {
		(void)NXFlush(s);
	    } NX_HANDLER {
		exception = NXLocalHandler;
		break;
	    } NX_ENDHANDLER
	}
    /*
     * Figure out how much to copy this time. 
     */
	n = count;
	if (n > s->buf_left)
	    n = s->buf_left;
	bcopy((const char *)bufPtr, s->buf_ptr, n);
    /*
     * Update all pointers. 
     */
	s->buf_ptr += n;
	s->buf_left -= n;
	bufPtr += n;
	count -= n;
    }
示例#14
0
int
NXVScanf(NXStream *stream, register const char *fmt, va_list arg)
{
	register int ch;
	int nmatch, len, ch1;
	void *ptr;
	int fileended, size;
	char _sctab[SCTAB_SIZE];

	_NXVerifyStream(stream);
	bzero( _sctab, SCTAB_SIZE );
	_sctab[9] = _sctab[10] = _sctab[32] = SPC;
	nmatch = 0;
	fileended = 0;
	for (;;) switch (ch = *fmt++) {
	case '\0': 
		return (nmatch);
	case '%': 
		if ((ch = *fmt++) == '%')
			goto def;
		ptr = 0;
		if (ch != '*')
			ptr = va_arg(arg, void *);
		else
			ch = *fmt++;
		len = 0;
		size = REGULAR;
		while (isdigit(ch)) {
			len = len*10 + ch - '0';
			ch = *fmt++;
		}
		if (len == 0)
			len = 30000;
		if (ch=='l') {
			size = LONG;
			ch = *fmt++;
		} else if (ch=='h') {
			size = SHORT;
			ch = *fmt++;
		} else if (ch=='[')
			fmt = _getccl(fmt, _sctab);
		if (isupper(ch)) {
			ch = tolower(ch);
			size = LONG;
		}
		if (ch == '\0')
			return(-1);
		if (_innum(ptr, ch, len, size, stream, &fileended, _sctab) && ptr)
			nmatch++;
		if (fileended)
			return(nmatch? nmatch: -1);
		break;

	case ' ':
	case '\n':
	case '\t': 
		while ((ch1 = NXGetc(stream))==' ' || ch1=='\t' || ch1=='\n')
			;
		if (ch1 != EOF)
			NXUngetc(stream);
		break;

	default: 
	def:
		ch1 = NXGetc(stream);
		if (ch1 != ch) {
			if (ch1==EOF)
				return(-1);
			NXUngetc(stream);
			return(nmatch);
		}
	}