src/common/wxexpr.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wxexpr.cpp
   3 // Purpose:     wxExpr
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "wxexpr.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx/wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #include <stdarg.h>
  24 #include <ctype.h>
  25 #include <string.h>
  26
  27 #include "wx/utils.h"
  28 #include "wx/expr.h"
  29 #include "wx/wxexpr.h"
  30
  31 extern "C" void add_expr(char *);
  32 extern "C" void LexFromFile(FILE *fd);
  33 extern "C" void LexFromString(char *buf);
  34
  35
  36 wxExprDatabase *thewxExprDatabase = NULL;
  37 wxExprErrorHandler currentwxExprErrorHandler;
  38
  39 wxExpr::wxExpr(const wxString& functor)
  40 {
  41   type = wxExprList;
  42   next = NULL;
  43   last = NULL;
  44   value.first = NULL;
  45
  46   wxExpr *pfunctor = new wxExpr(wxExprWord, functor);
  47   Append(pfunctor);
  48   client_data = NULL;
  49 }
  50
  51 wxExpr::wxExpr(wxExprType the_type, const wxString& word_or_string)
  52 {
  53   type = the_type;
  54
  55   switch (the_type)
  56   {
  57    case wxExprWord:
  58     value.word = copystring((const wxChar *)word_or_string);
  59     break;
  60    case wxExprString:
  61     value.string = copystring((const wxChar *)word_or_string);
  62     break;
  63    case wxExprList:
  64     last = NULL;
  65     value.first = NULL;
  66     break;
  67    case wxExprReal:
  68    case wxExprInteger:
  69    case wxExprNull:
  70     break;
  71   }
  72   client_data = NULL;
  73   next = NULL;
  74 }
  75
  76 wxExpr::wxExpr(wxExprType the_type, wxChar *word_or_string, bool allocate)
  77 {
  78   type = the_type;
  79
  80   switch (the_type)
  81   {
  82    case wxExprWord:
  83     value.word = allocate ? copystring(word_or_string) : word_or_string;
  84     break;
  85    case wxExprString:
  86     value.string = allocate ? copystring(word_or_string) : word_or_string;
  87     break;
  88    case wxExprList:
  89     last = NULL;
  90     value.first = NULL;
  91     break;
  92    case wxExprReal:
  93    case wxExprInteger:
  94    case wxExprNull:
  95     break;
  96   }
  97   client_data = NULL;
  98   next = NULL;
  99 }
 100
 101 wxExpr::wxExpr(long the_integer)
 102 {
 103   type = wxExprInteger;
 104   value.integer = the_integer;
 105   client_data = NULL;
 106   next = NULL;
 107 }
 108
 109 wxExpr::wxExpr(double the_real)
 110 {
 111   type = wxExprReal;
 112   value.real = the_real;
 113   client_data = NULL;
 114   next = NULL;
 115 }
 116
 117 wxExpr::wxExpr(wxList *the_list)
 118 {
 119   type = wxExprList;
 120   client_data = NULL;
 121   last = NULL;
 122   value.first = NULL;
 123
 124   wxExpr *listExpr = new wxExpr(wxExprList);
 125
 126   wxNode *node = the_list->First();
 127   while (node)
 128   {
 129     wxExpr *expr = (wxExpr *)node->Data();
 130     listExpr->Append(expr);
 131     node = node->Next();
 132   }
 133   Append(listExpr);
 134
 135   delete the_list;
 136 }
 137
 138 wxExpr::~wxExpr(void)
 139 {
 140   switch (type)
 141   {
 142     case wxExprInteger:
 143     case wxExprReal:
 144     {
 145      break;
 146     }
 147    case wxExprString:
 148    {
 149      delete[] value.string;
 150      break;
 151    }
 152    case wxExprWord:
 153    {
 154      delete[] value.word;
 155      break;
 156    }
 157    case wxExprList:
 158    {
 159      wxExpr *expr = value.first;
 160      while (expr)
 161      {
 162        wxExpr *expr1 = expr->next;
 163
 164        delete expr;
 165        expr = expr1;
 166      }
 167      break;
 168    }
 169    case wxExprNull: break;
 170   }
 171 }
 172
 173 void wxExpr::Append(wxExpr *expr)
 174 {
 175   if (!value.first)
 176     value.first = expr;
 177
 178   if (last)
 179     last->next = expr;
 180   last = expr;
 181 }
 182
 183 void wxExpr::Insert(wxExpr *expr)
 184 {
 185   expr->next = value.first;
 186   value.first = expr;
 187
 188   if (!last)
 189     last = expr;
 190 }
 191
 192 wxExpr *wxExpr::Copy(void) const
 193 {
 194   // This seems to get round an optimizer bug when
 195   // using Watcom C++ 10a in WIN32 compilation mode.
 196   // If these lines not present, the type seems to be
 197   // interpreted wrongly as an integer.
 198   // I don't want to turn optimization off since it's needed
 199   // for reading in files quickly.
 200 #if defined(__WATCOMC__)
 201   char buf[2];
 202   sprintf(buf, "");
 203 #endif
 204
 205   switch (type)
 206   {
 207     case wxExprInteger:
 208       return new wxExpr(value.integer);
 209     case wxExprReal:
 210       return new wxExpr(value.real);
 211     case wxExprString:
 212       return new wxExpr(wxExprString, wxString(value.string));
 213     case wxExprWord:
 214       return new wxExpr(wxExprWord, wxString(value.word));
 215     case wxExprList:
 216     {
 217       wxExpr *expr = value.first;
 218       wxExpr *new_list = new wxExpr(wxExprList);
 219       while (expr)
 220       {
 221         wxExpr *expr2 = expr->Copy();
 222         new_list->Append(expr2);
 223         expr = expr->next;
 224       }
 225       return new_list;
 226     }
 227    case wxExprNull:
 228     break;
 229   }
 230   return NULL;
 231 }
 232
 233
 234 // Get the wxExpr (containing (= wxExpr Value) form) for the given word
 235 //  or string, assuming that we have Attribute=Value, ...
 236 wxExpr *wxExpr::GetAttributeValueNode(const wxString& word) const // Use only for a clause or list
 237 {
 238   if (type != wxExprList)
 239     return NULL;
 240
 241   wxExpr *expr = value.first;
 242   while (expr)
 243   {
 244     if (expr->type == wxExprList)
 245     {
 246       wxExpr *firstNode = expr->value.first;
 247       if ((firstNode->type == wxExprWord) && (firstNode->value.word[0] == '='))
 248       {
 249         wxExpr *secondNode = firstNode->next;
 250         if ((secondNode->type == wxExprWord) &&
 251             (wxStrcmp((const wxChar *)word, secondNode->value.word) == 0))
 252         {
 253           return expr;
 254         }
 255       }
 256     }
 257     expr = expr->next;
 258   }
 259   return NULL;
 260 }
 261
 262 // Get the value (in wxExpr form) for the given word or string, assuming
 263 // that we have Attribute=Value, ...
 264 wxExpr *wxExpr::AttributeValue(const wxString& word) const // Use only for a clause or list
 265 {
 266   if (type != wxExprList)
 267     return NULL;
 268
 269   wxExpr *attExpr = GetAttributeValueNode(word);
 270   if (attExpr && attExpr->value.first && attExpr->value.first->next)
 271     return attExpr->value.first->next->next;
 272   else return NULL;
 273 }
 274
 275 wxString wxExpr::Functor(void) const // Use only for a clause
 276 {
 277   if ((type != wxExprList) || !value.first)
 278     return wxString(_T(""));
 279
 280   if (value.first->type == wxExprWord)
 281     return wxString(value.first->value.word);
 282   else
 283     return wxString(_T(""));
 284 }
 285
 286 bool wxExpr::IsFunctor(const wxString& f) const  // Use only for a clause
 287 {
 288   if ((type != wxExprList) || !value.first)
 289     return FALSE;
 290
 291   return (value.first->type == wxExprWord &&
 292           (wxStrcmp((const wxChar *)f, value.first->value.word) == 0));
 293 }
 294
 295 // Return nth argument of a clause (starting from 1)
 296 wxExpr *wxExpr::Arg(wxExprType theType, int arg) const
 297 {
 298   wxExpr *expr = value.first;
 299   int i;
 300   for (i = 1; i < arg; i++)
 301     if (expr)
 302       expr = expr->next;
 303
 304   if (expr && (expr->type == theType))
 305     return expr;
 306   else
 307     return NULL;
 308 }
 309
 310 // Return nth argument of a list expression (starting from zero)
 311 wxExpr *wxExpr::Nth(int arg) const
 312 {
 313   if (type != wxExprList)
 314     return NULL;
 315
 316   wxExpr *expr = value.first;
 317   int i;
 318   for (i = 0; i < arg; i++)
 319     if (expr)
 320       expr = expr->next;
 321     else return NULL;
 322
 323   if (expr)
 324     return expr;
 325   else
 326     return NULL;
 327 }
 328
 329   // Returns the number of elements in a list expression
 330 int wxExpr::Number(void) const
 331 {
 332   if (type != wxExprList)
 333     return 0;
 334
 335   int i = 0;
 336   wxExpr *expr = value.first;
 337   while (expr)
 338   {
 339     expr = expr->next;
 340     i ++;
 341   }
 342   return i;
 343 }
 344
 345 void wxExpr::DeleteAttributeValue(const wxString& attribute)
 346 {
 347   if (type != wxExprList)
 348     return;
 349
 350   wxExpr *expr = value.first;
 351   wxExpr *lastExpr = this;
 352   while (expr)
 353   {
 354     if (expr->type == wxExprList)
 355     {
 356       wxExpr *firstNode = expr->value.first;
 357       if ((firstNode->type == wxExprWord) && (firstNode->value.word[0] == '='))
 358       {
 359         wxExpr *secondNode = firstNode->next;
 360         if ((secondNode->type == wxExprWord) &&
 361             (wxStrcmp((const wxChar *)attribute, secondNode->value.word) == 0))
 362         {
 363           wxExpr *nextExpr = expr->next;
 364           delete expr;
 365
 366           lastExpr->next = nextExpr;
 367
 368           if (last == expr)
 369             last = lastExpr;
 370
 371           return;
 372         }
 373       }
 374     }
 375     lastExpr = expr;
 376     expr = expr->next;
 377   }
 378   return;
 379 }
 380
 381 void wxExpr::AddAttributeValue(const wxString& attribute, wxExpr *val)
 382 {
 383   if (type != wxExprList)
 384   {
 385 //    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
 386     return;
 387   }
 388   // Warning - existing code may assume that any existing value
 389   // is deleted first. For efficiency, we leave this to the application.
 390 //  DeleteAttributeValue(attribute);
 391
 392   wxExpr *patt = new wxExpr(wxExprWord, attribute);
 393   wxExpr *pequals = new wxExpr(wxExprWord, _T("="));
 394
 395   wxExpr *listExpr = new wxExpr(wxExprList);
 396
 397   listExpr->Append(pequals);
 398   listExpr->Append(patt);
 399   listExpr->Append(val);
 400
 401   Append(listExpr);
 402 }
 403
 404 void wxExpr::AddAttributeValue(const wxString& attribute, long val)
 405 {
 406   if (type != wxExprList)
 407   {
 408 //    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
 409     return;
 410   }
 411   // Warning - existing code may assume that any existing value
 412   // is deleted first. For efficiency, we leave this to the application.
 413 //  DeleteAttributeValue(attribute);
 414
 415   wxExpr *patt = new wxExpr(wxExprWord, attribute);
 416   wxExpr *pval = new wxExpr(val);
 417   wxExpr *pequals = new wxExpr(wxExprWord, _T("="));
 418
 419   wxExpr *listExpr = new wxExpr(wxExprList);
 420
 421   listExpr->Append(pequals);
 422   listExpr->Append(patt);
 423   listExpr->Append(pval);
 424
 425   Append(listExpr);
 426 }
 427
 428 void wxExpr::AddAttributeValue(const wxString& attribute, double val)
 429 {
 430   if (type != wxExprList)
 431   {
 432 //    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
 433     return;
 434   }
 435
 436 //  DeleteAttributeValue(attribute);
 437   wxExpr *patt = new wxExpr(wxExprWord, attribute);
 438   wxExpr *pval = new wxExpr(val);
 439   wxExpr *pequals = new wxExpr(wxExprWord, _T("="));
 440
 441   wxExpr *listExpr = new wxExpr(wxExprList);
 442
 443   listExpr->Append(pequals);
 444   listExpr->Append(patt);
 445   listExpr->Append(pval);
 446
 447   Append(listExpr);
 448 }
 449
 450 void wxExpr::AddAttributeValueString(const wxString& attribute, const wxString& val)
 451 {
 452   if (type != wxExprList)
 453   {
 454 //    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
 455     return;
 456   }
 457
 458 //  DeleteAttributeValue(attribute);
 459
 460   wxExpr *patt = new wxExpr(wxExprWord, attribute);
 461   wxExpr *pval = new wxExpr(wxExprString, val);
 462   wxExpr *pequals = new wxExpr(wxExprWord, _T("="));
 463
 464   wxExpr *listExpr = new wxExpr(wxExprList);
 465
 466   listExpr->Append(pequals);
 467   listExpr->Append(patt);
 468   listExpr->Append(pval);
 469
 470   Append(listExpr);
 471 }
 472
 473 void wxExpr::AddAttributeValueWord(const wxString& attribute, const wxString& val)
 474 {
 475   if (type != wxExprList)
 476   {
 477 //    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
 478     return;
 479   }
 480
 481 //  DeleteAttributeValue(attribute);
 482
 483   wxExpr *patt = new wxExpr(wxExprWord, attribute);
 484   wxExpr *pval = new wxExpr(wxExprWord, val);
 485   wxExpr *pequals = new wxExpr(wxExprWord, _T("="));
 486
 487   wxExpr *listExpr = new wxExpr(wxExprList);
 488
 489   listExpr->Append(pequals);
 490   listExpr->Append(patt);
 491   listExpr->Append(pval);
 492
 493   Append(listExpr);
 494 }
 495
 496 void wxExpr::AddAttributeValue(const wxString& attribute, wxList *val)
 497 {
 498   if (type != wxExprList)
 499   {
 500 //    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
 501     return;
 502   }
 503   if (!val)
 504     return;
 505
 506 //  DeleteAttributeValue(attribute);
 507
 508   wxExpr *patt = new wxExpr(wxExprWord, attribute);
 509   wxExpr *pval = new wxExpr(val);
 510   wxExpr *pequals = new wxExpr(wxExprWord, _T("="));
 511
 512   wxExpr *listExpr = new wxExpr(wxExprList);
 513
 514   listExpr->Append(pequals);
 515   listExpr->Append(patt);
 516   listExpr->Append(pval);
 517
 518   Append(listExpr);
 519 }
 520
 521 void wxExpr::AddAttributeValueStringList(const wxString& attribute, wxList *string_list)
 522 {
 523   if (type != wxExprList)
 524   {
 525 //    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
 526     return;
 527   }
 528   if (!string_list)
 529     return;
 530
 531 //  DeleteAttributeValue(attribute);
 532
 533   // First make a list of wxExpr strings
 534   wxExpr *listExpr = new wxExpr(wxExprList);
 535   wxNode *node = string_list->First();
 536   while (node)
 537   {
 538     char *string = (char *)node->Data();
 539     wxExpr *expr = new wxExpr(wxExprString, wxString(string));
 540     listExpr->Append(expr);
 541     node = node->Next();
 542   }
 543
 544   // Now make an (=, Att, Value) triple
 545   wxExpr *patt = new wxExpr(wxExprWord, attribute);
 546   wxExpr *pequals = new wxExpr(wxExprWord, _T("="));
 547
 548   wxExpr *listExpr2 = new wxExpr(wxExprList);
 549
 550   listExpr2->Append(pequals);
 551   listExpr2->Append(patt);
 552   listExpr2->Append(listExpr);
 553
 554   Append(listExpr2);
 555 }
 556
 557 bool wxExpr::GetAttributeValue(const wxString& att, int& var) const
 558 {
 559   wxExpr *expr = AttributeValue(att);
 560
 561   if (expr && (expr->Type() == wxExprInteger || expr->Type() == wxExprReal))
 562   {
 563     var = (int)(expr->IntegerValue());
 564     return TRUE;
 565   }
 566   else
 567     return FALSE;
 568 }
 569
 570 bool wxExpr::GetAttributeValue(const wxString& att, long& var) const
 571 {
 572   wxExpr *expr = AttributeValue(att);
 573
 574   if (expr && (expr->Type() == wxExprInteger || expr->Type() == wxExprReal))
 575   {
 576     var = expr->IntegerValue();
 577     return TRUE;
 578   }
 579   else
 580     return FALSE;
 581 }
 582
 583 bool wxExpr::GetAttributeValue(const wxString& att, float& var) const
 584 {
 585   wxExpr *expr = AttributeValue(att);
 586   if (expr && (expr->Type() == wxExprInteger || expr->Type() == wxExprReal))
 587   {
 588     var = (float) expr->RealValue();
 589     return TRUE;
 590   }
 591   else
 592     return FALSE;
 593 }
 594
 595 bool wxExpr::GetAttributeValue(const wxString& att, double& var) const
 596 {
 597   wxExpr *expr = AttributeValue(att);
 598   if (expr && (expr->Type() == wxExprInteger || expr->Type() == wxExprReal))
 599   {
 600     var = expr->RealValue();
 601     return TRUE;
 602   }
 603   else
 604     return FALSE;
 605 }
 606
 607 bool wxExpr::GetAttributeValue(const wxString& att, wxString& var)  const // Word OR string -> string
 608 {
 609   wxExpr *expr = AttributeValue(att);
 610   if (expr && expr->Type() == wxExprWord)
 611   {
 612     var = expr->WordValue();
 613     return TRUE;
 614   }
 615   else if (expr && expr->Type() == wxExprString)
 616   {
 617     var = expr->StringValue();
 618     return TRUE;
 619   }
 620   else
 621     return FALSE;
 622 }
 623
 624 bool wxExpr::GetAttributeValue(const wxString& att, wxExpr **var) const
 625 {
 626   wxExpr *expr = AttributeValue(att);
 627   if (expr)
 628   {
 629     *var = expr;
 630     return TRUE;
 631   }
 632   else
 633     return FALSE;
 634 }
 635
 636 bool wxExpr::GetAttributeValueStringList(const wxString& att, wxList *var) const
 637 {
 638   wxExpr *expr = AttributeValue(att);
 639   if (expr && expr->Type() == wxExprList)
 640   {
 641     wxExpr *string_expr = expr->value.first;
 642     while (string_expr)
 643     {
 644       if (string_expr->Type() == wxExprString)
 645         var->Append((wxObject *)copystring(string_expr->StringValue()));
 646
 647       string_expr = string_expr->next;
 648     }
 649         return TRUE;
 650   }
 651   else
 652     return FALSE;
 653 }
 654
 655 // Compatibility
 656 void wxExpr::AssignAttributeValue(wxChar *att, wxChar **var) const
 657 {
 658   wxString str;
 659   if (GetAttributeValue(att, str))
 660   {
 661     if (*var)
 662       delete[] *var;
 663     *var = copystring((const wxChar *) str);
 664   }
 665 }
 666
 667 void wxExpr::WriteClause(FILE* stream)  // Write this expression as a top-level clause
 668 {
 669   if (type != wxExprList)
 670     return;
 671
 672   wxExpr *node = value.first;
 673   if (node)
 674   {
 675     node->WriteExpr(stream);
 676     fprintf( stream, "(" );
 677     node = node->next;
 678     bool first = TRUE;
 679     while (node)
 680     {
 681       if (!first)
 682         fprintf( stream, "  " );
 683       node->WriteExpr(stream);
 684       node = node->next;
 685       if (node)
 686         fprintf( stream, ",\n" );
 687       first = FALSE;
 688     }
 689     fprintf( stream, ").\n\n" );
 690   }
 691 }
 692
 693 void wxExpr::WriteExpr(FILE* stream)    // Write as any other subexpression
 694 {
 695   // This seems to get round an optimizer bug when
 696   // using Watcom C++ 10a in WIN32 compilation mode.
 697   // If these lines not present, the type seems to be
 698   // interpreted wrongly as an integer.
 699   // I don't want to turn optimization off since it's needed
 700   // for reading in files quickly.
 701 #if defined(__WATCOMC__)
 702   char buf[2];
 703   sprintf(buf, "");
 704 #endif
 705
 706   switch (type)
 707   {
 708     case wxExprInteger:
 709     {
 710       fprintf( stream, "%ld", value.integer );
 711       break;
 712     }
 713     case wxExprReal:
 714     {
 715       double f = value.real;
 716       fprintf( stream, "%.6g", f);
 717       break;
 718     }
 719     case wxExprString:
 720     {
 721       fprintf( stream, "\"" );
 722       int i;
 723       const wxWX2MBbuf val = wxConvLibc.cWX2MB(value.string);
 724       int len = strlen(val);
 725       for (i = 0; i < len; i++)
 726       {
 727         char ch = val[i];
 728         if (ch == '"' || ch == '\\')
 729           fprintf( stream, "\\" );
 730         char tmp[2];
 731         tmp[0] = ch;
 732         tmp[1] = 0;
 733         fprintf( stream, tmp );
 734       }
 735       fprintf( stream, "\"" );
 736       break;
 737     }
 738     case wxExprWord:
 739     {
 740       bool quote_it = FALSE;
 741       const wxWX2MBbuf val = wxConvLibc.cWX2MB(value.word);
 742       int len = strlen(val);
 743       if ((len == 0) || (len > 0 && (val[0] > 64 && val[0] < 91)))
 744         quote_it = TRUE;
 745       else
 746       {
 747         int i;
 748         for (i = 0; i < len; i++)
 749           if ((!isalpha(val[i])) && (!isdigit(val[i])) &&
 750               (val[i] != '_'))
 751             { quote_it = TRUE; i = len; }
 752       }
 753
 754       if (quote_it)
 755         fprintf( stream ,"'" );
 756
 757       fprintf( stream, (const char*) val );
 758
 759       if (quote_it)
 760         fprintf( stream, "'" );
 761
 762       break;
 763     }
 764     case wxExprList:
 765     {
 766       if (!value.first)
 767         fprintf( stream, "[]" );
 768       else
 769       {
 770         wxExpr *expr = value.first;
 771
 772         if ((expr->Type() == wxExprWord) && (wxStrcmp(expr->WordValue(), _T("=")) == 0))
 773         {
 774           wxExpr *arg1 = expr->next;
 775           wxExpr *arg2 = arg1->next;
 776           arg1->WriteExpr(stream);
 777           fprintf( stream, " = " );
 778           arg2->WriteExpr(stream);
 779         }
 780         else
 781         {
 782           fprintf( stream, "[" );
 783           while (expr)
 784           {
 785             expr->WriteExpr(stream);
 786             expr = expr->next;
 787             if (expr)
 788               fprintf( stream, ", " );
 789           }
 790           fprintf( stream, "]" );
 791         }
 792       }
 793       break;
 794     }
 795    case wxExprNull: break;
 796   }
 797 }
 798
 799 void wxExpr::WriteLispExpr(FILE* stream)
 800 {
 801   switch (type)
 802   {
 803     case wxExprInteger:
 804     {
 805       fprintf( stream, "%ld", value.integer );
 806       break;
 807     }
 808     case wxExprReal:
 809     {
 810       fprintf( stream, "%.6g", value.real );
 811       break;
 812     }
 813     case wxExprString:
 814     {
 815       fprintf( stream, "\"" );
 816       const wxWX2MBbuf val = wxConvLibc.cWX2MB(value.string);
 817       fprintf( stream, (const char*) val );
 818       fprintf( stream, "\"" );
 819       break;
 820     }
 821     case wxExprWord:
 822     {
 823       const wxWX2MBbuf val = wxConvLibc.cWX2MB(value.word);
 824       fprintf( stream, (const char*) val );
 825       break;
 826     }
 827     case wxExprList:
 828     {
 829       wxExpr *expr = value.first;
 830
 831       fprintf( stream, "(" );
 832       while (expr)
 833       {
 834         expr->WriteLispExpr(stream);
 835         expr = expr->next;
 836         if (expr)
 837           fprintf( stream, " " );
 838       }
 839
 840       fprintf( stream, ")" );
 841       break;
 842     }
 843    case wxExprNull: break;
 844   }
 845 }
 846
 847 /*
 848  * wxExpr 'database' (list of expressions)
 849  */
 850
 851 #if !USE_SHARED_LIBRARIES
 852 IMPLEMENT_DYNAMIC_CLASS(wxExprDatabase, wxList)
 853 #endif
 854
 855 wxExprDatabase::wxExprDatabase(wxExprErrorHandler handler)
 856 {
 857   position = NULL;
 858   hash_table = NULL;
 859   currentwxExprErrorHandler = handler;
 860   noErrors = 0;
 861 }
 862
 863 wxExprDatabase::wxExprDatabase(wxExprType type, const wxString& attribute, int size,
 864                                wxExprErrorHandler handler)
 865 {
 866   position = NULL;
 867   attribute_to_hash = attribute;
 868   if (type == wxExprString)
 869     hash_table = new wxHashTable(wxKEY_STRING, size);
 870   else if (type == wxExprInteger)
 871     hash_table = new wxHashTable(wxKEY_INTEGER, size);
 872   else hash_table = NULL;
 873
 874   currentwxExprErrorHandler = handler;
 875   noErrors = 0;
 876 }
 877
 878 wxExprDatabase::~wxExprDatabase(void)
 879 {
 880   ClearDatabase();
 881   if (hash_table)
 882     delete hash_table;
 883 }
 884
 885 void wxExprDatabase::BeginFind(void)          // Initialise a search
 886 {
 887   position = First();
 888 }
 889
 890 wxExpr *wxExprDatabase::FindClause(long id)  // Find a term based on an integer id attribute
 891                                  // e.g. node(id=23, type=rectangle, ....).
 892 {
 893   wxExpr *found = NULL;
 894   while (position && !found)
 895   {
 896     wxExpr *term = (wxExpr *)position->Data();
 897
 898     if (term->Type() == wxExprList)
 899     {
 900       wxExpr *value = term->AttributeValue("id");
 901       if (value->Type() == wxExprInteger && value->IntegerValue() == id)
 902         found = term;
 903     }
 904     position = position->Next();
 905   }
 906   return found;
 907 }
 908
 909 // Find on basis of attribute/value pairs, e.g. type=rectangle
 910 wxExpr *wxExprDatabase::FindClause(const wxString& word, const wxString& val)
 911 {
 912   wxExpr *found = NULL;
 913   while (position && !found)
 914   {
 915     wxExpr *term = (wxExpr *)position->Data();
 916
 917     if (term->Type() == wxExprList)
 918     {
 919       wxExpr *value = term->AttributeValue(word);
 920       if ((value->Type() == wxExprWord && value->WordValue() == val) ||
 921           (value->Type() == wxExprString && value->StringValue() == val))
 922         found = term;
 923     }
 924     position = position->Next();
 925   }
 926   return found;
 927 }
 928
 929 wxExpr *wxExprDatabase::FindClause(const wxString& word, long val)
 930 {
 931   wxExpr *found = NULL;
 932   while (position && !found)
 933   {
 934     wxExpr *term = (wxExpr *)position->Data();
 935
 936     if (term->Type() == wxExprList)
 937     {
 938       wxExpr *value = term->AttributeValue(word);
 939       if ((value->Type() == wxExprInteger) && (value->IntegerValue() == val))
 940         found = term;
 941     }
 942     position = position->Next();
 943   }
 944   return found;
 945 }
 946
 947 wxExpr *wxExprDatabase::FindClause(const wxString& word, double val)
 948 {
 949   wxExpr *found = NULL;
 950   while (position && !found)
 951   {
 952     wxExpr *term = (wxExpr *)position->Data();
 953
 954     if (term->Type() == wxExprList)
 955     {
 956       wxExpr *value = term->AttributeValue(word);
 957       if ((value->Type() == wxExprReal) && (value->RealValue() == val))
 958         found = term;
 959     }
 960     position = position->Next();
 961   }
 962   return found;
 963 }
 964
 965 wxExpr *wxExprDatabase::FindClauseByFunctor(const wxString& functor)
 966 {
 967   wxExpr *found = NULL;
 968   while (position && !found)
 969   {
 970     wxExpr *term = (wxExpr *)position->Data();
 971
 972     if (term->Type() == wxExprList)
 973     {
 974       if (term->Functor() == functor)
 975         found = term;
 976     }
 977     position = position->Next();
 978   }
 979   return found;
 980 }
 981
 982 // If hashing is on, must store in hash table too
 983 void wxExprDatabase::Append(wxExpr *clause)
 984 {
 985   wxList::Append((wxObject *)clause);
 986   if (hash_table)
 987   {
 988     wxString functor(clause->Functor());
 989     wxExpr *expr = clause->AttributeValue(attribute_to_hash);
 990     if (expr)
 991     {
 992       long functor_key = hash_table->MakeKey(WXSTRINGCAST functor);
 993       long value_key = 0;
 994       if (expr && expr->Type() == wxExprString)
 995       {
 996         value_key = hash_table->MakeKey(WXSTRINGCAST expr->StringValue());
 997         hash_table->Put(functor_key + value_key, WXSTRINGCAST expr->StringValue(), (wxObject *)clause);
 998       }
 999       else if (expr && expr->Type() == wxExprInteger)
1000       {
1001         value_key = expr->IntegerValue();
1002         hash_table->Put(functor_key + value_key, expr->IntegerValue(), (wxObject *)clause);
1003       }
1004
1005     }
1006   }
1007 }
1008
1009 wxExpr *wxExprDatabase::HashFind(const wxString& functor, long value) const
1010 {
1011   long key = hash_table->MakeKey(WXSTRINGCAST functor) + value;
1012
1013   // The key alone isn't guaranteed to be unique:
1014   // must supply value too. Let's assume the value of the
1015   // id is going to be reasonably unique.
1016   return (wxExpr *)hash_table->Get(key, value);
1017 }
1018
1019 wxExpr *wxExprDatabase::HashFind(const wxString& functor, const wxString& value) const
1020 {
1021   long key = hash_table->MakeKey(WXSTRINGCAST functor) + hash_table->MakeKey(WXSTRINGCAST value);
1022   return (wxExpr *)hash_table->Get(key, WXSTRINGCAST value);
1023 }
1024
1025 void wxExprDatabase::ClearDatabase(void)
1026 {
1027   noErrors = 0;
1028   wxNode *node = First();
1029   while (node)
1030   {
1031     wxExpr *expr = (wxExpr *)node->Data();
1032     delete expr;
1033     delete node;
1034     node = First();
1035   }
1036
1037   if (hash_table)
1038     hash_table->Clear();
1039 }
1040
1041 bool wxExprDatabase::Read(const wxString& filename)
1042 {
1043   noErrors = 0;
1044
1045   FILE *f = fopen(filename.fn_str(), "r");
1046   if (f)
1047   {
1048     thewxExprDatabase = this;
1049
1050     LexFromFile(f);
1051     yyparse();
1052     fclose(f);
1053
1054     wxExprCleanUp();
1055     return (noErrors == 0);
1056   }
1057   else
1058   {
1059     return FALSE;
1060   }
1061 }
1062
1063 bool wxExprDatabase::ReadFromString(const wxString& buffer)
1064 {
1065   noErrors = 0;
1066   thewxExprDatabase = this;
1067
1068   const wxWX2MBbuf buf = buffer.mb_str();
1069   LexFromString(MBSTRINGCAST buf);
1070   yyparse();
1071   wxExprCleanUp();
1072   return (noErrors == 0);
1073 }
1074
1075 bool wxExprDatabase::Write(const wxString& fileName)
1076 {
1077   FILE *stream = fopen( fileName.fn_str(), "w+" );
1078
1079   if (!stream)
1080     return FALSE;
1081
1082   return Write(stream);
1083 }
1084
1085 bool wxExprDatabase::Write(FILE *stream)
1086 {
1087   noErrors = 0;
1088   wxNode *node = First();
1089   while (node)
1090   {
1091     wxExpr *expr = (wxExpr *)node->Data();
1092     expr->WriteClause(stream);
1093     node = node->Next();
1094   }
1095   return (noErrors == 0);
1096 }
1097
1098 void wxExprDatabase::WriteLisp(FILE* stream)
1099 {
1100   noErrors = 0;
1101   wxNode *node = First();
1102   while (node)
1103   {
1104     wxExpr *expr = (wxExpr *)node->Data();
1105     expr->WriteLispExpr(stream);
1106     fprintf( stream, "\n\n" );
1107     node = node->Next();
1108   }
1109 }
1110
1111 void add_expr(wxExpr * expr)
1112 {
1113   thewxExprDatabase->Append(expr);
1114 }
1115
1116 // Checks functor
1117 bool wxExprIsFunctor(wxExpr *expr, const wxString& functor)
1118 {
1119   if (expr && (expr->Type() == wxExprList))
1120   {
1121     wxExpr *first_expr = expr->value.first;
1122
1123     if (first_expr && (first_expr->Type() == wxExprWord) &&
1124        (first_expr->WordValue() == functor))
1125       return TRUE;
1126     else
1127       return FALSE;
1128   }
1129   else
1130     return FALSE;
1131 }
1132
1133 /*
1134  * Called from parser
1135  *
1136  */
1137
1138 char *wxmake_integer(char *str)
1139 {
1140   wxExpr *x = new wxExpr(atol(str));
1141
1142   return (char *)x;
1143 }
1144
1145 char *wxmake_real(char *str1, char *str2)
1146 {
1147   char buf[50];
1148
1149   sprintf(buf, "%s.%s", str1, str2);
1150   double f = (double)atof(buf);
1151   wxExpr *x = new wxExpr(f);
1152
1153   return (char *)x;
1154 }
1155
1156 // extern "C" double exp10(double);
1157
1158 char *wxmake_exp(char *str1, char *str2)
1159 {
1160   double mantissa = (double)atoi(str1);
1161   double exponent = (double)atoi(str2);
1162
1163   double d = mantissa * pow(10.0, exponent);
1164
1165   wxExpr *x = new wxExpr(d);
1166
1167   return (char *)x;
1168 }
1169
1170 char *wxmake_exp2(char *str1, char *str2, char *str3)
1171 {
1172   char buf[50];
1173
1174   sprintf(buf, "%s.%s", str1, str2);
1175   double mantissa = (double)atof(buf);
1176   double exponent = (double)atoi(str3);
1177
1178   double d = mantissa * pow(10.0, exponent);
1179
1180   wxExpr *x = new wxExpr(d);
1181
1182   return (char *)x;
1183 }
1184
1185 char *wxmake_word(char *str)
1186 {
1187   wxExpr *x = new wxExpr(wxExprWord, str);
1188   return (char *)x;
1189 }
1190
1191 char *wxmake_string(char *str)
1192 {
1193   wxChar *s, *t;
1194   int len, i;
1195   const wxMB2WXbuf sbuf = wxConvLibc.cMB2WX(str);
1196
1197 //  str++;                      /* skip leading quote */
1198   len = wxStrlen(sbuf) - 1;     /* ignore trailing quote */
1199
1200   s = new wxChar[len + 1];
1201
1202   t = s;
1203   for(i=1; i<len; i++) // 1 since we want to skip leading quote
1204   {
1205     if (sbuf[i] == _T('\\') && sbuf[i+1] == _T('"'))
1206     {
1207       *t++ = _T('"');
1208       i ++;
1209     }
1210     else if (sbuf[i] == _T('\\') && sbuf[i+1] == _T('\\'))
1211     {
1212       *t++ = _T('\\');
1213       i ++;
1214     }
1215     else
1216       *t++ = sbuf[i];
1217   }
1218
1219   *t = _T('\0');
1220
1221   wxExpr *x = new wxExpr(wxExprString, s, FALSE);
1222   return (char *)x;
1223 }
1224
1225 char *proio_cons(char * ccar, char * ccdr)
1226 {
1227   wxExpr *car = (wxExpr *)ccar;
1228   wxExpr *cdr = (wxExpr *)ccdr;
1229
1230   if (cdr == NULL)
1231   {
1232     cdr = new wxExpr(wxExprList);
1233   }
1234   if (car)
1235     cdr->Insert(car);
1236   return (char *)cdr;
1237 }
1238
1239 void process_command(char * cexpr)
1240 {
1241   wxExpr *expr = (wxExpr *)cexpr;
1242   add_expr(expr);
1243 }
1244
1245 void syntax_error(char *WXUNUSED(s))
1246 {
1247   if (currentwxExprErrorHandler)
1248     (void)(*(currentwxExprErrorHandler))(WXEXPR_ERROR_SYNTAX, "syntax error");
1249   if (thewxExprDatabase) thewxExprDatabase->noErrors += 1;
1250 }
1251
1252 #if 0
1253 #ifdef _WINDLL
1254 // char *__cdecl strdup(const char *s)
1255 WXDLLEXPORT char *strdup(const char *s)
1256 {
1257   int len = strlen(s);
1258   char *new_s = (char *)malloc(sizeof(char)*(len+1));
1259   strcpy(new_s, s);
1260   return new_s;
1261 }
1262 #endif
1263 #endif
1264