1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Prolog-like file I/O, used by resource system.
4 // Author: Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
15 #if defined(__GNUG__) && !defined(__APPLE__)
16 #pragma interface "wxexpr.h"
22 #include "wx/string.h"
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
46 #define WXEXPR_ERROR_GENERAL 1
47 #define WXEXPR_ERROR_SYNTAX 2
49 // Error handler function definition. If app returns TRUE,
50 // carry on processing.
51 typedef bool (*wxExprErrorHandler
) (int errorType
, char *msg
);
53 WXDLLEXPORT_DATA(extern wxExprErrorHandler
) currentwxExprErrorHandler
;
65 class WXDLLEXPORT wxExprDatabase
;
67 class WXDLLEXPORT wxExpr
70 wxObject
*client_data
;
77 wxExpr
*first
; // If is a list expr, points to the first node
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
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
);
91 inline wxExprType
Type(void) const { return type
; }
92 inline long IntegerValue(void) const
94 if (type
== wxExprInteger
)
96 else if (type
== wxExprReal
)
97 return (long)value
.real
;
101 inline double RealValue(void) const {
102 if (type
== wxExprReal
)
104 else if (type
== wxExprInteger
)
105 return (double)value
.integer
;
106 else return (double)0.0;
109 inline wxString
WordValue(void) const {
110 if (type
== wxExprWord
)
112 else if (type
== wxExprString
)
113 return wxString(value
.string
);
114 else return wxString(wxT(""));
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(""));
125 // Get nth arg of clause (starting from 1)
126 wxExpr
*Arg(wxExprType type
, int arg
) const;
128 // Return nth argument of a list expression (starting from zero)
129 wxExpr
*Nth(int arg
) const;
131 // Returns the number of elements in a list expression
132 int Number(void) const;
135 wxExpr
*Copy(void) const;
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
144 // Append an expression to a list
145 void Append(wxExpr
*expr
);
146 // Insert at beginning of list
147 void Insert(wxExpr
*expr
);
149 // Get first expr in list
150 inline wxExpr
*GetFirst(void) const { return ((type
== wxExprList
) ? value
.first
: (wxExpr
*)NULL
); }
152 // Get next expr if this is a node in a list
153 inline wxExpr
*GetNext(void) const { return next
; }
155 // Get last expr in list
156 inline wxExpr
*GetLast(void) const { return ((type
== wxExprList
) ? last
: (wxExpr
*)NULL
); }
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
);
168 void DeleteAttributeValue(const wxString
& attribute
);
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;
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
185 // Add string items to list if the list attribute exists
186 bool GetAttributeValueStringList(const wxString
& att
, wxList
*var
) const;
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
; }
195 class WXDLLEXPORT wxExprDatabase
: public wxList
198 wxNode
*position
; // Where we are in a search
199 wxHashTable
*hash_table
;
200 wxString attribute_to_hash
;
205 wxExprDatabase(wxExprErrorHandler handler
= 0);
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.
218 wxExprDatabase(wxExprType type
, const wxString
& attribute
, int size
= 500,
219 wxExprErrorHandler handler
= 0);
221 ~wxExprDatabase(void);
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, ....).
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
);
234 wxExpr
*HashFind(const wxString
& functor
, const wxString
& value
) const;
235 wxExpr
*HashFind(const wxString
& functor
, long value
) const;
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
);
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
); }
251 DECLARE_DYNAMIC_CLASS(wxExprDatabase
)
254 // Function call-style interface - some more convenience wrappers/unwrappers
257 WXDLLEXPORT wxExpr
* wxExprMakeCall(const wxString
& functor
...);
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))
266 WXDLLEXPORT
bool wxExprIsFunctor(wxExpr
*expr
, const wxString
& functor
);
268 // Temporary variable for communicating between wxexpr.cpp and YACC/LEX
269 WXDLLEXPORT_DATA(extern wxExprDatabase
*) thewxExprDatabase
;
271 // YACC/LEX can leave memory lying around...
272 extern "C" WXDLLEXPORT
int wxExprCleanUp();
274 #endif // wxUSE_PROLOGIO
276 #endif // _WX_WXEXPRH__