src/subtitles/libssf/Stream.cpp

   1 /*
   2  *      Copyright (C) 2003-2006 Gabest
   3  *      http://www.gabest.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GNU Make; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *  http://www.gnu.org/copyleft/gpl.html
  19  *
  20  */
  21
  22 #include "stdafx.h"
  23 #include "Stream.h"
  24 #include <stdio.h>
  25
  26 namespace ssf
  27 {
  28         Stream::Stream()
  29                 : m_encoding(none)
  30                 , m_line(0)
  31                 , m_col(-1)
  32         {
  33
  34         }
  35
  36         Stream::~Stream()
  37         {
  38         }
  39
  40         void Stream::ThrowError(LPCTSTR fmt, ...)
  41         {
  42                 va_list args;
  43                 va_start(args, fmt);
  44                 int len = _vsctprintf(fmt, args) + 1;
  45                 CString str;
  46                 if(len > 0) _vstprintf_s(str.GetBufferSetLength(len), len, fmt, args);
  47                 va_end(args);
  48
  49                 throw Exception(_T("Error (Ln %d Col %d): %s"), m_line+1, m_col+1, str);
  50         }
  51
  52         bool Stream::IsWhiteSpace(int c, LPCWSTR morechars)
  53         {
  54                 return c != 0xa0 && iswspace(c) || morechars && wcschr(morechars, (WCHAR)c);
  55         }
  56
  57         //
  58
  59         InputStream::InputStream()
  60         {
  61
  62         }
  63
  64         InputStream::~InputStream()
  65         {
  66         }
  67
  68         int InputStream::NextChar()
  69         {
  70                 if(m_encoding == none)
  71                 {
  72                         m_encoding = unknown;
  73
  74                         switch(NextByte())
  75                         {
  76                         case 0xef:
  77                                 if(NextByte() == 0xbb && NextByte() == 0xbf) m_encoding = utf8;
  78                                 break;
  79                         case 0xff:
  80                                 if(NextByte() == 0xfe) m_encoding = utf16le;
  81                                 break;
  82                         case 0xfe:
  83                                 if(NextByte() == 0xff) m_encoding = utf16be;
  84                                 break;
  85                         }
  86                 }
  87
  88                 if(m_encoding == unknown)
  89                 {
  90                         throw Exception(_T("unknown character encoding, missing BOM"));
  91                 }
  92
  93                 int i, c;
  94
  95                 int cur = NextByte();
  96
  97                 switch(m_encoding)
  98                 {
  99                 case utf8:
 100                         for(i = 7; i >= 0 && (cur & (1 << i)); i--);
 101                         cur &= (1 << i) - 1;
 102                         while(++i < 7) {c = NextByte(); if(c == EOS) {cur = EOS; break;} cur = (cur << 6) | (c & 0x3f);}
 103                         break;
 104                 case utf16le:
 105                         c = NextByte();
 106                         if(c == EOS) {cur = EOS; break;}
 107                         cur = (c << 8) | cur;
 108                         break;
 109                 case utf16be:
 110                         c = NextByte();
 111                         if(c == EOS) {cur = EOS; break;}
 112                         cur = cur | (c << 8);
 113                         break;
 114                 case wchar:
 115                         break;
 116                 }
 117
 118                 return cur;
 119         }
 120
 121         int InputStream::PushChar()
 122         {
 123                 int c = NextChar();
 124                 m_queue.AddTail(c);
 125                 return c;
 126         }
 127
 128         int InputStream::PopChar()
 129         {
 130                 if(m_queue.IsEmpty()) ThrowError(_T("fatal stream error"));
 131
 132                 int c = m_queue.RemoveHead();
 133
 134                 if(c != EOS)
 135                 {
 136                         if(c == '\n') {m_line++; m_col = -1;}
 137                         m_col++;
 138                 }
 139
 140                 return c;
 141         }
 142
 143         int InputStream::PeekChar()
 144         {
 145                 while(m_queue.GetCount() < 2) PushChar();
 146
 147                 ASSERT(m_queue.GetCount() == 2);
 148
 149                 if(m_queue.GetHead() == '/' && m_queue.GetTail() == '/')
 150                 {
 151                         while(!m_queue.IsEmpty()) PopChar();
 152                         int c;
 153                         do {PushChar(); c = PopChar();} while(!(c == '\n' || c == EOS));
 154                         return PeekChar();
 155                 }
 156                 else if(m_queue.GetHead() == '/' && m_queue.GetTail() == '*')
 157                 {
 158                         while(!m_queue.IsEmpty()) PopChar();
 159                         int c1, c2;
 160                         PushChar();
 161                         do {c2 = PushChar(); c1 = PopChar();} while(!((c1 == '*' && c2 == '/') || c1 == EOS));
 162                         PopChar();
 163                         return PeekChar();
 164                 }
 165
 166                 return m_queue.GetHead();
 167         }
 168
 169         int InputStream::GetChar()
 170         {
 171                 if(m_queue.GetCount() < 2) PeekChar();
 172                 return PopChar();
 173         }
 174
 175         int InputStream::SkipWhiteSpace(LPCWSTR morechars)
 176         {
 177                 int c = PeekChar();
 178                 for(; IsWhiteSpace(c, morechars); c = PeekChar())
 179                         GetChar();
 180                 return c;
 181         }
 182
 183         // FileInputStream
 184
 185         FileInputStream::FileInputStream(const TCHAR* fn)
 186                 : m_file(NULL)
 187         {
 188                 if(_tfopen_s(&m_file, fn, _T("r")) != 0) ThrowError(_T("cannot open file '%s'"), fn);
 189         }
 190
 191         FileInputStream::~FileInputStream()
 192         {
 193                 if(m_file) {fclose(m_file); m_file = NULL;}
 194         }
 195
 196         int FileInputStream::NextByte()
 197         {
 198                 if(!m_file) ThrowError(_T("file pointer is NULL"));
 199                 return fgetc(m_file);
 200         }
 201
 202         // MemoryInputStream
 203
 204         MemoryInputStream::MemoryInputStream(BYTE* pBytes, int len, bool fCopy, bool fFree)
 205                 : m_pBytes(NULL)
 206                 , m_pos(0)
 207                 , m_len(len)
 208         {
 209                 if(fCopy)
 210                 {
 211                         m_pBytes = new BYTE[len];
 212                         if(m_pBytes) memcpy(m_pBytes, pBytes, len);
 213                         m_fFree = true;
 214                 }
 215                 else
 216                 {
 217                         m_pBytes = pBytes;
 218                         m_fFree = fFree;
 219                 }
 220
 221                 if(!m_pBytes) ThrowError(_T("memory stream pointer is NULL"));
 222         }
 223
 224         MemoryInputStream::~MemoryInputStream()
 225         {
 226                 if(m_fFree) delete [] m_pBytes;
 227                 m_pBytes = NULL;
 228         }
 229
 230         int MemoryInputStream::NextByte()
 231         {
 232                 if(!m_pBytes) ThrowError(_T("memory stream pointer is NULL"));
 233                 if(m_pos >= m_len) return Stream::EOS;
 234                 return (int)m_pBytes[m_pos++];
 235         }
 236
 237         // WCharInputStream
 238
 239         WCharInputStream::WCharInputStream(CStringW str)
 240                 : m_str(str)
 241                 , m_pos(0)
 242         {
 243                 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...
 244         }
 245
 246         int WCharInputStream::NextByte()
 247         {
 248                 if(m_pos >= m_str.GetLength()) return Stream::EOS;
 249                 return m_str[m_pos++];
 250         }
 251
 252         // OutputStream
 253
 254         OutputStream::OutputStream(encoding_t e)
 255         {
 256                 m_encoding = e;
 257                 m_bof = true;
 258         }
 259
 260         OutputStream::~OutputStream()
 261         {
 262         }
 263
 264         void OutputStream::PutChar(WCHAR c)
 265         {
 266                 if(m_bof)
 267                 {
 268                         m_bof = false;
 269
 270                         switch(m_encoding)
 271                         {
 272                         case utf8:
 273                         case utf16le:
 274                         case utf16be:
 275                                 PutChar(0xfeff);
 276                                 break;
 277                         }
 278                 }
 279
 280                 switch(m_encoding)
 281                 {
 282                 case utf8:
 283                         if(0 <= c && c < 0x80) // 0xxxxxxx
 284                         {
 285                                 NextByte(c);
 286                         }
 287                         else if(0x80 <= c && c < 0x800) // 110xxxxx 10xxxxxx
 288                         {
 289                                 NextByte(0xc0 | ((c<<2)&0x1f));
 290                                 NextByte(0x80 | ((c<<0)&0x3f));
 291                         }
 292                         else if(0x800 <= c && c < 0xFFFF) // 1110xxxx 10xxxxxx 10xxxxxx
 293                         {
 294                                 NextByte(0xe0 | ((c<<4)&0x0f));
 295                                 NextByte(0x80 | ((c<<2)&0x3f));
 296                                 NextByte(0x80 | ((c<<0)&0x3f));
 297                         }
 298                         else
 299                         {
 300                                 NextByte('?');
 301                         }
 302                         break;
 303                 case utf16le:
 304                         NextByte(c & 0xff);
 305                         NextByte((c >> 8) & 0xff);
 306                         break;
 307                 case utf16be:
 308                         NextByte((c >> 8) & 0xff);
 309                         NextByte(c & 0xff);
 310                         break;
 311                 case wchar:
 312                         NextByte(c);
 313                         break;
 314                 }
 315         }
 316
 317         void OutputStream::PutString(LPCWSTR fmt, ...)
 318         {
 319                 CStringW str;
 320
 321                 va_list args;
 322                 va_start(args, fmt);
 323                 int len = _vscwprintf(fmt, args) + 1;
 324                 if(len > 0) vswprintf_s(str.GetBufferSetLength(len), len, fmt, args);
 325                 va_end(args);
 326
 327                 LPCWSTR s = str;
 328                 while(*s) PutChar(*s++);
 329         }
 330
 331         // WCharOutputStream
 332
 333         WCharOutputStream::WCharOutputStream()
 334                 : OutputStream(wchar)
 335         {
 336         }
 337
 338         void WCharOutputStream::NextByte(int b)
 339         {
 340                 m_str += (WCHAR)b;
 341         }
 342
 343         // DebugOutputStream
 344
 345         DebugOutputStream::DebugOutputStream()
 346                 : OutputStream(wchar)
 347         {
 348         }
 349
 350         DebugOutputStream::~DebugOutputStream()
 351         {
 352                 TRACE(_T("%s\n"), m_str);
 353         }
 354
 355         void DebugOutputStream::NextByte(int b)
 356         {
 357                 if(b == '\n') {TRACE(_T("%s\n"), m_str); m_str.Empty();}
 358                 else if(b != '\r') m_str += (WCHAR)b;
 359         }
 360 }