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