/////////////////////////////////////////////////////////////////////////////
// Name:        wxexpr.h
// Purpose:     Prolog-like file I/O, used by resource system.
// Author:      Julian Smart
// Modified by:
// Created:     01/02/97
// RCS-ID:      $Id$
// Copyright:   (c)
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef __WXEXPRH__
#define __WXEXPRH__

#ifdef __GNUG__
#pragma interface "wxexpr.h"
#endif

#include <stdio.h>

#include "wx/defs.h"
#include "wx/string.h"

#if USE_IOSTREAMH
#include <iostream.h>
#else
#include <iostream>
#endif

#include "wx/list.h"
#include "wx/hash.h"

#include "wx/expr.h"

// Compatibility
#define PrologExpr wxExpr
#define PrologDatabase wxExprDatabase
#define proioErrorHandler wxExprErrorHandler
#define PROIO_ERROR_GENERAL 1
#define PROIO_ERROR_SYNTAX  2
#define PrologNull wxExprNull
#define PrologInteger wxExprInteger
#define PrologReal wxExprReal
#define PrologWord wxExprWord
#define PrologString wxExprString
#define PrologList wxExprList
#define PrologType wxExprType

// Error types
#define WXEXPR_ERROR_GENERAL 1
#define WXEXPR_ERROR_SYNTAX  2

// Error handler function definition. If app returns TRUE,
// carry on processing.
typedef bool (*wxExprErrorHandler) (int errorType, char *msg);

WXDLLEXPORT_DATA(extern wxExprErrorHandler) currentwxExprErrorHandler;

WXDLLEXPORT_DATA(extern "C" FILE*) yyin;

extern "C" int WXDLLEXPORT yyparse(void);

typedef enum {
    wxExprNull,
    wxExprInteger,
    wxExprReal,
    wxExprWord,
    wxExprString,
    wxExprList
} wxExprType;

class WXDLLEXPORT wxExprDatabase;

class WXDLLEXPORT wxExpr
{
 public:
  wxObject *client_data;
  wxExprType type;
  union {
    long integer;
    char *word;
    char *string;
    float real;
    wxExpr *first;  // If is a list expr, points to the first node
    } value;

  wxExpr *next;     // If this is a node in a list, points to the next node
  wxExpr *last;     // If is a list expr, points to the last node

  wxExpr(wxExprType the_type, char *word_or_string, bool allocate);
  wxExpr(const wxString& functor);      // Assume this is a new clause - pass functor
  wxExpr(wxExprType the_type, const wxString& word_or_string = "");
  wxExpr(long the_integer);
  wxExpr(float the_real);
  wxExpr(wxList *the_list);
  ~wxExpr(void);

  inline wxExprType Type(void) const { return type; }
  inline long IntegerValue(void) const
  {
    if (type == wxExprInteger)
      return value.integer;
    else if (type == wxExprReal)
      return (long)value.real;
    else return 0;
  }

  inline float RealValue(void) const {
    if (type == wxExprReal)
      return value.real;
    else if (type == wxExprInteger)
      return (float)value.integer;
    else return (float)0.0;
  }

  inline wxString WordValue(void) const {
    if (type == wxExprWord)
      return value.word;
    else if (type == wxExprString)
      return wxString(value.string);
    else return wxString("");
  }

  inline wxString StringValue(void) const {
    if (type == wxExprString)
      return wxString(value.string);
    else if (type == wxExprWord)
      return wxString(value.word);
    else return wxString("");
  }

  // Get nth arg of clause (starting from 1)
  wxExpr *Arg(wxExprType type, int arg) const;

  // Return nth argument of a list expression (starting from zero)
  wxExpr *Nth(int arg) const;

  // Returns the number of elements in a list expression
  int Number(void) const;

  // Make a clone
  wxExpr *Copy(void) const;

  wxExpr *GetAttributeValueNode(const wxString& word) const;  // Use only for a clause or list
  wxExpr *AttributeValue(const wxString& word) const;  // Use only for a clause
  wxString Functor(void) const;                     // Only for a clause
  bool IsFunctor(const wxString& s) const;                     // Only for a clause
  void WriteClause(ostream& stream);  // Write this expression as a top-level clause
  void WriteExpr(ostream& stream);    // Write as any other subexpression
  void WriteLispExpr(ostream& stream);

  // Append an expression to a list
  void Append(wxExpr *expr);
  // Insert at beginning of list
  void Insert(wxExpr *expr);

  // Get first expr in list
  inline wxExpr *GetFirst(void) const { return ((type == wxExprList) ? value.first : (wxExpr*)NULL); }

  // Get next expr if this is a node in a list
  inline wxExpr *GetNext(void) const { return next; }

  // Get last expr in list
  inline wxExpr *GetLast(void) const { return ((type == wxExprList) ? last : (wxExpr*)NULL); }

  // This should really be called SetAttributeValue since any existing
  // attribute-value is deleted first.
  void AddAttributeValue(const wxString& attribute, long value);
  void AddAttributeValue(const wxString& attribute, float value);
  void AddAttributeValueWord(const wxString& attribute, const wxString& value);
  void AddAttributeValueString(const wxString& attribute, const wxString& value);
  void AddAttributeValue(const wxString& attribute, wxList *value);
  void AddAttributeValue(const wxString& attribute, wxExpr *value);
  void AddAttributeValueStringList(const wxString& attribute, wxList *string_list);

  void DeleteAttributeValue(const wxString& attribute);

  bool GetAttributeValue(const wxString& att, int& var) const;
  bool GetAttributeValue(const wxString& att, long& var) const;
  bool GetAttributeValue(const wxString& att, float& var) const;
  bool GetAttributeValue(const wxString& att, wxString& var) const;  // Word OR string -> string
  bool GetAttributeValue(const wxString& att, wxExpr **var) const;

  // Compatibility with old PrologIO
  inline void AssignAttributeValue(char *att, int *var) const { GetAttributeValue(att, *var); }
  inline void AssignAttributeValue(char *att, long *var) const { GetAttributeValue(att, *var); }
  inline void AssignAttributeValue(char *att, float *var) const { GetAttributeValue(att, *var); }
  inline void AssignAttributeValue(char *att, wxExpr **var) const { GetAttributeValue(att, var); }
  void AssignAttributeValue(char *att, char **var) const ;  // Word OR string -> string

  // Add string items to list if the list attribute exists
  bool GetAttributeValueStringList(const wxString& att, wxList *var) const;

  // Associate other data with this expression, e.g. when reading in a
  // number of linked items - store C++ object pointer with the expression
  // so we can index into the wxExpr database and fish out the pointer.
  inline void SetClientData(wxObject *data) { client_data = data; }
  inline wxObject *GetClientData(void) const { return client_data; }
};

class WXDLLEXPORT wxExprDatabase: public wxList
{
  DECLARE_DYNAMIC_CLASS(wxExprDatabase)
 private:
  wxNode *position;              // Where we are in a search
  wxHashTable *hash_table;
  wxString attribute_to_hash;
 public:
  int noErrors;

  wxExprDatabase(wxExprErrorHandler handler = 0);

  // Use hashing on both the functor, and the attribute of
  // specified type (wxExprString or wxExprInteger) and name.
  // So to find node 45
  // (i.e. match the clause node(id=45, ...))
  // it usually requires 1 look-up: the keys for functor and attribute
  // are added together.
  // Obviously if the attribute was missing in a clause, it would
  // fail to be found by this method, but could be retrieved by a
  // linear search using BeginFind and FindClauseByFunctor,
  // or just searching through the list as per usual.

  wxExprDatabase(wxExprType type, const wxString& attribute, int size = 500,
                 wxExprErrorHandler handler = 0);

  ~wxExprDatabase(void);

  void BeginFind(void) ;          // Initialise a search
  wxExpr *FindClause(long id) ;  // Find a term based on an integer id attribute
                                 // e.g. node(id=23, type=rectangle, ....).

  // Find on basis of attribute/value pairs, e.g. type=rectangle
  // This doesn't use hashing; it's a linear search.
  wxExpr *FindClause(const wxString& word, const wxString& value);
  wxExpr *FindClause(const wxString& word, long value);
  wxExpr *FindClause(const wxString& word, float value);
  wxExpr *FindClauseByFunctor(const wxString& functor);

  wxExpr *HashFind(const wxString& functor, const wxString& value) const;
  wxExpr *HashFind(const wxString& functor, long value) const;

  void Append(wxExpr *expr);  // Does cleverer things if hashing is on
  void ClearDatabase(void);
  inline int GetErrorCount() const { return noErrors; }
  bool Read(const wxString& filename);
  bool ReadFromString(const wxString& buffer);
  bool Write(const wxString& fileName);
  bool Write(ostream& stream);
  void WriteLisp(ostream& stream);
  
  // Compatibility
  inline bool ReadProlog(char *filename) { return Read(wxString(filename)); }
  inline bool ReadPrologFromString(char *buffer) { return ReadFromString(wxString(buffer)); }
  inline void WriteProlog(ostream& stream) { Write(stream); }
};

// Function call-style interface - some more convenience wrappers/unwrappers

// Make a call
wxExpr* WXDLLEXPORT wxExprMakeCall(const wxString& functor ...);

#define wxExprMakeInteger(x) (new wxExpr((long)x))
#define wxExprMakeReal(x) (new wxExpr((float)x))
#define wxExprMakeString(x) (new wxExpr(wxExprString, x))
#define wxExprMakeWord(x)   (new wxExpr(wxExprWord, x))
#define wxExprMake(x)       (new wxExpr(x))

// Checks functor
bool WXDLLEXPORT wxExprIsFunctor(wxExpr *expr, const wxString& functor);

// Temporary variable for communicating between wxexpr.cpp and YACC/LEX
WXDLLEXPORT_DATA(extern wxExprDatabase*) thewxExprDatabase;

// YACC/LEX can leave memory lying around...
extern "C" WXDLLEXPORT wxExprCleanUp();

#endif

