src/subtitles/libssf/File.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 "File.h"
  24
  25 #ifndef iswcsym
  26 #define iswcsym(c) (iswalnum(c) || (c) == '_')
  27 #endif
  28
  29 namespace ssf
  30 {
  31         File::File()
  32         {
  33         }
  34
  35         File::~File()
  36         {
  37         }
  38
  39         void File::Parse(InputStream& s, LPCWSTR predef)
  40         {
  41                 Reference* pRef = CreateRootRef();
  42
  43                 SetPredefined(true);
  44
  45                 try {ParseDefs(WCharInputStream(predef), pRef);}
  46                 catch(Exception& e) {ASSERT(0); TRACE(_T("%s\n"), e.ToString());}
  47
  48                 SetPredefined(false);
  49
  50                 ParseDefs(s, pRef);
  51
  52                 Commit();
  53
  54                 if(s.PeekChar() != Stream::EOS)
  55                 {
  56                         TRACE(_T("Warning: parsing ended before EOF!\n"));
  57                 }
  58         }
  59
  60         void File::ParseDefs(InputStream& s, Reference* pParentRef)
  61         {
  62                 while(s.SkipWhiteSpace(L";") != '}' && s.PeekChar() != Stream::EOS)
  63                 {
  64                         NodePriority priority = PNormal;
  65                         CAtlList<CStringW> types;
  66                         CStringW name;
  67
  68                         int c = s.SkipWhiteSpace();
  69
  70                         if(c == '*') {s.GetChar(); priority = PLow;}
  71                         else if(c == '!') {s.GetChar(); priority = PHigh;}
  72
  73                         ParseTypes(s, types);
  74
  75                         if(s.SkipWhiteSpace() == '#')
  76                         {
  77                                 s.GetChar();
  78                                 ParseName(s, name);
  79                         }
  80
  81                         if(types.IsEmpty())
  82                         {
  83                                 if(name.IsEmpty()) s.ThrowError(_T("syntax error"));
  84                                 types.AddTail(L"?");
  85                         }
  86
  87                         Reference* pRef = pParentRef;
  88
  89                         while(types.GetCount() > 1)
  90                                 pRef = CreateRef(CreateDef(pRef, types.RemoveHead()));
  91
  92                         Definition* pDef = NULL;
  93
  94                         if(!types.IsEmpty())
  95                                 pDef = CreateDef(pRef, types.RemoveHead(), name, priority);
  96
  97                         c = s.SkipWhiteSpace(L":=");
  98
  99                         if(c == '"' || c == '\'') ParseQuotedString(s, pDef);
 100                         else if(iswdigit(c) || c == '+' || c == '-') ParseNumber(s, pDef);
 101                         else if(pDef->IsType(L"@")) ParseBlock(s, pDef);
 102                         else ParseRefs(s, pDef);
 103                 }
 104
 105                 s.GetChar();
 106         }
 107
 108         void File::ParseTypes(InputStream& s, CAtlList<CStringW>& types)
 109         {
 110                 types.RemoveAll();
 111
 112                 CStringW str;
 113
 114                 for(int c = s.SkipWhiteSpace(); iswcsym(c) || c == '.' || c == '@'; c = s.PeekChar())
 115                 {
 116                         c = s.GetChar();
 117
 118                         if(c == '.')
 119                         {
 120                                 if(str.IsEmpty()) s.ThrowError(_T("'type' cannot be an empty string"));
 121                                 if(!iswcsym(s.PeekChar())) s.ThrowError(_T("unexpected dot after type '%s'"), CString(str));
 122
 123                                 types.AddTail(str);
 124                                 str.Empty();
 125                         }
 126                         else
 127                         {
 128                                 if(str.IsEmpty() && iswdigit(c)) s.ThrowError(_T("'type' cannot start with a number"));
 129                                 if((!str.IsEmpty() || !types.IsEmpty()) && c == '@') s.ThrowError(_T("unexpected @ in 'type'"));
 130
 131                                 str += (WCHAR)c;
 132                         }
 133                 }
 134
 135                 if(!str.IsEmpty())
 136                 {
 137                         types.AddTail(str);
 138                 }
 139         }
 140
 141         void File::ParseName(InputStream& s, CStringW& name)
 142         {
 143                 name.Empty();
 144
 145                 for(int c = s.SkipWhiteSpace(); iswcsym(c); c = s.PeekChar())
 146                 {
 147                         if(name.IsEmpty() && iswdigit(c)) s.ThrowError(_T("'name' cannot start with a number"));
 148                         name += (WCHAR)s.GetChar();
 149                 }
 150         }
 151
 152         void File::ParseQuotedString(InputStream& s, Definition* pDef)
 153         {
 154                 CStringW v;
 155
 156                 int quote = s.SkipWhiteSpace();
 157                 if(quote != '"' && quote != '\'') s.ThrowError(_T("expected qouted string"));
 158                 s.GetChar();
 159
 160                 for(int c = s.PeekChar(); c != Stream::EOS; c = s.PeekChar())
 161                 {
 162                         c = s.GetChar();
 163                         if(c == quote) {pDef->SetAsValue(Definition::string, v); return;}
 164                         if(c == '\n') s.ThrowError(_T("qouted string terminated unexpectedly by a new-line character"));
 165                         if(c == '\\') c = s.GetChar();
 166                         if(c == Stream::EOS) s.ThrowError(_T("qouted string terminated unexpectedly by EOS"));
 167                         v += (WCHAR)c;
 168                 }
 169
 170                 s.ThrowError(_T("unterminated quoted string"));
 171         }
 172
 173         void File::ParseNumber(InputStream& s, Definition* pDef)
 174         {
 175                 CStringW v, u;
 176
 177                 for(int c = s.SkipWhiteSpace(); iswxdigit(c) || wcschr(L"+-.x:", c); c = s.PeekChar())
 178                 {
 179                         if((c == '+' || c == '-') && !v.IsEmpty()
 180                         || (c == '.' && (v.IsEmpty() || v.Find('.') >= 0 || v.Find('x') >= 0))
 181                         || (c == 'x' && v != '0')
 182                         || (c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F') && v.Find(L"0x") != 0
 183                         || (c == ':' && v.IsEmpty()))
 184                         {
 185                                 s.ThrowError(_T("unexpected character '%c' in number"), (TCHAR)c);
 186                         }
 187
 188                         v += (WCHAR)s.GetChar();
 189                 }
 190
 191                 if(v.IsEmpty()) s.ThrowError(_T("invalid number"));
 192
 193                 for(int c = s.SkipWhiteSpace(); iswcsym(c); c = s.PeekChar())
 194                 {
 195                         u += (WCHAR)s.GetChar();
 196                 }
 197
 198                 pDef->SetAsNumber(v, u);
 199         }
 200
 201         void File::ParseBlock(InputStream& s, Definition* pDef)
 202         {
 203                 CStringW v;
 204
 205                 int c = s.SkipWhiteSpace(L":=");
 206                 if(c != '{') s.ThrowError(_T("expected '{'"));
 207                 s.GetChar();
 208
 209                 int depth = 0;
 210
 211                 for(int c = s.PeekChar(); c != Stream::EOS; c = s.PeekChar())
 212                 {
 213                         c = s.GetChar();
 214                         if(c == '}' && depth == 0) {pDef->SetAsValue(Definition::block, v); return;}
 215                         if(c == '\\') {v += (WCHAR)c; c = s.GetChar();}
 216                         else if(c == '{') depth++;
 217                         else if(c == '}') depth--;
 218                         if(c == Stream::EOS) s.ThrowError(_T("block terminated unexpectedly by EOS"));
 219                         v += (WCHAR)c;
 220                 }
 221
 222                 s.ThrowError(_T("unterminated block"));
 223         }
 224
 225         void File::ParseRefs(InputStream& s, Definition* pParentDef, LPCWSTR term)
 226         {
 227                 int c = s.SkipWhiteSpace();
 228
 229                 do
 230                 {
 231                         if(pParentDef->IsValue()) s.ThrowError(_T("cannot mix references with other values"));
 232
 233                         if(c == '{')
 234                         {
 235                                 s.GetChar();
 236                                 ParseDefs(s, CreateRef(pParentDef));
 237                         }
 238                         else if(iswcsym(c))
 239                         {
 240                                 CStringW str;
 241                                 ParseName(s, str);
 242
 243                                 // TODO: allow spec references: parent.<type>, self.<type>, child.<type>
 244
 245                                 Definition* pDef = GetDefByName(str);
 246                                 if(!pDef) s.ThrowError(_T("cannot find definition of '%s'"), CString(str));
 247
 248                                 if(!pParentDef->IsVisible(pDef)) s.ThrowError(_T("cannot access '%s' from here"), CString(str));
 249
 250                                 pParentDef->AddTail(pDef);
 251                         }
 252                         else if(!wcschr(term, c) && c != Stream::EOS)
 253                         {
 254                                 s.ThrowError(_T("unexpected character '%c'"), (TCHAR)c);
 255                         }
 256
 257                         c = s.SkipWhiteSpace();
 258                 }
 259                 while(!wcschr(term, c) && c != Stream::EOS);
 260         }
 261 }