Show Stream.cpp syntax highlighted
/*
* Copyright (C) 2003-2006 Gabest
* http://www.gabest.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* 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 GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#include "stdafx.h"
#include "Stream.h"
#include <stdio.h>
namespace ssf
{
Stream::Stream()
: m_encoding(none)
, m_line(0)
, m_col(-1)
{
}
Stream::~Stream()
{
}
void Stream::ThrowError(LPCTSTR fmt, ...)
{
va_list args;
va_start(args, fmt);
int len = _vsctprintf(fmt, args) + 1;
CString str;
if(len > 0) _vstprintf_s(str.GetBufferSetLength(len), len, fmt, args);
va_end(args);
throw Exception(_T("Error (Ln %d Col %d): %s"), m_line+1, m_col+1, str);
}
bool Stream::IsWhiteSpace(int c, LPCWSTR morechars)
{
return c != 0xa0 && iswspace(c) || morechars && wcschr(morechars, (WCHAR)c);
}
//
InputStream::InputStream()
{
}
InputStream::~InputStream()
{
}
int InputStream::NextChar()
{
if(m_encoding == none)
{
m_encoding = unknown;
switch(NextByte())
{
case 0xef:
if(NextByte() == 0xbb && NextByte() == 0xbf) m_encoding = utf8;
break;
case 0xff:
if(NextByte() == 0xfe) m_encoding = utf16le;
break;
case 0xfe:
if(NextByte() == 0xff) m_encoding = utf16be;
break;
}
}
if(m_encoding == unknown)
{
throw Exception(_T("unknown character encoding, missing BOM"));
}
int i, c;
int cur = NextByte();
switch(m_encoding)
{
case utf8:
for(i = 7; i >= 0 && (cur & (1 << i)); i--);
cur &= (1 << i) - 1;
while(++i < 7) {c = NextByte(); if(c == EOS) {cur = EOS; break;} cur = (cur << 6) | (c & 0x3f);}
break;
case utf16le:
c = NextByte();
if(c == EOS) {cur = EOS; break;}
cur = (c << 8) | cur;
break;
case utf16be:
c = NextByte();
if(c == EOS) {cur = EOS; break;}
cur = cur | (c << 8);
break;
case wchar:
break;
}
return cur;
}
int InputStream::PushChar()
{
int c = NextChar();
m_queue.AddTail(c);
return c;
}
int InputStream::PopChar()
{
if(m_queue.IsEmpty()) ThrowError(_T("fatal stream error"));
int c = m_queue.RemoveHead();
if(c != EOS)
{
if(c == '\n') {m_line++; m_col = -1;}
m_col++;
}
return c;
}
int InputStream::PeekChar()
{
while(m_queue.GetCount() < 2) PushChar();
ASSERT(m_queue.GetCount() == 2);
if(m_queue.GetHead() == '/' && m_queue.GetTail() == '/')
{
while(!m_queue.IsEmpty()) PopChar();
int c;
do {PushChar(); c = PopChar();} while(!(c == '\n' || c == EOS));
return PeekChar();
}
else if(m_queue.GetHead() == '/' && m_queue.GetTail() == '*')
{
while(!m_queue.IsEmpty()) PopChar();
int c1, c2;
PushChar();
do {c2 = PushChar(); c1 = PopChar();} while(!((c1 == '*' && c2 == '/') || c1 == EOS));
PopChar();
return PeekChar();
}
return m_queue.GetHead();
}
int InputStream::GetChar()
{
if(m_queue.GetCount() < 2) PeekChar();
return PopChar();
}
int InputStream::SkipWhiteSpace(LPCWSTR morechars)
{
int c = PeekChar();
for(; IsWhiteSpace(c, morechars); c = PeekChar())
GetChar();
return c;
}
// FileInputStream
FileInputStream::FileInputStream(const TCHAR* fn)
: m_file(NULL)
{
if(_tfopen_s(&m_file, fn, _T("r")) != 0) ThrowError(_T("cannot open file '%s'"), fn);
}
FileInputStream::~FileInputStream()
{
if(m_file) {fclose(m_file); m_file = NULL;}
}
int FileInputStream::NextByte()
{
if(!m_file) ThrowError(_T("file pointer is NULL"));
return fgetc(m_file);
}
// MemoryInputStream
MemoryInputStream::MemoryInputStream(BYTE* pBytes, int len, bool fCopy, bool fFree)
: m_pBytes(NULL)
, m_pos(0)
, m_len(len)
{
if(fCopy)
{
m_pBytes = new BYTE[len];
if(m_pBytes) memcpy(m_pBytes, pBytes, len);
m_fFree = true;
}
else
{
m_pBytes = pBytes;
m_fFree = fFree;
}
if(!m_pBytes) ThrowError(_T("memory stream pointer is NULL"));
}
MemoryInputStream::~MemoryInputStream()
{
if(m_fFree) delete [] m_pBytes;
m_pBytes = NULL;
}
int MemoryInputStream::NextByte()
{
if(!m_pBytes) ThrowError(_T("memory stream pointer is NULL"));
if(m_pos >= m_len) return Stream::EOS;
return (int)m_pBytes[m_pos++];
}
// WCharInputStream
WCharInputStream::WCharInputStream(CStringW str)
: m_str(str)
, m_pos(0)
{
m_encoding = Stream::wchar; // HACK: it should return real bytes from NextByte (two per wchar_t), but this way it's a lot more simple...
}
int WCharInputStream::NextByte()
{
if(m_pos >= m_str.GetLength()) return Stream::EOS;
return m_str[m_pos++];
}
// OutputStream
OutputStream::OutputStream(encoding_t e)
{
m_encoding = e;
m_bof = true;
}
OutputStream::~OutputStream()
{
}
void OutputStream::PutChar(WCHAR c)
{
if(m_bof)
{
m_bof = false;
switch(m_encoding)
{
case utf8:
case utf16le:
case utf16be:
PutChar(0xfeff);
break;
}
}
switch(m_encoding)
{
case utf8:
if(0 <= c && c < 0x80) // 0xxxxxxx
{
NextByte(c);
}
else if(0x80 <= c && c < 0x800) // 110xxxxx 10xxxxxx
{
NextByte(0xc0 | ((c<<2)&0x1f));
NextByte(0x80 | ((c<<0)&0x3f));
}
else if(0x800 <= c && c < 0xFFFF) // 1110xxxx 10xxxxxx 10xxxxxx
{
NextByte(0xe0 | ((c<<4)&0x0f));
NextByte(0x80 | ((c<<2)&0x3f));
NextByte(0x80 | ((c<<0)&0x3f));
}
else
{
NextByte('?');
}
break;
case utf16le:
NextByte(c & 0xff);
NextByte((c >> 8) & 0xff);
break;
case utf16be:
NextByte((c >> 8) & 0xff);
NextByte(c & 0xff);
break;
case wchar:
NextByte(c);
break;
}
}
void OutputStream::PutString(LPCWSTR fmt, ...)
{
CStringW str;
va_list args;
va_start(args, fmt);
int len = _vscwprintf(fmt, args) + 1;
if(len > 0) vswprintf_s(str.GetBufferSetLength(len), len, fmt, args);
va_end(args);
LPCWSTR s = str;
while(*s) PutChar(*s++);
}
// WCharOutputStream
WCharOutputStream::WCharOutputStream()
: OutputStream(wchar)
{
}
void WCharOutputStream::NextByte(int b)
{
m_str += (WCHAR)b;
}
// DebugOutputStream
DebugOutputStream::DebugOutputStream()
: OutputStream(wchar)
{
}
DebugOutputStream::~DebugOutputStream()
{
TRACE(_T("%s\n"), m_str);
}
void DebugOutputStream::NextByte(int b)
{
if(b == '\n') {TRACE(_T("%s\n"), m_str); m_str.Empty();}
else if(b != '\r') m_str += (WCHAR)b;
}
}
See more files for this project here