lemAutoRun  1.0
PAutoRunParser.cpp
Go to the documentation of this file.
1 /********************************************************************************************
2 
3  PAutoRunParser.cpp
4 
5 *********************************************************************************************
6 
7  begin : Andreas Suter, 2006/03/14
8  modfied: :
9  copyright : (C) 2006 by
10  email : andreas.suter@psi.ch
11 
12 ********************************************************************************************/
13 
14 /***************************************************************************
15  * *
16  * This program is free software; you can redistribute it and/or modify *
17  * it under the terms of the GNU General Public License as published by *
18  * the Free Software Foundation; either version 2 of the License, or *
19  * (at your option) any later version. *
20  * *
21  ***************************************************************************/
22 
23 #include <iostream>
24 using namespace std;
25 
26 #include <QFile>
27 #include <QString>
28 #include <QStringList>
29 #include <QRegExp>
30 #include <QTextStream>
31 #include <QList>
32 
33 #include <xercesc/util/PlatformUtils.hpp>
34 #include <xercesc/sax2/SAX2XMLReader.hpp>
35 #include <xercesc/sax2/XMLReaderFactory.hpp>
36 #if defined(XERCES_NEW_IOSTREAMS)
37 #include <fstream>
38 #else
39 #include <fstream.h>
40 #endif
41 #include <xercesc/util/OutOfMemoryException.hpp>
42 
43 #include "lemAutoRun.h"
44 #include "PAutoRunParser.h"
45 
46 //*******************************************************************************************************
47 // implementation of the constructor
48 //*******************************************************************************************************
54 PSAX2AutoRunParseHandler::PSAX2AutoRunParseHandler(PAutoRunParser *arp)
55 {
56  fArp = arp; // keep pointer of the calling class
57 
58  // init class variables
59  fFlnAutoRunSeq = "";
60  fCurrentUserLineNo = 0;
61 
62  fKey = eEmpty;
63  fCmdKey = eEmpty;
64 
65  // get pointer to the auto run sequence vector
66  fAutoRunCmdVector = fArp->GetAutoRunCmdVector();
67 
68  // clear local auto run command structure (single instruction)
69  ClearAutoRunCmd();
70 
71  // initialize ODB tag
72  fOdbTag.tag = QString("");
73  fOdbTag.odb_path = QString("");
74  fOdbTag.idx = -1;
75 
76  fLoopNo = 0; // loop counter, needed for loops in loops ...
77 
78  fFatalError = false;
79 }
80 
81 //*******************************************************************************************************
82 // implementation of the destructor
83 //*******************************************************************************************************
87 PSAX2AutoRunParseHandler::~PSAX2AutoRunParseHandler()
88 {
89 }
90 
91 //*******************************************************************************************************
92 // implementation of the startDocument
93 //*******************************************************************************************************
97 void PSAX2AutoRunParseHandler::startDocument()
98 {
99 }
100 
101 //*******************************************************************************************************
102 // implementation of the startElement
103 //*******************************************************************************************************
112 void PSAX2AutoRunParseHandler::startElement(const XMLCh *const uri, const XMLCh *const localname,
113  const XMLCh *const qname, const Attributes &attrs)
114 {
115  if (fFatalError)
116  return;
117 
118  XMLLoopInfo loopInfo;
119 
120  if (uri) {} // in order to suppress compiler warnings
121  if (localname) {} // in order to suppress compiler warnings
122  if (attrs.getLength()) {} // in order to suppress compiler warnings
123 
124  // translate keyword to QString for simpler handling
125  QString qName = QString(XMLString::transcode(qname));
126 
127  // filter (command) key words
128  if (qName == "autoRunName") {
129  fKey = eFln;
130  } else if (qName == "line") {
131  fKey = eLineNo;
132  } else if (qName == "cmd_str") {
133  fKey = eCmdStr;
134  } else if (qName == "comment") {
135  fCmdKey = eComment;
136  fAutoRunCmd.cmd = "comment";
137  } else if (qName == "alias") {
138  fCmdKey = eAlias;
139  fAutoRunCmd.cmd = "alias";
140  } else if (qName == "ignore_alarms") {
141  fCmdKey = eIgnoreAlarms;
142  fAutoRunCmd.cmd = "ignore_alarms";
143  } else if (qName == "ignore_clients") {
144  fCmdKey = eIgnoreClients;
145  fAutoRunCmd.cmd = "ignore_clients";
146  } else if (qName == "setBPV") {
147  fCmdKey = eBPV;
148  fAutoRunCmd.cmd = "setBPV";
149  } else if (qName == "odbTag") {
150  fCmdKey = eOdbTag;
151  fAutoRunCmd.cmd = "odbTag";
152  } else if (qName == "setOdbData") {
153  fCmdKey = eSetOdbData;
154  fAutoRunCmd.cmd = "setOdbData";
155  } else if (qName == "setOdbDataArray") {
156  fCmdKey = eSetOdbDataArray;
157  fAutoRunCmd.cmd = "setOdbDataArray";
158  } else if (qName == "setTemp") {
159  fCmdKey = eSetTemp;
160  fAutoRunCmd.cmd = "setTemp";
161  fAutoRunCmd.noElements = 9;
162  } else if (qName == "setTfl") {
163  fCmdKey = eSetTfl;
164  fAutoRunCmd.cmd = "setTfl";
165  } else if (qName == "setSampleHV") {
166  fCmdKey = eSetSampleHV;
167  fAutoRunCmd.cmd = "setSampleHV";
168  } else if (qName == "setRA_HV") {
169  fCmdKey = eSetRA_HV;
170  fAutoRunCmd.cmd = "setRA_HV";
171  } else if (qName == "setTransportHV") {
172  fCmdKey = eSetTransportHV;
173  fAutoRunCmd.cmd = "setTransportHV";
174  } else if (qName == "setHVOff") {
175  fCmdKey = eSetHvOff;
176  fAutoRunCmd.cmd = "setHVOff";
177  } else if (qName == "setFieldWEWL") {
178  fCmdKey = eSetFieldWEWL;
179  fAutoRunCmd.cmd = "setFieldWEWL";
180  } else if (qName == "setFieldWEWH") {
181  fCmdKey = eSetFieldWEWH;
182  fAutoRunCmd.cmd = "setFieldWEWH";
183  } else if (qName == "setFieldDanfysik") {
184  fCmdKey = eSetFieldDanfysik;
185  fAutoRunCmd.cmd = "setFieldDanfysik";
186  } else if (qName == "setField") {
187  fCmdKey = eSetField;
188  fAutoRunCmd.cmd = "setField";
189  } else if (qName == "setSpinRot") {
190  fCmdKey = eSetSpinRot;
191  fAutoRunCmd.cmd = "setSpinRot";
192  } else if (qName == "setFOM") {
193  fCmdKey = eSetFOM;
194  fAutoRunCmd.cmd = "setFOM";
195  } else if (qName == "setTitle") {
196  fCmdKey = eSetTitle;
197  fAutoRunCmd.cmd = "setTitle";
198  } else if (qName == "setTOF") {
199  fCmdKey = eSetTOF;
200  fAutoRunCmd.cmd = "setTOF";
201  } else if (qName == "setModInfo") {
202  fCmdKey = eSetModInfo;
203  fAutoRunCmd.cmd = "setModInfo";
204  } else if (qName == "setLEMSetup") {
205  fCmdKey = eSetLEMSetup;
206  fAutoRunCmd.cmd = "setLEMSetup";
207  } else if (qName == "setWait") {
208  fCmdKey = eSetWait;
209  fAutoRunCmd.cmd = "setWait";
210  } else if (qName == "setDump") {
211  fCmdKey = eSetDump;
212  fAutoRunCmd.cmd = "setDump";
213  } else if (qName == "runStart") {
214  fCmdKey = eRunStart;
215  fAutoRunCmd.cmd = "runStart";
216  } else if (qName == "runStop") {
217  fCmdKey = eRunStop;
218  fAutoRunCmd.cmd = "runStop";
219  } else if (qName == "warmUp") {
220  fCmdKey = eWarmUp;
221  fAutoRunCmd.cmd = "warmUp";
222  } else if (qName == "degaussWEW") {
223  fCmdKey = eDegaussWEW;
224  fAutoRunCmd.cmd = "degaussWEW";
225  } else if (qName == "degaussDanfysik") {
226  fCmdKey = eDegaussDanfysik;
227  fAutoRunCmd.cmd = "degaussDanfysik";
228  } else if (qName == "degaussMagnet") {
229  fCmdKey = eDegauss;
230  fAutoRunCmd.cmd = "degaussMagnet";
231  } else if (qName == "degaussSpinRot") {
232  fCmdKey = eDegaussSpinRot;
233  fAutoRunCmd.cmd = "degaussSpinRot";
234  } else if (qName == "comment_line") {
235  fKey = eCommentLine;
236  } else if (qName == "alias_key") {
237  fKey = eAlias_key;
238  } else if (qName == "alias_value") {
239  fKey = eAlias_value;
240  } else if (qName == "loop") {
241  fCmdKey = eLoop;
242  fLoopNo++;
243  fLoopInfoVector.push_back(loopInfo);
244  } else if (qName == "loopList") {
245  fCmdKey = eLoopList;
246  } else if (qName == "loopElement") {
247  fKey = eLoopElement;
248  } else if (qName == "loopIterator") {
249  fCmdKey = eLoopIterator;
250  } else if (qName == "loopStart") {
251  fKey = eLoopStart;
252  } else if (qName == "loopStop") {
253  fKey = eLoopStop;
254  } else if (qName == "loopStep") {
255  fKey = eLoopStep;
256  } else if (qName == "loopSetTemp") {
257  fCmdKey = eLoopSetTemp;
258  fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetTemp";
259  fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
260  } else if (qName == "loopTempTag") {
261  fKey = eLoopTempTag;
262  } else if (qName == "loopSetSampleHV") {
263  fCmdKey = eLoopSetSampleHV;
264  fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetSampleHV";
265  fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
266  } else if (qName == "loopSampleHVTag") {
267  fKey = eLoopSampleHVTag;
268  } else if (qName == "loopSetFieldWEWL") {
269  fCmdKey = eLoopSetFieldWEWL;
270  fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetFieldWEWL";
271  fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
272  } else if (qName == "loopSetFieldWEWH") {
273  fCmdKey = eLoopSetFieldWEWH;
274  fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetFieldWEWH";
275  fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
276  } else if (qName == "loopSetFieldDanfysik") {
277  fCmdKey = eLoopSetFieldDanfysik;
278  fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetFieldDanfysik";
279  fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
280  } else if (qName == "loopSetField") {
281  fCmdKey = eLoopSetField;
282  fLoopInfoVector[fLoopNo-1].loopCmd.cmd = "loopSetField";
283  fLoopInfoVector[fLoopNo-1].loopCmd.noElements = 0;
284  } else if (qName == "loopFieldTag") {
285  fKey = eLoopFieldTag;
286  } else if (qName == "set_path") {
287  fKey = eOdbSetPath;
288  } else if (qName == "set_index") {
289  fKey = eOdbSetIndex;
290  } else if (qName == "set_value") {
291  fKey = eOdbSetValue;
292  } else if (qName == "read_path") {
293  fKey = eOdbReadPath;
294  } else if (qName == "read_index") {
295  fKey = eOdbReadIndex;
296  } else if (qName == "timeout") {
297  fKey = eOdbTimeout;
298  } else if (qName == "tolerance") {
299  fKey = eOdbTolerance;
300  } else if (qName == "tfl_pos") {
301  fKey = eTfl_pos;
302  } else if (qName == "tfl_mode") {
303  fKey = eTfl_mode;
304  } else if (qName == "temp") {
305  fKey = eTemp;
306  } else if (qName == "deltaT") {
307  fKey = eDeltaT;
308  } else if (qName == "ramp") {
309  fKey = eRamp;
310  } else if (qName == "heaterRange") {
311  fKey = eHeaterRange;
312  } else if (qName == "stabilityTimeout") {
313  fKey = eStabilityTimeout;
314  } else if (qName == "P_PID") {
315  fKey = eP_pid;
316  } else if (qName == "I_PID") {
317  fKey = eI_pid;
318  } else if (qName == "D_PID") {
319  fKey = eD_pid;
320  } else if (qName == "flow") {
321  fKey = eFlow;
322  } else if (qName == "hv_value") {
323  fKey = eHv_value;
324  } else if (qName == "hv_left") {
325  fKey = eHv_left;
326  } else if (qName == "hv_right") {
327  fKey = eHv_right;
328  } else if (qName == "hv_top") {
329  fKey = eHv_top;
330  } else if (qName == "hv_bottom") {
331  fKey = eHv_bottom;
332  } else if (qName == "transportHvSettingFileName") {
333  fKey = eTransportHvSettingFileName;
334  } else if (qName == "field_value") {
335  fKey = eField_value;
336  } else if (qName == "field_unit") {
337  fKey = eField_unit;
338  } else if (qName == "title") {
339  fKey = eTitle;
340  } else if (qName == "odb_sample") {
341  fKey = eOdb_sample;
342  } else if (qName == "odb_temp") {
343  fKey = eOdb_temp;
344  } else if (qName == "odb_field") {
345  fKey = eOdb_field;
346  } else if (qName == "odb_transp") {
347  fKey = eOdb_transp;
348  } else if (qName == "odb_hv_samp") {
349  fKey = eOdb_hv_samp;
350  } else if (qName == "odb_energy") {
351  fKey = eOdb_energy;
352  } else if (qName == "odb_ra_diff_lr") {
353  fKey = eOdb_ra_diff_lr;
354  } else if (qName == "odb_ra_diff_tb") {
355  fKey = eOdb_ra_diff_tb;
356  } else if (qName == "odb_spin_rot") {
357  fKey = eOdb_spin_rot;
358  } else if (qName == "start") {
359  fKey = eStart;
360  } else if (qName == "stop") {
361  fKey = eStop;
362  } else if (qName == "units") {
363  fKey = eUnits;
364  } else if (qName == "mod") {
365  fKey = eMod;
366  } else if (qName == "mod_date") {
367  fKey = eMod_date;
368  } else if (qName == "setup") {
369  fKey = eSetup;
370  } else if (qName == "wait") {
371  fKey = eWait;
372  } else if (qName == "no_events") {
373  fKey = eNo_events;
374  } else if (qName == "no_dumps") {
375  fKey = eNo_dumps;
376  } else if (qName == "date") {
377  fKey = eDate;
378  } else if (qName == "time") {
379  fKey = eTime;
380  } else if (qName == "vent") {
381  fKey = eVent;
382  } else if (qName == "current") {
383  fKey = eCurrent;
384  } else if (qName == "angle") {
385  fKey = eAngle;
386  } else if (qName == "no_degauss") {
387  fKey = eNoDegauss;
388  } else if (qName == "chamber") {
389  fKey = eChamber;
390  } else if (qName == "label") {
391  fKey = eLabel;
392  } else if (qName == "state") {
393  fKey = eState;
394  }
395 }
396 
397 //*******************************************************************************************************
398 // implementation of the characters
399 //*******************************************************************************************************
406 void PSAX2AutoRunParseHandler::characters(const XMLCh *const chars, const XMLSize_t)
407 {
408  if (fFatalError)
409  return;
410 
411  // keep some global information
412  QString str("");
413  switch (fKey) {
414  case eFln:
415  fFlnAutoRunSeq = QString(XMLString::transcode(chars));
416  break;
417  case eLineNo:
418  fCurrentUserLineNo = QString(XMLString::transcode(chars)).toInt();
419  break;
420  default:
421  break;
422  }
423 
424  if (fCmdKey == eComment) {
425  switch (fKey) {
426  case eLineNo:
427  fAutoRunCmd.lineNo = fCurrentUserLineNo;
428  break;
429  case eCmdStr:
430  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
431  break;
432  default:
433  break;
434  }
435  }
436 
437  if (fCmdKey == eIgnoreAlarms) {
438  switch (fKey) {
439  case eLineNo:
440  fAutoRunCmd.lineNo = fCurrentUserLineNo;
441  break;
442  case eCmdStr:
443  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
444  break;
445  case eState:
446  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
447  break;
448  default:
449  break;
450  }
451  }
452 
453  if (fCmdKey == eIgnoreClients) {
454  switch (fKey) {
455  case eLineNo:
456  fAutoRunCmd.lineNo = fCurrentUserLineNo;
457  break;
458  case eCmdStr:
459  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
460  break;
461  case eState:
462  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
463  break;
464  default:
465  break;
466  }
467  }
468 
469  if (fCmdKey == eAlias) {
470  switch (fKey) {
471  case eLineNo:
472  fAutoRunCmd.lineNo = fCurrentUserLineNo;
473  break;
474  case eCmdStr:
475  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
476  break;
477  case eAlias_key:
478  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
479  fAutoRunCmd.noElements++;
480  break;
481  case eAlias_value:
482  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
483  fAutoRunCmd.noElements++;
484  break;
485  default:
486  break;
487  }
488  }
489 
490  if (fCmdKey == eBPV) {
491  switch (fKey) {
492  case eLineNo:
493  fAutoRunCmd.lineNo = fCurrentUserLineNo;
494  break;
495  case eCmdStr:
496  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
497  break;
498  case eLabel:
499  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
500  fAutoRunCmd.noElements++;
501  break;
502  case eState:
503  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
504  fAutoRunCmd.noElements++;
505  break;
506  default:
507  break;
508  }
509  }
510 
511  if (fCmdKey == eOdbTag) {
512  switch (fKey) {
513  case eLineNo:
514  fAutoRunCmd.lineNo = fCurrentUserLineNo;
515  break;
516  case eCmdStr:
517  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
518  break;
519  case eLabel:
520  fOdbTag.tag = QString(XMLString::transcode(chars));
521  break;
522  case eOdbReadPath:
523  fOdbTag.odb_path = QString(XMLString::transcode(chars));
524  break;
525  case eOdbReadIndex:
526  fOdbTag.idx = QString(XMLString::transcode(chars)).toInt();
527  break;
528  default:
529  break;
530  }
531  }
532 
533  if (fCmdKey == eDegaussWEW) { // collect degauss cmd for the WEW magnet
534  switch (fKey) {
535  case eLineNo:
536  fAutoRunCmd.lineNo = fCurrentUserLineNo;
537  break;
538  case eCmdStr:
539  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
540  break;
541  default:
542  break;
543  }
544  }
545 
546  if (fCmdKey == eDegaussDanfysik) { // collect degauss cmd for the danfysik power supply
547  switch (fKey) {
548  case eLineNo:
549  fAutoRunCmd.lineNo = fCurrentUserLineNo;
550  break;
551  case eCmdStr:
552  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
553  break;
554  default:
555  break;
556  }
557  }
558 
559  if (fCmdKey == eDegauss) { // collect degauss cmd for the sample magnet
560  switch (fKey) {
561  case eLineNo:
562  fAutoRunCmd.lineNo = fCurrentUserLineNo;
563  break;
564  case eCmdStr:
565  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
566  break;
567  default:
568  break;
569  }
570  }
571 
572  if (fCmdKey == eDegaussSpinRot) { // collect degauss cmd for the spin rotator
573  switch (fKey) {
574  case eLineNo:
575  fAutoRunCmd.lineNo = fCurrentUserLineNo;
576  break;
577  case eCmdStr:
578  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
579  break;
580  default:
581  break;
582  }
583  }
584 
585  if (fCmdKey == eSetOdbData) { // collect set odb data
586  switch (fKey) {
587  case eLineNo:
588  fAutoRunCmd.lineNo = fCurrentUserLineNo;
589  break;
590  case eCmdStr:
591  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
592  break;
593  case eOdbSetPath:
594  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
595  fAutoRunCmd.noElements++;
596  break;
597  case eOdbSetIndex:
598  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
599  fAutoRunCmd.noElements++;
600  break;
601  case eOdbSetValue:
602  fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
603  fAutoRunCmd.noElements++;
604  break;
605  case eOdbReadPath:
606  fAutoRunCmd.param[3] = QString(XMLString::transcode(chars));
607  fAutoRunCmd.noElements++;
608  break;
609  case eOdbReadIndex:
610  fAutoRunCmd.param[4] = QString(XMLString::transcode(chars));
611  fAutoRunCmd.noElements++;
612  break;
613  case eOdbTimeout:
614  fAutoRunCmd.param[5] = QString(XMLString::transcode(chars));
615  fAutoRunCmd.noElements++;
616  break;
617  case eOdbTolerance:
618  fAutoRunCmd.param[6] = QString(XMLString::transcode(chars));
619  fAutoRunCmd.noElements++;
620  break;
621  default:
622  break;
623  }
624  }
625 
626  if (fCmdKey == eSetOdbDataArray) {
627  switch (fKey) {
628  case eLineNo:
629  fAutoRunCmd.lineNo = fCurrentUserLineNo;
630  break;
631  case eCmdStr:
632  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
633  break;
634  case eOdbSetPath:
635  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
636  fAutoRunCmd.noElements++;
637  break;
638  case eOdbSetValue:
639  fAutoRunCmd.param[fAutoRunCmd.noElements++] = QString(XMLString::transcode(chars));
640  break;
641  default:
642  break;
643  }
644  }
645 
646  if (fCmdKey == eSetTfl) { // collect set tfl cmd
647  switch (fKey) {
648  case eLineNo:
649  fAutoRunCmd.lineNo = fCurrentUserLineNo;
650  break;
651  case eCmdStr:
652  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
653  break;
654  case eTfl_pos:
655  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
656  fAutoRunCmd.noElements++;
657  break;
658  case eTfl_mode:
659  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
660  fAutoRunCmd.noElements++;
661  break;
662  default:
663  break;
664  }
665  }
666 
667  if (fCmdKey == eSetTemp) { // collect set temp cmd
668  switch (fKey) {
669  case eLineNo:
670  fAutoRunCmd.lineNo = fCurrentUserLineNo;
671  break;
672  case eCmdStr:
673  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
674  break;
675  case eTemp:
676  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
677  break;
678  case eDeltaT:
679  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
680  break;
681  case eStabilityTimeout:
682  fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
683  break;
684  case eRamp:
685  fAutoRunCmd.param[3] = QString(XMLString::transcode(chars));
686  break;
687  case eHeaterRange:
688  fAutoRunCmd.param[4] = QString(XMLString::transcode(chars));
689  break;
690  case eP_pid:
691  fAutoRunCmd.param[5] = QString(XMLString::transcode(chars));
692  break;
693  case eI_pid:
694  fAutoRunCmd.param[6] = QString(XMLString::transcode(chars));
695  break;
696  case eD_pid:
697  fAutoRunCmd.param[7] = QString(XMLString::transcode(chars));
698  break;
699  case eFlow:
700  fAutoRunCmd.param[8] = QString(XMLString::transcode(chars));
701  break;
702  default:
703  break;
704  }
705  }
706 
707  if (fCmdKey == eSetSampleHV) { // collect sample HV cmd
708  switch (fKey) {
709  case eLineNo:
710  fAutoRunCmd.lineNo = fCurrentUserLineNo;
711  break;
712  case eCmdStr:
713  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
714  break;
715  case eHv_value:
716  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
717  fAutoRunCmd.noElements++;
718  break;
719  default:
720  break;
721  }
722  }
723 
724  if (fCmdKey == eSetRA_HV) { // collect ring anode HV cmd
725  switch (fKey) {
726  case eLineNo:
727  fAutoRunCmd.lineNo = fCurrentUserLineNo;
728  break;
729  case eCmdStr:
730  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
731  break;
732  case eHv_left:
733  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
734  fAutoRunCmd.noElements++;
735  break;
736  case eHv_right:
737  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
738  fAutoRunCmd.noElements++;
739  break;
740  case eHv_top:
741  fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
742  fAutoRunCmd.noElements++;
743  break;
744  case eHv_bottom:
745  fAutoRunCmd.param[3] = QString(XMLString::transcode(chars));
746  fAutoRunCmd.noElements++;
747  break;
748  default:
749  break;
750  }
751  }
752 
753  if (fCmdKey == eSetTransportHV) {
754  switch (fKey) {
755  case eLineNo:
756  fAutoRunCmd.lineNo = fCurrentUserLineNo;
757  break;
758  case eCmdStr:
759  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
760  break;
761  case eTransportHvSettingFileName:
762  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
763  fAutoRunCmd.noElements++;
764  break;
765  default:
766  break;
767  }
768  }
769 
770  if (fCmdKey == eSetHvOff) {
771  switch (fKey) {
772  case eLineNo:
773  fAutoRunCmd.lineNo = fCurrentUserLineNo;
774  break;
775  case eCmdStr:
776  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
777  break;
778  case eChamber:
779  str = QString(XMLString::transcode(chars));
780  if (!str.contains("mc", Qt::CaseInsensitive) && !str.contains("tc", Qt::CaseInsensitive) &&
781  !str.contains("sc", Qt::CaseInsensitive)) {
782  QString err = QString("PSAX2AutoRunParseHandler::characters: found chamber name '%1' which is not supported").arg(str);
783  internalFatalError(err);
784  }
785  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
786  fAutoRunCmd.noElements++;
787  break;
788  default:
789  break;
790  }
791  }
792 
793  if (fCmdKey == eSetFieldWEWL) { // collect set field WEWL cmd
794  switch (fKey) {
795  case eLineNo:
796  fAutoRunCmd.lineNo = fCurrentUserLineNo;
797  break;
798  case eCmdStr:
799  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
800  break;
801  case eField_value:
802  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
803  fAutoRunCmd.noElements++;
804  break;
805  case eField_unit:
806  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
807  fAutoRunCmd.noElements++;
808  default:
809  break;
810  }
811  }
812 
813  if (fCmdKey == eSetFieldWEWH) { // collect set field WEWH cmd
814  switch (fKey) {
815  case eLineNo:
816  fAutoRunCmd.lineNo = fCurrentUserLineNo;
817  break;
818  case eCmdStr:
819  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
820  break;
821  case eField_value:
822  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
823  fAutoRunCmd.noElements++;
824  break;
825  case eField_unit:
826  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
827  fAutoRunCmd.noElements++;
828  default:
829  break;
830  }
831  }
832 
833  if (fCmdKey == eSetFieldDanfysik) { // collect set field Danfysik cmd
834  switch (fKey) {
835  case eLineNo:
836  fAutoRunCmd.lineNo = fCurrentUserLineNo;
837  break;
838  case eCmdStr:
839  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
840  break;
841  case eField_value:
842  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
843  fAutoRunCmd.noElements++;
844  break;
845  case eField_unit:
846  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
847  fAutoRunCmd.noElements++;
848  default:
849  break;
850  }
851  }
852 
853  if (fCmdKey == eSetField) { // collect set field sample magnet cmd
854  switch (fKey) {
855  case eLineNo:
856  fAutoRunCmd.lineNo = fCurrentUserLineNo;
857  break;
858  case eCmdStr:
859  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
860  break;
861  case eField_value:
862  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
863  fAutoRunCmd.noElements++;
864  break;
865  case eField_unit:
866  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
867  fAutoRunCmd.noElements++;
868  default:
869  break;
870  }
871  }
872 
873  if (fCmdKey == eSetSpinRot) {
874  switch (fKey) {
875  case eLineNo:
876  fAutoRunCmd.lineNo = fCurrentUserLineNo;
877  break;
878  case eCmdStr:
879  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
880  break;
881  case eAngle:
882  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
883  fAutoRunCmd.noElements++;
884  break;
885  case eNoDegauss:
886  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
887  fAutoRunCmd.noElements++;
888  break;
889  default:
890  break;
891  }
892  }
893 
894  if (fCmdKey == eSetFOM) { // collect set FOM cmd
895  switch (fKey) {
896  case eLineNo:
897  fAutoRunCmd.lineNo = fCurrentUserLineNo;
898  break;
899  case eCmdStr:
900  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
901  break;
902  case eCurrent:
903  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
904  fAutoRunCmd.noElements++;
905  break;
906  default:
907  break;
908  }
909  }
910 
911  if (fCmdKey == eSetTitle) { // collect set title cmd
912  switch (fKey) {
913  case eLineNo:
914  fAutoRunCmd.lineNo = fCurrentUserLineNo;
915  break;
916  case eCmdStr:
917  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
918  break;
919  case eTitle:
920  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
921  fAutoRunCmd.noElements++;
922  break;
923  case eOdb_sample:
924  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
925  fAutoRunCmd.noElements++;
926  break;
927  case eOdb_temp:
928  fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
929  fAutoRunCmd.noElements++;
930  break;
931  case eOdb_field:
932  fAutoRunCmd.param[3] = QString(XMLString::transcode(chars));
933  fAutoRunCmd.noElements++;
934  break;
935  case eOdb_transp:
936  fAutoRunCmd.param[4] = QString(XMLString::transcode(chars));
937  fAutoRunCmd.noElements++;
938  break;
939  case eOdb_hv_samp:
940  fAutoRunCmd.param[5] = QString(XMLString::transcode(chars));
941  fAutoRunCmd.noElements++;
942  break;
943  case eOdb_energy:
944  fAutoRunCmd.param[6] = QString(XMLString::transcode(chars));
945  fAutoRunCmd.noElements++;
946  break;
947  case eOdb_ra_diff_lr:
948  fAutoRunCmd.param[7] = QString(XMLString::transcode(chars));
949  fAutoRunCmd.noElements++;
950  break;
951  case eOdb_ra_diff_tb:
952  fAutoRunCmd.param[8] = QString(XMLString::transcode(chars));
953  fAutoRunCmd.noElements++;
954  break;
955  case eOdb_spin_rot:
956  fAutoRunCmd.param[9] = QString(XMLString::transcode(chars));
957  fAutoRunCmd.noElements++;
958  break;
959  default:
960  break;
961  }
962  }
963 
964  if (fCmdKey == eSetTOF) { // collect set TOF cmd
965  switch (fKey) {
966  case eLineNo:
967  fAutoRunCmd.lineNo = fCurrentUserLineNo;
968  break;
969  case eCmdStr:
970  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
971  break;
972  case eStart:
973  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
974  fAutoRunCmd.noElements++;
975  break;
976  case eStop:
977  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
978  fAutoRunCmd.noElements++;
979  break;
980  default:
981  break;
982  }
983  }
984 
985  if (fCmdKey == eSetModInfo) { // collect set moderator info cmd
986  switch (fKey) {
987  case eLineNo:
988  fAutoRunCmd.lineNo = fCurrentUserLineNo;
989  break;
990  case eCmdStr:
991  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
992  break;
993  case eMod:
994  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
995  fAutoRunCmd.noElements++;
996  break;
997  case eMod_date:
998  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
999  fAutoRunCmd.noElements++;
1000  break;
1001  default:
1002  break;
1003  }
1004  }
1005 
1006  if (fCmdKey == eSetLEMSetup) { // collect set LEM setup info cmd
1007  switch (fKey) {
1008  case eLineNo:
1009  fAutoRunCmd.lineNo = fCurrentUserLineNo;
1010  break;
1011  case eCmdStr:
1012  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1013  break;
1014  case eSetup:
1015  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
1016  fAutoRunCmd.noElements++;
1017  break;
1018  default:
1019  break;
1020  }
1021  }
1022 
1023  if (fCmdKey == eSetWait) { // collect set wait cmd
1024  switch (fKey) {
1025  case eLineNo:
1026  fAutoRunCmd.lineNo = fCurrentUserLineNo;
1027  break;
1028  case eCmdStr:
1029  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1030  break;
1031  case eWait:
1032  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
1033  fAutoRunCmd.noElements++;
1034  break;
1035  default:
1036  break;
1037  }
1038  }
1039 
1040  if (fCmdKey == eSetDump) { // collect set dump cmd
1041  switch (fKey) {
1042  case eLineNo:
1043  fAutoRunCmd.lineNo = fCurrentUserLineNo;
1044  break;
1045  case eCmdStr:
1046  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1047  break;
1048  case eNo_dumps:
1049  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
1050  fAutoRunCmd.noElements++;
1051  break;
1052  default:
1053  break;
1054  }
1055  }
1056 
1057  if (fCmdKey == eRunStart) { // collect run start cmd
1058  switch (fKey) {
1059  case eLineNo:
1060  fAutoRunCmd.lineNo = fCurrentUserLineNo;
1061  break;
1062  case eCmdStr:
1063  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1064  break;
1065  case eNo_events:
1066  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
1067  fAutoRunCmd.noElements++;
1068  break;
1069  case eUnits:
1070  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
1071  fAutoRunCmd.noElements++;
1072  if (fAutoRunCmd.param[1].toLower() != "sec") {
1073  QString err = QString("PSAX2AutoRunParseHandler::characters: found units '%1' in START command. Currently only 'sec' are supported!").arg(fAutoRunCmd.param[1].toLower());
1074  internalFatalError(err);
1075  }
1076  break;
1077  default:
1078  break;
1079  }
1080  }
1081 
1082  if (fCmdKey == eRunStop) { // collect run stop cmd
1083  switch (fKey) {
1084  case eLineNo:
1085  fAutoRunCmd.lineNo = fCurrentUserLineNo;
1086  break;
1087  case eCmdStr:
1088  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1089  break;
1090  case eNo_events:
1091  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
1092  fAutoRunCmd.noElements++;
1093  break;
1094  case eUnits:
1095  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
1096  fAutoRunCmd.noElements++;
1097  if (fAutoRunCmd.param[1].toLower() != "sec") {
1098  QString err = QString("PSAX2AutoRunParseHandler::characters: found units '%1' in STOP command. Currently only 'sec' are supported!").arg(fAutoRunCmd.param[1].toLower());
1099  internalFatalError(err);
1100  }
1101  break;
1102  default:
1103  break;
1104  }
1105  }
1106 
1107  if (fCmdKey == eWarmUp) { // collect warm up cmd
1108  switch (fKey) {
1109  case eLineNo:
1110  fAutoRunCmd.lineNo = fCurrentUserLineNo;
1111  break;
1112  case eCmdStr:
1113  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1114  break;
1115  case eDate:
1116  fAutoRunCmd.param[0] = QString(XMLString::transcode(chars));
1117  fAutoRunCmd.noElements++;
1118  break;
1119  case eTime:
1120  fAutoRunCmd.param[1] = QString(XMLString::transcode(chars));
1121  fAutoRunCmd.noElements++;
1122  break;
1123  case eVent:
1124  fAutoRunCmd.param[2] = QString(XMLString::transcode(chars));
1125  fAutoRunCmd.noElements++;
1126  break;
1127  default:
1128  break;
1129  }
1130  }
1131 
1132  if (fCmdKey == eLoopList) { // collect loop list elements
1133  switch (fKey) {
1134  case eLoopElement:
1135  if (fLoopNo <= 0) { // fatal error
1136  // stop parsing
1137  QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
1138  internalFatalError(err);
1139  fFatalError = true;
1140  return;
1141  } else {
1142  fLoopInfoVector[fLoopNo-1].list.push_back(QString(XMLString::transcode(chars)).toDouble());
1143  }
1144  default:
1145  break;
1146  }
1147  }
1148 
1149  if (fCmdKey == eLoopIterator) { // collect start, stop, step of the loop iterator
1150  if (fLoopNo <= 0) { // fatal error
1151  // stop parsing
1152  QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
1153  internalFatalError(err);
1154  fFatalError = true;
1155  return;
1156  }
1157  switch (fKey) {
1158  case eLoopStart:
1159  fLoopInfoVector[fLoopNo-1].iterator[0] = QString(XMLString::transcode(chars)).toDouble();
1160  break;
1161  case eLoopStop:
1162  fLoopInfoVector[fLoopNo-1].iterator[1] = QString(XMLString::transcode(chars)).toDouble();
1163  break;
1164  case eLoopStep:
1165  fLoopInfoVector[fLoopNo-1].iterator[2] = QString(XMLString::transcode(chars)).toDouble();
1166  break;
1167  default:
1168  break;
1169  }
1170  }
1171 
1172  if (fCmdKey == eLoopSetTemp) { // collect loop set temperature command information
1173  if (fLoopNo <= 0) { // fatal error
1174  // stop parsing
1175  QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
1176  internalFatalError(err);
1177  fFatalError = true;
1178  return;
1179  }
1180  switch (fKey) {
1181  case eLineNo:
1182  fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
1183  break;
1184  case eLoopTempTag:
1185  fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
1186  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1187  break;
1188  case eDeltaT:
1189  fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
1190  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1191  break;
1192  case eStabilityTimeout:
1193  fLoopInfoVector[fLoopNo-1].loopCmd.param[2] = QString(XMLString::transcode(chars));
1194  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1195  break;
1196  case eRamp:
1197  fLoopInfoVector[fLoopNo-1].loopCmd.param[3] = QString(XMLString::transcode(chars));
1198  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1199  break;
1200  default:
1201  break;
1202  }
1203  }
1204 
1205  if (fCmdKey == eLoopSetSampleHV) { // collect loop set sample HV command information
1206  if (fLoopNo <= 0) { // fatal error
1207  // stop parsing
1208  QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
1209  internalFatalError(err);
1210  fFatalError = true;
1211  return;
1212  }
1213  switch (fKey) {
1214  case eLineNo:
1215  fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
1216  break;
1217  case eCmdStr:
1218  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1219  break;
1220  case eLoopSampleHVTag:
1221  fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
1222  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1223  break;
1224  default:
1225  break;
1226  }
1227  }
1228 
1229  if (fCmdKey == eLoopSetFieldWEWL) { // collect loop set field WEWL command information
1230  if (fLoopNo <= 0) { // fatal error
1231  // stop parsing
1232  QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
1233  internalFatalError(err);
1234  fFatalError = true;
1235  return;
1236  }
1237  switch (fKey) {
1238  case eLineNo:
1239  fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
1240  break;
1241  case eCmdStr:
1242  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1243  break;
1244  case eLoopFieldTag:
1245  fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
1246  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1247  break;
1248  case eField_unit:
1249  fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
1250  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1251  break;
1252  default:
1253  break;
1254  }
1255  }
1256 
1257  if (fCmdKey == eLoopSetFieldWEWH) { // collect loop set field WEWH command information
1258  if (fLoopNo <= 0) { // fatal error
1259  // stop parsing
1260  QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
1261  internalFatalError(err);
1262  fFatalError = true;
1263  return;
1264  }
1265  switch (fKey) {
1266  case eLineNo:
1267  fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
1268  break;
1269  case eCmdStr:
1270  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1271  break;
1272  case eLoopFieldTag:
1273  fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
1274  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1275  break;
1276  case eField_unit:
1277  fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
1278  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1279  break;
1280  default:
1281  break;
1282  }
1283  }
1284 
1285  if (fCmdKey == eLoopSetFieldDanfysik) { // collect loop set field Danfysik command information
1286  if (fLoopNo <= 0) { // fatal error
1287  // stop parsing
1288  QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
1289  internalFatalError(err);
1290  fFatalError = true;
1291  return;
1292  }
1293  switch (fKey) {
1294  case eLineNo:
1295  fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
1296  break;
1297  case eCmdStr:
1298  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1299  break;
1300  case eLoopFieldTag:
1301  fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
1302  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1303  break;
1304  case eField_unit:
1305  fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
1306  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1307  break;
1308  default:
1309  break;
1310  }
1311  }
1312 
1313  if (fCmdKey == eLoopSetField) { // collect loop set field sample magnet command information
1314  if (fLoopNo <= 0) { // fatal error
1315  // stop parsing
1316  QString err("PSAX2AutoRunParseHandler::characters: negative loop fall back!");
1317  internalFatalError(err);
1318  fFatalError = true;
1319  return;
1320  }
1321  switch (fKey) {
1322  case eLineNo:
1323  fLoopInfoVector[fLoopNo-1].loopCmd.lineNo = fCurrentUserLineNo;
1324  break;
1325  case eCmdStr:
1326  fAutoRunCmd.cmdString = QString(XMLString::transcode(chars));
1327  break;
1328  case eLoopFieldTag:
1329  fLoopInfoVector[fLoopNo-1].loopCmd.param[0] = QString(XMLString::transcode(chars));
1330  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1331  break;
1332  case eField_unit:
1333  fLoopInfoVector[fLoopNo-1].loopCmd.param[1] = QString(XMLString::transcode(chars));
1334  fLoopInfoVector[fLoopNo-1].loopCmd.noElements++;
1335  break;
1336  default:
1337  break;
1338  }
1339  }
1340 }
1341 
1342 //*******************************************************************************************************
1343 // implementation of the endElement
1344 //*******************************************************************************************************
1352 void PSAX2AutoRunParseHandler::endElement(const XMLCh *const uri, const XMLCh *const localname,
1353  const XMLCh *const qname)
1354 {
1355  if (fFatalError)
1356  return;
1357 
1358  if (uri) {} // in order to suppress compiler warnings
1359  if (localname) {} // in order to suppress compiler warnings
1360 
1361  QString qName = QString(XMLString::transcode(qname));
1362 
1363  fKey = eEmpty;
1364 
1365  if (qName == "odbTag") {
1366  if ((fOdbTag.tag == "") || (fOdbTag.odb_path == "")) {
1367  // stop parsing
1368  QString err("PSAX2AutoRunParseHandler::endElement: ODB tag not complete");
1369  internalFatalError(err);
1370  fFatalError = true;
1371  return;
1372  }
1373  fArp->fOdbTagVector->push_back(fOdbTag);
1374  }
1375 
1376  if ((qName == "comment") || (qName == "alias") || (qName == "ignore_alarms") || (qName == "ignore_clients") || (qName == "odbTag") ||
1377  (qName == "setBPV") || (qName == "setTfl") || (qName == "setTemp") || (qName == "setSampleHV") || (qName == "setRA_HV") ||
1378  (qName == "setTransportHV") || (qName == "setFieldWEWL") || (qName == "setFieldWEWH") || (qName == "setFieldDanfysik") ||
1379  (qName == "setField") || (qName == "setSpinRot") || (qName == "setTitle") || (qName == "setTOF") || (qName == "setModInfo") ||
1380  (qName == "setLEMSetup") || (qName == "setWait") || (qName == "setDump") ||
1381  (qName == "runStart") || (qName == "runStop") || (qName == "warmUp") ||
1382  (qName == "degaussDanfysik") || (qName == "degaussWEW") || (qName == "degaussMagnet") || (qName == "degaussSpinRot") ||
1383  (qName == "setFOM") || (qName == "setOdbData") || (qName == "setOdbDataArray") || (qName == "setHVOff")) {
1384 
1385  if (qName == "setOdbData")
1386  CheckOdbSetDataParamsStructure();
1387 
1388  if (fLoopNo == 0)
1389  fAutoRunCmdVector->push_back(fAutoRunCmd);
1390  else
1391  fLoopInfoVector[fLoopNo-1].cmd.push_back(fAutoRunCmd);
1392  ClearAutoRunCmd();
1393  }
1394 
1395  if (qName == "loopIterator") { // convert start, stop, step to a list
1396  int no_elements = -1;
1397 
1398  if (fLoopInfoVector[fLoopNo-1].iterator[2] == 0.0) { // fatal error
1399  // stop parsing
1400  QString err("PSAX2AutoRunParseHandler::endElement: loop step iterator == 0!");
1401  internalFatalError(err);
1402  fFatalError = true;
1403  return;
1404  } else {
1405  no_elements = (int)round(round(fLoopInfoVector[fLoopNo-1].iterator[1] -
1406  fLoopInfoVector[fLoopNo-1].iterator[0]) / fLoopInfoVector[fLoopNo-1].iterator[2])+1;
1407 
1408  for (int i=0; i<no_elements; i++)
1409  fLoopInfoVector[fLoopNo-1].list.push_back(fLoopInfoVector[fLoopNo-1].iterator[0] +
1410  i*fLoopInfoVector[fLoopNo-1].iterator[2]);
1411  }
1412  }
1413 
1414  if (qName == "loop") {
1415  // expand loop cmd's
1416  AutoRunCmd expandedLoopCmd;
1417 
1418  expandedLoopCmd.lineNo = fLoopInfoVector[fLoopNo-1].loopCmd.lineNo;
1419  expandedLoopCmd.noElements = fLoopInfoVector[fLoopNo-1].loopCmd.noElements;
1420  for (int i=1; i<fLoopInfoVector[fLoopNo-1].loopCmd.noElements; i++)
1421  expandedLoopCmd.param[i] = fLoopInfoVector[fLoopNo-1].loopCmd.param[i];
1422 
1423  // filter what loop cmd it is
1424  if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetTemp") {
1425  expandedLoopCmd.cmd = "setTemp";
1426  } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetSampleHV") {
1427  expandedLoopCmd.cmd = "setSampleHV";
1428  } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetFieldWEWL") {
1429  expandedLoopCmd.cmd = "setFieldWEWL";
1430  } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetFieldWEWH") {
1431  expandedLoopCmd.cmd = "setFieldWEWH";
1432  } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetFieldDanfysik") {
1433  expandedLoopCmd.cmd = "setFieldDanfysik";
1434  } else if (fLoopInfoVector[fLoopNo-1].loopCmd.cmd == "loopSetField") {
1435  expandedLoopCmd.cmd = "setField";
1436  } else { // fatal error
1437  // stop parsing
1438  QString err("PSAX2AutoRunParseHandler::endElement: syntactically incorrect command!");
1439  internalFatalError(err);
1440  fFatalError = true;
1441  return;
1442  }
1443 
1444  // loop over all elements in the list
1445  PXMLLoopListVector::Iterator listIter;
1446  PAutoRunCmdVector::Iterator cmdIter;
1447 
1448  for (listIter = fLoopInfoVector[fLoopNo-1].list.begin();
1449  listIter != fLoopInfoVector[fLoopNo-1].list.end(); ++listIter) {
1450 
1451  expandedLoopCmd.param[0] = QString("%1").arg(*listIter); // copy loop list value
1452  fLoopInfoVector[fLoopNo-1].expandedCmd.push_back(expandedLoopCmd);
1453 
1454  // copy all the remaining cmd's of the loop
1455  for (cmdIter = fLoopInfoVector[fLoopNo-1].cmd.begin();
1456  cmdIter != fLoopInfoVector[fLoopNo-1].cmd.end(); ++cmdIter) {
1457  fLoopInfoVector[fLoopNo-1].expandedCmd.push_back(*cmdIter);
1458  }
1459  }
1460 
1461  // decrement loop nesting counter
1462  fLoopNo--;
1463  if (fLoopNo < 0) { // fatal error
1464  // stop parsing
1465  QString err("PSAX2AutoRunParseHandler::endElement: negative loop fall back!");
1466  internalFatalError(err);
1467  fFatalError = true;
1468  return;
1469  }
1470  PAutoRunCmdVector::Iterator iter;
1471  if (fLoopNo == 0) { // back from all the loops -> add expanded list to fAutoRunCmdVector
1472  QString lastLoopVal("");
1473  for (iter = fLoopInfoVector[0].expandedCmd.begin();
1474  iter != fLoopInfoVector[0].expandedCmd.end(); ++iter) {
1475  // for the loop, the cmdStr might need to be created here
1476  if (iter->cmd == "setSampleHV") {
1477  iter->cmdString = QString("SAMPLE_HV ");
1478  for (int i=0; i<LAR_MAX_PARAM; i++) {
1479  if (!iter->param[i].isEmpty())
1480  iter->cmdString += iter->param[i] + ", ";
1481  }
1482  // remove last ','
1483  iter->cmdString.truncate(iter->cmdString.length()-2);
1484  // keep loop command value
1485  iter->loopVal = iter->param[0];
1486  lastLoopVal = iter->param[0];
1487  } else if (iter->cmd == "setTemp") {
1488  iter->cmdString = QString("TEMP ");
1489  for (int i=0; i<LAR_MAX_PARAM; i++) {
1490  if (!iter->param[i].isEmpty())
1491  iter->cmdString += iter->param[i] + ", ";
1492  }
1493  // remove last ','
1494  iter->cmdString.truncate(iter->cmdString.length()-2);
1495  // keep loop command value
1496  iter->loopVal = iter->param[0];
1497  lastLoopVal = iter->param[0];
1498  } else if (iter->cmd == "setFieldWEWL") {
1499  iter->cmdString = QString("FIELD_WEWL ");
1500  for (int i=0; i<LAR_MAX_PARAM; i++) {
1501  if (!iter->param[i].isEmpty())
1502  iter->cmdString += iter->param[i] + ", ";
1503  }
1504  // remove last ','
1505  iter->cmdString.truncate(iter->cmdString.length()-2);
1506  // keep loop command value
1507  iter->loopVal = iter->param[0];
1508  lastLoopVal = iter->param[0];
1509  } else if (iter->cmd == "setFieldWEWH") {
1510  iter->cmdString = QString("FIELD_WEWH ");
1511  for (int i=0; i<LAR_MAX_PARAM; i++) {
1512  if (!iter->param[i].isEmpty())
1513  iter->cmdString += iter->param[i] + ", ";
1514  }
1515  // remove last ','
1516  iter->cmdString.truncate(iter->cmdString.length()-2);
1517  // keep loop command value
1518  iter->loopVal = iter->param[0];
1519  lastLoopVal = iter->param[0];
1520  } else if (iter->cmd == "setFieldDanfysik") {
1521  iter->cmdString = QString("FIELD_DANFYSIK ");
1522  for (int i=0; i<LAR_MAX_PARAM; i++) {
1523  if (!iter->param[i].isEmpty())
1524  iter->cmdString += iter->param[i] + ", ";
1525  }
1526  // remove last ','
1527  iter->cmdString.truncate(iter->cmdString.length()-2);
1528  // keep loop command value
1529  iter->loopVal = iter->param[0];
1530  lastLoopVal = iter->param[0];
1531  } else if (iter->cmd == "setField") {
1532  iter->cmdString = QString("FIELD ");
1533  for (int i=0; i<LAR_MAX_PARAM; i++) {
1534  if (!iter->param[i].isEmpty())
1535  iter->cmdString += iter->param[i] + ", ";
1536  }
1537  // remove last ','
1538  iter->cmdString.truncate(iter->cmdString.length()-2);
1539  // keep loop command value
1540  iter->loopVal = iter->param[0];
1541  lastLoopVal = iter->param[0];
1542  } else {
1543  iter->loopVal = lastLoopVal;
1544  }
1545 
1546  // store the expanded command
1547  fAutoRunCmdVector->push_back(*iter);
1548  }
1549  // clear the loop list
1550  fLoopInfoVector.clear();
1551  } else { // back from an inner loop -> add expanded list to current loop
1552  for (iter = fLoopInfoVector[fLoopNo].expandedCmd.begin();
1553  iter != fLoopInfoVector[fLoopNo].expandedCmd.end(); ++iter) {
1554  fLoopInfoVector[fLoopNo-1].cmd.push_back(*iter);
1555  }
1556  }
1557  // remove processed loop
1558  if (fLoopInfoVector.size() > 0)
1559  fLoopInfoVector.pop_back();
1560  }
1561 }
1562 
1563 //*******************************************************************************************************
1564 // implementation of the endDocument
1565 //*******************************************************************************************************
1569 void PSAX2AutoRunParseHandler::endDocument()
1570 {
1571 }
1572 
1573 //*******************************************************************************************************
1574 // implementation of the warning
1575 //*******************************************************************************************************
1581 void PSAX2AutoRunParseHandler::warning(const SAXParseException& exc)
1582 {
1583  XMLParseError err;
1584 
1585  // fill warning information
1586  err.errorCode = LAR_XML_WARNING;
1587  err.lineNo = fCurrentUserLineNo;
1588  err.errorMsg = QString(XMLString::transcode(exc.getMessage()));
1589 
1590  // add to the error message queque
1591  PXMLParseErrorVector *p;
1592  p = fArp->GetXMLParseErrorVector();
1593  p->push_back(err);
1594 }
1595 
1596 //*******************************************************************************************************
1597 // implementation of the error
1598 //*******************************************************************************************************
1604 void PSAX2AutoRunParseHandler::error(const SAXParseException& exc)
1605 {
1606  XMLParseError err;
1607 
1608  // fill error information
1609  err.errorCode = LAR_XML_ERROR;
1610  err.lineNo = fCurrentUserLineNo;
1611  err.errorMsg = QString(XMLString::transcode(exc.getMessage()));
1612 
1613  // add to the error message queque
1614  PXMLParseErrorVector *p;
1615  p = fArp->GetXMLParseErrorVector();
1616  p->push_back(err);
1617 }
1618 
1619 //*******************************************************************************************************
1620 // implementation of the fatalError
1621 //*******************************************************************************************************
1627 void PSAX2AutoRunParseHandler::fatalError(const SAXParseException& exc)
1628 {
1629  XMLParseError err;
1630 
1631  // fill error information
1632  err.errorCode = LAR_XML_FATAL;
1633  err.lineNo = fCurrentUserLineNo;
1634  err.errorMsg = QString(XMLString::transcode(exc.getMessage()));
1635 
1636  // add to the error message queque
1637  PXMLParseErrorVector *p;
1638  p = fArp->GetXMLParseErrorVector();
1639  p->push_back(err);
1640 }
1641 
1642 //*******************************************************************************************************
1643 // implementation of the internalFatalError
1644 //*******************************************************************************************************
1650 void PSAX2AutoRunParseHandler::internalFatalError(QString& msg)
1651 {
1652  XMLParseError err;
1653 
1654  // fill error information
1655  err.errorCode = LAR_XML_FATAL;
1656  err.lineNo = fCurrentUserLineNo;
1657  err.errorMsg = msg;
1658 
1659  // add to the error message queque
1660  PXMLParseErrorVector *p;
1661  p = fArp->GetXMLParseErrorVector();
1662  p->push_back(err);
1663 }
1664 
1665 //*******************************************************************************************************
1666 // implementation of the ClearAutoRunCmd
1667 //*******************************************************************************************************
1671 void PSAX2AutoRunParseHandler::ClearAutoRunCmd()
1672 {
1673  fAutoRunCmd.cmd = "";
1674  fAutoRunCmd.lineNo = -1;
1675  fAutoRunCmd.noElements = 0;
1676  for (int i=0; i<LAR_MAX_PARAM; i++)
1677  fAutoRunCmd.param[i] = "";
1678  fAutoRunCmd.loopVal = "";
1679 }
1680 
1681 //*******************************************************************************************************
1682 // implementation of the CheckOdbSetDataParamsStructure
1683 //*******************************************************************************************************
1687 void PSAX2AutoRunParseHandler::CheckOdbSetDataParamsStructure()
1688 {
1689  bool error = false;
1690  QString err("PSAX2AutoRunParseHandler::CheckOdbSetDataParamsStructure: ");
1691 
1692  /***************************************************************************
1693  param[0] = set_path (required)
1694  param[1] = set_index
1695  param[2] = set_value (required)
1696  param[3] = read_path
1697  param[4] = read_index
1698  param[5] = timeout
1699  param[6] = tolerance
1700  ****************************************************************************/
1701 
1702  switch (fAutoRunCmd.noElements) {
1703  case 2: // parameters set_path, set_value needs to be set
1704  if ((fAutoRunCmd.param[0].length() == 0) || (fAutoRunCmd.param[2].length() == 0)) {
1705  // set_path or set_value are empty which would be the only valid filling
1706  error = true;
1707  err += QString("if only 2 values are given, they have to be set_path and set_value!");
1708  }
1709  break;
1710  case 3: // parameters set_path, set_index, set_value needs to be set
1711  if ((fAutoRunCmd.param[0].length() == 0) || (fAutoRunCmd.param[1].length() == 0) ||
1712  (fAutoRunCmd.param[2].length() == 0)) {
1713  // set_path, set_index or set_value are empty which would be the only valid filling
1714  error = true;
1715  err += QString("if only 3 values are given, they have to be set_path, set_index, and set_value!");
1716  }
1717  break;
1718  case 5: // parameters set_path, set_value, read_path, timeout, tolerance needs to be set
1719  if ((fAutoRunCmd.param[1].length() != 0) || (fAutoRunCmd.param[4].length() != 0)) {
1720  // set_index or read_index set -> error since the above parameter needs to be set
1721  error = true;
1722  err += QString("if 5 values are given, they have to be: set_path, set_value, read_path, timeout, tolerance!");
1723  }
1724  break;
1725  case 6: // parameters set_path, set_value, read_path, timeout, tolerance, and (set_index or read_index) needs to be set
1726  if ((fAutoRunCmd.param[1].length() != 0) && (fAutoRunCmd.param[4].length() != 0)) {
1727  // set_index and read_index set -> error since the above parameter needs to be set
1728  error = true;
1729  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) !");
1730  }
1731  break;
1732  case 7: // all used, from syntax point of view correct
1733  break;
1734  default:
1735  error = true;
1736  err += QString("ODB_SET_DATA parameter error! Please check the manual");
1737  break;
1738  }
1739 
1740  if (error) { // parameter error
1741  internalFatalError(err);
1742  fFatalError = true;
1743  return;
1744  }
1745 }
1746 
1747 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1748 
1749 //*******************************************************************************************************
1750 // implementation of the constructor
1751 //*******************************************************************************************************
1760 PAutoRunParser::PAutoRunParser(QString userAutoRunSeqFln, QString &schemaPath, QString &xmlFln,
1761  PAutoRunCmdVector *arcv, POdbTagVector *odbtagv) :
1762  fInputFileName(userAutoRunSeqFln),
1763  fAutoRunXMLSchemaPath(schemaPath),
1764  fXMLFileName(xmlFln),
1765  fAutoRunCmdVector(arcv),
1766  fOdbTagVector(odbtagv)
1767 {
1768  fParseErrorCounter=0;
1769 
1770  fXMLParseErrorVector = new PXMLParseErrorVector();
1771 }
1772 
1773 //*******************************************************************************************************
1774 // implementation of the destructor
1775 //*******************************************************************************************************
1779 PAutoRunParser::~PAutoRunParser()
1780 {
1781 }
1782 
1783 //*******************************************************************************************************
1784 // implementation of ConvertToXML
1785 //*******************************************************************************************************
1790 void PAutoRunParser::ConvertToXML()
1791 {
1792  int line_no = 0;
1793  int loop_no = 0;
1794  QString errorMsg;
1795  QString str;
1796  QString offset = "";
1797  QStringList runSeq;
1798  QStringList runSeqXML;
1799 
1800  QFile file(fInputFileName);
1801 
1802  // check if file exists
1803  if (!file.exists()) {
1804  errorMsg = "File does not exist: '" + fInputFileName + "'";
1805  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INPUT_FILE_NOT_EXISTING, -1, errorMsg);
1806  fParseErrorCounter = 1;
1807  return;
1808  }
1809 
1810  // read file into string list
1811  if (file.open(QIODevice::ReadOnly)) {
1812  QTextStream stream( &file );
1813  QString line;
1814  while ( !stream.atEnd() ) {
1815  line = stream.readLine(); // line of text excluding '\n'
1816  runSeq += line;
1817  }
1818  file.close();
1819  } else {
1820  errorMsg = "Couldn't open file (" + fInputFileName + ")";
1821  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INPUT_FILE_READ_ERROR, line_no, errorMsg);
1822  }
1823 
1824  // collect all the alias
1825  QString key(""), value("");
1826  line_no = 0;
1827  for (QStringList::Iterator it = runSeq.begin(); it != runSeq.end(); ++it) {
1828  line_no++;
1829  str = (QString)*it;
1830  if (str.startsWith("ALIAS")) {
1831  key = str.section(' ', 1, 1);
1832  value = str.section(' ', 2);
1833  if ((key.length() == 0) || (value.length() == 0)) {
1834  QString err = QString("**ERROR** Invalid ALIAS command!");
1835  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, line_no, err);
1836  return;
1837  }
1838  fAlias[key] = value;
1839  }
1840  }
1841 
1842  // convert to XML
1843  // write header
1844  runSeqXML.clear();
1845  runSeqXML += QString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
1846  runSeqXML += QString("<autoRun xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
1847  runSeqXML += QString(" xsi:noNamespaceSchemaLocation=\"file:")+fAutoRunXMLSchemaPath+QString("\">");
1848  runSeqXML += QString("<autoRunName>%1</autoRunName>").arg(fInputFileName);
1849 
1850  // write body
1851  line_no = 0;
1852  for (QStringList::Iterator it = runSeq.begin(); it != runSeq.end(); ++it) {
1853  line_no++;
1854  str = (QString)*it;
1855  str = str.trimmed();
1856  str = str.simplified();
1857 
1858  if (str.isEmpty())
1859  continue;
1860 
1861  if (str.startsWith("%"))
1862  ConvertComment(str, line_no, offset, runSeqXML);
1863  else if (str.startsWith("ALIAS"))
1864  ConvertAlias(str, line_no, offset, runSeqXML);
1865  else if (str.startsWith("IGNORE_ALARMS"))
1866  ConvertIgnoreAlarms(str, line_no, offset, runSeqXML);
1867  else if (str.startsWith("IGNORE_CLIENTS"))
1868  ConvertIgnoreClients(str, line_no, offset, runSeqXML);
1869  else if (str.startsWith("BPV"))
1870  ConvertBPV(str, line_no, offset, runSeqXML);
1871  else if (str.startsWith("FIELD_WEWL"))
1872  ConvertFieldWEWL(str, line_no, offset, runSeqXML);
1873  else if (str.startsWith("FIELD_WEWH"))
1874  ConvertFieldWEWH(str, line_no, offset, runSeqXML);
1875  else if (str.startsWith("FIELD_DANFYSIK"))
1876  ConvertFieldDanfysik(str, line_no, offset, runSeqXML);
1877  else if (str.startsWith("FIELD "))
1878  ConvertField(str, line_no, offset, runSeqXML);
1879  else if (str.startsWith("FOM"))
1880  ConvertFOM(str, line_no, offset, runSeqXML);
1881  else if (str.startsWith("LEM_SETUP"))
1882  ConvertLEMSetup(str, line_no, offset, runSeqXML);
1883  else if (str.startsWith("MODERATOR"))
1884  ConvertModerator(str, line_no, offset, runSeqXML);
1885  else if (str.startsWith("SAMPLE_HV"))
1886  ConvertSampleHV(str, line_no, offset, runSeqXML);
1887  else if (str.startsWith("RA_HV"))
1888  ConvertRA_HV(str, line_no, offset, runSeqXML);
1889  else if (str.startsWith("TRANSPORT_HV"))
1890  ConvertTransportHV(str, line_no, offset, runSeqXML);
1891  else if (str.startsWith("HV_OFF"))
1892  ConvertHVOff(str, line_no, offset, runSeqXML);
1893  else if (str.startsWith("ODB_TAG"))
1894  ConvertOdbTag(str, line_no, offset, runSeqXML);
1895  else if (str.startsWith("ODB_SET_DATA"))
1896  if (str.startsWith("ODB_SET_DATA_ARRAY")) {
1897  ConvertOdbSetDataArray(str, line_no, offset, runSeqXML);
1898  } else {
1899  ConvertOdbSetData(str, line_no, offset, runSeqXML);
1900  }
1901  else if (str.startsWith("SPIN_ROT"))
1902  ConvertSpinRot(str, line_no, offset, runSeqXML);
1903  else if (str.startsWith("START"))
1904  ConvertStart(str, line_no, offset, runSeqXML);
1905  else if (str.startsWith("STOP"))
1906  ConvertStop(str, line_no, offset, runSeqXML);
1907  else if (str.startsWith("TFL"))
1908  ConvertTfl(str, line_no, offset, runSeqXML);
1909  else if (str.startsWith("TEMP"))
1910  ConvertTemp(str, line_no, offset, runSeqXML);
1911  else if (str.startsWith("TITLE"))
1912  ConvertTitle(str, line_no, offset, runSeqXML);
1913  else if (str.startsWith("TOF"))
1914  ConvertTOF(str, line_no, offset, runSeqXML);
1915  else if (str.startsWith("WAIT"))
1916  ConvertWait(str, line_no, offset, runSeqXML);
1917  else if (str.startsWith("WARMUP"))
1918  ConvertWarmUp(str, line_no, offset, runSeqXML);
1919  else if (str.startsWith("DUMP"))
1920  ConvertDump(str, line_no, offset, runSeqXML);
1921  else if (str.startsWith("DEGAUSS_WEW"))
1922  ConvertDegaussWEW(str, line_no, offset, runSeqXML);
1923  else if (str.startsWith("DEGAUSS_DANFYSIK"))
1924  ConvertDegaussDanfysik(str, line_no, offset, runSeqXML);
1925  else if (str.startsWith("DEGAUSS_MAGNET"))
1926  ConvertDegauss(str, line_no, offset, runSeqXML);
1927  else if (str.startsWith("DEGAUSS_SPIN_ROT"))
1928  ConvertDegaussSpinRot(str, line_no, offset, runSeqXML);
1929  else if (str.startsWith("LOOP_START")) {
1930  ConvertLoopStart(line_no, offset, runSeqXML);
1931  loop_no++;
1932  offset = "";
1933  for (int i=0; i<loop_no; i++)
1934  offset += " ";
1935  }
1936  else if (str.startsWith("LOOP_LIST"))
1937  ConvertLoopList(str, offset, runSeqXML);
1938  else if (str.startsWith("LOOP_ITERATOR"))
1939  ConvertLoopIterator(str, offset, runSeqXML);
1940  else if (str.startsWith("LOOP_TEMP"))
1941  ConvertLoopTemp(str, line_no, offset, runSeqXML);
1942  else if (str.startsWith("LOOP_SAMPLE_HV"))
1943  ConvertLoopSampleHV(str, line_no, offset, runSeqXML);
1944  else if (str.startsWith("LOOP_FIELD_WEWL"))
1945  ConvertLoopFieldWEWL(str, line_no, offset, runSeqXML);
1946  else if (str.startsWith("LOOP_FIELD_WEWH"))
1947  ConvertLoopFieldWEWH(str, line_no, offset, runSeqXML);
1948  else if (str.startsWith("LOOP_FIELD_DANFYSIK"))
1949  ConvertLoopFieldDanfysik(str, line_no, offset, runSeqXML);
1950  else if (str.startsWith("LOOP_FIELD "))
1951  ConvertLoopField(str, line_no, offset, runSeqXML);
1952  else if (str.startsWith("LOOP_END")) {
1953  loop_no--;
1954  offset = "";
1955  for (int i=0; i<loop_no; i++)
1956  offset += " ";
1957  ConvertLoopEnd(offset, runSeqXML);
1958  }
1959  else {
1960  fParseErrorCounter++;
1961  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, line_no, "Invalid Auto Run Command.");
1962  }
1963  }
1964  // write closure
1965  runSeqXML += QString("</autoRun>");
1966 
1967  // save XML-file
1968  QFile fileOut( fXMLFileName );
1969  if (fileOut.open( QIODevice::WriteOnly )) {
1970  QTextStream stream( &fileOut );
1971  for ( QStringList::Iterator it = runSeqXML.begin(); it != runSeqXML.end(); ++it )
1972  stream << *it << "\n";
1973  fileOut.close();
1974  } else {
1975  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_OUTPUT_FILE_WRITE_ERROR, 0, "Couldn't write XML ouput.");
1976  }
1977 }
1978 
1979 
1980 //*******************************************************************************************************
1981 // implementation of CheckForAlias
1982 //*******************************************************************************************************
1990 QString PAutoRunParser::CheckForAlias(QString &str)
1991 {
1992  QString result = str;
1993  QStringList tokens = result.split(QRegExp("[\\s,\\[\\]]"), QString::SkipEmptyParts);
1994 
1995  QList<QString> keys = fAlias.keys();
1996  QList<QString>::iterator it;
1997  QString key(""), sKey(""), sAlias("");
1998  int idx1, idx2;
1999  for (it = keys.begin(); it != keys.end(); ++it) {
2000  key = (QString)*it; // alias key
2001  for (int i=0; i<tokens.count(); i++) { // tokenized lar string
2002  if (key == tokens[i]) {
2003  sKey = " "+key; // needed to make sure that key in results starts with a space
2004  sAlias = " "+fAlias[key];
2005  result.replace(sKey, sAlias);
2006 
2007  // check if something like "..."[idx] is found, and if yes fix it
2008  idx1 = result.indexOf("\"[");
2009  if (idx1 > 0) {
2010  idx2 = result.indexOf("]", idx1);
2011  for (int i=idx1; i<=idx2; i++)
2012  result[i] = result[i+1];
2013  result[idx2] = '"';
2014  }
2015  }
2016  }
2017  }
2018 
2019  return result;
2020 }
2021 
2022 
2023 //*******************************************************************************************************
2024 // implementation of ConvertAlias
2025 //*******************************************************************************************************
2034 void PAutoRunParser::ConvertAlias(QString &str, int lineNo, QString &offset, QStringList &xml)
2035 {
2036  xml += offset + QString("<autoRunCmd>");
2037  xml += offset + QString(" <alias>");
2038  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2039  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2040  xml += offset + QString(" <alias_key>%1</alias_key>").arg(str.section(' ', 1, 1));
2041  xml += offset + QString(" <alias_value>%1</alias_value>").arg(str.section(' ', 2, 2));
2042  xml += offset + QString(" </alias>");
2043  xml += offset + QString("</autoRunCmd>");
2044 }
2045 
2046 //*******************************************************************************************************
2047 // implementation of ConvertIgnoreAlarms
2048 //*******************************************************************************************************
2057 void PAutoRunParser::ConvertIgnoreAlarms(QString &str, int lineNo, QString &offset, QStringList &xml)
2058 {
2059  xml += offset + QString("<autoRunCmd>");
2060  xml += offset + QString(" <ignore_alarms>");
2061  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2062  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2063  xml += offset + QString(" <state>%1</state>").arg(str.section(' ', 1, 1).toLower());
2064  xml += offset + QString(" </ignore_alarms>");
2065  xml += offset + QString("</autoRunCmd>");
2066 }
2067 
2068 //*******************************************************************************************************
2069 // implementation of ConvertIgnoreClients
2070 //*******************************************************************************************************
2079 void PAutoRunParser::ConvertIgnoreClients(QString &str, int lineNo, QString &offset, QStringList &xml)
2080 {
2081  xml += offset + QString("<autoRunCmd>");
2082  xml += offset + QString(" <ignore_clients>");
2083  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2084  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2085  xml += offset + QString(" <state>%1</state>").arg(str.section(' ', 1, 1).toLower());
2086  xml += offset + QString(" </ignore_clients>");
2087  xml += offset + QString("</autoRunCmd>");
2088 }
2089 
2090 //*******************************************************************************************************
2091 // implementation of ConvertBPV
2092 //*******************************************************************************************************
2101 void PAutoRunParser::ConvertBPV(QString &str, int lineNo, QString &offset, QStringList &xml)
2102 {
2103  xml += offset + QString("<autoRunCmd>");
2104  xml += offset + QString(" <setBPV>");
2105  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2106  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2107  if (str.contains("X"))
2108  xml += offset + QString(" <label>X</label>");
2109  else if (str.contains("Y"))
2110  xml += offset + QString(" <label>Y</label>");
2111  else
2112  xml += offset + QString(" <label>?</label>");
2113  xml += offset + QString(" <state>%1</state>").arg(str.section(' ', 1, 1).toLower());
2114  xml += offset + QString(" </setBPV>");
2115  xml += offset + QString("</autoRunCmd>");
2116 }
2117 
2118 //*******************************************************************************************************
2119 // implementation of ConvertComment
2120 //*******************************************************************************************************
2129 void PAutoRunParser::ConvertComment(QString &str, int lineNo, QString &offset, QStringList &xml)
2130 {
2131  QString comment = str;
2132  comment.replace("<", " less-than ");
2133  comment.replace(">", " greater-than ");
2134 
2135  xml += offset + QString("<autoRunCmd>");
2136  xml += offset + QString(" <comment>");
2137  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2138  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(comment);
2139  xml += offset + QString(" </comment>");
2140  xml += offset + QString("</autoRunCmd>");
2141 }
2142 
2143 //*******************************************************************************************************
2144 // implementation of ConvertDump
2145 //*******************************************************************************************************
2155 void PAutoRunParser::ConvertDump(QString &str, int lineNo, QString &offset, QStringList &xml)
2156 {
2157  QString line = CheckForAlias(str);
2158  xml += offset + QString("<autoRunCmd>");
2159  xml += offset + QString(" <setDump>");
2160  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2161  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2162  xml += offset + QString(" <no_dumps>%1</no_dumps>").arg(line.section(' ', 1, 1));
2163  xml += offset + QString(" </setDump>");
2164  xml += offset + QString("</autoRunCmd>");
2165 }
2166 
2167 //*******************************************************************************************************
2168 // implementation of ConvertFieldWEWL
2169 //*******************************************************************************************************
2179 void PAutoRunParser::ConvertFieldWEWL(QString &str, int lineNo, QString &offset, QStringList &xml)
2180 {
2181  QString line = CheckForAlias(str);
2182  xml += offset + QString("<autoRunCmd>");
2183  xml += offset + QString(" <setFieldWEWL>");
2184  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2185  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2186  xml += offset + QString(" <field_value>%1</field_value>").arg(line.section(' ', 1, 1));
2187  QString unit("");
2188  unit = line.section(' ', 2, 2);
2189  if ((unit != "A") && (unit != "G") && (unit != "")) {
2190  QString err = QString("**ERROR** Wrong units in FIELD_WEWL cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
2191  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2192  return;
2193  }
2194  if (unit == "G")
2195  xml += offset + QString(" <field_unit>G</field_unit>");
2196  else
2197  xml += offset + QString(" <field_unit>A</field_unit>");
2198  xml += offset + QString(" </setFieldWEWL>");
2199  xml += offset + QString("</autoRunCmd>");
2200 }
2201 
2202 //*******************************************************************************************************
2203 // implementation of ConvertFieldWEWH
2204 //*******************************************************************************************************
2214 void PAutoRunParser::ConvertFieldWEWH(QString &str, int lineNo, QString &offset, QStringList &xml)
2215 {
2216  QString line = CheckForAlias(str);
2217  xml += offset + QString("<autoRunCmd>");
2218  xml += offset + QString(" <setFieldWEWH>");
2219  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2220  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2221  xml += offset + QString(" <field_value>%1</field_value>").arg(line.section(' ', 1, 1));
2222  QString unit("");
2223  unit = line.section(' ', 2, 2);
2224  if ((unit != "A") && (unit != "G") && (unit != "")) {
2225  QString err = QString("**ERROR** Wrong units in FIELD_WEWH cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
2226  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2227  return;
2228  }
2229  if (unit == "G")
2230  xml += offset + QString(" <field_unit>G</field_unit>");
2231  else
2232  xml += offset + QString(" <field_unit>A</field_unit>");
2233  xml += offset + QString(" </setFieldWEWH>");
2234  xml += offset + QString("</autoRunCmd>");
2235 }
2236 
2237 //*******************************************************************************************************
2238 // implementation of ConvertFieldDanfysik
2239 //*******************************************************************************************************
2249 void PAutoRunParser::ConvertFieldDanfysik(QString &str, int lineNo, QString &offset, QStringList &xml)
2250 {
2251  QString line = CheckForAlias(str);
2252  xml += offset + QString("<autoRunCmd>");
2253  xml += offset + QString(" <setFieldDanfysik>");
2254  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2255  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2256  xml += offset + QString(" <field_value>%1</field_value>").arg(line.section(' ', 1, 1));
2257  QString unit("");
2258  unit = line.section(' ', 2, 2);
2259  if ((unit != "A") && (unit != "G") && (unit != "")) {
2260  QString err = QString("**ERROR** Wrong units in FIELD_DANFYSIK cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
2261  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2262  return;
2263  }
2264  if (unit == "G")
2265  xml += offset + QString(" <field_unit>G</field_unit>");
2266  else
2267  xml += offset + QString(" <field_unit>A</field_unit>");
2268  xml += offset + QString(" </setFieldDanfysik>");
2269  xml += offset + QString("</autoRunCmd>");
2270 }
2271 
2272 //*******************************************************************************************************
2273 // implementation of ConvertField
2274 //*******************************************************************************************************
2284 void PAutoRunParser::ConvertField(QString &str, int lineNo, QString &offset, QStringList &xml)
2285 {
2286  QString line = CheckForAlias(str);
2287  xml += offset + QString("<autoRunCmd>");
2288  xml += offset + QString(" <setField>");
2289  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2290  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2291  xml += offset + QString(" <field_value>%1</field_value>").arg(line.section(' ', 1, 1));
2292  QString unit("");
2293  unit = line.section(' ', 2, 2);
2294  if ((unit != "A") && (unit != "G") && (unit != "")) {
2295  QString err = QString("**ERROR** Wrong units in FIELD cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
2296  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2297  return;
2298  }
2299  if (unit == "G")
2300  xml += offset + QString(" <field_unit>G</field_unit>");
2301  else
2302  xml += offset + QString(" <field_unit>A</field_unit>");
2303  xml += offset + QString(" </setField>");
2304  xml += offset + QString("</autoRunCmd>");
2305 }
2306 
2307 //*******************************************************************************************************
2308 // implementation of ConvertFOM
2309 //*******************************************************************************************************
2319 void PAutoRunParser::ConvertFOM(QString &str, int lineNo, QString &offset, QStringList &xml)
2320 {
2321  QString line = CheckForAlias(str);
2322  xml += offset + QString("<autoRunCmd>");
2323  xml += offset + QString(" <setFOM>");
2324  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2325  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2326  xml += offset + QString(" <current>%1</current>").arg(line.section(' ', 1, 1).remove(","));
2327  xml += offset + QString(" </setFOM>");
2328  xml += offset + QString("</autoRunCmd>");
2329 }
2330 
2331 //*******************************************************************************************************
2332 // implementation of ConvertLEMSetup
2333 //*******************************************************************************************************
2343 void PAutoRunParser::ConvertLEMSetup(QString &str, int lineNo, QString &offset, QStringList &xml)
2344 {
2345  QString line = CheckForAlias(str);
2346  xml += offset + QString("<autoRunCmd>");
2347  xml += offset + QString(" <setLEMSetup>");
2348  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2349  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2350  xml += offset + QString(" <setup>%1</setup>").arg(line.section(' ', 1));
2351  xml += offset + QString(" </setLEMSetup>");
2352  xml += offset + QString("</autoRunCmd>");
2353 }
2354 
2355 //*******************************************************************************************************
2356 // implementation of ConvertLoopStart
2357 //*******************************************************************************************************
2366 void PAutoRunParser::ConvertLoopStart(int lineNo, QString &offset, QStringList &xml)
2367 {
2368  xml += offset + QString("<autoRunCmd>");
2369  xml += offset + QString(" <loop>");
2370  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2371 }
2372 
2373 //*******************************************************************************************************
2374 // implementation of ConvertLoopList
2375 //*******************************************************************************************************
2384 void PAutoRunParser::ConvertLoopList(QString &str, QString &offset, QStringList &xml)
2385 {
2386  QString workStr;
2387  QString value;
2388  int i=0;
2389 
2390  xml += offset + QString("<loopList>");
2391  workStr = str.section('[', 1).trimmed();
2392  value = " ";
2393  while (!value.isEmpty()) {
2394  value = workStr.section(',',i,i);
2395  value.remove(",");
2396  if (!value.trimmed().isEmpty()) {
2397  value = value.trimmed().remove("]");
2398  xml += offset + QString(" <loopElement>%1</loopElement>").arg(value);
2399  }
2400  i++;
2401  }
2402  xml += offset + QString("</loopList>");
2403 }
2404 
2405 //*******************************************************************************************************
2406 // implementation of ConvertLoopIterator
2407 //*******************************************************************************************************
2416 void PAutoRunParser::ConvertLoopIterator(QString &str, QString &offset, QStringList &xml)
2417 {
2418  QString workStr;
2419  QString value;
2420  int i=0;
2421 
2422  xml += offset + QString("<loopIterator>");
2423  workStr = str.section('[', 1).trimmed();
2424  value = " ";
2425  while (!value.isEmpty()) {
2426  value = workStr.section(',',i,i);
2427  value.remove(",");
2428  if (!value.trimmed().isEmpty()) {
2429  value = value.trimmed().remove("]");
2430  switch (i) {
2431  case 0:
2432  xml += offset + QString(" <loopStart>%1</loopStart>").arg(value);
2433  break;
2434  case 1:
2435  xml += offset + QString(" <loopStop>%1</loopStop>").arg(value);
2436  break;
2437  case 2:
2438  xml += offset + QString(" <loopStep>%1</loopStep>").arg(value);
2439  break;
2440  default:
2441  break;
2442  }
2443  }
2444  i++;
2445  }
2446  xml += offset + QString("</loopIterator>");
2447 }
2448 
2449 //*******************************************************************************************************
2450 // implementation of ConvertLoopTemp
2451 //*******************************************************************************************************
2461 void PAutoRunParser::ConvertLoopTemp(QString &str, int lineNo, QString &offset, QStringList &xml)
2462 {
2463  QString workStr;
2464  QString line = CheckForAlias(str);
2465 
2466  xml += offset + QString("<loopSetTemp>");
2467  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2468  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2469  workStr = line.section(' ', 1, 1);
2470  workStr.remove(",");
2471  xml += offset + QString(" <loopTempTag>%1</loopTempTag>").arg(workStr);
2472  xml += offset + QString(" <deltaT>%1</deltaT>").arg(line.section(',', 1, 1).trimmed());
2473  xml += offset + QString(" <stabilityTimeout>%1</stabilityTimeout>").arg(line.section(',', 2, 2).trimmed());
2474  workStr = line.section(',', 3, 3); // ramp
2475  // check if a ramp value is given
2476  if (workStr.remove(",").trimmed().length()>0) {
2477  xml += offset + QString(" <ramp>%1</ramp>").arg(workStr.remove(",").trimmed());
2478  }
2479  xml += offset + QString("</loopSetTemp>");
2480 }
2481 
2482 //*******************************************************************************************************
2483 // implementation of ConvertLoopSampleHV
2484 //*******************************************************************************************************
2494 void PAutoRunParser::ConvertLoopSampleHV(QString &str, int lineNo, QString &offset, QStringList &xml)
2495 {
2496  QString line = CheckForAlias(str);
2497  xml += offset + QString("<loopSetSampleHV>");
2498  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2499  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2500  xml += offset + QString(" <loopSampleHVTag>%1</loopSampleHVTag>").arg(line.section(' ', 1, 1));
2501  xml += offset + QString("</loopSetSampleHV>");
2502 }
2503 
2504 //*******************************************************************************************************
2505 // implementation of ConvertLoopFieldWEWL
2506 //*******************************************************************************************************
2516 void PAutoRunParser::ConvertLoopFieldWEWL(QString &str, int lineNo, QString &offset, QStringList &xml)
2517 {
2518  QString line = CheckForAlias(str);
2519  xml += offset + QString("<loopSetFieldWEWL>");
2520  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2521  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2522  xml += offset + QString(" <loopFieldTag>%1</loopFieldTag>").arg(line.section(' ', 1, 1));
2523  QString unit("");
2524  unit = line.section(' ', 2, 2);
2525  if ((unit != "A") && (unit != "G") && (unit != "")) {
2526  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);
2527  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2528  return;
2529  }
2530  if (unit == "G")
2531  xml += offset + QString(" <field_unit>G</field_unit>");
2532  else
2533  xml += offset + QString(" <field_unit>A</field_unit>");
2534  xml += offset + QString("</loopSetFieldWEWL>");
2535 }
2536 
2537 //*******************************************************************************************************
2538 // implementation of ConvertLoopFieldWEWH
2539 //*******************************************************************************************************
2549 void PAutoRunParser::ConvertLoopFieldWEWH(QString &str, int lineNo, QString &offset, QStringList &xml)
2550 {
2551  QString line = CheckForAlias(str);
2552  xml += offset + QString("<loopSetFieldWEWH>");
2553  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2554  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2555  xml += offset + QString(" <loopFieldTag>%1</loopFieldTag>").arg(line.section(' ', 1, 1));
2556  QString unit("");
2557  unit = line.section(' ', 2, 2);
2558  if ((unit != "A") && (unit != "G") && (unit != "")) {
2559  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);
2560  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2561  return;
2562  }
2563  if (unit == "G")
2564  xml += offset + QString(" <field_unit>G</field_unit>");
2565  else
2566  xml += offset + QString(" <field_unit>A</field_unit>");
2567  xml += offset + QString("</loopSetFieldWEWH>");
2568 }
2569 
2570 //*******************************************************************************************************
2571 // implementation of ConvertLoopFieldDanfysik
2572 //*******************************************************************************************************
2582 void PAutoRunParser::ConvertLoopFieldDanfysik(QString &str, int lineNo, QString &offset, QStringList &xml)
2583 {
2584  QString line = CheckForAlias(str);
2585  xml += offset + QString("<loopSetFieldDanfysik>");
2586  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2587  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2588  xml += offset + QString(" <loopFieldTag>%1</loopFieldTag>").arg(line.section(' ', 1, 1));
2589  QString unit("");
2590  unit = line.section(' ', 2, 2);
2591  if ((unit != "A") && (unit != "G") && (unit != "")) {
2592  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);
2593  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2594  return;
2595  }
2596  if (unit == "G")
2597  xml += offset + QString(" <field_unit>G</field_unit>");
2598  else
2599  xml += offset + QString(" <field_unit>A</field_unit>");
2600  xml += offset + QString("</loopSetFieldDanfysik>");
2601 }
2602 
2603 //*******************************************************************************************************
2604 // implementation of ConvertLoopField
2605 //*******************************************************************************************************
2615 void PAutoRunParser::ConvertLoopField(QString &str, int lineNo, QString &offset, QStringList &xml)
2616 {
2617  QString line = CheckForAlias(str);
2618  xml += offset + QString("<loopSetField>");
2619  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2620  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2621  xml += offset + QString(" <loopFieldTag>%1</loopFieldTag>").arg(line.section(' ', 1, 1));
2622  QString unit("");
2623  unit = line.section(' ', 2, 2);
2624  if ((unit != "A") && (unit != "G") && (unit != "")) {
2625  QString err = QString("**ERROR** Wrong units in LOOP_FIELD cmd, Found '%1', allowed 'G', 'A', or nothing which is identical to 'A'.").arg(unit);
2626  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2627  return;
2628  }
2629  if (unit == "G")
2630  xml += offset + QString(" <field_unit>G</field_unit>");
2631  else
2632  xml += offset + QString(" <field_unit>A</field_unit>");
2633  xml += offset + QString("</loopSetField>");
2634 }
2635 
2636 //*******************************************************************************************************
2637 // implementation of ConvertLoopEnd
2638 //*******************************************************************************************************
2646 void PAutoRunParser::ConvertLoopEnd(QString &offset, QStringList &xml)
2647 {
2648  xml += offset + QString(" </loop>");
2649  xml += offset + QString("</autoRunCmd>");
2650 }
2651 
2652 //*******************************************************************************************************
2653 // implementation of ConvertModerator
2654 //*******************************************************************************************************
2664 void PAutoRunParser::ConvertModerator(QString &str, int lineNo, QString &offset, QStringList &xml)
2665 {
2666  QString line = CheckForAlias(str);
2667  QString workStr;
2668 
2669  xml += offset + QString("<autoRunCmd>");
2670  xml += offset + QString(" <setModInfo>");
2671  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2672  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2673  workStr = line.section(' ', 1, 1);
2674  workStr.remove(",");
2675  xml += offset + QString(" <mod>%1</mod>").arg(workStr);
2676  xml += offset + QString(" <mod_date>%1</mod_date>").arg(line.section(' ', 2));
2677  xml += offset + QString(" </setModInfo>");
2678  xml += offset + QString("</autoRunCmd>");
2679 }
2680 
2681 //*******************************************************************************************************
2682 // implementation of ConvertOdbSetData
2683 //*******************************************************************************************************
2693 void PAutoRunParser::ConvertOdbSetData(QString &str, int lineNo, QString &offset, QStringList &xml)
2694 {
2695  QString line = CheckForAlias(str);
2696  line.remove("ODB_SET_DATA ");
2697 
2698  QStringList tokens = line.split(QRegExp("[,]"));
2699 
2700  if ((tokens.count() != 2) && (tokens.count() != 5)) { // something is totaly wrong
2701  QString err = QString("**ERROR** Invalid ODB_SET_DATA command! Given number of parameters have to be 2 or 5 found %1").arg(tokens.count());
2702  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2703  return;
2704  }
2705 
2706  xml += offset + QString("<autoRunCmd>");
2707  xml += offset + QString(" <setOdbData>");
2708  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2709  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2710 
2711  QString sec("");
2712  if (tokens.count() == 2) { // ODB_SET_DATA without readback
2713  int idx1 = tokens[0].indexOf("["), idx2;
2714  if (idx1 == -1) {
2715  // set path
2716  xml += offset + QString(" <set_path>%1</set_path>").arg(tokens[0].remove('"').trimmed());
2717  } else {
2718  // set path
2719  sec = tokens[0];
2720  sec.truncate(idx1);
2721  xml += offset + QString(" <set_path>%1</set_path>").arg(sec.remove('"').trimmed());
2722  // set index
2723  idx2 = tokens[0].indexOf("]", idx1);
2724  xml += offset + QString(" <set_index>%1</set_index>").arg(tokens[0].mid(idx1+1,idx2-idx1-1));
2725  }
2726  // set value
2727  xml += offset + QString(" <set_value>%1</set_value>").arg(tokens[1].remove('"').trimmed());
2728  } else if (tokens.count() == 5) {
2729  int idx1 = tokens[0].indexOf("["), idx2;
2730  if (idx1 == -1) { // no index
2731  // set path
2732  xml += offset + QString(" <set_path>%1</set_path>").arg(tokens[0].remove('"').trimmed());
2733  } else {
2734  // set path
2735  sec = tokens[0];
2736  sec.truncate(idx1);
2737  xml += offset + QString(" <set_path>%1</set_path>").arg(sec.remove('"').trimmed());
2738  // set index
2739  idx2 = tokens[0].indexOf("]", idx1);
2740  xml += offset + QString(" <set_index>%1</set_index>").arg(tokens[0].mid(idx1+1,idx2-idx1-1));
2741  }
2742  // set value
2743  xml += offset + QString(" <set_value>%1</set_value>").arg(tokens[1].remove('"').trimmed());
2744 
2745  // set readback path (and index if present)
2746  idx1 = tokens[2].indexOf("[");
2747  if (idx1 == -1) {
2748  // set path
2749  xml += offset + QString(" <read_path>%1</read_path>").arg(tokens[2].remove('"').trimmed());
2750  } else {
2751  // set path
2752  sec = tokens[2];
2753  sec.truncate(idx1);
2754  xml += offset + QString(" <read_path>%1</read_path>").arg(sec.remove('"').trimmed());
2755  // set index
2756  idx2 = tokens[2].indexOf("]", idx1);
2757  xml += offset + QString(" <read_index>%1</read_index>").arg(tokens[2].mid(idx1+1,idx2-idx1-1));
2758  }
2759 
2760  // set timeout
2761  xml += offset + QString(" <timeout>%1</timeout>").arg(tokens[3].trimmed());
2762 
2763  // tolerance
2764  xml += offset + QString(" <tolerance>%1</tolerance>").arg(tokens[4].trimmed());
2765  } else {
2766  QString err = QString("**ERROR** Invalid ODB_SET_DATA command! Given number of parameters have to be 2 or 5 found %1").arg(tokens.count());
2767  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2768  return;
2769  }
2770 
2771  xml += offset + QString(" </setOdbData>");
2772  xml += offset + QString("</autoRunCmd>");
2773 }
2774 
2775 //*******************************************************************************************************
2776 // implementation of ConvertOdbSetDataArray
2777 //*******************************************************************************************************
2786 void PAutoRunParser::ConvertOdbSetDataArray(QString &str, int lineNo, QString &offset, QStringList &xml)
2787 {
2788  QString line = CheckForAlias(str);
2789  QString sec;
2790 
2791  xml += offset + QString("<autoRunCmd>");
2792  xml += offset + QString(" <setOdbDataArray>");
2793  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2794  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2795  // set path
2796  sec = line.section(",", 0, 0);
2797  sec.remove("ODB_SET_DATA_ARRAY ");
2798  xml += offset + QString(" <set_path>%1</set_path>").arg(sec.remove('"').trimmed());
2799 
2800  // handle all the potentially being present entries
2801  int i=1;
2802  bool done = false, ok;
2803  do {
2804  sec = str.section(",", i, i);
2805  sec = sec.trimmed();
2806  if (sec.length() == 0) { // no token left
2807  done = true;
2808  } else {
2809  sec.toFloat(&ok);
2810  if (ok) {
2811  xml += offset + QString(" <set_value>%1</set_value>").arg(sec);
2812  i++;
2813  } else {
2814  QString err = QString("**ERROR** Invalid ODB_SET_DATA_ARRAY command! Currently only float arrays are supported.");
2815  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2816  return;
2817  }
2818  }
2819  } while (!done);
2820 
2821  xml += offset + QString(" </setOdbDataArray>");
2822  xml += offset + QString("</autoRunCmd>");
2823 }
2824 
2825 //*******************************************************************************************************
2826 // implementation of ConvertSampleHV
2827 //*******************************************************************************************************
2837 void PAutoRunParser::ConvertOdbTag(QString &str, int lineNo, QString &offset, QStringList &xml)
2838 {
2839  QString line = CheckForAlias(str);
2840 
2841  // get ODB path
2842  QString path = line.section(' ', 2);
2843  int pos = path.indexOf("[");
2844  if (pos >= 0)
2845  path.truncate(pos);
2846 
2847  // get ODB path index if present
2848  QString idxStr("-1"); // -1 means there is no index present, i.e. ODB path is a single variable
2849  if (pos >= 0) {
2850  QString sstr = line.section(' ', 2);
2851  int pos2 = sstr.indexOf("]");
2852  sstr.truncate(pos2);
2853  idxStr = sstr.right(pos2-pos-1);
2854  }
2855 
2856  xml += offset + QString("<autoRunCmd>");
2857  xml += offset + QString(" <odbTag>");
2858  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2859  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2860  xml += offset + QString(" <label>%1</label>").arg(line.section(' ', 1, 1));
2861  xml += offset + QString(" <read_path>%1</read_path>").arg(path);
2862  xml += offset + QString(" <read_index>%1</read_index>").arg(idxStr);
2863  xml += offset + QString(" </odbTag>");
2864  xml += offset + QString("</autoRunCmd>");
2865 }
2866 
2867 //*******************************************************************************************************
2868 // implementation of ConvertSampleHV
2869 //*******************************************************************************************************
2879 void PAutoRunParser::ConvertSampleHV(QString &str, int lineNo, QString &offset, QStringList &xml)
2880 {
2881  QString line = CheckForAlias(str);
2882  xml += offset + QString("<autoRunCmd>");
2883  xml += offset + QString(" <setSampleHV>");
2884  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2885  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2886  xml += offset + QString(" <hv_value>%1</hv_value>").arg(line.section(' ', 1, 1));
2887  xml += offset + QString(" </setSampleHV>");
2888  xml += offset + QString("</autoRunCmd>");
2889 }
2890 
2891 //*******************************************************************************************************
2892 // implementation of ConvertRA_HV
2893 //*******************************************************************************************************
2903 void PAutoRunParser::ConvertRA_HV(QString &str, int lineNo, QString &offset, QStringList &xml)
2904 {
2905  QString line = CheckForAlias(str);
2906  QString workStr;
2907  QStringList tokens;
2908 
2909  // check that there are the right number of tokens, this could e.g. fail if somebody writes accidently
2910  // RA_HV 9.15, 9.15, 9.15, 9,15
2911  // ^
2912  // |--- error here !!
2913  tokens = str.split(",", QString::SkipEmptyParts);
2914  if ((tokens.count() != 2) && (tokens.count() != 4)) { // error
2915  QString err = QString("**ERROR** Invalid HV_RA command! Found %1 HV values: '%2' (2 or 4 required).").arg(tokens.count()).arg(str);
2916  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
2917  return;
2918  }
2919 
2920  xml += offset + QString("<autoRunCmd>");
2921  xml += offset + QString(" <setRA_HV>");
2922  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2923  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2924  workStr = line.section(' ', 1, 1);
2925  workStr = workStr.section(',', 0, 0);
2926  workStr.remove(",");
2927  xml += offset + QString(" <hv_left>%1</hv_left>").arg(workStr.trimmed());
2928  workStr = str.section(',', 1, 1);
2929  xml += offset + QString(" <hv_right>%1</hv_right>").arg(workStr.trimmed());
2930  workStr = str.section(',', 2, 2);
2931  if (!workStr.isNull()) {
2932  xml += offset + QString(" <hv_top>%1</hv_top>").arg(workStr.trimmed());
2933  workStr = str.section(',', 3, 3);
2934  xml += offset + QString(" <hv_bottom>%1</hv_bottom>").arg(workStr.trimmed());
2935  }
2936  xml += offset + QString(" </setRA_HV>");
2937  xml += offset + QString("</autoRunCmd>");
2938 }
2939 
2940 //*******************************************************************************************************
2941 // implementation of ConvertTransportHV
2942 //*******************************************************************************************************
2952 void PAutoRunParser::ConvertTransportHV(QString &str, int lineNo, QString &offset, QStringList &xml)
2953 {
2954  QString line = CheckForAlias(str);
2955  xml += offset + QString("<autoRunCmd>");
2956  xml += offset + QString(" <setTransportHV>");
2957  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2958  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2959  xml += offset + QString(" <transportHvSettingFileName>%1</transportHvSettingFileName>").arg(line.remove("TRANSPORT_HV "));
2960  xml += offset + QString(" </setTransportHV>");
2961  xml += offset + QString("</autoRunCmd>");
2962 }
2963 
2964 //*******************************************************************************************************
2965 // implementation of ConvertHVOff
2966 //*******************************************************************************************************
2976 void PAutoRunParser::ConvertHVOff(QString &str, int lineNo, QString &offset, QStringList &xml)
2977 {
2978  QString line = CheckForAlias(str);
2979  xml += offset + QString("<autoRunCmd>");
2980  xml += offset + QString(" <setHVOff>");
2981  xml += offset + QString(" <line>%1</line>").arg(lineNo);
2982  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
2983  xml += offset + QString(" <chamber>%1</chamber>").arg(line.remove("HV_OFF "));
2984  xml += offset + QString(" </setHVOff>");
2985  xml += offset + QString("</autoRunCmd>");
2986 }
2987 
2988 //*******************************************************************************************************
2989 // implementation of ConvertSpinRot
2990 //*******************************************************************************************************
3000 void PAutoRunParser::ConvertSpinRot(QString &str, int lineNo, QString &offset, QStringList &xml)
3001 {
3002  QString line = CheckForAlias(str);
3003 
3004  // make sure that the argument is either "off" or a number within range
3005  QString arg = line;
3006  arg = line.section(' ', 1, 1);
3007  if (!arg.contains("off")) {
3008  bool ok;
3009  float fval = arg.toFloat(&ok);
3010  if (!ok) {
3011  QString err = QString("**ERROR** Invalid SPIN_ROT command! Argument is neither \"off\", nor a number between -90.0..+90.0.");
3012  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
3013  return;
3014  }
3015  if ((fval < -90.0) || (fval > 90.0)) {
3016  QString err = QString("**ERROR** Invalid SPIN_ROT command! Argument is out of range (-90.0..+90.0), found %1.").arg(fval);
3017  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
3018  return;
3019  }
3020  }
3021 
3022  xml += offset + QString("<autoRunCmd>");
3023  xml += offset + QString(" <setSpinRot>");
3024  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3025  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3026  xml += offset + QString(" <angle>%1</angle>").arg(line.section(' ', 1, 1));
3027  QString noDegauss = line.section(' ', 2, 2);
3028  if (arg.contains("off") && (noDegauss.indexOf("ndg", 0, Qt::CaseInsensitive) == 0)) {
3029  QString err = QString("**ERROR** Invalid SPIN_ROT command! You cannot combine 'off' with 'ndg'").arg(noDegauss);
3030  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
3031  return;
3032  }
3033  if (!noDegauss.isEmpty()) {
3034  if (noDegauss.indexOf("ndg", 0, Qt::CaseInsensitive) == 0) {
3035  xml += offset + QString(" <no_degauss>%1</no_degauss>").arg(noDegauss);
3036  } else {
3037  QString err = QString("**ERROR** Invalid SPIN_ROT command! Unkown 2nd argument '%1'. Allowed would be 'ndg'").arg(noDegauss);
3038  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_INVALID_CMD, lineNo, err);
3039  return;
3040  }
3041  }
3042  xml += offset + QString(" </setSpinRot>");
3043  xml += offset + QString("</autoRunCmd>");
3044 }
3045 
3046 //*******************************************************************************************************
3047 // implementation of ConvertStart
3048 //*******************************************************************************************************
3058 void PAutoRunParser::ConvertStart(QString &str, int lineNo, QString &offset, QStringList &xml)
3059 {
3060  QString line = CheckForAlias(str);
3061  QString units("");
3062 
3063  xml += offset + QString("<autoRunCmd>");
3064  xml += offset + QString(" <runStart>");
3065  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3066  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3067  xml += offset + QString(" <no_events>%1</no_events>").arg((int)line.section(' ', 1, 1).toDouble());
3068  units = line.section(' ', 2, 2);
3069  if (!units.isEmpty()) {
3070  xml += offset + QString(" <units>%1</units>").arg(units);
3071  }
3072  xml += offset + QString(" </runStart>");
3073  xml += offset + QString("</autoRunCmd>");
3074 }
3075 
3076 //*******************************************************************************************************
3077 // implementation of ConvertStop
3078 //*******************************************************************************************************
3088 void PAutoRunParser::ConvertStop(QString &str, int lineNo, QString &offset, QStringList &xml)
3089 {
3090  QString line = CheckForAlias(str);
3091  QString units("");
3092  xml += offset + QString("<autoRunCmd>");
3093  xml += offset + QString(" <runStop>");
3094  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3095  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3096  xml += offset + QString(" <no_events>%1</no_events>").arg((int)line.section(' ', 1, 1).toDouble());
3097  units = line.section(' ', 2, 2);
3098  if (!units.isEmpty()) {
3099  xml += offset + QString(" <units>%1</units>").arg(units);
3100  }
3101  xml += offset + QString(" </runStop>");
3102  xml += offset + QString("</autoRunCmd>");
3103 }
3104 
3105 //*******************************************************************************************************
3106 // implementation of ConvertTfl
3107 //*******************************************************************************************************
3116 void PAutoRunParser::ConvertTfl(QString &str, int lineNo, QString &offset, QStringList &xml)
3117 {
3118  QString line = CheckForAlias(str);
3119  QString workStr;
3120 
3121  xml += offset + QString("<autoRunCmd>");
3122  xml += offset + QString(" <setTfl>");
3123  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3124  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3125  workStr = line.section(' ', 1, 1);
3126  workStr = workStr.section(',', 0, 0);
3127  workStr.remove(",");
3128  xml += offset + QString(" <tfl_pos>%1</tfl_pos>").arg(workStr);
3129  workStr = line.section(',', 1, 1);
3130  workStr.remove(",");
3131  xml += offset + QString(" <tfl_mode>%1</tfl_mode>").arg(workStr.trimmed());
3132  xml += offset + QString(" </setTfl>");
3133  xml += offset + QString("</autoRunCmd>");
3134 }
3135 
3136 //*******************************************************************************************************
3137 // implementation of ConvertTemp
3138 //*******************************************************************************************************
3148 void PAutoRunParser::ConvertTemp(QString &str, int lineNo, QString &offset, QStringList &xml)
3149 {
3150  QString line = CheckForAlias(str);
3151  QString workStr;
3152 
3153  xml += offset + QString("<autoRunCmd>");
3154  xml += offset + QString(" <setTemp>");
3155  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3156  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3157  workStr = line.section(' ', 1, 1);
3158  workStr = workStr.section(',', 0, 0);
3159  workStr.remove(",");
3160  xml += offset + QString(" <temp>%1</temp>").arg(workStr);
3161  workStr = line.section(',', 1);
3162  if (workStr.contains(",")>0) { // full command
3163  workStr = line.section(',', 1, 1); // dT
3164  workStr.remove(",");
3165  xml += offset + QString(" <deltaT>%1</deltaT>").arg(workStr.trimmed());
3166  workStr = line.section(',', 2, 2); // stability timeout
3167  workStr.remove(",");
3168  xml += offset + QString(" <stabilityTimeout>%1</stabilityTimeout>").arg(workStr.trimmed());
3169  workStr = line.section(',', 3, 3); // ramp
3170  // check if a ramp value is given
3171  if (workStr.remove(",").trimmed().length()>0) {
3172  xml += offset + QString(" <ramp>%1</ramp>").arg(workStr.remove(",").trimmed());
3173  }
3174  workStr = line.section(',', 4, 4); // heater range
3175  // check if a heater range value is given
3176  if (workStr.remove(",").trimmed().length()>0) {
3177  xml += offset + QString(" <heaterRange>%1</heaterRange>").arg(workStr.remove(",").trimmed());
3178  }
3179  workStr = line.section(',', 5, 5); // P
3180  // check if a P value is given
3181  if (workStr.remove(",").trimmed().length()>0) {
3182  xml += offset + QString(" <P_PID>%1</P_PID>").arg(workStr.remove(",").trimmed());
3183  }
3184  workStr = line.section(',', 6, 6); // I
3185  // check if a I value is given
3186  if (workStr.remove(",").trimmed().length()>0) {
3187  xml += offset + QString(" <I_PID>%1</I_PID>").arg(workStr.remove(",").trimmed());
3188  }
3189  workStr = line.section(',', 7, 7); // D
3190  // check if a D value is given
3191  if (workStr.remove(",").trimmed().length()>0) {
3192  xml += offset + QString(" <D_PID>%1</D_PID>").arg(workStr.remove(",").trimmed());
3193  }
3194  workStr = line.section(',', 8, 8); // flow
3195  // check if a flow value is given
3196  if (workStr.remove(",").trimmed().length()>0) {
3197  xml += offset + QString(" <flow>%1</flow>").arg(workStr.remove(",").trimmed());
3198  }
3199  } else { // only T, dT given
3200  xml += offset + QString(" <deltaT>%1</deltaT>").arg(workStr.trimmed());
3201  }
3202  xml += offset + QString(" </setTemp>");
3203  xml += offset + QString("</autoRunCmd>");
3204 }
3205 
3206 //*******************************************************************************************************
3207 // implementation of ConvertTitle
3208 //*******************************************************************************************************
3218 void PAutoRunParser::ConvertTitle(QString &str, int lineNo, QString &offset, QStringList &xml)
3219 {
3220  QString line = CheckForAlias(str);
3221  QString workStr;
3222 
3223  xml += offset + QString("<autoRunCmd>");
3224  xml += offset + QString(" <setTitle>");
3225  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3226  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3227  xml += offset + QString(" <title>%1</title>").arg(line.section(' ', 1));
3228  // check for ODB tags
3229  if (line.contains("ODB_SAMPLE")>0)
3230  xml += offset + QString(" <odb_sample>true</odb_sample>");
3231  else
3232  xml += offset + QString(" <odb_sample>false</odb_sample>");
3233  if (line.contains("ODB_TEMP")>0)
3234  xml += offset + QString(" <odb_temp>true</odb_temp>");
3235  else
3236  xml += offset + QString(" <odb_temp>false</odb_temp>");
3237  if (line.contains("ODB_FIELD")>0)
3238  xml += offset + QString(" <odb_field>true</odb_field>");
3239  else
3240  xml += offset + QString(" <odb_field>false</odb_field>");
3241  if (line.contains("ODB_TRANSP")>0)
3242  xml += offset + QString(" <odb_transp>true</odb_transp>");
3243  else
3244  xml += offset + QString(" <odb_transp>false</odb_transp>");
3245  if (line.contains("ODB_HV_SAMP")>0)
3246  xml += offset + QString(" <odb_hv_samp>true</odb_hv_samp>");
3247  else
3248  xml += offset + QString(" <odb_hv_samp>false</odb_hv_samp>");
3249  if (line.contains("ODB_ENERGY")>0)
3250  xml += offset + QString(" <odb_energy>true</odb_energy>");
3251  else
3252  xml += offset + QString(" <odb_energy>false</odb_energy>");
3253  if (line.contains("ODB_RA_DIFF_LR")>0)
3254  xml += offset + QString(" <odb_ra_diff_lr>true</odb_ra_diff_lr>");
3255  else
3256  xml += offset + QString(" <odb_ra_diff_lr>false</odb_ra_diff_lr>");
3257  if (line.contains("ODB_RA_DIFF_TB")>0)
3258  xml += offset + QString(" <odb_ra_diff_tb>true</odb_ra_diff_tb>");
3259  else
3260  xml += offset + QString(" <odb_ra_diff_tb>false</odb_ra_diff_tb>");
3261  if (line.contains("ODB_SPIN_ROT")>0)
3262  xml += offset + QString(" <odb_spin_rot>true</odb_spin_rot>");
3263  else
3264  xml += offset + QString(" <odb_spin_rot>false</odb_spin_rot>");
3265  xml += offset + QString(" </setTitle>");
3266  xml += offset + QString("</autoRunCmd>");
3267 }
3268 
3269 //*******************************************************************************************************
3270 // implementation of ConvertTOF
3271 //*******************************************************************************************************
3281 void PAutoRunParser::ConvertTOF(QString &str, int lineNo, QString &offset, QStringList &xml)
3282 {
3283  QString line = CheckForAlias(str);
3284  QString workStr;
3285 
3286  xml += offset + QString("<autoRunCmd>");
3287  xml += offset + QString(" <setTOF>");
3288  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3289  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3290  workStr = line.section(' ', 1, 1);
3291  workStr = workStr.section(',', 0, 0);
3292  workStr.remove(",");
3293  xml += offset + QString(" <start>%1</start>").arg(workStr);
3294  xml += offset + QString(" <stop>%1</stop>").arg(line.section(',', 1, 1).trimmed());
3295  xml += offset + QString(" </setTOF>");
3296  xml += offset + QString("</autoRunCmd>");
3297 }
3298 
3299 //*******************************************************************************************************
3300 // implementation of ConvertWait
3301 //*******************************************************************************************************
3311 void PAutoRunParser::ConvertWait(QString &str, int lineNo, QString &offset, QStringList &xml)
3312 {
3313  QString line = CheckForAlias(str);
3314  xml += offset + QString("<autoRunCmd>");
3315  xml += offset + QString(" <setWait>");
3316  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3317  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3318  xml += offset + QString(" <wait>%1</wait>").arg(line.section(' ', 1, 1, QString::SectionSkipEmpty));
3319  xml += offset + QString(" </setWait>");
3320  xml += offset + QString("</autoRunCmd>");
3321 }
3322 
3323 //*******************************************************************************************************
3324 // implementation of ConvertWarmUp
3325 //*******************************************************************************************************
3335 void PAutoRunParser::ConvertWarmUp(QString &str, int lineNo, QString &offset, QStringList &xml)
3336 {
3337  QString line = CheckForAlias(str);
3338  xml += offset + QString("<autoRunCmd>");
3339  xml += offset + QString(" <warmUp>");
3340  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3341  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3342  xml += offset + QString(" <date>%1</date>").arg(line.section(' ', 1, 1).remove(",").trimmed());
3343  xml += offset + QString(" <time>%1</time>").arg(line.section(',', 1, 1).trimmed());
3344  if (line.indexOf("vent") == -1) {
3345  xml += offset + QString(" <vent>0</vent>");
3346  } else {
3347  xml += offset + QString(" <vent>1</vent>");
3348  }
3349  xml += offset + QString(" </warmUp>");
3350  xml += offset + QString("</autoRunCmd>");
3351 }
3352 
3353 //*******************************************************************************************************
3354 // implementation of ConvertDegaussWEW
3355 //*******************************************************************************************************
3364 void PAutoRunParser::ConvertDegaussWEW(QString &str, int lineNo, QString &offset, QStringList &xml)
3365 {
3366  xml += offset + QString("<autoRunCmd>");
3367  xml += offset + QString(" <degaussWEW>");
3368  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3369  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3370  xml += offset + QString(" </degaussWEW>");
3371  xml += offset + QString("</autoRunCmd>");
3372 }
3373 
3374 //*******************************************************************************************************
3375 // implementation of ConvertDegaussDanfysik
3376 //*******************************************************************************************************
3385 void PAutoRunParser::ConvertDegaussDanfysik(QString &str, int lineNo, QString &offset, QStringList &xml)
3386 {
3387  xml += offset + QString("<autoRunCmd>");
3388  xml += offset + QString(" <degaussDanfysik>");
3389  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3390  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3391  xml += offset + QString(" </degaussDanfysik>");
3392  xml += offset + QString("</autoRunCmd>");
3393 }
3394 
3395 //*******************************************************************************************************
3396 // implementation of ConvertDegauss
3397 //*******************************************************************************************************
3406 void PAutoRunParser::ConvertDegauss(QString &str, int lineNo, QString &offset, QStringList &xml)
3407 {
3408  xml += offset + QString("<autoRunCmd>");
3409  xml += offset + QString(" <degaussMagnet>");
3410  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3411  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3412  xml += offset + QString(" </degaussMagnet>");
3413  xml += offset + QString("</autoRunCmd>");
3414 }
3415 
3416 //*******************************************************************************************************
3417 // implementation of ConvertDegaussSpinRot
3418 //*******************************************************************************************************
3427 void PAutoRunParser::ConvertDegaussSpinRot(QString &str, int lineNo, QString &offset, QStringList &xml)
3428 {
3429  xml += offset + QString("<autoRunCmd>");
3430  xml += offset + QString(" <degaussSpinRot>");
3431  xml += offset + QString(" <line>%1</line>").arg(lineNo);
3432  xml += offset + QString(" <cmd_str>%1</cmd_str>").arg(str);
3433  xml += offset + QString(" </degaussSpinRot>");
3434  xml += offset + QString("</autoRunCmd>");
3435 }
3436 
3437 //*******************************************************************************************************
3438 // implementation of Parse
3439 //*******************************************************************************************************
3443 void PAutoRunParser::Parse()
3444 {
3445  QString errorMsg;
3446 
3447  // initialize xerces XML framework
3448  try {
3449  XMLPlatformUtils::Initialize();
3450  } catch (const XMLException &toCatch) {
3451  errorMsg = QString("XML xerces Error during initialization! Message:\n") +
3452  QString(XMLString::transcode(toCatch.getMessage()));
3453  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_XML_INIT_ERROR , 0, errorMsg);
3454  }
3455 
3456  // create a SAX parser object
3457  SAX2XMLReader *parser = XMLReaderFactory::createXMLReader();
3458  // set all the necessary parser flags
3459  parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
3460  parser->setFeature(XMLUni::fgXercesSchema, true);
3461  parser->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
3462  // for validation scheme 'auto'
3463  parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
3464  parser->setFeature(XMLUni::fgXercesDynamic, true);
3465 
3466  // create XML parse handler
3467  PSAX2AutoRunParseHandler handler(this);
3468  parser->setContentHandler(&handler);
3469  parser->setErrorHandler(&handler);
3470 
3471  // do the parsing
3472  try {
3473  parser->parse(fXMLFileName.toLatin1().data());
3474  } catch(const OutOfMemoryException&) {
3475  errorMsg = QString("XML xerces: Out of Memory Exception!");
3476  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_XML_OUT_OF_MEMORY, 0, errorMsg);
3477  } catch(const XMLException &e) {
3478  errorMsg = QString("Error during parsing in '") + fXMLFileName +
3479  QString("', Exception message:\n") +
3480  QString(XMLString::transcode(e.getMessage()));
3481  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_XML_EXCEPTION, 0, errorMsg);
3482  } catch(...) {
3483  errorMsg = QString("");
3484  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, LAR_XML_UNEXPECTED_EXCEPTION, 0, errorMsg);
3485  }
3486 
3487  // delete parser
3488  if (parser) {
3489  delete parser;
3490  parser = 0;
3491  }
3492 
3493  // terminate xerces XML framework
3494  XMLPlatformUtils::Terminate();
3495 
3496  // emit all encountered errors
3497  PXMLParseErrorVector::iterator it;
3498  for (it = fXMLParseErrorVector->begin(); it != fXMLParseErrorVector->end(); ++it) {
3499  emit ParseError(fXMLParseErrorVector->size(), fParseErrorCounter, it->errorCode, it->lineNo, it->errorMsg);
3500  fParseErrorCounter++;
3501  }
3502 
3503  // clean up fXMLParseErrorVector
3504  fXMLParseErrorVector->clear();
3505 }
PAutoRunParser::ConvertLoopTemp
void ConvertLoopTemp(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2461
PAutoRunParser::ConvertField
void ConvertField(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2284
PAutoRunParser::ConvertLoopFieldDanfysik
void ConvertLoopFieldDanfysik(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2582
PAutoRunParser::ConvertComment
void ConvertComment(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2129
PAutoRunParser::ConvertDump
void ConvertDump(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2155
XMLParseError::lineNo
int lineNo
line number in the user auto run seqence where the error occured
Definition: PAutoRunParser.h:46
PAutoRunParser::fAlias
QMap< QString, QString > fAlias
keep all alias
Definition: PAutoRunParser.h:179
LAR_XML_INIT_ERROR
#define LAR_XML_INIT_ERROR
XML init error tag.
Definition: lemAutoRun.h:56
LAR_XML_ERROR
#define LAR_XML_ERROR
XML error tag (parsing)
Definition: lemAutoRun.h:61
PAutoRunParser::ConvertWait
void ConvertWait(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3311
PAutoRunParser::ConvertLoopField
void ConvertLoopField(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2615
PAutoRunParser::ConvertSpinRot
void ConvertSpinRot(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3000
PAutoRunParser::ConvertTemp
void ConvertTemp(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3148
PSAX2AutoRunParseHandler::internalFatalError
void internalFatalError(QString &msg)
Definition: PAutoRunParser.cpp:1650
PAutoRunParser::ConvertTitle
void ConvertTitle(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3218
PAutoRunParser::ConvertFieldDanfysik
void ConvertFieldDanfysik(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2249
PXMLParseErrorVector
QVector< XMLParseError > PXMLParseErrorVector
Definition: PAutoRunParser.h:54
PSAX2AutoRunParseHandler::error
void error(const SAXParseException &exc)
Definition: PAutoRunParser.cpp:1604
AutoRunCmd::noElements
int noElements
number of parameters used for this command
Definition: lemAutoRun.h:224
PAutoRunParser::ConvertWarmUp
void ConvertWarmUp(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3335
AutoRunCmd::param
QString param[LAR_MAX_PARAM]
parameter list of the command
Definition: lemAutoRun.h:225
PAutoRunParser::ParseError
void ParseError(int noOfErrors, int idx, int errorNo, int line, QString errorMsg)
PAutoRunParser::ConvertBPV
void ConvertBPV(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2101
PAutoRunParser::ConvertFieldWEWL
void ConvertFieldWEWL(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2179
LAR_INPUT_FILE_READ_ERROR
#define LAR_INPUT_FILE_READ_ERROR
file read error tag
Definition: lemAutoRun.h:46
PAutoRunParser::fXMLFileName
QString fXMLFileName
file name of the XML auto run sequence
Definition: PAutoRunParser.h:177
PAutoRunParser::ConvertFOM
void ConvertFOM(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2319
PAutoRunParser::CheckForAlias
QString CheckForAlias(QString &str)
Definition: PAutoRunParser.cpp:1990
LAR_XML_EXCEPTION
#define LAR_XML_EXCEPTION
XML exception error tag.
Definition: lemAutoRun.h:58
PAutoRunParser::ConvertDegaussDanfysik
void ConvertDegaussDanfysik(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3385
PAutoRunCmdVector
QVector< AutoRunCmd > PAutoRunCmdVector
Definition: lemAutoRun.h:233
XMLParseError::errorCode
int errorCode
error code number defined in lemAutoRun.h
Definition: PAutoRunParser.h:45
PAutoRunParser::ConvertSampleHV
void ConvertSampleHV(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2879
PSAX2AutoRunParseHandler::warning
void warning(const SAXParseException &exc)
Definition: PAutoRunParser.cpp:1581
PAutoRunParser::ConvertHVOff
void ConvertHVOff(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2976
PSAX2AutoRunParseHandler::characters
void characters(const XMLCh *const chars, const XMLSize_t length)
Definition: PAutoRunParser.cpp:406
AutoRunCmd::lineNo
int lineNo
line number from where in the user auto run sequence the command originates
Definition: lemAutoRun.h:223
LAR_INVALID_CMD
#define LAR_INVALID_CMD
invalid cmd error tag
Definition: lemAutoRun.h:52
PAutoRunParser::GetAutoRunCmdVector
PAutoRunCmdVector * GetAutoRunCmdVector()
Definition: PAutoRunParser.h:166
PAutoRunParser::fInputFileName
QString fInputFileName
file name of the user auto run sequence
Definition: PAutoRunParser.h:175
PSAX2AutoRunParseHandler::startElement
void startElement(const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname, const Attributes &attrs)
Definition: PAutoRunParser.cpp:112
PAutoRunParser::ConvertIgnoreAlarms
void ConvertIgnoreAlarms(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2057
PAutoRunParser::ConvertTfl
void ConvertTfl(QString &str, int lineNo, QString &offset, QStringList &xml)
PAutoRunParser::ConvertTfl.
Definition: PAutoRunParser.cpp:3116
PAutoRunParser::ConvertLoopFieldWEWL
void ConvertLoopFieldWEWL(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2516
PAutoRunParser::ConvertFieldWEWH
void ConvertFieldWEWH(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2214
PAutoRunParser::fParseErrorCounter
int fParseErrorCounter
the number parse errors encountered before giving up
Definition: PAutoRunParser.h:181
LAR_XML_OUT_OF_MEMORY
#define LAR_XML_OUT_OF_MEMORY
XML out of memory error tag.
Definition: lemAutoRun.h:57
LAR_XML_FATAL
#define LAR_XML_FATAL
XML fatal error tag (parsing)
Definition: lemAutoRun.h:62
PSAX2AutoRunParseHandler::PSAX2AutoRunParseHandler
PSAX2AutoRunParseHandler(PAutoRunParser *arp)
Definition: PAutoRunParser.cpp:54
PAutoRunParser::ConvertModerator
void ConvertModerator(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2664
PSAX2AutoRunParseHandler::fatalError
void fatalError(const SAXParseException &exc)
Definition: PAutoRunParser.cpp:1627
LAR_INPUT_FILE_NOT_EXISTING
#define LAR_INPUT_FILE_NOT_EXISTING
file does not exist error tag
Definition: lemAutoRun.h:45
PAutoRunParser::ConvertOdbTag
void ConvertOdbTag(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2837
PAutoRunParser::ConvertLoopFieldWEWH
void ConvertLoopFieldWEWH(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2549
PAutoRunParser::ConvertDegaussSpinRot
void ConvertDegaussSpinRot(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3427
PAutoRunParser::fXMLParseErrorVector
PXMLParseErrorVector * fXMLParseErrorVector
vector holding all the parse error information
Definition: PAutoRunParser.h:233
PAutoRunParser::fAutoRunXMLSchemaPath
QString fAutoRunXMLSchemaPath
file name of the XML-schema
Definition: PAutoRunParser.h:176
PAutoRunParser::ConvertDegaussWEW
void ConvertDegaussWEW(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3364
PAutoRunParser::ConvertOdbSetData
void ConvertOdbSetData(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2693
LAR_XML_WARNING
#define LAR_XML_WARNING
XML warning tag (parsing)
Definition: lemAutoRun.h:60
PAutoRunParser::ConvertTransportHV
void ConvertTransportHV(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2952
PAutoRunParser::ConvertLoopList
void ConvertLoopList(QString &str, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2384
POdbTagVector
QVector< OdbTag > POdbTagVector
Definition: lemAutoRun.h:249
AutoRunCmd::cmd
QString cmd
command name string
Definition: lemAutoRun.h:222
PAutoRunParser::ConvertRA_HV
void ConvertRA_HV(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2903
PAutoRunParser::PAutoRunParser
PAutoRunParser(QString userAutoRunSeqFln, QString &schemaPath, QString &xmlFln, PAutoRunCmdVector *arcv, POdbTagVector *odbtagv)
Definition: PAutoRunParser.cpp:1760
PAutoRunParser::ConvertLoopEnd
void ConvertLoopEnd(QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2646
LAR_XML_UNEXPECTED_EXCEPTION
#define LAR_XML_UNEXPECTED_EXCEPTION
XML unexpected exception error tag.
Definition: lemAutoRun.h:59
PAutoRunParser::ConvertLoopIterator
void ConvertLoopIterator(QString &str, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2416
PAutoRunParser::ConvertIgnoreClients
void ConvertIgnoreClients(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2079
PAutoRunParser::ConvertAlias
void ConvertAlias(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2034
LAR_OUTPUT_FILE_WRITE_ERROR
#define LAR_OUTPUT_FILE_WRITE_ERROR
output file write error tag
Definition: lemAutoRun.h:54
XMLParseError::errorMsg
QString errorMsg
&#39;clear text&#39; error message. At the moment mostly comming from xerces
Definition: PAutoRunParser.h:47
PAutoRunParser::ConvertStop
void ConvertStop(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3088
PAutoRunParser::ConvertLEMSetup
void ConvertLEMSetup(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2343
PAutoRunParser::ConvertStart
void ConvertStart(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3058
PAutoRunParser::ConvertDegauss
void ConvertDegauss(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3406
PSAX2AutoRunParseHandler::endElement
void endElement(const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname)
Definition: PAutoRunParser.cpp:1352
PAutoRunParser::ConvertLoopStart
void ConvertLoopStart(int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2366
PAutoRunParser::ConvertTOF
void ConvertTOF(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:3281
PAutoRunParser::ConvertLoopSampleHV
void ConvertLoopSampleHV(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2494
LAR_MAX_PARAM
#define LAR_MAX_PARAM
maximum number of parameters for an auto run cmd
Definition: lemAutoRun.h:30
PAutoRunParser::ConvertOdbSetDataArray
void ConvertOdbSetDataArray(QString &str, int lineNo, QString &offset, QStringList &xml)
Definition: PAutoRunParser.cpp:2786
Generated by   doxygen 1.8.5