enable c++11 compilation and check for c++11 support

added GCC  option to enable c++11 support
added try compile statement to check for c++11 support
with small test program for checking null pointer and new initializers
removed the obtaining of GCC version (no longer being used)
c++11: added enum class to try compile test program
removed number of enumerator from data type enumeration

to eliminate the need for the number of enumerator changed the bit mask
data type array to an unordered map in table constructor, and removed
the equivalent data type function from the table class (was only
returning the input value), removed the call to equivalent data type
function in LET translate function, and added an enum class hash for
converting enum class values to integers (needed for unordered maps
using enum class enumerators)
removed size of enumeration from data type enumeration

the convert code have need array was removed and the table convert code
access function was changed from using this array to doing a compound
switch statement to do the equivalent of the array contents; the table
find code function was modified to use this function instead of
accessing this array directly; and the convert function was renamed (the
abbreviation was not appropriate)

the translator expected error state function was modified from having a
data type and reference type to token error status array to having a
compound switch statement; and the size of enumerator of the reference
type enumeration was removed
changed data type enumeration to a enumeration class

the No_DataType enumerator was replaced with DataType{} (to indicate an
unset data type; all Xx_DataType were renamed without the _DataType and
uses changed to DataType::Xx; the DataType::Double was assigned to one
so as not to conflict with the value of DataType{}; and the test names
awk script was modified to look for the data type enum class and
generate an unordered map for data type to string with an initializer
list instead of C style array of character array
changed more enumerations to enumeration classes

this included the translator test mode, translator reference, dictionary
entry type, error list type, operation (program model), and multiple
(table) enumerations; and also removed the redundant "enum" keyword from
a couple of places
token: improvements to class and type enumeration

moved convert code function from table to token class
replaced auto-generated data type names map with function (for tester)
  (removed generate map function from test names awk script)
changed token parentheses flag and precedence arrays to maps
  (renamed more appropriately and added initializer lists)
  (token initialization function now no longer needed)
change token type enumeration to enumeration class
  (and moved enumeration class into token class)
replaced auto-generated token type names map with function (for tester)
  (removed find enumeration function from test names awk script)
token: status changed to enumeration class

changed status message array to a function with a switch
removed auto-generation of token status enumeration
  (auto enumerations header no longer dependent on token source file)
moved token status enumeration into token class
removed unused token status enumerators
updated error suppression for newer versions of Qt

this new suppression file was tested with Qt 4.8.2, 4.8.4 and 4.8.6 with
valgrind 3.7.0 (Mint 13/Ubuntu 12.04 default) and valgrind 3.9.0
(installed from source code); the previous suppression file only worked
with Qt 4.8.2 and maybe earlier but not with 4.8.4 and 4.8.6 (other
versions not tested)
handle rpn item pointers with a shared pointer class

all instances of "RpnItem *" were replaced with RpnItemPtr, which is
an alias for std::shared_ptr<RpnItem>
- generally RPN item pointers as arguments were changed to a reference
  (so that the pointer is not copied unnecessarily incrementing its use
  count before and decrementing after the function call)
- RPN items no longer need to be deleted
- RPN item constructor changed to use initializers
- RPN list class no longer needs a clear function
  (RPN items now automatically deleted)
- allocated RPN item attached array changed to standard vector
  (which will automatically delete any attached RPN items)
  (count member removed since vector has the size)
  (RpnItemPtrVector alias added for std::vector<RpnItemPtr>)
- translator output append function simplified
  (no caller was using the attached argument, so it was removed)
rpn item: removed index member and changed text generation

rpn item changes:
- removed the index member, which was only being used for testing output
- modified attached member access functions (made constant as they don't
  modify contents, and made attached function return the entire vector
  instead of just one element)
- removed text function (now handled by rpn list text function)

rpn list text function changes:
- now handles generating the strings of the attached rpn items so that
  it can generate the indexes for the attached items (the indexes are
  temporarily assigned to each item in the list and held in a standard
  unordered map
- the final string is now built up using a standard string stream, which
  for now is converted to a QString for returning (this will be changed
  to a standard string at some point along with the token text function)
token: modified text function to return a standard string

the text function now builds into a standard string stream
was rewritten to make the private text operand function unnecessary
callers adjusted to accept a standard string
(rpn list text function was already ready for a standard string)
rpn list: change list from base class to member

having the underlying list as a base class turned out to be problematic
downstream, so the list was made a member of the class instead with
needed access functions added

the associated translator list access functions were insured to use the
rpn list class access functions instead of the list directly (only the
output last token function needed to be modified)

the call to clear the list in the destructor was removed since this is
what the destructor does anyway
rpn list: changed to standard list

added alias for rpm item pointer standard list
renamed alias for rpm item pointer standard vector
added constant iterator access functions for being and end of list
removed at access function (standard lists cannot be access by index)
changed insert index argument to iterator argument
added new append iterator function (returns iterator of item appended)
changed detection of first time through loop in text function

changed regular for loops to range-for loops for iterating over items
  (auto not used so that Qt Creator completion still works)
updated translator output access functions
  (insert and new append iterator)
changed input command translate to use list iterator instead of index
rpn list: pass by value instead of by pointer

made use of move constructor and move assignment to efficiently return
the rpn lists instance by value from functions instead of by pointer:
- return value of translator is moved to return value to delete member
- translator output member changed from pointer to regular variable
- return value of decoder, which is now a local variable
- return value of tester translate input
- rpn lists are now passed as reference to users (encode, recreate)
- receivers of rpn lists no longer need to delete the rpn list
translator: changed hold stack to standard stack

emplace function used for pushing items unto the stack, which required
the hold item structure to have a constructor (the old hold stack class
was removed); pop calls changed to top and pop calls (standard stack pop
only pops the element from the stack, but doesn't return a reference);
is empty calls changed to empty; and drop calls changed to pop (the
equivalent operation)
translator: realigned done stack and item functionality

delete open and closing parentheses calls were added to a new done item
destructor so that the these calls would be removed from the done stack
pop and drop functions

the done stack pop function had to be modified to first get the rpn item
from the top of the stack (into a temporary), drop the top stack item,
and then return the temporary rpn item - this prevents a problem where
the destuctor is called twice with the same first and last pointers, one
for the item on top of the stack and one for the temporary done item
created when popping the top item to get the rpn item

the done item replace first and last functions were combined into a
single function, which gets called directly for the top stack item, and
the done stack replace top first last function was removed

(also changed the argument names for the new hold item constructor)
translator: changed done stack to standard stack

push calls replaced with emplace calls, which required the done item
class to have constructors, one for each possible present arguments of
just rpn item, rpn item and last token, and rpn item with both first and
last tokens (the old done stack class was replaced with a using alias);
pop calls changed to top and pop calls (standard stack pop only pops the
element from the stack, but doesn't return a reference); is empty calls
changed to empty; and drop calls changed to pop (equivalent operation)
token: use alias for pointers

in preparation for changing token pointers to shared pointers, the alias
TokenPtr was added for all Token*; arguments of functions with token
pointers that did not modify the token were changed to a constant
reference (when changed to shared pointers, this will prevent
unnecessary copying of shared pointers); and token pointer
initializations and checks with NULL were changed to nullptr
token: changed token pointers to standard shared pointers

the use of standard shared pointers eliminates the need for deleting
tokens when no longer needed and worrying about parentheses tokens
and whether the closing parentheses can be deleted if not used (for
which the unused, used and last sub-codes are no longer needed)

used standard move to transfer token pointer and reset source pointer
removed token memory issue detection (free stack, used vector, deleted
  list, error reporting and overloaded new and delete operators)
removed token stack class (use standard stack instead)
removed parentheses token deletion handling from done item class
removed done stack source files, done item now in translator class
added specific hold item structure constructors
added popped enumeration for check pending parentheses boolean argument
changed translator done stack functions to standard naming convention
changed translator output append to not return item
added specific rpn item constructors, removed destructor
removed rpn set token function (not needed)
changed rpn list append to not return and inlined function
added rpn list back function to get last item (like after an append)