1547 {
1552 int i,
j, l,
n,
status, size,
index1,
index2,
state,
run_number,
cont;
1557
1558 if (!
seq.running ||
seq.paused) {
1560 return;
1561 }
1562
1563 if (
c->pnseq ==
NULL) {
1568 return;
1569 }
1570
1573 return;
1574
1575
1578 strcpy(
seq.last_msg,
str+11);
1579
1582 seq_error(
seq,
c,
"Cannot find <RunSequence> tag in XML file");
1583 return;
1584 }
1585
1587
1588
1589 if (
seq.stack_index > 0 &&
seq.current_line_number ==
seq.subroutine_end_line[
seq.stack_index - 1]) {
1591 seq.subroutine_end_line[
seq.stack_index - 1] = 0;
1592
1593 if (
seq.subroutine_return_line[
seq.stack_index - 1] == -1) {
1594
1596 cm_msg(
MTALK,
"sequencer",
"Sequencer is finished.");
1597
1599 return;
1600 }
1601
1602 seq.current_line_number =
seq.subroutine_return_line[
seq.stack_index - 1];
1603 seq.subroutine_return_line[
seq.stack_index - 1] = 0;
1604 seq.subroutine_call_line[
seq.stack_index - 1] = 0;
1605 seq.ssubroutine_call_line[
seq.stack_index - 1] = 0;
1608 return;
1609 }
1610
1611
1613
1616 cm_msg(
MTALK,
"sequencer",
"Sequencer is finished.");
1617
1619 }
1620 return;
1621 }
1622
1623
1625 if (
seq.loop_start_line[
i] > 0)
1626 break;
1628 if (
seq.current_line_number ==
seq.loop_end_line[
i]) {
1631
1632 if (
seq.loop_counter[
i] ==
seq.loop_n[
i]) {
1633 seq.loop_counter[
i] = 0;
1634 seq.loop_start_line[
i] = 0;
1635 seq.sloop_start_line[
i] = 0;
1636 seq.loop_end_line[
i] = 0;
1637 seq.sloop_end_line[
i] = 0;
1639 seq.current_line_number++;
1640 } else {
1649 value = std::to_string(
seq.loop_counter[
i] + 1);
1650 }
1652 size =
value.length() + 1;
1653 if (size < 32)
1654 size = 32;
1656 }
1657 seq.loop_counter[
i]++;
1658 seq.current_line_number =
seq.loop_start_line[
i] + 1;
1659 }
1661 return;
1662 }
1663 }
1664
1665
1666 if (
seq.if_index > 0 &&
seq.current_line_number ==
seq.if_endif_line[
seq.if_index - 1]) {
1670 seq.if_line[
seq.if_index] = 0;
1671 seq.if_else_line[
seq.if_index] = 0;
1672 seq.if_endif_line[
seq.if_index] = 0;
1673 seq.current_line_number++;
1675 return;
1676 }
1677
1678
1679 if (
seq.current_line_number ==
seq.subdir_end_line) {
1682 seq.subdir_end_line = 0;
1686 return;
1687 }
1688
1689
1694 seq.current_line_number++;
1696 return;
1697 }
1698
1699
1702 if (
seq.follow_libraries) {
1707
1708
1709 if (filename != std::string(
seq.sfilename)) {
1711 mstrlcpy(
seq.sfilename, filename.c_str(),
sizeof(
seq.sfilename));
1712 }
1713 }
1714 } else {
1717 }
1718 }
1719
1720
1721
1722#if 0
1723 if (
seq.scurrent_line_number >= 0) {
1725 std::string s =
o[
seq.scurrent_line_number - 1];
1726 printf(
"%3d: %s\n",
seq.scurrent_line_number, s.c_str());
1727 }
1728#endif
1729
1732
1733 seq.current_line_number++;
1735 }
1736
1737
1741 } else {
1742
1744 if (s.find('$') != std::string::npos)
1746
1751 seq.current_line_number++;
1752 }
1753 }
1754
1755
1759 } else {
1764
1767
1769 std::string
s1 = s.substr(0, s.find(
'['));
1770 std::string
s2 = s.substr(s.find(
'['));
1774 } else {
1775
1779 }
1780 }
1781
1783 if (
seq.subdir_not_notify)
1787
1790
1792
1794
1798 seq.current_line_number++;
1805 } else {
1806
1809 return;
1810 }
1811 }
1812 }
1813
1814
1817
1818
1820 path += "userfiles/sequencer/";
1823 } else {
1824
1826 path += "userfiles/sequencer/";
1829 if (
value.back() !=
'/')
1832 }
1833
1834 if (
value.find(
'$') != std::string::npos)
1836
1837
1843
1848 }
1849
1850
1854 return;
1855 } else {
1857 }
1858 } else {
1859
1861 }
1862
1866 seq.current_line_number++;
1869 } else {
1870
1872 return;
1873 }
1874 }
1875
1876
1879
1880
1882 path += "userfiles/sequencer/";
1885 } else {
1886
1888 path += "userfiles/sequencer/";
1892 size_t pos =
value.find_last_of(
'/');
1893 if (pos != std::string::npos)
1896 }
1897
1898 if (
value.find(
'$') != std::string::npos)
1900
1901
1907
1912 }
1913
1914
1918 return;
1919 } else {
1924 else
1928 return;
1929 }
1930 }
1931 } else {
1932 seq_error(
seq,
c,
"No ODB path specified in ODBSAVE command");
1933 return;
1934 }
1935
1939 seq.current_line_number++;
1942 } else {
1943
1945 return;
1946 }
1947 }
1948
1949
1953 } else {
1958
1961
1963 std::string
s1 = s.substr(0, s.find(
'['));
1964 std::string
s2 = s.substr(s.find(
'['));
1968 } else {
1969
1973 }
1974 }
1975
1976
1979
1984 return;
1985 } else {
1987 size =
sizeof(
data);
1988
1991 value = *((
int *)
data) > 0 ?
"1" :
"0";
1992 else
1994
1996 size =
value.length() + 1;
1997 if (size < 32)
1998 size = 32;
2000
2004 }
2005 }
2006 }
2007
2008
2014 } else {
2019
2022
2024 std::string
s1 = s.substr(0, s.find(
'['));
2025 std::string
s2 = s.substr(s.find(
'['));
2029 } else {
2030
2034 }
2035 }
2036
2038
2041
2045 return;
2046 } else {
2048
2049
2051 size =
sizeof(
data);
2054 break;
2055 }
2056
2060 else {
2063 return;
2064 }
2065
2067 size =
value.length() + 1;
2068 if (size < 32)
2069 size = 32;
2071
2075 }
2076 }
2077 }
2078
2079
2083 } else {
2088
2091
2093 std::string
s1 = s.substr(0, s.find(
'['));
2094 std::string
s2 = s.substr(s.find(
'['));
2098 } else {
2099
2103 }
2104 }
2105
2108
2110
2114 } else {
2116 size =
sizeof(
data);
2122 size =
sizeof(
data);
2124
2126 if (
seq.subdir_not_notify)
2130
2132 seq.current_line_number++;
2133 }
2134 }
2135 }
2136
2137
2143
2148 }
2149
2153 } else {
2157 } else
2158 seq.current_line_number++;
2159 }
2160 }
2161
2162
2168 } else {
2173
2178 }
2179
2180
2181 unsigned int tid;
2182 for (tid = 0; tid <
TID_LAST; tid++) {
2184 break;
2185 }
2186
2188 seq_error(
seq,
c,
"Type must be one of UINT8,INT8,UINT16,INT16,UINT32,INT32,BOOL,FLOAT,DOUBLE,STRING");
2189 else {
2190
2197 }
2198 } else {
2204 }
2205
2208 } else {
2214 }
2215 seq.current_line_number++;
2216 }
2217 }
2218 }
2219 }
2220
2221
2224 seq.current_line_number++;
2225 }
2226
2227
2230
2234 for (
i = 0;
i <
n;
i++) {
2235
2237
2240 }
2241 }
2242
2245 std::string r =
ss_execs(s.c_str());
2246
2247
2249
2250 seq.current_line_number++;
2251 }
2252
2253
2256 if (!
seq.transition_request) {
2257 seq.transition_request =
TRUE;
2258 size =
sizeof(
state);
2266 }
2267 }
2268 } else {
2269
2270 size =
sizeof(
state);
2274 seq.current_line_number++;
2275 }
2276 }
2278 if (!
seq.transition_request) {
2279 seq.transition_request =
TRUE;
2280 size =
sizeof(
state);
2285
2288 }
2289 }
2290 } else {
2291
2292 size =
sizeof(
state);
2297
2299
2300 if (
seq.stop_after_run) {
2302
2307 cm_msg(
MTALK,
"sequencer",
"Sequencer is finished by \"stop after current run\".");
2308 } else {
2309 cm_msg(
MTALK,
"sequencer",
"Sequencer is going to finish by \"stop after current run\". Executing ATEXIT.");
2310 }
2311 } else {
2312 seq.current_line_number++;
2313 }
2314
2316 }
2317 }
2318 } else {
2320 return;
2321 }
2322 }
2323
2324
2329 strcpy(
seq.wait_type,
"Events");
2337 seq.wait_type[0] = 0;
2338 seq.wait_odb[0] = 0;
2339 }
2346 return;
2347 } else {
2350
2353
2355 std::string
s1 = s.substr(0, s.find(
'['));
2356 std::string
s2 = s.substr(s.find(
'['));
2360 } else {
2361
2365 }
2366 }
2367
2373 return;
2374 } else {
2377 else
2380
2382 size =
sizeof(
data);
2385 value = *((
int *)
data) > 0 ?
"1" :
"0";
2386 else
2402 } else {
2404 return;
2405 }
2406
2411 seq.wait_type[0] = 0;
2412 seq.wait_odb[0] = 0;
2413 }
2414 }
2415 }
2418 strcpy(
seq.wait_type,
"Seconds");
2419 if (
seq.start_time == 0) {
2422 } else {
2424 if (
seq.wait_value >
seq.wait_limit)
2425 seq.wait_value =
seq.wait_limit;
2426 }
2428 seq.current_line_number++;
2432 seq.wait_type[0] = 0;
2433 seq.wait_odb[0] = 0;
2434 }
2435 } else {
2437 }
2438
2439
2441 }
2442
2443
2446 if (
seq.loop_start_line[
i] == 0)
2447 break;
2450 return;
2451 }
2452 seq.loop_start_line[
i] =
seq.current_line_number;
2458 seq.loop_counter[
i] = 1;
2459
2463 else {
2465 }
2471 } else {
2473 return;
2474 }
2475
2479 size =
value.length() + 1;
2480 if (size < 32)
2481 size = 32;
2483 }
2484
2485 seq.current_line_number++;
2486 }
2487
2488
2490
2491
2492 while (
seq.if_index > 0 &&
2493 seq.current_line_number >
seq.if_line[
seq.if_index - 1] &&
2494 seq.current_line_number <
seq.if_endif_line[
seq.if_index-1]) {
2498 seq.if_line[
seq.if_index] = 0;
2499 seq.if_else_line[
seq.if_index] = 0;
2500 seq.if_endif_line[
seq.if_index] = 0;
2501 seq.current_line_number++;
2503 }
2504
2505
2507 if (
seq.loop_start_line[
i] == 0)
2508 break;
2511 return;
2512 }
2513
2514
2515 seq.current_line_number =
seq.loop_end_line[
i-1];
2516 seq.loop_counter[
i-1] =
seq.loop_n[
i-1];
2517 }
2518
2519
2521
2523 seq_error(
seq,
c,
"Maximum number of nested if..endif exceeded");
2524 return;
2525 }
2526
2527
2528 seq.if_line[
seq.if_index] =
seq.current_line_number;
2530
2531
2532 seq.if_else_line[
seq.if_index] = 0;
2535
2536
2539 continue;
2540 }
2541
2542
2544 seq.if_else_line[
seq.if_index] =
j;
2545 break;
2546 }
2547 }
2548
2553 return;
2554 }
2555
2557 seq.current_line_number++;
2558 else if (
seq.if_else_line[
seq.if_index])
2559 seq.current_line_number =
seq.if_else_line[
seq.if_index] + 1;
2560 else
2561 seq.current_line_number =
seq.if_endif_line[
seq.if_index];
2562
2564 }
2565
2566
2568
2569 if (
seq.if_index == 0) {
2571 return;
2572 }
2573 seq.current_line_number =
seq.if_endif_line[
seq.if_index - 1];
2574 }
2575
2576
2579 cm_msg(
MTALK,
"sequencer",
"Sequencer is finished.");
2580 return;
2581 }
2582
2583
2587 return;
2588 }
2591 }
2599 seq.current_line_number =
i;
2600 break;
2601 }
2602 }
2603 }
2604 }
2605 }
2606
2607
2609
2611 }
2612
2613
2615
2617 }
2618
2619
2621
2623 }
2624
2625
2629 return;
2630 }
2633
2635
2646 }
2647 size =
value.length() + 1;
2648 if (size < 32)
2649 size = 32;
2651 } else {
2653 size =
value.length() + 1;
2654 if (size < 32)
2655 size = 32;
2657 }
2658
2659
2661 if (
seq.loop_start_line[
i] > 0) {
2666 }
2667 }
2668
2670 }
2671
2672
2676 else
2682
2684
2688 } else {
2689
2690
2691
2692 if (!
seq.message_wait) {
2696
2697 return;
2698 } else {
2699
2700
2701
2702 if (
seq.message[0] != 0) {
2703
2704 return;
2705 }
2706
2707
2708 seq.message_wait =
false;
2709 }
2710 }
2711
2713 }
2714
2715
2719 else
2721 std::string
type =
"INFO";
2724
2725 if (
type ==
"ERROR")
2727 else if (
type ==
"DEBUG")
2729 else if (
type ==
"LOG")
2731 else if (
type ==
"TALK")
2733 else
2735
2737 }
2738
2739
2743 return;
2744 }
2747 return;
2750 if (size < 32)
2751 size = 32;
2753
2755 }
2756
2757
2761 return;
2762 } else {
2763
2767
2768
2774
2776
2778
2780 char p[256];
2783 else
2785
2787 }
2788
2790 break;
2791 }
2792 }
2793 }
2794 }
2797 }
2798 }
2799 }
2800
2801
2802 else {
2804 }
2805
2806
2808 size =
sizeof(
seq1);
2814 seq.stop_after_run =
seq1.stop_after_run;
2816
2817
2820
2821
2823}
INT cm_transition(INT transition, INT run_number, char *errstr, INT errstr_size, INT async_flag, INT debug_flag)
#define CM_DEFERRED_TRANSITION
std::string ss_execs(const char *cmd)
std::string ss_replace_env_variables(const std::string &inputPath)
INT ss_sleep(INT millisec)
INT cm_msg_retrieve(INT n_message, char *message, INT buf_size)
INT db_get_data_index(HNDLE hDB, HNDLE hKey, void *data, INT *buf_size, INT idx, DWORD type)
INT db_delete_key(HNDLE hDB, HNDLE hKey, BOOL follow_links)
INT db_get_value(HNDLE hDB, HNDLE hKeyRoot, const char *key_name, void *data, INT *buf_size, DWORD type, BOOL create)
INT db_save_json(HNDLE hDB, HNDLE hKey, const char *filename, int flags)
INT db_save_xml(HNDLE hDB, HNDLE hKey, const char *filename)
INT db_create_key(HNDLE hDB, HNDLE hKey, const char *key_name, DWORD type)
INT db_get_record(HNDLE hDB, HNDLE hKey, void *data, INT *buf_size, INT align)
INT db_save(HNDLE hDB, HNDLE hKey, const char *filename, BOOL bRemote)
INT db_get_key(HNDLE hDB, HNDLE hKey, KEY *key)
INT db_load(HNDLE hDB, HNDLE hKeyRoot, const char *filename, BOOL bRemote)
INT db_set_data_index(HNDLE hDB, HNDLE hKey, const void *data, INT data_size, INT idx, DWORD type)
INT db_sprintf(char *string, const void *data, INT data_size, INT idx, DWORD type)
INT db_set_value(HNDLE hDB, HNDLE hKeyRoot, const char *key_name, const void *data, INT data_size, INT num_values, DWORD type)
INT db_set_data_index1(HNDLE hDB, HNDLE hKey, const void *data, INT data_size, INT idx, DWORD type, BOOL bNotify)
INT db_sscanf(const char *data_str, void *data, INT *data_size, INT i, DWORD tid)
INT db_set_num_values(HNDLE hDB, HNDLE hKey, INT num_values)
const char * rpc_tid_name(INT id)
void seq_array_index(SEQUENCER &seq, SeqCon *c, char *odbpath, int *index1, int *index2)
int concatenate(SEQUENCER &seq, SeqCon *c, char *result, int size, char *value)
int set_all_matching(HNDLE hDB, HNDLE hBaseKey, char *odbpath, char *value, int index1, int index2, int notify)
static void seq_start_next(SEQUENCER &seq, SeqCon *c)
int eval_condition(SEQUENCER &seq, SeqCon *c, const char *condition)
std::string msprintf(const char *format,...)
#define JSFLAG_FOLLOW_LINKS
#define JSFLAG_OMIT_LAST_WRITTEN
static void pn(const te_expr *n, int depth)