Eine aufbereitete Darstellung der Quelle

 
     
 
 
Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 

Benutzer

Quelle  vbuf.c

  Sprache: C
 

/*++
/* NAME
/* vbuf 3
/* SUMMARY
/* generic buffer package
/* SYNOPSIS
/* #include <vbuf.h>
/*
/* int VBUF_GET(bp)
/* VBUF *bp;
/*
/* int VBUF_PUT(bp, ch)
/* VBUF *bp;
/* int ch;
/*
/* int VBUF_SPACE(bp, len)
/* VBUF *bp;
/* ssize_t len;
/*
/* int vbuf_unget(bp, ch)
/* VBUF *bp;
/* int ch;
/*
/* ssize_t vbuf_read(bp, buf, len)
/* VBUF *bp;
/* void *buf;
/* ssize_t len;
/*
/* ssize_t vbuf_write(bp, buf, len)
/* VBUF *bp;
/* const void *buf;
/* ssize_t len;
/*
/* int vbuf_err(bp)
/* VBUF *bp;
/*
/* int vbuf_eof(bp)
/* VBUF *bp;
/*
/* int vbuf_timeout(bp)
/* VBUF *bp;
/*
/* int vbuf_clearerr(bp)
/* VBUF *bp;
/*
/* int vbuf_rd_err(bp)
/* VBUF *bp;
/*
/* int vbuf_wr_err(bp)
/* VBUF *bp;
/*
/* int vbuf_rd_timeout(bp)
/* VBUF *bp;
/*
/* int vbuf_wr_timeout(bp)
/* VBUF *bp;
/* DESCRIPTION
/* This module implements a buffer with read/write primitives that
/* automatically handle buffer-empty or buffer-full conditions.
/* The application is expected to provide callback routines that run
/* when the read-write primitives detect a buffer-empty/full condition.
/*
/* VBUF buffers provide primitives to store and retrieve characters,
/* and to look up buffer status information.
/* By design, VBUF buffers provide no explicit primitives for buffer
/* memory management. This is left to the application to avoid any bias
/* toward specific management models. The application is free to use
/* whatever strategy suits best: memory-resident buffer, memory mapped
/* file, or stdio-like window to an open file.
/*
/* VBUF_GET() returns the next character from the specified buffer,
/* or VBUF_EOF when none is available. VBUF_GET() is an unsafe macro
/* that evaluates its argument more than once.
/*
/* VBUF_PUT() stores one character into the specified buffer. The result
/* is the stored character, or VBUF_EOF in case of problems. VBUF_PUT()
/* is an unsafe macro that evaluates its arguments more than once.
/*
/* VBUF_SPACE() requests that the requested amount of buffer space be
/* made available, so that it can be accessed without using VBUF_PUT().
/* The result value is 0 for success, VBUF_EOF for problems.
/* VBUF_SPACE() is an unsafe macro that evaluates its arguments more
/* than once. VBUF_SPACE() does not support read-only streams.
/*
/* vbuf_unget() provides at least one character of pushback, and returns
/* the pushed back character, or VBUF_EOF in case of problems. It is
/* an error to call vbuf_unget() on a buffer before reading any data
/* from it. vbuf_unget() clears the buffer's end-of-file indicator upon
/* success, and sets the buffer's error indicator when an attempt is
/* made to push back a non-character value.
/*
/* vbuf_read() and vbuf_write() do bulk I/O. The result value is the
/* number of bytes transferred. A short count is returned in case of
/* an error.
/*
/* vbuf_timeout() is a macro that returns non-zero if a timeout error
/* condition was detected while reading or writing the buffer. The
/* error status can be reset by calling vbuf_clearerr().
/*
/* vbuf_err() is a macro that returns non-zero if a non-EOF error
/* (including timeout) condition was detected while reading or writing
/* the buffer. The error status can be reset by calling vbuf_clearerr().
/*
/* The vbuf_rd_mumble() and vbuf_wr_mumble() macros report on
/* read and write error conditions, respectively.
/*
/* vbuf_eof() is a macro that returns non-zero if an end-of-file
/* condition was detected while reading or writing the buffer. The error
/* status can be reset by calling vbuf_clearerr().
/* APPLICATION CALLBACK SYNOPSIS
/* int get_ready(bp)
/* VBUF *bp;
/*
/* int put_ready(bp)
/* VBUF *bp;
/*
/* int space(bp, len)
/* VBUF *bp;
/* ssize_t len;
/* APPLICATION CALLBACK DESCRIPTION
/* .ad
/* .fi
/* get_ready() is called when VBUF_GET() detects a buffer-empty condition.
/* The result is zero when more data could be read, VBUF_EOF otherwise.
/*
/* put_ready() is called when VBUF_PUT() detects a buffer-full condition.
/* The result is zero when the buffer could be flushed, VBUF_EOF otherwise.
/*
/* space() performs whatever magic necessary to make at least \fIlen\fR
/* bytes available for access without using VBUF_PUT(). The result is 0
/* in case of success, VBUF_EOF otherwise.
/* SEE ALSO
/* vbuf(3h) layout of the VBUF data structure.
/* LICENSE
/* .ad
/* .fi
/* The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/* Wietse Venema
/* IBM T.J. Watson Research
/* P.O. Box 704
/* Yorktown Heights, NY 10598, USA
/*
/* Wietse Venema
/* Google, Inc.
/* 111 8th Avenue
/* New York, NY 10011, USA
/*--*/


/* System library. */

#include "sys_defs.h"
#include <string.h>

/* Utility library. */

#include "vbuf.h"

/* vbuf_unget - implement at least one character pushback */

int     vbuf_unget(VBUF *bp, int ch)
{
    if ((ch & 0xff) != ch || -bp->cnt >= bp->len) {
 bp->flags |= VBUF_FLAG_RD_ERR; /* This error affects reads! */
 return (VBUF_EOF);
    } else {
 bp->cnt--;
 bp->flags &= ~VBUF_FLAG_EOF;
 return (*--bp->ptr = ch);
    }
}

/* vbuf_get - handle read buffer empty condition */

int     vbuf_get(VBUF *bp)
{
    return (bp->get_ready(bp) ?
     ((bp->flags |= VBUF_FLAG_EOF), VBUF_EOF) : VBUF_GET(bp));
}

/* vbuf_put - handle write buffer full condition */

int     vbuf_put(VBUF *bp, int ch)
{
    return (bp->put_ready(bp) ? VBUF_EOF : VBUF_PUT(bp, ch));
}

/* vbuf_read - bulk read from buffer */

ssize_t vbuf_read(VBUF *bp, void *buf, ssize_t len)
{
    ssize_t count;
    void   *cp;
    ssize_t n;

#if 0
    for (count = 0; count < len; count++)
 if ((buf[count] = VBUF_GET(bp)) < 0)
     break;
    return (count);
#else
    for (cp = buf, count = len; count > 0; cp += n, count -= n) {
 if (bp->cnt >= 0 && bp->get_ready(bp))
     break;
 n = (count < -bp->cnt ? count : -bp->cnt);
 memcpy(cp, bp->ptr, n);
 bp->ptr += n;
 bp->cnt += n;
    }
    return (len - count);
#endif
}

/* vbuf_write - bulk write to buffer */

ssize_t vbuf_write(VBUF *bp, const void *buf, ssize_t len)
{
    ssize_t count;
    const void *cp;
    ssize_t n;

#if 0
    for (count = 0; count < len; count++)
 if (VBUF_PUT(bp, buf[count]) < 0)
     break;
    return (count);
#else
    for (cp = buf, count = len; count > 0; cp += n, count -= n) {
 if (bp->cnt <= 0 && bp->put_ready(bp) != 0)
     break;
 n = (count < bp->cnt ? count : bp->cnt);
 memcpy(bp->ptr, cp, n);
 bp->ptr += n;
 bp->cnt -= n;
    }
    return (len - count);
#endif
}

Messung V0.5 in Prozent
C=89 H=92 G=90

¤ Dauer der Verarbeitung: 0.0 Sekunden  (vorverarbeitet am  2026-08-08) ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Open Source Software

     Quellcodebibliothek
     Eigene Quellcodes
     Fremde Quellcodes
     Suchen

Jenseits des Üblichen ....
    

Besucherstatistik

Besucherstatistik

Statistik
#Sources=141584
#Domains=738142