src/subtitles/libssf/Node.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 "Node.h"
  24 #include "NodeFactory.h"
  25 #include "Exception.h"
  26 #include "Split.h"
  27
  28 #include <math.h>
  29
  30 namespace ssf
  31 {
  32         Node::Node(NodeFactory* pnf, CStringW name)
  33                 : m_pnf(pnf)
  34                 , m_type('?')
  35                 , m_name(name)
  36                 , m_priority(PNormal)
  37                 , m_predefined(false)
  38                 , m_parent(NULL)
  39         {
  40                 ASSERT(m_pnf);
  41         }
  42
  43         void Node::AddTail(Node* pNode)
  44         {
  45                 if(POSITION pos = m_nodes.Find(pNode)) // TODO: slow
  46                 {
  47                         m_nodes.MoveToTail(pos);
  48                         return;
  49                 }
  50
  51                 m_nodes.AddTail(pNode);
  52                 m_name2node[pNode->m_name] = pNode;
  53         }
  54
  55         bool Node::IsNameUnknown()
  56         {
  57                 return m_name.IsEmpty() || !!iswdigit(m_name[0]);
  58         }
  59
  60         bool Node::IsTypeUnknown()
  61         {
  62                 return m_type.IsEmpty() || m_type == '?';
  63         }
  64
  65         bool Node::IsType(CStringW type)
  66         {
  67                 return m_type == type;
  68         }
  69
  70         void Node::GetChildDefs(CAtlList<Definition*>& l, LPCWSTR type, bool fFirst)
  71         {
  72                 CAtlList<Definition*> rdl[3];
  73
  74                 if(fFirst)
  75                 {
  76                         if(Definition* pDef = m_pnf->GetDefByName(m_type))
  77                         {
  78                                 pDef->GetChildDefs(rdl[pDef->m_priority], type, false);
  79                         }
  80                 }
  81
  82                 POSITION pos = m_nodes.GetHeadPosition();
  83                 while(pos)
  84                 {
  85                         if(Node* pNode = m_nodes.GetNext(pos))
  86                         {
  87                                 pNode->GetChildDefs(rdl[pNode->m_priority], type, false);
  88                         }
  89                 }
  90
  91                 for(int i = 0; i < sizeof(rdl)/sizeof(rdl[0]); i++)
  92                 {
  93                         l.AddTailList(&rdl[i]);
  94                 }
  95         }
  96
  97         // Reference
  98
  99         Reference::Reference(NodeFactory* pnf, CStringW name)
 100                 : Node(pnf, name)
 101         {
 102         }
 103
 104         Reference::~Reference()
 105         {
 106         }
 107
 108         void Reference::GetChildDefs(CAtlList<Definition*>& l, LPCWSTR type, bool fFirst)
 109         {
 110                 CAtlList<Definition*> rdl[3];
 111
 112                 POSITION pos = m_nodes.GetHeadPosition();
 113                 while(pos)
 114                 {
 115                         if(Definition* pDef = dynamic_cast<Definition*>(m_nodes.GetNext(pos)))
 116                         {
 117                                 if(!type || pDef->m_type == type) // TODO: faster lookup
 118                                 {
 119                                         rdl[pDef->m_priority].AddTail(pDef);
 120                                 }
 121                         }
 122                 }
 123
 124                 for(int i = 0; i < sizeof(rdl)/sizeof(rdl[0]); i++)
 125                 {
 126                         l.AddTailList(&rdl[i]);
 127                 }
 128         }
 129
 130         void Reference::Dump(OutputStream& s, int level, bool fLast)
 131         {
 132                 if(m_predefined) return;
 133
 134                 CStringW tabs(' ', level*4);
 135
 136                 // s.PutString(tabs + '\n' + tabs + L" {\n");
 137                 s.PutString(L" {\n");
 138
 139                 POSITION pos = m_nodes.GetHeadPosition();
 140                 while(pos)
 141                 {
 142                         Node* pNode = m_nodes.GetNext(pos);
 143
 144                         if(Definition* pDef = dynamic_cast<Definition*>(pNode))
 145                         {
 146                                 pDef->Dump(s, level + 1, pos == NULL);
 147                         }
 148                 }
 149
 150                 s.PutString(tabs + '}');
 151         }
 152
 153         // Definition
 154
 155         Definition::Definition(NodeFactory* pnf, CStringW name)
 156                 : Node(pnf, name)
 157                 , m_status(node)
 158                 , m_autotype(false)
 159         {
 160         }
 161
 162         Definition::~Definition()
 163         {
 164                 RemoveFromCache();
 165         }
 166
 167         bool Definition::IsVisible(Definition* pDef)
 168         {
 169                 Node* pNode = m_parent;
 170
 171                 while(pNode)
 172                 {
 173                         if(pNode->m_name2node.Lookup(pDef->m_name))
 174                         {
 175                                 return true;
 176                         }
 177
 178                         pNode = pNode->m_parent;
 179                 }
 180
 181                 return false;
 182         }
 183
 184         void Definition::AddTail(Node* pNode)
 185         {
 186 //              if(Reference* pRef = dynamic_cast<Reference*>(pNode))
 187                 {
 188                         ASSERT(m_status == node);
 189
 190                         m_status = node;
 191
 192                         if(IsTypeUnknown() && !pNode->IsTypeUnknown())
 193                         {
 194                                 m_type = pNode->m_type;
 195                                 m_autotype = true;
 196                         }
 197
 198                         RemoveFromCache(pNode->m_type);
 199                 }
 200
 201                 __super::AddTail(pNode);
 202         }
 203
 204         Definition& Definition::operator[] (LPCWSTR type)
 205         {
 206                 Definition* pRetDef = NULL;
 207                 if(m_type2def.Lookup(type, pRetDef))
 208                         return *pRetDef;
 209
 210                 pRetDef = new Definition(m_pnf, L"");
 211                 pRetDef->m_priority = PLow;
 212                 pRetDef->m_type = type;
 213                 m_type2def[type] = pRetDef;
 214
 215                 CAtlList<Definition*> l;
 216                 GetChildDefs(l, type);
 217
 218                 while(!l.IsEmpty())
 219                 {
 220                         Definition* pDef = l.RemoveHead();
 221
 222                         pRetDef->m_priority = pDef->m_priority;
 223                         pRetDef->m_parent = pDef->m_parent;
 224
 225                         if(pDef->IsValue())
 226                         {
 227                                 pRetDef->SetAsValue(pDef->m_status, pDef->m_value, pDef->m_unit);
 228                         }
 229                         else
 230                         {
 231                                 pRetDef->m_status = node;
 232                                 pRetDef->m_nodes.AddTailList(&pDef->m_nodes);
 233                         }
 234                 }
 235
 236                 return *pRetDef;
 237         }
 238
 239         void Definition::RemoveFromCache(LPCWSTR type)
 240         {
 241                 if(!type)
 242                 {
 243                         POSITION pos = m_type2def.GetStartPosition();
 244                         while(pos) delete m_type2def.GetNextValue(pos);
 245                 }
 246                 else if(StringMapW<Definition*>::CPair* p = m_type2def.Lookup(type))
 247                 {
 248                         delete p->m_value;
 249                         m_type2def.RemoveKey(type);
 250                 }
 251         }
 252
 253         bool Definition::IsValue(status_t s)
 254         {
 255                 return s ? m_status == s : m_status != node;
 256         }
 257
 258         void Definition::SetAsValue(status_t s, CStringW v, CStringW u)
 259         {
 260                 ASSERT(s != node);
 261
 262                 m_nodes.RemoveAll();
 263                 m_name2node.RemoveAll();
 264
 265                 m_status = s;
 266
 267                 m_value = v;
 268                 m_unit = u;
 269         }
 270
 271         void Definition::SetAsNumber(CStringW v, CStringW u)
 272         {
 273                 SetAsValue(number, v, u);
 274
 275                 Number<float> n;
 276                 GetAsNumber(n); // will throw an exception if not a number
 277         }
 278
 279         template<class T>
 280         void Definition::GetAsNumber(Number<T>& n, StringMapW<T>* n2n)
 281         {
 282                 CStringW str = m_value;
 283                 str.Replace(L" ", L"");
 284
 285                 n.value = 0;
 286                 n.unit = m_unit;
 287                 n.sign = 0;
 288
 289                 if(n2n)
 290                 {
 291                         if(m_status == node) throw Exception(_T("expected value type"));
 292
 293                         if(StringMapW<T>::CPair* p = n2n->Lookup(str))
 294                         {
 295                                 n.value = p->m_value;
 296                                 return;
 297                         }
 298                 }
 299
 300                 if(m_status != number) throw Exception(_T("expected number"));
 301
 302                 n.sign = str.Find('+') == 0 ? 1 : str.Find('-') == 0 ? -1 : 0;
 303                 str.TrimLeft(L"+-");
 304
 305                 if(str.Find(L"0x") == 0)
 306                 {
 307                         if(n.sign) throw Exception(_T("hex values must be unsigned"));
 308
 309                         n.value = (T)wcstoul(str.Mid(2), NULL, 16);
 310                 }
 311                 else
 312                 {
 313                         CStringW num_string = m_value + m_unit;
 314
 315                         if(m_num_string != num_string)
 316                         {
 317                                 Split sa(':', str);
 318                                 Split sa2('.', sa ? sa[sa-1] : L"");
 319
 320                                 if(sa == 0 || sa2 == 0 || sa2 > 2) throw Exception(_T("invalid number"));
 321
 322                                 float f = 0;
 323                                 for(size_t i = 0; i < sa; i++) {f *= 60; f += wcstoul(sa[i], NULL, 10);}
 324                                 if(sa2 > 1) f += (float)wcstoul(sa2[1], NULL, 10) / pow((float)10, sa2[1].GetLength());
 325
 326                                 if(n.unit == L"ms") {f /= 1000; n.unit = L"s";}
 327                                 else if(n.unit == L"m") {f *= 60; n.unit = L"s";}
 328                                 else if(n.unit == L"h") {f *= 3600; n.unit = L"s";}
 329
 330                                 m_num.value = f;
 331                                 m_num.unit = n.unit;
 332                                 m_num_string = num_string;
 333
 334                                 n.value = (T)f;
 335                         }
 336                         else
 337                         {
 338                                 n.value = (T)m_num.value;
 339                                 n.unit = m_num.unit;
 340                         }
 341
 342                         if(n.sign) n.value *= n.sign;
 343                 }
 344         }
 345
 346         void Definition::GetAsString(CStringW& str)
 347         {
 348                 if(m_status == node) throw Exception(_T("expected value type"));
 349
 350                 str = m_value;
 351         }
 352
 353         void Definition::GetAsNumber(Number<int>& n, StringMapW<int>* n2n) {return GetAsNumber<int>(n, n2n);}
 354         void Definition::GetAsNumber(Number<DWORD>& n, StringMapW<DWORD>* n2n) {return GetAsNumber<DWORD>(n, n2n);}
 355         void Definition::GetAsNumber(Number<float>& n, StringMapW<float>* n2n) {return GetAsNumber<float>(n, n2n);}
 356
 357         void Definition::GetAsBoolean(bool& b)
 358         {
 359                 static StringMapW<bool> s2b;
 360
 361                 if(s2b.IsEmpty())
 362                 {
 363                         s2b[L"true"] = true;
 364                         s2b[L"on"] = true;
 365                         s2b[L"yes"] = true;
 366                         s2b[L"1"] = true;
 367                         s2b[L"false"] = false;
 368                         s2b[L"off"] = false;
 369                         s2b[L"no"] = false;
 370                         s2b[L"0"] = false;
 371                 }
 372
 373                 if(!s2b.Lookup(m_value, b)) // m_status != boolean && m_status != number ||
 374                 {
 375                         throw Exception(_T("expected boolean"));
 376                 }
 377         }
 378
 379         bool Definition::GetAsTime(Time& t, StringMapW<float>& offset, StringMapW<float>* n2n, int default_id)
 380         {
 381                 Definition& time = (*this)[L"time"];
 382
 383                 CStringW id;
 384                 if(time[L"id"].IsValue()) id = time[L"id"];
 385                 else id.Format(L"%d", default_id);
 386
 387                 float scale = time[L"scale"].IsValue() ? time[L"scale"] : 1.0f;
 388
 389                 if(time[L"start"].IsValue() && time[L"stop"].IsValue())
 390                 {
 391                         time[L"start"].GetAsNumber(t.start, n2n);
 392                         time[L"stop"].GetAsNumber(t.stop, n2n);
 393
 394                         if(t.start.unit.IsEmpty()) t.start.value *= scale;
 395                         if(t.stop.unit.IsEmpty()) t.stop.value *= scale;
 396
 397                         float o = 0;
 398                         offset.Lookup(id, o);
 399
 400                         if(t.start.sign != 0) t.start.value = o + t.start.value;
 401                         if(t.stop.sign != 0) t.stop.value = t.start.value + t.stop.value;
 402
 403                         offset[id] = t.stop.value;
 404
 405                         return true;
 406                 }
 407
 408                 return false;
 409         }
 410
 411         Definition::operator LPCWSTR()
 412         {
 413                 CStringW str;
 414                 GetAsString(str);
 415                 return str;
 416         }
 417
 418         Definition::operator float()
 419         {
 420                 float d;
 421                 GetAsNumber(d);
 422                 return d;
 423         }
 424
 425         Definition::operator bool()
 426         {
 427                 bool b;
 428                 GetAsBoolean(b);
 429                 return b;
 430         }
 431
 432         Definition* Definition::SetChildAsValue(CStringW path, status_t s, CStringW v, CStringW u)
 433         {
 434                 Definition* pDef = this;
 435
 436                 Split split('.', path);
 437
 438                 for(size_t i = 0, j = split-1; i <= j; i++)
 439                 {
 440                         CStringW type = split[i];
 441
 442                         if(pDef->m_nodes.IsEmpty() || !dynamic_cast<Reference*>(pDef->m_nodes.GetTail()))
 443                         {
 444                                 EXECUTE_ASSERT(m_pnf->CreateRef(pDef) != NULL);
 445                         }
 446
 447                         if(Reference* pRef = dynamic_cast<Reference*>(pDef->m_nodes.GetTail()))
 448                         {
 449                                 pDef = NULL;
 450
 451                                 POSITION pos = pRef->m_nodes.GetTailPosition();
 452                                 while(pos)
 453                                 {
 454                                         Definition* pChildDef = dynamic_cast<Definition*>(pRef->m_nodes.GetPrev(pos));
 455
 456                                         if(pChildDef->IsType(type))
 457                                         {
 458                                                 if(pChildDef->IsNameUnknown()) pDef = pChildDef;
 459                                                 break;
 460                                         }
 461                                 }
 462
 463                                 if(!pDef)
 464                                 {
 465                                         pDef = m_pnf->CreateDef(pRef, type);
 466                                 }
 467
 468                                 if(i == j)
 469                                 {
 470                                         pDef->SetAsValue(s, v, u);
 471                                         return pDef;
 472                                 }
 473                         }
 474                 }
 475
 476                 return NULL;
 477         }
 478
 479         Definition* Definition::SetChildAsNumber(CStringW path, CStringW v, CStringW u)
 480         {
 481                 Definition* pDef = SetChildAsValue(path, number, v, u);
 482
 483                 Number<float> n;
 484                 pDef->GetAsNumber(n); // will throw an exception if not a number
 485
 486                 return pDef;
 487         }
 488
 489         void Definition::Dump(OutputStream& s, int level, bool fLast)
 490         {
 491                 if(m_predefined) return;
 492
 493                 CStringW tabs(' ', level*4);
 494
 495                 CStringW str = tabs;
 496                 if(m_predefined) str += '?';
 497                 if(m_priority == PLow) str += '*';
 498                 else if(m_priority == PHigh) str += '!';
 499                 if(!IsTypeUnknown() && !m_autotype) str += m_type;
 500                 if(!IsNameUnknown()) str += '#' + m_name;
 501                 str += ':';
 502                 s.PutString(L"%s", str);
 503
 504                 if(!m_nodes.IsEmpty())
 505                 {
 506                         POSITION pos = m_nodes.GetHeadPosition();
 507                         while(pos)
 508                         {
 509                                 Node* pNode = m_nodes.GetNext(pos);
 510
 511                                 if(Reference* pRef = dynamic_cast<Reference*>(pNode))
 512                                 {
 513                                         pRef->Dump(s, level, fLast);
 514                                 }
 515                                 else
 516                                 {
 517                                         ASSERT(!pNode->IsNameUnknown());
 518                                         s.PutString(L" %s", pNode->m_name);
 519                                 }
 520                         }
 521
 522                         s.PutString(L";\n");
 523
 524                         if(!fLast && (!m_nodes.IsEmpty() || level == 0)) s.PutString(L"\n");
 525                 }
 526                 else if(m_status == string)
 527                 {
 528                         CStringW str = m_value;
 529                         str.Replace(L"\"", L"\\\"");
 530                         s.PutString(L" \"%s\";\n", str);
 531                 }
 532                 else if(m_status == number)
 533                 {
 534                         CStringW str = m_value;
 535                         if(!m_unit.IsEmpty()) str += m_unit;
 536                         s.PutString(L" %s;\n", str);
 537                 }
 538                 else if(m_status == boolean)
 539                 {
 540                         s.PutString(L" %s;\n", m_value);
 541                 }
 542                 else if(m_status == block)
 543                 {
 544                         s.PutString(L" {%s};\n", m_value);
 545                 }
 546                 else
 547                 {
 548                         s.PutString(L" null;\n");
 549                 }
 550         }
 551 }