home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / include / wx / wxexpr.h < prev    next >
C/C++ Source or Header  |  2002-11-09  |  10KB  |  278 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        wxexpr.h
  3. // Purpose:     Prolog-like file I/O, used by resource system.
  4. // Author:      Julian Smart
  5. // Modified by:
  6. // Created:     01/02/97
  7. // RCS-ID:      $Id: wxexpr.h,v 1.16.2.1 2002/11/04 23:22:44 VZ Exp $
  8. // Copyright:   (c)
  9. // Licence:     wxWindows licence
  10. /////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifndef _WX_WXEXPRH__
  13. #define _WX_WXEXPRH__
  14.  
  15. #if defined(__GNUG__) && !defined(__APPLE__)
  16. #pragma interface "wxexpr.h"
  17. #endif
  18.  
  19. #if wxUSE_PROLOGIO
  20.  
  21. #include "wx/defs.h"
  22. #include "wx/string.h"
  23.  
  24. #include "wx/list.h"
  25. #include "wx/hash.h"
  26.  
  27. #include "wx/expr.h"
  28.  
  29. #include <stdio.h>
  30.  
  31. // Compatibility
  32. #define PrologExpr wxExpr
  33. #define PrologDatabase wxExprDatabase
  34. #define proioErrorHandler wxExprErrorHandler
  35. #define PROIO_ERROR_GENERAL 1
  36. #define PROIO_ERROR_SYNTAX  2
  37. #define PrologNull wxExprNull
  38. #define PrologInteger wxExprInteger
  39. #define PrologReal wxExprReal
  40. #define PrologWord wxExprWord
  41. #define PrologString wxExprString
  42. #define PrologList wxExprList
  43. #define PrologType wxExprType
  44.  
  45. // Error types
  46. #define WXEXPR_ERROR_GENERAL 1
  47. #define WXEXPR_ERROR_SYNTAX  2
  48.  
  49. // Error handler function definition. If app returns TRUE,
  50. // carry on processing.
  51. typedef bool (*wxExprErrorHandler) (int errorType, char *msg);
  52.  
  53. WXDLLEXPORT_DATA(extern wxExprErrorHandler) currentwxExprErrorHandler;
  54.  
  55.  
  56. typedef enum {
  57.     wxExprNull,
  58.     wxExprInteger,
  59.     wxExprReal,
  60.     wxExprWord,
  61.     wxExprString,
  62.     wxExprList
  63. } wxExprType;
  64.  
  65. class WXDLLEXPORT wxExprDatabase;
  66.  
  67. class WXDLLEXPORT wxExpr
  68. {
  69.  public:
  70.   wxObject *client_data;
  71.   wxExprType type;
  72.   union {
  73.     long integer;
  74.     wxChar *word;
  75.     wxChar *string;
  76.     double real;
  77.     wxExpr *first;  // If is a list expr, points to the first node
  78.     } value;
  79.  
  80.   wxExpr *next;     // If this is a node in a list, points to the next node
  81.   wxExpr *last;     // If is a list expr, points to the last node
  82.  
  83.   wxExpr(wxExprType the_type, wxChar *word_or_string, bool allocate);
  84.   wxExpr(const wxString& functor);      // Assume this is a new clause - pass functor
  85.   wxExpr(wxExprType the_type, const wxString& word_or_string = "");
  86.   wxExpr(long the_integer);
  87.   wxExpr(double the_real);
  88.   wxExpr(wxList *the_list);
  89.   ~wxExpr(void);
  90.  
  91.   inline wxExprType Type(void) const { return type; }
  92.   inline long IntegerValue(void) const
  93.   {
  94.     if (type == wxExprInteger)
  95.       return value.integer;
  96.     else if (type == wxExprReal)
  97.       return (long)value.real;
  98.     else return 0;
  99.   }
  100.  
  101.   inline double RealValue(void) const {
  102.     if (type == wxExprReal)
  103.       return value.real;
  104.     else if (type == wxExprInteger)
  105.       return (double)value.integer;
  106.     else return (double)0.0;
  107.   }
  108.  
  109.   inline wxString WordValue(void) const {
  110.     if (type == wxExprWord)
  111.       return value.word;
  112.     else if (type == wxExprString)
  113.       return wxString(value.string);
  114.     else return wxString(wxT(""));
  115.   }
  116.  
  117.   inline wxString StringValue(void) const {
  118.     if (type == wxExprString)
  119.       return wxString(value.string);
  120.     else if (type == wxExprWord)
  121.       return wxString(value.word);
  122.     else return wxString(wxT(""));
  123.   }
  124.  
  125.   // Get nth arg of clause (starting from 1)
  126.   wxExpr *Arg(wxExprType type, int arg) const;
  127.  
  128.   // Return nth argument of a list expression (starting from zero)
  129.   wxExpr *Nth(int arg) const;
  130.  
  131.   // Returns the number of elements in a list expression
  132.   int Number(void) const;
  133.  
  134.   // Make a clone
  135.   wxExpr *Copy(void) const;
  136.  
  137.   wxExpr *GetAttributeValueNode(const wxString& word) const;  // Use only for a clause or list
  138.   wxExpr *AttributeValue(const wxString& word) const;  // Use only for a clause
  139.   wxString Functor(void) const;                     // Only for a clause
  140.   bool IsFunctor(const wxString& s) const;                     // Only for a clause
  141.   void WriteClause(FILE* stream);  // Write this expression as a top-level clause
  142.   void WriteExpr(FILE* stream);    // Write as any other subexpression
  143.  
  144.   // Append an expression to a list
  145.   void Append(wxExpr *expr);
  146.   // Insert at beginning of list
  147.   void Insert(wxExpr *expr);
  148.  
  149.   // Get first expr in list
  150.   inline wxExpr *GetFirst(void) const { return ((type == wxExprList) ? value.first : (wxExpr*)NULL); }
  151.  
  152.   // Get next expr if this is a node in a list
  153.   inline wxExpr *GetNext(void) const { return next; }
  154.  
  155.   // Get last expr in list
  156.   inline wxExpr *GetLast(void) const { return ((type == wxExprList) ? last : (wxExpr*)NULL); }
  157.  
  158.   // This should really be called SetAttributeValue since any existing
  159.   // attribute-value is deleted first.
  160.   void AddAttributeValue(const wxString& attribute, long value);
  161.   void AddAttributeValue(const wxString& attribute, double value);
  162.   void AddAttributeValueWord(const wxString& attribute, const wxString& value);
  163.   void AddAttributeValueString(const wxString& attribute, const wxString& value);
  164.   void AddAttributeValue(const wxString& attribute, wxList *value);
  165.   void AddAttributeValue(const wxString& attribute, wxExpr *value);
  166.   void AddAttributeValueStringList(const wxString& attribute, wxList *string_list);
  167.  
  168.   void DeleteAttributeValue(const wxString& attribute);
  169.  
  170.   bool GetAttributeValue(const wxString& att, int& var) const;
  171.   bool GetAttributeValue(const wxString& att, long& var) const;
  172.   bool GetAttributeValue(const wxString& att, float& var) const;
  173.   bool GetAttributeValue(const wxString& att, double& var) const;
  174.   bool GetAttributeValue(const wxString& att, wxString& var) const;  // Word OR string -> string
  175.   bool GetAttributeValue(const wxString& att, wxExpr **var) const;
  176.  
  177.   // Compatibility with old PrologIO
  178.   inline void AssignAttributeValue(wxChar *att, int *var) const { GetAttributeValue(att, *var); }
  179.   inline void AssignAttributeValue(wxChar *att, long *var) const { GetAttributeValue(att, *var); }
  180.   inline void AssignAttributeValue(wxChar *att, float *var) const { GetAttributeValue(att, *var); }
  181.   inline void AssignAttributeValue(wxChar *att, double *var) const { GetAttributeValue(att, *var); }
  182.   inline void AssignAttributeValue(wxChar *att, wxExpr **var) const { GetAttributeValue(att, var); }
  183.   void AssignAttributeValue(wxChar *att, wxChar **var) const ;  // Word OR string -> string
  184.  
  185.   // Add string items to list if the list attribute exists
  186.   bool GetAttributeValueStringList(const wxString& att, wxList *var) const;
  187.  
  188.   // Associate other data with this expression, e.g. when reading in a
  189.   // number of linked items - store C++ object pointer with the expression
  190.   // so we can index into the wxExpr database and fish out the pointer.
  191.   inline void SetClientData(wxObject *data) { client_data = data; }
  192.   inline wxObject *GetClientData(void) const { return client_data; }
  193. };
  194.  
  195. class WXDLLEXPORT wxExprDatabase: public wxList
  196. {
  197. private:
  198.     wxNode *position;              // Where we are in a search
  199.     wxHashTable *hash_table;
  200.     wxString attribute_to_hash;
  201.  
  202. public:
  203.     int noErrors;
  204.  
  205.     wxExprDatabase(wxExprErrorHandler handler = 0);
  206.  
  207.     // Use hashing on both the functor, and the attribute of
  208.     // specified type (wxExprString or wxExprInteger) and name.
  209.     // So to find node 45
  210.     // (i.e. match the clause node(id=45, ...))
  211.     // it usually requires 1 look-up: the keys for functor and attribute
  212.     // are added together.
  213.     // Obviously if the attribute was missing in a clause, it would
  214.     // fail to be found by this method, but could be retrieved by a
  215.     // linear search using BeginFind and FindClauseByFunctor,
  216.     // or just searching through the list as per usual.
  217.  
  218.     wxExprDatabase(wxExprType type, const wxString& attribute, int size = 500,
  219.             wxExprErrorHandler handler = 0);
  220.  
  221.     ~wxExprDatabase(void);
  222.  
  223.     void BeginFind(void) ;          // Initialise a search
  224.     wxExpr *FindClause(long id) ;  // Find a term based on an integer id attribute
  225.     // e.g. node(id=23, type=rectangle, ....).
  226.  
  227.     // Find on basis of attribute/value pairs, e.g. type=rectangle
  228.     // This doesn't use hashing; it's a linear search.
  229.     wxExpr *FindClause(const wxString& word, const wxString& value);
  230.     wxExpr *FindClause(const wxString& word, long value);
  231.     wxExpr *FindClause(const wxString& word, double value);
  232.     wxExpr *FindClauseByFunctor(const wxString& functor);
  233.  
  234.     wxExpr *HashFind(const wxString& functor, const wxString& value) const;
  235.     wxExpr *HashFind(const wxString& functor, long value) const;
  236.  
  237.     void Append(wxExpr *expr);  // Does cleverer things if hashing is on
  238.     void ClearDatabase(void);
  239.     inline int GetErrorCount() const { return noErrors; }
  240.     bool Read(const wxString& filename);
  241.     bool ReadFromString(const wxString& buffer);
  242.     bool Write(const wxString& fileName);
  243.     bool Write(FILE* stream);
  244.  
  245.     // Compatibility
  246.     inline bool ReadProlog(wxChar *filename) { return Read(wxString(filename)); }
  247.     inline bool ReadPrologFromString(char *buffer) { return ReadFromString(wxString(buffer)); }
  248.     inline void WriteProlog(FILE* stream) { Write(stream); }
  249.  
  250. private:
  251.     DECLARE_DYNAMIC_CLASS(wxExprDatabase)
  252. };
  253.  
  254. // Function call-style interface - some more convenience wrappers/unwrappers
  255.  
  256. // Make a call
  257. WXDLLEXPORT wxExpr* wxExprMakeCall(const wxString& functor ...);
  258.  
  259. #define wxExprMakeInteger(x) (new wxExpr((long)x))
  260. #define wxExprMakeReal(x) (new wxExpr((double)x))
  261. #define wxExprMakeString(x) (new wxExpr(wxExprString, x))
  262. #define wxExprMakeWord(x)   (new wxExpr(wxExprWord, x))
  263. #define wxExprMake(x)       (new wxExpr(x))
  264.  
  265. // Checks functor
  266. WXDLLEXPORT bool wxExprIsFunctor(wxExpr *expr, const wxString& functor);
  267.  
  268. // Temporary variable for communicating between wxexpr.cpp and YACC/LEX
  269. WXDLLEXPORT_DATA(extern wxExprDatabase*) thewxExprDatabase;
  270.  
  271. // YACC/LEX can leave memory lying around...
  272. extern "C" WXDLLEXPORT int wxExprCleanUp();
  273.  
  274. #endif // wxUSE_PROLOGIO
  275.  
  276. #endif // _WX_WXEXPRH__
  277.  
  278.