Eval - an expression evaluation library

Main goals:

• Give functionality to applications where the users can define expressions used by the program (mainly for different kinds of calculations, transformations, etc)
• Easy embeddability/integration into the applications: the library can either statically (with source) or dynamically (in dll-s) linked into the application.
• The library depends on other ones (like the SDPP that have the similar characteristics in usability.
• Use a syntax that isn't too difficult to learn and use (at least for programmers...) - those who are familiar with C-family of the programming languages, the syntax is very easy
• Emphasis on the easy usage of the most frequent functions (like string containment) and tokenization (for the processing of CSV-structured texts)
• Different data types (int (64 bit), double, complex, point (planar), string, arrays and matrices of these ones)
• Runtime variables: the expressions can refer to variables (of the previous types) that were defined within the application. This serves as an interface between the application's inner data and the user
• Avoid the usage of regular expressions (apropos)
• Good performance: as the expressions are evaluated at runtime, it is important how they are handled inside the program. The library translates the expressions into a precompiled form (tokenization, this is the only phase where text processing takes place, must be done only once) and the evaluation works with this form of the expression (useful for situations where the expressions must be evaluated quite a big number of times - like GIS coordinate transformations (this was the original purpose of the library) or text searching and conversion).
• Good string performance - as the library is applied in several text-related applications, the inner implementation uses several techniques to avoid superflous string allocations, copies, etc
• Good multithreaded performance: the inner structure is made so that the parallel evaluations do not interfere with each other (no evil things as locks or shared data) and the memory usage is minimalized (superflous buffer reallocations are avoided).

Applicability:

• Situations, where the runtime parameterization is useful, like transformations, (sorting or similar) key extraction (like the asort)
• Queries, where the input data has several fields and logical structure of the query is not "simple" or the usage is limited if the application implies too strict constraints.
  This is the case for example in the Microsoft TFS:

  Similar cases could be written in the Eval library this way:	assigned == 'Lucky Luke' && state == 'Active' && reason == 'Approved' && changed_by == 'Roy Bean'
  The query can easily be more complex:	assigned == 'Lucky Luke' && (state == 'Active' || state == 'Pending') && (changed_by == 'Roy Bean' || changed_by == 'Henry Dalton')

  
  These hierarchical relationships are not problematic at all (to any depth, with using the parentheses) to be formulated in Eval, while the form-like (combo- and table-based) solutions have their limits in these terms.

Applications that use (the most) of this library:

• ECalc: the GUI built around the library
• MEditor: text editor, the expressions are used for searching, conversion, defining sorting keys
• cmdtools: the command line toolset, where the most important applications using the library are:
  • acalc: the command line application of the library
  • agrep: text searching
  • aconv: text conversion
  • asort: sorting, the sorting criteria can be defined with the library
• There is also a webserver (using POCO library), that uses the library and provides its entire functionality through an http form (the server is a C++ application). This page can be used as an online calculator, too.

C++ code examples of usage:

• The simplest calculator (with all the functionalities of the library):

  while (true) { std::string s; std::cin >> s; // read in expressions from the user TExpression e(s.c_str()); // create the expression (compile, check) if (e.Valid()) // error checking std::cout << e.EvalS().c_str() << std::endl; // print the result of the expression else std::cout << "Invalid input" << std::endl; }

• A simple text processor (that converts the input lines to a form specified by the user):

  std::string s; std::cin >> s; TString *sp = NewString("line"); // create a runtime variable called 'line', that can be used in the user-specified expressions TExpression e(s.c_str()); if (!s.Valid()) ... std::vector strings; // fill up 'strings' (generate, get from input, read from file, etc) // convert the 'strings' into a form specified by the user for (std::vector::iterator i = strings.begin(); i != strings.end(); ++i) { *sp = i->c_str(); // fill up the 'line' runtime variable *i = e.EvalS().c_str(); // do the conversion (assumes that the user specified an expression that gives a string result) }

  Here the user can give such expressions as:
  • line + '_postfix': the lines will be appended by the "_postfix" string
  • substr(line, 0, 10): get only the first ten characters of the strings
  • 'address: ' + strtok(line, '|', 1): get the second token of the lines from pipe-separated data