PAutoRunParser.cpp

Go to the documentation of this file.

/********************************************************************************************

  PAutoRunParser.cpp

*********************************************************************************************

    begin                : Andreas Suter, 2006/03/14
    modfied:             :
    copyright            : (C) 2006 by
    email                : andreas.suter@psi.ch

********************************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <cmath>
#include <iostream>

#include <QFile>
#include <QString>
#include <QStringList>
#include <QRegExp>
#include <QTextStream>
#include <QList>

#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/sax2/SAX2XMLReader.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>
#if defined(XERCES_NEW_IOSTREAMS)
#include <fstream>
#else
#include <fstream.h>
#endif
#include <xercesc/util/OutOfMemoryException.hpp>

#include "lemAutoRun.h"
#include "PAutoRunParser.h"

//*******************************************************************************************************
//  implementation of the constructor
//*******************************************************************************************************
PSAX2AutoRunParseHandler::PSAX2AutoRunParseHandler(PAutoRunParser *arp)
{
  fArp = arp; // keep pointer of the calling class

  // init class variables
  fFlnAutoRunSeq = "";
  fCurrentUserLineNo = 0;

  fKey    = eEmpty;
  fCmdKey = eEmpty;

  // get pointer to the auto run sequence vector
  fAutoRunCmdVector = fArp->GetAutoRunCmdVector();

  // clear local auto run command structure (single instruction)
  ClearAutoRunCmd();

  // initialize ODB tag
  fOdbTag.tag = QString("");
  fOdbTag.odb_path = QString("");
  fOdbTag.idx = -1;

  fLoopNo = 0; // loop counter, needed for loops in loops ...

  fFatalError = false;
}

//*******************************************************************************************************
//  implementation of the destructor
//*******************************************************************************************************
PSAX2AutoRunParseHandler::~PSAX2AutoRunParseHandler()
{
}

//*******************************************************************************************************
//  implementation of the startDocument
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::startDocument()
{
}

//*******************************************************************************************************
//  implementation of the startElement
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::startElement(const XMLCh *const uri, const XMLCh *const localname,
          const XMLCh *const qname, const Attributes &attrs)
{
  if (fFatalError)
    return;

  XMLLoopInfo loopInfo;

  if (uri) {}      // in order to suppress compiler warnings
  if (localname) {}  // in order to suppress compiler warnings
  if (attrs.getLength()) {} // in order to suppress compiler warnings

  // translate keyword to QString for simpler handling
  QString qName = QString(XMLString::transcode(qname));

  // filter (command) key words
  if (qName == "autoRunName") {
    fKey = eFln;
  } else if (qName == "line") {
    fKey = eLineNo;
  } else if (qName == "cmd_str") {
    fKey = eCmdStr;
  } else if (qName == "comment") {
    fCmdKey = eComment;
    fAutoRunCmd.cmd = "comment";
  } else if (qName == "alias") {
    fCmdKey = eAlias;
    fAutoRunCmd.cmd = "alias";
  } else if (qName == "ignore_alarms") {
    fCmdKey = eIgnoreAlarms;
    fAutoRunCmd.cmd = "ignore_alarms";
  } else if (qName == "ignore_clients") {
    fCmdKey = eIgnoreClients;
    fAutoRunCmd.cmd = "ignore_clients";
  } else if (qName == "setBPV") {
    fCmdKey = eBPV;
    fAutoRunCmd.cmd = "setBPV";
  } else if (qName == "odbTag") {
    fCmdKey = eOdbTag;
    fAutoRunCmd.cmd = "odbTag";
  } else if (qName == "setOdbData") {
    fCmdKey = eSetOdbData;
    fAutoRunCmd.cmd = "setOdbData";
  } else if (qName == "setOdbDataArray") {
    fCmdKey = eSetOdbDataArray;
    fAutoRunCmd.cmd = "setOdbDataArray";
  } else if (qName == "setTemp") {
    fCmdKey = eSetTemp;
    fAutoRunCmd.cmd = "setTemp";
    fAutoRunCmd.noElements = 9;
  } else if (qName == "setTfl") {
    fCmdKey = eSetTfl;
    fAutoRunCmd.cmd = "setTfl";
  } else if (qName == "setSampleHV") {
    fCmdKey = eSetSampleHV;
    fAutoRunCmd.cmd = "setSampleHV";
  } else if (qName == "setRA_HV") {
    fCmdKey = eSetRA_HV;
    fAutoRunCmd.cmd = "setRA_HV";
  } else if (qName == "setTransportHV") {
    fCmdKey = eSetTransportHV;
    fAutoRunCmd.cmd = "setTransportHV";
  } else if (qName == "setHVOff") {
    fCmdKey = eSetHvOff;
    fAutoRunCmd.cmd = "setHVOff";
  } else if (qName == "setFieldWEWL") {
    fCmdKey = eSetFieldWEWL;
    fAutoRunCmd.cmd = "setFieldWEWL";
  } else if (qName == "setFieldWEWH") {
    fCmdKey = eSetFieldWEWH;
    fAutoRunCmd.cmd = "setFieldWEWH";
  } else if (qName == "setFieldDanfysik") {
    fCmdKey = eSetFieldDanfysik;
    fAutoRunCmd.cmd = "setFieldDanfysik";
  } else if (qName == "setField") {
    fCmdKey = eSetField;
    fAutoRunCmd.cmd = "setField";
  } else if (qName == "setSpinRot") {
    fCmdKey = eSetSpinRot;
    fAutoRunCmd.cmd = "setSpinRot";
  } else if (qName == "setFOM") {
    fCmdKey = eSetFOM;
    fAutoRunCmd.cmd = "setFOM";
  } else if (qName == "setTitle") {
    fCmdKey = eSetTitle;
    fAutoRunCmd.cmd = "setTitle";
  } else if (qName == "setTOF") {
    fCmdKey = eSetTOF;
    fAutoRunCmd.cmd = "setTOF";
  } else if (qName == "setModInfo") {
    fCmdKey = eSetModInfo;
    fAutoRunCmd.cmd = "setModInfo";
  } else if (qName == "setLEMSetup") {
    fCmdKey = eSetLEMSetup;
    fAutoRunCmd.cmd = "setLEMSetup";
  } else if (qName == "setWait") {
    fCmdKey = eSetWait;
    fAutoRunCmd.cmd = "setWait";
  } else if (qName == "setDump") {
    fCmdKey = eSetDump;
    fAutoRunCmd.cmd = "setDump";
  } else if (qName == "runStart") {
    fCmdKey = eRunStart;
    fAutoRunCmd.cmd = "runStart";
  } else if (qName == "runStop") {
    fCmdKey = eRunStop;
    fAutoRunCmd.cmd = "runStop";
  } else if (qName == "warmUp") {
    fCmdKey = eWarmUp;
    fAutoRunCmd.cmd = "warmUp";
  } else if (qName == "degaussWEW") {
    fCmdKey = eDegaussWEW;
    fAutoRunCmd.cmd = "degaussWEW";
  } else if (qName == "degaussDanfysik") {
    fCmdKey = eDegaussDanfysik;
    fAutoRunCmd.cmd = "degaussDanfysik";
  } else if (qName == "degaussMagnet") {
    fCmdKey = eDegauss;
    fAutoRunCmd.cmd = "degaussMagnet";
  } else if (qName == "degaussSpinRot") {
    fCmdKey = eDegaussSpinRot;
    fAutoRunCmd.cmd = "degaussSpinRot";
  } else if (qName == "comment_line") {
    fKey = eCommentLine;
  } else if (qName == "alias_key") {
    fKey = eAlias_key;
  } else if (qName == "alias_value") {
    fKey = eAlias_value;
  } else if (qName == "loop") {
    fCmdKey = eLoop;
    fLoopNo++;
    fLoopInfoVector.push_back(loopInfo);
  } else if (qName == "loopList") {
    fCmdKey = eLoopList;
  } else if (qName == "loopElement") {
    fKey = eLoopElement;
  } else if (qName == "loopIterator") {
    fCmdKey = eLoopIterator;
  } else if (qName == "loopStart") {
    fKey = eLoopStart;
  } else if (qName == "loopStop") {
    fKey = eLoopStop;
  } else if (qName == "loopStep") {
    fKey = eLoopStep;
  } else if (qName == "loopSetTemp") {
    fCmdKey = eLoopSetTemp;
    fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetTemp";
    fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
  } else if (qName == "loopTempTag") {
    fKey = eLoopTempTag;
  } else if (qName == "loopSetSampleHV") {
    fCmdKey = eLoopSetSampleHV;
    fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetSampleHV";
    fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
  } else if (qName == "loopSampleHVTag") {
    fKey = eLoopSampleHVTag;
  } else if (qName == "loopSetFieldWEWL") {
    fCmdKey = eLoopSetFieldWEWL;
    fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetFieldWEWL";
    fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
  } else if (qName == "loopSetFieldWEWH") {
    fCmdKey = eLoopSetFieldWEWH;
    fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetFieldWEWH";
    fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
  } else if (qName == "loopSetFieldDanfysik") {
    fCmdKey = eLoopSetFieldDanfysik;
    fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetFieldDanfysik";
    fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
  } else if (qName == "loopSetField") {
    fCmdKey = eLoopSetField;
    fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetField";
    fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
  } else if (qName == "loopFieldTag") {
    fKey = eLoopFieldTag;
  } else if (qName == "set_path") {
    fKey = eOdbSetPath;
  } else if (qName == "set_index") {
    fKey = eOdbSetIndex;
  } else if (qName == "set_value") {
    fKey = eOdbSetValue;
  } else if (qName == "read_path") {
    fKey = eOdbReadPath;
  } else if (qName == "read_index") {
    fKey = eOdbReadIndex;
  } else if (qName == "timeout") {
    fKey = eOdbTimeout;
  } else if (qName == "tolerance") {
    fKey = eOdbTolerance;
  } else if (qName == "tfl_pos") {
    fKey = eTfl_pos;
  } else if (qName == "tfl_mode") {
    fKey = eTfl_mode;
  } else if (qName == "temp") {
    fKey = eTemp;
  } else if (qName == "deltaT") {
    fKey = eDeltaT;
  } else if (qName == "ramp") {
    fKey = eRamp;
  } else if (qName == "heaterRange") {
    fKey = eHeaterRange;
  } else if (qName == "stabilityTimeout") {
    fKey = eStabilityTimeout;
  } else if (qName == "P_PID") {
    fKey = eP_pid;
  } else if (qName == "I_PID") {
    fKey = eI_pid;
  } else if (qName == "D_PID") {
    fKey = eD_pid;
  } else if (qName == "flow") {
    fKey = eFlow;
  } else if (qName == "hv_value") {
    fKey = eHv_value;
  } else if (qName == "hv_left") {
    fKey = eHv_left;
  } else if (qName == "hv_right") {
    fKey = eHv_right;
  } else if (qName == "hv_top") {
    fKey = eHv_top;
  } else if (qName == "hv_bottom") {
    fKey = eHv_bottom;
  } else if (qName == "transportHvSettingFileName") {
    fKey = eTransportHvSettingFileName;
  } else if (qName == "field_value") {
    fKey = eField_value;
  } else if (qName == "field_unit") {
    fKey = eField_unit;
  } else if (qName == "title") {
    fKey = eTitle;
  } else if (qName == "odb_sample") {
    fKey = eOdb_sample;
  } else if (qName == "odb_temp") {
    fKey = eOdb_temp;
  } else if (qName == "odb_field") {
    fKey = eOdb_field;
  } else if (qName == "odb_transp") {
    fKey = eOdb_transp;
  } else if (qName == "odb_hv_samp") {
    fKey = eOdb_hv_samp;
  } else if (qName == "odb_energy") {
    fKey = eOdb_energy;
  } else if (qName == "odb_ra_diff_lr") {
    fKey = eOdb_ra_diff_lr;
  } else if (qName == "odb_ra_diff_tb") {
    fKey = eOdb_ra_diff_tb;
  } else if (qName == "odb_spin_rot") {
    fKey = eOdb_spin_rot;
  } else if (qName == "start") {
    fKey = eStart;
  } else if (qName == "stop") {
    fKey = eStop;
  } else if (qName == "units") {
    fKey = eUnits;
  } else if (qName == "mod") {
    fKey = eMod;
  } else if (qName == "mod_date") {
    fKey = eMod_date;
  } else if (qName == "setup") {
    fKey = eSetup;
  } else if (qName == "wait") {
    fKey = eWait;
  } else if (qName == "no_events") {
    fKey = eNo_events;
  } else if (qName == "no_dumps") {
    fKey = eNo_dumps;
  } else if (qName == "date") {
    fKey = eDate;
  } else if (qName == "time") {
    fKey = eTime;
  } else if (qName == "vent") {
    fKey = eVent;
  } else if (qName == "current") {
    fKey = eCurrent;
  } else if (qName == "angle") {
    fKey = eAngle;
  } else if (qName == "no_degauss") {
    fKey = eNoDegauss;
  } else if (qName == "chamber") {
    fKey = eChamber;
  } else if (qName == "label") {
    fKey = eLabel;
  } else if (qName == "state") {
    fKey = eState;
  }
}

//*******************************************************************************************************
//  implementation of the characters
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::characters(const XMLCh *const chars, const XMLSize_t)
{
  if (fFatalError)
    return;

  // keep some global information
  QString str("");
  switch (fKey) {
    case eFln:
      fFlnAutoRunSeq = QString(XMLString::transcode(chars));
      break;
    case eLineNo:
      fCurrentUserLineNo = QString(XMLString::transcode(chars)).toInt();
      break;    
    default:
      break;
  }

  if (fCmdKey == eComment) {
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eIgnoreAlarms) {
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eState:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eIgnoreClients) {
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eState:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eAlias) {
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eAlias_key:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eAlias_value:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eBPV) {
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eLabel:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eState:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eOdbTag) {
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eLabel:
        fOdbTag.tag = QString(XMLString::transcode(chars));
        break;
      case eOdbReadPath:
        fOdbTag.odb_path = QString(XMLString::transcode(chars));
        break;
      case eOdbReadIndex:
        fOdbTag.idx = QString(XMLString::transcode(chars)).toInt();
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eDegaussWEW) { // collect degauss cmd for the WEW magnet
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eDegaussDanfysik) { // collect degauss cmd for the danfysik power supply
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eDegauss) { // collect degauss cmd for the sample magnet
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eDegaussSpinRot) { // collect degauss cmd for the spin rotator
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetOdbData) { // collect set odb data
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eOdbSetPath:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdbSetIndex:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdbSetValue:
        fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdbReadPath:
        fAutoRunCmd.param[3] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdbReadIndex:
        fAutoRunCmd.param[4] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdbTimeout:
        fAutoRunCmd.param[5] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdbTolerance:
        fAutoRunCmd.param[6] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetOdbDataArray) {
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eOdbSetPath:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdbSetValue:
        fAutoRunCmd.param[fAutoRunCmd.noElements++] = QString(XMLString::transcode(chars));
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetTfl) { // collect set tfl cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eTfl_pos:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eTfl_mode:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetTemp) { // collect set temp cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eTemp:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        break;
      case eDeltaT:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        break;
      case eStabilityTimeout:
        fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
        break;
      case eRamp:
        fAutoRunCmd.param[3] = QString(XMLString::transcode(chars));
        break;
      case eHeaterRange:
        fAutoRunCmd.param[4] = QString(XMLString::transcode(chars));
        break;
      case eP_pid:
        fAutoRunCmd.param[5] = QString(XMLString::transcode(chars));
        break;
      case eI_pid:
        fAutoRunCmd.param[6] = QString(XMLString::transcode(chars));
        break;
      case eD_pid:
        fAutoRunCmd.param[7] = QString(XMLString::transcode(chars));
        break;
      case eFlow:
        fAutoRunCmd.param[8] = QString(XMLString::transcode(chars));
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetSampleHV) { // collect sample HV cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eHv_value:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetRA_HV) { // collect ring anode HV cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eHv_left:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eHv_right:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eHv_top:
        fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eHv_bottom:
        fAutoRunCmd.param[3] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetTransportHV) {
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eTransportHvSettingFileName:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetHvOff) {
    switch (fKey) {
      case eLineNo:
       fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eChamber:
        str = QString(XMLString::transcode(chars));
        if (!str.contains("mc", Qt::CaseInsensitive) && !str.contains("tc", Qt::CaseInsensitive) &&
            !str.contains("sc", Qt::CaseInsensitive)) {
          QString err = QString("PSAX2AutoRunParseHandler::characters: found chamber name '%1' which is not supported").arg(str);
          internalFatalError(err);
        }
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetFieldWEWL) { // collect set field WEWL cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eField_value:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eField_unit:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
      default:
        break;
    }
  }

  if (fCmdKey == eSetFieldWEWH) { // collect set field WEWH cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eField_value:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eField_unit:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
      default:
        break;
    }
  }

  if (fCmdKey == eSetFieldDanfysik) { // collect set field Danfysik cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eField_value:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eField_unit:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
      default:
        break;
    }
  }

  if (fCmdKey == eSetField) { // collect set field sample magnet cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eField_value:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eField_unit:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
      default:
        break;
    }
  }

  if (fCmdKey == eSetSpinRot) {
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eAngle:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eNoDegauss:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetFOM) { // collect set FOM cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eCurrent:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetTitle) { // collect set title cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eTitle:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdb_sample:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdb_temp:
        fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdb_field:
        fAutoRunCmd.param[3] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdb_transp:
        fAutoRunCmd.param[4] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdb_hv_samp:
        fAutoRunCmd.param[5] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdb_energy:
        fAutoRunCmd.param[6] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdb_ra_diff_lr:
        fAutoRunCmd.param[7] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdb_ra_diff_tb:
        fAutoRunCmd.param[8] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eOdb_spin_rot:
        fAutoRunCmd.param[9] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetTOF) { // collect set TOF cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eStart:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eStop:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetModInfo) { // collect set moderator info cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eMod:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eMod_date:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetLEMSetup) { // collect set LEM setup info cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eSetup:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetWait) { // collect set wait cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eWait:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eSetDump) { // collect set dump cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eNo_dumps:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eRunStart) { // collect run start cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eNo_events:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eUnits:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        if (fAutoRunCmd.param[1].toLower() != "sec") {
          QString err = QString("PSAX2AutoRunParseHandler::characters: found units '%1' in START command. Currently only 'sec' are supported!").arg(fAutoRunCmd.param[1].toLower());
          internalFatalError(err);
        }
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eRunStop) { // collect run stop cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eNo_events:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eUnits:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        if (fAutoRunCmd.param[1].toLower() != "sec") {
          QString err = QString("PSAX2AutoRunParseHandler::characters: found units '%1' in STOP command. Currently only 'sec' are supported!").arg(fAutoRunCmd.param[1].toLower());
          internalFatalError(err);
        }
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eWarmUp) { // collect warm up cmd
    switch (fKey) {
      case eLineNo:
        fAutoRunCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eDate:
        fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      case eTime:
        fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
     case eVent:
        fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
        fAutoRunCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eLoopList) { // collect loop list elements
    switch (fKey) {
      case eLoopElement:
        if (fLoopNo <= 0) { // fatal error
          // stop parsing
          QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
          internalFatalError(err);
          fFatalError = true;
          return;
        } else {
          fLoopInfoVector[fLoopNo-1].list.push_back(QString(XMLString::transcode(chars)).toDouble());
        }
      default:
        break;
    }
  }

  if (fCmdKey == eLoopIterator) { // collect start, stop, step of the loop iterator
    if (fLoopNo <= 0) { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
      internalFatalError(err);
      fFatalError = true;
      return;
    }
    switch (fKey) {
      case eLoopStart:
        fLoopInfoVector[fLoopNo-1].iterator[0] = QString(XMLString::transcode(chars)).toDouble();
        break;
      case eLoopStop:
        fLoopInfoVector[fLoopNo-1].iterator[1] = QString(XMLString::transcode(chars)).toDouble();
        break;
      case eLoopStep:
        fLoopInfoVector[fLoopNo-1].iterator[2] = QString(XMLString::transcode(chars)).toDouble();
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eLoopSetTemp) { // collect loop set temperature command information
    if (fLoopNo <= 0) { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
      internalFatalError(err);
      fFatalError = true;
      return;
    }
    switch (fKey) {
      case eLineNo:
        fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
        break;
      case eLoopTempTag:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      case eDeltaT:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      case eStabilityTimeout:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[2] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      case eRamp:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[3] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eLoopSetSampleHV) { // collect loop set sample HV command information
    if (fLoopNo <= 0) { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
      internalFatalError(err);
      fFatalError = true;
      return;
    }
    switch (fKey) {
      case eLineNo:
        fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eLoopSampleHVTag:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eLoopSetFieldWEWL) { // collect loop set field WEWL command information
    if (fLoopNo <= 0) { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
      internalFatalError(err);
      fFatalError = true;
      return;
    }
    switch (fKey) {
      case eLineNo:
        fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eLoopFieldTag:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      case eField_unit:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eLoopSetFieldWEWH) { // collect loop set field WEWH command information
    if (fLoopNo <= 0) { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
      internalFatalError(err);
      fFatalError = true;
      return;
    }
    switch (fKey) {
      case eLineNo:
        fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eLoopFieldTag:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      case eField_unit:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eLoopSetFieldDanfysik) { // collect loop set field Danfysik command information
    if (fLoopNo <= 0) { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
      internalFatalError(err);
      fFatalError = true;
      return;
    }
    switch (fKey) {
      case eLineNo:
        fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eLoopFieldTag:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      case eField_unit:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      default:
        break;
    }
  }

  if (fCmdKey == eLoopSetField) { // collect loop set field sample magnet command information
    if (fLoopNo <= 0) { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
      internalFatalError(err);
      fFatalError = true;
      return;
    }
    switch (fKey) {
      case eLineNo:
        fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
        break;
      case eCmdStr:
        fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
        break;
      case eLoopFieldTag:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      case eField_unit:
        fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
        fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
        break;
      default:
        break;
    }
  }
}

//*******************************************************************************************************
//  implementation of the endElement
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::endElement(const XMLCh *const uri, const XMLCh *const localname,
          const XMLCh *const qname)
{
  if (fFatalError)
    return;

  if (uri) {}        // in order to suppress compiler warnings
  if (localname) {}  // in order to suppress compiler warnings

  QString qName = QString(XMLString::transcode(qname));

  fKey = eEmpty;

  if (qName == "odbTag") {
    if ((fOdbTag.tag == "") || (fOdbTag.odb_path == "")) {
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::endElement: ODB tag not complete");
      internalFatalError(err);
      fFatalError = true;
      return;
    }
    fArp->fOdbTagVector->push_back(fOdbTag);
  }

  if ((qName == "comment") || (qName == "alias") || (qName == "ignore_alarms") || (qName == "ignore_clients") || (qName == "odbTag") ||
      (qName == "setBPV") || (qName == "setTfl") || (qName == "setTemp") || (qName == "setSampleHV") || (qName == "setRA_HV") ||
      (qName == "setTransportHV") || (qName == "setFieldWEWL") || (qName == "setFieldWEWH") || (qName == "setFieldDanfysik") ||
      (qName == "setField") || (qName == "setSpinRot") || (qName == "setTitle") || (qName == "setTOF") || (qName == "setModInfo") ||
      (qName == "setLEMSetup") || (qName == "setWait") || (qName == "setDump") ||
      (qName == "runStart") || (qName == "runStop") || (qName == "warmUp") ||
      (qName == "degaussDanfysik") || (qName == "degaussWEW") || (qName == "degaussMagnet") || (qName == "degaussSpinRot") ||
      (qName == "setFOM") || (qName == "setOdbData") || (qName == "setOdbDataArray") || (qName == "setHVOff")) {

    if (qName == "setOdbData")
      CheckOdbSetDataParamsStructure();

    if (fLoopNo == 0)
      fAutoRunCmdVector->push_back(fAutoRunCmd);
    else
      fLoopInfoVector[fLoopNo-1].cmd.push_back(fAutoRunCmd);
    ClearAutoRunCmd();
  }

  if (qName == "loopIterator") { // convert start, stop, step to a list
    int no_elements = -1;

    if (fLoopInfoVector[fLoopNo-1].iterator[2] == 0.0) { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::endElement: loop step iterator == 0!");
      internalFatalError(err);
      fFatalError = true;
      return;
    } else {
      no_elements = (int)round(round(fLoopInfoVector[fLoopNo-1].iterator[1] -
          fLoopInfoVector[fLoopNo-1].iterator[0]) / fLoopInfoVector[fLoopNo-1].iterator[2])+1;

      for (int i=0; i<no_elements; i++)
        fLoopInfoVector[fLoopNo-1].list.push_back(fLoopInfoVector[fLoopNo-1].iterator[0] +
            i*fLoopInfoVector[fLoopNo-1].iterator[2]);
    }
  }

  if (qName == "loop") {
    // expand loop cmd's
    AutoRunCmd expandedLoopCmd;

    expandedLoopCmd.lineNo = fLoopInfoVector[fLoopNo-1].loopCmd.lineNo;
    expandedLoopCmd.noElements = fLoopInfoVector[fLoopNo-1].loopCmd.noElements;
    for (int i=1; i<fLoopInfoVector[fLoopNo-1].loopCmd.noElements; i++)
      expandedLoopCmd.param[i] = fLoopInfoVector[fLoopNo-1].loopCmd.param[i];

    // filter what loop cmd it is
    if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetTemp") {
      expandedLoopCmd.cmd = "setTemp";
    } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetSampleHV") {
      expandedLoopCmd.cmd = "setSampleHV";
    } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetFieldWEWL") {
      expandedLoopCmd.cmd = "setFieldWEWL";
    } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetFieldWEWH") {
      expandedLoopCmd.cmd = "setFieldWEWH";
    } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetFieldDanfysik") {
      expandedLoopCmd.cmd = "setFieldDanfysik";
    } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetField") {
      expandedLoopCmd.cmd = "setField";
    } else { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::endElement: syntactically incorrect command!");
      internalFatalError(err);
      fFatalError = true;
      return;
    }

    // loop over all elements in the list
    PXMLLoopListVector::Iterator listIter;
    PAutoRunCmdVector::Iterator  cmdIter;

    for (listIter = fLoopInfoVector[fLoopNo-1].list.begin();
         listIter != fLoopInfoVector[fLoopNo-1].list.end(); ++listIter) {

      expandedLoopCmd.param[0] = QString("%1").arg(*listIter); // copy loop list value
      fLoopInfoVector[fLoopNo-1].expandedCmd.push_back(expandedLoopCmd);

      // copy all the remaining cmd's of the loop
      for (cmdIter = fLoopInfoVector[fLoopNo-1].cmd.begin();
           cmdIter != fLoopInfoVector[fLoopNo-1].cmd.end(); ++cmdIter) {
        fLoopInfoVector[fLoopNo-1].expandedCmd.push_back(*cmdIter);
      }
    }

    // decrement loop nesting counter
    fLoopNo--;
    if (fLoopNo < 0) { // fatal error
      // stop parsing
      QString err("PSAX2AutoRunParseHandler::endElement: negative loop fall back!");
      internalFatalError(err);
      fFatalError = true;
      return;
    }
    PAutoRunCmdVector::Iterator iter;
    if (fLoopNo == 0) { // back from all the loops -> add expanded list to fAutoRunCmdVector
      QString lastLoopVal("");
      for (iter = fLoopInfoVector[0].expandedCmd.begin();
           iter != fLoopInfoVector[0].expandedCmd.end(); ++iter) {
        // for the loop, the cmdStr might need to be created here
        if (iter->cmd == "setSampleHV") {
          iter->cmdString = QString("SAMPLE_HV ");
          for (int i=0; i<LAR_MAX_PARAM; i++) {
            if (!iter->param[i].isEmpty())
              iter->cmdString += iter->param[i] + ", ";
          }
          // remove last ','
          iter->cmdString.truncate(iter->cmdString.length()-2);
          // keep loop command value
          iter->loopVal = iter->param[0];
          lastLoopVal = iter->param[0];
        } else if (iter->cmd == "setTemp") {
          iter->cmdString = QString("TEMP ");
          for (int i=0; i<LAR_MAX_PARAM; i++) {
            if (!iter->param[i].isEmpty())
              iter->cmdString += iter->param[i] + ", ";
          }
          // remove last ','
          iter->cmdString.truncate(iter->cmdString.length()-2);
          // keep loop command value
          iter->loopVal = iter->param[0];
          lastLoopVal = iter->param[0];
        } else if (iter->cmd == "setFieldWEWL") {
          iter->cmdString = QString("FIELD_WEWL ");
          for (int i=0; i<LAR_MAX_PARAM; i++) {
            if (!iter->param[i].isEmpty())
              iter->cmdString += iter->param[i] + ", ";
          }
          // remove last ','
          iter->cmdString.truncate(iter->cmdString.length()-2);
          // keep loop command value
          iter->loopVal = iter->param[0];
          lastLoopVal = iter->param[0];
        } else if (iter->cmd == "setFieldWEWH") {
          iter->cmdString = QString("FIELD_WEWH ");
          for (int i=0; i<LAR_MAX_PARAM; i++) {
            if (!iter->param[i].isEmpty())
              iter->cmdString += iter->param[i] + ", ";
          }
          // remove last ','
          iter->cmdString.truncate(iter->cmdString.length()-2);
          // keep loop command value
          iter->loopVal = iter->param[0];
          lastLoopVal = iter->param[0];
        } else if (iter->cmd == "setFieldDanfysik") {
          iter->cmdString = QString("FIELD_DANFYSIK ");
          for (int i=0; i<LAR_MAX_PARAM; i++) {
            if (!iter->param[i].isEmpty())
              iter->cmdString += iter->param[i] + ", ";
          }
          // remove last ','
          iter->cmdString.truncate(iter->cmdString.length()-2);
          // keep loop command value
          iter->loopVal = iter->param[0];
          lastLoopVal = iter->param[0];
        } else if (iter->cmd == "setField") {
          iter->cmdString = QString("FIELD ");
          for (int i=0; i<LAR_MAX_PARAM; i++) {
            if (!iter->param[i].isEmpty())
              iter->cmdString += iter->param[i] + ", ";
          }
          // remove last ','
          iter->cmdString.truncate(iter->cmdString.length()-2);
          // keep loop command value
          iter->loopVal = iter->param[0];
          lastLoopVal = iter->param[0];
        } else {
          iter->loopVal = lastLoopVal;
        }

        // store the expanded command
        fAutoRunCmdVector->push_back(*iter);
      }
      // clear the loop list
      fLoopInfoVector.clear();
    } else { // back from an inner loop -> add expanded list to current loop
      for (iter = fLoopInfoVector[fLoopNo].expandedCmd.begin();
           iter != fLoopInfoVector[fLoopNo].expandedCmd.end(); ++iter) {
        fLoopInfoVector[fLoopNo-1].cmd.push_back(*iter);
      }
    }
    // remove processed loop
    if (fLoopInfoVector.size() > 0)
      fLoopInfoVector.pop_back();
  }
}

//*******************************************************************************************************
//  implementation of the endDocument
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::endDocument()
{
}

//*******************************************************************************************************
//  implementation of the warning
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::warning(const SAXParseException& exc)
{    
  XMLParseError err;

  // fill warning information
  err.errorCode = LAR_XML_WARNING;
  err.lineNo = fCurrentUserLineNo;
  err.errorMsg = QString(XMLString::transcode(exc.getMessage()));

  // add to the error message queque
  PXMLParseErrorVector *p;
  p = fArp->GetXMLParseErrorVector();
  p->push_back(err);
}

//*******************************************************************************************************
//  implementation of the error
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::error(const SAXParseException& exc)
{
  XMLParseError err;

  // fill error information
  err.errorCode = LAR_XML_ERROR;
  err.lineNo = fCurrentUserLineNo;
  err.errorMsg = QString(XMLString::transcode(exc.getMessage()));

  // add to the error message queque
  PXMLParseErrorVector *p;
  p = fArp->GetXMLParseErrorVector();
  p->push_back(err);
}

//*******************************************************************************************************
//  implementation of the fatalError
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::fatalError(const SAXParseException& exc)
{
  XMLParseError err;

  // fill error information
  err.errorCode = LAR_XML_FATAL;
  err.lineNo = fCurrentUserLineNo;
  err.errorMsg = QString(XMLString::transcode(exc.getMessage()));

  // add to the error message queque
  PXMLParseErrorVector *p;
  p = fArp->GetXMLParseErrorVector();
  p->push_back(err);
}

//*******************************************************************************************************
//  implementation of the internalFatalError
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::internalFatalError(QString& msg)
{
  XMLParseError err;

  // fill error information
  err.errorCode = LAR_XML_FATAL;
  err.lineNo = fCurrentUserLineNo;
  err.errorMsg = msg;

  // add to the error message queque
  PXMLParseErrorVector *p;
  p = fArp->GetXMLParseErrorVector();
  p->push_back(err);
}

//*******************************************************************************************************
//  implementation of the ClearAutoRunCmd
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::ClearAutoRunCmd()
{
  fAutoRunCmd.cmd        = "";
  fAutoRunCmd.lineNo     = -1;
  fAutoRunCmd.noElements = 0;
  for (int i=0; i<LAR_MAX_PARAM; i++)
    fAutoRunCmd.param[i] = "";
  fAutoRunCmd.loopVal = "";
}

//*******************************************************************************************************
//  implementation of the CheckOdbSetDataParamsStructure
//*******************************************************************************************************
void PSAX2AutoRunParseHandler::CheckOdbSetDataParamsStructure()
{
  bool error = false;
  QString err("PSAX2AutoRunParseHandler::CheckOdbSetDataParamsStructure: ");

  /***************************************************************************
    param[0] = set_path  (required)
    param[1] = set_index
    param[2] = set_value (required)
    param[3] = read_path
    param[4] = read_index
    param[5] = timeout
    param[6] = tolerance
  ****************************************************************************/

  switch (fAutoRunCmd.noElements) {
    case 2: // parameters set_path, set_value needs to be set
      if ((fAutoRunCmd.param[0].length() == 0) || (fAutoRunCmd.param[2].length() == 0)) {
        // set_path or set_value are empty which would be the only valid filling
        error = true;
        err += QString("if only 2 values are given, they have to be set_path and set_value!");
      }
      break;
    case 3: // parameters set_path, set_index, set_value needs to be set
      if ((fAutoRunCmd.param[0].length() == 0) || (fAutoRunCmd.param[1].length() == 0) ||
          (fAutoRunCmd.param[2].length() == 0)) {
        // set_path, set_index or set_value are empty which would be the only valid filling
        error = true;
        err += QString("if only 3 values are given, they have to be set_path, set_index, and set_value!");
      }
      break;
    case 5: // parameters set_path, set_value, read_path, timeout, tolerance needs to be set 
      if ((fAutoRunCmd.param[1].length() != 0) || (fAutoRunCmd.param[4].length() != 0)) {
        // set_index or read_index set -> error since the above parameter needs to be set
        error = true;
        err += QString("if 5 values are given, they have to be: set_path, set_value, read_path, timeout, tolerance!");
      }
      break;
    case 6: // parameters set_path, set_value, read_path, timeout, tolerance, and (set_index or read_index)  needs to be set
      if ((fAutoRunCmd.param[1].length() != 0) && (fAutoRunCmd.param[4].length() != 0)) {
        // set_index and read_index set -> error since the above parameter needs to be set
        error = true;
        err += QString("if 6 values are given, they have to be: set_path, set_value, read_path, timeout, tolerance, and (set_index or read_index) !");
      }
      break;
    case 7: // all used, from syntax point of view correct
      break;
    default:
      error = true;
      err += QString("ODB_SET_DATA parameter error! Please check the manual");
      break;
  }

  if (error) { // parameter error
    internalFatalError(err);
    fFatalError = true;
    return;
  }
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//*******************************************************************************************************
//  implementation of the constructor
//*******************************************************************************************************
PAutoRunParser::PAutoRunParser(QString userAutoRunSeqFln, QString &schemaPath, QString &xmlFln,
      PAutoRunCmdVector *arcv, POdbTagVector *odbtagv) :
  fInputFileName(userAutoRunSeqFln),
  fAutoRunXMLSchemaPath(schemaPath),
  fXMLFileName(xmlFln),
  fAutoRunCmdVector(arcv),
  fOdbTagVector(odbtagv)
{
  fParseErrorCounter=0;

  fXMLParseErrorVector = new PXMLParseErrorVector();
}

//*******************************************************************************************************
//  implementation of the destructor
//*******************************************************************************************************
PAutoRunParser::~PAutoRunParser()
{
}

//*******************************************************************************************************
//  implementation of ConvertToXML
//*******************************************************************************************************
void PAutoRunParser::ConvertToXML()
{
  int         line_no = 0;
  int         loop_no = 0;
  QString     errorMsg;
  QString     str;
  QString     offset = "";
  QStringList runSeq;
  QStringList runSeqXML;

  QFile file(fInputFileName);

  // check if file exists
  if (!file.exists()) {
    errorMsg = "File does not exist: '" + fInputFileName + "'";
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INPUT_FILE_NOT_EXISTING, -1, errorMsg);
    fParseErrorCounter = 1;
    return;
  }

  // read file into string list
  if (file.open(QIODevice::ReadOnly)) {
      QTextStream stream( &file );
      QString line;
      while ( !stream.atEnd() ) {
        line = stream.readLine(); // line of text excluding '\n'
        runSeq += line;
      }
      file.close();
  } else {
    errorMsg = "Couldn't open file (" + fInputFileName + ")";
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INPUT_FILE_READ_ERROR, line_no, errorMsg);
  }

  // collect all the alias
  QString key(""), value("");
  line_no = 0;
  for (QStringList::Iterator it = runSeq.begin(); it != runSeq.end(); ++it) {
    line_no++;
    str = (QString)*it;
    str = str.trimmed();
    if (str.startsWith("ALIAS")) {
      key = str.section(' ', 1, 1);
      value = str.section(' ', 2);
      if ((key.length() == 0) || (value.length() == 0)) {
        QString err = QString("**ERROR** Invalid ALIAS command!");
        emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, line_no, err);
        return;
      }
      fAlias[key] = value;
    }
  }

  // convert to XML
  // write header
  runSeqXML.clear();
  runSeqXML += QString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
  runSeqXML += QString("<autoRun xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
  runSeqXML += QString("   xsi:noNamespaceSchemaLocation=\"file:")+fAutoRunXMLSchemaPath+QString("\">");
  runSeqXML += QString("<autoRunName>%1</autoRunName>").arg(fInputFileName);

  // write body
  line_no = 0;
  for (QStringList::Iterator it = runSeq.begin(); it != runSeq.end(); ++it) {
    line_no++;
    str = (QString)*it;
    str = str.trimmed();
    str = str.simplified();

    if (str.isEmpty())
      continue;

    if (str.startsWith("%"))
      ConvertComment(str, line_no, offset, runSeqXML);
    else if (str.startsWith("ALIAS"))
      ConvertAlias(str, line_no, offset, runSeqXML);
    else if (str.startsWith("IGNORE_ALARMS"))
      ConvertIgnoreAlarms(str, line_no, offset, runSeqXML);
    else if (str.startsWith("IGNORE_CLIENTS"))
      ConvertIgnoreClients(str, line_no, offset, runSeqXML);
    else if (str.startsWith("BPV"))
      ConvertBPV(str, line_no, offset, runSeqXML);
    else if (str.startsWith("FIELD_WEWL"))
      ConvertFieldWEWL(str, line_no, offset, runSeqXML);
    else if (str.startsWith("FIELD_WEWH"))
      ConvertFieldWEWH(str, line_no, offset, runSeqXML);
    else if (str.startsWith("FIELD_DANFYSIK"))
      ConvertFieldDanfysik(str, line_no, offset, runSeqXML);
    else if (str.startsWith("FIELD "))
      ConvertField(str, line_no, offset, runSeqXML);
    else if (str.startsWith("FOM"))
      ConvertFOM(str, line_no, offset, runSeqXML);
    else if (str.startsWith("LEM_SETUP"))
      ConvertLEMSetup(str, line_no, offset, runSeqXML);
    else if (str.startsWith("MODERATOR"))
      ConvertModerator(str, line_no, offset, runSeqXML);
    else if (str.startsWith("SAMPLE_HV"))
      ConvertSampleHV(str, line_no, offset, runSeqXML);
    else if (str.startsWith("RA_HV"))
      ConvertRA_HV(str, line_no, offset, runSeqXML);
    else if (str.startsWith("TRANSPORT_HV"))
      ConvertTransportHV(str, line_no, offset, runSeqXML);
    else if (str.startsWith("HV_OFF"))
      ConvertHVOff(str, line_no, offset, runSeqXML);
    else if (str.startsWith("ODB_TAG"))
      ConvertOdbTag(str, line_no, offset, runSeqXML);
    else if (str.startsWith("ODB_SET_DATA"))
      if (str.startsWith("ODB_SET_DATA_ARRAY")) {
        ConvertOdbSetDataArray(str, line_no, offset, runSeqXML);
      } else {
        ConvertOdbSetData(str, line_no, offset, runSeqXML);
      }
    else if (str.startsWith("SPIN_ROT"))
      ConvertSpinRot(str, line_no, offset, runSeqXML);
    else if (str.startsWith("START"))
      ConvertStart(str, line_no, offset, runSeqXML);
    else if (str.startsWith("STOP"))
      ConvertStop(str, line_no, offset, runSeqXML);
    else if (str.startsWith("TFL"))
      ConvertTfl(str, line_no, offset, runSeqXML);
    else if (str.startsWith("TEMP"))
      ConvertTemp(str, line_no, offset, runSeqXML);
    else if (str.startsWith("TITLE"))
      ConvertTitle(str, line_no, offset, runSeqXML);
    else if (str.startsWith("TOF"))
      ConvertTOF(str, line_no, offset, runSeqXML);
    else if (str.startsWith("WAIT"))
      ConvertWait(str, line_no, offset, runSeqXML);
    else if (str.startsWith("WARMUP"))
      ConvertWarmUp(str, line_no, offset, runSeqXML);
    else if (str.startsWith("DUMP"))
      ConvertDump(str, line_no, offset, runSeqXML);
    else if (str.startsWith("DEGAUSS_WEW"))
      ConvertDegaussWEW(str, line_no, offset, runSeqXML);
    else if (str.startsWith("DEGAUSS_DANFYSIK"))
      ConvertDegaussDanfysik(str, line_no, offset, runSeqXML);
    else if (str.startsWith("DEGAUSS_MAGNET"))
      ConvertDegauss(str, line_no, offset, runSeqXML);
    else if (str.startsWith("DEGAUSS_SPIN_ROT"))
      ConvertDegaussSpinRot(str, line_no, offset, runSeqXML);
    else if (str.startsWith("LOOP_START")) {
      ConvertLoopStart(line_no, offset, runSeqXML);
      loop_no++;
      offset = "";
      for (int i=0; i<loop_no; i++)
        offset += "    ";
    }
    else if (str.startsWith("LOOP_LIST"))
      ConvertLoopList(str, offset, runSeqXML);
    else if (str.startsWith("LOOP_ITERATOR"))
      ConvertLoopIterator(str, offset, runSeqXML);
    else if (str.startsWith("LOOP_TEMP"))
      ConvertLoopTemp(str, line_no, offset, runSeqXML);
    else if (str.startsWith("LOOP_SAMPLE_HV"))
      ConvertLoopSampleHV(str, line_no, offset, runSeqXML);
    else if (str.startsWith("LOOP_FIELD_WEWL"))
      ConvertLoopFieldWEWL(str, line_no, offset, runSeqXML);
    else if (str.startsWith("LOOP_FIELD_WEWH"))
      ConvertLoopFieldWEWH(str, line_no, offset, runSeqXML);
    else if (str.startsWith("LOOP_FIELD_DANFYSIK"))
      ConvertLoopFieldDanfysik(str, line_no, offset, runSeqXML);
    else if (str.startsWith("LOOP_FIELD "))
      ConvertLoopField(str, line_no, offset, runSeqXML);
    else if (str.startsWith("LOOP_END")) {
      loop_no--;
      offset = "";
      for (int i=0; i<loop_no; i++)
        offset += "    ";
      ConvertLoopEnd(offset, runSeqXML);
    }
    else {
      fParseErrorCounter++;
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, line_no, "Invalid Auto Run Command.");
    }
  }
  // write closure
  runSeqXML += QString("</autoRun>");

  // save XML-file
  QFile fileOut( fXMLFileName );
  if (fileOut.open( QIODevice::WriteOnly )) {
    QTextStream stream( &fileOut );
    for ( QStringList::Iterator it = runSeqXML.begin(); it != runSeqXML.end(); ++it )
       stream << *it << "\n";
    fileOut.close();
  } else {
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_OUTPUT_FILE_WRITE_ERROR, 0, "Couldn't write XML ouput.");
  }
}


//*******************************************************************************************************
//  implementation of CheckForAlias
//*******************************************************************************************************
QString PAutoRunParser::CheckForAlias(QString &str)
{
  QString result = str;
  QStringList tokens = result.split(QRegExp("[\\s,\\[\\]]"), Qt::SkipEmptyParts);

  QList<QString> keys = fAlias.keys();
  QList<QString>::iterator it;
  QString key(""), sKey(""), sAlias("");
  int idx1, idx2;
  for (it = keys.begin(); it != keys.end(); ++it) {
    key = (QString)*it; // alias key
    for (int i=0; i<tokens.count(); i++) { // tokenized lar string
      if (key == tokens[i]) {
        sKey = " "+key; // needed to make sure that key in results starts with a space
        sAlias = " "+fAlias[key];
        result.replace(sKey, sAlias);

        // check if something like "..."[idx] is found, and if yes fix it
        idx1 = result.indexOf("\"[");
        if (idx1 > 0) {
          idx2 = result.indexOf("]", idx1);
          for (int i=idx1; i<=idx2; i++)
            result[i] = result[i+1];
          result[idx2] = '"';
        }
      }
    }
  }

  return result;
}


//*******************************************************************************************************
//  implementation of ConvertAlias
//*******************************************************************************************************
void PAutoRunParser::ConvertAlias(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <alias>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <alias_key>%1</alias_key>").arg(str.section(' ', 1, 1));
  xml += offset + QString("    <alias_value>%1</alias_value>").arg(str.section(' ', 2, 2));
  xml += offset + QString("  </alias>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertIgnoreAlarms
//*******************************************************************************************************
void PAutoRunParser::ConvertIgnoreAlarms(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <ignore_alarms>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <state>%1</state>").arg(str.section(' ', 1, 1).toLower());
  xml += offset + QString("  </ignore_alarms>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertIgnoreClients
//*******************************************************************************************************
void PAutoRunParser::ConvertIgnoreClients(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <ignore_clients>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <state>%1</state>").arg(str.section(' ', 1, 1).toLower());
  xml += offset + QString("  </ignore_clients>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertBPV
//*******************************************************************************************************
void PAutoRunParser::ConvertBPV(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setBPV>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  if (str.contains("X"))
    xml += offset + QString("    <label>X</label>");
  else if (str.contains("Y"))
    xml += offset + QString("    <label>Y</label>");
  else
    xml += offset + QString("    <label>?</label>");
  xml += offset + QString("    <state>%1</state>").arg(str.section(' ', 1, 1).toLower());
  xml += offset + QString("  </setBPV>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertComment
//*******************************************************************************************************
void PAutoRunParser::ConvertComment(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString comment = str;
  comment.replace("<", " less-than ");
  comment.replace(">", " greater-than ");

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <comment>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(comment);
  xml += offset + QString("  </comment>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertDump
//*******************************************************************************************************
void PAutoRunParser::ConvertDump(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setDump>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <no_dumps>%1</no_dumps>").arg(line.section(' ', 1, 1));
  xml += offset + QString("  </setDump>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertFieldWEWL
//*******************************************************************************************************
void PAutoRunParser::ConvertFieldWEWL(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setFieldWEWL>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <field_value>%1</field_value>").arg(line.section(' ', 1, 1));
  QString unit("");
  unit = line.section(' ', 2, 2);
  if ((unit != "A") && (unit != "G") && (unit != "")) {
      QString err = QString("**ERROR** Wrong units in FIELD_WEWL cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
  }
  if (unit == "G")
    xml += offset + QString("    <field_unit>G</field_unit>");
  else
    xml += offset + QString("    <field_unit>A</field_unit>");
  xml += offset + QString("  </setFieldWEWL>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertFieldWEWH
//*******************************************************************************************************
void PAutoRunParser::ConvertFieldWEWH(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setFieldWEWH>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <field_value>%1</field_value>").arg(line.section(' ', 1, 1));
  QString unit("");
  unit = line.section(' ', 2, 2);
  if ((unit != "A") && (unit != "G") && (unit != "")) {
      QString err = QString("**ERROR** Wrong units in FIELD_WEWH cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
  }
  if (unit == "G")
    xml += offset + QString("    <field_unit>G</field_unit>");
  else
    xml += offset + QString("    <field_unit>A</field_unit>");
  xml += offset + QString("  </setFieldWEWH>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertFieldDanfysik
//*******************************************************************************************************
void PAutoRunParser::ConvertFieldDanfysik(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setFieldDanfysik>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <field_value>%1</field_value>").arg(line.section(' ', 1, 1));
  QString unit("");
  unit = line.section(' ', 2, 2);
  if ((unit != "A") && (unit != "G") && (unit != "")) {
      QString err = QString("**ERROR** Wrong units in FIELD_DANFYSIK cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
  }
  if (unit == "G")
    xml += offset + QString("    <field_unit>G</field_unit>");
  else
    xml += offset + QString("    <field_unit>A</field_unit>");
  xml += offset + QString("  </setFieldDanfysik>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertField
//*******************************************************************************************************
void PAutoRunParser::ConvertField(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setField>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <field_value>%1</field_value>").arg(line.section(' ', 1, 1));
  QString unit("");
  unit = line.section(' ', 2, 2);
  if ((unit != "A") && (unit != "G") && (unit != "")) {
      QString err = QString("**ERROR** Wrong units in FIELD cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
  }
  if (unit == "G")
    xml += offset + QString("    <field_unit>G</field_unit>");
  else
    xml += offset + QString("    <field_unit>A</field_unit>");
  xml += offset + QString("  </setField>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertFOM
//*******************************************************************************************************
void PAutoRunParser::ConvertFOM(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setFOM>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <current>%1</current>").arg(line.section(' ', 1, 1).remove(","));
  xml += offset + QString("  </setFOM>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertLEMSetup
//*******************************************************************************************************
void PAutoRunParser::ConvertLEMSetup(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setLEMSetup>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <setup>%1</setup>").arg(line.section(' ', 1));
  xml += offset + QString("  </setLEMSetup>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertLoopStart
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopStart(int lineNo, QString &offset, QStringList &xml)
{
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <loop>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
}

//*******************************************************************************************************
//  implementation of ConvertLoopList
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopList(QString &str, QString &offset, QStringList &xml)
{
  QString workStr;
  QString value;
  int     i=0;

  xml += offset + QString("<loopList>");
  workStr = str.section('[', 1).trimmed();
  value = " ";
  while (!value.isEmpty()) {
    value = workStr.section(',',i,i);
    value.remove(",");
    if (!value.trimmed().isEmpty()) {
      value = value.trimmed().remove("]");
      xml += offset + QString("  <loopElement>%1</loopElement>").arg(value);
    }
    i++;
  }
  xml += offset + QString("</loopList>");
}

//*******************************************************************************************************
//  implementation of ConvertLoopIterator
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopIterator(QString &str, QString &offset, QStringList &xml)
{
  QString workStr;
  QString value;
  int     i=0;

  xml += offset + QString("<loopIterator>");
  workStr = str.section('[', 1).trimmed();
  value = " ";
  while (!value.isEmpty()) {
    value = workStr.section(',',i,i);
    value.remove(",");
    if (!value.trimmed().isEmpty()) {
      value = value.trimmed().remove("]");
      switch (i) {
        case 0:
          xml += offset + QString("  <loopStart>%1</loopStart>").arg(value);
          break;
        case 1:
          xml += offset + QString("  <loopStop>%1</loopStop>").arg(value);
          break;
        case 2:
          xml += offset + QString("  <loopStep>%1</loopStep>").arg(value);
          break;
        default:
          break;
      }
    }
    i++;
  }
  xml += offset + QString("</loopIterator>");
}

//*******************************************************************************************************
//  implementation of ConvertLoopTemp
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopTemp(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString workStr;
  QString line = CheckForAlias(str);

  xml += offset + QString("<loopSetTemp>");
  xml += offset + QString("  <line>%1</line>").arg(lineNo);
  xml += offset + QString("  <cmd_str>%1</cmd_str>").arg(str);
  workStr = line.section(' ', 1, 1);
  workStr.remove(",");
  xml += offset + QString("  <loopTempTag>%1</loopTempTag>").arg(workStr);
  xml += offset + QString("  <deltaT>%1</deltaT>").arg(line.section(',', 1, 1).trimmed());
  xml += offset + QString("  <stabilityTimeout>%1</stabilityTimeout>").arg(line.section(',', 2, 2).trimmed());
  workStr = line.section(',', 3, 3); // ramp
  // check if a ramp value is given
  if (workStr.remove(",").trimmed().length()>0) {
    xml += offset + QString("  <ramp>%1</ramp>").arg(workStr.remove(",").trimmed());
  }
  xml += offset + QString("</loopSetTemp>");
}

//*******************************************************************************************************
//  implementation of ConvertLoopSampleHV
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopSampleHV(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<loopSetSampleHV>");
  xml += offset + QString("  <line>%1</line>").arg(lineNo);
  xml += offset + QString("  <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("  <loopSampleHVTag>%1</loopSampleHVTag>").arg(line.section(' ', 1, 1));
  xml += offset + QString("</loopSetSampleHV>");
}

//*******************************************************************************************************
//  implementation of ConvertLoopFieldWEWL
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopFieldWEWL(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<loopSetFieldWEWL>");
  xml += offset + QString("  <line>%1</line>").arg(lineNo);
  xml += offset + QString("  <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("  <loopFieldTag>%1</loopFieldTag>").arg(line.section(' ', 1, 1));
  QString unit("");
  unit = line.section(' ', 2, 2);
  if ((unit != "A") && (unit != "G") && (unit != "")) {
      QString err = QString("**ERROR** Wrong units in LOOP_FIELD_WEWL cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
  }
  if (unit == "G")
    xml += offset + QString("    <field_unit>G</field_unit>");
  else
    xml += offset + QString("    <field_unit>A</field_unit>");
  xml += offset + QString("</loopSetFieldWEWL>");
}

//*******************************************************************************************************
//  implementation of ConvertLoopFieldWEWH
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopFieldWEWH(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<loopSetFieldWEWH>");
  xml += offset + QString("  <line>%1</line>").arg(lineNo);
  xml += offset + QString("  <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("  <loopFieldTag>%1</loopFieldTag>").arg(line.section(' ', 1, 1));
  QString unit("");
  unit = line.section(' ', 2, 2);
  if ((unit != "A") && (unit != "G") && (unit != "")) {
      QString err = QString("**ERROR** Wrong units in LOOP_FIELD_WEWH cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
  }
  if (unit == "G")
    xml += offset + QString("    <field_unit>G</field_unit>");
  else
    xml += offset + QString("    <field_unit>A</field_unit>");
  xml += offset + QString("</loopSetFieldWEWH>");
}

//*******************************************************************************************************
//  implementation of ConvertLoopFieldDanfysik
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopFieldDanfysik(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<loopSetFieldDanfysik>");
  xml += offset + QString("  <line>%1</line>").arg(lineNo);
  xml += offset + QString("  <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("  <loopFieldTag>%1</loopFieldTag>").arg(line.section(' ', 1, 1));
  QString unit("");
  unit = line.section(' ', 2, 2);
  if ((unit != "A") && (unit != "G") && (unit != "")) {
      QString err = QString("**ERROR** Wrong units in LOOP_FIELD_DANFYSIK cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
  }
  if (unit == "G")
    xml += offset + QString("    <field_unit>G</field_unit>");
  else
    xml += offset + QString("    <field_unit>A</field_unit>");
  xml += offset + QString("</loopSetFieldDanfysik>");
}

//*******************************************************************************************************
//  implementation of ConvertLoopField
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopField(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<loopSetField>");
  xml += offset + QString("  <line>%1</line>").arg(lineNo);
  xml += offset + QString("  <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("  <loopFieldTag>%1</loopFieldTag>").arg(line.section(' ', 1, 1));
  QString unit("");
  unit = line.section(' ', 2, 2);
  if ((unit != "A") && (unit != "G") && (unit != "")) {
      QString err = QString("**ERROR** Wrong units in LOOP_FIELD cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
  }
  if (unit == "G")
    xml += offset + QString("    <field_unit>G</field_unit>");
  else
    xml += offset + QString("    <field_unit>A</field_unit>");
  xml += offset + QString("</loopSetField>");
}

//*******************************************************************************************************
//  implementation of ConvertLoopEnd
//*******************************************************************************************************
void PAutoRunParser::ConvertLoopEnd(QString &offset, QStringList &xml)
{
  xml += offset + QString("  </loop>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertModerator
//*******************************************************************************************************
void PAutoRunParser::ConvertModerator(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  QString workStr;

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setModInfo>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  workStr = line.section(' ', 1, 1);
  workStr.remove(",");
  xml += offset + QString("    <mod>%1</mod>").arg(workStr);
  xml += offset + QString("    <mod_date>%1</mod_date>").arg(line.section(' ', 2));
  xml += offset + QString("  </setModInfo>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertOdbSetData
//*******************************************************************************************************
void PAutoRunParser::ConvertOdbSetData(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  line.remove("ODB_SET_DATA ");

  QStringList tokens = line.split(QRegExp("[,]"));

  if ((tokens.count() != 2) && (tokens.count() != 5)) { // something is totaly wrong
    QString err = QString("**ERROR** Invalid ODB_SET_DATA command! Given number of parameters have to be 2 or 5 found %1").arg(tokens.count());
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
    return;
  }

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setOdbData>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);

  QString sec("");
  if (tokens.count() == 2) { // ODB_SET_DATA without readback
    int idx1 = tokens[0].indexOf("["), idx2;
    if (idx1 == -1) {
      // set path
      xml += offset + QString("    <set_path>%1</set_path>").arg(tokens[0].remove('"').trimmed());
    } else {
      // set path
      sec = tokens[0];
      sec.truncate(idx1);
      xml += offset + QString("    <set_path>%1</set_path>").arg(sec.remove('"').trimmed());
      // set index
      idx2 = tokens[0].indexOf("]", idx1);
      xml += offset + QString("    <set_index>%1</set_index>").arg(tokens[0].mid(idx1+1,idx2-idx1-1));
    }
    // set value
    xml += offset + QString("    <set_value>%1</set_value>").arg(tokens[1].remove('"').trimmed());
  } else if (tokens.count() == 5) {
    int idx1 = tokens[0].indexOf("["), idx2;
    if (idx1 == -1) { // no index
      // set path
      xml += offset + QString("    <set_path>%1</set_path>").arg(tokens[0].remove('"').trimmed());
    } else {
      // set path
      sec = tokens[0];
      sec.truncate(idx1);
      xml += offset + QString("    <set_path>%1</set_path>").arg(sec.remove('"').trimmed());
      // set index
      idx2 = tokens[0].indexOf("]", idx1);
      xml += offset + QString("    <set_index>%1</set_index>").arg(tokens[0].mid(idx1+1,idx2-idx1-1));
    }
    // set value
    xml += offset + QString("    <set_value>%1</set_value>").arg(tokens[1].remove('"').trimmed());

    // set readback path (and index if present)
    idx1 = tokens[2].indexOf("[");
    if (idx1 == -1) {
      // set path
      xml += offset + QString("    <read_path>%1</read_path>").arg(tokens[2].remove('"').trimmed());
    } else {
      // set path
      sec = tokens[2];
      sec.truncate(idx1);
      xml += offset + QString("    <read_path>%1</read_path>").arg(sec.remove('"').trimmed());
      // set index
      idx2 = tokens[2].indexOf("]", idx1);
      xml += offset + QString("    <read_index>%1</read_index>").arg(tokens[2].mid(idx1+1,idx2-idx1-1));
    }

    // set timeout
    xml += offset + QString("    <timeout>%1</timeout>").arg(tokens[3].trimmed());

    // tolerance
    xml += offset + QString("    <tolerance>%1</tolerance>").arg(tokens[4].trimmed());
  } else {
    QString err = QString("**ERROR** Invalid ODB_SET_DATA command! Given number of parameters have to be 2 or 5 found %1").arg(tokens.count());
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
    return;
  }

  xml += offset + QString("  </setOdbData>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertOdbSetDataArray
//*******************************************************************************************************
void PAutoRunParser::ConvertOdbSetDataArray(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  QString sec;

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setOdbDataArray>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  // set path
  sec = line.section(",", 0, 0);
  sec.remove("ODB_SET_DATA_ARRAY ");
  xml += offset + QString("    <set_path>%1</set_path>").arg(sec.remove('"').trimmed());

  // handle all the potentially being present entries
  int i=1;
  bool done = false, ok;
  do {
    sec = str.section(",", i, i);
    sec = sec.trimmed();
    if (sec.length() == 0) { // no token left
      done = true;
    } else {
      sec.toFloat(&ok);
      if (ok) {
        xml += offset + QString("    <set_value>%1</set_value>").arg(sec);
        i++;
      } else {
        QString err = QString("**ERROR** Invalid ODB_SET_DATA_ARRAY command! Currently only float arrays are supported.");
        emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
        return;
      }
    }
  } while (!done);

  xml += offset + QString("  </setOdbDataArray>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertSampleHV
//*******************************************************************************************************
void PAutoRunParser::ConvertOdbTag(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);

  // get ODB path
  QString path = line.section(' ', 2);
  int pos = path.indexOf("[");
  if (pos >= 0)
    path.truncate(pos);

  // get ODB path index if present
  QString idxStr("-1"); // -1 means there is no index present, i.e. ODB path is a single variable
  if (pos >= 0) {
    QString sstr = line.section(' ', 2);
    int pos2 = sstr.indexOf("]");
    sstr.truncate(pos2);
    idxStr = sstr.right(pos2-pos-1);
  }

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <odbTag>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <label>%1</label>").arg(line.section(' ', 1, 1));
  xml += offset + QString("    <read_path>%1</read_path>").arg(path);
  xml += offset + QString("    <read_index>%1</read_index>").arg(idxStr);
  xml += offset + QString("  </odbTag>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertSampleHV
//*******************************************************************************************************
void PAutoRunParser::ConvertSampleHV(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setSampleHV>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <hv_value>%1</hv_value>").arg(line.section(' ', 1, 1));
  xml += offset + QString("  </setSampleHV>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertRA_HV
//*******************************************************************************************************
void PAutoRunParser::ConvertRA_HV(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  QString workStr;
  QStringList tokens;

  // check that there are the right number of tokens, this could e.g. fail if somebody writes accidently
  // RA_HV 9.15, 9.15, 9.15, 9,15
  //                          ^
  //                          |--- error here !!
  tokens = str.split(",", Qt::SkipEmptyParts);
  if ((tokens.count() != 2) && (tokens.count() != 4)) { // error
    QString err = QString("**ERROR** Invalid HV_RA command! Found %1 HV values: '%2' (2 or 4 required).").arg(tokens.count()).arg(str);
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
    return;
  }

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setRA_HV>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  workStr = line.section(' ', 1, 1);
  workStr = workStr.section(',', 0, 0);
  workStr.remove(",");
  xml += offset + QString("    <hv_left>%1</hv_left>").arg(workStr.trimmed());
  workStr = str.section(',', 1, 1);
  xml += offset + QString("    <hv_right>%1</hv_right>").arg(workStr.trimmed());
  workStr = str.section(',', 2, 2);
  if (!workStr.isNull()) {
    xml += offset + QString("    <hv_top>%1</hv_top>").arg(workStr.trimmed());
    workStr = str.section(',', 3, 3);
    xml += offset + QString("    <hv_bottom>%1</hv_bottom>").arg(workStr.trimmed());
  }
  xml += offset + QString("  </setRA_HV>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertTransportHV
//*******************************************************************************************************
void PAutoRunParser::ConvertTransportHV(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setTransportHV>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <transportHvSettingFileName>%1</transportHvSettingFileName>").arg(line.remove("TRANSPORT_HV "));
  xml += offset + QString("  </setTransportHV>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertHVOff
//*******************************************************************************************************
void PAutoRunParser::ConvertHVOff(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setHVOff>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <chamber>%1</chamber>").arg(line.remove("HV_OFF "));
  xml += offset + QString("  </setHVOff>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertSpinRot
//*******************************************************************************************************
void PAutoRunParser::ConvertSpinRot(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);

  // make sure that the argument is either "off" or a number within range
  QString arg = line;
  arg = line.section(' ', 1, 1);
  if (!arg.contains("off")) {
    bool ok;
    float fval = arg.toFloat(&ok);
    if (!ok) {
      QString err = QString("**ERROR** Invalid SPIN_ROT command! Argument is neither \"off\", nor a number between -90.0..+90.0.");
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
    }
    if ((fval < -90.0) || (fval > 90.0)) {
      QString err = QString("**ERROR** Invalid SPIN_ROT command! Argument is out of range (-90.0..+90.0), found %1.").arg(fval);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
    }
  }

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setSpinRot>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <angle>%1</angle>").arg(line.section(' ', 1, 1));
  QString noDegauss = line.section(' ', 2, 2);
  if (arg.contains("off") && (noDegauss.indexOf("ndg", 0, Qt::CaseInsensitive) == 0)) {
    QString err = QString("**ERROR** Invalid SPIN_ROT command! You cannot combine 'off' with 'ndg'").arg(noDegauss);
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
    return;
  }
  if (!noDegauss.isEmpty()) {
    if (noDegauss.indexOf("ndg", 0, Qt::CaseInsensitive) == 0) {
      xml += offset + QString("    <no_degauss>%1</no_degauss>").arg(noDegauss);
    } else {
      QString err = QString("**ERROR** Invalid SPIN_ROT command! Unkown 2nd argument '%1'. Allowed would be 'ndg'").arg(noDegauss);
      emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
      return;
    }
  }
  xml += offset + QString("  </setSpinRot>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertStart
//*******************************************************************************************************
void PAutoRunParser::ConvertStart(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  QString units("");

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <runStart>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <no_events>%1</no_events>").arg((int)line.section(' ', 1, 1).toDouble());
  units = line.section(' ', 2, 2);
  if (!units.isEmpty()) {
    xml += offset + QString("    <units>%1</units>").arg(units);
  }
  xml += offset + QString("  </runStart>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertStop
//*******************************************************************************************************
void PAutoRunParser::ConvertStop(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  QString units("");
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <runStop>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <no_events>%1</no_events>").arg((int)line.section(' ', 1, 1).toDouble());
  units = line.section(' ', 2, 2);
  if (!units.isEmpty()) {
    xml += offset + QString("    <units>%1</units>").arg(units);
  }
  xml += offset + QString("  </runStop>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertTfl
//*******************************************************************************************************
void PAutoRunParser::ConvertTfl(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  QString workStr;

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setTfl>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  workStr = line.section(' ', 1, 1);
  workStr = workStr.section(',', 0, 0);
  workStr.remove(",");
  xml += offset + QString("    <tfl_pos>%1</tfl_pos>").arg(workStr);
  workStr = line.section(',', 1, 1);
  workStr.remove(",");
  xml += offset + QString("    <tfl_mode>%1</tfl_mode>").arg(workStr.trimmed());
  xml += offset + QString("  </setTfl>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertTemp
//*******************************************************************************************************
void PAutoRunParser::ConvertTemp(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  QString workStr;

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setTemp>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  workStr = line.section(' ', 1, 1);
  workStr = workStr.section(',', 0, 0);
  workStr.remove(",");
  xml += offset + QString("    <temp>%1</temp>").arg(workStr);
  workStr = line.section(',', 1);
  if (workStr.contains(",")>0) { // full command
    workStr = line.section(',', 1, 1); // dT
    workStr.remove(",");
    xml += offset + QString("    <deltaT>%1</deltaT>").arg(workStr.trimmed());
    workStr = line.section(',', 2, 2); // stability timeout
    workStr.remove(",");
    xml += offset + QString("    <stabilityTimeout>%1</stabilityTimeout>").arg(workStr.trimmed());
    workStr = line.section(',', 3, 3); // ramp
    // check if a ramp value is given
    if (workStr.remove(",").trimmed().length()>0) {
      xml += offset + QString("    <ramp>%1</ramp>").arg(workStr.remove(",").trimmed());
    }
    workStr = line.section(',', 4, 4); // heater range
    // check if a heater range value is given
    if (workStr.remove(",").trimmed().length()>0) {
      xml += offset + QString("    <heaterRange>%1</heaterRange>").arg(workStr.remove(",").trimmed());
    }
    workStr = line.section(',', 5, 5); // P
    // check if a P value is given
    if (workStr.remove(",").trimmed().length()>0) {
      xml += offset + QString("    <P_PID>%1</P_PID>").arg(workStr.remove(",").trimmed());
    }
    workStr = line.section(',', 6, 6); // I
    // check if a I value is given
    if (workStr.remove(",").trimmed().length()>0) {
      xml += offset + QString("    <I_PID>%1</I_PID>").arg(workStr.remove(",").trimmed());
    }
    workStr = line.section(',', 7, 7); // D
    // check if a D value is given
    if (workStr.remove(",").trimmed().length()>0) {
      xml += offset + QString("    <D_PID>%1</D_PID>").arg(workStr.remove(",").trimmed());
    }
    workStr = line.section(',', 8, 8); // flow
    // check if a flow value is given
    if (workStr.remove(",").trimmed().length()>0) {
      xml += offset + QString("    <flow>%1</flow>").arg(workStr.remove(",").trimmed());
    }
  } else { // only T, dT given
    xml += offset + QString("    <deltaT>%1</deltaT>").arg(workStr.trimmed());
  }
  xml += offset + QString("  </setTemp>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertTitle
//*******************************************************************************************************
void PAutoRunParser::ConvertTitle(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  QString workStr;

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setTitle>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <title>%1</title>").arg(line.section(' ', 1));
  // check for ODB tags
  if (line.contains("ODB_SAMPLE")>0)
    xml += offset + QString("    <odb_sample>true</odb_sample>");
  else
    xml += offset + QString("    <odb_sample>false</odb_sample>");
  if (line.contains("ODB_TEMP")>0)
    xml += offset + QString("    <odb_temp>true</odb_temp>");
  else
    xml += offset + QString("    <odb_temp>false</odb_temp>");
  if (line.contains("ODB_FIELD")>0)
    xml += offset + QString("    <odb_field>true</odb_field>");
  else
    xml += offset + QString("    <odb_field>false</odb_field>");
  if (line.contains("ODB_TRANSP")>0)
    xml += offset + QString("    <odb_transp>true</odb_transp>");
  else
    xml += offset + QString("    <odb_transp>false</odb_transp>");
  if (line.contains("ODB_HV_SAMP")>0)
    xml += offset + QString("    <odb_hv_samp>true</odb_hv_samp>");
  else
    xml += offset + QString("    <odb_hv_samp>false</odb_hv_samp>");
  if (line.contains("ODB_ENERGY")>0)
    xml += offset + QString("    <odb_energy>true</odb_energy>");
  else
    xml += offset + QString("    <odb_energy>false</odb_energy>");
  if (line.contains("ODB_RA_DIFF_LR")>0)
    xml += offset + QString("    <odb_ra_diff_lr>true</odb_ra_diff_lr>");
  else
    xml += offset + QString("    <odb_ra_diff_lr>false</odb_ra_diff_lr>");
  if (line.contains("ODB_RA_DIFF_TB")>0)
    xml += offset + QString("    <odb_ra_diff_tb>true</odb_ra_diff_tb>");
  else
    xml += offset + QString("    <odb_ra_diff_tb>false</odb_ra_diff_tb>");
  if (line.contains("ODB_SPIN_ROT")>0)
    xml += offset + QString("    <odb_spin_rot>true</odb_spin_rot>");
  else
    xml += offset + QString("    <odb_spin_rot>false</odb_spin_rot>");
  xml += offset + QString("  </setTitle>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertTOF
//*******************************************************************************************************
void PAutoRunParser::ConvertTOF(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  QString workStr;

  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setTOF>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  workStr = line.section(' ', 1, 1);
  workStr = workStr.section(',', 0, 0);
  workStr.remove(",");
  xml += offset + QString("    <start>%1</start>").arg(workStr);
  xml += offset + QString("    <stop>%1</stop>").arg(line.section(',', 1, 1).trimmed());
  xml += offset + QString("  </setTOF>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertWait
//*******************************************************************************************************
void PAutoRunParser::ConvertWait(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <setWait>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <wait>%1</wait>").arg(line.section(' ', 1, 1, QString::SectionSkipEmpty));
  xml += offset + QString("  </setWait>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertWarmUp
//*******************************************************************************************************
void PAutoRunParser::ConvertWarmUp(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  QString line = CheckForAlias(str);
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <warmUp>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("    <date>%1</date>").arg(line.section(' ', 1, 1).remove(",").trimmed());
  xml += offset + QString("    <time>%1</time>").arg(line.section(',', 1, 1).trimmed());
  if (line.indexOf("vent") == -1) {
    xml += offset + QString("    <vent>0</vent>");
  } else {
    xml += offset + QString("    <vent>1</vent>");
  }
  xml += offset + QString("  </warmUp>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertDegaussWEW
//*******************************************************************************************************
void PAutoRunParser::ConvertDegaussWEW(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <degaussWEW>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("  </degaussWEW>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertDegaussDanfysik
//*******************************************************************************************************
void PAutoRunParser::ConvertDegaussDanfysik(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <degaussDanfysik>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("  </degaussDanfysik>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertDegauss
//*******************************************************************************************************
void PAutoRunParser::ConvertDegauss(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <degaussMagnet>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("  </degaussMagnet>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of ConvertDegaussSpinRot
//*******************************************************************************************************
void PAutoRunParser::ConvertDegaussSpinRot(QString &str, int lineNo, QString &offset, QStringList &xml)
{
  xml += offset + QString("<autoRunCmd>");
  xml += offset + QString("  <degaussSpinRot>");
  xml += offset + QString("    <line>%1</line>").arg(lineNo);
  xml += offset + QString("    <cmd_str>%1</cmd_str>").arg(str);
  xml += offset + QString("  </degaussSpinRot>");
  xml += offset + QString("</autoRunCmd>");
}

//*******************************************************************************************************
//  implementation of Parse
//*******************************************************************************************************
void PAutoRunParser::Parse()
{
  QString errorMsg;

  // initialize xerces XML framework
  try {
    XMLPlatformUtils::Initialize();
  } catch (const XMLException &toCatch) {
    errorMsg = QString("XML xerces Error during initialization! Message:\n") +
               QString(XMLString::transcode(toCatch.getMessage()));
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_XML_INIT_ERROR , 0, errorMsg);
  }

  // create a SAX parser object
  SAX2XMLReader *parser = XMLReaderFactory::createXMLReader();
  // set all the necessary parser flags
  parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
  parser->setFeature(XMLUni::fgXercesSchema, true);
  parser->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
  // for validation scheme 'auto'
  parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
  parser->setFeature(XMLUni::fgXercesDynamic, true);

  // create XML parse handler
  PSAX2AutoRunParseHandler handler(this);
  parser->setContentHandler(&handler);
  parser->setErrorHandler(&handler);

  // do the parsing
  try {
    parser->parse(fXMLFileName.toLatin1().data());
  } catch(const OutOfMemoryException&) {
    errorMsg = QString("XML xerces: Out of Memory Exception!");
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_XML_OUT_OF_MEMORY, 0, errorMsg);
  } catch(const XMLException &e) {
    errorMsg = QString("Error during parsing in '") + fXMLFileName +
               QString("', Exception message:\n") +
               QString(XMLString::transcode(e.getMessage()));
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_XML_EXCEPTION, 0, errorMsg);
  } catch(...) {
    errorMsg = QString("");
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_XML_UNEXPECTED_EXCEPTION, 0, errorMsg);
  }

  // delete parser
  if (parser) {
    delete parser;
    parser = 0;
  }

  // terminate xerces XML framework
  XMLPlatformUtils::Terminate();

  // emit all encountered errors
  PXMLParseErrorVector::iterator it;
  for (it = fXMLParseErrorVector->begin(); it != fXMLParseErrorVector->end(); ++it) {
    emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, it->errorCode, it->lineNo, it->errorMsg);
    fParseErrorCounter++;
  }

  // clean up fXMLParseErrorVector
  fXMLParseErrorVector->clear();
}