src/tools/stream.h

/* 
 *      HT Editor
 *      stream.h
 *
 *      Copyright (C) 1999-2002 Stefan Weyergraf
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef __STREAM_H__
#define __STREAM_H__

#include <stdarg.h>
#include <stdio.h>

#include "data.h"
#include "str.h"
#include "system/file.h"

class String;

/* Stream access mode */
enum IOAccessModeAtomic {
        IOAM_NULL = 0,
        IOAM_READ = 1,
        IOAM_WRITE = 2
};

typedef uint IOAccessMode;

/**
 *      A stream.
 */
class Stream {
private:
        IOAccessMode mAccessMode;
//      Container *mListeners;
protected:
                void                    checkAccess(IOAccessMode mask);
//              void                    notifyListeners(StreamEvent event,...);
public:
                                        Stream();
        virtual                         ~Stream();
        /* new */
//              void                    addEventListener(StreamEventListener *l, StreamEvent mask);
        virtual uint                    copyAllTo(Stream *stream);
        virtual uint                    copyTo(Stream *stream, uint count);
        virtual IOAccessMode            getAccessMode() const;
        virtual String &                getDesc(String &result) const;
        virtual uint                    read(void *buf, uint size);
                void                    readx(void *buf, uint size);
//              void                    removeEventListener(StreamEventListener *l);
        virtual int                     setAccessMode(IOAccessMode mode);
        virtual uint                    write(const void *buf, uint size);
                void                    writex(const void *buf, uint size);
};

/**
 *      A stream, layering a stream.
 */
class StreamLayer: public Stream {
protected:
        Stream *mStream;
        bool mOwnStream;

public:

                                        StreamLayer(Stream *stream, bool own_stream);
        virtual                         ~StreamLayer();
        /* extends Stream */
        virtual IOAccessMode            getAccessMode() const;
        virtual String &                getDesc(String &result) const;
        virtual uint                    read(void *buf, uint size);
        virtual int                     setAccessMode(IOAccessMode mode);
        virtual uint                    write(const void *buf, uint size);
        /* new */
                Stream *                getLayered() const;
                void                    setLayered(Stream *newLayered, bool ownNewLayered);
};

#define OS_FMT_DEC              0
#define OS_FMT_HEX              1

/* cntl cmd */
#define FCNTL_MODS_INVD                 0x00000001
#define FCNTL_MODS_FLUSH                0x00000002
#define FCNTL_MODS_IS_DIRTY             0x00000003      // const FileOfs &offset, const FileOfs &range, bool &isdirty
//#define FCNTL_MODS_CLEAR_DIRTY                0x00000004
//#define FCNTL_MODS_CLEAR_DIRTY_RANGE  0x00000005      // const FileOfs &offset, const FileOfs &range
#define FCNTL_FLUSH_STAT                0x00000006
#define FCNTL_GET_RELOC                 0x00000007      // bool &enabled
#define FCNTL_SET_RELOC                 0x00000008      // bool enable
#define FCNTL_GET_FD                    0x00000009      // int &fd

// Return a "modification count" that changes everytime the file state ( content, size, pstat )
// changes.
// While identical mod-counts imply identical file states,
// different mod-counts do not necessarily imply different file states !
#define FCNTL_GET_MOD_COUNT             0x0000000a      // int &mcount

#define IS_DIRTY_SINGLEBIT              0x80000000

/* File open mode */
enum FileOpenMode {
        FOM_EXISTS,
        FOM_CREATE,
        FOM_APPEND
};

/**
 *      A file.
 */
class File: public Stream {
protected:
        int mcount;
public:
                File();
        /* new */
                int                     cntl(uint cmd, ...);
        virtual void                    del(uint size);
        virtual void                    extend(FileOfs newsize);
        virtual String &                getFilename(String &result) const;
        virtual FileOfs                 getSize() const;
        virtual void                    insert(const void *buf, uint size);
        virtual void                    pstat(pstat_t &s) const;
        virtual void                    seek(FileOfs offset);
        virtual FileOfs                 tell() const;
        virtual void                    truncate(FileOfs newsize);
        virtual int                     vcntl(uint cmd, va_list vargs);
};

/**
 *      A file, layering a file.
 */
class FileLayer: public File {
protected:
        File *mFile;
        bool mOwnFile;
public:
                                        FileLayer(File *file, bool own_file);
        virtual                         ~FileLayer();
        /* extends File */
        virtual void                    del(uint size);
        virtual void                    extend(FileOfs newsize);
        virtual IOAccessMode            getAccessMode() const;
        virtual String &                getDesc(String &result) const;
        virtual String &                getFilename(String &result) const;
        virtual FileOfs                 getSize() const;
        virtual void                    insert(const void *buf, uint size);
        virtual void                    pstat(pstat_t &s) const;
        virtual uint                    read(void *buf, uint size);
        virtual void                    seek(FileOfs offset);
        virtual int                     setAccessMode(IOAccessMode mode);
        virtual FileOfs                 tell() const;
        virtual void                    truncate(FileOfs newsize);
        virtual int                     vcntl(uint cmd, va_list vargs);
        virtual uint                    write(const void *buf, uint size);
        /* new */
                File *                  getLayered() const;
                void                    setLayered(File *newLayered, bool ownNewLayered);
};

/**
 *      A local file (file descriptor [fd]).
 */
class LocalFileFD: public File {
protected:
        String          mFilename;
        FileOpenMode    mOpenMode;

        int fd;
        bool own_fd;

        FileOfs offset;

                int             setAccessModeInternal(IOAccessMode mode);
public:

                                LocalFileFD(const String &aFilename, IOAccessMode mode, FileOpenMode aOpenMode);
                                LocalFileFD(int fd, bool own_fd, IOAccessMode mode);
        virtual                 ~LocalFileFD();
        /* extends File */
        virtual String &        getDesc(String &result) const;
        virtual String &        getFilename(String &result) const;
        virtual FileOfs         getSize() const;
        virtual uint            read(void *buf, uint size);
        virtual void            seek(FileOfs offset);
        virtual int             setAccessMode(IOAccessMode mode);
        virtual FileOfs         tell() const;
        virtual void            truncate(FileOfs newsize);
        virtual int             vcntl(uint cmd, va_list vargs);
        virtual uint            write(const void *buf, uint size);
};

/**
 *      A local file (file stream [FILE*]).
 */
class LocalFile: public File {
protected:
        String          mFilename;
        FileOpenMode    mOpenMode;

        FILE *          file;
        bool            own_file;

        FileOfs         offset;

                int             setAccessModeInternal(IOAccessMode mode);
public:
                                LocalFile(const String &aFilename, IOAccessMode mode=IOAM_READ, FileOpenMode aOpenMode=FOM_EXISTS);
                                LocalFile(FILE *file, bool own_file, IOAccessMode mode);
        virtual                 ~LocalFile();
        /* extends File */
        virtual String &        getDesc(String &result) const;
        virtual String &        getFilename(String &result) const;
        virtual FileOfs         getSize() const;
        virtual void            pstat(pstat_t &s) const;
        virtual uint            read(void *buf, uint size);
        virtual void            seek(FileOfs offset);
        virtual int             setAccessMode(IOAccessMode mode);
        virtual FileOfs         tell() const;
        virtual void            truncate(FileOfs newsize);
        virtual int             vcntl(uint cmd, va_list vargs);
        virtual uint            write(const void *buf, uint size);
};

/**
 *      A temporary file.
 */
class TempFile: public LocalFile {
public:
                                TempFile(IOAccessMode mode);
        /* extends File */
        virtual String &        getDesc(String &result) const;
        virtual void            pstat(pstat_t &s) const;
};

/**
 *      A fixed-size, read-only file, mapping a area of memory.
 */
class ConstMemMapFile: public File {
protected:
        FileOfs pos;
        uint size;
        const void *buf;
public:
                                ConstMemMapFile(const void *buf, uint size);
        /* extends File */
        virtual String &        getDesc(String &result) const;
        virtual FileOfs getSize() const;
        virtual uint            read(void *buf, uint size);
        virtual void            seek(FileOfs offset);
        virtual FileOfs         tell() const;
};

/**
 *      A fixed-size file, mapping a area of memory.
 */
class MemMapFile: public ConstMemMapFile {
public:
                                MemMapFile(void *buf, uint size);
        /* extends Stream */
        virtual uint            write(const void *buf, uint size);
};

/**
 *      A file layer, representing a cropped version of a file
 */
class CroppedFile: public FileLayer {
protected:
        FileOfs mCropStart;
        bool    mHasCropSize;
        FileOfs mCropSize;
public:
                                // crop [start; start+size-1]
                                CroppedFile(File *file, bool own_file, FileOfs aCropStart, FileOfs aCropSize);
                                // no size, just start
                                CroppedFile(File *file, bool own_file, FileOfs aCropStart);
        /* extends FileLayer */
        virtual void            extend(FileOfs newsize);
        virtual String &        getDesc(String &result) const;
        virtual FileOfs getSize() const;
        virtual void            pstat(pstat_t &s) const;
        virtual uint            read(void *buf, uint size);
        virtual void            seek(FileOfs offset);
        virtual FileOfs         tell() const;
        virtual void            truncate(FileOfs newsize);
        virtual uint            write(const void *buf, uint size);
};

/**
 *      A (read-only) file with zero-content.
 */
class NullFile: public File {
public:
                                NullFile();
        /* extends File */
        virtual void            extend(FileOfs newsize);
        virtual String &        getDesc(String &result) const;
        virtual FileOfs getSize() const;
        virtual void            pstat(pstat_t &s) const;
        virtual uint            read(void *buf, uint size);
        virtual void            seek(FileOfs offset);
        virtual int             setAccessMode(IOAccessMode mode);
        virtual FileOfs         tell() const;
        virtual void            truncate(FileOfs newsize);
        virtual uint            write(const void *buf, uint size);
};

/**
 *      A file, existing only in memory.
 */
class MemoryFile: public File {
protected:
        FileOfs ofs;
        FileOfs pos;
        uint bufsize, dsize, ibufsize;
        byte *buf;

        virtual uint            extendBufSize(uint bufsize);
        virtual uint            shrinkBufSize(uint bufsize);
                void            extendBuf();
                void            shrinkBuf();
                void            resizeBuf(uint newsize);
public:
                                MemoryFile(FileOfs ofs = 0, uint size = 0, IOAccessMode mode = IOAM_READ | IOAM_WRITE);
        virtual                 ~MemoryFile();
        /* extends File */
        virtual void            extend(FileOfs newsize);
        virtual IOAccessMode    getAccessMode() const;
        virtual String &        getDesc(String &result) const;
        virtual FileOfs         getSize() const;
        virtual void            pstat(pstat_t &s) const;
        virtual uint            read(void *buf, uint size);
        virtual void            seek(FileOfs offset);
        virtual int             setAccessMode(IOAccessMode mode);
        virtual FileOfs         tell() const;
        virtual void            truncate(FileOfs newsize);
        virtual uint            write(const void *buf, uint size);
        /* new */
                byte *          getBufPtr() const;
};

void fileMove(File *file, FileOfs src, FileOfs dest, FileOfs size);

/** read string from file (zero-terminated, 8-bit chars) */
char *fgetstrz(File *file);
/** read string from stream (zero-terminated, 8-bit chars) */
char *getstrz(Stream *stream);
/** write string into stream (zero-terminated, 8-bit chars) */
void putstrz(Stream *stream, const char *str);

/** read string from stream (8-bit length followed by content aka. Pascal-style) */
char *getstrp(Stream *stream);
/** write string into stream (8-bit length followed by content aka. Pascal-style) */
void putstrp(Stream *stream, const char *str);

/** read string from stream (zero-terminated, 16-bit chars) */
char *getstrw(Stream *stream);
/** write string into stream (zero-terminated, 16-bit chars) */
void putstrw(Stream *stream, const char *str);

#endif /* __STREAM_H__ */
1	dpavlin	1	/*
2			* HT Editor
3			* stream.h
4			*
5			* Copyright (C) 1999-2002 Stefan Weyergraf
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License version 2 as
9			* published by the Free Software Foundation.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19			*/
20
21			#ifndef __STREAM_H__
22			#define __STREAM_H__
23
24			#include <stdarg.h>
25			#include <stdio.h>
26
27			#include "data.h"
28			#include "str.h"
29			#include "system/file.h"
30
31			class String;
32
33			/* Stream access mode */
34			enum IOAccessModeAtomic {
35			IOAM_NULL = 0,
36			IOAM_READ = 1,
37			IOAM_WRITE = 2
38			};
39
40			typedef uint IOAccessMode;
41
42			/**
43			* A stream.
44			*/
45			class Stream {
46			private:
47			IOAccessMode mAccessMode;
48			// Container *mListeners;
49			protected:
50			void checkAccess(IOAccessMode mask);
51			// void notifyListeners(StreamEvent event,...);
52			public:
53			Stream();
54			virtual ~Stream();
55			/* new */
56			// void addEventListener(StreamEventListener *l, StreamEvent mask);
57			virtual uint copyAllTo(Stream *stream);
58			virtual uint copyTo(Stream *stream, uint count);
59			virtual IOAccessMode getAccessMode() const;
60			virtual String & getDesc(String &result) const;
61			virtual uint read(void *buf, uint size);
62			void readx(void *buf, uint size);
63			// void removeEventListener(StreamEventListener *l);
64			virtual int setAccessMode(IOAccessMode mode);
65			virtual uint write(const void *buf, uint size);
66			void writex(const void *buf, uint size);
67			};
68
69			/**
70			* A stream, layering a stream.
71			*/
72			class StreamLayer: public Stream {
73			protected:
74			Stream *mStream;
75			bool mOwnStream;
76
77			public:
78
79			StreamLayer(Stream *stream, bool own_stream);
80			virtual ~StreamLayer();
81			/* extends Stream */
82			virtual IOAccessMode getAccessMode() const;
83			virtual String & getDesc(String &result) const;
84			virtual uint read(void *buf, uint size);
85			virtual int setAccessMode(IOAccessMode mode);
86			virtual uint write(const void *buf, uint size);
87			/* new */
88			Stream * getLayered() const;
89			void setLayered(Stream *newLayered, bool ownNewLayered);
90			};
91
92			#define OS_FMT_DEC 0
93			#define OS_FMT_HEX 1
94
95			/* cntl cmd */
96			#define FCNTL_MODS_INVD 0x00000001
97			#define FCNTL_MODS_FLUSH 0x00000002
98			#define FCNTL_MODS_IS_DIRTY 0x00000003 // const FileOfs &offset, const FileOfs &range, bool &isdirty
99			//#define FCNTL_MODS_CLEAR_DIRTY 0x00000004
100			//#define FCNTL_MODS_CLEAR_DIRTY_RANGE 0x00000005 // const FileOfs &offset, const FileOfs &range
101			#define FCNTL_FLUSH_STAT 0x00000006
102			#define FCNTL_GET_RELOC 0x00000007 // bool &enabled
103			#define FCNTL_SET_RELOC 0x00000008 // bool enable
104			#define FCNTL_GET_FD 0x00000009 // int &fd
105
106			// Return a "modification count" that changes everytime the file state ( content, size, pstat )
107			// changes.
108			// While identical mod-counts imply identical file states,
109			// different mod-counts do not necessarily imply different file states !
110			#define FCNTL_GET_MOD_COUNT 0x0000000a // int &mcount
111
112			#define IS_DIRTY_SINGLEBIT 0x80000000
113
114			/* File open mode */
115			enum FileOpenMode {
116			FOM_EXISTS,
117			FOM_CREATE,
118			FOM_APPEND
119			};
120
121			/**
122			* A file.
123			*/
124			class File: public Stream {
125			protected:
126			int mcount;
127			public:
128			File();
129			/* new */
130			int cntl(uint cmd, ...);
131			virtual void del(uint size);
132			virtual void extend(FileOfs newsize);
133			virtual String & getFilename(String &result) const;
134			virtual FileOfs getSize() const;
135			virtual void insert(const void *buf, uint size);
136			virtual void pstat(pstat_t &s) const;
137			virtual void seek(FileOfs offset);
138			virtual FileOfs tell() const;
139			virtual void truncate(FileOfs newsize);
140			virtual int vcntl(uint cmd, va_list vargs);
141			};
142
143			/**
144			* A file, layering a file.
145			*/
146			class FileLayer: public File {
147			protected:
148			File *mFile;
149			bool mOwnFile;
150			public:
151			FileLayer(File *file, bool own_file);
152			virtual ~FileLayer();
153			/* extends File */
154			virtual void del(uint size);
155			virtual void extend(FileOfs newsize);
156			virtual IOAccessMode getAccessMode() const;
157			virtual String & getDesc(String &result) const;
158			virtual String & getFilename(String &result) const;
159			virtual FileOfs getSize() const;
160			virtual void insert(const void *buf, uint size);
161			virtual void pstat(pstat_t &s) const;
162			virtual uint read(void *buf, uint size);
163			virtual void seek(FileOfs offset);
164			virtual int setAccessMode(IOAccessMode mode);
165			virtual FileOfs tell() const;
166			virtual void truncate(FileOfs newsize);
167			virtual int vcntl(uint cmd, va_list vargs);
168			virtual uint write(const void *buf, uint size);
169			/* new */
170			File * getLayered() const;
171			void setLayered(File *newLayered, bool ownNewLayered);
172			};
173
174			/**
175			* A local file (file descriptor [fd]).
176			*/
177			class LocalFileFD: public File {
178			protected:
179			String mFilename;
180			FileOpenMode mOpenMode;
181
182			int fd;
183			bool own_fd;
184
185			FileOfs offset;
186
187			int setAccessModeInternal(IOAccessMode mode);
188			public:
189
190			LocalFileFD(const String &aFilename, IOAccessMode mode, FileOpenMode aOpenMode);
191			LocalFileFD(int fd, bool own_fd, IOAccessMode mode);
192			virtual ~LocalFileFD();
193			/* extends File */
194			virtual String & getDesc(String &result) const;
195			virtual String & getFilename(String &result) const;
196			virtual FileOfs getSize() const;
197			virtual uint read(void *buf, uint size);
198			virtual void seek(FileOfs offset);
199			virtual int setAccessMode(IOAccessMode mode);
200			virtual FileOfs tell() const;
201			virtual void truncate(FileOfs newsize);
202			virtual int vcntl(uint cmd, va_list vargs);
203			virtual uint write(const void *buf, uint size);
204			};
205
206			/**
207			* A local file (file stream [FILE*]).
208			*/
209			class LocalFile: public File {
210			protected:
211			String mFilename;
212			FileOpenMode mOpenMode;
213
214			FILE * file;
215			bool own_file;
216
217			FileOfs offset;
218
219			int setAccessModeInternal(IOAccessMode mode);
220			public:
221			LocalFile(const String &aFilename, IOAccessMode mode=IOAM_READ, FileOpenMode aOpenMode=FOM_EXISTS);
222			LocalFile(FILE *file, bool own_file, IOAccessMode mode);
223			virtual ~LocalFile();
224			/* extends File */
225			virtual String & getDesc(String &result) const;
226			virtual String & getFilename(String &result) const;
227			virtual FileOfs getSize() const;
228			virtual void pstat(pstat_t &s) const;
229			virtual uint read(void *buf, uint size);
230			virtual void seek(FileOfs offset);
231			virtual int setAccessMode(IOAccessMode mode);
232			virtual FileOfs tell() const;
233			virtual void truncate(FileOfs newsize);
234			virtual int vcntl(uint cmd, va_list vargs);
235			virtual uint write(const void *buf, uint size);
236			};
237
238			/**
239			* A temporary file.
240			*/
241			class TempFile: public LocalFile {
242			public:
243			TempFile(IOAccessMode mode);
244			/* extends File */
245			virtual String & getDesc(String &result) const;
246			virtual void pstat(pstat_t &s) const;
247			};
248
249			/**
250			* A fixed-size, read-only file, mapping a area of memory.
251			*/
252			class ConstMemMapFile: public File {
253			protected:
254			FileOfs pos;
255			uint size;
256			const void *buf;
257			public:
258			ConstMemMapFile(const void *buf, uint size);
259			/* extends File */
260			virtual String & getDesc(String &result) const;
261			virtual FileOfs getSize() const;
262			virtual uint read(void *buf, uint size);
263			virtual void seek(FileOfs offset);
264			virtual FileOfs tell() const;
265			};
266
267			/**
268			* A fixed-size file, mapping a area of memory.
269			*/
270			class MemMapFile: public ConstMemMapFile {
271			public:
272			MemMapFile(void *buf, uint size);
273			/* extends Stream */
274			virtual uint write(const void *buf, uint size);
275			};
276
277			/**
278			* A file layer, representing a cropped version of a file
279			*/
280			class CroppedFile: public FileLayer {
281			protected:
282			FileOfs mCropStart;
283			bool mHasCropSize;
284			FileOfs mCropSize;
285			public:
286			// crop [start; start+size-1]
287			CroppedFile(File *file, bool own_file, FileOfs aCropStart, FileOfs aCropSize);
288			// no size, just start
289			CroppedFile(File *file, bool own_file, FileOfs aCropStart);
290			/* extends FileLayer */
291			virtual void extend(FileOfs newsize);
292			virtual String & getDesc(String &result) const;
293			virtual FileOfs getSize() const;
294			virtual void pstat(pstat_t &s) const;
295			virtual uint read(void *buf, uint size);
296			virtual void seek(FileOfs offset);
297			virtual FileOfs tell() const;
298			virtual void truncate(FileOfs newsize);
299			virtual uint write(const void *buf, uint size);
300			};
301
302			/**
303			* A (read-only) file with zero-content.
304			*/
305			class NullFile: public File {
306			public:
307			NullFile();
308			/* extends File */
309			virtual void extend(FileOfs newsize);
310			virtual String & getDesc(String &result) const;
311			virtual FileOfs getSize() const;
312			virtual void pstat(pstat_t &s) const;
313			virtual uint read(void *buf, uint size);
314			virtual void seek(FileOfs offset);
315			virtual int setAccessMode(IOAccessMode mode);
316			virtual FileOfs tell() const;
317			virtual void truncate(FileOfs newsize);
318			virtual uint write(const void *buf, uint size);
319			};
320
321			/**
322			* A file, existing only in memory.
323			*/
324			class MemoryFile: public File {
325			protected:
326			FileOfs ofs;
327			FileOfs pos;
328			uint bufsize, dsize, ibufsize;
329			byte *buf;
330
331			virtual uint extendBufSize(uint bufsize);
332			virtual uint shrinkBufSize(uint bufsize);
333			void extendBuf();
334			void shrinkBuf();
335			void resizeBuf(uint newsize);
336			public:
337			MemoryFile(FileOfs ofs = 0, uint size = 0, IOAccessMode mode = IOAM_READ \| IOAM_WRITE);
338			virtual ~MemoryFile();
339			/* extends File */
340			virtual void extend(FileOfs newsize);
341			virtual IOAccessMode getAccessMode() const;
342			virtual String & getDesc(String &result) const;
343			virtual FileOfs getSize() const;
344			virtual void pstat(pstat_t &s) const;
345			virtual uint read(void *buf, uint size);
346			virtual void seek(FileOfs offset);
347			virtual int setAccessMode(IOAccessMode mode);
348			virtual FileOfs tell() const;
349			virtual void truncate(FileOfs newsize);
350			virtual uint write(const void *buf, uint size);
351			/* new */
352			byte * getBufPtr() const;
353			};
354
355			void fileMove(File *file, FileOfs src, FileOfs dest, FileOfs size);
356
357			/** read string from file (zero-terminated, 8-bit chars) */
358			char fgetstrz(File file);
359			/** read string from stream (zero-terminated, 8-bit chars) */
360			char getstrz(Stream stream);
361			/** write string into stream (zero-terminated, 8-bit chars) */
362			void putstrz(Stream stream, const char str);
363
364			/** read string from stream (8-bit length followed by content aka. Pascal-style) */
365			char getstrp(Stream stream);
366			/** write string into stream (8-bit length followed by content aka. Pascal-style) */
367			void putstrp(Stream stream, const char str);
368
369			/** read string from stream (zero-terminated, 16-bit chars) */
370			char getstrw(Stream stream);
371			/** write string into stream (zero-terminated, 16-bit chars) */
372			void putstrw(Stream stream, const char str);
373
374			#endif /* __STREAM_H__ */