commit 196f8482453b919fa106b88bd5a7f1f435e35a77
Author: Bohumil Franek <Bohumil.Franek@stfc.ac.uk>
Date:   Fri May 17 15:56:31 2019 +0200

     FOR instruction complete by argument replacement implementation in
          SET instruction.
    
          classes affected: 'SetIns' in Translator and in State Manager
    -----
         Argument Replacement extended to operand type 'COMPNAME'
           class 'ParOperand' in commonSource
    -----
         Bug fixed in class 'IfIns' method 'hasArgs'
-----------------------------------------------------------
 
commit 20fd69e71e6b59266013399e3830802cad31c955
Author: Bohumil Franek <Bohumil.Franek@stfc.ac.uk>
Date:   Fri May 10 14:16:24 2019 +0200

    Argument Replacement implemented in REPORT instruction and the instruction
    can be used in FOR instruction.
    
          classes affected: 'ReportIns' in Translator and in State Manager
-----------------------------------------------------------
 
commit f734ca9ae75328f749642a96f170f4c30db81937
Author: Bohumil Franek <Bohumil.Franek@stfc.ac.uk>
Date:   Sun Apr 21 15:29:15 2019 +0200

    Argument replacement in IF instruction extended into the Instruction Lists
     associated with the IF's conditions. This completes argument replacement
     in IF and makes IF fully usable in FOR instruction.
    
          classes affected: 'IfUnit' in Translator and 'IfIns' in State Manager
    
    ---
     'setCurrentArgs' method in all classws protected by check on existence
                          of arguments (by calling hasArgs() method)
    
          classes affected: 'ParOperand' in Common Source and
                           'Condition', 'DoIns', 'IfIns', 'SmpCondTyp4'
    		        in State Manager
    ---
    
     Bug fixed: class 'ParOperand' in Common Source
                        method  'outSobj'  ... when operator value type is not
    		    assigned, it outputs STRING in its place. State Manager
    		    expects this to be set to work properly.
                        Most likely this belongs to FOR instruction.
-----------------------------------------------------------
 
commit 650b8bc7d3702a45fdbd8b4d4bdcaff1409a03bc
Author: Bohumil Franek <Bohumil.Franek@stfc.ac.uk>
Date:   Sat Apr 6 12:54:35 2019 +0200

    Argument replacement in Simple condition Type 1.
    This completes argument replacement in Condition.
-----------------------------------------------------------
 
commit 333e45a9c8330b4b2c0f947487e44a5ff6d1e040
Author: Bohumil Franek <Bohumil.Franek@stfc.ac.uk>
Date:   Tue Apr 2 14:05:18 2019 +0200

    Argument replacement in Simple condition Type 4 
    
    see  comments in src/commonSource/History   dated 01-Apr-2019
-----------------------------------------------------------
 
GIT commit:  7176915d
Then History was commited again and that resulted in r4895.  Now over to GIT
------------------------------------------------------------------------
r4894 | franek | 2019-01-15 14:38:37 +0100 (Tue, 15 Jan 2019) | 2 lines

Commiting a few ReleaseNotes plus History file

------------------------------------------------------------------------
------------------------------------------------------------------------
r4893 | franek | 2018-11-19 17:08:46 +0100 (Mon, 19 Nov 2018) | 101 lines

 			   
       The design of handling arguments was changed:
       ---------------------------------------------

   src/stateManager
          			   
    - class 'Instruction'
    
         1) private data 
	     _hasArgs that kept info whether the instruction has arguments
	              is now removed. This info can be obtain by
		      calling hasArgs() ...see below
		      
	 2) private data
	      _currentArgs  removed. This was unnecessary duplication. This
	          is already kept within the parent Instruction Block.
		  
         3) the following two methods were changed to virtual and it is
	    left up to the specific instruction to provide its own methods
	    to override them. If it does not, then:
	    
	         'hasArgs()' returns FALSE
		 'setCurrentArgs(...)'  does nothing.
		 
    - class 'DoIns'
    
         1) two new methods 'hasArgs()' and
	                   'setCurrentArgs(...)'
			   
         2) instantiator  ... does not set _hasArgs.
	 
	 3)  method 'execute()'  the code for setting the arguments was moved
	                  to the new 'setCurrentArgs(...)'

      - class 'WaitIns' 
 
         1) two new methods 'hasArgs()' and
	                   'setCurrentArgs(...)'  
			   
         2) instantiator  ... does not set _hasArgs.
	 
	 	 
	 3)  method 'execute()'  the code for setting the arguments was moved
	                  to the new 'setCurrentArgs(...)'. 
			  The code in 'updateWaitIns(...)' was copied to
			  'setCurrentArgs' and 'updateWaitIns(...) removed.

 
         Partial Implementation of IF arguments:
	 ---------------------------------------
	 
	 ***WARNING***   untested changes
			  
    - class 'IfIns'
    
           two new methods 'hasArgs()' and
	                   'setCurrentArgs(...)'
     
    - class 'Condition'
    
           two new methods 'hasArgs()' and
	                   'setCurrentArgs(...)'
  			  
		 
     - class 'SmpCond'
            two new virtual methods: 
	    
	         'hasArgs()' returns FALSE
		 'setCurrentArgs(...)'  does nothing.
		 
	       it is left up to the specific Simple Condition to provide its
	       own methods to override them.
	       
      - class 'SmpCondTyp4'
      
            two new methods 'hasArgs()' and
	                   'setCurrentArgs(...)' 
	         
    src/commonSource
 
  - class 'ArgName'  moved here from src/stateManager folder. This is because
               of its use in 'ParOperand' class.	
           this required necessary changes to trunk/makefile_translator and
                                              trunk/makefile_stateManager
  
  - class 'ParOperand'
  
     1) Parameter Operand can now also be an argument and therefore have a form
      $(argn). To make it easier to process this eventuality, I introduced
      in addition to _parName additional private data 
         ArgName _parName_gen
	
     2) method 'initFromSMLcode(....)'
       	at the end the private data '_parName_gen' is initialised.
	
     3) new method    bool hasArgs() operating on _parName_gen will return TRUE
                            when Parameter Name is an argument
			    
     4) new method    setCurrentArgs(const NameVector& currArgs)
                            will replace _parName by the supplied argument.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4892 | franek | 2018-11-10 13:55:20 +0100 (Sat, 10 Nov 2018) | 44 lines

    Changes to enable IF instruction to be used in FOR instruction
    --------------------------------------------------------------
    
    src/commonSource
    
    
 - class 'ParOperand'
         new method 'replaceArgs(...)'  when appropriate, it will replace
	       parameter name by $(argi). See header file.
	       

    src/translator

  - class 'Instruction'
                    new virtual method 'replaceArgs(...)'  does nothing
		    
  - class 'InsList' modified method 'replaceArgs(...)
                          it will call 'replaceArgs' method for all its 
			  instructions without checking the instruction type.
			  This is taken care of by the virtuality of the called 
			  instruction. 
  
  
  - class 'IfIns'   new method  'replaceArgs(...)' will call the similar method
                   for all its If Units.
		   
  - class 'IfUnit'  new method 'replaceArgs(...)'  will call the similar method
                   for it Head Block.
		   
  - class 'IfUnitHeadBlock' 
                     new method 'replaceArgs(...)'  will call the similar method
                   for its Condition. 

  - class 'Condition'
                    new method 'replaceArgs(...)'  will call the similar method
                   for all its Simple Conditions.
		   
  - class 'SmpCond'
                    new virtual method 'replaceArgs(...)'  does nothing
		    
  - class 'SmpCondTyp4'
                    new method 'replaceArgs(...)'  will call the similar method
                   for its two operands

------------------------------------------------------------------------
------------------------------------------------------------------------
r4889 | franek | 2018-07-28 14:41:15 +0200 (Sat, 28 Jul 2018) | 2 lines

modified version and History files with v52r1 tag

------------------------------------------------------------------------
=== 28-July-2018:14:35 ==========  v52r1  =================
------------------------------------------------------------------------
r4888 | franek | 2018-07-25 15:05:56 +0200 (Wed, 25 Jul 2018) | 54 lines

   Changes to treatment of SMI Sets so that the original order of SMI objects
   --------------------------------------------------------------------------
   is preserved. FOR instruction is now fully functional with DO and WAIT
   -----------------------------------------------------------------------
   instructions
   -------------
                		   
    src/translator
  
   - class 'ForIns'   method 'translate()' ... removed diagnostic prints 
   		             
    src/stateManager
  
     - new class 'SMISetMember'
     
         Once an SMI Object becomes a member of a Set, its position in the Set
         remains fixed in the following sense: When the object is 'taken out',
         it is not actually removed from the set container (as used to be the
	 case),but 'switched off'. When it is inserted back again, it is just
	 'switched on'.
         Instantiations of this class hold the necessary information.
 
     - new class 'SMISetContainer'
     
         This class keeps the information about the composition of a SMI Set.
	 From a user point of view it is just a simple container of names of
	 objects (and their pointers) that are members of a given Set.
	 The speciality of this container is that the original order of
	 the objects in the Set is preserved. (The original means the order
	 in which the objects were first inserted.)
	 Internally, this is achieved by keeping the information about the
	 objects in a vector of instantiations of class 'SMISetMember'
	 plus a couple of pointes to navigate around this vector. Objects are
	 switched on when inserted, or switched off when removed.
  
     - class 'SMIObjectSet'
     
          uses now the new container class 'SMISetContainer' instead
	                                   'NmndPtnrList'
					   
     - class  'SMIObjectSetSimple'
     
               - dtto -     plus better diagnostic printinting
	       
     - class 'SMIObjectSetUnion'
     
     
     		better diagnostic printinting
	       
     - class 'ForIns' method 'execute'  bug fixed. When FOR instruction starts
                  execution, _setContents has to be cleared. Because class
		  'NameVector' does not have method 'clear', I had to change
		  to std::<vector>

------------------------------------------------------------------------
------------------------------------------------------------------------
r4887 | franek | 2018-06-25 12:56:40 +0200 (Mon, 25 Jun 2018) | 31 lines

   Modifications to WAIT instruction for use in 
   --------------------------------------------
   FOR instruction in State Manager
   --------------------------------
                 		   
    src/commonSource
  
   - utilities.cxx,.hxx  some improvements

		             
    src/stateManager
 
      - new class 'ArgName' representing names that can be picked up
                            as arguments
			    
      - class 'DoIns'  will use the new class 'ArgName'
      
      - class 'WaitIns'
      
              1) replaced names _refObjects and  _refObjectSets by
	                       _waitObjects and _waitObjectSets
	         This is beter description of what they are.
		 
	      2) new private data
	             vector<ArgName> _waitObjects_gen; see the header file
		     
	      3) new private function   'updateWaitInsObjects()'
	      
	               updates the object names in _waitObjects from
		            'argument list'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4886 | franek | 2018-06-08 15:44:38 +0200 (Fri, 08 Jun 2018) | 83 lines

   Implementation of FOR instruction in State Manager
   --------------------------------------------------
                 		   
    src/commonSource
  
   - utilities.cxx,.hxx  new function  'int argNo(const Name& name)' ... it
               checks that name is of the form $(argn) and if it is, it returns
	       'n' as integer.

		             
    src/stateManager
 
    - class 'Instruction'
    
        New concept introduced: some SMI instruction can now have arguments
	rather than fixed values for some of the elements in an instruction
	such as 'object name' in DO instruction.
	At the time of the execution of the instruction these arguments are
	replaced by their values which are supplied by the 'instruction's
	parent block(list)'.
	Consequently, we now have the following new private data:
	    bool _hasArgs;   indicating whether the instruction has arguments
	    
	    NameVector _currentArgs;   current arguments of the parent
	                                                      Instruction Block
	
	Also there are two new public methods:
	    'bool hasArgs()'       and   void 'setCurrentArgs(...)'
 
    - class 'InsList' (instruction block)
    
       a) As the consequence of the above, there are two new private data items:
	
	    bool _hasArgs;   indicating whether the instruction block has
	                     any instructions with arguments
			     
	    NameVector _currentArgs;   current arguments of the Instruction
	                                                        Block
	
	b) Also there are two new public methods:
	    'bool hasArgs()'       and   void 'setCurrentArgs(...)'
	
        c) method 'initialise(...)'  at the end of the initiliasation it goes
	       throught its instructions and if it find one that has arguments,
	       it sets '_hasArgs' to true.
	       
	d) method 'execute(...)'
	
	    - before an instruction is executed, its current arguments are set.
	    
	    - some cosmetic changes to diagnostic prints.

    - class 'DoIns' representing DO instruction.
    
         a)  DO intruction can take the name of the object on which it acts
	   as an argument. The parent Instruction Block may be supplying
	   several different arguments and which argument to use has to be
	   indicated. This is the purpose of the new data item
	   
	       int _objectNmArg
	       
	    This is initiated in the class constructor. The value 0 means that
	    object name is not taken from an argument. Otherwise the values
	    are 1 to 9.
	    The constructor also initiates the Instruction base class data
	    _hasArgs.
	    This can be generalised in future if needed.
	     
	    method 'execute'
	    
	      At the begining, if DO takes the name of the object from
	      an argument, the replacement is done at this stage.
	      NB: before the call to execute, Instruction Block sets
	      the arguments. 
	    
	  b)  replace level by _level to comply with my naming convention  
	  
	  c) improvements to diagnostic printing.   
	       
     - class  'ForIns'
     
            method 'execute(...)' implemented

------------------------------------------------------------------------
------------------------------------------------------------------------
r4885 | franek | 2018-05-01 14:39:08 +0200 (Tue, 01 May 2018) | 2 lines

adding new instruction.cxx

---------------------------------------------------------------------------
r4884 a couple of minutes before r4885

   Finished implementation of FOR instruction in Translator and started
   --------------------------------------------------------------------
                   implementation in State Manager
                   -------------------------------
		   
    src/commonSource
  
   - class 'NameVector'   new method 'replace(const int i, const Name& o)'
                              will replace ith element of vector by 'o'
   
 
    src/translator
    
    - class 'InsList'   new method 'replaceArgs(const NameVector& args)'
                              In all the relevant instructions it will replace
			      the names in the args array by $(argi) where i
			      is the position in the array.
                              At the moment it concerns only 'do' and 'wait'
			      instruction.
			      
    - class 'DoIns' 	new method 'replaceArgs(const NameVector& args)'	                                   The first name in the 'args' array that
                                  matches _objectNm will cause _objectNm to be
				  replaced by $(argi) where i is the position
				  of the matching element in 'args' array.
				  
    - class 'WaitIns'   new method 'replaceArgs(const NameVector& args)'        
                              The first name in the 'args' array that matches
			      one of the _refObjects will cause that object to
			      be replaced by $(argi) where i is the position of
			      the matching element in 'args' array. Similarly
			      for _refObjectSets.

    - class 'ForIns'   method 'translate'  at the end of the translation it 
                             replaces _argName by $(arg1) by calling
			      'replaceArgs' of 'InsBlock'.
			      
		       implemented method 'out'
		       
		       implemented method 'outSobj'
		       
		             
    src/stateManager
 
     - new class 'ForIns'   representing FOR instruction.
     
                constructor implemented
		
		'whatAreYou' method implemented
		
     - class 'InsList' takes FOR instruction into account.
     
     - class 'Action'   small diagnostics
     

------------------------------------------------------------------------
------------------------------------------------------------------------
r4883 | franek | 2018-04-12 10:59:04 +0200 (Thu, 12 Apr 2018) | 41 lines

   Significantly simplified 'outSobj' methods in several classes
   -------------------------------------------------------------
   Some BUG fixes
   --------------
   
   src/commonSource
 
     - BUG fixed
         utilities.cxx  functions  'check_compname', 'check_string',
                        'check_float', 'check_int' and 'check_name'
			
		      put in protection against rubbishy input.

   src/translator
   

      - BUG fixed in OperManager::makeOperandsSameType(...)
                 Taking properly into account the situatuation when one of
		 the operands is a constant.
	
      - 'outSobj' method in several classes was simplified.
          This is to do with 'labelling' Instruction Lists 
	                                 (aka Instruction Blocks)
	  Until now this has been done in an obscure and unsavoury manner during
	  'sobj' stage.
          Now, the labelling is done during the translation of 'action'. Any
	  Instruction Block created during that stage such as Instruction
	  Blocks in IF instructions, is labelled (id and level) and these are
	  stored as private data of the Block. The Blocks are also ordered in
	  desired order. This simplifies significantly the 'outSobj' methods
	  in the following classes:
	  
	      Action, InsList, IfIns and IfUnit
      
              In relation to this, confusing and now obsolete arguments
	      from method 'outSobj' were removed in
              the folowing classes:
	        'InsertIns', 'DoIns', 'TermIns', 'WaitForIns', 'ForIns',
                'CreateObjectIns', 'IfIns', 'SleepIns', 'WaitIns', 'InsList',
	        'ReportIns', 'IfUnit', 'SetIns', 'Instruction'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4882 | franek | 2018-03-26 15:18:06 +0200 (Mon, 26 Mar 2018) | 97 lines

   Preparatory work for re-hacking several outSobj methods 
   -------------------------------------------------------
   and introduction of 'ForIns' class representing FOR instruction
   ---------------------------------------------------------------
   
   src/commonSource
 
    - class 'SMLline'  method 'instructionLine' recognises FOR end END_FOR
    
    - class 'PtrVector' (files files ptrvector.hxx & cxx) copied here from
               stateManager  to be used by translator also.
	       This required the necessary change in makefile_translator.
	       NB: It should be deleted from stateManager. To be done later ****
   
   src/translator
   
     - new class 'ForIns'  representing FOR instruction. (files forins.cxx&hxx)
     

     - class 'Action'
           1) new private data: PtrVector _actionBlocks
	     	 vector of pointers to all the blocks that were
		  instantiated during the action translation
		  
	   2) new private method  'orderBlockPointers()'
              This method is called sfter the action translation and
	      will order the pointers in _actionBlocks 
              so that the blocks come in increasing level starting
	      with level 0. It also sets the id of each block to its position
	      in this vector.
	      This is necessary for backward compatibility of .sobj files.
	      
	   3) new private method 'printBlocks()'
              For diagnostic purposes. It prints the source code of
              blocks in _actionBlocks	 
	      
	   4) method 'translate()'passes the action pointer and the parent
	      block pointer to its top block (_pInsList). This latter is clearly
	      zero, as there is none. At the end of the translation it uses
	      the new 'orderBlockPointers'.
	                  
	      
     -class  'IfIns'
     
            1) new private data:
	         Action*  _pParentAction
		 InsList* _pParentList
		 
	    2) constructor IfIns() deleted
	     
	    3) new constructor
	          IfIns(pointer to parent action, pointer to parent block)
	
	    4) method 'translate()'  passes its parent action and block to
	                'IfUnit'

     - class 'IfUnit'
     
            1) new private data:
	         Action*  _pParentAction
		 InsList* _pParentList
		 
	    2) constructor IfUnit() deleted
	     
	    3) new constructor
	          IfUnit(pointer to parent action, pointer to parent block)
	
	    4) method 'translate()'  passes its parent action and block to
	                'InsList'
    

     - class 'InsList'
     
     
            1) new private data:
	         Action*  _pParentAction
		 InsList* _pParentList
		 int _id     This is set in Action object
		 int _level     When the object is instantiated, this is
		                set to one higher then the parent block.
		 
	    2) constructor InsList() deleted
	     
	    3) new constructor
	          InsList(pointer to parent action, pointer to parent block)
		  
            4) new method 'level()'  returns _level   and
	                  'id()'     returns _id      and
			  'setId(id)'  sets _id. called from
			               method 'orderBlockPointers'
			               of Action class.
	     
	    
	    5) method 'translate()'  passes its parent action and block to
	                'IfIns'  and 'ForIns'. It take the existence of FOR
			instruction into account.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4881 | franek | 2018-03-08 15:41:11 +0100 (Thu, 08 Mar 2018) | 19 lines

   Improved translation of Actions and InsList blocks
   --------------------------------------------------
   
   src/translator
 
      - class 'SMLUnit'   new public method 'printCodeAllIntUnits()' ...
                        prints the code of all the internal units.
			
      - class 'Action'  method 'translate()'...re-written to make it more
                        readable.

      - class 'InsList' 
             a) new private method 'collectIns'. description see the header file
	     b) new private method 'collectTermIns'. description
	        see the header file
		
	     c) method 'translate()'...re-written to make it more
                        readable.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4880 | franek | 2018-02-01 15:28:32 +0100 (Thu, 01 Feb 2018) | 44 lines

                    More tidy exiting from Translator - cont
		    ----------------------------------------
		    
   src/commonSource  
 
   - new class 'ExaminationStage'.  Keeps information about 
                                    Examination Stage in Translator.
          It is used primarily by 'ErrorWarning::printHeadTop(..)' method.
	  
   - class 'ErrorWarning'   method  'printheadTop(const char* label)'
   
          'label' argument was originally meant to be an arbitrary string
	  to give the message some sort of a heading.
	  It however, through usage, became 'message classifier', i.e.
	  'WARNING', 'SEVERE WARNING', 'ERROR' or FATAL. This is particularly
	  true during the Examination Stage in Translator (ES). 
	  Untill now, the return code from the ES was either 0 or non-zero,
	  0 meaning that .sobj file can be produced.
	  We would like additionaly to keep the info about the badest message.
          And so during ES, overall ES status is updated by calling
	         'ExaminationStage::updExamStatus(label)'.
          NB: the alternative would have been to modify every single 'examine'
	      method which there are many. It would have resulted in a more
	      professional code though. 
	  	  
   src/translator

     - main.cxx
           a) the output file is removed right at the start of the program
	      and opened just before the output stage.
	   
	   b) try-catch block was extended to include both translation and
	      examination stage.
	   
	   c) before Examination Stage starts and after it stops, 
	      'ExaminationStage' class is notified.
	      
	   d) unless there are fatal errors catched, the program terminates
	      with the Examination Stage overall status.
	   
	   d)  output stage is also put inside try-catch block. It has to be
	    different than above because when something goes wrong output
	    file has to be closed and removed.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4879 | franek | 2018-01-25 15:58:03 +0100 (Thu, 25 Jan 2018) | 18 lines

                    More tidy exiting from Translator
		    ---------------------------------
  - new enum 'ExitStatus' in commonSource/errorwarning.hxx
		    
  -Replaced  exit/abort  by throw FATAL in most of the files in
                'commonSource' and 'translator'
		
  - main.cxx a) replaced 'return n' or 'exit(n)' by either 
                        'return FATAL' or 'return SUCCESS' whichever appropriate
			
	     b) Inserted  translation stage into 'try-catch' block.
	     
	            More tydiing
		    ------------
      Small changes to remove compiler warnings in 
          commonSource/smlline.cxx,
          translator/smpcondtyp1.cxx and translator/smpcondtyp2.cxx

------------------------------------------------------------------------
----------------------------------------------------------------------------
r4876 | franek | 2018-01-10 16:01:39 +0100 (Wed, 10 Jan 2018) | 2 lines

modified version and History files with tag v51r3

------------------------------------------------------------------------
=== 10-January-2018:15:54 ==========  v51r3  =================
------------------------------------------------------------------------
r4875 | franek | 2018-01-10 15:51:54 +0100 (Wed, 10 Jan 2018) | 19 lines

                       Various
		       -------
		       
     - src/rtl
   
        1) smiuirtl.c    structure MSG renamed to MSGCHANGE
    
        2) smiuirtlcpp.cxx  For the user (rather than SMI) messages, the name of
                         the method 'smiMessageHandler' changed to 
                                    'smiUserMessageHandler'
				    
	   The necessary changes also made to the class 'SMIUserMessage'
	     in trunk/smixx/smiuirtl.hxx
	     
    
     -src/stateManager
     
          adjusting format of REPORT and ALARM messages

------------------------------------------------------------------------
------------------------------------------------------------------------
r4873 | franek | 2017-12-12 16:50:20 +0100 (Tue, 12 Dec 2017) | 17 lines

               Tidying up
	       ----------
	       
    - small changes in various files to remove compiler warnings :
        Files affected in:
	
	src/commonSource,  src/preprocessor, src/stateManager,
	src/translator, src/utilities
	
	see the relevant History files
	
    - possible BUG found in src/preprocessor/macro.cxx  NEEDS MORE INVESTIGATION
    
    - BUG fixed in src/translator/smlunit.hxx(&.cxx)  in class 'SMLUnit'
                    method 'nextChar'. However this method has not been used
		    by anybody and therefore no consequences.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4871 | franek | 2017-12-01 08:44:48 +0100 (Fri, 01 Dec 2017) | 2 lines

commited History file

------------------------------------------------------------------------
------------------------------------------------------------------------
r4870 | franek | 2017-12-01 08:41:23 +0100 (Fri, 01 Dec 2017) | 2 lines

 modified verion and History files with tag v51r2

------------------------------------------------------------------------
=== 01-December-2017:08:33 ==========  v51r2  =================
------------------------------------------------------------------------
r4869 | franek | 2017-12-01 08:26:39 +0100 (Fri, 01 Dec 2017) | 54 lines

 
 
    More on ALARM  and  REPORT messages which are now called
    --------------------------------------------------------
    SMI  and  USER  messages
    ------------------------
    
    
    src/stateManager
    ----------------
     - alarm.cxx   new format for SMI (used to be called Alarm) messages:
     
            SMI 'severity' 'domain-name'::'object-name', 'message'
	    
     - report.cxx  new format for User (used to be called Report) messages:
                   the same as for SMI messages.
		   
	    
     - reportins.cxx   removed double quotes from the message.
     
     - commhandler.cxx   new nemes for ALARM and REPORT messages :
     
              SMI/'domain-name'/SMI_MESSAGE  and
	      SMI/'domain-name'/USER_MESSAGE

    src/rtl
      
   -  Added necessary functions for receiving SMI and User messages.
      corresponding changes also in ../../smixx/...
      
        in smiuirtl.c
   
     new functions:  smiui_book_smi_message(...)
                     smiui_get_smi_message(...)
		     smiui_cancel_smi_message(...)
		 
		     smiui_book_user_message(...)
                     smiui_get_user_message(...)
		     smiui_cancel_user_message(...)
		 
         in smiuirtlcpp.cxx
  
     new classes 'SmiMessage'   with callback  'smiMessageHandler'
                 'SmiUserMessage' with callback  'smiMessageHandler'
	 
		 
   -  Fixed bug in smiui_cancel_objectsetchange(...)
             

    src/translator
 
   - class 'ReportIns'  method 'translate()'  ...  bug fixed. Crashed when
                    REPORT instruction finished with CRTLF after ')'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4863 | franek | 2017-10-05 13:00:49 +0200 (Thu, 05 Oct 2017) | 2 lines

modified versions and History files with v51r1 tag

------------------------------------------------------------------------
=== 05-October-2017:12:54 ==========  v51r1  =================
------------------------------------------------------------------------
r4862 | franek | 2017-10-05 12:42:27 +0200 (Thu, 05 Oct 2017) | 29 lines

   The generalized type of DO parameters determined in the constructor
   -------------------------------------------------------------------
                                of 'DoIns' class
                                ----------------        
    src/stateManager
    ----------------
     - class 'Parms'  new method 'add_nocheck' ... it does the same as 'add'
                      but does not verify the correctness of type.
		      'add' does not do it actually very well and this
		      SHOULD BE REVISED. Specificaly, it does not allow 
		      the type 'NAME'.
		      
     - ut_sm.hxx & .cxx  some tydiing: previously commented out code deleted
     
     - class 'DoIns'  1) constructor. Previously, determination of 
                               parameter type (generalized) was done in 
			       'execute' method calling
			       'createOutgoingParameters'.
			       It is now done here, i.e.only once. Also all
			       the checks that were done in the above method
			       are done here.
			      
                      2) method 'createOutgoingParameters' ... does not need
		         to determine the generalized type of a parameter and
			 simply picks it up from the stored value. Also does
			 not need to do any checks. Its task has been reduced
			 to getting the specific value/type for parameters with
			 generalized type 'NAME'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4861 | franek | 2017-09-28 14:24:01 +0200 (Thu, 28 Sep 2017) | 21 lines

         Yet more housekeeping
         ---------------------

    src/commonSource
    ----------------
  
      - utilities.hxx & .cxx new function 'getGenValueType(...)' ...
                  given generalized value, it returns the type, i.e.
		  INT, FLOAT. STRING, NAME, COMPNAME or UNKNOWN   
        
    src/stateManager
    ----------------

      - ut_sm.cxx   function 'getLocalParameter(...)' improved. In particular
                   it takes now into account the possibility that it may be
		   called in the environment where an action is not available.
		   Such as from WHEN. 
		   
      - class 'DoIns'  method 'createOutgoingParameters(...)' re-written and
                   hopefully rationalised.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4860 | franek | 2017-09-19 14:43:02 +0200 (Tue, 19 Sep 2017) | 18 lines

         Some housekeeping
         -----------------
    
    src/stateManager
    ----------------

      - class 'DoIns'
      
            1) private method 'createOutgoingParameters()...'
	            will now create updated parameter string for
		    dispatch with an action.
	       
	    2) method 'executeHp' which has been using the above method
	                          already, took the above change into account.
		      
            3) method 'execute' is now also using method
	                       'createOutgoingParameters()...'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4859 | franek | 2017-09-13 15:08:15 +0200 (Wed, 13 Sep 2017) | 13 lines

         Some housekeeping
         -----------------
    
    src/stateManager
    ----------------
					  
      - ut_sm.cxx&hxx  1) new function 'getAnyObjParameter' ... will return
                         the value of parameter of any object in the domain.
			 
			 2) function 'getOperandValue' re-written 
			     it is now using the two new functions
			     'getAnyObjParameter' and 'getLocalParameter'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4858 | franek | 2017-08-23 14:48:18 +0200 (Wed, 23 Aug 2017) | 18 lines

         Some housekeeping
         -----------------
	 
    src/translator
    --------------
       - class 'ReportIns'   methode 'examine()'  ... 
                                removed diagnostic prints.    

    
    src/stateManager
    ----------------
  
      - class 'ReportIns'  private method 'stripEnclosingQuotes(..)' and
                                          'getLocalParameter(...)' moved to
					  ut_sm
					  
      - ut_sm.cxx&hxx  see above

------------------------------------------------------------------------
------------------------------------------------------------------------
r4857 | franek | 2017-08-17 16:28:25 +0200 (Thu, 17 Aug 2017) | 51 lines

         Implemented REPORT instruction in State Manager
         -----------------------------------------------
    Syntax:
    
          REPORT (severity,msg)
	  
where severity is INFO,WARNING,ERROR or FATAL
	 msg      elm1+elm2+ ... + elmn
    where   elm  is either a string enclosed in doublequotes or paramter
                  name.
	
    The instruction executed as a part of an ordinary SMI action will
    deliver the associated message to an agent outside SMI world.
    It is then up to that agent to use it, most likely to display it
    on some Report Panel or whatever.
 
    src/stateManager
    ----------------
        - new class 'Report' (report.hxx&cxx) with two static methods:
            
	    'initialise()' and 'message(...). 
	    
	     This is hidding the actual mechanism of delivering the message
	     from the rest of the SMI code.
             This mechanism was chosen as DIM Service
	               'SMI/domain-name/REPORT_MESSAGE'
		       
              call to Report::initialise() is made at the start of the program.
	      This will declare to DIM the Reporting service.
	      
	      call to Report::message(severity,object,text of the message) will
	      deliver the message to Reporting agent.
	        
        - class 'CommHandler'
              a) two new public methods:
                  1) void declareReport()
	          2) void publishReport(char message[]);

              b) new data 
	           char itsReportMessage[MAX_REPORT_MESSAGE] and
		   DimService *pReport

      - new class 'ReportIns' (reportins.hxx &cxx) representing REPORT                                          instruction

      - class 'InsList'   method  'initialise(..)' It now recognises
                          and instantiates REPORT instruction and ads 
			  the pointer to it to its own list.

      - class 'Scheduler'  method 'intitialise()' .. it initiates the report
                           by calling Report::initialise().

------------------------------------------------------------------------
------------------------------------------------------------------------
r4856 | franek | 2017-07-31 13:50:06 +0200 (Mon, 31 Jul 2017) | 27 lines

         Implemented REPORT instruction in Translator
         --------------------------------------------
    Syntax:
    
          REPORT (severity,msg)
	  
where severity is INFO,WARNING,ERROR or FATAL
	 msg      elm1+elm2+ ... + elmn
    where   elm  is either a string enclosed in doublequotes or paramter
                  name.
 
    src/commonSource
    ----------------

      - class 'SMLline'   method 'instructionLine' recognises REPORT instruction
      
   src/translator
    --------------
 
   - new class  'ReportIns'  representing REPORT instruction. As always 
                   the main mathods are:  'translate()', 'examine()' and  
		   'outSobj()' 
		   
   - class  'InsList'   method 'translate()'...  recognises REPORT instruction,
                   and then , as for the others, collects its code and ivokes
		   its translation.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4855 | franek | 2017-05-19 12:37:33 +0200 (Fri, 19 May 2017) | 60 lines

         Recognition of Reserved names as special parameter names
         ---------------------------------------------------------
	 
    At the moment they are  _DOMAIN_, _OBJECT_, _STATE_, _ACTION_
    
    For example in simple conditions one can say ( _STATE_ == "ERROR" )
  
    src/commonSource
    ----------------
 
      -  new class 'ReservedNames'  encapsulates functions (static) used for
                 checking and retrieving the values of reserved names. It is                            used by both Translator and StateManager.
		 Relevant changes necessary in the make files.
		 The Translator does not use the value retriaval function.
		 This is supplied in StateManager/reservednames_sm.cxx
		 
 
    ./makefile_translator  & ./makefile_stateManager   see above 
     
    src/translator
    --------------
     - class 'ParameterBlock'   new method 'examine()'. Checks that declared                                    parameters are not reserved names.

     - class  'ActionHeadBlock'   new method 'examine()'. Checks that declared                                    parameters are not reserved names.
  
     - class  'SetIns'   method  'examine()'.  Included check that makes sure                             that the left side of the instruction is not reserved                            name.
  
     - class 'OperManager'   method 'getParValueType' 
    
                             -now returns enum 'getParValueTypeStatus_t'
			      instead of simple integer.
			      
			      - it also returns values of reserved names.
  
     - class  'SMLUnit'   ... removed references to 'Parms' class as this is not
                           used.  
  
     - class 'SMIObject'   method 'examine()' ... some unimportant tydiing


    src/stateManager
    ----------------
      - new file 'reservednames_sm.cxx'  this supplies the method 'getValue'
                   of class 'ReservedNames' defined in commonSource.
  
      - file 'ut_sm.*'
      
            a) function 'getOperandValue' takes also pParentState input                         parameter
	        It also takes into account the existence od reserved names and
		retrieves their values when required using the new function
		(see below)
	    
             - new function 'getReservedNameValue' ... does what its name says.
	                  This extra layer also takes care about some 
			  formating issues (i.e. enclosing STRING values in
			  double quotes).
 
      -class 'DoIns'
            - new private data  '_pParentState'.
	    
	    - constructor   ...  possibility of reserved names taken into                                         account
	    
      - class 'SetIns' and 'SmpCondTyp4' use the new 'getOperandValue' during
                      execution/evaluation which takes into account the                                existence of reserved names.
      
                      NB: Notice that this is different from DoIns where the
		          reserved substitution takes place at the time of
			  construction.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4854 | franek | 2017-03-09 13:11:12 +0100 (Thu, 09 Mar 2017) | 33 lines

  Added comprehensive description of methods and data in class 'ParOperand' &
  --------------------------------------------------------------------------
            'OepManager'. Also a few minor software changes.
            ------------------------------------------------
  
    src/commonSource
 
     - class 'ParOperand'
     
           a) new method 'eraseUserRequestedType'.  Used to erase, in certain
	                circumstances, user's casting request.
			
	   b) method 'initFromSobj_firstLine'  ... code rationslised a bit
			
	   c) added a comprehensive description of methods and data. This
	      was added to header file for the class complying with
	      Doxygen format.
     
     
    src/translator
  
  - class  'OperManager'
  
         - method 'getParValueType' was made private. Only used internaly.
    
         - method 'getParValueAndOperValueTypes'
	       check is made right at the beginning and if the operand type is
	       VALUE, then it returns, unless user specified cast request
	       in which case it returns warning and erases the user request.
    
         - added a comprehensive description of methods and data. This
	   was added to header file for the class complying with Doxygen format.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4853 | franek | 2017-02-13 15:25:35 +0100 (Mon, 13 Feb 2017) | 26 lines

  tydiing processing operands, casting and all that - cont
  -------------------------------------------------
  
    src/commonSource
  
      - class 'ParOperand'
      
           - removed obsolete method 'setCast'.
	   
	   - replaced method 'calcOperValueType' by 'setOperValueType'
	  
  
    src/translator
  
    - class  'OperManager'
    
         - method 'getParValueAndOperValueTypes'
	      - check is made right at the beginning and if the operand type is
	       VALUE, then it returns, unless user specified cast request
	       in which case it returns error.

              - using method 'setOperValue' instead of 'calc...'  
	      
	 - method 'attemptCasting'
	      - using method 'setOperValue' instead of 'calc...'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4852 | franek | 2017-02-09 15:07:39 +0100 (Thu, 09 Feb 2017) | 25 lines

  tydiing processing operands, casting and all that - cont
  -------------------------------------------------
  
    src/commonSource

   -  class 'ParOperand'
  
      - changed the name of private data _tobeCastedTo to _userRequestedType
        to reflect its true(more precise) meaning.
	The method 'Name& tobeCastedTo()' renamed to 
	                                        'Name& userRequestedType()'.

      - private data _castingRequested removed as it is obsolete.
        consequently method 'int castingRequested()' also removed.
  
    src/translator
   
    - class  'OperManager'  ... method 'makeOperandsSameType'
                using the method 'ParOperand::userRequestedType' (new name)
		instead the removed 'ParOperand::castingRequested' to determine
		wheather user requested any casting.
		
    - class 'SetIns'  ... method 'examine'
                the same as above.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4851 | franek | 2017-02-08 15:25:40 +0100 (Wed, 08 Feb 2017) | 28 lines

  tydiing processing operands, casting and all that
  -------------------------------------------------
  
    src/commonSource

   -  class 'ParOperand'
      
      - changed the name of private data _value to _cValue to reflect its 
        true meaning, i.e constant value in the case when operand is VALUE.
	The method 'Name& value()' renamed to 'Name& cValue()'.
	The method 'setValue' removed as it is not used.
	
      - changed the name of private data _valueType to _parmValueType
        to reflect its true meaning, i.e it is the value type of the parameter
	it refers to.
	The method 'Name valueType()' renamed to 'Name& parmValueType()'
	The method 'setValueType' renamed to 'setParmValueType'.
    
    src/translator
 
    - class 'OperManager' ... method  'getParValueType' 
                 using the new name 'ParOperand::setParmValueType'

    src/stateManager
    
    - file  'ut_sm.cxx'  ... function 'getOperandValue'
                        using the new name 'ParOperand::vValue'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4850 | franek | 2017-01-23 15:16:27 +0100 (Mon, 23 Jan 2017) | 8 lines

  simplification of code
  ----------------------
    src/translator
  
      Private methods 'collectUnit' in class 'SMIObject' and 'State' have
      identical code. This code was therefore moved to Base class 'SMLUnit'
      from which it is then inherited.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4849 | franek | 2017-01-11 14:47:52 +0100 (Wed, 11 Jan 2017) | 20 lines

  simplification of code
  ----------------------
  
    src/commonSource
    
    - class 'SMLline'
    
        removed method 'objectKeyword' and 'stateKeyword' and replaced them
	by the new method   'SMLlineType_t lineType(Name& name)' 

     src/translator
   
       - class 'SMIObject'   replaced usage of method 'objectKeyword' by 
                             'lineType'
			     
       - class  'State'    
                a) replaced usage of method 'stateKeyword' by 'lineType'
                b) modified method 'collectUnit' so that it is now
                   identical to that in class 'SMIObject'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4848 | franek | 2016-12-17 11:58:45 +0100 (Sat, 17 Dec 2016) | 5 lines

  replaced the old 'unitType_t' enum type by 'SMLlineType_t'
  ---------------------------------------------------------
  
  changes in src/translator/state.*

------------------------------------------------------------------------
------------------------------------------------------------------------
r4847 | franek | 2016-12-14 16:11:09 +0100 (Wed, 14 Dec 2016) | 6 lines

  replaced the old 'stateKeywordReturn_t' enum type by 'SMLlineType_t'
  --------------------------------------------------------------------
  
  changes in src/commonSource/smlline.*   and
             src/translator/state.*

------------------------------------------------------------------------
------------------------------------------------------------------------
r4846 | franek | 2016-12-13 15:14:01 +0100 (Tue, 13 Dec 2016) | 26 lines


   method 'translate' of class made more transparent.
   --------------------------------------------------
   
   src/commonSource
   
   - class 'SMLline'
   
      a)  new enum SMLlineType_t
      b)  method 'objectKeyword' now returns type 'SMLlineType_t'
                              It also now denies an existence of Subobjects
			      
   src/translator
 
       - new enum sectionType_t      File smlsectiontype.hxx (used also by
                                      SMIObject class)
       
       - class 'State'  uses the new enum type
	     
       - class 'SMIObject'    method 'translate()' substantialy re-written
                 a la that in 'State' class making it more redable. This is with
		 the help of a few private methods:
		 
		 collectUnit, processAttributeBlock, processParameters,
		 createCollectTranslateState and processStates.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4843 | franek | 2016-06-19 12:07:40 +0200 (Sun, 19 Jun 2016) | 2 lines

modified version and History files with v50r1 tag

------------------------------------------------------------------------
=== 19-June-2016:12:02 ==========  v50r1  =================
------------------------------------------------------------------------
r4842 | franek | 2016-06-17 14:50:00 +0200 (Fri, 17 Jun 2016) | 26 lines



   
    -  Global variable 'newTimeFlg' and 'unlockedIfs' are now picked up
       ----------------------------------------------------------------
                       from 'Options' class
		       ---------------------
		       This is the last of the options
		       
             This affects files :
	     
             state_manager.cxx ... also the call Options::bodgeGlobals()
	                           was removed
				   
	     options.cxx ... external declaration of the variables and 
	                     method 'bodgeGlobals' were removed as there are
			     no globals to be bodged.
			     
	     options.hxx ... declaration of 'bodgeGlobals' removed
	     
	     scheduler.cxx ... call to Options::bodgeGlobals() removed
	     
	     ut_sm.cxx  and  ifins.cxx
	     
     - small corrections to pacify compiler in ifins.cxx and set_name.cxx

------------------------------------------------------------------------
------------------------------------------------------------------------
r4839 | franek | 2016-06-16 12:49:46 +0200 (Thu, 16 Jun 2016) | 48 lines


    Removing Global variable 'dbg'. This is picked up from 'Options' class
    ----------------------------------------------------------------------
    
    src/commonSource
    
        - utilities.cxx   added comments about the redundancy of &DOMAIN object
	
    src/stateManager
    
  
     -  class 'Action'
       
           object &DOMAIN is now redundant and therefore 
	         method 'dealWithDomainCommands' is removed.   
		 
     -  dbg is picked up from class 'Options' instead from global variable
     
           the following files affected:  
	   
        condition.cxx
        createobjectins.cxx
        doins.cxx
        ifhandler.cxx
        ifins.cxx
        initiator.cxx
        insertins.cxx
        inslist.cxx
        options.cxx
        resumehandler.cxx
        scheduler.cxx
        setins.cxx
        sleepins.cxx
        smiclass.cxx
        smifrozenset.cxx
        smiobject.cxx
        smiobjectset.cxx
        smiobjectsetsimple.cxx
        smiobjectsetunion.cxx
        smpcondtyp2.cxx
        smpcondtyp4.cxx
        state.cxx
        state_manager.cxx
        termins.cxx
        waitforins.cxx
        waitins.cxx
        when.cxx

------------------------------------------------------------------------
------------------------------------------------------------------------
r4838 | franek | 2016-05-23 13:36:48 +0200 (Mon, 23 May 2016) | 2 lines

 removed unnecessary include from smiobject.cxx in src/stateManager

------------------------------------------------------------------------
------------------------------------------------------------------------
r4837 | franek | 2016-05-19 14:33:50 +0200 (Thu, 19 May 2016) | 113 lines


     Dynamical changing of options implemented
     -----------------------------------------
     
     - src/stateManager:
     
       - state_manager.cxx  ... using the new Options method 'bodgeGlobals'
       
       class 'CommHandler'
       
              new public method 'void declareOptions()'
	          1) declares Dim service 'SMI/domain/OPTIONS' for exporting
		  Options string (see class Options)
		  2) declares Dim command 'SMI/domain/OPTIONS/CMD' to receive
		     command to change an option
	      
	      new public method 'void publishOptions(...)
	            publishes the Options string.
	      
	      new public method 'void commandHandler()'
	          this is called when 'SMI/domain/OPTIONS/CMD' command is 
		  received. This command is of the form  id/value
		  The method puts an entry on the External Action Queue,
		  with object name '&OPTION' and action string being the
		  above string.
	      
	      new data:
	      
	           DimService *pOptions
		   DimCommand *pOptionsCmd
 
       class 'Option'
              new public method 'Name gimeExportString()'
                        returns id/type/value/name    string
       
              method 'outString()' ... slightly changed format
	      
	      method 'newValue(..)'  ... if it fails, the old value is unchanged
	      
	      method 'convertValue()' ... re-written using 'check_int' and
	                                  'check_float' utilities
					  
       class 'Options'
       
              new public method 'Name gimeExportString()'
	          returns id1/type1/value1/name1|.......
		         |idn/typen/valuen/namen          string
	      
	      new public method 'int newValue(...)'. Used to be private
	      
	      new public method 'void bodgeGlobals()'
	          this will update global variables for -d, -u and -t option.
		  This is a temporary Bodge.
		  
	      method 'initialise()'
	           names of options must not contain '/'
		   
	class 'Scheduler'
	
	     method 'initialise()'
	        added calls to CommHandler methods 'declareOptions()'
		                               and 'publishOptions(...)'
					       
	     method 'execute()'
	        it watches for the request to modify an option on the
		External Action Queue and when identified it calls
		'modifyOptionRequest()'. See below.
	
	      new private method 'modifyOptionRequest(...)'
	         it takes the request to modify an option in the form
		 'id/value'  (e.g. d/7) and modifies the option using the
		 appropriate methods of 'Option' class.
	  
     Changes so that a User Interface can change and view options:
     ------------------------------------------------------------
     
     src/rtl
     
  - smiuirtl.c
  
        new function 'int smiui_get_options(domain, optionString)'
	                   char* domain, *optionString
			   
              given domain name, it will return option string in the format:
	         id1/type1/value1/name1|...|idn/typen/valuen/namen

        new functions 'int smiu_change_option(domain,option,value)'
	          and 'int smiu_change_option_wait(...)'
	
	      it will send request to the State Manager to change one of the
	      options.
           The appropriate changes were done in ../../smixx/smiuirtl.h
	      
   - smiuirtlcpp.cxx
   
         class 'SmiUi'
	 
	  new static public method 
	        'getOptions(char *domain, char *optionString)'
		
          new static public method
	         'changeOption(char *domain, char *option, char *value)'
		 
   - new file smi_change_option.c
         this will allow to change an option from the command line in analogy
	 to smi_send_command.c
	          The appropriate changes were done in ../../smixx/smiuirtl.hxx    
    
   implemented command smiChangeOption 'domain' 'option' 'value'
   -----------------------------------
   
      This required changes in trunk directory in '.setup' and 'makefile_rtl'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4836 | franek | 2016-04-25 14:10:29 +0200 (Mon, 25 Apr 2016) | 31 lines


   'Options' class made mode sophisticated. In view of 
             the future dynamic manipulations
   ----------------------------------------------------
   
   src/stateManager
 
   
      class 'Options'   restructered and made more sophisticated. This allows
                        to change options very easily :
			
			to add and option: in method 'Options::initialise()'
			                   it is sufficient to add a call
	    'takeOption(option-Id,type,def-value, option-name, comment)'
	    
	    for example:
	    
	    takeOption("d","INT","3","Diagnostic Level","default is level 3");
	    
	                to remove an option, it is sufficient to remove the
			corresponding call. In this case however make sure
			that State Manager does not needed it!
			
      new class 'Option'   used by class 'Options'
      
      class 'SMIObject'  method 'checkForLoop()' ...
          a few small changes because retrieval of options from
	  Options class is now different.

      Main Program (state_manager.cxx)	 ...   same as above

------------------------------------------------------------------------
------------------------------------------------------------------------
r4835 | franek | 2016-04-19 14:23:09 +0200 (Tue, 19 Apr 2016) | 21 lines


   Removed explicit references to DIM in Alarm Handling
   ----------------------------------------------------
   
   src/stateManager
   
    
      class 'CommHandler'
              a) two new public methods:
                  1) void declareAlarm()
	          2) void publishAlarm(char message[]);

              b) new data 
	           char itsAlarmMessage[MAX_ALARM_MESSAGE] and
		   DimService *pAlarm
		   
      class 'Alarm' has been deprived of any knowledge about DIM and everything
                    goes through CommHandler class.		   
		    
      class 'SMIObject'   method 'checkForLoop'   small bug fixed

------------------------------------------------------------------------
------------------------------------------------------------------------
r4834 | franek | 2016-03-17 14:27:59 +0100 (Thu, 17 Mar 2016) | 4 lines


    Forgotten to add src/stateManager/options.*  files,  the previous rev will
    not work

------------------------------------------------------------------------
------------------------------------------------------------------------
r4833 | franek | 2016-03-17 14:22:26 +0100 (Thu, 17 Mar 2016) | 82 lines

 all this is in src/stateManager
 
 
   Rationalized Time handling
   --------------------------
   The purpose is to move all time relevant functions into a special class
   container 'TimeHandling' and thus encapsulating the platform dependent
   idiosyncrasies.
   
   - new class 'TimeHandling'   (file: timehandling.hxx and timehandling.cxx)
   
   at the moment it contains one new time method:
   
        double floatTime();   returns the current time in the form
	       sssssssssssss.mmm     
	       
 
   Rationalized Command line (smiSM...) options handling.
   --------------------------
   The purpose is to move all time relevant functions into a special class
   container 'Options'  (file: options.hxx and options.cxx)
   
   It contains the flowing methods:
   
   	static char* pCL_bareFileName(char* fullName);
	static void processCommandLine(int argc, char* argv[],
		        Name& ,Name&);
	these two were copied from the file 'processcommandline.cxx' which
	is now removed from svn
	
	static void printOptions();
	static void printUsage();
	these two are new methods
	
   It also contains the options picked up from the command line:
   
	static int dbg;
	static Name dim_dns_node;
	static int unlockedIfs;
	static int newTimeFlg;
	static int loopMaxChanges;
	static int loopMaxChangesFatal;
	static float loopMinDuration;

    - state_manager.cxx modified .... changes in connection with the new
                                      options handling.   
 
				      
    Loop Detection
    --------------
    Loop detection is performed for every smi object.
    
    'SMIObject'
    
    	a) new data:
	
//
/** Detection of infinite loops
*/				    
	double _fstateTime; // time of the last call to 'setState' method
	double _fprevStateTime;  // time of the previous call
	double _fstartOfLoop; // the time when the difference between
	                      // the current and prev time is less than
			      // given limit.

	bool _loopStarted;   // set true  when the difference between
	                     // the current and prev time is less than
			     // given limit.
			    // set false  when the difference between
			    // the current and prev time is greater than
			    // given limit. 
			    
	bool _seriousLoopStarted; 
	int _numChngs;   // num of state changes since the begining
	                 // of the loop  
	
    	b) new private method 'checkForLoop()'
	      this is called at the beginning of 'setState(...)' method.
	      It calculates the above new data and based on these decides
	      whethere a loop has occured and in such case issues alarm. It can
	      even kill State Manager if the loop is too severe.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4831 | franek | 2016-02-03 13:58:02 +0100 (Wed, 03 Feb 2016) | 52 lines

 
            Alarm Messages
	    --------------

    These are messages that are meant to be delivered to an agent that will
    display them on some Alarm Panel.
    
    For this purpose there is a new class 'Alarm' with two static methods
    'initialise()' and 'message(...). The mechanism for delivering the messages
    was chosen as DIM Service 'SMI/domain-name/ALARM_MESSAGE'.
    To sent a message, the call
          Alarm::message(severity,object,text of message)
    is made.
    where
         severity is "INFO","WARNING","ERROR" or "FATAL"
	        "FATAL" will cause the method to call exit(2)
	 
	 object   is name of an SMI object involved,if it makes sense
	 
    At the moment all exit and abort statements (all 132 of them) in the
    program were replaced by the Alarm::message... call. The files modified:

	action.cxx
	block_name.cxx
	condition.cxx
	doins.cxx
	ifins.cxx
	initiator.cxx
	insertins.cxx
	inslist.cxx
	logic_engine.cxx
	objectregistrar.cxx
	parms.cxx
	processcommandline.cxx
	queue_name.cxx
	queue_twonames.cxx
	scheduler.cxx
	setins.cxx
	set_name.cxx
	smiobject.cxx
	smiobjectset.cxx
	smiobjectsetsimple.cxx
	smiobjectsetunion.cxx
	smpcondtyp1.cxx
	smpcondtyp2.cxx
	smpcondtyp3.cxx
	smpcondtyp4.cxx
	state.cxx
	state_manager.cxx
	waitforins.cxx
	waitins.cxx

------------------------------------------------------------------------
------------------------------------------------------------------------
r4827 | franek | 2015-10-21 13:47:01 +0200 (Wed, 21 Oct 2015) | 2 lines

modified version and History files with v49r1 tag

------------------------------------------------------------------------
=== 21-October-2015:13:41 ==========  v49r1  =================
------------------------------------------------------------------------
r4826 | franek | 2015-10-20 15:22:41 +0200 (Tue, 20 Oct 2015) | 45 lines

       Final change to State Manager to complete the convertion to the
       ---------------------------------------------------------------
             new WHEN design based on 'WhenResponse' class
	     ---------------------------------------------
   
   src/stateManager
	   

    Cosmetic changes
    ----------------  
    - class 'WhenResponse'   new method 'Name outShort()'  ... generates zero
                                                              length string
    - class 'WFWMove_To'   new method 'Name outShort()'  ... generates string
                                                        "move_to 'state-name'"
    - class 'WFWContinue'   new method 'Name outShort()'  ... generates string
                                                        "continue"
    - class 'SWStay_in_State'   new method 'Name outShort()'  ... generates
                                                        string "stay_in_state"
    - class 'DoIns'   new method 'Name outShort()' ... generates a short
                                            string describing the DO

    Changes potentialy affecting the behaviour (It should not)
    ------------------------------------------

    - class 'DoIns'
            removed method 'stay_in_state()'  ... this is now inherited from
                                             from 'WhenResponse' class.
    - class 'When'
    
        1) removed private data 'DoIns* _pDoIns'  ... DO is accessed via
	                                            _pWhenResponse.

        2) constructor ... necessary changes in this respect.
	
	3) method 'whatAreYou' ... using _pWhenResponce
	
	4) method 'executeWhen'  ... all idiosyncracies of the various responses
	                hidden into call _pWhenResponse->executeResponse();
			
	5) method 'nextMove'  ... all idiosyncracies of the various responses
	                hidden into call _pWhenResponse->nextMove();
			
	6) method 'specialWhen'  ... all idiosyncracies of the various responses
	                hidden into call _pWhenResponse->stay_in_state();

------------------------------------------------------------------------
------------------------------------------------------------------------
r4825 | franek | 2015-10-15 14:50:59 +0200 (Thu, 15 Oct 2015) | 32 lines

   Some additions. They should not affect anything.
   ------------------------------------------------
   
   src/stateManager
	   
  
     - new classes    
     
       1)  class 'WhenResponse'  ... provide a common interface to various
                                     responses of When
				     
       2)  class  'SWStay_inState ... representing STAY_IN_STATE responce
       
       3)  class  'WFWContinue' ... representing CONTINUE response
       
       4)  class  'WFWMove_To'  ... representing MOVE_TO 'state-name'
       
    - class 'DoIns'
       1) inheriting from 'WhenResponse'
       
       2) new method 'executeResponse' which is overriding the one in
                                          'WhenResponse'.
		            It simply calls the old method  'executeHp'.
			    
    - class 'When'
    
       1)  new private data  'WhenResponse *_pWhenResponse'
       
       2)  constructor   added constructing various responses. They can all
                         be accessed through the common interface _pWhenResponse
			 For the moment still left also the pointer to _pDoIns.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4824 | franek | 2015-10-02 15:03:19 +0200 (Fri, 02 Oct 2015) | 13 lines

   More code tidying
   -----------------
   
   src/stateManager
	   
      - class 'When'
            The method 'executeWaitForWhen' was so simplified, that its function
	    was now moved into 'executeStateWhen' and we now have one method and
	    renamed it to 'executeWhen'
	    
       - class 'State' and 'WaitForIns'  had the calls to the above methods
                 changed

------------------------------------------------------------------------
------------------------------------------------------------------------
r4823 | franek | 2015-09-30 14:51:00 +0200 (Wed, 30 Sep 2015) | 19 lines

   Some code tidying
   -----------------
   
   src/stateManager
  
     - class 'When'
     
     	 method 'executeWaitForWhen' significantly simplified. It now returns
	     integer which is 1 when associated condition is TRUE, otherwise
	     it returns zero. It does nothing else. 
	     The previous functionaly is provided by this method together with
	     the new method 'nextMove'. 
	     
      - class 'WaitForIns'
      
          method 'executeWhens'  ... it uses the new 'executeWaitForWhen' and
	                             new 'nextMove' methods of class 'When'
				     to implement the same behaviour as before.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4822 | franek | 2015-09-29 15:30:51 +0200 (Tue, 29 Sep 2015) | 22 lines

   Some code tidying
   -----------------
   
   src/stateManager

  
     class 'When'
          - new method  'Name nextMove()'  This is relevant only to WhaitFor
	    whens. It returns what should be the next move in case the when
	    condition is TRUE. The return is either &CONTINUE or 'state-name'
	    into which to proceed, or &NOT-APPLICABLE for DO
	    response.
	    
	  - removed private data 'int _stay_in_state_flag'. Used only in 
	     method 'specialWhen'.
	    This flag was before set in the constructor
	    
	  - 'constructor'  removed the setting of the above flag.
	  
	  - method 'specialWhen()'  now using directly the DO instruction for 
	    determining its return.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4821 | franek | 2015-09-25 14:17:57 +0200 (Fri, 25 Sep 2015) | 25 lines

   Some code tidying
   -----------------
   
   src/stateManager
   
      class 'When'
             1) renamed method 'forcedExecute'  to 'executeStateWhen'.
	        The old name was a legacy issue. The new name is also easier to
		grep for.
		
             2) renamed method 'executeWF' to 'executeWaitForWhen'.
	     
      class 'State'
             method 'executeRequestedWhens' ... call to 'forcedExecute' name
	               changed appripriately, see above. This is the only
		       place from which this call is made.
	     
      class 'WaitForIns'
              method 'executeWhens' ...
	           1) 'executeWF' name changed to the new name, see above.
		        This is in fact the only place from which it is called.
                
		   2) the method was made private because it is used only
		      by this class

------------------------------------------------------------------------
------------------------------------------------------------------------
r4820 | franek | 2015-09-23 17:29:11 +0200 (Wed, 23 Sep 2015) | 25 lines


   DO parameters are now used and passed on even when DO is part of WHEN
   ---------------------------------------------------------------------
   
   src/stateManager
   
     
      class 'DoIns'
      
          new private method 'createOutgoingParameters'  ... will create a copy
	        of DO parameters updated from the current action and state 
		parameters.
		It is basically a copy of the existing code in 'execute'
		method and now used also in the 'executeHp' method. The code
		in 'execute' method could be now replaced by call to this method
		
	  method 'executeHp' builds and passes on the parameter string.
	  
      class 'When'
      
          constructor ... it passes to constructor of DO the pointer to parent
	                  object.
			  
	  method 'forcedExecute()' ... added more diagnostic printing.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4819 | franek | 2015-09-15 15:52:43 +0200 (Tue, 15 Sep 2015) | 181 lines


           Re-designed 'When' class to use class 'WhenResponse'.
	   -----------------------------------------------------
   WHEN response to its condition being true has several different forms 
   (DO, STAY_IN_STATE ..). Until now these were all coded (bodged up) like
    if these were all DO instruction. This is now rationalized and each
    response has its own class in which their idiosynkrasies are hidden 
    and they all inherit from a new class 'WhenResponse'. The redesign
    affected class 'When' and class 'DoIns'. In addion several new classes
    were created: 
      src/translator
   
     - new class 'WhenResponse' (whenresponse.hxx) provides a common
                 interface for different responses of WHEN, when its
		 condition is TRUE. One of the oldest responses is
		 DO instruction.
		 
     - new class 'SWStay_in_State' (swstay_in_state.cxx & hxx) is one of
                 the WHEN responses( in SML code STAY_IN_STATE).
		 NB: SW means State WHEN (as compared to WAIT_FOR WHEN)
		 
     - new class 'SWMove_To'  (swmove_to.hxx & .cxx)
                 WHEN response (in SML code  MOVE_TO 'state-name').
		 During the member instantiation, a new action with one
		 instruction (terminate_action / state='state') is generated
		 and included among the other actions of the current state.
		 This action is given a special name and the WHEN response
		 is like if it was 'DO special-action-name'

     - new class  'WFWMove_To' (wfwmove_to.hxx & .cxx)
                 WHEN response ( in SML code MOVE_TO 'state-name'; in Wait-For
		 when).
		 
     - new class  'WFWcontinue' (wfwcontinue.hxx & .cxx)
                WHEN response ( in SML code CONTINUE; in Wait-For when)

  Changes to:
  
     - class 'When'
			 
               1) private data 'DoIns *_pDoIns' replaced by 
	                       'WhenResponse *_pResponse' 
			       
	       2) private data  'SMLlineVector* _pEndStateActionCode' removed.
	                  this is now kept in SWMove_To class
			  
               3) method 'endStateActionPointer' is now called
	                 'getEndStateActionCodePointer'. It calls action
			 _Response->getEndStateActionCodePointer() which
			 will provide the relevant pointer. This method is
			 defined as virtual in the base class WhenResponse that
			 returns the pointer as NULL. It is overriden in
			 SWMove_To class returning the nonzero pointer that is
			 kept there.
			  
	       4) constructors improved
	       
	       5) method 'translate' ... modified to take into account, that
	                  WHEN now points to different responses represented
			  by the new classes. Before, it was bodged up to look
			  like if they were all DOs. All this has been now
			  pushed down into the new classes. WHEN does not
			  distinquishes between them. It only knows about
			  WhenResponse.	
			  
	       6) methods  'out',  'outSobj' and 'examine' ...
		                      _DoIns -> _pResponse 
 
    - class 'DoIns'
    
            - also inherits from 'WhenResponse' class as it can be one of WHEN
	                                                            respnses
								    
	    - new constructor 'DoIns(const Name& objectName)' ... this is in
	                      case when object name is not supplied from SML
			      code.
			      
	    - various translation methods for different WHEN responses removed
	      They are now in the relevant new classes. 
	      Also for similar reason 'whendo_examine' method removed. Every
	      class looks after itself.
	      
	    - protected method 'createTermAction' removed. It is now part of 
	                  'SWMove_To' class.

	    - method 'translate' ... 
	          - it takes into account that DO can start at non-zero column.
		  
		  - It also takes into account that object name can be
		       supplied by constructor.
	    
	          - method 'outSobj' rationalized a bit. 
		  
	    - method 'examine' ... significantly developed
	    
	    - new protected methods:
	    
	     1) 'examineAction'  2) 'examineParameters' 3) 'checkCompatibility'
	     
	        used in the examination stage of DoIns


                Various Changes
		----------------
	src/translator
    
     - class 'Action'
     		1) new method 'numParameters' returns number of the action's
		                              parameters
					      
		2) new method 'pActionParameters' returns pointer to action
		                            parameters (class Parms)
					    
     - class 'SMLUnit'
                1) improved the constructor (this removed some compiler
		                             warnings)
                   
		2) new method 'firstLineOfUnit' ... returns the first SML line
		                                    of the unit.
     
     - class 'Parms'
               a) bug fixed in method 'add'. Num of parameters should be
	                            together with the actual adding.
				    Also some redundant code removed
				    
	       b) method 'getNextParameter' used for parsing parameters from
	                            SML code ... for parameters from DO
				    instruction, the type of the parameter is
				    determined from its value (always present).
				    Before set as undefined.
               c) new methods:
	       
	         1) getParName(int inx) ... given parameter index, it returns
		                            its name
	         2) getParValue(int inx) ... given parameter index, it returns
		                             its value
	         3) getParType(int inx) ... given parameter index, it returns
		                            its type
	         4)  getParType(const Name& parName)  ...given parameter name it
	                                              returns its type
	         5) setParType(int inx, const Name& type) ... given parameter
	                        index, it sets its type.
				
	         6) getParIndex(const Name& parName)  ... given parameter name,
	                               it returns its index (-1 if not found)

     - class 'State'
               1) new method 'numActions' returns the number of actions
	       
	       2) new method  'gimeActionPointer(const int i)' for given action
	                          index, returns pointer to Action.
				  
	       3) new method 'gimeActionPointer(const Name& actionNm) for given
	                          action name, returns pointer to Action
		
	       4) method 'createCollectTranslateWhen' ... uses the new WHEN 
	                       method to retrieve generated action code pointer.		  
				      
    - class 'SMIObject'
    
               1) new method 'pObjectParameters()' ... returns pointer to the
	                          object parameters.
				  
	       2) new method 'candidateActions' ... given action name and
	                         number of parameters, it will return pointers
				 to actions of the object that have the right
				 name and at least the same number of parameters
				 as required.

     src/commonSource
 
   - Bug fixed in 'firstNonBlank' global function  (utilities.cxx &.hxx)
                  The function has also been re-writen to be more readable.
		  
   - class 'SMLlineVector'
         1) method 'out'  minor mods to do mostly with removing compiler
	    warnings
	    
	 2) new method 'validIndexes'.  Given line number and col number, it
	    checks that they are legal.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4817 | franek | 2015-07-18 15:28:39 +0200 (Sat, 18 Jul 2015) | 73 lines


         Generated 'MOVE_TO state' actions from WHENS. Handling changed.
	 Also 'translate' method of 'State' class re-designed.
	 --------------------------------------------------------------
	 
      Translation of a state WHEN with 'MOVE_TO state' response used
      to generate instantion of class Action with one instruction (i.e
      MOVE_TO state). After State was translated, these actions were
      added to the other state actions. This has not been done in a very
      consistent way.
      Now, only the SML code of these actions is generated and added to
      the state code. Consequently they are then treated exactly the same
      way as the other actions.
      

   src/translator
   --------------

    - class 'DoIns'
    
       a) method 'SWmove_to_translate', which handles MOVE_TO 'state'
	                      in State whens and used to generate Action
			      instantiation of terminate action, now
			      generates only the terminate action code
			      and returns pointer to it.
			      
        b) method 'createTermAction' had to be modified accordingly.
    
         
     - class 'When'
        
	 a) private pointer to generated Action instantiation of terminate
	    action replaced by private pointer to the generated code of
	    terminate action (_pEndStateActionCode)
	    
	    this required a small change in method 'translate()'
	    
         b) method 'endStateActionPointer()' returns pointer to the generated
	              code.
		      
         c) obsolete private method 'createTermAction' removed.
	 
     - class 'State'
     
         a) removed some 'magic' numbers and used a couple of enum types
	 
	 b) substantially re-written method 'translate()' with the help of
	    a suite of private methods. This makes it much more readable
	    and is easy to see what is going on. This change has been a long
	    time overdue.
	    
	 c) obsolete private method 'getWhenActions()' removed. This used to be
	          called at the end of the old 'translate' method and generated
		  terminate actions were added to 'State'. This was not done
		  in a very consistent manner.
		  
		  This is now handled as follows:
		     State actions and whens were translated all at once once
		     the translation of state was finished. In new translate
		     they are translated one by one once they are created and
		     collected. If the particular when has generated action
		     code, this is added to the end of the current state code
		     and thus gets processed in due course. This way these
		     actions are handled the same way as the others.	 
  
   src/commonSource
   ----------------
 
   - class 'SMLline'
   
       enum stateKeywordReturn_t {...}   decribing return codes from 
                                         'stateKeyword' method

------------------------------------------------------------------------
------------------------------------------------------------------------
r4816 | franek | 2015-07-04 16:37:43 +0200 (Sat, 04 Jul 2015) | 93 lines


         Redesign of WHEN class
	 ----------------------
 This class originally just encapsulated the condition and then just the name
 of the action  named in the DO instruction. Over the time the response to the
 TRUE condition became more complicated.
 
    We now have the following possibilities for when response:

    when response	followed by
    
 1.      DO    		'action-name'		state when
 2.      MOVE_TO	'state-name'	        state when    
 3.      STAY_IN_STATE	 n/a			state when
 
 4.      MOVE_TO	'state-name'	        Wait For When
 5.	 CONTINUE	n/a			WFW

 So I made it from the point of the WHEN more simple. WHEN will encapsulate DO
 instruction and this will also represent the other cases (2. -5). In effect we have
 shifted all the work onto DO.

   src/translator
   --------------
 
   - 'DoIns' class
   
      a) new translate method for each of the 5 cases above
         They will translate the above cases into the following DOs:
	
  	Name of the action	Name of the object	Name of the method
	
 1.	'action-name'		&THIS-OBJECT		SWdo_translate
 2.	&END_IN_STATE_WHENi	&THIS-OBJECT		SWmove_to_translate
 3.	&NULL			&THIS-OBJECT		SWstay_in_state_translate
 
 4.	&MOVE_TO'_state-name'	&THIS-OBJECT		WFWmove_to_translate
 5.	&CONTINUE		&THIS-OBJECT		WFWcontinue_translate
      
	  
       b)  new method 'createTermAction'. Used by 'SWmove_to_translate'
      
       c) new method 'outSobj'. It has an identical code to the existing one,
           but different arguments. sobj code for DO in WHEN was so far produced
	   directly from WHEN outSobj. How bad!     
      
       d)  method 'examine' modified. For the DO belonging to WHEN it will call
          the new method 'whendo_examine'
       
      
   - 'When' class
   
       a) removed private data _actionName and _endState
       
       b) new private data DoIns* _pDoIns
       
       c) method 'translate' modified. It will call the appropriate translation
          method for translating the DO depending on which kind of DO it is.
	  
       d) method 'out' and 'outSobj' modified to use the new private data.
       
       e) method 'examine' simplified by simply calling 'examine' of DO rather
           than trying to do the work.

   - 'Condition' class
   
       a) new private data   int _terminatorRow, _terminatorCol;
          Every condition is followed by a terminator (THEN, DO, .. ). This is
	  the position of the terminator within it's SMLcode.
	  
       b) method 'getNextItem' modified. Determines the above.
	  
       b) new method 'getTermPosition'. Returns the above.
       
   - 'SMLUnit' class
   
       a) new private data  'int _firstColOfUnit'. So far SMLunits always started with 
                  col 0 of the 0th line. This is allowing it to start at different col.
		  
       b) new method 'setFirstCol' is used for changing it.
   
       c) new method 'acceptLines'. It takes SMLlineVector and includes requested
                range of lines in the SMLUnit
   
   
       src/commonSource
       ----------------
 
    - class 'SMLlineVector'
    
       new method 'indicateCharacter'. Will do what method of the same name
                in  class 'SMLline' does, for a selected line.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4812 | franek | 2015-04-22 16:37:38 +0200 (Wed, 22 Apr 2015) | 2 lines

commiting the History and version files for tag v48r1

------------------------------------------------------------------------
=== 22-April-2015:16:31 ==========  v48r1  =================
------------------------------------------------------------------------
r4811 | franek | 2015-04-22 16:22:33 +0200 (Wed, 22 Apr 2015) | 27 lines


                     Instruction WAIT_FOR ... some cleaning 
		     --------------------------------------
		     
  src/translator
  --------------
   
    - 'opermanager.cxx'   ... printing more complete information with one of
                              the warnings.

    - 'waitforins.cxx'  ... commented out forgotten diagnostic printing.

  src/stateManager
  ----------------
    
      class 'WaitForIns'
      
          1) removed obsolete methods 'reportingLockedObject',
	  'attemptToLockObjects' and 'unlockObjects'. We do not have any
	   locking with this instruction
	   
	  2) removed the private data '_lockedObjects' and
	  'objectsWaitingForLock'
	  
	  3) renamed private date '_refObjectsAtStartExecution' to
	  '_refObjectsCurrent'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4807 | franek | 2015-04-10 14:00:21 +0200 (Fri, 10 Apr 2015) | 90 lines

This is promissed log for r4806.

                     Instruction WAIT_FOR ... cont 
		     -----------------------------
		     
 This is the development in State Manager. It concerns adding and removing
 objects into sets while WAIT_FOR is suspended. The WAIT_FOR implementation
 should now be complete.
 
  src/StateManager
  ----------------
  
   - 'Scheduler' class
   
          1) method 'execute'
	        Once it is detected that contents of some of the sets was
		changed, Resume Handler's method 'reportingChangedSets'
		is called. This method is specific for WAIT_IF whens. I think it
		should be used for the others too.
		Following the call, sets are removed from the list of changed
		sets. This used tobe in function 'handleObjectSetWhens_new()'
		
          2) function 'handleObjectSetWhens_new()' called from 'execute'
	      deleting of the list of changed sets removed

    - 'SMIObjectSet' class
    
    	  1) new private data
	      NameList _clientObjectsWF;
	      keeps the list of objects which are suspended because of WAIT_FOR
	      and this Set is their server (mentioned in at least one of the
	      whens)
	      
	  2) new public methods:
	  
	     'youHaveClientWF(Name& clientObject)' ... will inform the set, 
	              that there is an object with suspended WAIT_FOR
		      refering to it.
	     
	     'unregisterClientWF(Name&clientObject)'  ...unregisters client 
	             object
	     
	     'gimeWFClients()' ... will provide the list of current WAIT_FOR
	              clients. 
	       
	      'isObjectClient(Name objName)' ... will check if the object is
	              one of the clients.
	  
    - 'SMIObject' class
    
          new public method  'reportingChangedSets(NameList& sets)'
                 called by Resume Handler when contents of some sets
		 changed and the current object is suspended waiting
		 for WAIT_FOR. Once it finds that the current object is
		 a client of one of the changed set, it calls a method
		 of the same name for the WAIT_FOR instruction that is
		 causing the suspension.
    
    - 'ResumeHandler' class
    
          new public method  'reportingChangedSets(NameList& sets)'
                 called by Scheduler when contents of some sets
		 has changed.
		 For every suspended SMI object it will call its own 
		 method of the same name. If it signals that the object is
		 now ready to resume execution, it adds it to Ready To Resume
		 List and removes it from Suspended Objects list.

     - 'WaitForIns' class
     
          1) removed public method 'reportingObjectRemovedFromSet' and
	     replaced it by 
	     new public method 'reportingChangedSets()'
	          it establishes which objects were added and which were
		  removed by conmparing Previous Referenced Objects List
		  with Current Referenced Objects List.
	          It unregisters its object as being client of removed objects.
	          It registers its object as being client of added objects.
	          Finaly it checks if it can resume execution and if yes, it
	          returns 1. 
		  
          2) method 'informSetversOfSuspension()
	          in addition to explicit objects, it also informs referenced
		  sets as being servers for this object.  	  

		  
          3) method 'informSetversOfSuspensionEnd()
	          in addition to explicit objects, it also unregisters this 
		  object from being client of referenced sets.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4806 | franek | 2015-03-24 16:17:38 +0100 (Tue, 24 Mar 2015) | 2 lines

WAIT_FOR in State Manager handles insertion/removal objects from sets. Details in the next commit

------------------------------------------------------------------------
------------------------------------------------------------------------
r4805 | franek | 2015-03-04 14:11:47 +0100 (Wed, 04 Mar 2015) | 78 lines


                     Instruction WAIT_FOR ... cont 
		     -----------------------------
		     
 This is the development primarily in State Manager. It should now work
 exept removing and adding objects into sets while WAIT_FOR is suspended.
 
  src/translator
  --------------
  
    - 'WaitForIns' class   ... outputing 'endwaitfor' into .sobj file
                               to make it easier for State Manager	    	     


    src/stateManager
    ----------------

  -  new 'WaitForIns' class, new waitforins.cxx & hxx ... carefull there is a
     lot of crappy code from wait.cxx & hxx. Will be tydied up later.
     
  -  'Scheduler' class  new method 'handleWhensWF'. After an object reaches a
                        new state, it will handle its client objects that have
			been suspended because of WAIT_FOR instruction. If they
			are ready to resume, it informs ResumeHandler.
  -  'DoIns'  class  new method 'Name actionName()'. returnd the action name
                      associated with the DO.	
  
  -  'Condition' class
                 1) new method  'getDirectlyRefObjects'. Gets directly
		      (explicitely) referenced objects in the condition.
		      
		 2) new method 'getRefObjectSets'. Gets the object sets
		    referenced by the condition. Either simple, or union.
		    If an object set is part of a union, it has to be mentioned
		    in the condition explicitly in order to show in the list. It
		    is not enough that it is a part of a union that is
		    mentioned.
		    
  -  'SMIObject' class
                 1)  new private data  'WaitForIns* _pointerToSuspendedWAIT_FOR'
		 
		 2)  new private data  'NameList _clientObjectsWF'
		           Keeps a list of objects that are suspended because of
			   WAIT_FOR and this object is their server.
		 
		 2)  new method 'set pointerToSuspendedWAIT_FOR'. This is called
		                by object's just suspended WAIT_FOR.
		 
		 3)  new method 'youHaveClientWF'.  Informs object that there
		     is a client WAIT_FOR refering to it. This is called by just
		     suspended WAIT_FOR that is referencing this object.
		     
		 4)  new method 'unregisterClientWF'. This is called by just
		     resumed WAIT_FOR that has been referencing this object.
		 
		 5)  new method 'gimeWFClients'. Called by Scheduler when this
		     object reaches a state.
		 
		 6)  new method 'areYouReadyToResume'. Retuns TRUE if suspended
		      WAIT_FOR can go. This means that one of its when
		      conditions evaluates to TRUE. Called by Scheduler for
		      every object with suspended WAIT_FOR that is a client for
		      the object that has just reached state.
		      
   - 'InsList' class,  constructer takes into account the exestence of WAIT_FOR
                        instruction.
			
   -  'When'  class   1) new method 'getCurrentRefObjects'.
   
                      2) new method 'executeWF'. Used for execution of when
		      belonging to a WAIT_FOR instruction.
		      
		      3) new method 'getDirectlyRefObjects'. Similar to the one
		            in Condition class.
			    
		      4) new method 'getRefObjectSets'. Similar to the one in
		            Condition class.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4804 | franek | 2015-02-09 15:30:55 +0100 (Mon, 09 Feb 2015) | 53 lines


                     New  Instruction WAIT_FOR
		     -------------------------
	Syntax:
	
	   WAIT_FOR
	       when () X1
	         ...
	       when () Xn
	   END_WAIT_FOR
	   
	This instruction suspends the execution of the current action and
	waits untill one of the conditions in whens is true. It then executes
	the corresponding Xi.  This is either MOVE_TO 'state-name', or CONTINUE.

     src/translator
     --------------
	
    - new class 'WaitForIns'   (new files waitforins.hxx & cxx)
    
    - class 'Condition'.  
            1) It has to take into account that the end of 
               a condition could be indicated by CONTINUE
            2) method 'getHeader' ... some cleaning of the code
			  
    - class 'InsList'   method 'translate' takes into account WAIT_FOR
    
    - class 'State'  method 'translate' has to take into account the fact, 
                     that whens can occur also as part of actions.
		     
    - class 'SMIObjectSet'  corrected spelling mistake in one of the error
                            messages.
			    
    - class 'When'  
            1) new protected data   'bool _belongsToWaitFor'
	    
	    2) method 'translate'    when that belongs to WAIT_FOR and has
	                            MOVE_TO behaves differently than 'normal'
				    when.
				    also CONTINUE is a new thing
				    
	    3) method 'examine'   small change for when with CONTINUE		    	     

    src/commonSource
    ----------------

    - class SMLline
    
       1) method 'instruction' will recognise WAIT_FOR and END_WAIT_FOR
    
       2) New method 'waitForKeyword()'  used to recognise keywords inside
          WAIT_FOR instruction.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4800 | franek | 2014-09-12 11:57:30 +0200 (Fri, 12 Sep 2014) | 2 lines

 Commiting the updated History and version files fo tag  v47r1

------------------------------------------------------------------------
=== 12-September-2014:11:49 ==========  v47r1  =================
------------------------------------------------------------------------
r4798 | franek | 2014-09-12 11:38:12 +0200 (Fri, 12 Sep 2014) | 46 lines

    Last minute changes before tagging
  --------------------------------------
           
	   Bug fixes
	   ----------
	   
    1) When checking for cast indicators it is necessary to ignore the case
     i.e (INT) same as (int). This bug was fixed in :
     
        - method 'checkForCast' of class 'ParOperand'  (src/commonSource)
	
        - method 'castIndicator' of 'Condition' class   (src/translator)
         
	- method 'checkForRightSideCast' of 'SetIns' class  (src/translator)
          
    2) old bug fixed in method 'translate' of class 'IsOfClassObject'.
       This should be further investigated.
       
    3) omitted 'return 1' statement added to 'floatParToStringPar' in
                                               'src/stateManager/ut_sm.cxx
					       
	    New features
	    ------------
  folder   src/stateManager

   - class 'SmpCondTyp4'
   
         a) implemented public method 'whatAreYou'
	 
	 b) used the above method to improve diagnostic printing
	    
	    
            Code tidying
	    ------------
     The main purpose was to eliminate compiler warnings. Files affected:
     
     src/translator/attributeblock.cxx
                    condition.cxx
		    oepmanager.cxx
		    setins.cxx 
		    smlunit.cxx    
		    
     src/stateManager/ut_sm.hxx & cxx
     
     NB: For details see the relevant History files

------------------------------------------------------------------------
------------------------------------------------------------------------
r4797 | franek | 2014-09-07 17:21:09 +0200 (Sun, 07 Sep 2014) | 65 lines

                Final changes for dealing with parameter casting
        in SmpCondTyp4 ans SetIns classes. This time mainly in State Manager
  --------------------------------------------------------------------------
             Hope fully, this is it!

   folder  src/commonSource

    - class ParOperand
		   
	  - method 'outSobj'  ... outputs '_operValueType'. This will change
	                      .sobj file
    
          - method 'initFromSobj_firstLine' &
	           'initFromSobj_nextLine'  are reading the '_operValueType'

   folder  src/translator

    - class 'SetIns'
         it accepts also right hand side casting. This only switches off
	 warning message about the right side conversion.
	      
	      SET A = (S)( B + C )
         This required changes in 
	 
             1) method 'translate'
	     2) method 'examine'
	      and also 
	      
	     2 new methods:
	         'skipSpacesandTabs' & 'checkForRightSideCast'
		 
   folder  src/stateManager
   
    All the changes are in conection with the fact, that type mixing of
   parameters is dealt with in Translator.
   -------------------------------------------------------------------
   - ut_sm.hxx & cxx
   
         new function  'getOperandValue'  moved here from 'SmpCondTyp4'. Used
	                 to be its private function.

   - class 'SmpCondTyp4'
   
         - instantiator   ... put in more controlled diagnostic prints
   
         - method 'evaluate'  ...
	 
	     - using the common 'getOperandValue'
	     
	     - removed type mixing sorting...it is done now in Translator
	    
    - class 'SetIns'
    
         - method 'execute'  ...
	 
	      - using the common 'getOperandValue'
	      
	      - removed type mixing sorting...it is done now in Translator
	      
	 - method  'setLeftOperand'
	 
	      - using the common 'getOperandValue'
	      
	      - and quite substantially re-written

------------------------------------------------------------------------
------------------------------------------------------------------------
r4796 | franek | 2014-08-31 16:49:02 +0200 (Sun, 31 Aug 2014) | 58 lines

  Final changes for dealing with parameter casting
        in SmpCondTyp4 ans SetIns classes
  -------------------------------------------------

   folder  src/commonSource

    - class ParOperand
         - new private data  'Name _operValueType' this is the operand
	                      value type after the possible casting was
			      considered.
			      
	 - new private data  'int _castingRequested'.
	                        0 - no casting
				1 - user casting in SML
				2 - imposed by Translator
				3 - imposed by Translator and overriding user
				    cast
				    
	 - new public method 'int calcOperValueType()' ... calculates the
	                      operand value type from the type of ref parameter
			      and possible casting.
			      return
			        1 - success
				2 - casing constant, casting ignored
				-1 - casting STRING to FLOAT not allowed.			    
          - new public method 'void outShort() const' ... prints one line info
	 
          - new public method 'int castingRequested()' ... retieves the 
                                                relevant private data

   folder  src/translator

    - class 'OperManager'
    
         - new method 
	   ' int getParValueAndOperValueTypes(...)'
	   This method also issues the standard warnings or errors.
	   The return is 0 if only warnings, 1 if errors.
           The code from this method was picked up from examine method
           of class SmpCondTyp4

         - new method
           ' int makeOperandsSameType(...)'
           This also issues the standard warnings and errors.
           The return is 0 if only warnings, 1 if errors.

         - new private method
           ' int attemptCasting(...)'   ... used by the above method

    - class 'SmpCondTyp4'

         - method 'examine()' uses the new functions in 'OperManager' class

    - class 'SetIns'

         - method 'examine()' substantially re-written using the two new
           methods in 'OperManager' class

------------------------------------------------------------------------
------------------------------------------------------------------------
r4795 | franek | 2014-08-20 15:06:25 +0200 (Wed, 20 Aug 2014) | 46 lines

  Some preparatory work. Should not affect anything
  -------------------------------------------------

   folder  src/commonSource


    class ParOperand

       - new method 'setValue(Name& value)' ... set the '_value' to the 
                    value of referenced parameter. This is clearly only 
                    used in the State Manager when the actual values 
                    become known.

      - new method 'setCast(Name& cast)'  ... sets the value of the 
                                               '_tobeCastedTo'

      - new method 'operValueType()'  ... retrieves the final operand
                        value type after all the casting has been done.
             
       - paroperand.hxx ... oxygen type writeup added and the code re-organised
                            a bit.

       - instead using "UNKNOWN" for the initial value private data, we
                use "".

   folder  src/translator

   -  new class 'OperManager'  used for encapsulating various functions 
                               used for managing operands

          - method 'getParValueType(...)' retrieves the referenced 
                parameter value type from SML code. (called from examine 
                method in translator). The code was moved here from 
                ut_tr.cxx

          -  methods may produce warning/error messages which are stored  
                 in 'static Name _message' local data.

          -  method 'Name& getMessage()' retrieves the last message.

    - ut_tr.hxx,cxx   ... moved 'getParValueType(...)' to class 
                          'OperManager'

    - class 'SmpCondTyp4'  ... picks ups 'getParValueType' from 
                               'OperManager' class

------------------------------------------------------------------------
------------------------------------------------------------------------
r4794 | franek | 2014-08-14 13:48:06 +0200 (Thu, 14 Aug 2014) | 67 lines


   Casting in Simple condition and SET instruction - parsing
   ---------------------------------------------------------
 
    It is possible to say  ( PARSI > (I)PARSS ) or
    
    SET X = (F)A +B       etc
    
      
   - folder  src/commonSource
 
  - class 'ParOperand'
      a) new protected method 
            'void checkForCast(SMLline& line, int& jst, int& jnext)'
	    
	   Operand name is now allowed to be preceeded by a 'cast'.
	   That is one of (S), (STRING), (I), (INT), (F) or (FLOAT).
	   The function assumes that operand name starts with jstth
	   col of line and checks wheather it begins with cast, in which
	   case it sets _tobeCastedTo to STRING, INT or FLOAT. It then sets
	   jnext to the col where the proper name begins. This way
	   the rest of the parsing code can proceed as before.
	   
      b) new private data  'Name _tobeCastedTo'    
	    
      c) new public method
            'Name& tobeCastedTo()'  retrieving the above private data




   - folder  src/translator
 
  - class 'Condition'
  
       - new protected method 
            'bool castIndicator(SMLlineVector* pSMLcode, int ist, int jst)'
	   This checks whether (ist,jst) in the pSMLcode is begining of
	   cast indicator. Used by getNextItem method.
	    
       - method getNextItem(...) modified
            This method is searching forward for 'item'. Possible items are:
	    ), (, NOT, AND, OR, 'simple condition'. Before, as soon as we found
	    (, this was it. As we have now allowed for casting, we have to make
	    sure that this bracket is not a begining of casting indicator
	    because in this case we would be at the begining of Simple
	    Condition.
	    casting, 
	    
	    
  - class  'SmpCondTyp4'
  
        - method examine()  modified
	
	     this now takes into account the type into which an operand is
	     to be casted to. At parsing stage, it allows user to switch off
	     mixing types warnings.
	     An example: PARSS is type STRING and PARSI is type INT. Simple
	         condition ( PARSI > PARSS ) would have generate warning.
		 It is now possible to say ( PARSI > (I)PARSS ) to switch the
		 warning off. 
        
       	    
   - class 'SetIns'
   
       now comented out debug prints put in

------------------------------------------------------------------------
------------------------------------------------------------------------
r4793 | franek | 2014-07-30 14:58:14 +0200 (Wed, 30 Jul 2014) | 8 lines

   Extensive writeup written for some of the utility functions,
   as well as many comments in the code
   -----------------------------------------------------------------
   
   - folder  src/commonSource

         - utilities.cxx  & .hxx

------------------------------------------------------------------------
------------------------------------------------------------------------
r4792 | franek | 2014-07-15 15:17:33 +0200 (Tue, 15 Jul 2014) | 33 lines

   Dynamical switching of diagnostic level printing in State Manager
   -----------------------------------------------------------------
   
   - folder  src/commonSource

         - utilities.cxx    function 'int specialCode(...)'
   
         This function has been supplying to Translator the SML code
	 for the special object '&ALLOC'.
	 From now on it will also supply the SML code for another special
	 object '&DOMAIN'. This object is intended to be used for communicating
	 directly with State Manager. At the moment, its code is:
	 
	     Object : &DOMAIN
	     State : READY
	           action : DIAG (int LEVEL = 0 )
		          terminate_action / state = READY
			  
	 and it will be used to switch the level of diagnostic printing
	 in State Manager.
 
   - folder src/stateManager

      - class 'Action'  (action.cxx&hxx)
    
            new private function 'dealWithDomainCommands(...)'
       
           This is called when a command intended for '&DOMAIN' object
	   is received. At the moment it expects only command 'DIAG'
	   with an integer parameter 'LEVEL'. 
           It will set the value of the global flag 'dbg' which controls the
	   diagnostic printing to the value of parameter 'LEVEL'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4789 | franek | 2014-06-30 15:20:37 +0200 (Mon, 30 Jun 2014) | 2 lines

modified version and History files with v47 tag

------------------------------------------------------------------------
=== 30-June-2014:15:16 ==========  v47  =================
------------------------------------------------------------------------
r4787 | franek | 2014-06-30 14:17:24 +0200 (Mon, 30 Jun 2014) | 44 lines

   Last run on error/warning messages in Translator
   ------------------------------------------------
   
   - folder  src/translator
 
   all the error/warning messages were reviewed and made
   more compiler-like, i.e
   offending line with its number, immediately followed by
   one line description of the error/warning. The files affected:
   
       actionheadblock.cxx
       attributeblock.cxx
       condition.cxx
       createobjectins.cxx
       doins.cxx
       ifins.cxx
       ifunitheadblock.cxx
       insertins.cxx
       inslist.cxx
       isofclassobject.cxx
       main.cxx
       parameterblock.cxx
       parms.cxx
       setins.cxx
       sleepins.cxx
       smiobjectset.cxx
       smiobjectsetunion.cxx
       smpcondtyp1.cxx
       smpcondtyp2.cxx
       smpcondtyp3.cxx
       smpcondtyp4.cxx
       state.cxx
       termins.cxx
       waitins.cxx
       when.cxx
   
   Bug? fix
   --------
   
   src/stateManager/ut_sm.cxx  in order to make new compiler happy,
                              include file '<climits>'
                              has to be included for non-windows
			      platforms.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4784 | franek | 2014-06-19 14:41:07 +0200 (Thu, 19 Jun 2014) | 11 lines

   Some changes from Clara
   -----------------------
   
   - folder  src/rtl   2 files
   
   - folder src/state_manager   file ut_sm.cxx  & state_manager.cxx
        small changes to do with idiosyncrasies of Windows
	
   - folder Visual
        quite a few files. Looks like mostly tydiing up.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4783 | franek | 2014-04-20 16:19:50 +0200 (Sun, 20 Apr 2014) | 6 lines

   New time format for diagnostic printing
   ---------------------------------------
   
   This is switched on by option -t on smiSM command line. If supplied it will
   print '2014.01.31 16:00:52.824' instead of 'Fri Jan 31 16:00:52 2014'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4782 | franek | 2014-04-17 13:40:19 +0200 (Thu, 17 Apr 2014) | 116 lines

    Cleaning
    --------
    folder trunk/src/translator
    
   - parameter.hxx and parameter.cxx   deleted. These have never been used.
   
    
   - class Instruction : methods 'translate' and 'outSobj' were changed
                             prom 'virtual' to 'pure virtual'
   
	       
    - class Parms
          much of the code was removed. Originally it was intended to use this
	  class in Translator and State Manager. However an independent class
	  has been developed in State Manager over the years and consequently
	  much of the code here is obsolete.     
    
    
   Unified Error/Warning message printing in Translator
   ----------------------------------------------------
   
   This will be used systematically throughout the whole of Translator.
   
        in folder trunk/src/commonSource
        --------------------------------
     
   - new class 'ErrorWarning' keeping static method 'printHead' for unified
     Error/Warning messages.
     new files: errorwarning.hxx & cxx
     
   - 'ParOperand' (paroperand.cxx)
    
          method 'initFromSMLcode'
	      a) added checking error returned from 'getValue' function
	      
	      b) converted the existion error prints to the unified format
	      
   
   
         in folder trunk/src/translator 
         ------------------------------
     
   - usage of 'printErrorWarningHead' and 'printErrorWarningHeadGL' was replaced
           by 'ErrorWarning::printHead' everywhere.
	   
   - ut_tr.cxx&hxx  'printErrorWarningHead' removed
   
   - smpcond.cxx&hxx  'printErrorWarningHead' removed
   
   - smlunit.cxx&hxx 'printErrorWarningHead' removed
	
   - the following modification was applied to some of the classes:
       in method 'translate'( in some cases could be called 'initialise')
            replaced the old style of error messages by the new style
	    i.e using 'ErrorWarning::printHead'.
		
	The classes affected are: 
	    'ActionHeadBlock', 'AttributeBlock', 'CreateObjectIns', 'InsList',
	     'IfIns', 'IfUnitHeadBlock', 'InsertIns', 'ParameterBlock',
	     'Parms', 'SleepIns' and 'State'
	and Main program in main.cxx
 
    - the following modifications were applied to some of the classes:  
        in method 'translate' (in some cases called 'initialise')
	    replaced the old style of error messages by the new style
            i.e using 'ErrorWarning::printHead'.
		    
	in method 'examine'
	    replaced calls 'printErrorWarningHead' by
		     calls to 'ErrorWarning::printHead'
		       
	removed commented out 'printErrorWarningHead' method and put
		  back method 'outString'. This may become usefull.

        The classes affected:
	     'DoIns', 'IsOfClassObject', 'SetIns', 'SMIObject', 'SMIObjectSet',
	     'SMIObjectSetUnion', 'SmpCondTyp1', 'SmpCondTyp2', 'SmpCondTyp3',
	     'SmpCondTyp4', 'TermIns', 'WaitIns' and 'When'
     
   
   - class Condition 
    
          1) new private data:   SMLline _lineBeingTranslated
	      updated by method 'initialise' and used by the called private
	      methods. 
	      
	  2) method 'handleStack' (called from 'initialise'):
	  
	     when it encounters something wrong, it print the new style
	     error message, end exits Translator (before it returned zero).
	     The only return codes now are 1 and 2. 2 indicates the end of the
	     condition.
	     
	  3) method 'smpCondTyp'
	  
	  4) method 'initialise'
	  
	       a) replaced the old style of error messages by the new style
		i.e using 'ErrorWarning::printHead'. It also instead of
		returning zero, it exits Translator.
	     
	       b) keeps updated _lineBeingTranslated
	       
	       c) tydied up the code after calling 'handleStack' a bit
   
         
           in folder trunk
	   ---------------
    
   - makefile_translator   modified to include compilation of errorwarning.cxx
   
   - makefile_stateManager modified to include compilation of errorwarning.cxx.
                           The State manager does not use the unified error
			   printing, but the class 'ParOperand' does and as it
			   is used by StateManager ...

------------------------------------------------------------------------
------------------------------------------------------------------------
r4781 | franek | 2014-03-18 16:15:05 +0100 (Tue, 18 Mar 2014) | 83 lines

    
       Various tydiing do to with examination
       --------------------------------------
	

    folder: src/commonSource
   
     - class 'SMLline'
   
     implemented method 'int linNum()' ... returns the line number
          and           'Name lineBody()' ... returns the line itself
	  
    
    	
   folder: src/translator

   
     - class 'SMLUnit'
     
         new methods 1) 'void printCode()'. This prints the SML code of the unit
	 
	             2) 'void printErrorWarningHead(const char* label)'
		        Prints the label followed by the line number of the
			first line of the SML code and the line itself
				    
     - class 'SmpCond'
     
         1) new private data 'SMLlineVector* _pSMLcode'. Contains the first
	     line of SML code where the condition starts. This enables the
	     new method (below) to work.
	     
	 2) new method 'void printErrorWarningHead(const char* label)'
		        Prints the label followed by the line number of the
			first line of the SML code and the line itself.
			Identical code to the method of the same name in
			'SMLUnit' class. (SmpCond does not inherit from SMLUnit)

     - in several classes:
            Method 'outString()'  was deleted
	    method 'printErrorWarningHead(label)' was deleted. This is now
	            inherited  from 'SMLUnit' or 'SmpCond' class.
	    method 'examine()' unifying the format of ERROR?WARNING messages
	    
	 Classes affected:  DoIns, IsOfClassObject, SetIns, SMIObject,
	                    SMIObjectSet, SMIObjectSetUnion, TermIns,
			    WaitIns, When
			    SmpCondTyp1, SmpCondTyp2, SmpCondTyp3, SmpCondTyp4

			
     - class 'DoIns'
	    a bug fixed: more sophisticated function 'gimeObjectPointer' used
	    
     - class 'SMIObjectSet'
            class definition VOID now indicates, that user can not make it
	    specific class. This effectively switches off the warning.

     - class 'SmpCondTyp1'
            constructor instantiates _pSMLCode

     - class 'SmpCondTyp2'
            constructor instantiates _pSMLCode

     - class 'SmpCondTyp3'
            constructor instantiates _pSMLCode

     - class 'SmpCondTyp4'
            constructor instantiates _pSMLCode
	    
     - ut_tr.cxx, .hxx
     
        3 new global methods:
	
	  a) printErrorWarningHeadTop(label)
	  b) printErrorWarningHeadSrcLine(lnNo,line)
	  
	  c) printErrorWarningHead(label,smlline)

      a) and b) are used by 'printErrorWarningHead' method in
               class SMLUnit / SmpCond respectively
	       
       c) is going to be used in casses when SML code is not available 
          (like in the main program)

------------------------------------------------------------------------
------------------------------------------------------------------------
r4780 | franek | 2014-02-04 14:46:48 +0100 (Tue, 04 Feb 2014) | 28 lines

    
       Examination of Terminate and Wait instruction and of When clause
       ----------------------------------------------------------------
	
	
   folder: src/translator

    
      - class 'TermIns'
      
           implemented method 'examine()'. Checks if the parent object has the
	   termination state.
	   
      - class 'WaitIns'
      
           implemented method 'examine()'. Checks if all the reference objects
	   and sets are declared.
	   
      - class 'When'
      
          a) added one private data item 'Name _endState'. This equals "" for
	     'do when' and 'stay_in_state when'. For 'move_to when' it holds the
	     name of the state where to move.
	     
	  b) developed method 'examine()'. 
	     For 'do when' it checks if the parent state has the action.
	     For 'move_to when' it checks if parent object has the state.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4779 | franek | 2014-01-29 12:52:51 +0100 (Wed, 29 Jan 2014) | 25 lines

    
       Examination of DO instruction
       -----------------------------
	
	
   folder: src/translator
    
      - class 'State'
      
         new method 'bool hasAction(Name action-name)'
	 
      - class 'SMIObject'
      
         new method 'bool hasAction(Name action-name)'
	       checks if any of its states has action action-name.
	       
      - class 'DoIns'
      
         implemented method 'examine()'.
	     This checks if the object acted upon is declared and also
	      if the dispatched action is declared.
	     In case when DO is dispatching action to all objects of 
	     an object set (OS), it checks if OS is declared and when OS
	     is associated with a class, it also checks the action.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4778 | franek | 2014-01-21 15:41:10 +0100 (Tue, 21 Jan 2014) | 16 lines

    
       More examination
       ----------------
	
	
   folder: src/translator
   
      method 'examine()' implemented for the following classes :
      
      'SMIObject'
      'IsOfClassObject'
      'SMIObjectSet'
      'SMIObjectSetUnion'
      
      more details see in the History file

------------------------------------------------------------------------
------------------------------------------------------------------------
r4776 | franek | 2014-01-13 13:22:50 +0100 (Mon, 13 Jan 2014) | 43 lines

    
       Modifications resulting from tests at CERN at the beg of Dec 2013
       -----------------------------------------------------------------
	
	
   folder: src/translator
   
     - class 'SMIObjectSetUnion'
     
       a) new private data 'Name _isOfClass'.  When it is a union of sets that
                 are associated  with the same class, it becomes associated to
		 that class also. Tests on states can then be performed.
		 
       b) new method Name setClass() that retrieves the above class
 
    
    - class 'SmpCondTyp1'
    
       method 'examine()'
       
          a) do not check for DEAD state being declared.
	  
	  b) the check weather object has undeclared states is brought forward
	     before the check for a particular state being declared is made.
	     This really was a bug because if the first state was not declared
	     and yet object had undeclared state, the existing code would have
	     failed it.
   
          c) if Object has undeclared state, the warning was removed from here
	     and will be implemented in examine method for object.
	
   - class 'SmpCondTyp2'
     
        a) bug fixed in method 'examine()' : the account has to be taken of the
	                                  fact that SMI sets are of two kinds
					   1) simple  2) unions
   
        b) if Object Set has associated Class and the Class was not declared,
	   then this warning was taken out of here and will be implemented
	   in examine method of ObjectSet.
	
	c) -dtto- if Object Set is not associated with a Class.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4775 | franek | 2013-11-22 14:29:59 +0100 (Fri, 22 Nov 2013) | 31 lines

    
       Examination code for SET instruction (typ1, typ2 & typ3)
       --------------------------------------------------------
	
	
   folder: src/translator
     
     - class 'State'
     
         new method 'int getAttributes'. Does what it says
	 
	 new method 'bool isUndeclared'. If there is the attribute
	                                 UNDECLARED_STATE, returns true
     - class 'SMIObject'
     
         new method 'int getStates'. Does what it says.
     
         new method 'bool  hasState(const Name& stateNm, int& undeclared)'
	 	 Checks if object has state 'stateNm' declared. 
                 If such state is declared ... returns true, otherwise false
                 undeclared is set to 1 if objects has undeclared states,
		 otherwise 0

   
     
     - class 'SmpCondTyp1' 'SmpCondTyp2'  and 'SmpCondTyp3'
     
        new method 'examine()'
	
        plus a couple of new auxiliary methods

------------------------------------------------------------------------
------------------------------------------------------------------------
r4766 | franek | 2013-08-15 13:58:25 +0200 (Thu, 15 Aug 2013) | 31 lines

    
       Examination code for SET instruction (Parameter testing)
       --------------------------------------------------------
	
	
   folder: src/translator
	       
     - class 'SetIns'
    
         a) new method 'int examine()'
      
         b) 2 new methods for diagnostic printing
	       1) 'outString()'
	       2) 'printErrorWarningHead(label)'
	       
     - global function 'int getParValueType(...)'  (ut_tr.cxx)
         BUG fixed
	 
     - class 'SmpCondTyp4'
     
           method 'examine()'    BUG fixed

    folder:  src/commonSource
    
  
      - class 'ParOperand'
   
         a) method 'out(...)' improved
      
         b) method 'thisObjPar()'  BUG fixed

------------------------------------------------------------------------
------------------------------------------------------------------------
r4765 | franek | 2013-07-30 16:26:13 +0200 (Tue, 30 Jul 2013) | 67 lines

       Examination code for Simple Condition Type 4 (Parameter testing)
       ----------------------------------------------------------------
 	     
	- class 'SmpCondTyp4'
	
	     new method 'int examine()'
	     
          The following changes were also necessary to facilitate the above:
	  
	  
       - two new files 'ut_tr.hxx' and 'ut_tr.cxx'
         utility global routines specific for translator
		
	- class 'SMLUnit'
	
	   a) new private data:   'Name _type'
	       this is definitely a bodge. At the moment I use it to recognise
	       that the object that inherited belongs to 'IsOfClassObject' C++
	       class.
	       
	   b) constructor modified to accept '_type' as an argument.
	   
	   c) new method 'Name unitType()'  to retrieve the '_type'
	   
	   d) new method 'void parents(Name& object, Name& state, Name& action)'
	         to retrieve the parents of the unit.
		 
	   e) new method 'SMLUnit* parentPointer(const Name& id)'
	        given unit id, it will return the pointer to the first found
		searching upwards in the hierarchy.
			 
	- class 'Action'
	  
	   new method 'int getActionParameter(const Name& name, Name& value,
	                                  Name& typeNm)' 
	        given the parameter name, it returns its value and type
		
	- class 'SMIObject'
	  
	    2 new methods:
	  
	    1) 'int getObjectParameter(const Name& name, Name& value,
	                                  Name& typeNm)' 
	        given the parameter name, it returns its value and type
		
	    2) 'bool isClass()'
	        returns true when the instantion is class (SMI class)
	- class 'IsOfClassObject'
	
	   a) constructor modified to supply to SMLUnit type 'IsOfClassObject'
	      (see 'SMLUnit' class modification)
	      
	   b) new method 'Name& isOfClass()'. Retrieves the name of the class
	        to which it belongs.
		
	- class 'SmpCond'
	     new method  'bool belongsToIf()'
	
 folder  src/commonSource
 
          class 'ParOperand'
  
      new method 'setValueType(Name& valueType)'
      
      new method 'Name printingName()'
           prints its name in a convenient format

------------------------------------------------------------------------
------------------------------------------------------------------------
r4754 | franek | 2013-07-01 14:22:30 +0200 (Mon, 01 Jul 2013) | 154 lines

  
  folder : src/translator
  
 
   Preparatory work for the final (after the translation is finished)
   ------------------------------------------------------------------
                consistency checking (Examination)
                ----------------------------------

  Translator recognises 2 main groups of elements of SML code
  and their associated C++ classes as described in the Apendix II of
  LANGUAGE DESCRIPTION section in Web manual:

   Group 1  ... chunks of SML code consisting of a number of complete lines.
                Classes of this group inherit from 'SMLUnit' class. They can
                refer to other classes of Group 1 through an uniform mechanism.
                That is, they store the pointers to these internal units
                in the protected data '_internalSMLUnits' of 'SMLUnit'.

   Group 2 ... chunks of SML code not belonging to Group 1



  Changes of type I
  -----------------
   Examination (or consistency checking) of a particular language element
  will be achieved by executing method 'examine()' of its C++ class.
  It is therefore necessary to assure that all these are reached and executed.

     For Group 1 classes this is achieved as follows:
     -------------------

         - As all these classes inherit from 'SMLUnit' class, this class has
           for this purpose two new methods implemented:

                 1) protected 'examineUnits()'
                    This method loops through internal units whose pointers are
                    stored in '_internalSMLUnits' and for each internal unit
                    it calls the unit's 'examine()' method.

                 2) public virtual 'int examine()'
                    This method just simply calls 'examineUnits()'

         - in 'main.cxx' , examination loop is inserted after the translation
           stage. It loops through the top level units and executes their
           'examine()' method.

         When an examine() method is invoked then it is either not implemented
         in which case the base class examine() is executed and the process
         continues at the lower level, or it is implemented and then it is
         important that 'examineUnits()' is called before it returns.
         ------------------------------------------------------------

     This way all the examine methods of all the Group 1 classes are reached.

     For Group 2 classes:
     --------------------
        As these classes are always pointed to by a class of Group 1, it is
        the responsibility of the relevant Group 1 class (let's call it A) to
        invoke the examine() method of the Group 2 class (let's call it B).
        That means that if examine method of class B is implemented, then
        class A's examine method has to be also implemented in order to call
        examine method of class B.
        If more than one Group 1 class refer to B, then they all have to have
        their examine method implemented. This is for example a situation of 
        class 'When' and class 'IfUnitHeadBlock' (both Group 1) which both
        refer to class 'Condition' (Group 2).

        NB: the obvious improvement would be if also Group 2 classes inherited
            from 'SMLUnit' class. 

      As I would like to start writting examination code for simple condition,
      then
      
            - 'examine()' method was implemented for 'SmpCond' class

            - 'examine()' method implemented for 'Condition' class that simply
                  calls examine() method of 'SmpCond' class

            - 'examine()' method implemented for 'When' class that simply
                  calls examine() method of 'Condition' class

            - 'examine()' method implemented for 'IfUnitHeadBlock' class that simply
                  calls examine() method of 'Condition' class

  Changes of type II
  ------------------
    In order to facilitate clarity of possible reported errors/warnings
    generated by any given 'examine()' method, the following changes were
    implemented:

      For Group 1-1 classes
      ---------------------

         - in 'SMLUnit' class
              1) new protected data:   'SMLUnit* _pParentUnit'
                   will keep the address of the unit that is refering to it

              2) new method:       'void setParentUnit(SMLUnit* parent)'

         - method 'translate()' was modified as
           follows:
              Every time an internal code unit is instantiated, its pointer to
              parent unit is set to the current instantiation of the calling
              class by calling 'setParentUnit' inherited from SMLUnit class.
 
      Group 2 classes:
      ----------------
        
          - class 'SmpCond':

              1)  new private data 'SMLUnit* _pParentUnit'

              2)  new method 'virtual void setParameterUnit(SMLUnit* parent)'

          - class 'Condition' :

              1) new private data 'SMLUnit* _pParentUnit'

              2) new method 'void setParentUnit(SMLUnit* parent)'

              3) method 'getNextItem(...)'
                    after instantiating Simple Condition, its pointer to
                    parent unit is set to the condition's. I.e. the simple
                    conditions are pointing to the same parent as the condition.

           - class 'When' :

               1) method 'translate()'
                     Condition's pointer to parent unit is set to the pointer
                     of the current instantiation of When. 
                     This has to be done before initialising Condition.
                     --------------------------------------------------

                2) method 'createTermAction(...)'
                     When the terminal action of When is instantiated, its
                     pointer to parent unit is set to the pointer of the
                     current instantiation of When.

           - class 'IfUnitHeadBlock' :

                 1) method 'translate()'
                      Condition's pointer to parent unit is set to the pointer
                      to the current instantiation of IfUnitHeadBlock. This has
                      to be done before initialising Condition.

     NB: Again, all this would have been so much easier if these guys inherited
         from 'SMLUnit' class.

  Other Changes
  -------------

    Number of classes had their constructors improved

------------------------------------------------------------------------
------------------------------------------------------------------------
r4746 | franek | 2013-01-28 16:41:45 +0100 (Mon, 28 Jan 2013) | 2 lines

modified version and History files with tag v46r3

------------------------------------------------------------------------
=== 28-January-2013:16:36 ==========  v46r3  =================
------------------------------------------------------------------------
r4745 | franek | 2013-01-28 16:17:16 +0100 (Mon, 28 Jan 2013) | 27 lines

   
  SET instruction  - this should be now finished
  ----------------------------------------------
  
  folder : src/translator
  
  -   class SetIns  The code was tydied up
         - the code of 'newCode' method was incorporated (with minor changes)
	   into method 'translate'
	   
	 - method 'newCode' and the old (type 1,2,3) data structure were deleted

  folder : src/stateManager
  
    
  class 'SetIns' 

    
    - CLEANING
        - As there is only type 10 SET instruction, all the code relating to
          the old types and their data structures was deleted. 

        - 5 global functions that were residing in setins.cxx were moved into
          ut_sm.cxx (hxx)
  
    - SET instruction now accepts % operator

------------------------------------------------------------------------
------------------------------------------------------------------------
r4743 | franek | 2013-01-23 15:46:21 +0100 (Wed, 23 Jan 2013) | 27 lines

   
  SET instruction  - old types 1,2 and 3 are now obsolete and there is only 1 type
  --------------------------------------------------------------------------------
  
  folder : src/translator
  
  -   class SetIns  private method 'newCode'. Untill now, this method determined
             whether SET instruction was old type (1,2,3). i.e. just an
	     assigments, or the new type (type 10, i.e. 2 right hand operands.)
	     This is now unified so that types 1,2, 3 become also type 10. 

  - the necessary changes in stateManager have already been made.
  
  MISC
  ----
    
   folder : src/stateManager

  -class 'Action'   new method 'Name& actionName'
  		   
  - setins.cxx  some diagnostic print improvement.
  
  folder : src/commonSource
  
  - class 'ParOperand' : Bug fixed:  Parameter operand can also be
                                     delimited by "="

------------------------------------------------------------------------
------------------------------------------------------------------------
r4735 | franek | 2012-12-19 14:26:49 +0100 (Wed, 19 Dec 2012) | 13 lines

   
  SET instruction  - handling extended to type 10 with only 1 operand
  -------------------------------------------------------------------
 
   folder : src/stateManager
   
  - setins.hxx  two new private data: 
  
                   _numOperands  .. number of operands on the right side
		   -numOperations  .. not used at the moment
		   
  - setins.cxx  the necessary changes in constructor and method execute.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4731 | franek | 2012-11-19 14:40:52 +0100 (Mon, 19 Nov 2012) | 2 lines

modified version and History files with tag v46r2

------------------------------------------------------------------------
=== 19-November-2012:14:31 ==========  v46r2  =================
------------------------------------------------------------------------
r4730 | franek | 2012-11-19 12:53:36 +0100 (Mon, 19 Nov 2012) | 21 lines

    Type mixing implemented in Simple Condition of Typ4
    ---------------------------------------------------

   folder : src/stateManager
   
 
   class 'SetIns'   private method 'sortTypeMixing' was made global function
                    by removing it from 'setins.hxx' and also moving it to the
		    front in file 'setins.cxx'.
		    
		    It was then sufficient to put the header info at the
		    begining of file smpcondtyp4.cxx to use the function there.
		    See below.
		    
   class 'SmpCondTyp4'    method 'evaluate'
                    implemented some type mixing:
		    
		    int comparing with float, int converted to float first
		    int comparing with string, if str represents int it is
		    converted first.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4727 | franek | 2012-10-25 14:37:40 +0200 (Thu, 25 Oct 2012) | 34 lines

 
   folder :  src/commonSource

    Bug fixed
    ---------
    
    class 'ParOperand'  all the private data has to be initialised in
        the class constructor.


   folder : src/stateManager
   
 
  class 'SetIns' (setins.hxx & .cxx)
  
  a) Bug fixed in private function 'evalExpr_str'. When two strings are added
     together, the end string of the first string and beginning string of
     the second string have to be removed.
     
  b) some type mixing is now allowed when performing parameter operations:
  
      int,float  --> int converted to float and the result is float
      int,string --> if str reopresents int, then it is converted to
                     int and the result is int
		    
  c) some type mixing allowed between the resulting parameter and the result of
      the operation:
      
      Res Par     Result
        int        float    float converted to int (i.e. truncated)
	int        str      if str represents integer then it is converted
	float      int      int converted to float
	str        int      int converted to str

------------------------------------------------------------------------
------------------------------------------------------------------------
r4723 | franek | 2012-09-26 12:48:07 +0200 (Wed, 26 Sep 2012) | 2 lines

commiting main History file

------------------------------------------------------------------------
------------------------------------------------------------------------
r4722 | franek | 2012-09-26 12:43:37 +0200 (Wed, 26 Sep 2012) | 2 lines

 commiting modified version and History files for v46r1 tag

------------------------------------------------------------------------
=== 26-September-2012:12:33 ==========  v46r1  =================

 modified version and History files for the new tag
------------------------------------------------------------------------
r4721 | clara | 2012-09-25 17:17:52 +0200 (Tue, 25 Sep 2012) | 2 lines

necessary changes in Visual folder

------------------------------------------------------------------------
------------------------------------------------------------------------
r4718 | franek | 2012-09-12 14:06:26 +0200 (Wed, 12 Sep 2012) | 18 lines

 
   folder :  src/commonSource

  Bug Fixed:  paroperand.cxx  ... not enough space reserved in 'typevch' aray.
  
   folder : src/stateManager
   
 
  -  state_manager.cxx - State Manager version and diagnostic level are always
         printed. Some other prints removed.
	 
  -  smpcondtype4.cxx  -  when comparing floating point numbers,
                          operators  ==   and  <>  are also allowed
			  
  -  setins.cxx  -  'snprintf'  calls replaced  by 'sprintf'. This is because
                    Windows do not support the call. It almost certainly is not
		    needed anyway.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4714 | franek | 2012-08-31 11:32:29 +0200 (Fri, 31 Aug 2012) | 20 lines


=== 31-August-2012:11:18 ==========  v46r0  =================

            Bug fix and preps for tagging
            -----------------------------
 - rare BUG fixed
  
   folder :  src/stateManager
   
   class 'IfIns'   method 'reportingObjectRemovedFromSet'
   
   The situation which I thought could not arrise and so when it did I aborted
   the program, can arrise. Only warning is now printed.
   It happens when an object is inserted into a SET and then subsequently
   removed from the same SET during an execution of the relevant IF instruction.
   NB: Relevant IF is the one having the SET in one of its conditions.
   
  - in preparation for tagging, version and History files were modified with
    tag v46r0 (4600)

------------------------------------------------------------------------
------------------------------------------------------------------------
r4713 | franek | 2012-08-14 15:56:03 +0200 (Tue, 14 Aug 2012) | 17 lines


   Finished the development of extension of SET instruction.
   --------------------------------------------------------
   folder  src/commonSource
   
    a small bug fixed in function 'getValue'   file:utilities.cxx
   
 
 folder   src/stateManager

 
   class 'SetIns'
   
       a) implemented 'evalExpr_str' and 'evalExpr_float'
       
       b) some diagnostic prints put under debugging switch

------------------------------------------------------------------------
------------------------------------------------------------------------
r4712 | franek | 2012-08-13 14:02:57 +0200 (Mon, 13 Aug 2012) | 19 lines


   Continuing development of extension of SET instruction.
   ------------------------------------------------------
 
 folder   src/stateManager
  
   class 'SMIObject'
         new method:  'setObjectParameter(const Name& name, const Name& value)'
	 
   class 'SetIns'
        a) 3 new methods declared:
	 
	 'evalExpr_str(Name& value1, Name& value2, Name& res)'  not implemented
	 'evalExpr_int(Name& value1, Name& value2, Name& res)'
	 'evalExpr_float(Name& value1, Name& value2, Name& res)'  not implemented
	 'setLeftOperand( Name& value)'
	 
	b) method 'execute'   finished coding

------------------------------------------------------------------------
------------------------------------------------------------------------
r4711 | franek | 2012-08-09 14:27:13 +0200 (Thu, 09 Aug 2012) | 19 lines


   Continuing development of extension of SET instruction.
   ------------------------------------------------------
 
 folder   src/stateManager
 
  
  class 'SetIns'
  
    - new private function
    
       'int getOperandValue(...' which is an identical copy of the one in
           SmpCondTyp4
	 
   - function 'execute'
        added some of the code for processing the new type (10). At the moment
	it just retrieves the values of the two operands without any
	calculation. The instruction will have no effect.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4710 | franek | 2012-08-09 12:03:03 +0200 (Thu, 09 Aug 2012) | 24 lines


   Continuing development of extension of SET instruction.
   ------------------------------------------------------
   
   It will allow:
   
   SET 'left operand' = 'operand1' 'operator' 'operand2'
   
   e.g.  A = B + OBJ.C
 
  folder src/stateManager
   
   class 'SetIns'
   
     - new private data:
     
         ParOperand _lOperand;
	 ParOperand _operand1;
	 ParOperand _operand2;
	 Name _operator;   

    - extended the constructor to process the new type (type 10)
       SET instruction

------------------------------------------------------------------------
------------------------------------------------------------------------
r4709 | franek | 2012-08-07 16:12:36 +0200 (Tue, 07 Aug 2012) | 31 lines


   FINAL development of Simple Condition Type 4
   ----------------------------------------------
   
   folder src/commonSource

  class 'ParOperand' : new public method 'void thisObjPar()'
     it will change operandType to COMPNAME  and set ownerObjName to THIS.
     Use with caution!
     
	Files modified: paroperand.hxx & .cxx   
   
  folder src/stateManager
 
    class 'SmpCondTyp4'
    
        1) 3 new private methods:
	
	    bool compare_str( Name& v1, Name& v2, int& er);
	    bool compare_int( Name& v1, Name& v2, int& er);
	    bool compare_float( Name& v1, Name& v2, int& er);
	    
	 they compare the values in v1 and v2 using the _operator. If anything
	 goues wrong, er is non-zero.
	 
	2) public method 'int evaluate()' implemented
	     
	     Files modified: smpcondtyp4.hxx  &.cxx
	
   ----  This should finish Type 4 condition development  ------------

------------------------------------------------------------------------
------------------------------------------------------------------------
r4708 | franek | 2012-07-31 17:43:59 +0200 (Tue, 31 Jul 2012) | 30 lines


   Further development of Simple Condition Type 4
   ----------------------------------------------
   
   folder src/commonSource

   class 'ParOperand' : 4 new public methods to retrieve the private data.
   
   	Name& valueType();  Name& value(); Name& parName(); and
	                                   Name& ownerObjName();
	Files modified: paroperand.hxx & .cxx   
   
  folder src/stateManager
 
     class 'SmpCondTyp4'
     
          new private method 
	     'int getOperandValue(ParOperand& operand, name& value, Name& type)'
	     
	     Given operand, it returns its value and type.
	        - if the operand type is VALUE, it is trivial
		- if operand is parameter name, it returns the current value of
		  the parameter of the current action if such parameter exists.
		  If not, it returns value of the object parameter. If that
		  does not exist either, it returns failure (0).
		- if the operand is composite name, ie. object-name.par-name,
		  it returns value of the parameter par-name of object obj-name.
	     
	     Files modified: smpcondtyp4.hxx  &.cxx

------------------------------------------------------------------------
------------------------------------------------------------------------
r4707 | franek | 2012-07-25 16:13:39 +0200 (Wed, 25 Jul 2012) | 59 lines


   Further development of Simple Condition Type 4
   ----------------------------------------------
  folder src/stateManager
  
   - class 'SMIObject'   new method 'getObjectParameter'
       (files: smiobject.hxx &cxx)
   
   - class 'Action'     new method 'getObjectParameter'
       (files: action.hxx &cxx)
	 
   - method 'evaluate' of class 'SmpCondTyp4' needs info about its
      parents (object, state, action). In order to supply this info the
      folowing 4 modifications were made:
      
   1) class  'IfIns'  (files:  ifins.hxx & cxx)
   
       A) new private data:
               State*  _pParentState  (the other 2 are already there)
	       
       B) the constructor stores the extra pointer. (it was already supplied)
       
       C) supplies these 3 pointers to the constructor of 'Condition' class.
       
	       
   
   2) class  'When'   (files:  when.hxx & cxx )
  
       A) new private data:
               State*  _pParentState  (_pParentObject was already there
	                               and parent action is meaningless)
	       
       B) the constructor stores the extra pointer. (it was already supplied)
				       
       
       C) supplies the 3 parent pointers to the constructor of
          'Condition' class. Pointer to parent action is supplied as zero.
				       
   
   3) class 'Condition'   (files condition.hxx & cxx)
         A) new private data:
                SMIObject* _pParentObject
		State*     _pParentState
	        Action*    _pParentAction
			 
         B) the constructor accepts the 3 pointers and stores them
	 
	 C) supplies these pointers to the constructor of  'SmpCondTyp4'
   
   
   
   4) class  'SmpCondTyp4'  (files: smpcondtyp4.hxx & cxx)
         A) new private data:
                SMIObject* _pParentObject
		State*     _pParentState
	        Action*    _pParentAction
			 
         B) the constructor accepts the 3 pointers and stores them

------------------------------------------------------------------------
------------------------------------------------------------------------
r4706 | franek | 2012-07-20 14:14:07 +0200 (Fri, 20 Jul 2012) | 10 lines


   Further development of Simple Condition Type 4
   ----------------------------------------------
   
   State Manager  recognizes the type and initialises it. 
    - Changes in condition.cxx, smpcondtyp4.hxx & cxx
    
    At the moment what remains is implementation of 'evaluate'
    method in 'SmpCondTyp4' class. The result now is 'ghost'.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4705 | franek | 2012-07-19 13:21:22 +0200 (Thu, 19 Jul 2012) | 11 lines


			
      Moved definition of class 'ParOperand' from translator to commonSource
      ----------------------------------------------------------------------
   
    - files paroperand.cxx & .hxx moved from src/translator to 
                                             src/commonSource
   
    - makefile_translator &  makefile_stateManager  modified to take the above
       move into account

------------------------------------------------------------------------
------------------------------------------------------------------------
r4704 | franek | 2012-07-18 15:13:29 +0200 (Wed, 18 Jul 2012) | 36 lines


			
    - Further development of Simple Condition Type 4
      ----------------------------------------------
   folder   src/translator
  
   -  smpcondtyp4.hxx
         changed 'const int _type' to 'enum {_type = 4 }'
	 
   -  smpcondtyp4.cxx
   
      1) above change taken into account
      
      2) some unused declarations removed, some diagnostic prints removed
          and other tydiing.
      
      3) method 'outSobj' implemented
      
   -  paroperand.hxx & .cxx
   
      two new methods for initialisation from 'sobj' code:
      
      1) 'initFromSobj_firstLine'
      2) 'initFromSobj_nextLine'
      
      These will be used in State Manager
      
    folder    src/stateManager
    
  
    - new class 'SmpCondTyp4' for testing on parameter values
       -> two new files smpcondtyp4.hxx * .cxx at this moment it does nothing
       
    - condition.cxx recognises the new class and calls the appropriate
                    constructor, which at the moment is just dummy.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4663 | franek | 2012-04-02 15:18:23 +0200 (Mon, 02 Apr 2012) | 29 lines


			
    - Further development of SET instruction
      --------------------------------------
   folder   src/translator
   
   - setins.hxx  
       In order to make SET instruction to resemble Condition so that it would
       be relatively easy to upgrade it to general arithmetic expression,
       I added 2 integers to protected data:
   
       _numOperands   at the moment it is either 1 or 2 (this is like number
                      of simple conditions in the case of Condition class)
       _numOperations at the moment 0 or 1 	
   
    - paroperand.hxx
        declaration of new function 'void outSobj(ofstream&)'
   
     - paroperand.cxx
     
       1) some diagnostic prints removed
       2)code for new function 'void outSobj(ofstream&)'
	
     - setins.cxx

       1) some diagnostic prints removed
       2) 'outSobj' method modified: added code for the new type (10)
	  SET instruction

------------------------------------------------------------------------
------------------------------------------------------------------------
r4661 | franek | 2012-03-26 14:01:20 +0200 (Mon, 26 Mar 2012) | 18 lines

    - Bug fixed in src/commonSource/utilities.cxx in the new function
                        'check_compname'
			
    - Further development of SET instruction
      --------------------------------------
      
      folder  src/translator
      
        - class 'ParOperand'   new public function 'operandType()' retrieving
                            the type.
	  files: paroperand.cxx  & .hxx 
	  
        - 'newCode' private function in 'SetIns' class has been developped
	   and it now parses the new type SET instruction. This is given
	   _insType = 10.
	   The old type (1,2 and 3) is parsed by the old code for backward
	   ccompatibility safety.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4659 | franek | 2012-03-12 13:11:26 +0100 (Mon, 12 Mar 2012) | 28 lines

  
    More development of Simple condition Type 4
    -------------------------------------------
    
    folder   src/commonSource
    
        - file 'utilities.cxx & hxx'
         1) new function: 'check_compname' checks for composite names
         2) function  'getValue'   uses the new function
    
    folder  src/translator
    
    Files modified:   smpcondtyp4.cxx   and   paroperand.cxx
      
     - paroperand.cxx  class ParOperan now handles composite names operands
       Parsing of the simple condition typ4 is now finished. However before
       I complete it, i.e sobj output, I will do parsing of SET instruction:
     
   Development of SET instruction
   ------------------------------
   
     - setins.hxx  & setinc.cxx
     
        new data structure added in addition to the existing one and
	new private function 'newCode' which is called just after SET keyword
	was found. At the moment it does not do anything and should not
	affect existing working of the program.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4658 | franek | 2012-02-24 12:51:07 +0100 (Fri, 24 Feb 2012) | 17 lines


   Continuing the new Simple Condition Type(4) for parameter testing
   -----------------------------------------------------------------
   
   folder   src/translator

    - some development in 'smpcondtyp4.cxx'     not fully working yet
    
    - dtto  for  'paroperand.cxx'
    
    folder   src/commonSource
    
    - file 'utilities.cxx'  function  'getValue'
    
     Bug fixed for the case when string constant value has 'blank' as the
     only delimitersvn status

------------------------------------------------------------------------
------------------------------------------------------------------------
r4657 | franek | 2012-02-22 15:56:23 +0100 (Wed, 22 Feb 2012) | 14 lines


   Continuing the new Simple Condition Type(4) for parameter testing
   -----------------------------------------------------------------
   
   folder   src/translator
   
    - new class 'ParOperand'. This contains  either
       1) simple parameter value    or
       2) simple parameter name   or
       3) composite parameter name    obj-name.par-name   or obj-name<par-name>
      2 files paroperand.hxx ( & .cxx)

    - some development in smpcondtyp4.hxx & .cxx    not working yet

------------------------------------------------------------------------
------------------------------------------------------------------------
r4654 | franek | 2012-01-26 16:04:38 +0100 (Thu, 26 Jan 2012) | 15 lines


   First Shot at the new Simple Condition Type(4) for parameter testing
   -----------------------------------------------------------------
   
   folder   src/translator
   
    
   - new class 'SmpCondTyp4'. Simple condition for parameter testing
      2 new files   smpcondtyp4.hxx (&cxx). At the moment they are not
       doing anything.
   -  condition.cxx
      a)  bug fixed  "NOT_EMPTY" replaced by temp == "NOT_EMPTY"
      b)  Condition class recognises the new simple condition type
          and takes it properly into account.

------------------------------------------------------------------------
=== 20-January-2012:14:16 ==========  v45r1  =================
------------------------------------------------------------------------
r4649 | franek | 2012-01-20 14:10:54 +0100 (Fri, 20 Jan 2012) | 5 lines


 - Bug fix in src/rtl/smiuirtl.c
 
 - some files in 'Visual' subfolder updated to comply with recent developments.

------------------------------------------------------------------------
=== 15-December-2011:15:36 ==========  v45r0  =================
------------------------------------------------------------------------
r4643 | franek | 2011-12-15 15:27:20 +0100 (Thu, 15 Dec 2011) | 17 lines


  
                       Unlocked IFs
	       Option '-u' on smiSM command
               ----------------------------
	       
     This option will alter IF processing: IF's objects, instead of being locked
     for the whole duration of IF, are released as soon as IF's conditions are
     evaluated.
     
     Files modified:
     
     - state_manager.cxx 
     - processcommandline.cxx
     
     - ifins.cxx:  Class 'IfIns'   method 'execute'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4638 | franek | 2011-11-29 16:14:12 +0100 (Tue, 29 Nov 2011) | 3 lines


  modified version and History files with v44r0 tag

------------------------------------------------------------------------
=== 29-November-2011:16:00 ==========  v44r0  =================
------------------------------------------------------------------------
r4637 | franek | 2011-11-29 15:31:22 +0100 (Tue, 29 Nov 2011) | 54 lines

        Bug fixes
	---------
   - smixx/smiuirtl.h   fix to do with BIT64 architecture
   
   - src/rtl/smiuirtl.c  bug fixed in 'int get_param_value'
   
    
        New IF instruction handling (ala WAIT instruction)
        ---------------------------------------------------
       The following changes will switch IF handling to the new way
       
	 (  folder  src/stateManager )
     
     - 'IfIns'  method 'execute()'
         - instead of calling the old 'unlockObjects()', the new
	 'unlockLockedObjects()' is used.
	 
         - case fresh (fresh IF instruction)
	    a) instead of the old 'lockObjects()', the new
	    'attemptToLockObjects()' method is called that builds two lists:
	        _lockedObjects   and  _objectsWaitingForLock
	    b) if there are objects waiting for lock, then instead of informing
	       'ifHandler', it will call 'registerSuspendedObject' method of
	       resumeHandler.
	    
     -  'SMIObject' class
            method 'execute()'
	       when the locking (&lock) action arrives, ifHandler is not
	       informed about it anymore. This is reported directly to the
	       object requesting the lock (see below)
	       
	   method 'reportingLockedObject'
	       it will call method of the same name of the suspended IF.
	       If all the objects of IF are locked, it will inform resumeHandler
	       that the object is ready to resume.
	       This was before allowed only for WAIT instruction 
	       
   
     -  'SMIObjectSetSimple' class  method 'remove'
                                when object is removed from set, this is no
				longer reported to ifHandler. It is reported to
				resumeHandler instead.
				
     -  'SMIObjectSetUnion'  class  method 'removedObjectFromOneOfYourSets'
                                when object is removed from set, this is no
				longer reported to ifHandler. It is reported to
				resumeHandler instead.
   
    - 'SMIObject' class  method 'reportingObjectRemovedFromSet'
    
          this is called by resumeHandler for all suspended objects when 
	  an object is removed from a set. This will now call method of the
	  same name of class 'IfIns'

------------------------------------------------------------------------
------------------------------------------------------------------------
r4633 | franek | 2011-11-09 16:08:10 +0100 (Wed, 09 Nov 2011) | 28 lines

    
       Preparation for new IF instruction handling (ala WAIT instruction)
       ------------------------------------------------------------------
       None of the changes should affect working of the program YET.
       
	 (  folder  src/stateManager )
   
      IfIns  class:
      
         - two new private methods: 
	     1)'attemptToLockObjects()' and  2) 'unlockLockedObjects()'
	     
	 - two new public methods:
	 
	     1) 'reportingLockedObject(Name&)
	     The usage will be as follows: when locking action is executed
	     on an object, this object informs its client (the object that
	     requested the lock). The client in turn informs its IF instruction
	     by calling the new method.
	     
	     2) 'reportingObjectRemovedFromSet(Name& obj, Name& set)'
	     The future usage: 
	     when an object is removed from a set, all suspended objects are
	     informed by 'resumeHandler'. Each of them then calls this new
	     method for its suspended IF to take necessary action (if any).
	     
	 - more diagnostic prints in 'execute' method.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4632 | franek | 2011-10-28 14:28:55 +0200 (Fri, 28 Oct 2011) | 41 lines

            FATAL BUG fixed
	    ---------------
    In 'InsList' class (folder src/stateManager). 
    This was recently introduced in r4562 and stopped any IF that
    had to be suspended from working. 
    
       Preparation for new IF instruction handling (ala WAIT instruction)
       ------------------------------------------------------------------
       None of the changes should affect working of the program YET.
       
	 (  folder  src/stateManager )
     
    - Condition  class : new method
    		'getCurrentRefObjects(NameList& currRefObjects)'
		will get list of objects that are currently referenced by
		the condition, directly or indirectly through Object Sets.
    
    - IfIns   class
    
    	a) 3 new private data all of them type 'NameList':
	    _refObjectsAtStartExecution  ... holds list of objects referenced
	                      by IF's condition at the start of it's execution.
	    _lockedObjects 
	    _objectsWaitingForLock
	    
	b) new private method 'getCurrentRefObjects()'  ... fills in the above
	    private list
	    
	c) method 'execute()
	   at the begining of execution of IF it calls the above new private
	   method.

    
    - TermIns  class :  improved diagnostic prints


	 (  folder  src/commonSource )
	 
    - Class NameList    new method  'add(NameList& list)' - will add the items
              from list unless already present.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4631 | franek | 2011-10-18 14:56:59 +0200 (Tue, 18 Oct 2011) | 12 lines

         Continuing tidying up IF instruction handling
         ---------------------------------------------
	 (  folder  src/stateManager )
	 
   - IfIns class : method 'execute':
   			
   		The three sections of code dealing with execution of 'true'
		instruction block were replaced by
		 'goto executeInstructionBlock;' statement and
		the single version of the code itself was placed at the end
		of the method and labeled executeInstructionBlock:

------------------------------------------------------------------------
------------------------------------------------------------------------
r4630 | franek | 2011-10-14 13:57:41 +0200 (Fri, 14 Oct 2011) | 18 lines

         Continuing tidying up IF instruction handling
         ---------------------------------------------
	 (  folder  src/stateManager )
	 
   - IfIns class : method 'execute':
   			
		     a) removed unnecessary freezing and unfreezing of IF's
		     conditions. Once conditions are evaluated they can be
		     unfrozen untill the IF is executed again from scratch.

                     b) renamed local variable 'returnStat' to 'blockReturnStat'
		        as in all cases it is the return status of the last
			instruction executed in an instruction block (list).
		     
		     c) added a few redundant lines of code to make three
		        sections of code,dealing with execution of 'true'
			instruction block, identical.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4582 | franek | 2011-09-16 14:44:03 +0200 (Fri, 16 Sep 2011) | 11 lines

         Continuing tidying up IF instruction handling
         ---------------------------------------------
	 (  folder  src/stateManager )
	 
   - IfIns class : method 'execute':
                     a) converted the main 'if-else' construct into 'switch'.
		        This is much clearer.
		       
		     b) improved spacing and general appearance of the code.
		        When comparing differences, '-b' option should be used

------------------------------------------------------------------------
------------------------------------------------------------------------
r4562 | franek | 2011-09-05 15:52:08 +0200 (Mon, 05 Sep 2011) | 23 lines

		 Tydying up execution of If instruction
		 -------------------------------------- 
		 (the changes in src/stateManager folder)
 
   -  new file : instruction_return_status.hxx
            header file holding the definition of 'InstructionReturnStatus_t'
	    enum type. This the return status of any SMI instruction and the
	    type provides for better clarity.
	    
   - class InsList : method 'execute':
                     a) returns type 'InstructionReturnStatus_t' instead of int
		     b) the code tydied up using the new type.
		     NB: as most instruction still return 'int', their return
		         is cast into the new type.
			 
  
   - class IfIns :  1) private data _suspend_flag was made enum type for better
                       clarity.

                    2) method 'execute' :
		     a) returns type 'InstructionReturnStatus_t' instead of int
		     b) the two new enum types are used inster of ints

------------------------------------------------------------------------
------------------------------------------------------------------------
r4513 | franek | 2011-07-28 14:32:22 +0200 (Thu, 28 Jul 2011) | 2 lines

This will be tagged v43r0

------------------------------------------------------------------------
=== 28-July-2011 ========== Tag: v43r0  ========================
------------------------------------------------------------------------
r4512 | franek | 2011-07-27 16:32:10 +0200 (Wed, 27 Jul 2011) | 2 lines

modification to taggingProcedure: different format of the top History file
 and no more updating README. Also modification to History and version
 files in preparation for the new tag.
------------------------------------------------------------------------
------------------------------------------------------------------------
r4509 | franek | 2011-07-26 15:54:29 +0200 (Tue, 26 Jul 2011) | 35 lines

   
    Implementation of SLEEP instruction in State Manager
    ----------------------------------------------------
     ( all changes in src/stateManager )
    
    - New class  'SleepIns'    two new files sleepins.hxx and sleepins.cxx
  
    - new class 'SleepInsTimer' two new files sleepinstimer.hxx and .cxx
             .... timer object used by 'SleepIns' class    

    - class  'InsList'  (inslist.cxx) now processes SLEEP instruction.

  
    - class SMIObject  (smiobject.hxx and cxx)
          a) new private data   SleepIns*  _pointerToSuspendedSLEEP
	  
          b) new method  'void setPointerToSuspendedSLEEP(SleepIns*)'
  
          c) method 'resume()'
             - private data connected with suspension reset
             - added diagnostic print
    
    - logic_engine.cxx ...  there is now a new source of asynchronous events
           i.e. timer events from SLEEP instruction. They affect the contents
	    of Resume Queue and so we have to have an extra check on it.

    - waitins.cxx   minor improvements to debug prints
     
    Added a few additional header files to pacify some picky compilers in:
    ----------------------------------------------------------------------
	 
       src/translator/waitins.cxx
       src/utilities/tellMonObjects.cxx and
       src/utilities/tclTkGUI-Builder.cxx

------------------------------------------------------------------------
------------------------------------------------------------------------
r4494 | franek | 2011-07-13 16:30:36 +0200 (Wed, 13 Jul 2011) | 26 lines

When object is 'locked', it reports this directly to the client object
rather then going via 'ResumeHandler' object. Also, it is now the responsibility
of the object that is ready to resume execution to inform 'ResumeHandler' about
this fact.
At the moment this relates only to WAIT handling.
  
 - class 'ResumeHandler' :
         a) new method 'void objectReadyToResume( Name& objName )'
            this deregisters object from suspended objects list and puts it
            on 'ready to resume Q'
	    
	 b) the obsolete method 'reportingLockedObject' removed.
  
	 
     - class 'SMIObject'  (file smiobject.cxx & hxx) 
          a) method 'execute'
           when &lock action is received and the object is locked, this is
	   now reported directly to the client object (the one requesting
	   the lock), instead of to the ResumeHandler.
	   
	  b) new method 'void reportingLockedObject(Name& lockedObject)'
	     used by locked object to inform the client object.

          c) the old method 'int reportingLockedObject(Name& lockedObject)'
	     removed.

------------------------------------------------------------------------
------------------------------------------------------------------------
r4492 | franek | 2011-07-05 15:55:13 +0200 (Tue, 05 Jul 2011) | 20 lines

- new script 'updateHistory'. It will pick up the latest commited
  log from svn and put it at the Head of History file.

 The following changes are all in src/stateManager folder:
   
- new method in ResumeHandler class :  'isResumeQueueEmpty()'.
    
- replaced DISABLE_AST by dim_lock()     and  ENABLE_AST by dim_unlock()
   in commhandler.cxx, queue_name.cxx, queue_twonames.cxx and 
           smpcondtyp2.cxx
   
- resumehandler.hxx   added dim locking to 'resumeReadyToResumeObjects()   

- scheduler.cxx   resuming objects is taken out of executableObjectQ loop
        and placed outside. This way all the queues are handled in a similar
	way. The only difference is that the loop over the resume Q is inside
	ResumeHandler method.

- state_manager.cxx  added printing diagnostic level

------------------------------------------------------------------------
------------------------------------------------------------------------
r4491 | franek | 2011-06-29 16:02:37 +0200 (Wed, 29 Jun 2011) | 7 lines

 New  SLEEP instruction. Necessary modifications in 'translator' and
 one file in 'commonSource'
 Format:   SLEEP <integer>
     or    SLEEP $(<par-name>)
     
     e.g.    SLEEP 10              or  SLEEP $(seconds)

------------------------------------------------------------------------
------------------------------------------------------------------------
r4490 | franek | 2011-06-24 15:50:51 +0200 (Fri, 24 Jun 2011) | 14 lines

- fixed compiler warnings in src/generator/generator.c

- modified the following makefiles to use the common make file 'makefile_common'
  which was taken over from dim package with minor modifications :
  
  makefile_preprocessor, makefile_generator, makefile_translator,
  makefile_rtl, makefile_stateManager and makefile_utilities
  
  NB: makefile_gui was kept the same to avoid copious warnings. Some of these
      are tricky and might require a minor re-design.
      
NB: There is one compiler warning left in 'preprocessor'. This could be a bug
    and should be addressed later.

------------------------------------------------------------------------
r4459 | franek | 2011-03-24 16:25:04 +0100 (Thu, 24 Mar 2011) | 2 lines

fixed compiler warnings in src/rtl/smiuirtlcpp.cxx and  src/rtl/smi_kill.c

------------------------------------------------------------------------
r4458 | franek | 2011-03-23 16:28:59 +0100 (Wed, 23 Mar 2011) | 2 lines

fixed compiler warnings in src/rtl/smirtlcpp.cxx and src/rtl/smiuirtl.c

------------------------------------------------------------------------
r4457 | franek | 2011-03-22 15:45:54 +0100 (Tue, 22 Mar 2011) | 2 lines

fixed compiler warnings in src/rtl/smirtl.c

------------------------------------------------------------------------
r4445 | franek | 2011-03-10 16:16:17 +0100 (Thu, 10 Mar 2011) | 2 lines

 fixed compilation warnings in generator.c related to the return type defaults to 'int'

------------------------------------------------------------------------
r4444 | franek | 2011-03-10 15:08:08 +0100 (Thu, 10 Mar 2011) | 2 lines

 fixed compilation warnings in generator.c related to the absence of parentheses around assignment used as truth value

------------------------------------------------------------------------
r4422 | franek | 2011-02-24 15:26:35 +0100 (Thu, 24 Feb 2011) | 2 lines

fixing compilation warnings in 'utilities'

------------------------------------------------------------------------
r4421 | franek | 2011-02-22 16:56:31 +0100 (Tue, 22 Feb 2011) | 2 lines

fixing compilation warnings in Translator

------------------------------------------------------------------------
r4420 | franek | 2011-02-17 11:35:16 +0100 (Thu, 17 Feb 2011) | 10 lines

File commonsource/utilities.cxx :

 - Bug fixed in function 'process_line_forTrans'. It was uppercasing also
   inside double quotes. As this function is called only from 'getHeader'
   of Condition class in order to generate a comment from condition string,
   it was not very serious. Especially as condition strings do not contain
   any double quotes.

 -fixing a few compilation warnings

------------------------------------------------------------------------
r4419 | franek | 2011-02-17 11:19:33 +0100 (Thu, 17 Feb 2011) | 2 lines

compilation warning fixed

------------------------------------------------------------------------
r4418 | franek | 2011-02-11 15:37:34 +0100 (Fri, 11 Feb 2011) | 2 lines

removing compilation warnings in some of commonSource files

------------------------------------------------------------------------
r4417 | franek | 2011-02-11 15:07:44 +0100 (Fri, 11 Feb 2011) | 2 lines

2 Bugs fixed in commhandler.cxx of State Manager and also some compilation warnings fixed

------------------------------------------------------------------------
r4416 | franek | 2011-02-11 14:49:51 +0100 (Fri, 11 Feb 2011) | 2 lines

 removing more compilation warnings in State Manager

------------------------------------------------------------------------
r4407 | franek | 2011-02-04 15:39:25 +0100 (Fri, 04 Feb 2011) | 2 lines

tagging procedure for v42r1

------------------------------------------------------------------------
