wxexpr.cpp

Wxpython Implemented on Windows CE, Source code

/////////////////////////////////////////////////////////////////////////////
// Name:        wxexpr.cpp
// Purpose:     wxExpr
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id: wxexpr.cpp,v 1.9 2005/09/23 12:47:39 MR Exp $
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#include "wx/deprecated/setup.h"

#if wxUSE_PROLOGIO

#include <stdarg.h>
#include <ctype.h>
#include <string.h>

#include "wx/utils.h"
#include "wx/deprecated/expr.h"
#include "wx/deprecated/wxexpr.h"

#if !WXWIN_COMPATIBILITY_2_4
static inline wxChar* copystring(const wxChar* s)
    { return wxStrcpy(new wxChar[wxStrlen(s) + 1], s); }
#endif

extern "C" void add_expr(char *);
extern "C" void LexFromFile(FILE *fd);
extern "C" void LexFromString(char *buf);



/* Rename all YACC/LEX stuff or we'll conflict with other
 * applications
 */

#define yyback PROIO_yyback
#define yylook PROIO_yylook
#define yywrap PROIO_yywrap
#define yyoutput PROIO_yyoutput
#define yylex PROIO_yylex
#define yyerror PROIO_yyerror
#define yyleng PROIO_yyleng
#define yytext PROIO_yytext
#define yymorfg PROIO_yymorfg
#define yylineno PROIO_yylineno
#define yytchar PROIO_yytchar
#define yyin PROIO_yyin
#define yyout PROIO_yyout
#define yysvf PROIO_yysvf
#define yyestate PROIO_yyestate
#define yysvec PROIO_yysvec
#define yybgin PROIO_yybgin
#define yyprevious PROIO_yyprevious
#define yylhs PROIO_yylhs
#define yylen PROIO_yylen
#define yydefred PROIO_yydefred
#define yydgoto PROIO_yydgoto
#define yysindex PROIO_yysindex
#define yyrindex PROIO_yyrindex
#define yygindex PROIO_yygindex
#define yytable PROIO_yytable
#define yycheck PROIO_yycheck
#define yyname PROIO_yyname
#define yyrule PROIO_yyrule
#define yydebug PROIO_yydebug
#define yynerrs PROIO_yynerrs
#define yyerrflag PROIO_yyerrflag
#define yychar PROIO_yychar
#define yyvsp PROIO_yyvsp
#define yyssp PROIO_yyssp
#define yyval PROIO_yyval
#define yylval PROIO_yylval
#define yyss PROIO_yyss
#define yyvs PROIO_yyvs
#define yyparse PROIO_yyparse

/* +++steve162e: more defines necessary */
#define yy_init_buffer PROIO_yy_init_buffer
#define yy_create_buffer PROIO_yy_create_buffer
#define yy_load_buffer_state PROIO_yy_load_buffer_state
#define yyrestart PROIO_yyrestart
#define yy_switch_to_buffer PROIO_yy_switch_to_buffer
#define yy_delete_buffer PROIO_yy_delete_buffer
/* ---steve162e */

/* WG 1/96: still more for flex 2.5 */
#define yy_scan_buffer PROIO_scan_buffer
#define yy_scan_string PROIO_scan_string
#define yy_scan_bytes PROIO_scan_bytes
#define yy_flex_debug PROIO_flex_debug
#define yy_flush_buffer PROIO_flush_buffer
#if !defined(__VISAGECPP__)
/* multiply defined??? */
#define yyleng PROIO_yyleng
#define yytext PROIO_yytext
#endif

extern "C" WXDLLIMPEXP_DATA_DEPRECATED(FILE*) yyin;
extern "C" WXDLLIMPEXP_DEPRECATED int yyparse(void);


wxExprDatabase *thewxExprDatabase = NULL;
wxExprErrorHandler currentwxExprErrorHandler;

wxExpr::wxExpr(const wxString& functor)
{
  type = wxExprList;
  next = NULL;
  last = NULL;
  value.first = NULL;

  wxExpr *pfunctor = new wxExpr(wxExprWord, functor);
  Append(pfunctor);
  client_data = NULL;
}

wxExpr::wxExpr(wxExprType the_type, const wxString& word_or_string)
{
  type = the_type;

  switch (the_type)
  {
   case wxExprWord:
    value.word = copystring((const wxChar *)word_or_string);
    break;
   case wxExprString:
    value.string = copystring((const wxChar *)word_or_string);
    break;
   case wxExprList:
    last = NULL;
    value.first = NULL;
    break;
   case wxExprReal:
   case wxExprInteger:
   case wxExprNull:
    break;
  }
  client_data = NULL;
  next = NULL;
}

wxExpr::wxExpr(wxExprType the_type, wxChar *word_or_string, bool allocate)
{
  type = the_type;

  switch (the_type)
  {
   case wxExprWord:
    value.word = allocate ? copystring(word_or_string) : word_or_string;
    break;
   case wxExprString:
    value.string = allocate ? copystring(word_or_string) : word_or_string;
    break;
   case wxExprList:
    last = NULL;
    value.first = NULL;
    break;
   case wxExprReal:
   case wxExprInteger:
   case wxExprNull:
    break;
  }
  client_data = NULL;
  next = NULL;
}

wxExpr::wxExpr(long the_integer)
{
  type = wxExprInteger;
  value.integer = the_integer;
  client_data = NULL;
  next = NULL;
}

wxExpr::wxExpr(double the_real)
{
  type = wxExprReal;
  value.real = the_real;
  client_data = NULL;
  next = NULL;
}

wxExpr::wxExpr(wxList *the_list)
{
  type = wxExprList;
  client_data = NULL;
  last = NULL;
  value.first = NULL;

  wxExpr *listExpr = new wxExpr(wxExprList);

  wxNode *node = the_list->GetFirst();
  while (node)
  {
    wxExpr *expr = (wxExpr *)node->GetData();
    listExpr->Append(expr);
    node = node->GetNext();
  }
  Append(listExpr);

  delete the_list;
}

wxExpr::~wxExpr(void)
{
  switch (type)
  {
    case wxExprInteger:
    case wxExprReal:
    {
     break;
    }
   case wxExprString:
   {
     delete[] value.string;
     break;
   }
   case wxExprWord:
   {
     delete[] value.word;
     break;
   }
   case wxExprList:
   {
     wxExpr *expr = value.first;
     while (expr)
     {
       wxExpr *expr1 = expr->next;

       delete expr;
       expr = expr1;
     }
     break;
   }
   case wxExprNull: break;
  }
}

void wxExpr::Append(wxExpr *expr)
{
  if (!value.first)
    value.first = expr;

  if (last)
    last->next = expr;
  last = expr;
}

void wxExpr::Insert(wxExpr *expr)
{
  expr->next = value.first;
  value.first = expr;

  if (!last)
    last = expr;
}

wxExpr *wxExpr::Copy(void) const
{
  // This seems to get round an optimizer bug when
  // using Watcom C++ 10a in WIN32 compilation mode.
  // If these lines not present, the type seems to be
  // interpreted wrongly as an integer.
  // I don't want to turn optimization off since it's needed
  // for reading in files quickly.
#if defined(__WATCOMC__)
  char buf[2];
  sprintf(buf, "");
#endif

  switch (type)
  {
    case wxExprInteger:
      return new wxExpr(value.integer);
    case wxExprReal:
      return new wxExpr(value.real);
    case wxExprString:
      return new wxExpr(wxExprString, wxString(value.string));
    case wxExprWord:
      return new wxExpr(wxExprWord, wxString(value.word));
    case wxExprList:
    {
      wxExpr *expr = value.first;
      wxExpr *new_list = new wxExpr(wxExprList);
      while (expr)
      {
        wxExpr *expr2 = expr->Copy();
        new_list->Append(expr2);
        expr = expr->next;
      }
      return new_list;
    }
   case wxExprNull:
    break;
  }
  return NULL;
}


// Get the wxExpr (containing (= wxExpr Value) form) for the given word
//  or string, assuming that we have Attribute=Value, ...
wxExpr *wxExpr::GetAttributeValueNode(const wxString& word) const // Use only for a clause or list
{
  if (type != wxExprList)
    return NULL;

  wxExpr *expr = value.first;
  while (expr)
  {
    if (expr->type == wxExprList)
    {
      wxExpr *firstNode = expr->value.first;
      if ((firstNode->type == wxExprWord) && (firstNode->value.word[0] == '='))
      {
        wxExpr *secondNode = firstNode->next;
        if ((secondNode->type == wxExprWord) &&
            (wxStrcmp((const wxChar *)word, secondNode->value.word) == 0))
        {
          return expr;
        }
      }
    }
    expr = expr->next;
  }
  return NULL;
}

// Get the value (in wxExpr form) for the given word or string, assuming
// that we have Attribute=Value, ...
wxExpr *wxExpr::AttributeValue(const wxString& word) const // Use only for a clause or list
{
  if (type != wxExprList)
    return NULL;

  wxExpr *attExpr = GetAttributeValueNode(word);
  if (attExpr && attExpr->value.first && attExpr->value.first->next)
    return attExpr->value.first->next->next;
  else return NULL;
}

wxString wxExpr::Functor(void) const // Use only for a clause
{
  if ((type != wxExprList) || !value.first)
    return wxString(wxT(""));

  if (value.first->type == wxExprWord)
    return wxString(value.first->value.word);
  else
    return wxString(wxT(""));
}

bool wxExpr::IsFunctor(const wxString& f) const  // Use only for a clause
{
  if ((type != wxExprList) || !value.first)
    return false;

  return (value.first->type == wxExprWord &&
          (wxStrcmp((const wxChar *)f, value.first->value.word) == 0));
}

// Return nth argument of a clause (starting from 1)
wxExpr *wxExpr::Arg(wxExprType theType, int arg) const
{
  wxExpr *expr = value.first;
  int i;
  for (i = 1; i < arg; i++)
    if (expr)
      expr = expr->next;

  if (expr && (expr->type == theType))
    return expr;
  else
    return NULL;
}

// Return nth argument of a list expression (starting from zero)
wxExpr *wxExpr::Nth(int arg) const
{
  if (type != wxExprList)
    return NULL;

  wxExpr *expr = value.first;
  int i;
  for (i = 0; i < arg; i++)
    if (expr)
      expr = expr->next;
    else return NULL;

  if (expr)
    return expr;
  else
    return NULL;
}

  // Returns the number of elements in a list expression
int wxExpr::Number(void) const
{
  if (type != wxExprList)
    return 0;

  int i = 0;
  wxExpr *expr = value.first;
  while (expr)
  {
    expr = expr->next;
    i ++;
  }
  return i;
}

void wxExpr::DeleteAttributeValue(const wxString& attribute)
{
  if (type != wxExprList)
    return;

  wxExpr *expr = value.first;
  wxExpr *lastExpr = this;
  while (expr)
  {
    if (expr->type == wxExprList)
    {
      wxExpr *firstNode = expr->value.first;
      if ((firstNode->type == wxExprWord) && (firstNode->value.word[0] == '='))
      {
        wxExpr *secondNode = firstNode->next;
        if ((secondNode->type == wxExprWord) &&
            (wxStrcmp((const wxChar *)attribute, secondNode->value.word) == 0))
        {
          wxExpr *nextExpr = expr->next;
          delete expr;

          lastExpr->next = nextExpr;

          if (last == expr)
            last = lastExpr;

          return;
        }
      }
    }
    lastExpr = expr;
    expr = expr->next;
  }
  return;
}

void wxExpr::AddAttributeValue(const wxString& attribute, wxExpr *val)
{
  if (type != wxExprList)
  {
//    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
    return;
  }
  // Warning - existing code may assume that any existing value
  // is deleted first. For efficiency, we leave this to the application.
//  DeleteAttributeValue(attribute);

  wxExpr *patt = new wxExpr(wxExprWord, attribute);
  wxExpr *pequals = new wxExpr(wxExprWord, wxT("="));

  wxExpr *listExpr = new wxExpr(wxExprList);

  listExpr->Append(pequals);
  listExpr->Append(patt);
  listExpr->Append(val);

  Append(listExpr);
}

void wxExpr::AddAttributeValue(const wxString& attribute, long val)
{
  if (type != wxExprList)
  {
//    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
    return;
  }
  // Warning - existing code may assume that any existing value
  // is deleted first. For efficiency, we leave this to the application.
//  DeleteAttributeValue(attribute);

  wxExpr *patt = new wxExpr(wxExprWord, attribute);
  wxExpr *pval = new wxExpr(val);
  wxExpr *pequals = new wxExpr(wxExprWord, wxT("="));

  wxExpr *listExpr = new wxExpr(wxExprList);

  listExpr->Append(pequals);
  listExpr->Append(patt);
  listExpr->Append(pval);

  Append(listExpr);
}

void wxExpr::AddAttributeValue(const wxString& attribute, double val)
{
  if (type != wxExprList)
  {
//    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
    return;
  }

//  DeleteAttributeValue(attribute);
  wxExpr *patt = new wxExpr(wxExprWord, attribute);
  wxExpr *pval = new wxExpr(val);
  wxExpr *pequals = new wxExpr(wxExprWord, wxT("="));

  wxExpr *listExpr = new wxExpr(wxExprList);

  listExpr->Append(pequals);
  listExpr->Append(patt);
  listExpr->Append(pval);

  Append(listExpr);
}

void wxExpr::AddAttributeValueString(const wxString& attribute, const wxString& val)
{
  if (type != wxExprList)
  {
//    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
    return;
  }

//  DeleteAttributeValue(attribute);

  wxExpr *patt = new wxExpr(wxExprWord, attribute);
  wxExpr *pval = new wxExpr(wxExprString, val);
  wxExpr *pequals = new wxExpr(wxExprWord, wxT("="));

  wxExpr *listExpr = new wxExpr(wxExprList);

  listExpr->Append(pequals);
  listExpr->Append(patt);
  listExpr->Append(pval);

  Append(listExpr);
}

void wxExpr::AddAttributeValueWord(const wxString& attribute, const wxString& val)
{
  if (type != wxExprList)
  {
//    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
    return;
  }

//  DeleteAttributeValue(attribute);

  wxExpr *patt = new wxExpr(wxExprWord, attribute);
  wxExpr *pval = new wxExpr(wxExprWord, val);
  wxExpr *pequals = new wxExpr(wxExprWord, wxT("="));

  wxExpr *listExpr = new wxExpr(wxExprList);

  listExpr->Append(pequals);
  listExpr->Append(patt);
  listExpr->Append(pval);

  Append(listExpr);
}

void wxExpr::AddAttributeValue(const wxString& attribute, wxList *val)
{
  if (type != wxExprList)
  {
//    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
    return;
  }
  if (!val)
    return;

//  DeleteAttributeValue(attribute);

  wxExpr *patt = new wxExpr(wxExprWord, attribute);
  wxExpr *pval = new wxExpr(val);
  wxExpr *pequals = new wxExpr(wxExprWord, wxT("="));

  wxExpr *listExpr = new wxExpr(wxExprList);

  listExpr->Append(pequals);
  listExpr->Append(patt);
  listExpr->Append(pval);

  Append(listExpr);
}

void wxExpr::AddAttributeValueStringList(const wxString& attribute, wxList *string_list)
{
  if (type != wxExprList)
  {
//    cout << "Error! tried to add an attribute-value pair to a nonlist wxExpr expression\n";
    return;
  }
  if (!string_list)
    return;

//  DeleteAttributeValue(attribute);

  // First make a list of wxExpr strings
  wxExpr *listExpr = new wxExpr(wxExprList);
  wxNode *node = string_list->GetFirst();
  while (node)
  {
    wxChar *string = (wxChar*)node->GetData();
    wxExpr *expr = new wxExpr(wxExprString, wxString(string));
    listExpr->Append(expr);
    node = node->GetNext();
  }

  // Now make an (=, Att, Value) triple
  wxExpr *patt = new wxExpr(wxExprWord, attribute);
  wxExpr *pequals = new wxExpr(wxExprWord, wxT("="));

  wxExpr *listExpr2 = new wxExpr(wxExprList);

  listExpr2->Append(pequals);
  listExpr2->Append(patt);
  listExpr2->Append(listExpr);

  Append(listExpr2);
}

bool wxExpr::GetAttributeValue(const wxString& att, int& var) const
{
  wxExpr *expr = AttributeValue(att);

  if (expr && (expr->Type() == wxExprInteger || expr->Type() == wxExprReal))
  {
    var = (int)(expr->IntegerValue());
    return true;
  }