layout/generic/nsFrameUtil.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is Mozilla Communicator client code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 /* utilities for regression tests based on frame tree comparison */
  39
  40 #include "nsIFrameUtil.h"
  41 #include "nsFrame.h"
  42 #include "nsString.h"
  43 #include "nsRect.h"
  44 #include <stdlib.h>
  45 #include "plstr.h"
  46
  47
  48 #ifdef NS_DEBUG
  49 class nsFrameUtil : public nsIFrameUtil {
  50 public:
  51   nsFrameUtil();
  52   virtual ~nsFrameUtil();
  53
  54   NS_DECL_ISUPPORTS
  55
  56   NS_IMETHOD CompareRegressionData(FILE* aFile1, FILE* aFile2,PRInt32 aRegressionOutput=0);
  57   NS_IMETHOD DumpRegressionData(FILE* aInputFile, FILE* aOutputFile);
  58
  59   struct Node;
  60   struct Tag;
  61
  62   struct NodeList {
  63     NodeList();
  64     ~NodeList();
  65
  66     static void Destroy(NodeList* aLists);
  67
  68     NodeList* next;            // for lists of lists
  69     Node* node;
  70     char* name;
  71   };
  72
  73   struct Node {
  74     Node();
  75     ~Node();
  76
  77     static void Destroy(Node* aNode);
  78
  79     static Node* Read(FILE* aFile, Tag* aTag);
  80
  81     static Node* ReadTree(FILE* aFile);
  82
  83     Node* next;
  84     char* type;
  85     PRUint32 state;
  86     nsRect bbox;
  87     nsCString styleData;
  88     NodeList* lists;
  89   };
  90
  91   struct Tag {
  92     Tag();
  93     ~Tag();
  94
  95     static Tag* Parse(FILE* aFile);
  96
  97     void AddAttr(char* aAttr, char* aValue);
  98
  99     const char* GetAttr(const char* aAttr);
 100
 101     void ReadAttrs(FILE* aFile);
 102
 103     void ToString(nsString& aResult);
 104
 105     enum Type {
 106       open,
 107       close,
 108       openClose
 109     };
 110
 111     char* name;
 112     Type type;
 113     char** attributes;
 114     PRInt32 num;
 115     PRInt32 size;
 116     char** values;
 117   };
 118
 119   static char* Copy(const char* aString);
 120
 121   static void DumpNode(Node* aNode, FILE* aOutputFile, PRInt32 aIndent);
 122   static void DumpTree(Node* aNode, FILE* aOutputFile, PRInt32 aIndent);
 123   static PRBool CompareTrees(Node* aNode1, Node* aNode2);
 124 };
 125
 126 char*
 127 nsFrameUtil::Copy(const char* aString)
 128 {
 129   if (aString) {
 130     int l = ::strlen(aString);
 131     char* c = new char[l+1];
 132     if (!c)
 133       return nsnull;
 134     memcpy(c, aString, l+1);
 135     return c;
 136   }
 137   return nsnull;
 138 }
 139
 140 //----------------------------------------------------------------------
 141
 142 nsFrameUtil::NodeList::NodeList()
 143   : next(nsnull), node(nsnull), name(nsnull)
 144 {
 145 }
 146
 147 nsFrameUtil::NodeList::~NodeList()
 148 {
 149   if (nsnull != name) {
 150     delete name;
 151   }
 152   if (nsnull != node) {
 153     Node::Destroy(node);
 154   }
 155 }
 156
 157 void
 158 nsFrameUtil::NodeList::Destroy(NodeList* aLists)
 159 {
 160   while (nsnull != aLists) {
 161     NodeList* next = aLists->next;
 162     delete aLists;
 163     aLists = next;
 164   }
 165 }
 166
 167 //----------------------------------------------------------------------
 168
 169 nsFrameUtil::Node::Node()
 170   : next(nsnull), type(nsnull), state(0), lists(nsnull)
 171 {
 172 }
 173
 174 nsFrameUtil::Node::~Node()
 175 {
 176   if (nsnull != type) {
 177     delete type;
 178   }
 179   if (nsnull != lists) {
 180     NodeList::Destroy(lists);
 181   }
 182 }
 183
 184 void
 185 nsFrameUtil::Node::Destroy(Node* aList)
 186 {
 187   while (nsnull != aList) {
 188     Node* next = aList->next;
 189     delete aList;
 190     aList = next;
 191   }
 192 }
 193
 194 static PRInt32 GetInt(nsFrameUtil::Tag* aTag, const char* aAttr)
 195 {
 196   const char* value = aTag->GetAttr(aAttr);
 197   if (nsnull != value) {
 198     return PRInt32( atoi(value) );
 199   }
 200   return 0;
 201 }
 202
 203 nsFrameUtil::Node*
 204 nsFrameUtil::Node::ReadTree(FILE* aFile)
 205 {
 206   Tag* tag = Tag::Parse(aFile);
 207   if (nsnull == tag) {
 208     return nsnull;
 209   }
 210   if (PL_strcmp(tag->name, "frame") != 0) {
 211     delete tag;
 212     return nsnull;
 213   }
 214   Node* result = Read(aFile, tag);
 215   fclose(aFile);
 216   return result;
 217 }
 218
 219 nsFrameUtil::Node*
 220 nsFrameUtil::Node::Read(FILE* aFile, Tag* tag)
 221 {
 222   Node* node = new Node;
 223   if (!node) {
 224     /* crash() */
 225   }
 226   node->type = Copy(tag->GetAttr("type"));
 227   if (!node->type) {
 228     /* crash() */
 229   }
 230   node->state = GetInt(tag, "state");
 231   delete tag;
 232
 233   for (;;) {
 234     tag = Tag::Parse(aFile);
 235     if (nsnull == tag) break;
 236     if (PL_strcmp(tag->name, "frame") == 0) {
 237       delete tag;
 238       break;
 239     }
 240     if (PL_strcmp(tag->name, "bbox") == 0) {
 241       nscoord x = nscoord( GetInt(tag, "x") );
 242       nscoord y = nscoord( GetInt(tag, "y") );
 243       nscoord w = nscoord( GetInt(tag, "w") );
 244       nscoord h = nscoord( GetInt(tag, "h") );
 245       node->bbox.SetRect(x, y, w, h);
 246     }
 247     else if (PL_strcmp(tag->name, "child-list") == 0) {
 248       NodeList* list = new NodeList();
 249       list->name = Copy(tag->GetAttr("name"));
 250       if (!list->name) {
 251         /* crash() */
 252       }
 253       list->next = node->lists;
 254       node->lists = list;
 255       delete tag;
 256
 257       Node** tailp = &list->node;
 258       for (;;) {
 259         tag = Tag::Parse(aFile);
 260         if (nsnull == tag) {
 261           break;
 262         }
 263         if (PL_strcmp(tag->name, "child-list") == 0) {
 264           break;
 265         }
 266         if (PL_strcmp(tag->name, "frame") != 0) {
 267           break;
 268         }
 269         Node* child = Node::Read(aFile, tag);
 270         if (nsnull == child) {
 271           break;
 272         }
 273         *tailp = child;
 274         tailp = &child->next;
 275       }
 276     }
 277     else if((PL_strcmp(tag->name, "font") == 0) ||
 278             (PL_strcmp(tag->name, "color") == 0) ||
 279             (PL_strcmp(tag->name, "spacing") == 0) ||
 280             (PL_strcmp(tag->name, "list") == 0) ||
 281             (PL_strcmp(tag->name, "position") == 0) ||
 282             (PL_strcmp(tag->name, "text") == 0) ||
 283             (PL_strcmp(tag->name, "display") == 0) ||
 284             (PL_strcmp(tag->name, "table") == 0) ||
 285             (PL_strcmp(tag->name, "content") == 0) ||
 286             (PL_strcmp(tag->name, "UI") == 0) ||
 287             (PL_strcmp(tag->name, "print") == 0)) {
 288       const char* attr = tag->GetAttr("data");
 289       node->styleData.Append('|');
 290       node->styleData.Append(attr ? attr : "null attr");
 291     }
 292
 293     delete tag;
 294   }
 295   return node;
 296 }
 297
 298 //----------------------------------------------------------------------
 299
 300 nsFrameUtil::Tag::Tag()
 301   : name(nsnull), type(open), attributes(nsnull), num(0), size(0),
 302     values(nsnull)
 303 {
 304 }
 305
 306 nsFrameUtil::Tag::~Tag()
 307 {
 308   PRInt32 i, n = num;
 309   if (0 != n) {
 310     for (i = 0; i < n; i++) {
 311       delete attributes[i];
 312       delete values[i];
 313     }
 314     delete attributes;
 315     delete values;
 316   }
 317 }
 318
 319 void
 320 nsFrameUtil::Tag::AddAttr(char* aAttr, char* aValue)
 321 {
 322   if (num == size) {
 323     PRInt32 newSize = size * 2 + 4;
 324     char** a = new char*[newSize];
 325     char** v = new char*[newSize];
 326     if (0 != num) {
 327       memcpy(a, attributes, num * sizeof(char*));
 328       memcpy(v, values, num * sizeof(char*));
 329       delete attributes;
 330       delete values;
 331     }
 332     attributes = a;
 333     values = v;
 334     size = newSize;
 335   }
 336   attributes[num] = aAttr;
 337   values[num] = aValue;
 338   num = num + 1;
 339 }
 340
 341 const char*
 342 nsFrameUtil::Tag::GetAttr(const char* aAttr)
 343 {
 344   PRInt32 i, n = num;
 345   for (i = 0; i < n; i++) {
 346     if (PL_strcmp(attributes[i], aAttr) == 0) {
 347       return values[i];
 348     }
 349   }
 350   return nsnull;
 351 }
 352
 353 static inline int IsWhiteSpace(int c) {
 354   return (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r');
 355 }
 356
 357 static PRBool EatWS(FILE* aFile)
 358 {
 359   for (;;) {
 360     int c = getc(aFile);
 361     if (c < 0) {
 362       return PR_FALSE;
 363     }
 364     if (!IsWhiteSpace(c)) {
 365       ungetc(c, aFile);
 366       break;
 367     }
 368   }
 369   return PR_TRUE;
 370 }
 371
 372 static PRBool Expect(FILE* aFile, char aChar)
 373 {
 374   int c = getc(aFile);
 375   if (c < 0) return PR_FALSE;
 376   if (c != aChar) {
 377     ungetc(c, aFile);
 378     return PR_FALSE;
 379   }
 380   return PR_TRUE;
 381 }
 382
 383 static char* ReadIdent(FILE* aFile)
 384 {
 385   char id[1000];
 386   char* ip = id;
 387   char* end = ip + sizeof(id) - 1;
 388   while (ip < end) {
 389     int c = fgetc(aFile);
 390     if (c < 0) return nsnull;
 391     if ((c == '=') || (c == '>') || (c == '/') || IsWhiteSpace(c)) {
 392       ungetc(c, aFile);
 393       break;
 394     }
 395     *ip++ = char(c);
 396   }
 397   *ip = '\0';
 398   return nsFrameUtil::Copy(id);
 399   /* may return a null pointer */
 400 }
 401
 402 static char* ReadString(FILE* aFile)
 403 {
 404   if (!Expect(aFile, '\"')) {
 405     return nsnull;
 406   }
 407   char id[1000];
 408   char* ip = id;
 409   char* end = ip + sizeof(id) - 1;
 410   while (ip < end) {
 411     int c = fgetc(aFile);
 412     if (c < 0) return nsnull;
 413     if (c == '\"') {
 414       break;
 415     }
 416     *ip++ = char(c);
 417   }
 418   *ip = '\0';
 419   return nsFrameUtil::Copy(id);
 420   /* may return a null pointer */
 421 }
 422
 423 void
 424 nsFrameUtil::Tag::ReadAttrs(FILE* aFile)
 425 {
 426   for (;;) {
 427     if (!EatWS(aFile)) {
 428       break;
 429     }
 430     int c = getc(aFile);
 431     if (c < 0) break;
 432     if (c == '/') {
 433       if (!EatWS(aFile)) {
 434         return;
 435       }
 436       if (Expect(aFile, '>')) {
 437         type = openClose;
 438         break;
 439       }
 440     }
 441     else if (c == '>') {
 442       break;
 443     }
 444     ungetc(c, aFile);
 445     char* attr = ReadIdent(aFile);
 446     if ((nsnull == attr) || !EatWS(aFile)) {
 447       break;
 448     }
 449     char* value = nsnull;
 450     if (Expect(aFile, '=')) {
 451       value = ReadString(aFile);
 452       if (nsnull == value) {
 453         delete [] attr;
 454         break;
 455       }
 456     }
 457     AddAttr(attr, value);
 458   }
 459 }
 460
 461 nsFrameUtil::Tag*
 462 nsFrameUtil::Tag::Parse(FILE* aFile)
 463 {
 464   if (!EatWS(aFile)) {
 465     return nsnull;
 466   }
 467   if (Expect(aFile, '<')) {
 468     Tag* tag = new Tag;
 469     if (Expect(aFile, '/')) {
 470       tag->type = close;
 471     }
 472     else {
 473       tag->type = open;
 474     }
 475     tag->name = ReadIdent(aFile);
 476     tag->ReadAttrs(aFile);
 477     return tag;
 478   }
 479   return nsnull;
 480 }
 481
 482 void
 483 nsFrameUtil::Tag::ToString(nsString& aResult)
 484 {
 485   aResult.Truncate();
 486   aResult.Append(PRUnichar('<'));
 487   if (type == close) {
 488     aResult.Append(PRUnichar('/'));
 489   }
 490   aResult.AppendASCII(name);
 491   if (0 != num) {
 492     PRInt32 i, n = num;
 493     for (i = 0; i < n; i++) {
 494       aResult.Append(PRUnichar(' '));
 495       aResult.AppendASCII(attributes[i]);
 496       if (values[i]) {
 497         aResult.AppendLiteral("=\"");
 498         aResult.AppendASCII(values[i]);
 499         aResult.Append(PRUnichar('\"'));
 500       }
 501     }
 502   }
 503   if (type == openClose) {
 504     aResult.Append(PRUnichar('/'));
 505   }
 506   aResult.Append(PRUnichar('>'));
 507 }
 508
 509 //----------------------------------------------------------------------
 510
 511 nsresult NS_NewFrameUtil(nsIFrameUtil** aResult);
 512 nsresult
 513 NS_NewFrameUtil(nsIFrameUtil** aResult)
 514 {
 515   NS_PRECONDITION(nsnull != aResult, "null pointer");
 516   if (nsnull == aResult) {
 517     return NS_ERROR_NULL_POINTER;
 518   }
 519   *aResult = nsnull;
 520
 521   nsFrameUtil* it = new nsFrameUtil();
 522   if (nsnull == it) {
 523     return NS_ERROR_OUT_OF_MEMORY;
 524   }
 525   return it->QueryInterface(NS_GET_IID(nsIFrameUtil), (void**) aResult);
 526 }
 527
 528 nsFrameUtil::nsFrameUtil()
 529 {
 530 }
 531
 532 nsFrameUtil::~nsFrameUtil()
 533 {
 534 }
 535
 536 NS_IMPL_ISUPPORTS1(nsFrameUtil, nsIFrameUtil)
 537
 538 void
 539 nsFrameUtil::DumpNode(Node* aNode, FILE* aOutputFile, PRInt32 aIndent)
 540 {
 541   nsFrame::IndentBy(aOutputFile, aIndent);
 542   fprintf(aOutputFile, "%s 0x%x %d,%d,%d,%d, %s\n", aNode->type, aNode->state,
 543           aNode->bbox.x, aNode->bbox.y,
 544           aNode->bbox.width, aNode->bbox.height,
 545           aNode->styleData.get());
 546 }
 547
 548 void
 549 nsFrameUtil::DumpTree(Node* aNode, FILE* aOutputFile, PRInt32 aIndent)
 550 {
 551   while (nsnull != aNode) {
 552     DumpNode(aNode, aOutputFile, aIndent);
 553     nsFrameUtil::NodeList* lists = aNode->lists;
 554     if (nsnull != lists) {
 555       while (nsnull != lists) {
 556         nsFrame::IndentBy(aOutputFile, aIndent);
 557         fprintf(aOutputFile, " list: %s\n",
 558                 lists->name ? lists->name : "primary");
 559         DumpTree(lists->node, aOutputFile, aIndent + 1);
 560         lists = lists->next;
 561       }
 562     }
 563     aNode = aNode->next;
 564   }
 565 }
 566
 567 PRBool
 568 nsFrameUtil::CompareTrees(Node* tree1, Node* tree2)
 569 {
 570   PRBool result = PR_TRUE;
 571   for (;; tree1 = tree1->next, tree2 = tree2->next) {
 572     // Make sure both nodes are non-null, or at least agree with each other
 573     if (nsnull == tree1) {
 574       if (nsnull == tree2) {
 575         break;
 576       }
 577       printf("first tree prematurely ends\n");
 578       return PR_FALSE;
 579     }
 580     else if (nsnull == tree2) {
 581       printf("second tree prematurely ends\n");
 582       return PR_FALSE;
 583     }
 584
 585     // Check the attributes that we care about
 586     if (0 != PL_strcmp(tree1->type, tree2->type)) {
 587       printf("frame type mismatch: %s vs. %s\n", tree1->type, tree2->type);
 588       printf("Node 1:\n");
 589       DumpNode(tree1, stdout, 1);
 590       printf("Node 2:\n");
 591       DumpNode(tree2, stdout, 1);
 592       return PR_FALSE;
 593     }
 594
 595     // Ignore the XUL scrollbar frames
 596     static const char kScrollbarFrame[] = "ScrollbarFrame";
 597     if (0 == PL_strncmp(tree1->type, kScrollbarFrame, sizeof(kScrollbarFrame) - 1))
 598       continue;
 599
 600     if (tree1->state != tree2->state) {
 601       printf("frame state mismatch: 0x%x vs. 0x%x\n",
 602              tree1->state, tree2->state);
 603       printf("Node 1:\n");
 604       DumpNode(tree1, stdout, 1);
 605       printf("Node 2:\n");
 606       DumpNode(tree2, stdout, 1);
 607       result = PR_FALSE; // we have a non-critical failure, so remember that but continue
 608     }
 609     if (tree1->bbox != tree2->bbox) {
 610       printf("frame bbox mismatch: %d,%d,%d,%d vs. %d,%d,%d,%d\n",
 611              tree1->bbox.x, tree1->bbox.y,
 612              tree1->bbox.width, tree1->bbox.height,
 613              tree2->bbox.x, tree2->bbox.y,
 614              tree2->bbox.width, tree2->bbox.height);
 615       printf("Node 1:\n");
 616       DumpNode(tree1, stdout, 1);
 617       printf("Node 2:\n");
 618       DumpNode(tree2, stdout, 1);
 619       result = PR_FALSE; // we have a non-critical failure, so remember that but continue
 620     }
 621     if (tree1->styleData != tree2->styleData) {
 622       printf("frame style data mismatch: %s vs. %s\n",
 623         tree1->styleData.get(),
 624         tree2->styleData.get());
 625     }
 626
 627     // Check child lists too
 628     NodeList* list1 = tree1->lists;
 629     NodeList* list2 = tree2->lists;
 630     for (;;) {
 631       if (nsnull == list1) {
 632         if (nsnull != list2) {
 633           printf("first tree prematurely ends (no child lists)\n");
 634           printf("Node 1:\n");
 635           DumpNode(tree1, stdout, 1);
 636           printf("Node 2:\n");
 637           DumpNode(tree2, stdout, 1);
 638           return PR_FALSE;
 639         }
 640         else {
 641           break;
 642         }
 643       }
 644       if (nsnull == list2) {
 645         printf("second tree prematurely ends (no child lists)\n");
 646         printf("Node 1:\n");
 647         DumpNode(tree1, stdout, 1);
 648         printf("Node 2:\n");
 649         DumpNode(tree2, stdout, 1);
 650         return PR_FALSE;
 651       }
 652       if (0 != PL_strcmp(list1->name, list2->name)) {
 653         printf("child-list name mismatch: %s vs. %s\n",
 654                list1->name ? list1->name : "(null)",
 655                list2->name ? list2->name : "(null)");
 656         result = PR_FALSE; // we have a non-critical failure, so remember that but continue
 657       }
 658       else {
 659         PRBool equiv = CompareTrees(list1->node, list2->node);
 660         if (!equiv) {
 661           return equiv;
 662         }
 663       }
 664       list1 = list1->next;
 665       list2 = list2->next;
 666     }
 667   }
 668   return result;
 669 }
 670
 671 NS_IMETHODIMP
 672 nsFrameUtil::CompareRegressionData(FILE* aFile1, FILE* aFile2,PRInt32 aRegressionOutput)
 673 {
 674   Node* tree1 = Node::ReadTree(aFile1);
 675   Node* tree2 = Node::ReadTree(aFile2);
 676
 677   nsresult rv = NS_OK;
 678   if (!CompareTrees(tree1, tree2)) {
 679     // only output this if aRegressionOutput is 0
 680     if( 0 == aRegressionOutput ){
 681       printf("Regression data 1:\n");
 682       DumpTree(tree1, stdout, 0);
 683       printf("Regression data 2:\n");
 684       DumpTree(tree2, stdout, 0);
 685     }
 686     rv = NS_ERROR_FAILURE;
 687   }
 688
 689   Node::Destroy(tree1);
 690   Node::Destroy(tree2);
 691
 692   return rv;
 693 }
 694
 695 NS_IMETHODIMP
 696 nsFrameUtil::DumpRegressionData(FILE* aInputFile, FILE* aOutputFile)
 697 {
 698   Node* tree1 = Node::ReadTree(aInputFile);
 699   if (nsnull != tree1) {
 700     DumpTree(tree1, aOutputFile, 0);
 701     Node::Destroy(tree1);
 702     return NS_OK;
 703   }
 704   return NS_ERROR_FAILURE;
 705 }
 706 #endif