This source file includes following definitions.
- setenv
- unsetenv
- xstrerror_l
- strremove
- strtrimspace
- allowCores
- CleanDUMA
- dl_iterate_phdr_callback
- GetUCRTVersion
- dps8_sir_report_error
- main
- process_stdin_commands
- set_prompt
- find_cmd
- exit_cmd
- _cmd_name_compare
- fprint_help
- fprint_header
- fprint_reg_help_ex
- fprint_reg_help
- fprint_attach_help_ex
- fprint_set_help_ex
- fprint_set_help
- fprint_show_help_ex
- fprint_show_help
- fprint_brk_help_ex
- help_dev_help
- help_cmd_output
- help_cmd
- spawn_cmd
- echo_cmd
- do_cmd
- do_position
- do_cmd_label
- sim_sub_args
- sim_cmp_string
- assert_cmd
- send_cmd
- sim_show_send
- expect_cmd
- sim_show_expect
- goto_cmd
- return_cmd
- shift_cmd
- call_cmd
- on_cmd
- noop_cmd
- set_on
- set_verify
- set_message
- set_localopc
- set_quiet
- sim_set_environment
- set_cmd
- find_ctab
- find_c1tab
- set_dev_radix
- set_dev_enbdis
- set_unit_enbdis
- set_dev_debug
- show_cmd
- show_cmd_fi
- find_shtab
- show_device
- fprint_sep
- show_unit
- sprint_capac
- fprint_capac
- show_default_base_system_script
- printp
- strip_spaces
- printpq
- show_prom
- show_buildinfo
- show_version
- show_config
- show_log_names
- show_dev_logicals
- show_queue
- show_time
- show_break
- show_dev_radix
- show_dev_debug
- show_on
- show_mod_names
- show_dev_modifiers
- show_all_mods
- show_one_mod
- show_show_commands
- show_dev_show_commands
- brk_cmd
- ssh_break
- ssh_break_one
- reset_cmd
- reset_all
- reset_all_p
- attach_cmd
- scp_attach_unit
- attach_unit
- attach_err
- detach_cmd
- detach_all
- scp_detach_unit
- detach_unit
- sim_dname
- sim_uname
- run_cmd
- run_cmd_message
- sim_run_boot_prep
- fprint_stopped_gen
- fprint_stopped
- step_svc
- expect_svc
- int_handler
- exdep_cmd
- exdep_reg_loop
- exdep_addr_loop
- ex_reg
- get_rval
- dep_reg
- put_rval
- ex_addr
- get_aval
- dep_addr
- eval_cmd
- read_line
- read_line_p
- get_glyph_gen
- get_glyph
- get_glyph_nc
- get_glyph_quoted
- get_glyph_cmd
- sim_trim_endspc
- sim_isspace
- sim_islower
- sim_isalpha
- sim_isprint
- sim_isdigit
- sim_isgraph
- sim_isalnum
- get_uint
- get_range
- sim_decode_quoted_string
- sim_encode_quoted_string
- fprint_buffer_string
- find_dev
- find_unit
- sim_register_internal_device
- find_dev_from_unit
- qdisable
- find_reg_glob
- find_reg
- get_switches
- get_sim_sw
- get_sim_opt
- put_switches
- get_rsearch
- get_asearch
- test_search
- strtotv
- sprint_val
- fprint_val
- sim_fmt_secs
- sim_process_event
- sim_activate
- _sim_activate
- sim_activate_abs
- sim_activate_after
- _sim_activate_after
- sim_cancel
- sim_is_active
- sim_activate_time
- sim_gtime
- sim_qcount
- sim_brk_init
- sim_brk_fnd
- sim_brk_fnd_ex
- sim_brk_new
- sim_brk_set
- sim_brk_clr
- sim_brk_clrall
- sim_brk_show
- sim_brk_showall
- sim_brk_test
- sim_brk_getact
- sim_brk_clract
- sim_brk_setact
- sim_brk_npc
- sim_brk_clrspc
- sim_brk_message
- sim_set_expect
- sim_set_noexpect
- sim_exp_fnd
- sim_exp_clr_tab
- sim_exp_clr
- sim_exp_clrall
- sim_exp_set
- sim_exp_show_tab
- sim_exp_show
- sim_exp_showall
- sim_exp_check
- sim_send_input
- sim_send_clear
- sim_show_send_input
- sim_send_poll_data
- sim_error_text
- sim_string_to_stat
- get_dbg_verb
- sim_debug_prefix
- fprint_fields
- sim_debug_bits_hdr
- sim_debug_bits
- sim_printf
- sim_messagef
- _sim_debug
- sim_data_trace
- Fprintf
- appendText
- cleanHelp
- buildHelp
- helpPrompt
- displayMagicTopic
- displayFlatHelp
- matchHelpTopicName
- scp_vhelp
- scp_help
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42 #if !defined(__EXTENSIONS__)
43 # define __EXTENSIONS__
44 #endif
45
46 #if !defined(__STDC_WANT_LIB_EXT1__)
47 # define __STDC_WANT_LIB_EXT1__ 1
48 #endif
49
50 #if !defined(_GNU_SOURCE)
51 # define _GNU_SOURCE
52 #endif
53
54
55
56 #include "sim_defs.h"
57 #include "sim_disk.h"
58 #include "sim_hints.h"
59 #include "sim_tape.h"
60 #include "sim_sock.h"
61 #include "sim_os_mem.h"
62
63 #include <signal.h>
64 #include <ctype.h>
65 #include <time.h>
66 #include <math.h>
67 #include <stddef.h>
68 #if defined(_WIN32)
69 # if !defined(WIN32_LEAN_AND_MEAN)
70 # define WIN32_LEAN_AND_MEAN
71 # endif
72 # if defined(_MSC_VER)
73 # pragma warning(push, 3)
74 # endif
75 # include <direct.h>
76 # include <io.h>
77 # include <fcntl.h>
78 #else
79 # include <unistd.h>
80 # define HAVE_UNISTD 1
81 #endif
82 #include <sys/stat.h>
83 #include <sys/types.h>
84 #if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__MINGW64__) && !defined(CROSS_MINGW32) && !defined(CROSS_MINGW64)
85 # include <sys/resource.h>
86 #endif
87 #include <setjmp.h>
88 #include <stdint.h>
89 #include <limits.h>
90 #if defined(__APPLE__)
91 # include <xlocale.h>
92 #endif
93 #include <locale.h>
94
95 #include "linehistory.h"
96
97 #if defined(__APPLE__)
98 # include <sys/sysctl.h>
99 #endif
100
101 #if ( defined(__linux__) || defined(__linux) || defined(_linux) || defined(linux) )
102 # include <sys/sysinfo.h>
103 # define LINUX_OS
104 #endif
105
106 #include <uv.h>
107
108 #if !defined(HAVE_UNISTD)
109 # undef USE_BACKTRACE
110 #endif
111
112 #if defined(USE_BACKTRACE)
113 # include <string.h>
114 # include <signal.h>
115 #endif
116
117 #if defined(__HAIKU__)
118 # include <OS.h>
119 #endif
120
121 #if !defined(__CYGWIN__)
122 # if !defined(__APPLE__)
123 # if !defined(_AIX)
124 # if !defined(__MINGW32__)
125 # if !defined(__MINGW64__)
126 # if !defined(CROSS_MINGW32)
127 # if !defined(CROSS_MINGW64)
128 # if !defined(_WIN32)
129 # if !defined(__HAIKU__)
130 # if !defined(__QNX__)
131 # include <link.h>
132 # endif
133 # endif
134 # endif
135 # endif
136 # endif
137 # endif
138 # endif
139 # endif
140 # endif
141 #endif
142
143 #if defined(_WIN32) || defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
144 # include <windows.h>
145 #endif
146
147 #if defined(__CYGWIN__)
148 # include <windows.h>
149 # include <sys/utsname.h>
150 # include <sys/cygwin.h>
151 # include <cygwin/version.h>
152 #endif
153
154 #define DBG_CTR 0
155
156 #include "../dps8/dps8.h"
157 #include "../dps8/dps8_cpu.h"
158 #include "../dps8/dps8_rt.h"
159 #include "../dps8/dps8_priv.h"
160 #include "../dps8/dps8_topo.h"
161 #include "../dps8/ver.h"
162
163 #include "../dps8/dps8_iom.h"
164 #include "../dps8/dps8_fnp2.h"
165
166 #include "../decNumber/decContext.h"
167 #include "../decNumber/decNumberLocal.h"
168
169 #include "../dps8/dps8_math128.h"
170
171 #include "../dps8/dps8_sir.h"
172
173 #if !defined(__CYGWIN__)
174 # if !defined(__APPLE__)
175 # if !defined(_AIX)
176 # if !defined(__MINGW32__)
177 # if !defined(__MINGW64__)
178 # if !defined(CROSS_MINGW32)
179 # if !defined(CROSS_MINGW64)
180 # if !defined(_WIN32)
181 # if !defined(__HAIKU__)
182 # if !defined(__QNX__)
183 static unsigned int dl_iterate_phdr_callback_called = 0;
184 # endif
185 # endif
186 # endif
187 # endif
188 # endif
189 # endif
190 # endif
191 # endif
192 # endif
193 #endif
194
195 #if defined(MAX)
196 # undef MAX
197 #endif
198 #define MAX(a,b) (((a) >= (b)) ? (a) : (b))
199
200 #if defined(FREE)
201 # undef FREE
202 #endif
203 #define FREE(p) do \
204 { \
205 free((p)); \
206 (p) = NULL; \
207 } while(0)
208
209
210
211 #define SCH_OR 0
212 #define SCH_AND 1
213 #define SCH_XOR 2
214 #define SCH_E 0
215 #define SCH_N 1
216 #define SCH_G 2
217 #define SCH_L 3
218 #define SCH_EE 4
219 #define SCH_NE 5
220 #define SCH_GE 6
221 #define SCH_LE 7
222
223 #define MAX_DO_NEST_LVL 20
224 #define SRBSIZ 1024
225 #define SIM_BRK_INILNT 4096
226 #define SIM_BRK_ALLTYP 0xFFFFFFFB
227
228 #define UPDATE_SIM_TIME \
229 if (1) { \
230 int32 _x; \
231 if (sim_clock_queue == QUEUE_LIST_END) \
232 _x = noqueue_time; \
233 else \
234 _x = sim_clock_queue->time; \
235 sim_time = sim_time + (_x - sim_interval); \
236 sim_rtime = sim_rtime + ((uint32) (_x - sim_interval)); \
237 if (sim_clock_queue == QUEUE_LIST_END) \
238 noqueue_time = sim_interval; \
239 else \
240 sim_clock_queue->time = sim_interval; \
241 } \
242 else \
243 (void)0
244
245 #define SZ_D(dp) (size_map[((dp)->dwidth + CHAR_BIT - 1) / CHAR_BIT])
246
247 #define SZ_R(rp) \
248 (size_map[((rp)->width + (rp)->offset + CHAR_BIT - 1) / CHAR_BIT])
249
250 #define SZ_LOAD(sz,v,mb,j) \
251 if (sz == sizeof (uint8)) v = *(((uint8 *) mb) + ((uint32) j)); \
252 else if (sz == sizeof (uint16)) v = *(((uint16 *) mb) + ((uint32) j)); \
253 else if (sz == sizeof (uint32)) v = *(((uint32 *) mb) + ((uint32) j)); \
254 else v = *(((t_uint64 *) mb) + ((uint32) j));
255
256 #define SZ_STORE(sz,v,mb,j) \
257 if (sz == sizeof (uint8)) *(((uint8 *) mb) + j) = (uint8) v; \
258 else if (sz == sizeof (uint16)) *(((uint16 *) mb) + ((uint32) j)) = (uint16) v; \
259 else if (sz == sizeof (uint32)) *(((uint32 *) mb) + ((uint32) j)) = (uint32) v; \
260 else *(((t_uint64 *) mb) + ((uint32) j)) = v;
261
262 #define GET_SWITCHES(cp) \
263 if ((cp = get_sim_sw (cp)) == NULL) return SCPE_INVSW
264
265 #define GET_RADIX(val,dft) \
266 if (sim_switches & SWMASK ('O')) val = 8; \
267 else if (sim_switches & SWMASK ('D')) val = 10; \
268 else if (sim_switches & SWMASK ('H')) val = 16; \
269 else val = dft;
270
271
272
273
274
275
276 t_bool sim_asynch_enabled = FALSE;
277 t_stat tmxr_locate_line_send (const char *dev_line, SEND **snd);
278 t_stat tmxr_locate_line_expect (const char *dev_line, EXPECT **exp);
279 extern void (*sim_vm_init) (void);
280 extern void (*sim_vm_exit) (void);
281 char* (*sim_vm_read) (char *ptr, int32 size, FILE *stream) = NULL;
282 void (*sim_vm_post) (t_bool from_scp) = NULL;
283 CTAB *sim_vm_cmd = NULL;
284 void (*sim_vm_sprint_addr) (char *buf, DEVICE *dptr, t_addr addr) = NULL;
285 void (*sim_vm_fprint_addr) (FILE *st, DEVICE *dptr, t_addr addr) = NULL;
286 t_addr (*sim_vm_parse_addr) (DEVICE *dptr, CONST char *cptr, CONST char **tptr) = NULL;
287 t_value (*sim_vm_pc_value) (void) = NULL;
288 t_bool (*sim_vm_is_subroutine_call) (t_addr **ret_addrs) = NULL;
289 t_bool (*sim_vm_fprint_stopped) (FILE *st, t_stat reason) = NULL;
290 unsigned int nprocs;
291 unsigned int ncores;
292 bool mlock_failure = false;
293 char* sim_appfilename;
294
295
296
297
298
299 t_stat set_dev_radix (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
300 t_stat set_dev_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
301 t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
302 t_stat set_unit_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
303 t_stat ssh_break (FILE *st, const char *cptr, int32 flg);
304 t_stat show_cmd_fi (FILE *ofile, int32 flag, CONST char *cptr);
305 t_stat show_config (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
306 t_stat show_queue (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
307 t_stat show_time (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
308 t_stat show_mod_names (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
309 t_stat show_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
310 t_stat show_log_names (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
311 t_stat show_dev_radix (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
312 t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
313 t_stat show_dev_logicals (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
314 t_stat show_dev_modifiers (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
315 t_stat show_dev_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
316 t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
317 t_stat show_buildinfo (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cprr);
318 t_stat show_prom (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
319 t_stat show_default_base_system_script (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
320 t_stat show_default (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
321 t_stat show_break (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
322 t_stat show_on (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
323 t_stat sim_show_send (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
324 t_stat sim_show_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
325 t_stat show_device (FILE *st, DEVICE *dptr, int32 flag);
326 t_stat show_unit (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag);
327 t_stat show_all_mods (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flg, int32 *toks);
328 t_stat show_one_mod (FILE *st, DEVICE *dptr, UNIT *uptr, MTAB *mptr, CONST char *cptr, int32 flag);
329 t_stat sim_save (FILE *sfile);
330 t_stat sim_rest (FILE *rfile);
331
332
333
334 t_stat sim_brk_init (void);
335 t_stat sim_brk_set (t_addr loc, int32 sw, int32 ncnt, CONST char *act);
336 t_stat sim_brk_clr (t_addr loc, int32 sw);
337 t_stat sim_brk_clrall (int32 sw);
338 t_stat sim_brk_show (FILE *st, t_addr loc, int32 sw);
339 t_stat sim_brk_showall (FILE *st, uint32 sw);
340 CONST char *sim_brk_getact (char *buf, int32 size);
341 BRKTAB *sim_brk_new (t_addr loc, uint32 btyp);
342 char *sim_brk_clract (void);
343
344 FILE *stdnul;
345
346
347
348 SCHTAB *get_rsearch (CONST char *cptr, int32 radix, SCHTAB *schptr);
349 SCHTAB *get_asearch (CONST char *cptr, int32 radix, SCHTAB *schptr);
350 int32 test_search (t_value *val, SCHTAB *schptr);
351 static const char *get_glyph_gen (const char *iptr, char *optr, char mchar, t_bool uc, t_bool quote, char escape_char);
352 int32 get_switches (const char *cptr);
353 CONST char *get_sim_sw (CONST char *cptr);
354 t_stat get_aval (t_addr addr, DEVICE *dptr, UNIT *uptr);
355 t_value get_rval (REG *rptr, uint32 idx);
356 void put_rval (REG *rptr, uint32 idx, t_value val);
357 void fprint_help (FILE *st);
358 void fprint_stopped (FILE *st, t_stat r);
359 void fprint_capac (FILE *st, DEVICE *dptr, UNIT *uptr);
360 void fprint_sep (FILE *st, int32 *tokens);
361 char *read_line (char *ptr, int32 size, FILE *stream);
362 char *read_line_p (const char *prompt, char *ptr, int32 size, FILE *stream);
363 REG *find_reg_glob (CONST char *ptr, CONST char **optr, DEVICE **gdptr);
364 char *sim_trim_endspc (char *cptr);
365
366
367
368 t_stat scp_attach_unit (DEVICE *dptr, UNIT *uptr, const char *cptr);
369 t_stat scp_detach_unit (DEVICE *dptr, UNIT *uptr);
370 t_bool qdisable (DEVICE *dptr);
371 t_stat attach_err (UNIT *uptr, t_stat stat);
372 t_stat detach_all (int32 start_device, t_bool shutdown);
373 t_stat assign_device (DEVICE *dptr, const char *cptr);
374 t_stat deassign_device (DEVICE *dptr);
375 t_stat ssh_break_one (FILE *st, int32 flg, t_addr lo, int32 cnt, CONST char *aptr);
376 t_stat exdep_reg_loop (FILE *ofile, SCHTAB *schptr, int32 flag, CONST char *cptr,
377 REG *lowr, REG *highr, uint32 lows, uint32 highs);
378 t_stat ex_reg (FILE *ofile, t_value val, int32 flag, REG *rptr, uint32 idx);
379 t_stat dep_reg (int32 flag, CONST char *cptr, REG *rptr, uint32 idx);
380 t_stat exdep_addr_loop (FILE *ofile, SCHTAB *schptr, int32 flag, const char *cptr,
381 t_addr low, t_addr high, DEVICE *dptr, UNIT *uptr);
382 t_stat ex_addr (FILE *ofile, int32 flag, t_addr addr, DEVICE *dptr, UNIT *uptr);
383 t_stat dep_addr (int32 flag, const char *cptr, t_addr addr, DEVICE *dptr,
384 UNIT *uptr, int32 dfltinc);
385 void fprint_fields (FILE *stream, t_value before, t_value after, BITFIELD* bitdefs);
386 t_stat step_svc (UNIT *ptr);
387 t_stat expect_svc (UNIT *ptr);
388 t_stat set_on (int32 flag, CONST char *cptr);
389 t_stat set_verify (int32 flag, CONST char *cptr);
390 t_stat set_message (int32 flag, CONST char *cptr);
391 t_stat set_quiet (int32 flag, CONST char *cptr);
392 t_stat set_localopc (int32 flag, CONST char *cptr);
393 t_stat set_asynch (int32 flag, CONST char *cptr);
394 t_stat sim_show_asynch (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
395 t_stat do_cmd_label (int32 flag, CONST char *cptr, CONST char *label);
396 void int_handler (int signal);
397 t_stat set_prompt (int32 flag, CONST char *cptr);
398 t_stat sim_set_asynch (int32 flag, CONST char *cptr);
399 t_stat sim_set_environment (int32 flag, CONST char *cptr);
400 static const char *get_dbg_verb (uint32 dbits, DEVICE* dptr);
401
402
403
404 DEVICE *sim_dflt_dev = NULL;
405 UNIT *sim_clock_queue = QUEUE_LIST_END;
406 int32 sim_interval = 0;
407 int32 sim_switches = 0;
408 FILE *sim_ofile = NULL;
409 SCHTAB *sim_schrptr = NULL;
410 SCHTAB *sim_schaptr = NULL;
411 DEVICE *sim_dfdev = NULL;
412 UNIT *sim_dfunit = NULL;
413 DEVICE **sim_internal_devices = NULL;
414 uint32 sim_internal_device_count = 0;
415 int32 sim_opt_out = 0;
416 int32 sim_is_running = 0;
417 t_bool sim_processing_event = FALSE;
418 uint32 sim_brk_summ = 0;
419 uint32 sim_brk_types = 0;
420 BRKTYPTAB *sim_brk_type_desc = NULL;
421 uint32 sim_brk_dflt = 0;
422 uint32 sim_brk_match_type;
423 t_addr sim_brk_match_addr;
424 char *sim_brk_act[MAX_DO_NEST_LVL];
425 char *sim_brk_act_buf[MAX_DO_NEST_LVL];
426 BRKTAB **sim_brk_tab = NULL;
427 int32 sim_brk_ent = 0;
428 int32 sim_brk_lnt = 0;
429 int32 sim_brk_ins = 0;
430 int32 sim_iglock = 0;
431 int32 sim_nolock = 0;
432 int32 sim_quiet = 0;
433 int32 sim_localopc = 1;
434 int32 sim_randompst = 0;
435 int32 sim_randstate = 0;
436 int32 sim_step = 0;
437 int nodist = 0;
438 #if defined(PERF_STRIP)
439 int32 sim_nostate = 1;
440 #else
441 int32 sim_nostate = 0;
442 #endif
443 static double sim_time;
444 static uint32 sim_rtime;
445 static int32 noqueue_time;
446 volatile int32 stop_cpu = 0;
447 t_value *sim_eval = NULL;
448 static t_value sim_last_val;
449 static t_addr sim_last_addr;
450 FILE *sim_log = NULL;
451 FILEREF *sim_log_ref = NULL;
452 FILE *sim_deb = NULL;
453 FILEREF *sim_deb_ref = NULL;
454 int32 sim_deb_switches = 0;
455 struct timespec sim_deb_basetime;
456 char *sim_prompt = NULL;
457 static FILE *sim_gotofile;
458 static int32 sim_goto_line[MAX_DO_NEST_LVL+1];
459 static int32 sim_do_echo = 0;
460 static int32 sim_show_message = 1;
461 static int32 sim_on_inherit = 0;
462 #if !defined(PERF_STRIP)
463 static int32 sim_realtime = 0;
464 #endif
465 static int32 sim_do_depth = 0;
466 uint64_t sim_free_memory = 0;
467
468 static int32 sim_on_check[MAX_DO_NEST_LVL+1];
469 static char *sim_on_actions[MAX_DO_NEST_LVL+1][SCPE_MAX_ERR+1];
470 static char sim_do_filename[MAX_DO_NEST_LVL+1][CBUFSIZE];
471 static const char *sim_do_ocptr[MAX_DO_NEST_LVL+1];
472 static const char *sim_do_label[MAX_DO_NEST_LVL+1];
473
474 t_stat sim_last_cmd_stat;
475
476 static SCHTAB sim_stabr;
477 static SCHTAB sim_staba;
478
479 static UNIT sim_step_unit = { UDATA (&step_svc, 0, 0) };
480 static UNIT sim_expect_unit = { UDATA (&expect_svc, 0, 0) };
481
482 pthread_t main_thread_id;
483
484
485
486 const char save_vercur[] = "V4.1";
487 const char save_ver40[] = "V4.0";
488 const char save_ver35[] = "V3.5";
489 const char save_ver32[] = "V3.2";
490 const char save_ver30[] = "V3.0";
491 const struct scp_error {
492 const char *code;
493 const char *message;
494 } scp_errors[1+SCPE_MAX_ERR-SCPE_BASE] =
495 {{"NXM", "Address space exceeded"},
496 {"UNATT", "Unit not attached"},
497 {"IOERR", "I/O error"},
498 {"CSUM", "Checksum error"},
499 {"FMT", "Format error"},
500 {"NOATT", "Unit not attachable"},
501 {"OPENERR", "File open error"},
502 {"MEM", "Memory exhausted"},
503 {"ARG", "Invalid argument"},
504 {"STEP", "Step expired"},
505 {"UNK", "Unknown command"},
506 {"RO", "Read only argument"},
507 {"INCOMP", "Command not completed"},
508 {"STOP", "Simulation stopped"},
509 {"EXIT", "Goodbye"},
510 {"TTIERR", "Console input I/O error"},
511 {"TTOERR", "Console output I/O error"},
512 {"EOF", "End of file"},
513 {"REL", "Relocation error"},
514 {"NOPARAM", "No settable parameters"},
515 {"ALATT", "Unit already attached"},
516 {"TIMER", "Hardware timer error"},
517 {"SIGERR", "Signal handler setup error"},
518 {"TTYERR", "Console terminal setup error"},
519 {"SUB", "Subscript out of range"},
520 {"NOFNC", "Command not allowed"},
521 {"UDIS", "Unit disabled"},
522 {"NORO", "Read only operation not allowed"},
523 {"INVSW", "Invalid switch"},
524 {"MISVAL", "Missing value"},
525 {"2FARG", "Too few arguments"},
526 {"2MARG", "Too many arguments"},
527 {"NXDEV", "Non-existent device"},
528 {"NXUN", "Non-existent unit"},
529 {"NXREG", "Non-existent register"},
530 {"NXPAR", "Non-existent parameter"},
531 {"NEST", "Nested DO command limit exceeded"},
532 {"IERR", "Internal error"},
533 {"MTRLNT", "Invalid magtape record length"},
534 {"LOST", "Console Telnet connection lost"},
535 {"TTMO", "Console Telnet connection timed out"},
536 {"STALL", "Console Telnet output stall"},
537 {"AFAIL", "Assertion failed"},
538 {"INVREM", "Invalid remote console command"},
539 {"NOTATT", "Not attached"},
540 {"EXPECT", "Expect matched"},
541 {"REMOTE", "Remote console command"},
542 };
543
544 const size_t size_map[] = { sizeof (int8),
545 sizeof (int8), sizeof (int16), sizeof (int32), sizeof (int32)
546 , sizeof (t_int64), sizeof (t_int64), sizeof (t_int64), sizeof (t_int64)
547 };
548
549 const t_value width_mask[] = { 0,
550 0x1, 0x3, 0x7, 0xF,
551 0x1F, 0x3F, 0x7F, 0xFF,
552 0x1FF, 0x3FF, 0x7FF, 0xFFF,
553 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF,
554 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF,
555 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, 0xFFFFFF,
556 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF,
557 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF,
558 0x1FFFFFFFF, 0x3FFFFFFFF, 0x7FFFFFFFF, 0xFFFFFFFFF,
559 0x1FFFFFFFFF, 0x3FFFFFFFFF, 0x7FFFFFFFFF, 0xFFFFFFFFFF,
560 0x1FFFFFFFFFF, 0x3FFFFFFFFFF, 0x7FFFFFFFFFF, 0xFFFFFFFFFFF,
561 0x1FFFFFFFFFFF, 0x3FFFFFFFFFFF, 0x7FFFFFFFFFFF, 0xFFFFFFFFFFFF,
562 0x1FFFFFFFFFFFF, 0x3FFFFFFFFFFFF, 0x7FFFFFFFFFFFF, 0xFFFFFFFFFFFFF,
563 0x1FFFFFFFFFFFFF, 0x3FFFFFFFFFFFFF, 0x7FFFFFFFFFFFFF, 0xFFFFFFFFFFFFFF,
564 0x1FFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFF,
565 0x1FFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF
566 };
567
568 static const char simh_help[] =
569
570 "1Commands\n"
571 #define HLP_RESET "*Commands Resetting Devices"
572
573 "2Resetting Devices\n"
574 " The `RESET` command (*abbreviated* `RE`) resets a device or the entire\r\n"
575 " simulator to a predefined condition. If the switch \"`-p`\" is specified,\r\n"
576 " the device is reset to its initial power-on state:\r\n\r\n"
577 "++RESET resets all devices\r\n"
578 "++RESET -p power-cycle all devices\r\n"
579 "++RESET ALL resets all devices\r\n"
580 "++RESET <device> resets the specified <device>\r\n\r\n"
581 " * Typically, `RESET` *aborts* in-progress I/O operations, *clears* any\r\n"
582 " interrupt requests, and returns the device to a quiescent state.\r\n\r\n"
583 " * It does **NOT** clear the main memory or affect associated I/O\r\n"
584 " connections.\r\n"
585 #define HLP_EXAMINE "*Commands Examining_and_Changing_State"
586 #define HLP_IEXAMINE "*Commands Examining_and_Changing_State"
587 #define HLP_DEPOSIT "*Commands Examining_and_Changing_State"
588 #define HLP_IDEPOSIT "*Commands Examining_and_Changing_State"
589
590 "2Examining and Changing State\n"
591 " There are four commands to examine and change state:\r\n\r\n"
592 " * `EXAMINE` (*abbreviated* `E`) examines state\r\n"
593 " * `DEPOSIT` (*abbreviated* `D`) changes state\r\n"
594 " * `IEXAMINE` (\"interactive examine\", *abbreviated* `IE`) examines state\r\n"
595 " and allows the user to interactively change it\r\n"
596 " * `IDEPOSIT` (interactive deposit, *abbreviated* `ID`) allows the user to\r\n"
597 " interactively change state\r\n\r\n"
598 " All four commands take the form:\r\n\r\n"
599 "++command {modifiers} <object list>\r\n\r\n"
600 " The `DEPOSIT` command requires the deposit value at the end of the command.\r\n\r\n"
601 " There are four kinds of modifiers: **switches**, **device/unit name**,\r\n"
602 " **search specifier**, and for `EXAMINE`, **output file**.\r\n\r\n"
603 " * **Switches** have been described previously.\r\n"
604 " * A **device/unit name** identifies the device and unit whose address\r\n"
605 " space is to be examined or modified. If no device is specified, the CPU\r\n"
606 " main memory is selected. If a device but no unit is specified, unit `0`\r\n"
607 " of the specified device is selected automatically.\r\n"
608 " * The **search specifier** provides criteria for testing addresses or\r\n"
609 " registers to see if they should be processed. The search specifier\r\n"
610 " consists of a \"<`logical operator`>\", a \"<`relational operator`>\", or\r\n"
611 " both, optionally separated by spaces:\r\n\r\n"
612 "++{ < logical op > < value > } < relational op > < value >\r\n\r\n"
613
614 " * * The \"<`logical operator`>\" may be \"`&`\" (*and*), \"`|`\" (*or*),\r\n"
615 " or \"`^`\" (*exclusive or*), and the \"<`relational operator`>\" may\r\n"
616 " be \"`=`\" or \"`==`\" (*equal*), \"`!`\" or \"`!=`\" (*not\r\n"
617 " equal*), \">=\" (*greater than or equal*), \">\" (*greater\r\n"
618 " than*), \"<=\" (*less than or equal*), or \"<\" (*less than*).\r\n"
619 " * * If any \"<`logical operator`>\" is specified without\r\n"
620 " a \"<`relational operator`>\", it is ignored.\r\n"
621 " * * If any \"<`relational operator`>\" is specified without\r\n"
622 " a \"<`logical operator`>\", no logical operation is performed.\r\n"
623 " * * All comparisons are unsigned.\r\n\r\n"
624 " * The **output file** modifier redirects the command output to a file\r\n"
625 " instead of the console. The **output file** modifier is specified with\r\n"
626 " the \"`@`\" (*commercial-at*) character, followed by a valid file name.\r\n\r\n"
627 " **NOTE**: Modifiers may be specified in any order. If multiple\r\n"
628 " modifiers of the same type are specified, later modifiers override earlier\r\n"
629 " modifiers. If the **device/unit name** comes *after* the search specifier,\r\n"
630 " the search values will interpreted in the *radix of the CPU*, rather than\r\n"
631 " of the device/unit.\r\n\r\n"
632 " The \"<`object list`>\" argument consists of one or more of the following,\r\n"
633 " separated by commas:\r\n\r\n"
634
635 "++register the specified register\r\n"
636 "++register[sub1-sub2] the specified register array locations,\r\n"
637 "++++++++ starting at location sub1 up to and\r\n"
638 "++++++++ including location sub2\r\n"
639 "++register[sub1/length] the specified register array locations,\r\n"
640 "++++++++ starting at location sub1 up to but\r\n"
641 "++++++++ not including sub1+length\r\n"
642 "++register[ALL] all locations in the specified register\r\n"
643 "++++++++ array\r\n"
644 "++register1-register2 all the registers starting at register1\r\n"
645 "++++++++ up to and including register2\r\n"
646 "++address the specified location\r\n"
647 "++address1-address2 all locations starting at address1 up to\r\n"
648 "++++++++ and including address2\r\n"
649 "++address/length all location starting at address up to\r\n"
650 "++++++++ but not including address+length\r\n"
651 "++STATE all registers in the device\r\n"
652 "++ALL all locations in the unit\r\n"
653 "++$ the last value displayed by an EXAMINE\r\n"
654 "++++++++ command interpreted as an address\r\n"
655 "3Switches\n"
656 "4Formatting Control\n"
657 " Switches can be used to control the format of the displayed information:\r\n\r\n"
658
659 "5`-a`\n"
660 " display as ASCII\r\n"
661 "5`-c`\n"
662 " display as character string\r\n"
663 "5`-m`\n"
664 " display as instruction mnemonics\r\n"
665 "5`-o`\n"
666 " display as octal\r\n"
667 "5`-d`\n"
668 " display as decimal\r\n"
669 "5`-h`\n"
670 " display as hexadecimal\r\n\r\n"
671 "3Examples\n"
672 "++ex 1000-1100 examine 1000 to 1100\r\n"
673 "++de PC 1040 set PC to 1040\r\n"
674 "++ie 40-50 interactively examine 40:50\r\n"
675 "++ie >1000 40-50 interactively examine the subset\r\n"
676 "+++++++++ of locations 40:50 that are >1000\r\n"
677 "++ex rx0 50060 examine 50060, RX unit 0\r\n"
678 "++ex rx sbuf[3-6] examine SBUF[3] to SBUF[6] in RX\r\n"
679 "++de all 0 set main memory to 0\r\n"
680 "++de &77>0 0 set all addresses whose low order\r\n"
681 "+++++++++ bits are non-zero to 0\r\n"
682 "++ex -m @memdump.txt 0-7777 dump memory to file\r\n\r\n"
683 " * **NOTE**: To terminate an interactive command, simply type any bad value\r\n"
684 " (*e.g.* `XYZ`) when input is requested.\r\n"
685 #define HLP_EVALUATE "*Commands Evaluating_Instructions"
686
687 "2Evaluating Instructions\n"
688 " The `EVAL` command evaluates a symbolic expression and returns the\r\n"
689 " equivalent numeric value.\r\n\r\n"
690
691 "2Running A Simulated Program\n"
692 #define HLP_RUN "*Commands Running_A_Simulated_Program RUN"
693 "3RUN\n"
694 " The `RUN` command (*abbreviated* `RU`) resets all devices, deposits its\r\n"
695 " argument, if given, in the PC (program counter), and starts execution.\r\n"
696 " If no argument is given execution starts at the current PC.\r\n"
697 #define HLP_GO "*Commands Running_A_Simulated_Program GO"
698 "3GO\n"
699 " The `GO` command does *not* reset devices, deposits its argument (if\r\n"
700 " given) in the PC, and starts execution. If no argument is given,\r\n"
701 " execution starts at the current PC (program counter).\r\n"
702 #define HLP_CONTINUE "*Commands Running_A_Simulated_Program Continuing_Execution"
703 "3Continuing Execution\n"
704 " The `CONTINUE` command (*abbreviated* `CONT` or `CO`) resumes execution\r\n"
705 " (if execution was stopped, possibly due to hitting a breakpoint) at the\r\n"
706 " current program counter without resetting any devices.\r\n"
707 #define HLP_STEP "*Commands Running_A_Simulated_Program Step_Execution"
708 "3Step Execution\n"
709 " The `STEP` command (*abbreviated* `S`) resumes execution at the current\r\n"
710 " PC for the number of instructions given by its argument. If no argument\r\n"
711 " is supplied, one instruction is executed.\r\n"
712 "4Switches\n"
713 "5`-T`\n"
714 " If the `STEP` command is invoked with the \"`-T`\" switch, the step\r\n"
715 " command will cause execution to run for *microseconds* rather than\r\n"
716 " instructions.\r\n"
717 #define HLP_NEXT "*Commands Running_A_Simulated_Program NEXT"
718 "3NEXT\n"
719 " The `NEXT` command (*abbreviated* `N`) resumes execution at the current PC\r\n"
720 " for one instruction, attempting to execute *through* subroutine calls.\r\n"
721 " If the next instruction to be executed is *not* a subroutine call, then\r\n"
722 " one instruction is executed.\r\n"
723 #define HLP_BOOT "*Commands Running_A_Simulated_Program Booting_the_system"
724 "3Booting the system\n"
725 " The `BOOT` command (*abbreviated* `BO`) resets all devices and bootstraps\r\n"
726 " the device and unit given by its argument. If no unit is supplied,\r\n"
727 " unit `0` is bootstrapped. The specified unit must be `ATTACH`'ed.\r\n\r\n"
728 " When booting Multics, the boot device should always be `iom0`.\r\n"
729 " Assuming a tape is attached to the `tape0` device, it will be bootstrapped\r\n"
730 " into memory and the system will transfer control to the boot record.\r\n\r\n"
731 " **Example**\r\n\r\n"
732 "++; Boot Multics using iom0\r\n"
733 "++boot iom0\r\n\r\n"
734
735 "2Stopping The Simulator\n"
736 " The simulator runs until the simulated hardware encounters an error, or\r\n"
737 " until the user forces a stop condition.\r\n"
738 "3Simulator Detected Stop Conditions\n"
739 " These simulator-detected conditions stop simulation:\r\n\r\n"
740 "++- HALT instruction. If a HALT instruction is decoded, simulation stops.\r\n\r\n"
741 "++- I/O error. If an I/O error occurs during simulation of an I/O\r\n"
742 "+++operation, and the device stop-on-I/O-error flag is set, simulation\r\n"
743 "+++usually stops.\r\n\r\n"
744 "++- Processor condition. Certain processor conditions can stop\r\n"
745 "+++the simulation.\r\n"
746 "3User Specified Stop Conditions\n"
747 " Typing the interrupt character stops simulation. The interrupt character\r\n"
748 " is defined by the `WRU` (*Where aRe yoU*) console option, and is initially\r\n"
749 " set to `005` (`^E`).\r\n\r\n"
750
751 #define HLP_BREAK "*Commands Stopping_The_Simulator User_Specified_Stop_Conditions BREAK"
752 #define HLP_NOBREAK "*Commands Stopping_The_Simulator User_Specified_Stop_Conditions BREAK"
753 "4Breakpoints\n"
754 " The simulator offers breakpoint capability for debugging. Users may define\r\n"
755 " breakpoints of different types, identified by letter (for example, `E`\r\n"
756 " for *execution*, `R` for *read*, `W` for *write*, etc).\r\n\r\n"
757 " Associated with each breakpoint is a count and, optionally, one or more\r\n"
758 " actions. Each time a breakpoint occurs, the associated count\r\n"
759 " is *decremented*. If the count is less than or equal to `0`, the breakpoint\r\n"
760 " occurs; otherwise, it is deferred. When the breakpoint occurs, any\r\n"
761 " optional actions are automatically executed.\r\n\r\n"
762 " A breakpoint is set by the `BREAK` (or `SET BREAK`) command:\r\n\r\n"
763 "++BREAK {-types} {<addr range>{[count]},{addr range...}}{;action;action...}\r\n\r\n"
764 " If no type is specified, the default breakpoint type (`E`, *execution*) is\r\n"
765 " used. If no address range is specified, the current PC is used. As\r\n"
766 " with `EXAMINE` and `DEPOSIT`, an address range may be a single address, a\r\n"
767 " range of addresses low-high, or a relative range of address/length.\r\n"
768
769 "5Displaying Breakpoints\n"
770 " Currently set breakpoints can be displayed with the `SHOW BREAK` command:\r\n\r\n"
771 "++SHOW {-C} {-types} BREAK {ALL|<addr range>{,<addr range>...}}\r\n\r\n"
772 " Locations with breakpoints of the specified type are displayed.\r\n\r\n"
773 " The \"`-C`\" switch displays the selected breakpoint(s) formatted as\r\n"
774 " commands which may be subsequently used to establish the same\r\n"
775 " breakpoint(s).\r\n\r\n"
776 "5Removing Breakpoints\n"
777 " Breakpoints can be cleared by the `NOBREAK` or the `SET NOBREAK` commands.\r\n"
778 "5Examples\n"
779 " The following examples illustrate breakpoint usage:\r\n\r\n"
780 "++BREAK set E break at current PC\r\n"
781 "++BREAK -e 200 set E break at 200\r\n"
782 "++BREAK 2000/2[2] set E breaks at 2000,2001 with count = 2\r\n"
783 "++BREAK 100;EX AC;D MQ 0 set E break at 100 with actions EX AC and\r\n"
784 "+++++++++D MQ 0\r\n"
785 "++BREAK 100; delete action on break at 100\r\n\r\n"
786
787 "2Connecting and Disconnecting Devices\n"
788 " Units are simulated as files on the host file system. Before using any\r\n"
789 " simulated unit, the user must specify the file to be accessed by that unit.\r\n"
790 #define HLP_ATTACH "*Commands Connecting_and_Disconnecting_Devices Attaching_devices"
791 "3Attaching devices\n"
792 " The `ATTACH` (*abbreviation* `AT`) command associates a unit and a file:\r\n\r\n"
793 "++ATTACH <unit> <filename>\r\n\r\n"
794 " Some devices have more detailed or specific help available with:\r\n\r\n"
795 "++HELP <device> ATTACH\r\n\r\n"
796 "4Switches\n"
797 "5`-n`\n"
798 " If the \"`-n`\" switch is specified when `ATTACH` is executed, a new\r\n"
799 " file will be created when the filename specified does not exist, or an\r\n"
800 " existing file will have it's size truncated to zero, and an appropriate\r\n"
801 " message is printed.\r\n"
802 "5`-e`\n"
803 " If the file does not exist, and the \"`-e`\" switch *was not* specified,\r\n"
804 " a new file is created, and an appropriate message is printed. If\r\n"
805 " the \"`-e`\" switch *was* specified, a new file is *not* created, and an\r\n"
806 " error message is printed.\r\n"
807 "5`-r`\n"
808 " If the \"`-r`\" switch is specified, or the file is write protected by\r\n"
809 " host operating system, `ATTACH` tries to open the file in read only mode.\r\n"
810 " If the file does not exist, or the unit does not support read only\r\n"
811 " operation, an error occurs. Input-only devices, such as card readers, or\r\n"
812 " storage devices with write locking switches, such as disks or tapes,\r\n"
813 " support read only operation - other devices do not. If a file is\r\n"
814 " attached read only, its contents can be examined but not modified.\r\n"
815 "5`-q`\n"
816 " If the \"`-q`\" switch is specified when creating a new file (\"`-n`\")\r\n"
817 " or opening one read only (\"`-r`\"), the message announcing this fact\r\n"
818 " is suppressed.\r\n"
819 "5`-f`\n"
820 " For simulated magnetic tapes, the `ATTACH` command can specify the format\r\n"
821 " of the attached tape image file:\r\n\r\n"
822 "++ATTACH -f <tape_unit> <format> <filename>\r\n\r\n"
823 " * The currently supported magnetic tape image file formats are:\r\n\r\n"
824 " | | |\r\n"
825 " | ----------------:|:---------------------------------------------------- |\r\n"
826 " | \"**`SIMH`**\" | The **SIMH** / **DPS8M** native portable tape format |\r\n"
827 " | \"**`E11`**\" | The *D Bit* **Ersatz-11** simulator format |\r\n"
828 " | \"**`TPC`**\" | The **TPC** format (*used by _SIMH_ prior to V2.3*) |\r\n"
829 " | \"**`P7B`**\" | The **Paul Pierce** `7`-track tape archive format |\r\n\r\n"
830
831 " * The default tape format can also be specified with the `SET` command\r\n"
832 " prior to using the `ATTACH` command:\r\n\r\n"
833 "++SET <tape_unit> FORMAT=<format>\r\n"
834 "++ATTACH <tape_unit> <filename>\r\n\r\n"
835 " * The format of a currently attached tape image can be displayed with\r\n"
836 " the `SHOW FORMAT` command:\r\n\r\n"
837 "++SHOW <unit> FORMAT\r\n\r\n"
838 " **Examples**\r\n\r\n"
839 " The following example illustrates common `ATTACH` usage:\r\n"
840 "++; Associate the tape image file \"12.8MULTICS.tap\" with the tape0 unit\r\n"
841 "++; in read-only mode, where tape0 corresponds to the first tape device.\r\n"
842 "++ATTACH -r tape0 12.8MULTICS.tap\r\n\r\n"
843 "++; Associate the disk image file \"root.dsk\" with the disk0 unit.\r\n"
844 "++; The disk0 unit corresponds to the first disk device.\r\n"
845 "++ATTACH disk0 root.dsk\r\n\r\n"
846
847 #define HLP_DETACH "*Commands Connecting_and_Disconnecting_Devices Detaching_devices"
848 "3Detaching devices\n"
849 " The `DETACH` (*abbreviation* `DET`) command breaks the association between\r\n"
850 " a unit and its backing file or device:\r\n\r\n"
851 "++DETACH ALL Detach all units\r\n"
852 "++DETACH <unit> Detach specified unit\r\n\r\n"
853 " * **NOTE:** The `EXIT` command performs an automatic `DETACH ALL`.\r\n"
854 #define HLP_SET "*Commands SET"
855 "2SET\n"
856
857 #define HLP_SET_LOG "*Commands SET Logging"
858 "3Logging\n"
859 " Interactions with the simulator session can be recorded to a log file.\r\n\r\n"
860 "+SET LOG log_file Specify the log destination\r\n"
861 "++++++++ (STDOUT, DEBUG, or filename)\r\n"
862 "+SET NOLOG Disables any currently active logging\r\n"
863 "4Switches\n"
864 "5`-N`\n"
865 " By default, log output is written at the *end* of the specified log file.\r\n"
866 " A new log file can created if the \"`-N`\" switch is used on the command\r\n"
867 " line.\r\n\r\n"
868 "5`-B`\n"
869 " By default, log output is written in *text* mode. The log file can be\r\n"
870 " opened for *binary* mode writing if the \"`-B`\" switch is used on the\r\n"
871 " command line.\r\n"
872 #define HLP_SET_DEBUG "*Commands SET Debug_Messages"
873
874 "3Debug Messages\n"
875 "+SET DEBUG debug_file Specify the debug destination\r\n"
876 "++++++++ (STDOUT, STDERR, LOG, or filename)\r\n"
877 "+SET NODEBUG Disables any currently active debug output\r\n"
878 "4Switches\n"
879 " Debug message output contains a timestamp which indicates the number of\r\n"
880 " simulated instructions which have been executed prior to the debug event.\r\n\r\n"
881 " Debug message output can be enhanced to contain additional, potentially\r\n"
882 " useful information.\r\n\r\n\r\n"
883 " **NOTE**: If neither \"`-T`\" or \"`-A`\" is specified, \"`-T`\" is implied.\r\n"
884 "5`-T`\n"
885 " The \"`-T`\" switch causes debug output to contain a time of day displayed\r\n"
886 " as `hh:mm:ss.msec`.\r\n"
887 "5`-A`\n"
888 " The \"`-A`\" switch causes debug output to contain a time of day displayed\r\n"
889 " as `seconds.msec`.\r\n"
890 "5`-R`\n"
891 " The \"`-R`\" switch causes timing to be relative to the start of debugging.\r\n"
892 "5`-P`\n"
893 " The \"`-P`\" switch adds the output of the PC (program counter) to each\r\n"
894 " debug message.\r\n"
895 "5`-N`\n"
896 " The \"`-N`\" switch causes a new (empty) file to be written to.\r\n"
897 " (The default is to append to an existing debug log file).\r\n"
898 "5`-D`\n"
899 " The \"`-D`\" switch causes data blob output to also display the data\r\n"
900 " as **`RADIX-50`** characters.\r\n"
901 "5`-E`\n"
902 " The \"`-E`\" switch causes data blob output to also display the data\r\n"
903 " as \"**EBCDIC**\" characters.\r\n"
904
905 #define HLP_SET_ENVIRON "*Commands SET Environment_Variables"
906 "3Environment Variables\n"
907 "+SET ENVIRONMENT NAME=val Set environment variable\r\n"
908 "+SET ENVIRONMENT NAME Clear environment variable\r\n"
909 #define HLP_SET_ON "*Commands SET Command_Status_Trap_Dispatching"
910 "3Command Status Trap Dispatching\n"
911 "+SET ON Enables error checking command execution\r\n"
912 "+SET NOON Disables error checking command execution\r\n"
913 "+SET ON INHERIT Enables inheritance of ON state and actions\r\n"
914 "+SET ON NOINHERIT Disables inheritance of ON state and actions\r\n"
915 #define HLP_SET_VERIFY "*Commands SET Command_Execution_Display"
916 "3Command Execution Display\n"
917 "+SET VERIFY Enables display of processed script commands\r\n"
918 "+SET VERBOSE Enables display of processed script commands\r\n"
919 "+SET NOVERIFY Disables display of processed script commands\r\n"
920 "+SET NOVERBOSE Disables display of processed script commands\r\n"
921 #define HLP_SET_MESSAGE "*Commands SET Command_Error_Status_Display"
922 "3Command Error Status Display\n"
923 "+SET MESSAGE Re-enables display of script error messages\r\n"
924 "+SET NOMESSAGE Disables display of script error messages\r\n"
925 #define HLP_SET_QUIET "*Commands SET Command_Output_Display"
926 "3Command Output Display\n"
927 "+SET QUIET Disables suppression of some messages\r\n"
928 "+SET NOQUIET Re-enables suppression of some messages\r\n"
929 #define HLP_SET_LOCALOPC "*Commands SET Local_Operator_Console"
930 "3Local Operator Console\n"
931 "+SET LOCALOPC Enables local operator console\r\n"
932 "+SET NOLOCALOPC Disables local operator console\r\n"
933 #define HLP_SET_PROMPT "*Commands SET Command_Prompt"
934 "3Command Prompt\n"
935 "+SET PROMPT \"string\" Sets an alternate simulator prompt string\r\n"
936 "3Device and Unit Settings\n"
937 "+SET <dev> OCT|DEC|HEX Set device display radix\r\n"
938 "+SET <dev> ENABLED Enable device\r\n"
939 "+SET <dev> DISABLED Disable device\r\n"
940 "+SET <dev> DEBUG{=arg} Set device debug flags\r\n"
941 "+SET <dev> NODEBUG={arg} Clear device debug flags\r\n"
942 "+SET <dev> arg{,arg...} Set device parameters\r\n"
943 "+SET <unit> ENABLED Enable unit\r\n"
944 "+SET <unit> DISABLED Disable unit\r\n"
945 "+SET <unit> arg{,arg...} Set unit parameters\r\n"
946 "+HELP <dev> SET Displays any device specific SET commands\r\n"
947 " \r\n\r\n"
948 " See the Omnibus documentation for a complete SET command reference.\r\n"
949
950 #define HLP_SHOW "*Commands SHOW"
951 "2SHOW\n"
952 "+SH{OW} B{UILDINFO} Show build-time compilation information\r\n"
953 "+SH{OW} CL{OCKS} Show wall clock and timer information\r\n"
954 "+SH{OW} C{ONFIGURATION} Show simulator configuration\r\n"
955 "+SH{OW} D{EFAULT_BASE_SYSTEM} Show default base system script\r\n"
956 "+SH{OW} DEV{ICES} Show devices\r\n"
957 "+SH{OW} H{INTS} Show configuration hints\r\n"
958 "+SH{OW} M{ODIFIERS} Show SET commands for all devices\r\n"
959 "+SH{OW} O{N} Show ON condition actions\r\n"
960 "+SH{OW} P{ROM} Show CPU ID PROM initialization data\r\n"
961 "+SH{OW} Q{UEUE} Show event queue\r\n"
962 "+SH{OW} S{HOW} Show SHOW commands for all devices\r\n"
963 "+SH{OW} T{IME} Show simulated timer\r\n"
964 "+SH{OW} VE{RSION} Show simulator version\r\n"
965 "+H{ELP} <dev> SHOW Show device-specific SHOW commands\r\n"
966 "+SH{OW} <dev> {arg,...} Show device parameters\r\n"
967 "+SH{OW} <dev> DEBUG Show device debug flags\r\n"
968 "+SH{OW} <dev> MODIFIERS Show device modifiers\r\n"
969 "+SH{OW} <dev> RADIX Show device display radix\r\n"
970 "+SH{OW} <dev> SHOW Show device SHOW commands\r\n"
971 "+SH{OW} <unit> {arg,...} Show unit parameters\r\n\r\n"
972 " See the Omnibus documentation for a complete SHOW command reference.\r\n\r\n"
973 #define HLP_SHOW_CONFIG "*Commands SHOW"
974 #define HLP_SHOW_DEVICES "*Commands SHOW"
975 #define HLP_SHOW_FEATURES "*Commands SHOW"
976 #define HLP_SHOW_QUEUE "*Commands SHOW"
977 #define HLP_SHOW_TIME "*Commands SHOW"
978 #define HLP_SHOW_MODIFIERS "*Commands SHOW"
979 #define HLP_SHOW_NAMES "*Commands SHOW"
980 #define HLP_SHOW_SHOW "*Commands SHOW"
981 #define HLP_SHOW_VERSION "*Commands SHOW"
982 #define HLP_SHOW_BUILDINFO "*Commands SHOW"
983 #define HLP_SHOW_PROM "*Commands SHOW"
984 #define HLP_SHOW_HINTS "*Commands SHOW"
985 #define HLP_SHOW_DBS "*Commands SHOW"
986 #define HLP_SHOW_DEFAULT "*Commands SHOW"
987 #define HLP_SHOW_CONSOLE "*Commands SHOW"
988 #define HLP_SHOW_REMOTE "*Commands SHOW"
989 #define HLP_SHOW_BREAK "*Commands SHOW"
990 #define HLP_SHOW_LOG "*Commands SHOW"
991 #define HLP_SHOW_DEBUG "*Commands SHOW"
992 #define HLP_SHOW_CLOCKS "*Commands SHOW"
993 #define HLP_SHOW_ON "*Commands SHOW"
994 #define HLP_SHOW_SEND "*Commands SHOW"
995 #define HLP_SHOW_EXPECT "*Commands SHOW"
996 #define HLP_HELP "*Commands HELP"
997
998 "2HELP\n"
999 "+H{ELP} Show this message\r\n"
1000 "+H{ELP} <command> Show help for command\r\n"
1001 "+H{ELP} <dev> Show help for device\r\n"
1002 "+H{ELP} <dev> REGISTERS Show help for device register variables\r\n"
1003 "+H{ELP} <dev> ATTACH Show help for device specific ATTACH command\r\n"
1004 "+H{ELP} <dev> SET Show help for device specific SET commands\r\n"
1005 "+H{ELP} <dev> SHOW Show help for device specific SHOW commands\r\n"
1006 "+H{ELP} <dev> <command> Show help for device specific <command> command\r\n"
1007
1008 "2Altering The Simulated Configuration\n"
1009 " The \"SET <device> DISABLED\" command removes a device from the configuration.\r\n"
1010 " A `DISABLED` device is invisible to running programs. The device can still\r\n"
1011 " be `RESET`, but it cannot be `ATTACH`ed, `DETACH`ed, or `BOOT`ed.\r\n\r\n"
1012 " The \"SET <device> ENABLED\" command restores a disabled device to a\r\n"
1013 " configuration.\r\n\r\n"
1014 " Most multi-unit devices allow units to be enabled or disabled:\r\n\r\n"
1015 "++SET <unit> ENABLED\r\n"
1016 "++SET <unit> DISABLED\r\n\r\n"
1017 " When a unit is disabled, it will not be displayed by SHOW DEVICE.\r\n\r\n"
1018
1019 #define HLP_DO "*Commands Executing_Command_Files Processing_Command_Files"
1020 "2Executing Command Files\n"
1021 "3Processing Command Files\n"
1022 " The simulator can invoke another script file with the \"`DO`\" command:\r\n\r\n"
1023 "++DO <filename> {arguments...} execute commands in specified file\r\n\r\n"
1024 " The \"`DO`\" command allows command files to contain substitutable\r\n"
1025 " arguments. The string \"`%%n`\", where \"`n`\" is a number\r\n"
1026 " between \"`1`\" and \"`9`\", is replaced with argument \"`n`\" from\r\n"
1027 " the \"`DO`\" command line. (*i.e.* \"`%%0`\", \"`%%1`\", \"`%%2`\", etc.).\r\n"
1028 " The string \"`%%0`\" is replaced with \"<`filename`>\"\r\n"
1029 " The sequences \"`\\%%`\" and \"`\\\\`\" are replaced with the literal\r\n"
1030 " characters \"`%%`\" and \"`\\`\", respectively. Arguments with spaces must\r\n"
1031 " be enclosed in matching single or double quotation marks.\r\n\r\n"
1032 " * **NOTE**: Nested \"`DO`\" commands are supported, up to ten invocations\r\n"
1033 " deep.\r\n\r\n"
1034 "4Switches\n"
1035 "5`-v`\n\n"
1036 " If the switch \"`-v`\" is specified, commands in the command file are\r\n"
1037 " echoed *before* they are executed.\r\n\r\n"
1038 "5`-e`\n\n"
1039 " If the switch \"`-e`\" is specified, command processing (including nested\r\n"
1040 " command invocations) will be aborted if any command error is encountered.\r\n"
1041 " (A simulation stop **never** aborts processing; use `ASSERT` to catch\r\n"
1042 " unexpected stops.) Without this switch, all errors except `ASSERT` failures\r\n"
1043 " will be ignored, and command processing will continue.\r\n\r\n"
1044 "5`-o`\n\n"
1045 " If the switch \"`-o`\" is specified, the `ON` conditions and actions from\r\n"
1046 " the calling command file will be inherited by the command file being\r\n"
1047 " invoked.\r\n"
1048 "5`-q`\n\n"
1049 " If the switch \"`-q`\" is specified, *quiet mode* will be explicitly\r\n"
1050 " enabled for the called command file, otherwise the *quiet mode* setting\r\n"
1051 " is inherited from the calling context.\r\n"
1052
1053 #define HLP_GOTO "*Commands Executing_Command_Files GOTO"
1054 "3GOTO\n"
1055 " Commands in a command file execute in sequence until either an error\r\n"
1056 " trap occurs (when a command completes with an error status), or when an\r\n"
1057 " explicit request is made to start command execution elsewhere with\r\n"
1058 " the `GOTO` command:\r\n\r\n"
1059 "++GOTO <label>\r\n\r\n"
1060 " * Labels are lines in a command file which the first non-whitespace\r\n"
1061 " character is a \"`:`\".\r\n"
1062 " * The target of a `GOTO` is the first matching label in the current `DO`\r\n"
1063 " command file which is encountered.\r\n\r\n"
1064 " **Example**\r\n\r\n"
1065 " The following example illustrates usage of the `GOTO` command (by\r\n"
1066 " creating an infinite loop):\r\n\r\n"
1067 "++:Label\r\n"
1068 "++:: This is a loop.`\r\n"
1069 "++GOTO Label\r\n\r\n"
1070 #define HLP_RETURN "*Commands Executing_Command_Files RETURN"
1071
1072 "3RETURN\n"
1073 " The `RETURN` command causes the current procedure call to be restored to\r\n"
1074 " the calling context, possibly returning a specific return status.\r\n"
1075 " If no return status is specified, the return status from the last command\r\n"
1076 " executed will be returned. The calling context may have `ON` traps defined\r\n"
1077 " which may redirect command flow in that context.\r\n\r\n"
1078 "++RETURN return from command file with last command status\r\n"
1079 "++RETURN {-Q} <status> return from command file with specific status\r\n\r\n"
1080 " * The status return can be any numeric value or one of the standard SCPE_\r\n"
1081 " condition names.\r\n\r\n"
1082 " * The \"`-Q`\" switch on the `RETURN` command will cause the specified\r\n"
1083 " status to be returned, but normal error status message printing to be\r\n"
1084 " suppressed.\r\n\r\n"
1085 " **Condition Names**\r\n\r\n"
1086 " The available standard SCPE_ condition names and their meanings are:\r\n\r\n"
1087 " | Name | Meaning | Name | Meaning |\r\n"
1088 " | ------- | --------------------------------| ------- | ----------------------------------- |\r\n"
1089 " | NXM | Address space exceeded | UNATT | Unit not attached |\r\n"
1090 " | IOERR | I/O error | CSUM | Checksum error |\r\n"
1091 " | FMT | Format error | NOATT | Unit not attachable |\r\n"
1092 " | OPENERR | File open error | MEM | Memory exhausted |\r\n"
1093 " | ARG | Invalid argument | STEP | Step expired |\r\n"
1094 " | UNK | Unknown command | RO | Read only argument |\r\n"
1095 " | INCOMP | Command not completed | STOP | Simulation stopped |\r\n"
1096 " | EXIT | Goodbye | TTIERR | Console input I/O error |\r\n"
1097 " | TTOERR | Console output I/O error | EOF | End of file |\r\n"
1098 " | REL | Relocation error | NOPARAM | No settable parameters |\r\n"
1099 " | ALATT | Unit already attached | TIMER | Hardware timer error |\r\n"
1100 " | SIGERR | Signal handler setup error | TTYERR | Console terminal setup error |\r\n"
1101 " | NOFNC | Command not allowed | UDIS | Unit disabled |\r\n"
1102 " | NORO | Read only operation not allowed | INVSW | Invalid switch |\r\n"
1103 " | MISVAL | Missing value | 2FARG | Too few arguments |\r\n"
1104 " | 2MARG | Too many arguments | NXDEV | Non-existent device |\r\n"
1105 " | NXUN | Non-existent unit | NXREG | Non-existent register |\r\n"
1106 " | NXPAR | Non-existent parameter | NEST | Nested DO command limit exceeded |\r\n"
1107 " | IERR | Internal error | MTRLNT | Invalid magtape record length |\r\n"
1108 " | LOST | Console Telnet connection lost | TTMO | Console Telnet connection timed out |\r\n"
1109 " | STALL | Console Telnet output stall | AFAIL | Assertion failed |\r\n"
1110 " | INVREM | Invalid remote console command | | |\r\n"
1111 "\r\n\r\n"
1112 #define HLP_SHIFT "*Commands Executing_Command_Files Shift_Parameters"
1113 "3Shift Parameters\n"
1114 " Shift the command files positional parameters\r\n"
1115 #define HLP_CALL "*Commands Executing_Command_Files Call_a_subroutine"
1116 "3Call a subroutine\n"
1117 " Control can be transferred to a labeled subroutine using `CALL`.\r\n\r\n"
1118 " **Example**\r\n\r\n"
1119 "++CALL routine\r\n"
1120 "++BYE\r\n"
1121 "++\r\n"
1122 "++:routine\r\n"
1123 "++ECHO routine called\r\n"
1124 "++RETURN\r\n\r\n"
1125 #define HLP_ON "*Commands Executing_Command_Files ON"
1126 "3ON\n"
1127 " The `ON` command performs actions after a condition, or clears a condition.\r\n"
1128 "++ON <condition> <action> Perform action after condition\r\n"
1129 "++ON <condition> Clears action of specified condition\r\n"
1130 #define HLP_PROCEED "*Commands Executing_Command_Files PROCEED_or_IGNORE"
1131 #define HLP_IGNORE "*Commands Executing_Command_Files PROCEED_or_IGNORE"
1132
1133 "3PROCEED or IGNORE\n"
1134 " The `PROCEED` (or `IGNORE`) command does nothing. It is potentially\r\n"
1135 " useful as a placeholder for any `ON` action condition that should be\r\n"
1136 " explicitly ignored, allowing command file execution to continue without\r\n"
1137 " taking any specific action.\r\n"
1138 #define HLP_ECHO "*Commands Executing_Command_Files Displaying_Arbitrary_Text"
1139
1140 "3Displaying Arbitrary Text\n"
1141 " The `ECHO` command is a useful way of annotating command files. `ECHO`\r\n"
1142 " prints out its arguments to the console (and to any applicable log file):\r\n\r\n"
1143 "++ECHO <string> Output string to console\r\n\r\n"
1144 " **NOTE**: If no arguments are specified, `ECHO` prints a blank line.\r\n"
1145 " This may be used to provide spacing for console messages or log file\r\n"
1146 " output.\r\n"
1147
1148 #define HLP_ASSERT "*Commands Executing_Command_Files Testing_Assertions"
1149 "3Testing Assertions\n"
1150 " The `ASSERT` command tests a simulator state condition and halts command\r\n"
1151 " file execution if the condition is false:\r\n\r\n"
1152 "++ASSERT <Simulator State Expressions>\r\n\r\n"
1153 " * If the indicated expression evaluates to false, the command completes\r\n"
1154 " with an `AFAIL` condition. By default, when a command file encounters a\r\n"
1155 " command which returns the `AFAIL` condition, it will exit the running\r\n"
1156 " command file with the `AFAIL` status to the calling command file. This\r\n"
1157 " behavior can be changed with the `ON` command as well as switches to the\r\n"
1158 " invoking `DO` command.\r\n\r\n"
1159 " **Examples**\r\n\r\n"
1160 " The command file below might be used to bootstrap a hypothetical system\r\n"
1161 " that halts after the initial load from disk. The `ASSERT` command can then\r\n"
1162 " be used to confirm that the load completed successfully by examining the\r\n"
1163 " CPU's \"`A`\" register for the expected value:`\r\n\r\n"
1164 "++; Example INI file\r\n"
1165 "++BOOT\r\n"
1166 "++; A register contains error code; 0 = good boot\r\n"
1167 "++ASSERT A=0\r\n"
1168 "++RUN\r\n\r\n"
1169
1170 " * In the above example, if the \"`A`\" register is *not* `0`,\r\n"
1171 " the \"`ASSERT A=0`\" command will be displayed to the user, and the\r\n"
1172 " command file will be aborted with an \"`Assertion failed`\" message.\r\n"
1173 " Otherwise, the command file will continue to bring up the system.\r\n\r\n"
1174 " * See the **`IF`** command documentation for more information and details\r\n"
1175 " regarding simulator state expressions.\r\n\r\n"
1176 #define HLP_IF "*Commands Executing_Command_Files Testing_Conditions"
1177 "3Testing Conditions\n"
1178 " The `IF` command tests a simulator state condition and executes additional\r\n"
1179 " commands if the condition is true:\r\n\r\n"
1180 "++IF <Simulator State Expressions> commandtoprocess{; additionalcommand}...\r\n\r\n"
1181 " **Examples**\r\n\r\n"
1182 " The command file below might be used to bootstrap a hypothetical system\r\n"
1183 " that halts after the initial load from disk. The `IF` command can then\r\n"
1184 " be used to confirm that the load completed successfully by examining the\r\n"
1185 " CPU's \"`A`\" register for an expected value:\r\n\r\n"
1186 "++; Example INI file\r\n"
1187 "++BOOT\r\n"
1188 "++; A register contains error code; 0 = good boot\r\n"
1189 "++IF NOT A=0 echo Boot failed - Failure Code ; EX A; exit AFAIL\r\n"
1190 "++RUN\r\n\r\n"
1191
1192 " * In the above example, if the \"`A`\" register is *not* `0`, the\r\n"
1193 " message \"`Boot failed - Failure Code `\" will be displayed, the contents\r\n"
1194 " of the \"`A`\" register will be displayed, and the command file will be\r\n"
1195 " aborted with an \"`Assertion failed`\" message. Otherwise, the command\r\n"
1196 " file will continue to bring up the system.\r\n"
1197 "4Conditional Expressions\n"
1198 " The `IF` and `ASSERT` commands evaluate the following two different forms\r\n"
1199 " of conditional expressions.\r\n\r\n"
1200 "5Simulator State Expressions\n"
1201 " \r\n \r\n"
1202 " The values of simulator registers can be evaluated with:\r\n\r\n"
1203 "++{NOT} {<dev>} <reg>|<addr>{<logical-op><value>}<conditional-op><value>\r\n\r\n"
1204 " * If \"<`dev`>\" is not specified, `CPU` is assumed. \"<`reg`>\" is a\r\n"
1205 " register belonging to the indicated device.\r\n"
1206 " * The \"<`addr`>\" is an address in the address space of the indicated\r\n"
1207 " device.\r\n"
1208 " * The \"<`conditional-op`>\" and optional \"<`logical-op`>\" are\r\n"
1209 " the same as those used for \"search specifiers\" by the `EXAMINE` and\r\n"
1210 " `DEPOSIT` commands.\r\n"
1211 " The \"<`value`>\" is expressed in the radix specified for \"<`reg`>\",\r\n"
1212 " not in the radix for the device when referencing a register; when an\r\n"
1213 " address is referenced the device radix is used as the default.\r\n\r\n"
1214 " * If \"<`logical-op`>\" and \"<`value`>\" are specified, the target\r\n"
1215 " register value is first altered as indicated. The result is then compared\r\n"
1216 " to the \"<`value`>\" via the \"<`conditional-op`>\".\r\n"
1217 " * * If the result is *true*, the command(s) are executed before proceeding\r\n"
1218 " to the next line in the command file.\r\n"
1219 " * * If the result is *false*, the next command in the command file is\r\n"
1220 " processed.\r\n\r\n"
1221 "5String Comparison Expressions\n"
1222 " \r\n \r\n"
1223 " String Values can be compared with:\r\n\r\n"
1224 "++{-i} {NOT} \"<string1>\" <compare-op> \"<string2>\"\r\n\r\n"
1225 " * The \"`-i`\" switch, if present, causes a comparison to be case\r\n"
1226 " insensitive.\r\n"
1227 " * The \"<`string1`>\" and \"<`string2`>\" arguments are quoted string\r\n"
1228 " values which may have environment variables substituted as desired.\r\n"
1229 " * The \"<`compare-op`>\" may be one of:\r\n\r\n"
1230 " | | |\r\n"
1231 " | --------------:|:---------------------- |\r\n"
1232 " | \"**`==`**\" | equal |\r\n"
1233 " | \"**`EQU`**\" | equal |\r\n"
1234 " | \"**`!=`**\" | not equal |\r\n"
1235 " | \"**`NEQ`**\" | not equal |\r\n"
1236 " | \"**<**\" | less than |\r\n"
1237 " | \"**`LSS`**\" | less than |\r\n"
1238 " | \"**<=**\" | less than or equal |\r\n"
1239 " | \"**`LEQ`**\" | less than or equal |\r\n"
1240 " | \"**>**\" | greater than |\r\n"
1241 " | \"**`GTR`**\" | greater than |\r\n"
1242 " | \"**>=**\" | greater than or equal |\r\n"
1243 " | \"**`GEQ`**\" | greater than or equal |\r\n"
1244 " * **NOTE**: Comparisons are *generic*. This means that if\r\n"
1245 " both \"<`string1`>\" and \"<`string2`>\" are comprised of all numeric\r\n"
1246 " digits, then the strings are converted to numbers and a numeric\r\n"
1247 " comparison is performed. For example, the comparison\r\n"
1248 " '`\"+1\"` `EQU` `\"1\"`' evaluates to *true*.\r\n"
1249
1250 #define HLP_EXIT "*Commands Exiting_the_Simulator"
1251 "2Exiting the Simulator\n"
1252 " The `EXIT` command (*synonyms* `QUIT` *and* `BYE`) exits the simulator,\r\n"
1253 " returning control to the host operating system.\r\n"
1254
1255 #define HLP_SPAWN "*Commands Executing_System_Commands"
1256 "2Executing System Commands\n"
1257 " * The simulator can execute host operating system commands with\r\n"
1258 " the \"`!`\" (*spawn*) command.\r\n\r\n"
1259 " | | |\r\n"
1260 " |:----------------------- |:------------------------------------------- |\r\n"
1261 " | \"**`!`**\" | Spawn the hosts default command interpreter |\r\n"
1262 " | \"**`!`** <`command`>\" | Execute the host operating system `command` |\r\n\r\n"
1263 " * **NOTE**: The *exit status* from the command which was executed is set\r\n"
1264 " as the *command completion status* for the \"`!`\" command. This may\r\n"
1265 " influence any enabled `ON` condition traps.\r\n" ;
1266
1267
1268 static CTAB cmd_table[] = {
1269 { "RESET", &reset_cmd, 0, HLP_RESET },
1270 { "EXAMINE", &exdep_cmd, EX_E, HLP_EXAMINE },
1271 { "IEXAMINE", &exdep_cmd, EX_E+EX_I, HLP_IEXAMINE },
1272 { "DEPOSIT", &exdep_cmd, EX_D, HLP_DEPOSIT },
1273 { "IDEPOSIT", &exdep_cmd, EX_D+EX_I, HLP_IDEPOSIT },
1274 { "EVALUATE", &eval_cmd, 0, HLP_EVALUATE },
1275 { "RUN", &run_cmd, RU_RUN, HLP_RUN, NULL, &run_cmd_message },
1276 { "GO", &run_cmd, RU_GO, HLP_GO, NULL, &run_cmd_message },
1277 { "STEP", &run_cmd, RU_STEP, HLP_STEP, NULL, &run_cmd_message },
1278 { "NEXT", &run_cmd, RU_NEXT, HLP_NEXT, NULL, &run_cmd_message },
1279 { "CONTINUE", &run_cmd, RU_CONT, HLP_CONTINUE, NULL, &run_cmd_message },
1280 { "BOOT", &run_cmd, RU_BOOT, HLP_BOOT, NULL, &run_cmd_message },
1281 { "BREAK", &brk_cmd, SSH_ST, HLP_BREAK },
1282 { "NOBREAK", &brk_cmd, SSH_CL, HLP_NOBREAK },
1283 { "ATTACH", &attach_cmd, 0, HLP_ATTACH },
1284 { "DETACH", &detach_cmd, 0, HLP_DETACH },
1285 { "EXIT", &exit_cmd, 0, HLP_EXIT },
1286 { "QUIT", &exit_cmd, 0, NULL },
1287 { "BYE", &exit_cmd, 0, NULL },
1288 { "SET", &set_cmd, 0, HLP_SET },
1289 { "SHOW", &show_cmd, 0, HLP_SHOW },
1290 { "DO", &do_cmd, 1, HLP_DO },
1291 { "GOTO", &goto_cmd, 1, HLP_GOTO },
1292 { "RETURN", &return_cmd, 0, HLP_RETURN },
1293 { "SHIFT", &shift_cmd, 0, HLP_SHIFT },
1294 { "CALL", &call_cmd, 0, HLP_CALL },
1295 { "ON", &on_cmd, 0, HLP_ON },
1296 { "IF", &assert_cmd, 0, HLP_IF },
1297 { "PROCEED", &noop_cmd, 0, HLP_PROCEED },
1298 { "IGNORE", &noop_cmd, 0, HLP_IGNORE },
1299 { "ECHO", &echo_cmd, 0, HLP_ECHO },
1300 { "ASSERT", &assert_cmd, 1, HLP_ASSERT },
1301 { "SEND", &send_cmd, 0 },
1302 { "EXPECT", &expect_cmd, 1 },
1303 { "NOEXPECT", &expect_cmd, 0 },
1304 { "!", &spawn_cmd, 0, HLP_SPAWN },
1305 { "HELP", &help_cmd, 0, HLP_HELP },
1306 { NULL, NULL, 0 }
1307 };
1308
1309 static CTAB set_glob_tab[] = {
1310 { "CONSOLE", &sim_set_console, 0 },
1311 { "REMOTE", &sim_set_remote_console, 0 },
1312 { "BREAK", &brk_cmd, SSH_ST },
1313 { "NOBREAK", &brk_cmd, SSH_CL },
1314 { "TELNET", &sim_set_telnet, 0 },
1315 { "NOTELNET", &sim_set_notelnet, 0 },
1316 { "LOG", &sim_set_logon, 0, HLP_SET_LOG },
1317 { "NOLOG", &sim_set_logoff, 0, HLP_SET_LOG },
1318 { "DEBUG", &sim_set_debon, 0, HLP_SET_DEBUG },
1319 { "NODEBUG", &sim_set_deboff, 0, HLP_SET_DEBUG },
1320 { "ENVIRONMENT", &sim_set_environment, 1, HLP_SET_ENVIRON },
1321 { "ON", &set_on, 1, HLP_SET_ON },
1322 { "NOON", &set_on, 0, HLP_SET_ON },
1323 { "VERIFY", &set_verify, 1, HLP_SET_VERIFY },
1324 { "VERBOSE", &set_verify, 1, HLP_SET_VERIFY },
1325 { "NOVERIFY", &set_verify, 0, HLP_SET_VERIFY },
1326 { "NOVERBOSE", &set_verify, 0, HLP_SET_VERIFY },
1327 { "MESSAGE", &set_message, 1, HLP_SET_MESSAGE },
1328 { "NOMESSAGE", &set_message, 0, HLP_SET_MESSAGE },
1329 { "QUIET", &set_quiet, 1, HLP_SET_QUIET },
1330 { "NOQUIET", &set_quiet, 0, HLP_SET_QUIET },
1331 { "LOCALOPC", &set_localopc, 1, HLP_SET_LOCALOPC },
1332 { "NOLOCALOPC", &set_localopc, 0, HLP_SET_LOCALOPC },
1333 { "PROMPT", &set_prompt, 0, HLP_SET_PROMPT },
1334 { NULL, NULL, 0 }
1335 };
1336
1337 static C1TAB set_dev_tab[] = {
1338 { "OCTAL", &set_dev_radix, 8 },
1339 { "DECIMAL", &set_dev_radix, 10 },
1340 { "HEX", &set_dev_radix, 16 },
1341 { "ENABLED", &set_dev_enbdis, 1 },
1342 { "DISABLED", &set_dev_enbdis, 0 },
1343 { "DEBUG", &set_dev_debug, 1 },
1344 { "NODEBUG", &set_dev_debug, 0 },
1345 { NULL, NULL, 0 }
1346 };
1347
1348 static C1TAB set_unit_tab[] = {
1349 { "ENABLED", &set_unit_enbdis, 1 },
1350 { "DISABLED", &set_unit_enbdis, 0 },
1351 { NULL, NULL, 0 }
1352 };
1353
1354 static SHTAB show_glob_tab[] = {
1355 { "CONFIGURATION", &show_config, 0, HLP_SHOW_CONFIG },
1356 { "DEFAULT_BASE_SYSTEM_SCRIPT",
1357 &show_default_base_system_script, 0, HLP_SHOW_DBS },
1358 { "DEVICES", &show_config, 1, HLP_SHOW_DEVICES },
1359 { "FEATURES", &show_config, 2, HLP_SHOW_FEATURES },
1360 { "QUEUE", &show_queue, 0, HLP_SHOW_QUEUE },
1361 { "TIME", &show_time, 0, HLP_SHOW_TIME },
1362 { "MODIFIERS", &show_mod_names, 0, HLP_SHOW_MODIFIERS },
1363 { "NAMES", &show_log_names, 0, HLP_SHOW_NAMES },
1364 { "SHOW", &show_show_commands, 0, HLP_SHOW_SHOW },
1365 { "VERSION", &show_version, 1, HLP_SHOW_VERSION },
1366 { "BUILDINFO", &show_buildinfo, 1, HLP_SHOW_BUILDINFO },
1367 { "PROM", &show_prom, 0, HLP_SHOW_PROM },
1368 { "HINTS", &show_hints, 0, HLP_SHOW_HINTS },
1369 { "CONSOLE", &sim_show_console, 0, HLP_SHOW_CONSOLE },
1370 { "REMOTE", &sim_show_remote_console, 0, HLP_SHOW_REMOTE },
1371 { "BREAK", &show_break, 0, HLP_SHOW_BREAK },
1372 { "LOG", &sim_show_log, 0, HLP_SHOW_LOG },
1373 { "TELNET", &sim_show_telnet, 0 },
1374 { "DEBUG", &sim_show_debug, 0, HLP_SHOW_DEBUG },
1375 { "CLOCKS", &sim_show_timers, 0, HLP_SHOW_CLOCKS },
1376 { "SEND", &sim_show_send, 0, HLP_SHOW_SEND },
1377 { "EXPECT", &sim_show_expect, 0, HLP_SHOW_EXPECT },
1378 { "ON", &show_on, 0, HLP_SHOW_ON },
1379 { NULL, NULL, 0 }
1380 };
1381
1382 static SHTAB show_dev_tab[] = {
1383 { "RADIX", &show_dev_radix, 0 },
1384 { "DEBUG", &show_dev_debug, 0 },
1385 { "MODIFIERS", &show_dev_modifiers, 0 },
1386 { "NAMES", &show_dev_logicals, 0 },
1387 { "SHOW", &show_dev_show_commands, 0 },
1388 { NULL, NULL, 0 }
1389 };
1390
1391 static SHTAB show_unit_tab[] = {
1392 { NULL, NULL, 0 }
1393 };
1394
1395 #if defined(_WIN32)
1396 static
1397 int setenv(const char *envname, const char *envval, int overwrite)
1398 {
1399 char *envstr = (char *)malloc(strlen(envname)+strlen(envval)+2);
1400 int r;
1401
1402 (void)sprintf(envstr, "%s=%s", envname, envval);
1403 r = _putenv(envstr);
1404 FREE(envstr);
1405 return r;
1406 }
1407
1408 static
1409 int unsetenv(const char *envname)
1410 {
1411 setenv(envname, "", 1);
1412 return 0;
1413 }
1414 #endif
1415
1416 #if !defined(NO_LOCALE)
1417 # define XSTR_EMAXLEN 32767
1418
1419 const char
1420 *xstrerror_l(int errnum)
1421 {
1422 int saved = errno;
1423 const char *ret = NULL;
1424 static __thread char buf[XSTR_EMAXLEN];
1425
1426 # if defined(__APPLE__) || defined(_AIX) || defined(__MINGW32__) || \
1427 defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
1428 # if defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
1429 if (strerror_s(buf, sizeof(buf), errnum) == 0) ret = buf;
1430 # else
1431 if (strerror_r(errnum, buf, sizeof(buf)) == 0) ret = buf;
1432 # endif
1433 # else
1434 # if defined(__NetBSD__)
1435 locale_t loc = LC_GLOBAL_LOCALE;
1436 # else
1437 locale_t loc = uselocale((locale_t)0);
1438 # endif
1439 locale_t copy = loc;
1440 if (copy == LC_GLOBAL_LOCALE)
1441 copy = duplocale(copy);
1442
1443 if (copy != (locale_t)0)
1444 {
1445 ret = strerror_l(errnum, copy);
1446 if (loc == LC_GLOBAL_LOCALE)
1447 {
1448 freelocale(copy);
1449 }
1450 }
1451 # endif
1452
1453 if (!ret)
1454 {
1455 (void)snprintf(buf, sizeof(buf), "Unknown error %d", errnum);
1456 ret = buf;
1457 }
1458
1459 errno = saved;
1460 return ret;
1461 }
1462 #else
1463 # define xstrerror_l strerror
1464 #endif
1465
1466 t_stat process_stdin_commands (t_stat stat, char *argv[]);
1467
1468
1469
1470 char *strremove(char *str, const char *sub)
1471 {
1472 char *p, *q, *r;
1473 if (*sub && (q = r = strstr(str, sub)) != NULL) {
1474 size_t len = strlen(sub);
1475 while ((r = strstr(p = r + len, sub)) != NULL) {
1476 while (p < r)
1477 *q++ = *p++;
1478 }
1479 while ((*q++ = *p++) != '\0')
1480 continue;
1481 }
1482 return str;
1483 }
1484
1485
1486
1487 void strtrimspace (char *str_trimmed, const char *str_untrimmed)
1488 {
1489 while (*str_untrimmed != '\0') {
1490 if(!isspace((unsigned char)*str_untrimmed)) {
1491 *str_trimmed = (char)*str_untrimmed;
1492 str_trimmed++;
1493 }
1494 str_untrimmed++;
1495 }
1496 *str_trimmed = '\0';
1497 }
1498
1499 #if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__MINGW64__) && !defined(CROSS_MINGW32) && !defined(CROSS_MINGW64)
1500 void allowCores(void)
1501 {
1502 int ret;
1503 struct rlimit limit;
1504 # if defined(RLIMIT_CORE)
1505 ret = getrlimit(RLIMIT_CORE, &limit);
1506 (void)ret;
1507 # if defined(TESTING)
1508 if (ret != 0)
1509 {
1510 sim_warn ("Failed to query core dump configuration.");
1511 return;
1512 }
1513 # endif
1514 limit.rlim_cur = limit.rlim_max;
1515 ret = setrlimit(RLIMIT_CORE, &limit);
1516 # if defined(TESTING)
1517 if (ret != 0)
1518 {
1519 sim_warn ("Failed to enable unlimited core dumps.");
1520 return;
1521 }
1522 # endif
1523 # else
1524 # if defined(TESTING)
1525 sim_warn ("Unable to query core dump configuration.");
1526 # endif
1527 # endif
1528 return;
1529 }
1530 #endif
1531
1532 #if defined(USE_DUMA)
1533 void CleanDUMA(void)
1534 {
1535 (void)fflush(stdout);
1536 DUMA_CHECKALL();
1537 (void)fflush(stderr);
1538 }
1539 # undef USE_DUMA
1540 # define USE_DUMA 1
1541 #endif
1542
1543 #if !defined(SIG_SETMASK)
1544 # undef USE_BACKTRACE
1545 #endif
1546
1547 #if defined(PERF_STRIP)
1548 # undef USE_BACKTRACE
1549 #endif
1550
1551 #if defined(USE_BACKTRACE)
1552 # include <backtrace.h>
1553 # include <backtrace-supported.h>
1554 # define BACKTRACE_SKIP 1
1555 # define BACKTRACE_MAIN "main"
1556 # undef USE_BACKTRACE
1557 # define USE_BACKTRACE 1
1558 #endif
1559
1560 #if defined(BACKTRACE_SUPPORTED)
1561 # if defined(BACKTRACE_SUPPORTS_THREADS)
1562 # if !(BACKTRACE_SUPPORTED)
1563 # undef USE_BACKTRACE
1564 # endif
1565 # else
1566 # undef USE_BACKTRACE
1567 # endif
1568 #else
1569 # undef USE_BACKTRACE
1570 #endif
1571
1572 #if defined(USE_BACKTRACE)
1573 # if defined(BACKTRACE_SUPPORTED)
1574 # include "backtrace_func.c"
1575 # endif
1576 #endif
1577
1578 #if !defined(__CYGWIN__)
1579 # if !defined(__APPLE__)
1580 # if !defined(_AIX)
1581 # if !defined(__MINGW32__)
1582 # if !defined(__MINGW64__)
1583 # if !defined(CROSS_MINGW32)
1584 # if !defined(CROSS_MINGW64)
1585 # if !defined(_WIN32)
1586 # if !defined(__HAIKU__)
1587 # if !defined(__QNX__)
1588 static int
1589 dl_iterate_phdr_callback (struct dl_phdr_info *info, size_t size, void *data)
1590 {
1591 (void)size;
1592 (void)data;
1593
1594 if (strlen(info->dlpi_name) >= 2) {
1595 if (!dl_iterate_phdr_callback_called)
1596 (void)printf ("\r\n Loaded shared objects: ");
1597
1598 dl_iterate_phdr_callback_called++;
1599 (void)printf ("%s ", info->dlpi_name);
1600 }
1601
1602 return 0;
1603 }
1604 # endif
1605 # endif
1606 # endif
1607 # endif
1608 # endif
1609 # endif
1610 # endif
1611 # endif
1612 # endif
1613 #endif
1614
1615 #if defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
1616 # if defined(_UCRT)
1617 # define MINGW_CRT "UCRT"
1618 # else
1619 # define MINGW_CRT "MSVCRT"
1620 # endif
1621 #endif
1622
1623 #if defined(_WIN32) || defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
1624 struct UCRTVersion
1625 {
1626 uint16_t ProductVersion[4];
1627 };
1628
1629 int
1630 GetUCRTVersion (struct UCRTVersion *ucrtversion)
1631 {
1632 # ifdef _DEBUG
1633 static const wchar_t *DllName = L"ucrtbased.dll";
1634 # else
1635 static const wchar_t *DllName = L"ucrtbase.dll";
1636 # endif
1637
1638 HMODULE ucrt = GetModuleHandleW (DllName);
1639 if (!ucrt)
1640 return GetLastError ();
1641
1642 wchar_t path[SIR_MAXPATH];
1643 if (!GetModuleFileNameW (ucrt, path, SIR_MAXPATH))
1644 return GetLastError ();
1645
1646 DWORD versionInfoSize = GetFileVersionInfoSizeW (path, NULL);
1647 if (!versionInfoSize)
1648 return GetLastError ();
1649
1650 uint8_t versionInfo[versionInfoSize];
1651
1652 if (!GetFileVersionInfoW (path, 0, versionInfoSize, versionInfo))
1653 return GetLastError ();
1654
1655 VS_FIXEDFILEINFO *fixedFileInfo;
1656 UINT fixedFileInfoSize;
1657 if (!VerQueryValueW (versionInfo, L"\\", (void **)&fixedFileInfo, &fixedFileInfoSize))
1658 return GetLastError ();
1659
1660 memcpy (ucrtversion->ProductVersion, &fixedFileInfo->dwProductVersionMS, sizeof (uint32_t) * 2);
1661
1662 return 0;
1663 }
1664 #endif
1665
1666
1667
1668 #if !defined(PERF_STRIP)
1669 static int dps8_sir_report_error(void)
1670 {
1671 char message[SIR_MAXERROR] = {0};
1672 (void)sir_geterror(message);
1673 (void)fprintf(stderr, SIR_BREDB("libsir error: ") SIR_RED("%s%s"), message, SIR_EOL);
1674 return EXIT_FAILURE;
1675 }
1676
1677
1678
1679 int main (int argc, char *argv[])
1680 {
1681 char *cptr, *cptr2;
1682 char nbuf[PATH_MAX + 7];
1683 char cbuf[4*CBUFSIZE];
1684 char **targv = NULL;
1685 int32 i, sw;
1686 t_bool lookswitch;
1687 t_stat stat;
1688
1689
1690 # if !defined(__sun) && !defined(__illumos__) && !defined(_WIN32)
1691 uid_t real_uid = getuid();
1692 uid_t eff_uid = geteuid();
1693 if (0 == eff_uid && 0 != real_uid) {
1694 (void)fprintf(stderr, "FATAL: Running with improper setuid root privileges!\r\n");
1695 exit(EXIT_FAILURE);
1696 }
1697 # endif
1698
1699 sunos_obtain_realtime_privileges();
1700
1701 sim_free_memory = sim_memory_available();
1702
1703 sim_appfilename = _sir_getappfilename();
1704 if (sim_appfilename == NULL) {
1705 sim_appfilename = "dps8";
1706 }
1707
1708
1709
1710 sirinit si;
1711 if (!sir_makeinit(&si))
1712 return dps8_sir_report_error();
1713
1714
1715 si.d_stdout.levels = SIRL_DEBUG | SIRL_INFO | SIRL_WARN | SIRL_NOTICE;
1716
1717
1718 si.d_stdout.opts = SIRO_NONAME | SIRO_NOLEVEL | SIRO_NOTIME | SIRO_NOHOST | SIRO_NOPID;
1719
1720
1721 si.d_stderr.levels = SIRL_ERROR | SIRL_CRIT | SIRL_ALERT | SIRL_EMERG;
1722
1723
1724 si.d_stderr.opts = SIRO_NOHOST;
1725
1726
1727 si.d_syslog.levels = SIRL_NONE;
1728
1729
1730 si.d_syslog.opts = SIRO_DEFAULT;
1731
1732
1733 (void)_sir_strncpy(si.name, SIR_MAXNAME, appname, strnlen(appname, SIR_MAXNAME));
1734
1735
1736 if (!sir_init(&si))
1737 return dps8_sir_report_error();
1738
1739 # if defined(_AIX)
1740 if (getenv("DPS8M_SKIP_AIX_VARIABLES") == NULL) {
1741 if (setenv("DPS8M_SKIP_AIX_VARIABLES", "1", 1)) {
1742 (void)fprintf(stderr, "\rFATAL: Failed to set \"DPS8M_SKIP_AIX_VARIABLES=1\"! Aborting at %s[%s:%d]\r\n",
1743 __func__, __FILE__, __LINE__);
1744 abort();
1745 }
1746
1747 if (setenv("AIXTHREAD_AFFINITY", "strict", 1)) {
1748 (void)fprintf(stderr, "\rWARN: Failed to set \"AIXTHREAD_AFFINITY=strict\".\r\n");
1749 }
1750
1751 if (setenv("AIXTHREAD_MUTEX_FAST", "ON", 1)) {
1752 (void)fprintf(stderr, "\rWARN: Failed to set \"AIXTHREAD_MUTEX_FAST=ON\".\r\n");
1753 }
1754
1755 if (setenv("MALLOCOPTIONS", "multiheap", 1)) {
1756 (void)fprintf(stderr, "\rWARN: Failed to set \"MALLOCOPTIONS=multiheap\".\r\n");
1757 }
1758
1759 # if !defined(__PASE__)
1760 if (setenv("AIXTHREAD_SCOPE", "S", 1)) {
1761 (void)fprintf(stderr, "\rWARN: Failed to set \"AIXTHREAD_SCOPE=S\".\r\n");
1762 }
1763 # else
1764 # if !defined(TESTING)
1765 if (setenv("PASE_SYSCALL_NOSIGILL", "ALL", 1)) {
1766 (void)fprintf(stderr, "\rWARN: Failed to set \"PASE_SYSCALL_NOSIGILL=ALL\".\r\n");
1767 }
1768 # endif
1769 # endif
1770
1771 if (execvp(argv[0], argv) == -1) {
1772 (void)fprintf(stderr, "\rFATAL: execvp failed! Aborting at %s[%s:%d]\r\n",
1773 __func__, __FILE__, __LINE__);
1774 abort();
1775 }
1776 }
1777 # endif
1778
1779 # if defined(USE_BACKTRACE)
1780 # if defined(BACKTRACE_SUPPORTED)
1781 # if defined(_INC_BACKTRACE_FUNC)
1782 bt_pid = (long)_sir_getpid();
1783 (void)bt_pid;
1784 # endif
1785 # endif
1786 # endif
1787
1788 # if defined(__MINGW32__)
1789 # undef IS_WINDOWS
1790 # define IS_WINDOWS 1
1791 # if !defined(NEED_CONSOLE_SETUP)
1792 # define NEED_CONSOLE_SETUP
1793 # endif
1794 # endif
1795
1796 # if defined(CROSS_MINGW32)
1797 # undef IS_WINDOWS
1798 # define IS_WINDOWS 1
1799 # if !defined(NEED_CONSOLE_SETUP)
1800 # define NEED_CONSOLE_SETUP
1801 # endif
1802 # endif
1803
1804 # if defined(__MINGW64__)
1805 # undef IS_WINDOWS
1806 # define IS_WINDOWS 1
1807 # if !defined(NEED_CONSOLE_SETUP)
1808 # define NEED_CONSOLE_SETUP
1809 # endif
1810 # endif
1811
1812 # if defined(CROSS_MINGW64)
1813 # undef IS_WINDOWS
1814 # define IS_WINDOWS 1
1815 # if !defined(NEED_CONSOLE_SETUP)
1816 # define NEED_CONSOLE_SETUP
1817 # endif
1818 # endif
1819
1820 # if defined(__CYGWIN__)
1821 # if defined(IS_WINDOWS)
1822 # undef IS_WINDOWS
1823 # endif
1824 # endif
1825
1826 # if defined(USE_DUMA)
1827 # if defined(DUMA_EXPLICIT_INIT)
1828 duma_init();
1829 (void)fflush(stderr);
1830 # endif
1831 # if defined(DUMA_MIN_ALIGNMENT)
1832 # if DUMA_MIN_ALIGNMENT > 0
1833 DUMA_SET_ALIGNMENT(DUMA_MIN_ALIGNMENT);
1834 # endif
1835 # endif
1836 DUMA_SET_FILL(0x2E);
1837 (void)fflush(stderr);
1838 (void)atexit(CleanDUMA);
1839 # endif
1840
1841 # if defined(USE_BACKTRACE)
1842 # if defined(BACKTRACE_SUPPORTED)
1843 # include "backtrace_main.c"
1844 # endif
1845 # endif
1846
1847 # if !defined(NO_LOCALE)
1848 (void)setlocale(LC_ALL, "");
1849 # endif
1850
1851 # if defined(NEED_CONSOLE_SETUP) && defined(_WIN32)
1852 # if !defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
1853 # define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
1854 # endif
1855 # endif
1856
1857 # if defined(NEED_CONSOLE_SETUP)
1858 HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
1859 if (handle != INVALID_HANDLE_VALUE)
1860 {
1861 DWORD mode = 0;
1862 if (GetConsoleMode(handle, &mode))
1863 {
1864 mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
1865 SetConsoleMode(handle, mode);
1866 }
1867 }
1868 puts ("\e[0m");
1869 # endif
1870
1871 # if defined(__HAIKU__)
1872 (void)disable_debugger(1);
1873 # endif
1874
1875 running_perf_test = false;
1876
1877
1878 char thread_name[SIR_MAXPID] = {0};
1879 _sir_snprintf_trunc(thread_name, SIR_MAXPID, "%s", appname);
1880 (void)_sir_setthreadname(thread_name);
1881
1882
1883
1884 # if defined(__clang_analyzer__)
1885 (void)fprintf (stderr, "Error: Attempting to execute a Clang Analyzer build!\r\n");
1886 return 1;
1887 # endif
1888
1889 if (argc == 0) {
1890 (void)fprintf (stderr, "Error: main() called directly!\r\n");
1891 return 1;
1892 }
1893
1894
1895 # if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__MINGW64__) && !defined(CROSS_MINGW32) && !defined(CROSS_MINGW64)
1896 allowCores();
1897 # endif
1898
1899 int testEndian = decContextTestEndian();
1900 if (testEndian != 0) {
1901 if (testEndian == 1) {
1902 (void)fprintf (stderr,
1903 "Error: Compiled for big-endian, but little-endian ordering detected; aborting.\r\n");
1904 return 1;
1905 }
1906 if (testEndian == -1) {
1907 (void)fprintf (stderr,
1908 "Error: Compiled for little-endian, but big-endian ordering detected; aborting.\r\n");
1909 return 1;
1910 }
1911 (void)fprintf (stderr,
1912 "Error: Unable to determine system byte order; aborting.\r\n");
1913 return 1;
1914 }
1915 # if defined(NEED_128)
1916 test_math128();
1917 # endif
1918
1919 # define UV_VERSION(major, minor, patch) ((major << 16) | (minor << 8) | (patch))
1920
1921 # if defined(LINUX_OS) && UV_VERSION_HEX >= UV_VERSION(1, 44, 0)
1922
1923
1924
1925
1926 nprocs = (unsigned int)uv_available_parallelism();
1927 # else
1928 nprocs = (unsigned int)_sir_nprocs();
1929 # endif
1930 ncores = (unsigned int)get_core_count();
1931
1932
1933 targv = (char **)calloc (1+MAX(10, argc), sizeof(*targv));
1934 if (!targv)
1935 {
1936 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1937 __func__, __FILE__, __LINE__);
1938 # if defined(USE_BACKTRACE)
1939 # if defined(SIGUSR2)
1940 (void)raise(SIGUSR2);
1941
1942 # endif
1943 # endif
1944 abort();
1945 }
1946 for (i=0; i<argc; i++)
1947 targv[i] = argv[i];
1948 argv = targv;
1949
1950
1951 set_prompt (0, "sim>");
1952 *cbuf = 0;
1953 sim_switches = 0;
1954 lookswitch = TRUE;
1955 stdnul = fopen(NULL_DEVICE,"wb");
1956
1957
1958 for (i = 1; i < argc; i++) {
1959 if (argv[i] == NULL)
1960 continue;
1961
1962 # if defined(THREADZ) || defined(LOCKLESS)
1963
1964 int perftestflag = strcmp(argv[i], "--perftest");
1965 if (perftestflag == 0) {
1966 char * testName = NULL;
1967 if (i + 1 < argc)
1968 testName = argv[i + 1];
1969 perfTest (testName);
1970 return 0;
1971 }
1972 # endif
1973
1974
1975 int onlyvers = strcmp(argv[i], "--version");
1976 if (onlyvers == 0) {
1977 # if defined(VER_H_GIT_VERSION)
1978 # if defined(VER_H_GIT_PATCH) && defined(VER_H_GIT_PATCH_INT)
1979 # if VER_H_GIT_PATCH_INT < 1
1980 (void)fprintf (stdout, "%s simulator %s\r\n",
1981 sim_name, VER_H_GIT_VERSION);
1982 # else
1983 (void)fprintf (stdout, "%s simulator %s+%s\r\n",
1984 sim_name, VER_H_GIT_VERSION, VER_H_GIT_PATCH);
1985 # endif
1986 # else
1987 (void)fprintf (stdout, "%s simulator %s\r\n",
1988 sim_name, VER_H_GIT_VERSION);
1989 # endif
1990 # else
1991 (void)fprintf (stdout, "%s simulator\r\n", sim_name);
1992 # endif
1993 FREE (targv);
1994 return 0;
1995 }
1996
1997
1998 int longhelp = strcmp(argv[i], "--help");
1999 int shorthelp = strcmp(argv[i], "-h");
2000 if (shorthelp != 0) shorthelp = strcmp(argv[i], "-H");
2001 if (longhelp == 0 || shorthelp == 0) {
2002 # if defined(VER_H_GIT_VERSION)
2003 # if defined(VER_H_GIT_PATCH) && defined(VER_H_GIT_PATCH_INT)
2004 # if VER_H_GIT_PATCH_INT < 1
2005 (void)fprintf (stdout, "%s simulator %s", sim_name, VER_H_GIT_VERSION);
2006 # else
2007 (void)fprintf (stdout, "%s simulator %s+%s", sim_name, VER_H_GIT_VERSION, VER_H_GIT_PATCH);
2008 # endif
2009 # else
2010 (void)fprintf (stdout, "%s simulator %s", sim_name, VER_H_GIT_VERSION);
2011 # endif
2012 # else
2013 (void)fprintf (stdout, "%s simulator", sim_name);
2014 # endif
2015 (void)fprintf (stdout, "\r\n");
2016 (void)fprintf (stdout, "\r\n USAGE: %s [ [ SWITCH ] ... ] [ SCRIPT ]", argv[0]);
2017 (void)fprintf (stdout, "\r\n");
2018 (void)fprintf (stdout, "\r\n Invokes the %s simulator, with optional switches and/or script file.", sim_name);
2019 (void)fprintf (stdout, "\r\n");
2020 (void)fprintf (stdout, "\r\n Switches:");
2021 (void)fprintf (stdout, "\r\n -e, -E Aborts script processing immediately upon any error");
2022 (void)fprintf (stdout, "\r\n -h, -H, --help Prints only this informational help text and exits");
2023 (void)fprintf (stdout, "\r\n -k, -K Disables all support for exclusive file locking");
2024 (void)fprintf (stdout, "\r\n -l, -L Reports but ignores all exclusive file locking errors");
2025 (void)fprintf (stdout, "\r\n -o, -O Makes scripting ON conditions and actions inheritable");
2026 # if !defined(__MINGW32__) && !defined(__MINGW64__) && !defined(CROSS_MINGW32) && !defined(CROSS_MINGW64) && !defined(__CYGWIN__)
2027 (void)fprintf (stdout, "\r\n -p, -P Enables real-time scheduling (may require privileges)");
2028 # endif
2029 (void)fprintf (stdout, "\r\n -q, -Q Disables printing of non-fatal informational messages");
2030 (void)fprintf (stdout, "\r\n -r, -R Enables an unlinked ephemeral system state file");
2031 (void)fprintf (stdout, "\r\n -s, -S Enables a randomized persistent system state file");
2032 (void)fprintf (stdout, "\r\n -t, -T Disables fsync and creation/usage of system state file");
2033 (void)fprintf (stdout, "\r\n -v, -V Prints commands read from script file before execution");
2034 (void)fprintf (stdout, "\r\n --version Prints only the simulator identification text and exits");
2035 (void)fprintf (stdout, "\r\n");
2036 # if defined(USE_DUMA)
2037 nodist++;
2038 # endif
2039 if (!nodist) {
2040 (void)fprintf (stdout, "\r\n This software is made available under the terms of the ICU License.");
2041 (void)fprintf (stdout, "\r\n For complete license details, see the LICENSE file included with the");
2042 (void)fprintf (stdout, "\r\n software or https://gitlab.com/dps8m/dps8m/-/blob/master/LICENSE.md\r\n");
2043 }
2044 else
2045 {
2046 (void)fprintf (stdout, "\r\n********** LICENSE RESTRICTED BUILD ****** NOT FOR REDISTRIBUTION **********");
2047 }
2048 (void)fprintf (stdout, "\r\n");
2049 FREE(argv);
2050 return 0;
2051 }
2052
2053 if ((*argv[i] == '-') && lookswitch) {
2054 if ((sw = get_switches (argv[i])) < 0) {
2055 (void)fprintf (stderr, "Invalid switch \"%s\".\r\nTry \"%s -h\" for help.\r\n", argv[i], argv[0]);
2056 FREE(argv);
2057 return 1;
2058 }
2059 sim_switches = sim_switches | sw;
2060 }
2061
2062 else {
2063 if ((strlen (argv[i]) + strlen (cbuf) + 3) >= sizeof(cbuf)) {
2064 (void)fprintf (stderr, "Argument string too long\r\n");
2065 FREE(argv);
2066 return 1;
2067 }
2068 if (*cbuf)
2069 strcat (cbuf, " ");
2070 (void)sprintf(&cbuf[strlen(cbuf)], "%s%s%s",
2071 strchr(argv[i], ' ') ? "\"" : "", argv[i], strchr(argv[i], ' ') ? "\"" : "");
2072 lookswitch = FALSE;
2073 }
2074 }
2075 sim_nolock = sim_switches & SWMASK ('K');
2076 sim_iglock = sim_switches & SWMASK ('L');
2077 sim_randompst = sim_switches & SWMASK ('S');
2078 sim_quiet = sim_switches & SWMASK ('Q');
2079 sim_randstate = sim_switches & SWMASK ('R');
2080 if (sim_randompst) sim_randstate = 1;
2081 sim_nostate = sim_switches & SWMASK ('T');
2082 if (sim_nostate)
2083 {
2084 sim_randompst = 0;
2085 sim_randstate = 0;
2086 }
2087 sim_on_inherit = sim_switches & SWMASK ('O');
2088
2089 # if !defined(__MVS__) && !defined(__MINGW32__) && !defined(__MINGW64__) && \
2090 !defined(CROSS_MINGW32) && !defined(CROSS_MINGW64) && !defined(__CYGWIN__)
2091 sim_realtime = sim_switches & SWMASK ('P');
2092 # endif
2093
2094 sim_init_sock ();
2095 if (sim_dflt_dev == NULL)
2096 sim_dflt_dev = sim_devices[0];
2097 if (sim_vm_init != NULL)
2098 (*sim_vm_init)();
2099 sim_finit ();
2100 for (i = 0; cmd_table[i].name; i++) {
2101 size_t alias_len = strlen (cmd_table[i].name);
2102 char *cmd_name = (char *)calloc (1 + alias_len, sizeof (*cmd_name));
2103 if (!cmd_name)
2104 {
2105 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
2106 __func__, __FILE__, __LINE__);
2107 # if defined(USE_BACKTRACE)
2108 # if defined(SIGUSR2)
2109 (void)raise(SIGUSR2);
2110
2111 # endif
2112 # endif
2113 abort();
2114 }
2115
2116 strcpy (cmd_name, cmd_table[i].name);
2117 while (alias_len > 1) {
2118 cmd_name[alias_len] = '\0';
2119 --alias_len;
2120 if (getenv (cmd_name))
2121 unsetenv (cmd_name);
2122 }
2123 FREE (cmd_name);
2124 }
2125 stop_cpu = 0;
2126 sim_interval = 0;
2127 sim_time = sim_rtime = 0;
2128 noqueue_time = 0;
2129 sim_clock_queue = QUEUE_LIST_END;
2130 sim_is_running = 0;
2131 sim_log = NULL;
2132 if (sim_emax <= 0)
2133 sim_emax = 1;
2134
2135
2136 main_thread_id = pthread_self();
2137
2138
2139 save_thread_sched(pthread_self());
2140
2141
2142 if (sim_realtime) {
2143 if (nprocs < 2) {
2144 sir_emerg("FATAL: Real-time requires >1 CPU but only %u detected!", nprocs);
2145 exit(EXIT_FAILURE);
2146 } else {
2147 watchdog_startup();
2148 }
2149 }
2150
2151
2152 if (realtime_ok) {
2153 set_realtime_priority (pthread_self(), realtime_max_priority() - 1);
2154 check_realtime_priority (pthread_self(), realtime_max_priority() - 1);
2155 } else {
2156 # if !defined(__QNX__)
2157 (void)sim_os_set_thread_priority (PRIORITY_ABOVE_NORMAL);
2158 # endif
2159 }
2160
2161 sim_timer_init ();
2162
2163 if ((stat = sim_ttinit ()) != SCPE_OK) {
2164 (void)fprintf (stderr, "Fatal terminal initialization error\r\n%s\r\n",
2165 sim_error_text (stat));
2166 FREE(argv);
2167 return 1;
2168 }
2169 if ((sim_eval = (t_value *) calloc (sim_emax, sizeof (t_value))) == NULL) {
2170 (void)fprintf (stderr, "Unable to allocate examine buffer\r\n");
2171 FREE(argv);
2172 return 1;
2173 };
2174 if ((stat = reset_all_p (0)) != SCPE_OK) {
2175 (void)fprintf (stderr, "Fatal simulator initialization error\r\n%s\r\n",
2176 sim_error_text (stat));
2177 FREE(argv);
2178 return 1;
2179 }
2180 if ((stat = sim_brk_init ()) != SCPE_OK) {
2181 (void)fprintf (stderr, "Fatal breakpoint table initialization error\r\n%s\r\n",
2182 sim_error_text (stat));
2183 FREE(argv);
2184 return 1;
2185 }
2186 if (!sim_quiet) {
2187 (void)printf ("\r\n");
2188 show_version (stdout, NULL, NULL, 0, NULL);
2189 }
2190
2191 cptr = getenv("HOME");
2192 if (cptr == NULL) {
2193 cptr = getenv("HOMEPATH");
2194 cptr2 = getenv("HOMEDRIVE");
2195 }
2196 else
2197 cptr2 = NULL;
2198 (void)cptr2;
2199 if ( (*cbuf) && (strcmp(cbuf, "")) )
2200 stat = do_cmd (0, cbuf);
2201 else if (*argv[0]) {
2202 char *np;
2203 nbuf[0] = '"';
2204 stat = do_cmd (-1, nbuf) & ~SCPE_NOMESSAGE;
2205 if (stat == SCPE_OPENERR) {
2206 np = strrchr (nbuf, '/');
2207 if (np == NULL)
2208 np = strrchr (nbuf, '\\');
2209 if (np != NULL) {
2210 *np = '"';
2211 stat = do_cmd (-1, np) & ~SCPE_NOMESSAGE;
2212 }
2213 }
2214 }
2215
2216 argv = uv_setup_args(argc, argv);
2217
2218
2219 if (getenv("DPS8M_NO_HINTS") == NULL)
2220 if (!sim_quiet && 0 == strcmp(cbuf, ""))
2221 (void)show_hints(0, 0, 0, 1, 0);
2222
2223 stat = process_stdin_commands (SCPE_BARE_STATUS(stat), argv);
2224
2225 if (sim_vm_exit != NULL)
2226 (*sim_vm_exit)();
2227
2228 detach_all (0, TRUE);
2229 sim_set_deboff (0, NULL);
2230 sim_set_logoff (0, NULL);
2231 sim_set_notelnet (0, NULL);
2232 sim_ttclose ();
2233 sim_cleanup_sock ();
2234 fclose (stdnul);
2235 FREE (targv);
2236 FREE (sim_prompt);
2237 FREE (sim_eval);
2238 FREE (sim_internal_devices);
2239 FREE (sim_brk_tab);
2240 FREE (sim_staba.comp);
2241 FREE (sim_staba.mask);
2242 FREE (sim_stabr.comp);
2243 FREE (sim_stabr.mask);
2244 return sir_cleanup() ? EXIT_SUCCESS : dps8_sir_report_error();
2245 }
2246 #endif
2247
2248 t_stat process_stdin_commands (t_stat stat, char *argv[])
2249 {
2250 char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE];
2251 CONST char *cptr;
2252 t_stat stat_nomessage;
2253 CTAB *cmdp = NULL;
2254
2255 stat = SCPE_BARE_STATUS(stat);
2256 while (stat != SCPE_EXIT) {
2257 if ((cptr = sim_brk_getact (cbuf, sizeof(cbuf))))
2258 (void)printf ("%s%s\r\n", sim_prompt, cptr);
2259 else if (sim_vm_read != NULL) {
2260 (void)printf ("%s", sim_prompt);
2261 cptr = (*sim_vm_read) (cbuf, sizeof(cbuf), stdin);
2262 }
2263 else cptr = read_line_p (sim_prompt, cbuf, sizeof(cbuf), stdin);
2264 if (cptr == NULL) {
2265 if (sim_ttisatty()) continue;
2266 else break;
2267 }
2268 if (*cptr == 0)
2269 continue;
2270 sim_sub_args (cbuf, sizeof(cbuf), argv);
2271 if (sim_log)
2272 (void)fprintf (sim_log, "%s%s\r\n", sim_prompt, cptr);
2273 if (sim_deb && (sim_deb != sim_log) && (sim_deb != stdout))
2274 (void)fprintf (sim_deb, "%s%s\r\n", sim_prompt, cptr);
2275 cptr = get_glyph_cmd (cptr, gbuf);
2276 sim_switches = 0;
2277 if ((cmdp = find_cmd (gbuf)))
2278 stat = cmdp->action (cmdp->arg, cptr);
2279 else
2280 stat = SCPE_UNK;
2281 stat_nomessage = stat & SCPE_NOMESSAGE;
2282 stat_nomessage = stat_nomessage || (!sim_show_message);
2283 stat = SCPE_BARE_STATUS(stat);
2284 sim_last_cmd_stat = stat;
2285 if (!stat_nomessage) {
2286 if (cmdp && (cmdp->message))
2287 cmdp->message (NULL, stat);
2288 else
2289 if (stat >= SCPE_BASE)
2290 sim_printf ("%s\r\n", sim_error_text (stat));
2291 }
2292 if (sim_vm_post != NULL)
2293 (*sim_vm_post) (TRUE);
2294 }
2295 return stat;
2296 }
2297
2298
2299
2300 t_stat set_prompt (int32 flag, CONST char *cptr)
2301 {
2302 char gbuf[CBUFSIZE], *gptr;
2303
2304 if ((NULL == cptr) || (*cptr == '\0'))
2305 return SCPE_ARG;
2306
2307 cptr = get_glyph_nc (cptr, gbuf, '"');
2308 if (gbuf[0] == '\0') {
2309 gbuf[sizeof (gbuf)-1] = '\0';
2310 strncpy (gbuf, cptr, sizeof (gbuf)-1);
2311 gptr = strchr (gbuf, '"');
2312 if (NULL != gptr)
2313 *gptr = '\0';
2314 }
2315 sim_prompt = (char *)realloc (sim_prompt, strlen (gbuf) + 2);
2316 if (!sim_prompt)
2317 {
2318 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
2319 __func__, __FILE__, __LINE__);
2320 #if defined(USE_BACKTRACE)
2321 # if defined(SIGUSR2)
2322 (void)raise(SIGUSR2);
2323
2324 # endif
2325 #endif
2326 abort();
2327 }
2328 (void)sprintf (sim_prompt, "%s ", gbuf);
2329 return SCPE_OK;
2330 }
2331
2332
2333
2334 CTAB *find_cmd (const char *gbuf)
2335 {
2336 CTAB *cmdp = NULL;
2337
2338 if (sim_vm_cmd)
2339 cmdp = find_ctab (sim_vm_cmd, gbuf);
2340 if (cmdp == NULL)
2341 cmdp = find_ctab (cmd_table, gbuf);
2342 return cmdp;
2343 }
2344
2345
2346
2347 t_stat exit_cmd (int32 flag, CONST char *cptr)
2348 {
2349 return SCPE_EXIT;
2350 }
2351
2352
2353
2354
2355 static int _cmd_name_compare (const void *pa, const void *pb)
2356 {
2357 CTAB * const *a = (CTAB * const *)pa;
2358 CTAB * const *b = (CTAB * const *)pb;
2359
2360 return strcmp((*a)->name, (*b)->name);
2361 }
2362
2363 void fprint_help (FILE *st)
2364 {
2365 CTAB *cmdp;
2366 CTAB **hlp_cmdp = NULL;
2367 size_t cmd_cnt = 0;
2368 size_t cmd_size = 0;
2369 size_t max_cmdname_size = 0;
2370 size_t i, line_offset;
2371
2372 for (cmdp = sim_vm_cmd; cmdp && (cmdp->name != NULL); cmdp++) {
2373 if (cmdp->help) {
2374 if (cmd_cnt >= cmd_size) {
2375 cmd_size += 20;
2376 hlp_cmdp = (CTAB **)realloc (hlp_cmdp, sizeof(*hlp_cmdp)*cmd_size);
2377 if (!hlp_cmdp)
2378 {
2379 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
2380 __func__, __FILE__, __LINE__);
2381 #if defined(USE_BACKTRACE)
2382 # if defined(SIGUSR2)
2383 (void)raise(SIGUSR2);
2384
2385 # endif
2386 #endif
2387 abort();
2388 }
2389 }
2390 hlp_cmdp[cmd_cnt] = cmdp;
2391 ++cmd_cnt;
2392 if (strlen(cmdp->name) > max_cmdname_size)
2393 max_cmdname_size = strlen(cmdp->name);
2394 }
2395 }
2396 for (cmdp = cmd_table; cmdp && (cmdp->name != NULL); cmdp++) {
2397 if (cmdp->help && (NULL == sim_vm_cmd || NULL == find_ctab (sim_vm_cmd, cmdp->name))) {
2398 if (cmd_cnt >= cmd_size) {
2399 cmd_size += 20;
2400 hlp_cmdp = (CTAB **)realloc (hlp_cmdp, sizeof(*hlp_cmdp)*cmd_size);
2401 if (!hlp_cmdp)
2402 {
2403 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
2404 __func__, __FILE__, __LINE__);
2405 #if defined(USE_BACKTRACE)
2406 # if defined(SIGUSR2)
2407 (void)raise(SIGUSR2);
2408
2409 # endif
2410 #endif
2411 abort();
2412 }
2413 }
2414 hlp_cmdp[cmd_cnt] = cmdp;
2415 ++cmd_cnt;
2416 if (strlen (cmdp->name) > max_cmdname_size)
2417 max_cmdname_size = strlen(cmdp->name);
2418 }
2419 }
2420 (void)fprintf (st, "HELP is available for the following commands:\r\n\r\n ");
2421 if (hlp_cmdp)
2422 qsort (hlp_cmdp, cmd_cnt, sizeof(*hlp_cmdp), _cmd_name_compare);
2423 line_offset = 4;
2424 for ( i = 0 ; i < cmd_cnt ; ++i ) {
2425 fputs (hlp_cmdp[i]->name, st);
2426 line_offset += 5 + max_cmdname_size;
2427 if (line_offset + max_cmdname_size > 79) {
2428 line_offset = 4;
2429 (void)fprintf (st, "\r\n ");
2430 }
2431 else
2432 (void)fprintf (st, "%*s", (int)(max_cmdname_size + 5 - strlen (hlp_cmdp[i]->name)), "");
2433 }
2434 FREE (hlp_cmdp);
2435 (void)fprintf (st, "\r\n");
2436 return;
2437 }
2438
2439 static void fprint_header (FILE *st, t_bool *pdone, char *context)
2440 {
2441 if (!*pdone)
2442 (void)fprintf (st, "%s", context);
2443 *pdone = TRUE;
2444 }
2445
2446 void fprint_reg_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2447 {
2448 REG *rptr, *trptr;
2449 t_bool found = FALSE;
2450 t_bool all_unique = TRUE;
2451 size_t max_namelen = 0;
2452 DEVICE *tdptr;
2453 CONST char *tptr;
2454 char *namebuf;
2455 char rangebuf[32];
2456
2457 if (dptr->registers)
2458 for (rptr = dptr->registers; rptr->name != NULL; rptr++) {
2459 if (rptr->flags & REG_HIDDEN)
2460 continue;
2461 if (rptr->depth > 1)
2462 (void)sprintf (rangebuf, "[%d:%d]", 0, rptr->depth-1);
2463 else
2464 strcpy (rangebuf, "");
2465 if (max_namelen < (strlen(rptr->name) + strlen (rangebuf)))
2466 max_namelen = strlen(rptr->name) + strlen (rangebuf);
2467 found = TRUE;
2468 trptr = find_reg_glob (rptr->name, &tptr, &tdptr);
2469 if ((trptr == NULL) || (tdptr != dptr))
2470 all_unique = FALSE;
2471 }
2472 if (!found) {
2473 if (!silent)
2474 (void)fprintf (st, "No register HELP available for the %s device\r\n",
2475 dptr->name);
2476 }
2477 else {
2478 namebuf = (char *)calloc (max_namelen + 1, sizeof (*namebuf));
2479 if (!namebuf)
2480 {
2481 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
2482 __func__, __FILE__, __LINE__);
2483 #if defined(USE_BACKTRACE)
2484 # if defined(SIGUSR2)
2485 (void)raise(SIGUSR2);
2486
2487 # endif
2488 #endif
2489 abort();
2490 }
2491 (void)fprintf (st, "\r\nThe %s device implements these registers:\r\n\r\n",
2492 dptr->name);
2493 for (rptr = dptr->registers; rptr->name != NULL; rptr++) {
2494 if (rptr->flags & REG_HIDDEN)
2495 continue;
2496 if (rptr->depth <= 1)
2497 (void)sprintf (namebuf, "%*s",
2498 -((int)max_namelen),
2499 rptr->name);
2500 else {
2501 (void)sprintf (rangebuf, "[%d:%d]",
2502 0,
2503 rptr->depth-1);
2504 (void)sprintf (namebuf, "%s%*s",
2505 rptr->name,
2506 (int)(strlen(rptr->name))-((int)max_namelen),
2507 rangebuf);
2508 }
2509 if (all_unique) {
2510 (void)fprintf (st, " %s %4d %s\r\n",
2511 namebuf,
2512 rptr->width,
2513 rptr->desc ? rptr->desc : "");
2514 continue;
2515 }
2516 trptr = find_reg_glob (rptr->name, &tptr, &tdptr);
2517 if ((trptr == NULL) || (tdptr != dptr))
2518 (void)fprintf (st, " %s %s %4d %s\r\n",
2519 dptr->name,
2520 namebuf,
2521 rptr->width,
2522 rptr->desc ? rptr->desc : "");
2523 else
2524 (void)fprintf (st, " %*s %s %4d %s\r\n",
2525 (int)strlen(dptr->name), "",
2526 namebuf,
2527 rptr->width,
2528 rptr->desc ? rptr->desc : "");
2529 }
2530 FREE (namebuf);
2531 }
2532 }
2533
2534 void fprint_reg_help (FILE *st, DEVICE *dptr)
2535 {
2536 fprint_reg_help_ex (st, dptr, TRUE);
2537 }
2538
2539 void fprint_attach_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2540 {
2541 if (dptr->attach_help) {
2542 (void)fprintf (st, "\r\n%s device ATTACH commands:\r\n\r\n", dptr->name);
2543 dptr->attach_help (st, dptr, NULL, 0, NULL);
2544 return;
2545 }
2546 if (DEV_TYPE(dptr) == DEV_DISK) {
2547 (void)fprintf (st, "\r\n%s device ATTACH commands:\r\n\r\n", dptr->name);
2548 sim_disk_attach_help (st, dptr, NULL, 0, NULL);
2549 return;
2550 }
2551 if (DEV_TYPE(dptr) == DEV_TAPE) {
2552 (void)fprintf (st, "\r\n%s device ATTACH commands:\r\n\r\n", dptr->name);
2553 sim_tape_attach_help (st, dptr, NULL, 0, NULL);
2554 return;
2555 }
2556 if (!silent) {
2557 (void)fprintf (st, "No ATTACH help is available for the %s device\r\n", dptr->name);
2558 if (dptr->help)
2559 dptr->help (st, dptr, NULL, 0, NULL);
2560 }
2561 }
2562
2563 void fprint_set_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2564 {
2565 MTAB *mptr;
2566 DEBTAB *dep;
2567 t_bool found = FALSE;
2568 char buf[CBUFSIZE], header[CBUFSIZE];
2569 uint32 enabled_units = dptr->numunits;
2570 uint32 unit;
2571
2572 (void)sprintf (header, "\r\n%s device SET commands:\r\n\r\n", dptr->name);
2573 for (unit=0; unit < dptr->numunits; unit++)
2574 if (dptr->units[unit].flags & UNIT_DIS)
2575 --enabled_units;
2576 if (dptr->modifiers) {
2577 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
2578 if (!MODMASK(mptr,MTAB_VDV) && MODMASK(mptr,MTAB_VUN) && (dptr->numunits != 1))
2579 continue;
2580 if ((enabled_units != 1) && !(mptr->mask & MTAB_XTD))
2581 continue;
2582 if (mptr->mstring) {
2583 fprint_header (st, &found, header);
2584 (void)sprintf (buf, "SET %s %s%s", sim_dname (dptr),
2585 mptr->mstring,
2586 (strchr(mptr->mstring, '=')) \
2587 ? "" : (MODMASK(mptr,MTAB_VALR) \
2588 ? "=val" : (MODMASK(mptr,MTAB_VALO) \
2589 ? "{=val}" : "")));
2590 if ((strlen (buf) < 30) || (NULL == mptr->help))
2591 (void)fprintf (st, "%-30s\t%s\r\n", buf, mptr->help ? mptr->help : "");
2592 else
2593 (void)fprintf (st, "%s\r\n%-30s\t%s\r\n", buf, "", mptr->help);
2594 }
2595 }
2596 }
2597 if (dptr->flags & DEV_DISABLE) {
2598 fprint_header (st, &found, header);
2599 (void)sprintf (buf, "SET %s ENABLE", sim_dname (dptr));
2600 (void)fprintf (st, "%-30s\tEnables device %s\r\n", buf, sim_dname (dptr));
2601 (void)sprintf (buf, "SET %s DISABLE", sim_dname (dptr));
2602 (void)fprintf (st, "%-30s\tDisables device %s\r\n", buf, sim_dname (dptr));
2603 }
2604 if (dptr->flags & DEV_DEBUG) {
2605 fprint_header (st, &found, header);
2606 (void)sprintf (buf, "SET %s DEBUG", sim_dname (dptr));
2607 (void)fprintf (st, "%-30s\tEnables debugging for device %s\r\n", buf, sim_dname (dptr));
2608 (void)sprintf (buf, "SET %s NODEBUG", sim_dname (dptr));
2609 (void)fprintf (st, "%-30s\tDisables debugging for device %s\r\n", buf, sim_dname (dptr));
2610 if (dptr->debflags) {
2611 t_bool desc_available = FALSE;
2612 strcpy (buf, "");
2613 (void)fprintf (st, "SET %s DEBUG=", sim_dname (dptr));
2614 for (dep = dptr->debflags; dep->name != NULL; dep++) {
2615 (void)fprintf (st, "%s%s", ((dep == dptr->debflags) ? "" : ";"), dep->name);
2616 desc_available |= ((dep->desc != NULL) && (dep->desc[0] != '\0'));
2617 }
2618 (void)fprintf (st, "\r\n");
2619 (void)fprintf (st, "%-30s\tEnables specific debugging for device %s\r\n", buf, sim_dname (dptr));
2620 (void)fprintf (st, "SET %s NODEBUG=", sim_dname (dptr));
2621 for (dep = dptr->debflags; dep->name != NULL; dep++)
2622 (void)fprintf (st, "%s%s", ((dep == dptr->debflags) ? "" : ";"), dep->name);
2623 (void)fprintf (st, "\r\n");
2624 (void)fprintf (st, "%-30s\tDisables specific debugging for device %s\r\n", buf, sim_dname (dptr));
2625 if (desc_available) {
2626 (void)fprintf (st, "\r\n*%s device DEBUG settings:\r\n", sim_dname (dptr));
2627 for (dep = dptr->debflags; dep->name != NULL; dep++)
2628 (void)fprintf (st, "%4s%-12s%s\r\n", "", dep->name, dep->desc ? dep->desc : "");
2629 }
2630 }
2631 }
2632 if ((dptr->modifiers) && (dptr->units) && (enabled_units != 1)) {
2633 if (dptr->units->flags & UNIT_DISABLE) {
2634 fprint_header (st, &found, header);
2635 (void)sprintf (buf, "SET %sn ENABLE", sim_dname (dptr));
2636 (void)fprintf (st, "%-30s\tEnables unit %sn\r\n", buf, sim_dname (dptr));
2637 (void)sprintf (buf, "SET %sn DISABLE", sim_dname (dptr));
2638 (void)fprintf (st, "%-30s\tDisables unit %sn\r\n", buf, sim_dname (dptr));
2639 }
2640 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
2641 if ((!MODMASK(mptr,MTAB_VUN)) && MODMASK(mptr,MTAB_XTD))
2642 continue;
2643 if ((NULL == mptr->valid) && MODMASK(mptr,MTAB_XTD))
2644 continue;
2645 if (mptr->mstring) {
2646 fprint_header (st, &found, header);
2647 (void)sprintf (buf, "SET %s%s %s%s", sim_dname (dptr),
2648 (dptr->numunits > 1) ? "n" : "0", mptr->mstring,
2649 (strchr(mptr->mstring, '=')) \
2650 ? "" : (MODMASK(mptr,MTAB_VALR) \
2651 ? "=val" : (MODMASK(mptr,MTAB_VALO) \
2652 ? "{=val}" : "")));
2653 (void)fprintf (st, "%-30s\t%s\r\n", buf,
2654 (strchr(mptr->mstring, '=')) \
2655 ? "" : (mptr->help ? mptr->help : ""));
2656 }
2657 }
2658 }
2659 if (!found && !silent)
2660 (void)fprintf (st, "No SET help is available for the %s device\r\n", dptr->name);
2661 }
2662
2663 void fprint_set_help (FILE *st, DEVICE *dptr)
2664 {
2665 fprint_set_help_ex (st, dptr, TRUE);
2666 }
2667
2668 void fprint_show_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2669 {
2670 MTAB *mptr;
2671 t_bool found = FALSE;
2672 char buf[CBUFSIZE], header[CBUFSIZE];
2673 uint32 enabled_units = dptr->numunits;
2674 uint32 unit;
2675
2676 (void)sprintf (header, "\r\n%s device SHOW commands:\r\n\r\n", dptr->name);
2677 for (unit=0; unit < dptr->numunits; unit++)
2678 if (dptr->units[unit].flags & UNIT_DIS)
2679 --enabled_units;
2680 if (dptr->modifiers) {
2681 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
2682 if (!MODMASK(mptr,MTAB_VDV) && MODMASK(mptr,MTAB_VUN) && (dptr->numunits != 1))
2683 continue;
2684 if ((enabled_units != 1) && !(mptr->mask & MTAB_XTD))
2685 continue;
2686 if ((!mptr->disp) || (!mptr->pstring) || !(*mptr->pstring))
2687 continue;
2688 fprint_header (st, &found, header);
2689 (void)sprintf (buf, "SHOW %s %s%s", sim_dname (dptr),
2690 mptr->pstring, MODMASK(mptr,MTAB_SHP) ? "{=arg}" : "");
2691 (void)fprintf (st, "%-30s\t%s\r\n", buf, mptr->help ? mptr->help : "");
2692 }
2693 }
2694 if (dptr->flags & DEV_DEBUG) {
2695 fprint_header (st, &found, header);
2696 (void)sprintf (buf, "SHOW %s DEBUG", sim_dname (dptr));
2697 (void)fprintf (st, "%-30s\tDisplays debugging status for device %s\r\n", buf, sim_dname (dptr));
2698 }
2699 if ((dptr->modifiers) && (dptr->units) && (enabled_units != 1)) {
2700 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
2701 if ((!MODMASK(mptr,MTAB_VUN)) && MODMASK(mptr,MTAB_XTD))
2702 continue;
2703 if ((!mptr->disp) || (!mptr->pstring))
2704 continue;
2705 fprint_header (st, &found, header);
2706 (void)sprintf (buf, "SHOW %s%s %s%s", sim_dname (dptr),
2707 (dptr->numunits > 1) ? "n" : "0", mptr->pstring,
2708 MODMASK(mptr,MTAB_SHP) ? "=arg" : "");
2709 (void)fprintf (st, "%-30s\t%s\r\n", buf, mptr->help ? mptr->help : "");
2710 }
2711 }
2712 if (!found && !silent)
2713 (void)fprintf (st, "No SHOW help is available for the %s device\r\n", dptr->name);
2714 }
2715
2716 void fprint_show_help (FILE *st, DEVICE *dptr)
2717 {
2718 fprint_show_help_ex (st, dptr, TRUE);
2719 }
2720
2721 void fprint_brk_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2722 {
2723 BRKTYPTAB *brkt = dptr->brk_types;
2724 char gbuf[CBUFSIZE];
2725
2726 if (sim_brk_types == 0) {
2727 if ((dptr != sim_dflt_dev) && (!silent)) {
2728 (void)fprintf (st, "Breakpoints are not supported in the %s simulator\r\n", sim_name);
2729 if (dptr->help)
2730 dptr->help (st, dptr, NULL, 0, NULL);
2731 }
2732 return;
2733 }
2734 if (brkt == NULL) {
2735 int i;
2736
2737 if (dptr == sim_dflt_dev) {
2738 if (sim_brk_types & ~sim_brk_dflt) {
2739 (void)fprintf (st, "%s supports the following breakpoint types:\r\n", sim_dname (dptr));
2740 for (i=0; i<26; i++) {
2741 if (sim_brk_types & (1<<i))
2742 (void)fprintf (st, " -%c\r\n", 'A'+i);
2743 }
2744 }
2745 (void)fprintf (st, "The default breakpoint type is: %s\r\n", put_switches (gbuf, sizeof(gbuf), sim_brk_dflt));
2746 }
2747 return;
2748 }
2749 (void)fprintf (st, "%s supports the following breakpoint types:\r\n", sim_dname (dptr));
2750 while (brkt->btyp) {
2751 (void)fprintf (st, " %s %s\r\n", put_switches (gbuf, sizeof(gbuf), brkt->btyp), brkt->desc);
2752 ++brkt;
2753 }
2754 (void)fprintf (st, "The default breakpoint type is: %s\r\n", put_switches (gbuf, sizeof(gbuf), sim_brk_dflt));
2755 }
2756
2757 t_stat help_dev_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr)
2758 {
2759 char gbuf[CBUFSIZE];
2760 CTAB *cmdp;
2761
2762 if (*cptr) {
2763 (void)get_glyph (cptr, gbuf, 0);
2764 if ((cmdp = find_cmd (gbuf))) {
2765 if (cmdp->action == &exdep_cmd) {
2766 if (dptr->help)
2767 return dptr->help (st, dptr, uptr, flag, cptr);
2768 else
2769 (void)fprintf (st, "No HELP available for the %s %s command\r\n", cmdp->name, sim_dname(dptr));
2770 return SCPE_OK;
2771 }
2772 if (cmdp->action == &set_cmd) {
2773 fprint_set_help_ex (st, dptr, FALSE);
2774 return SCPE_OK;
2775 }
2776 if (cmdp->action == &show_cmd) {
2777 fprint_show_help_ex (st, dptr, FALSE);
2778 return SCPE_OK;
2779 }
2780 if (cmdp->action == &attach_cmd) {
2781 fprint_attach_help_ex (st, dptr, FALSE);
2782 return SCPE_OK;
2783 }
2784 if (cmdp->action == &brk_cmd) {
2785 fprint_brk_help_ex (st, dptr, FALSE);
2786 return SCPE_OK;
2787 }
2788 if (dptr->help)
2789 return dptr->help (st, dptr, uptr, flag, cptr);
2790 (void)fprintf (st, "No %s HELP is available for the %s device\r\n", cmdp->name, dptr->name);
2791 return SCPE_OK;
2792 }
2793 if (MATCH_CMD (gbuf, "REGISTERS") == 0) {
2794 fprint_reg_help_ex (st, dptr, FALSE);
2795 return SCPE_OK;
2796 }
2797 if (dptr->help)
2798 return dptr->help (st, dptr, uptr, flag, cptr);
2799 (void)fprintf (st, "No %s HELP is available for the %s device\r\n", gbuf, dptr->name);
2800 return SCPE_OK;
2801 }
2802 if (dptr->help) {
2803 return dptr->help (st, dptr, uptr, flag, cptr);
2804 }
2805 if (dptr->description)
2806 (void)fprintf (st, "%s %s HELP\r\n", dptr->description (dptr), dptr->name);
2807 else
2808 (void)fprintf (st, "%s HELP\r\n", dptr->name);
2809 fprint_set_help_ex (st, dptr, TRUE);
2810 fprint_show_help_ex (st, dptr, TRUE);
2811 fprint_attach_help_ex (st, dptr, TRUE);
2812 fprint_reg_help_ex (st, dptr, TRUE);
2813 fprint_brk_help_ex (st, dptr, TRUE);
2814 return SCPE_OK;
2815 }
2816
2817 t_stat help_cmd_output (int32 flag, const char *help, const char *help_base)
2818 {
2819 switch (help[0]) {
2820 case '*':
2821 scp_help (stdout, NULL, NULL, flag, help_base ? help_base : simh_help, help+1);
2822 if (sim_log)
2823 scp_help (sim_log, NULL, NULL, flag | SCP_HELP_FLAT, help_base ? help_base : simh_help, help+1);
2824 break;
2825 default:
2826 fputs (help, stdout);
2827 if (sim_log)
2828 fputs (help, sim_log);
2829 break;
2830 }
2831 return SCPE_OK;
2832 }
2833
2834 t_stat help_cmd (int32 flag, CONST char *cptr)
2835 {
2836 char gbuf[CBUFSIZE];
2837 CTAB *cmdp;
2838
2839 GET_SWITCHES (cptr);
2840 if (sim_switches & SWMASK ('F'))
2841 flag = flag | SCP_HELP_FLAT;
2842 if (*cptr) {
2843 cptr = get_glyph (cptr, gbuf, 0);
2844 if ((cmdp = find_cmd (gbuf))) {
2845 if (*cptr) {
2846 if ((cmdp->action == &set_cmd) || (cmdp->action == &show_cmd)) {
2847 DEVICE *dptr;
2848 UNIT *uptr;
2849 t_stat r;
2850 cptr = get_glyph (cptr, gbuf, 0);
2851 dptr = find_unit (gbuf, &uptr);
2852 if (dptr == NULL)
2853 dptr = find_dev (gbuf);
2854 if (dptr != NULL) {
2855 r = help_dev_help (stdout, dptr, uptr, flag, (cmdp->action == &set_cmd) ? "SET" : "SHOW");
2856 if (sim_log)
2857 help_dev_help (sim_log, dptr, uptr, flag | SCP_HELP_FLAT, (cmdp->action == &set_cmd) ? "SET" : "SHOW");
2858 return r;
2859 }
2860 if (cmdp->action == &set_cmd) {
2861
2862 if ((cmdp = find_ctab (set_glob_tab, gbuf)) &&
2863 (cmdp->help))
2864 return help_cmd_output (flag, cmdp->help, cmdp->help_base);
2865 }
2866 else {
2867 SHTAB *shptr = find_shtab (show_glob_tab, gbuf);
2868 if ((shptr == NULL) || (shptr->help == NULL) || (*shptr->help == '\0'))
2869 return SCPE_ARG;
2870 return help_cmd_output (flag, shptr->help, NULL);
2871 }
2872 return SCPE_ARG;
2873 }
2874 else
2875 return SCPE_2MARG;
2876 }
2877 if (cmdp->help) {
2878 if (strcmp (cmdp->name, "HELP") == 0) {
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913 }
2914 else {
2915 if (((cmdp->action == &exdep_cmd) || (0 == strcmp(cmdp->name, "BOOT"))) &&
2916 sim_dflt_dev && sim_dflt_dev->help) {
2917 sim_dflt_dev->help (stdout, sim_dflt_dev, sim_dflt_dev->units, 0, cmdp->name);
2918 if (sim_log)
2919 sim_dflt_dev->help (sim_log, sim_dflt_dev, sim_dflt_dev->units, 0, cmdp->name);
2920 }
2921 }
2922 help_cmd_output (flag, cmdp->help, cmdp->help_base);
2923 }
2924 else {
2925 CTAB *cmdpa;
2926 for (cmdpa=cmd_table; cmdpa->name != NULL; cmdpa++)
2927 if ((cmdpa->action == cmdp->action) && (cmdpa->help)) {
2928 sim_printf ("%s is an alias for the %s command:\r\n%s",
2929 cmdp->name, cmdpa->name, cmdpa->help);
2930 break;
2931 }
2932 if (cmdpa->name == NULL)
2933 sim_printf ("No help available for the %s command\r\n", cmdp->name);
2934 }
2935 }
2936 else {
2937 DEVICE *dptr;
2938 UNIT *uptr;
2939 t_stat r;
2940 dptr = find_unit (gbuf, &uptr);
2941 if (dptr == NULL) {
2942 dptr = find_dev (gbuf);
2943 if (dptr == NULL)
2944 return SCPE_ARG;
2945 if (dptr->flags & DEV_DIS)
2946 sim_printf ("Device %s is currently disabled\r\n", dptr->name);
2947 }
2948 r = help_dev_help (stdout, dptr, uptr, flag, cptr);
2949 if (sim_log)
2950 help_dev_help (sim_log, dptr, uptr, flag | SCP_HELP_FLAT, cptr);
2951 return r;
2952 }
2953 }
2954 else {
2955 fprint_help (stdout);
2956 if (sim_log)
2957 fprint_help (sim_log);
2958 }
2959 return SCPE_OK;
2960 }
2961
2962
2963
2964 t_stat spawn_cmd (int32 flag, CONST char *cptr)
2965 {
2966 t_stat status;
2967 if ((cptr == NULL) || (strlen (cptr) == 0))
2968 cptr = getenv("SHELL");
2969 if ((cptr == NULL) || (strlen (cptr) == 0))
2970 cptr = getenv("ComSpec");
2971 (void)fflush(stdout);
2972 if (sim_log)
2973 (void)fflush (sim_log);
2974 if (sim_deb)
2975 (void)fflush (sim_deb);
2976 status = system (cptr);
2977
2978 return status;
2979 }
2980
2981
2982
2983 t_stat echo_cmd (int32 flag, CONST char *cptr)
2984 {
2985 sim_printf ("%s\r\n", cptr);
2986 return SCPE_OK;
2987 }
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009 t_stat do_cmd (int32 flag, CONST char *fcptr)
3010 {
3011 return do_cmd_label (flag, fcptr, NULL);
3012 }
3013
3014 static char *do_position(void)
3015 {
3016 static char cbuf[4*CBUFSIZE];
3017
3018 (void)snprintf (cbuf, sizeof (cbuf), "%s%s%s-%d", sim_do_filename[sim_do_depth],
3019 sim_do_label[sim_do_depth] ? "::" : "",
3020 sim_do_label[sim_do_depth] ? sim_do_label[sim_do_depth] : "",
3021 sim_goto_line[sim_do_depth]);
3022 return cbuf;
3023 }
3024
3025 t_stat do_cmd_label (int32 flag, CONST char *fcptr, CONST char *label)
3026 {
3027 char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE], abuf[4*CBUFSIZE], quote, *c, *do_arg[11];
3028 CONST char *cptr;
3029 FILE *fpin;
3030 CTAB *cmdp = NULL;
3031 int32 echo, nargs, errabort, i;
3032 int32 saved_sim_do_echo = sim_do_echo,
3033 saved_sim_show_message = sim_show_message,
3034 saved_sim_on_inherit = sim_on_inherit,
3035 saved_sim_quiet = sim_quiet;
3036 t_bool staying;
3037 t_stat stat, stat_nomessage;
3038
3039 stat = SCPE_OK;
3040 staying = TRUE;
3041 if (flag > 0)
3042 GET_SWITCHES (fcptr);
3043 echo = (sim_switches & SWMASK ('V')) || sim_do_echo;
3044 sim_quiet = (sim_switches & SWMASK ('Q')) || sim_quiet;
3045 sim_on_inherit =(sim_switches & SWMASK ('O')) || sim_on_inherit;
3046 errabort = sim_switches & SWMASK ('E');
3047
3048 abuf[sizeof(abuf)-1] = '\0';
3049 strncpy (abuf, fcptr, sizeof(abuf)-1);
3050 c = abuf;
3051 do_arg[10] = NULL;
3052 for (nargs = 0; nargs < 10; ) {
3053 while (sim_isspace (*c))
3054 c++;
3055 if (*c == 0)
3056 do_arg [nargs++] = NULL;
3057 else {
3058 if (*c == '\'' || *c == '"')
3059 quote = *c++;
3060 else quote = 0;
3061 do_arg[nargs++] = c;
3062 while (*c && (quote ? (*c != quote) : !sim_isspace (*c)))
3063 c++;
3064 if (*c)
3065 *c++ = 0;
3066 }
3067 }
3068
3069 if (do_arg [0] == NULL)
3070 return SCPE_2FARG;
3071 if ((fpin = fopen (do_arg[0], "r")) == NULL) {
3072 strcat (strcpy (cbuf, do_arg[0]), ".ini");
3073 if ((fpin = fopen (cbuf, "r")) == NULL) {
3074 if (flag == 0)
3075 (void)fprintf (stderr, "Can't open file %s\r\n", do_arg[0]);
3076 return SCPE_OPENERR;
3077 }
3078 }
3079 if (flag >= 0) {
3080 ++sim_do_depth;
3081 if (sim_on_inherit) {
3082 sim_on_check[sim_do_depth] = sim_on_check[sim_do_depth-1];
3083 for (i=0; i<SCPE_MAX_ERR; i++) {
3084 if (sim_on_actions[sim_do_depth-1][i]) {
3085 sim_on_actions[sim_do_depth][i] = (char *)malloc(1+strlen(sim_on_actions[sim_do_depth-1][i]));
3086 if (NULL == sim_on_actions[sim_do_depth][i]) {
3087 while (--i >= 0) {
3088 FREE(sim_on_actions[sim_do_depth][i]);
3089 sim_on_actions[sim_do_depth][i] = NULL;
3090 }
3091 sim_on_check[sim_do_depth] = 0;
3092 sim_brk_clract ();
3093 --sim_do_depth;
3094 fclose(fpin);
3095 return SCPE_MEM;
3096 }
3097 strcpy(sim_on_actions[sim_do_depth][i], sim_on_actions[sim_do_depth-1][i]);
3098 }
3099 }
3100 }
3101 }
3102
3103 strcpy( sim_do_filename[sim_do_depth], do_arg[0]);
3104 sim_do_label[sim_do_depth] = label;
3105 sim_goto_line[sim_do_depth] = 0;
3106 if (label) {
3107 sim_gotofile = fpin;
3108 sim_do_echo = echo;
3109 stat = goto_cmd (0, label);
3110 if (stat != SCPE_OK) {
3111 strcpy(cbuf, "RETURN SCPE_ARG");
3112 cptr = get_glyph (cbuf, gbuf, 0);
3113 cmdp = find_cmd (gbuf);
3114 goto Cleanup_Return;
3115 }
3116 }
3117 if (errabort)
3118 set_on (1, NULL);
3119
3120 do {
3121 sim_do_ocptr[sim_do_depth] = cptr = sim_brk_getact (cbuf, sizeof(cbuf));
3122 if (!sim_do_ocptr[sim_do_depth]) {
3123 sim_do_ocptr[sim_do_depth] = cptr = read_line (cbuf, sizeof(cbuf), fpin);
3124 sim_goto_line[sim_do_depth] += 1;
3125 }
3126 if (cptr != NULL && strlen(cptr) < sizeof(cbuf)) {
3127 sim_sub_args(cbuf, sizeof(cbuf), do_arg);
3128 }
3129 sim_sub_args (cbuf, sizeof(cbuf), do_arg);
3130 if (cptr == NULL) {
3131 stat = SCPE_OK;
3132 break;
3133 }
3134 if (*cptr == 0)
3135 continue;
3136 if (echo)
3137 sim_printf("%s> %s\r\n", do_position(), cptr);
3138 if (*cptr == ':')
3139 continue;
3140 cptr = get_glyph_cmd (cptr, gbuf);
3141 sim_switches = 0;
3142 sim_gotofile = fpin;
3143 sim_do_echo = echo;
3144 if ((cmdp = find_cmd (gbuf))) {
3145 if (cmdp->action == &return_cmd)
3146 break;
3147 if (cmdp->action == &do_cmd) {
3148 if (sim_do_depth >= MAX_DO_NEST_LVL)
3149 stat = SCPE_NEST;
3150 else
3151 stat = do_cmd (sim_do_depth+1, cptr);
3152 }
3153 else
3154 stat = cmdp->action (cmdp->arg, cptr);
3155 }
3156 else stat = SCPE_UNK;
3157 echo = sim_do_echo;
3158 stat_nomessage = stat & SCPE_NOMESSAGE;
3159 stat_nomessage = stat_nomessage || (!sim_show_message);
3160 stat = SCPE_BARE_STATUS(stat);
3161 if (cmdp)
3162 if (((stat != SCPE_OK) && (stat != SCPE_EXPECT)) ||
3163 ((cmdp->action != &return_cmd) &&
3164 (cmdp->action != &goto_cmd) &&
3165 (cmdp->action != &on_cmd) &&
3166 (cmdp->action != &echo_cmd)))
3167 sim_last_cmd_stat = stat;
3168 switch (stat) {
3169 case SCPE_AFAIL:
3170 staying = (sim_on_check[sim_do_depth] &&
3171 sim_on_actions[sim_do_depth][stat]);
3172 break;
3173 case SCPE_EXIT:
3174 staying = FALSE;
3175 break;
3176 case SCPE_OK:
3177 case SCPE_STEP:
3178 break;
3179 default:
3180 break;
3181 }
3182 if ((stat >= SCPE_BASE) && (stat != SCPE_EXIT) &&
3183 (stat != SCPE_STEP)) {
3184 if (!echo && !sim_quiet &&
3185 !stat_nomessage &&
3186 !(cmdp && cmdp->message)) {
3187 sim_printf("%s> %s\r\n", do_position(), sim_do_ocptr[sim_do_depth]);
3188 }
3189 }
3190 if (!stat_nomessage) {
3191 if (cmdp && cmdp->message)
3192 cmdp->message ((!echo && !sim_quiet) ? sim_do_ocptr[sim_do_depth] : NULL, stat);
3193 else
3194 if (stat >= SCPE_BASE)
3195 sim_printf ("%s\r\n", sim_error_text (stat));
3196 }
3197 if (stat == SCPE_EXPECT)
3198 stat = SCPE_OK;
3199 if (staying &&
3200 (sim_on_check[sim_do_depth]) &&
3201 (stat != SCPE_OK) &&
3202 (stat != SCPE_STEP)) {
3203 if ((stat <= SCPE_MAX_ERR) && sim_on_actions[sim_do_depth][stat])
3204 sim_brk_setact (sim_on_actions[sim_do_depth][stat]);
3205 else
3206 sim_brk_setact (sim_on_actions[sim_do_depth][0]);
3207 }
3208 if (sim_vm_post != NULL)
3209 (*sim_vm_post) (TRUE);
3210 } while (staying);
3211 Cleanup_Return:
3212 if (fpin)
3213 fclose (fpin);
3214 sim_gotofile = NULL;
3215 if (flag >= 0) {
3216 sim_do_echo = saved_sim_do_echo;
3217 sim_show_message = saved_sim_show_message;
3218 sim_on_inherit = saved_sim_on_inherit;
3219 }
3220 sim_quiet = saved_sim_quiet;
3221 if ((flag >= 0) || (!sim_on_inherit)) {
3222 for (i=0; i<SCPE_MAX_ERR; i++) {
3223 FREE (sim_on_actions[sim_do_depth][i]);
3224 sim_on_actions[sim_do_depth][i] = NULL;
3225 }
3226 sim_on_check[sim_do_depth] = 0;
3227 }
3228 if (flag >= 0)
3229 --sim_do_depth;
3230 sim_brk_clract ();
3231 if (cmdp && (cmdp->action == &return_cmd) && (0 != *cptr)) {
3232 sim_string_to_stat (cptr, &stat);
3233 sim_last_cmd_stat = stat;
3234 if (sim_switches & SWMASK ('Q'))
3235 stat |= SCPE_NOMESSAGE;
3236 return stat;
3237 }
3238 return stat | SCPE_NOMESSAGE;
3239 }
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283 void sim_sub_args (char *instr, size_t instr_size, char *do_arg[])
3284 {
3285 char gbuf[CBUFSIZE];
3286 char *ip = instr, *op, *oend, *tmpbuf;
3287 const char *ap;
3288 char rbuf[CBUFSIZE];
3289 int i;
3290 time_t now;
3291 struct tm *tmnow;
3292
3293 time(&now);
3294 tmnow = localtime(&now);
3295 tmpbuf = (char *)malloc(instr_size);
3296 if (!tmpbuf)
3297 {
3298 (void)fprintf(stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
3299 __func__, __FILE__, __LINE__);
3300 #if defined(USE_BACKTRACE)
3301 # if defined(SIGUSR2)
3302 (void)raise(SIGUSR2);
3303
3304 # endif
3305 #endif
3306 abort();
3307 }
3308 op = tmpbuf;
3309 oend = tmpbuf + instr_size - 2;
3310 while (sim_isspace (*ip))
3311 *op++ = *ip++;
3312 for (; *ip && (op < oend); ) {
3313 if ((ip [0] == '\\') &&
3314 ((ip [1] == '%') || (ip [1] == '\\'))) {
3315 ip++;
3316 *op++ = *ip++;
3317 }
3318 else
3319 if ((*ip == '%') &&
3320 (sim_isalnum(ip[1]) || (ip[1] == '*') || (ip[1] == '_'))) {
3321 if ((ip[1] >= '0') && (ip[1] <= ('9'))) {
3322 ap = do_arg[ip[1] - '0'];
3323 for (i=0; i<ip[1] - '0'; ++i)
3324 if (do_arg[i] == NULL) {
3325 ap = NULL;
3326 break;
3327 }
3328 ip = ip + 2;
3329 }
3330 else if (ip[1] == '*') {
3331 (void)memset (rbuf, '\0', sizeof(rbuf));
3332 ap = rbuf;
3333 for (i=1; i<=9; ++i)
3334 if (do_arg[i] == NULL)
3335 break;
3336 else
3337 if ((sizeof(rbuf)-strlen(rbuf)) < (2 + strlen(do_arg[i]))) {
3338 if (strchr(do_arg[i], ' ')) {
3339 char quote = '"';
3340 if (strchr(do_arg[i], quote))
3341 quote = '\'';
3342 (void)sprintf(&rbuf[strlen(rbuf)], "%s%c%s%c\"",
3343 (i != 1) ? " " : "", quote,
3344 do_arg[i], quote);
3345 }
3346 else
3347 (void)sprintf(&rbuf[strlen(rbuf)], "%s%s",
3348 (i != 1) ? " " : "", do_arg[i]);
3349 }
3350 else
3351 break;
3352 ip = ip + 2;
3353 }
3354 else {
3355 ap = NULL;
3356 (void)get_glyph_nc (ip+1, gbuf, '%');
3357 ap = getenv(gbuf);
3358 if (!ap) {
3359 (void)get_glyph (ip+1, gbuf, '%');
3360 ap = getenv(gbuf);
3361 }
3362 ip += 1 + strlen (gbuf);
3363 if (*ip == '%') ++ip;
3364 if (!ap) {
3365
3366 if (!strcmp ("DATE", gbuf)) {
3367 (void)sprintf (rbuf, "%4d-%02d-%02d",
3368 tmnow->tm_year + 1900,
3369 tmnow->tm_mon + 1,
3370 tmnow->tm_mday);
3371 ap = rbuf;
3372 }
3373 else if (!strcmp ("TIME", gbuf)) {
3374 (void)sprintf (rbuf, "%02d:%02d:%02d",
3375 tmnow->tm_hour,
3376 tmnow->tm_min,
3377 tmnow->tm_sec);
3378 ap = rbuf;
3379 }
3380 else if (!strcmp ("DATETIME", gbuf)) {
3381 (void)sprintf (rbuf, "%04d-%02d-%02dT%02d:%02d:%02d",
3382 tmnow->tm_year + 1900,
3383 tmnow->tm_mon + 1,
3384 tmnow->tm_mday,
3385 tmnow->tm_hour,
3386 tmnow->tm_min,
3387 tmnow->tm_sec);
3388 ap = rbuf;
3389 }
3390
3391 if (!strcmp ("LDATE", gbuf)) {
3392 strftime (rbuf, sizeof(rbuf), "%x", tmnow);
3393 ap = rbuf;
3394 }
3395 else if (!strcmp ("LTIME", gbuf)) {
3396 strftime (rbuf, sizeof(rbuf), "%I:%M:%S %p", tmnow);
3397 ap = rbuf;
3398 }
3399 else if (!strcmp ("CTIME", gbuf)) {
3400 strftime (rbuf, sizeof(rbuf), "%c", tmnow);
3401 ap = rbuf;
3402 }
3403
3404 else if (!strcmp ("DATE_YYYY", gbuf)) {
3405 strftime (rbuf, sizeof(rbuf), "%Y", tmnow);
3406 ap = rbuf;
3407 }
3408 else if (!strcmp ("DATE_YY", gbuf)) {
3409 strftime (rbuf, sizeof(rbuf), "%y", tmnow);
3410 ap = rbuf;
3411 }
3412 else if (!strcmp ("DATE_YC", gbuf)) {
3413 (void)sprintf (rbuf, "%d", (tmnow->tm_year + 1900)/100);
3414 ap = rbuf;
3415 }
3416 else if ((!strcmp ("DATE_19XX_YY", gbuf)) ||
3417 (!strcmp ("DATE_19XX_YYYY", gbuf))) {
3418 int year = tmnow->tm_year + 1900;
3419 int days = year - 2001;
3420 int leaps = days/4 - days/100 + days/400;
3421 int lyear = ((year % 4) == 0) && (((year % 100) != 0) || ((year % 400) == 0));
3422 int selector = ((days + leaps + 7) % 7) + lyear * 7;
3423 static int years[] = {90, 91, 97, 98, 99, 94, 89,
3424 96, 80, 92, 76, 88, 72, 84};
3425 int cal_year = years[selector];
3426
3427 if (!strcmp ("DATE_19XX_YY", gbuf))
3428 (void)sprintf (rbuf, "%d", cal_year);
3429 else
3430 (void)sprintf (rbuf, "%d", cal_year + 1900);
3431 ap = rbuf;
3432 }
3433 else if (!strcmp ("DATE_MM", gbuf)) {
3434 strftime (rbuf, sizeof(rbuf), "%m", tmnow);
3435 ap = rbuf;
3436 }
3437 else if (!strcmp ("DATE_MMM", gbuf)) {
3438 strftime (rbuf, sizeof(rbuf), "%b", tmnow);
3439 ap = rbuf;
3440 }
3441 else if (!strcmp ("DATE_DD", gbuf)) {
3442 strftime (rbuf, sizeof(rbuf), "%d", tmnow);
3443 ap = rbuf;
3444 }
3445 else if (!strcmp ("DATE_D", gbuf)) {
3446 (void)sprintf (rbuf, "%d", (tmnow->tm_wday ? tmnow->tm_wday : 7));
3447 ap = rbuf;
3448 }
3449 else if ((!strcmp ("DATE_WW", gbuf)) ||
3450 (!strcmp ("DATE_WYYYY", gbuf))) {
3451 int iso_yr = tmnow->tm_year + 1900;
3452 int iso_wk = (tmnow->tm_yday + 11 - (tmnow->tm_wday ? tmnow->tm_wday : 7))/7;;
3453
3454 if (iso_wk == 0) {
3455 iso_yr = iso_yr - 1;
3456 tmnow->tm_yday += 365 + (((iso_yr % 4) == 0) ? 1 : 0);
3457 iso_wk = (tmnow->tm_yday + 11 - (tmnow->tm_wday ? tmnow->tm_wday : 7))/7;
3458 }
3459 else
3460 if ((iso_wk == 53) && (((31 - tmnow->tm_mday) + tmnow->tm_wday) < 4)) {
3461 ++iso_yr;
3462 iso_wk = 1;
3463 }
3464 if (!strcmp ("DATE_WW", gbuf))
3465 (void)sprintf (rbuf, "%02d", iso_wk);
3466 else
3467 (void)sprintf (rbuf, "%04d", iso_yr);
3468 ap = rbuf;
3469 }
3470 else if (!strcmp ("DATE_JJJ", gbuf)) {
3471 strftime (rbuf, sizeof(rbuf), "%j", tmnow);
3472 ap = rbuf;
3473 }
3474 else if (!strcmp ("TIME_HH", gbuf)) {
3475 strftime (rbuf, sizeof(rbuf), "%H", tmnow);
3476 ap = rbuf;
3477 }
3478 else if (!strcmp ("TIME_MM", gbuf)) {
3479 strftime (rbuf, sizeof(rbuf), "%M", tmnow);
3480 ap = rbuf;
3481 }
3482 else if (!strcmp ("TIME_SS", gbuf)) {
3483 strftime (rbuf, sizeof(rbuf), "%S", tmnow);
3484 ap = rbuf;
3485 }
3486 else if (!strcmp ("STATUS", gbuf)) {
3487 (void)sprintf (rbuf, "%08X", sim_last_cmd_stat);
3488 ap = rbuf;
3489 }
3490 else if (!strcmp ("TSTATUS", gbuf)) {
3491 (void)sprintf (rbuf, "%s", sim_error_text (sim_last_cmd_stat));
3492 ap = rbuf;
3493 }
3494 else if (!strcmp ("SIM_VERIFY", gbuf)) {
3495 (void)sprintf (rbuf, "%s", sim_do_echo ? "-V" : "");
3496 ap = rbuf;
3497 }
3498 else if (!strcmp ("SIM_VERBOSE", gbuf)) {
3499 (void)sprintf (rbuf, "%s", sim_do_echo ? "-V" : "");
3500 ap = rbuf;
3501 }
3502 else if (!strcmp ("SIM_LOCALOPC", gbuf)) {
3503 (void)sprintf (rbuf, "%s", sim_localopc ? "1" : "");
3504 ap = rbuf;
3505 }
3506 else if (!strcmp ("SIM_QUIET", gbuf)) {
3507 (void)sprintf (rbuf, "%s", sim_quiet ? "-Q" : "");
3508 ap = rbuf;
3509 }
3510 else if (!strcmp ("SIM_MESSAGE", gbuf)) {
3511 (void)sprintf (rbuf, "%s", sim_show_message ? "" : "-Q");
3512 ap = rbuf;
3513 }
3514 else if (!strcmp ("HOSTID", gbuf)) {
3515 #if defined(HAVE_UNISTD) && !defined(__HAIKU__) && !defined(__ANDROID__) && !defined(__serenity__) && !defined(__QNX__)
3516 (void)sprintf (rbuf, "%ld", (long)gethostid());
3517 #else
3518 (void)sprintf (rbuf, "00000000");
3519 #endif
3520 ap = rbuf;
3521 }
3522 else if (!strcmp ("UID", gbuf)) {
3523 #if defined(HAVE_UNISTD)
3524 (void)sprintf (rbuf, "%ld", (long)getuid());
3525 #else
3526 (void)sprintf (rbuf, "0");
3527 #endif
3528 ap = rbuf;
3529 }
3530 else if (!strcmp ("GID", gbuf)) {
3531 #if defined(HAVE_UNISTD)
3532 (void)sprintf (rbuf, "%ld", (long)getgid());
3533 #else
3534 (void)sprintf (rbuf, "0");
3535 #endif
3536 ap = rbuf;
3537 }
3538 else if (!strcmp ("EUID", gbuf)) {
3539 #if defined(HAVE_UNISTD)
3540 (void)sprintf (rbuf, "%ld", (long)geteuid());
3541 #else
3542 (void)sprintf (rbuf, "0");
3543 #endif
3544 ap = rbuf;
3545 }
3546 else if (!strcmp ("EGID", gbuf)) {
3547 #if defined(HAVE_UNISTD)
3548 (void)sprintf (rbuf, "%ld", (long)getegid());
3549 #else
3550 (void)sprintf (rbuf, "0");
3551 #endif
3552 ap = rbuf;
3553 }
3554 else if (!strcmp ("PID", gbuf)) {
3555 #if defined(HAVE_UNISTD)
3556 (void)sprintf (rbuf, "%ld", (long)_sir_getpid());
3557 #else
3558 (void)sprintf (rbuf, "0");
3559 #endif
3560 ap = rbuf;
3561 }
3562 else if (!strcmp ("PPID", gbuf)) {
3563 #if defined(HAVE_UNISTD)
3564 (void)sprintf (rbuf, "%ld", (long)getppid());
3565 #else
3566 (void)sprintf (rbuf, "0");
3567 #endif
3568 ap = rbuf;
3569 }
3570 else if (!strcmp ("PGID", gbuf)) {
3571 #if defined(HAVE_UNISTD)
3572 (void)sprintf (rbuf, "%ld", (long)getpgid(_sir_getpid()));
3573 #else
3574 (void)sprintf (rbuf, "0");
3575 #endif
3576 ap = rbuf;
3577 }
3578 else if (!strcmp ("SID", gbuf)) {
3579 #if defined(HAVE_UNISTD)
3580 (void)sprintf (rbuf, "%ld", (long)getsid(_sir_getpid()));
3581 #else
3582 (void)sprintf (rbuf, "0");
3583 #endif
3584 ap = rbuf;
3585 }
3586 else if (!strcmp ("ENDIAN", gbuf)) {
3587 #if ( defined(DECLITEND) && DECLITEND == 1 )
3588 (void)sprintf (rbuf, "LITTLE");
3589 #elif ( defined(DECLITEND) && DECLITEND == 0 )
3590 (void)sprintf (rbuf, "BIG");
3591 #else
3592 (void)sprintf (rbuf, "UNKNOWN");
3593 #endif
3594 ap = rbuf;
3595 }
3596 else if (!strcmp("SIM_NAME", gbuf)) {
3597 (void)sprintf (rbuf, "%s", sim_name);
3598 ap = rbuf;
3599 }
3600 else if (!strcmp("SIM_VERSION", gbuf)) {
3601 #if defined(VER_H_GIT_VERSION)
3602 (void)sprintf (rbuf, "%s", VER_H_GIT_VERSION);
3603 #else
3604 (void)sprintf (rbuf, "UNKNOWN");
3605 #endif
3606 ap = rbuf;
3607 }
3608 else if (!strcmp("SIM_HASH", gbuf)) {
3609 #if defined(VER_H_GIT_HASH)
3610 (void)sprintf (rbuf, "%s", VER_H_GIT_HASH);
3611 #else
3612 (void)sprintf (rbuf, "0000000000000000000000000000000000000000");
3613 #endif
3614 ap = rbuf;
3615 }
3616 else if (!strcmp("SIM_RELT", gbuf)) {
3617 #if defined(VER_H_GIT_RELT)
3618 (void)sprintf (rbuf, "%s", VER_H_GIT_RELT);
3619 #else
3620 (void)sprintf (rbuf, "X");
3621 #endif
3622 ap = rbuf;
3623 }
3624 else if (!strcmp("SIM_DATE", gbuf)) {
3625 #if defined(VER_H_GIT_DATE)
3626 (void)sprintf (rbuf, "%s", VER_H_GIT_DATE);
3627 #else
3628 (void)sprintf (rbuf, "UNKNOWN");
3629 #endif
3630 ap = rbuf;
3631 }
3632 else if ((!strcmp("CORES", gbuf)) ||
3633 (!strcmp("SIM_CORES", gbuf))) {
3634 (void)sprintf(rbuf, "%u", (ncores >= 1 && nprocs >= 1) ? ((ncores > nprocs) ? nprocs : ncores) : 1);
3635 ap = rbuf;
3636 }
3637 else if ((!strcmp("CPUS", gbuf)) ||
3638 (!strcmp("SIM_PROCESSORS", gbuf))) {
3639 (void)sprintf(rbuf, "%u", (nprocs < 2) ? 1U : nprocs);
3640 ap = rbuf;
3641 }
3642 }
3643 }
3644 if (ap) {
3645 while (*ap && (op < oend))
3646 *op++ = *ap++;
3647 }
3648 }
3649 else
3650 *op++ = *ip++;
3651 }
3652 *op = 0;
3653 strcpy (instr, tmpbuf);
3654 FREE (tmpbuf);
3655 return;
3656 }
3657
3658 static
3659 int sim_cmp_string (const char *s1, const char *s2)
3660 {
3661 long int v1, v2;
3662 char *ep1, *ep2;
3663
3664 v1 = strtol(s1+1, &ep1, 0);
3665 v2 = strtol(s2+1, &ep2, 0);
3666 if ((ep1 != s1 + strlen (s1) - 1) ||
3667 (ep2 != s2 + strlen (s2) - 1))
3668 return strcmp (s1, s2);
3669 if (v1 == v2)
3670 return 0;
3671 if (v1 < v2)
3672 return -1;
3673 return 1;
3674 }
3675
3676
3677
3678 t_stat assert_cmd (int32 flag, CONST char *cptr)
3679 {
3680 char gbuf[CBUFSIZE], gbuf2[CBUFSIZE];
3681 CONST char *tptr, *gptr;
3682 REG *rptr;
3683 uint32 idx = 0;
3684 t_value val;
3685 t_stat r;
3686 t_bool Not = FALSE;
3687 t_bool result;
3688 t_addr addr = 0;
3689 t_stat reason = SCPE_AFAIL;
3690
3691 cptr = (CONST char *)get_sim_opt (CMD_OPT_SW|CMD_OPT_DFT, (CONST char *)cptr, &r);
3692
3693 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3694 # pragma diagnostic push
3695 # pragma diag_suppress = integer_sign_change
3696 #endif
3697 sim_stabr.boolop = sim_staba.boolop = -1;
3698 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3699 # pragma diagnostic pop
3700 #endif
3701 if (*cptr == 0)
3702 return SCPE_2FARG;
3703 tptr = get_glyph (cptr, gbuf, 0);
3704 if (!strcmp (gbuf, "NOT")) {
3705 Not = TRUE;
3706 cptr = (CONST char *)tptr;
3707 }
3708 if (*cptr == '"') {
3709 char op[CBUFSIZE];
3710 static struct {
3711 const char *op;
3712 int aval;
3713 int bval;
3714 t_bool invert;
3715 } *optr, compare_ops[] =
3716 {
3717 { "==", 0, 0, FALSE },
3718 { "EQU", 0, 0, FALSE },
3719 { "!=", 0, 0, TRUE },
3720 { "NEQ", 0, 0, TRUE },
3721 { "<", -1, -1, FALSE },
3722 { "LSS", -1, -1, FALSE },
3723 { "<=", 0, -1, FALSE },
3724 { "LEQ", 0, -1, FALSE },
3725 { ">", 1, 1, FALSE },
3726 { "GTR", 1, 1, FALSE },
3727 { ">=", 0, 1, FALSE },
3728 { "GEQ", 0, 1, FALSE },
3729 { NULL }
3730 };
3731
3732 tptr = (CONST char *)get_glyph_gen (cptr, gbuf, '=', (sim_switches & SWMASK ('I')), TRUE, '\\');
3733
3734 if (!*tptr)
3735 return SCPE_2FARG;
3736 cptr += strlen (gbuf);
3737 while (sim_isspace (*cptr))
3738 ++cptr;
3739 (void)get_glyph (cptr, op, '"');
3740 for (optr = compare_ops; optr->op; optr++)
3741 if (0 == strcmp (op, optr->op))
3742 break;
3743 if (!optr->op)
3744 return sim_messagef (SCPE_ARG, "Invalid operator: %s\r\n", op);
3745 cptr += strlen (op);
3746 while (sim_isspace (*cptr))
3747 ++cptr;
3748 cptr = (CONST char *)get_glyph_gen (cptr, gbuf2, 0, (sim_switches & SWMASK ('I')), TRUE, '\\');
3749
3750 if (*cptr) {
3751 if (flag)
3752 return SCPE_2MARG;
3753 }
3754 else {
3755 if (!flag)
3756 return SCPE_2FARG;
3757 }
3758 result = sim_cmp_string (gbuf, gbuf2);
3759 result = ((result == optr->aval) || (result == optr->bval));
3760 if (optr->invert)
3761 result = !result;
3762 }
3763 else {
3764 cptr = get_glyph (cptr, gbuf, 0);
3765 rptr = find_reg (gbuf, &gptr, sim_dfdev);
3766 if (rptr) {
3767 if (*gptr == '[') {
3768 if (rptr->depth <= 1)
3769 return SCPE_ARG;
3770 idx = (uint32) strtotv (++gptr, &tptr, 10);
3771 if ((gptr == tptr) || (*tptr++ != ']'))
3772 return SCPE_ARG;
3773 gptr = tptr;
3774 }
3775 else idx = 0;
3776 if (idx >= rptr->depth)
3777 return SCPE_SUB;
3778 }
3779 else {
3780 if (sim_dfdev && sim_vm_parse_addr)
3781 addr = sim_vm_parse_addr (sim_dfdev, gbuf, &gptr);
3782 else if (sim_dfdev)
3783 addr = (t_addr) strtotv (gbuf, &gptr, sim_dfdev ? sim_dfdev->dradix : sim_dflt_dev->dradix);
3784 if (gbuf == gptr)
3785 return SCPE_NXREG;
3786 }
3787 if (*gptr != 0)
3788 (void)get_glyph (gptr, gbuf, 0);
3789 else {
3790 if (*cptr == 0)
3791 return SCPE_2FARG;
3792 cptr = get_glyph (cptr, gbuf, 0);
3793 }
3794 if (*cptr) {
3795 if (flag)
3796 return SCPE_2MARG;
3797 }
3798 else {
3799 if (!flag)
3800 return SCPE_2FARG;
3801 }
3802 if (rptr) {
3803 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3804 # pragma diagnostic push
3805 # pragma diag_suppress = integer_sign_change
3806 #endif
3807 if (!get_rsearch (gbuf, rptr->radix, &sim_stabr) ||
3808 (sim_stabr.boolop == -1))
3809 return SCPE_MISVAL;
3810 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3811 # pragma diagnostic pop
3812 #endif
3813 val = get_rval (rptr, idx);
3814 result = test_search (&val, &sim_stabr);
3815 }
3816 else {
3817 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3818 # pragma diagnostic push
3819 # pragma diag_suppress = integer_sign_change
3820 #endif
3821 if (sim_dfdev)
3822 if (!get_asearch (gbuf, sim_dfdev->dradix, &sim_staba) ||
3823 (sim_staba.boolop == -1))
3824 return SCPE_MISVAL;
3825 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3826 # pragma diagnostic pop
3827 #endif
3828 if (sim_dfdev)
3829 reason = get_aval (addr, sim_dfdev, sim_dfunit);
3830 if (reason != SCPE_OK)
3831 return reason;
3832 result = test_search (sim_eval, &sim_staba);
3833 }
3834 }
3835 if (Not ^ result) {
3836 if (!flag)
3837 sim_brk_setact (cptr);
3838 }
3839 else
3840 if (flag)
3841 return SCPE_AFAIL;
3842 return SCPE_OK;
3843 }
3844
3845
3846
3847 t_stat send_cmd (int32 flag, CONST char *cptr)
3848 {
3849 char gbuf[CBUFSIZE];
3850 CONST char *tptr;
3851 uint8 dbuf[CBUFSIZE];
3852 uint32 dsize = 0;
3853 uint32 delay = 0;
3854 uint32 after = 0;
3855 t_stat r;
3856 SEND *snd = NULL;
3857
3858 GET_SWITCHES (cptr);
3859 tptr = get_glyph (cptr, gbuf, ',');
3860 if (sim_isalpha(gbuf[0]) && (strchr (gbuf, ':'))) {
3861 r = tmxr_locate_line_send (gbuf, &snd);
3862 if (r != SCPE_OK)
3863 return r;
3864 cptr = tptr;
3865 tptr = get_glyph (tptr, gbuf, ',');
3866 }
3867 else
3868 snd = sim_cons_get_send ();
3869
3870 while (*cptr) {
3871 if ((!strncmp(gbuf, "DELAY=", 6)) && (gbuf[6])) {
3872 delay = (uint32)get_uint (&gbuf[6], 10, 2000000000, &r);
3873 if (r != SCPE_OK)
3874 return sim_messagef (SCPE_ARG, "Invalid Delay Value\r\n");
3875 cptr = tptr;
3876 tptr = get_glyph (cptr, gbuf, ',');
3877 continue;
3878 }
3879 if ((!strncmp(gbuf, "AFTER=", 6)) && (gbuf[6])) {
3880 after = (uint32)get_uint (&gbuf[6], 10, 2000000000, &r);
3881 if (r != SCPE_OK)
3882 return sim_messagef (SCPE_ARG, "Invalid After Value\r\n");
3883 cptr = tptr;
3884 tptr = get_glyph (cptr, gbuf, ',');
3885 continue;
3886 }
3887 if ((*cptr == '"') || (*cptr == '\''))
3888 break;
3889 return SCPE_ARG;
3890 }
3891 if (*cptr) {
3892 if ((*cptr != '"') && (*cptr != '\''))
3893 return sim_messagef (SCPE_ARG, "String must be quote delimited\r\n");
3894 cptr = get_glyph_quoted (cptr, gbuf, 0);
3895 if (*cptr != '\0')
3896 return SCPE_2MARG;
3897
3898 if (SCPE_OK != sim_decode_quoted_string (gbuf, dbuf, &dsize))
3899 return sim_messagef (SCPE_ARG, "Invalid String\r\n");
3900 }
3901 if ((dsize == 0) && (delay == 0) && (after == 0))
3902 return SCPE_2FARG;
3903 return sim_send_input (snd, dbuf, dsize, after, delay);
3904 }
3905
3906 t_stat sim_show_send (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
3907 {
3908 char gbuf[CBUFSIZE];
3909 CONST char *tptr;
3910 t_stat r;
3911 SEND *snd = NULL;
3912
3913 tptr = get_glyph (cptr, gbuf, ',');
3914 if (sim_isalpha(gbuf[0]) && (strchr (gbuf, ':'))) {
3915 r = tmxr_locate_line_send (gbuf, &snd);
3916 if (r != SCPE_OK)
3917 return r;
3918 cptr = tptr;
3919 }
3920 else
3921 snd = sim_cons_get_send ();
3922 if (*cptr)
3923 return SCPE_2MARG;
3924 return sim_show_send_input (st, snd);
3925 }
3926
3927 t_stat expect_cmd (int32 flag, CONST char *cptr)
3928 {
3929 char gbuf[CBUFSIZE];
3930 CONST char *tptr;
3931 EXPECT *exp = NULL;
3932
3933 GET_SWITCHES (cptr);
3934 tptr = get_glyph (cptr, gbuf, ',');
3935 if (sim_isalpha(gbuf[0]) && (strchr (gbuf, ':'))) {
3936 cptr = tptr;
3937 } else {
3938 exp = sim_cons_get_expect ();
3939 }
3940
3941 if (flag) {
3942 return sim_set_expect (exp, cptr);
3943 } else {
3944 if (exp == NULL) {
3945 exp = sim_cons_get_expect();
3946 }
3947 return sim_set_noexpect (exp, cptr);
3948 }
3949 }
3950
3951 t_stat sim_show_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
3952 {
3953 char gbuf[CBUFSIZE];
3954 CONST char *tptr;
3955 EXPECT *exp = NULL;
3956 t_stat r;
3957
3958 tptr = get_glyph (cptr, gbuf, ',');
3959 if (sim_isalpha(gbuf[0]) && (strchr (gbuf, ':'))) {
3960 r = tmxr_locate_line_expect (gbuf, &exp);
3961 if (r != SCPE_OK)
3962 return r;
3963 cptr = tptr;
3964 }
3965 else
3966 exp = sim_cons_get_expect ();
3967 if (*cptr && (*cptr != '"') && (*cptr != '\''))
3968 return SCPE_ARG;
3969 tptr = get_glyph_quoted (cptr, gbuf, 0);
3970 if (*tptr != '\0')
3971 return SCPE_2MARG;
3972 if (*cptr && (cptr[strlen(cptr)-1] != '"') && (cptr[strlen(cptr)-1] != '\''))
3973 return SCPE_ARG;
3974 return sim_exp_show (st, exp, gbuf);
3975 }
3976
3977
3978
3979 t_stat goto_cmd (int32 flag, CONST char *fcptr)
3980 {
3981 char cbuf[CBUFSIZE], gbuf[CBUFSIZE], gbuf1[CBUFSIZE];
3982 const char *cptr;
3983 long fpos;
3984 int32 saved_do_echo = sim_do_echo;
3985 int32 saved_goto_line = sim_goto_line[sim_do_depth];
3986
3987 if (NULL == sim_gotofile) return SCPE_UNK;
3988 (void)get_glyph (fcptr, gbuf1, 0);
3989 if ('\0' == gbuf1[0]) return SCPE_ARG;
3990 fpos = ftell(sim_gotofile);
3991 rewind(sim_gotofile);
3992 sim_goto_line[sim_do_depth] = 0;
3993 sim_do_echo = 0;
3994 while (1) {
3995 cptr = read_line (cbuf, sizeof(cbuf), sim_gotofile);
3996 if (cptr == NULL) break;
3997 sim_goto_line[sim_do_depth] += 1;
3998 if (*cptr == 0) continue;
3999 if (*cptr != ':') continue;
4000 ++cptr;
4001 while (sim_isspace (*cptr)) ++cptr;
4002 cptr = get_glyph (cptr, gbuf, 0);
4003 if (0 == strcmp(gbuf, gbuf1)) {
4004 sim_brk_clract ();
4005 sim_do_echo = saved_do_echo;
4006 if (sim_do_echo)
4007 sim_printf("%s> %s\r\n", do_position(), cbuf);
4008 return SCPE_OK;
4009 }
4010 }
4011 sim_do_echo = saved_do_echo;
4012 fseek(sim_gotofile, fpos, SEEK_SET);
4013 sim_goto_line[sim_do_depth] = saved_goto_line;
4014 return SCPE_ARG;
4015 }
4016
4017
4018
4019
4020
4021
4022
4023
4024 t_stat return_cmd (int32 flag, CONST char *fcptr)
4025 {
4026 return SCPE_UNK;
4027 }
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037 t_stat shift_cmd (int32 flag, CONST char *fcptr)
4038 {
4039 return SCPE_UNK;
4040 }
4041
4042
4043
4044
4045
4046
4047
4048
4049 t_stat call_cmd (int32 flag, CONST char *fcptr)
4050 {
4051 char cbuf[2*CBUFSIZE], gbuf[CBUFSIZE];
4052 const char *cptr;
4053
4054 if (NULL == sim_gotofile) return SCPE_UNK;
4055 cptr = get_glyph (fcptr, gbuf, 0);
4056 if ('\0' == gbuf[0]) return SCPE_ARG;
4057 (void)snprintf(cbuf, sizeof (cbuf), "%s %s", sim_do_filename[sim_do_depth], cptr);
4058 sim_switches |= SWMASK ('O');
4059 return do_cmd_label (flag, cbuf, gbuf);
4060 }
4061
4062
4063
4064 t_stat on_cmd (int32 flag, CONST char *cptr)
4065 {
4066 char gbuf[CBUFSIZE];
4067 t_stat cond;
4068
4069 cptr = get_glyph (cptr, gbuf, 0);
4070 if ('\0' == gbuf[0]) return SCPE_ARG;
4071 if (0 == strcmp("ERROR", gbuf))
4072 cond = 0;
4073 else
4074 if (SCPE_OK != sim_string_to_stat (gbuf, &cond))
4075 return SCPE_ARG;
4076 if ((NULL == cptr) || ('\0' == *cptr)) {
4077 FREE(sim_on_actions[sim_do_depth][cond]);
4078 sim_on_actions[sim_do_depth][cond] = NULL; }
4079 else {
4080 sim_on_actions[sim_do_depth][cond] =
4081 (char *)realloc(sim_on_actions[sim_do_depth][cond], 1+strlen(cptr));
4082 if (!sim_on_actions[sim_do_depth][cond])
4083 {
4084 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
4085 __func__, __FILE__, __LINE__);
4086 #if defined(USE_BACKTRACE)
4087 # if defined(SIGUSR2)
4088 (void)raise(SIGUSR2);
4089
4090 # endif
4091 #endif
4092 abort();
4093 }
4094 strcpy(sim_on_actions[sim_do_depth][cond], cptr);
4095 }
4096 return SCPE_OK;
4097 }
4098
4099
4100
4101 t_stat noop_cmd (int32 flag, CONST char *cptr)
4102 {
4103 if (cptr && (*cptr != 0))
4104 return SCPE_2MARG;
4105 return SCPE_OK;
4106 }
4107
4108
4109
4110 t_stat set_on (int32 flag, CONST char *cptr)
4111 {
4112 if ((flag) && (cptr) && (*cptr)) {
4113 char gbuf[CBUFSIZE];
4114
4115 cptr = get_glyph (cptr, gbuf, 0);
4116 if (((MATCH_CMD(gbuf,"INHERIT")) &&
4117 (MATCH_CMD(gbuf,"NOINHERIT"))) ||
4118 (*cptr))
4119 return SCPE_2MARG;
4120 if ((gbuf[0]) && (0 == MATCH_CMD(gbuf,"INHERIT")))
4121 sim_on_inherit = 1;
4122 if ((gbuf[0]) && (0 == MATCH_CMD(gbuf,"NOINHERIT")))
4123 sim_on_inherit = 0;
4124 return SCPE_OK;
4125 }
4126 if (cptr && (*cptr != 0))
4127 return SCPE_2MARG;
4128 sim_on_check[sim_do_depth] = flag;
4129 if ((sim_do_depth != 0) &&
4130 (NULL == sim_on_actions[sim_do_depth][0])) {
4131 sim_on_actions[sim_do_depth][0] =
4132 (char *)malloc(1+strlen("RETURN"));
4133 strcpy(sim_on_actions[sim_do_depth][0], "RETURN");
4134 }
4135 if ((sim_do_depth != 0) &&
4136 (NULL == sim_on_actions[sim_do_depth][SCPE_AFAIL])) {
4137 sim_on_actions[sim_do_depth][SCPE_AFAIL] =
4138 (char *)malloc(1+strlen("RETURN"));
4139 strcpy(sim_on_actions[sim_do_depth][SCPE_AFAIL], "RETURN");
4140 }
4141 return SCPE_OK;
4142 }
4143
4144
4145
4146 t_stat set_verify (int32 flag, CONST char *cptr)
4147 {
4148 if (cptr && (*cptr != 0))
4149 return SCPE_2MARG;
4150 if (flag == sim_do_echo)
4151 return SCPE_OK;
4152 sim_do_echo = flag;
4153 return SCPE_OK;
4154 }
4155
4156
4157
4158 t_stat set_message (int32 flag, CONST char *cptr)
4159 {
4160 if (cptr && (*cptr != 0))
4161 return SCPE_2MARG;
4162 if (flag == sim_show_message)
4163 return SCPE_OK;
4164 sim_show_message = flag;
4165 return SCPE_OK;
4166 }
4167
4168
4169
4170 t_stat set_localopc (int32 flag, CONST char *cptr)
4171 {
4172 if (cptr && (*cptr != 0))
4173 return SCPE_2MARG;
4174 if (flag == sim_localopc)
4175 return SCPE_OK;
4176 sim_localopc = flag;
4177 return SCPE_OK;
4178 }
4179
4180
4181 t_stat set_quiet (int32 flag, CONST char *cptr)
4182 {
4183 if (cptr && (*cptr != 0))
4184 return SCPE_2MARG;
4185 if (flag == sim_quiet)
4186 return SCPE_OK;
4187 sim_quiet = flag;
4188 return SCPE_OK;
4189 }
4190
4191
4192
4193 t_stat sim_set_environment (int32 flag, CONST char *cptr)
4194 {
4195 char varname[CBUFSIZE];
4196
4197 if ((NULL == cptr) || (*cptr == 0))
4198 return SCPE_2FARG;
4199 cptr = get_glyph (cptr, varname, '=');
4200 setenv(varname, cptr, 1);
4201 return SCPE_OK;
4202 }
4203
4204
4205
4206 t_stat set_cmd (int32 flag, CONST char *cptr)
4207 {
4208 uint32 lvl = 0;
4209 t_stat r;
4210 char gbuf[CBUFSIZE], *cvptr;
4211 CONST char *svptr;
4212 DEVICE *dptr;
4213 UNIT *uptr;
4214 MTAB *mptr;
4215 CTAB *gcmdp;
4216 C1TAB *ctbr = NULL, *glbr;
4217
4218 GET_SWITCHES (cptr);
4219 if ((NULL == cptr) || (*cptr == 0))
4220 return SCPE_2FARG;
4221 cptr = get_glyph (svptr = cptr, gbuf, 0);
4222
4223 if ((dptr = find_dev (gbuf))) {
4224 uptr = dptr->units;
4225 ctbr = set_dev_tab;
4226 lvl = MTAB_VDV;
4227 GET_SWITCHES (cptr);
4228 }
4229 else if ((dptr = find_unit (gbuf, &uptr))) {
4230 if (uptr == NULL)
4231 return SCPE_NXUN;
4232 ctbr = set_unit_tab;
4233 lvl = MTAB_VUN;
4234 GET_SWITCHES (cptr);
4235 }
4236 else if ((gcmdp = find_ctab (set_glob_tab, gbuf))) {
4237 GET_SWITCHES (cptr);
4238 return gcmdp->action (gcmdp->arg, cptr);
4239 }
4240 else {
4241 if (sim_dflt_dev && sim_dflt_dev->modifiers) {
4242 if ((cvptr = strchr (gbuf, '=')))
4243 *cvptr++ = 0;
4244 for (mptr = sim_dflt_dev->modifiers; mptr->mask != 0; mptr++) {
4245 if (mptr->mstring && (MATCH_CMD (gbuf, mptr->mstring) == 0)) {
4246 dptr = sim_dflt_dev;
4247 cptr = svptr;
4248 while (sim_isspace(*cptr))
4249 ++cptr;
4250 break;
4251 }
4252 }
4253 }
4254 if (!dptr)
4255 return SCPE_NXDEV;
4256 lvl = MTAB_VDV;
4257 uptr = dptr->units;
4258 }
4259 if ((*cptr == 0) || (*cptr == ';') || (*cptr == '#'))
4260 return SCPE_2FARG;
4261 GET_SWITCHES (cptr);
4262
4263 while (*cptr != 0) {
4264 cptr = get_glyph (svptr = cptr, gbuf, ',');
4265 if (0 == strcmp (gbuf, ";"))
4266 break;
4267 if ((cvptr = strchr (gbuf, '=')))
4268 *cvptr++ = 0;
4269 for (mptr = dptr->modifiers; mptr && (mptr->mask != 0); mptr++) {
4270 if ((mptr->mstring) &&
4271 (MATCH_CMD (gbuf, mptr->mstring) == 0)) {
4272 if (mptr->mask & MTAB_XTD) {
4273 if (((lvl & mptr->mask) & ~MTAB_XTD) == 0)
4274 return SCPE_ARG;
4275 if ((lvl == MTAB_VUN) && (uptr->flags & UNIT_DIS))
4276 return SCPE_UDIS;
4277 if (mptr->valid) {
4278 if (cvptr && MODMASK(mptr,MTAB_QUOTE)) {
4279 svptr = get_glyph_quoted (svptr, gbuf, ',');
4280 if ((cvptr = strchr (gbuf, '='))) {
4281 *cvptr++ = 0;
4282 cptr = svptr;
4283 }
4284 }
4285 else {
4286 if (cvptr && MODMASK(mptr,MTAB_NC)) {
4287 (void)get_glyph_nc (svptr, gbuf, ',');
4288 if ((cvptr = strchr (gbuf, '=')))
4289 *cvptr++ = 0;
4290 }
4291 }
4292 r = mptr->valid (uptr, mptr->match, cvptr, mptr->desc);
4293 if (r != SCPE_OK)
4294 return r;
4295 }
4296 else if (!mptr->desc)
4297 break;
4298 else if (cvptr)
4299 return SCPE_ARG;
4300 else *((int32 *) mptr->desc) = mptr->match;
4301 }
4302 else {
4303 if (cvptr)
4304 return SCPE_ARG;
4305 if (uptr->flags & UNIT_DIS)
4306 return SCPE_UDIS;
4307 if ((mptr->valid) &&
4308 ((r = mptr->valid (uptr, mptr->match, cvptr, mptr->desc)) != SCPE_OK))
4309 return r;
4310 uptr->flags = (uptr->flags & ~(mptr->mask)) |
4311 (mptr->match & mptr->mask);
4312 }
4313 break;
4314 }
4315 }
4316 if (!mptr || (mptr->mask == 0)) {
4317 if ((glbr = find_c1tab (ctbr, gbuf))) {
4318 r = glbr->action (dptr, uptr, glbr->arg, cvptr);
4319 if (r != SCPE_OK)
4320 return r;
4321 }
4322 else if (!dptr->modifiers)
4323 return SCPE_NOPARAM;
4324 else return SCPE_NXPAR;
4325 }
4326 }
4327 return SCPE_OK;
4328 }
4329
4330
4331
4332 CTAB *find_ctab (CTAB *tab, const char *gbuf)
4333 {
4334 if (!tab)
4335 return NULL;
4336 for (; tab->name != NULL; tab++) {
4337 if (MATCH_CMD (gbuf, tab->name) == 0)
4338 return tab;
4339 }
4340 return NULL;
4341 }
4342
4343 C1TAB *find_c1tab (C1TAB *tab, const char *gbuf)
4344 {
4345 if (!tab)
4346 return NULL;
4347 for (; tab->name != NULL; tab++) {
4348 if (MATCH_CMD (gbuf, tab->name) == 0)
4349 return tab;
4350 }
4351 return NULL;
4352 }
4353
4354
4355
4356 t_stat set_dev_radix (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4357 {
4358 if (cptr)
4359 return SCPE_ARG;
4360 dptr->dradix = flag & 037;
4361 return SCPE_OK;
4362 }
4363
4364
4365
4366 t_stat set_dev_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4367 {
4368 UNIT *up;
4369 uint32 i;
4370
4371 if (cptr)
4372 return SCPE_ARG;
4373 if ((dptr->flags & DEV_DISABLE) == 0)
4374 return SCPE_NOFNC;
4375 if (flag) {
4376 if ((dptr->flags & DEV_DIS) == 0)
4377 return SCPE_OK;
4378 dptr->flags = dptr->flags & ~DEV_DIS;
4379 }
4380 else {
4381 if (dptr->flags & DEV_DIS)
4382 return SCPE_OK;
4383 for (i = 0; i < dptr->numunits; i++) {
4384 up = (dptr->units) + i;
4385 if ((up->flags & UNIT_ATT) || sim_is_active (up))
4386 return SCPE_NOFNC;
4387 }
4388 dptr->flags = dptr->flags | DEV_DIS;
4389 }
4390 if (dptr->reset)
4391 return dptr->reset (dptr);
4392 else return SCPE_OK;
4393 }
4394
4395
4396
4397 t_stat set_unit_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4398 {
4399 if (cptr)
4400 return SCPE_ARG;
4401 if (!(uptr->flags & UNIT_DISABLE))
4402 return SCPE_NOFNC;
4403 if (flag)
4404 uptr->flags = uptr->flags & ~UNIT_DIS;
4405 else {
4406 if ((uptr->flags & UNIT_ATT) ||
4407 sim_is_active (uptr))
4408 return SCPE_NOFNC;
4409 uptr->flags = uptr->flags | UNIT_DIS;
4410 }
4411 return SCPE_OK;
4412 }
4413
4414
4415
4416 t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4417 {
4418 char gbuf[CBUFSIZE];
4419 DEBTAB *dep;
4420
4421 if ((dptr->flags & DEV_DEBUG) == 0)
4422 return SCPE_NOFNC;
4423 if (cptr == NULL) {
4424 dptr->dctrl = flag ? (dptr->debflags ? flag : 0xFFFFFFFF) : 0;
4425 if (flag && dptr->debflags) {
4426 for (dep = dptr->debflags; dep->name != NULL; dep++)
4427 dptr->dctrl = dptr->dctrl | dep->mask;
4428 }
4429 return SCPE_OK;
4430 }
4431 if (dptr->debflags == NULL)
4432 return SCPE_ARG;
4433 while (*cptr) {
4434 cptr = get_glyph (cptr, gbuf, ';');
4435 for (dep = dptr->debflags; dep->name != NULL; dep++) {
4436 if (strcmp (dep->name, gbuf) == 0) {
4437 if (flag)
4438 dptr->dctrl = dptr->dctrl | dep->mask;
4439 else dptr->dctrl = dptr->dctrl & ~dep->mask;
4440 break;
4441 }
4442 }
4443 if (dep->mask == 0)
4444 return SCPE_ARG;
4445 }
4446 return SCPE_OK;
4447 }
4448
4449
4450
4451 t_stat show_cmd (int32 flag, CONST char *cptr)
4452 {
4453 t_stat r = SCPE_IERR;
4454
4455 cptr = get_sim_opt (CMD_OPT_SW|CMD_OPT_OF, cptr, &r);
4456
4457 if (NULL == cptr)
4458 return r;
4459 if (sim_ofile) {
4460 r = show_cmd_fi (sim_ofile, flag, cptr);
4461 fclose (sim_ofile);
4462 }
4463 else {
4464 r = show_cmd_fi (stdout, flag, cptr);
4465 if (sim_log && (sim_log != stdout))
4466 show_cmd_fi (sim_log, flag, cptr);
4467 if (sim_deb && (sim_deb != stdout) && (sim_deb != sim_log))
4468 show_cmd_fi (sim_deb, flag, cptr);
4469 }
4470 return r;
4471 }
4472
4473 t_stat show_cmd_fi (FILE *ofile, int32 flag, CONST char *cptr)
4474 {
4475 uint32 lvl = 0xFFFFFFFF;
4476 char gbuf[CBUFSIZE], *cvptr;
4477 CONST char *svptr;
4478 DEVICE *dptr;
4479 UNIT *uptr;
4480 MTAB *mptr;
4481 SHTAB *shtb = NULL, *shptr;
4482
4483 GET_SWITCHES (cptr);
4484 if ((*cptr == 0) || (*cptr == ';') || (*cptr == '#'))
4485 return SCPE_2FARG;
4486 cptr = get_glyph (svptr = cptr, gbuf, 0);
4487
4488 if ((dptr = find_dev (gbuf))) {
4489 uptr = dptr->units;
4490 shtb = show_dev_tab;
4491 lvl = MTAB_VDV;
4492 GET_SWITCHES (cptr);
4493 }
4494 else if ((dptr = find_unit (gbuf, &uptr))) {
4495 if (uptr == NULL)
4496 return sim_messagef (SCPE_NXUN, "Non-existent unit: %s\r\n", gbuf);
4497 if (uptr->flags & UNIT_DIS)
4498 return sim_messagef (SCPE_UDIS, "Unit disabled: %s\r\n", gbuf);
4499 shtb = show_unit_tab;
4500 lvl = MTAB_VUN;
4501 GET_SWITCHES (cptr);
4502 }
4503 else if ((shptr = find_shtab (show_glob_tab, gbuf))) {
4504 GET_SWITCHES (cptr);
4505 return shptr->action (ofile, NULL, NULL, shptr->arg, cptr);
4506 }
4507 else {
4508 if (sim_dflt_dev && sim_dflt_dev->modifiers) {
4509 if ((cvptr = strchr (gbuf, '=')))
4510 *cvptr++ = 0;
4511 for (mptr = sim_dflt_dev->modifiers; mptr && (mptr->mask != 0); mptr++) {
4512 if ((((mptr->mask & MTAB_VDV) == MTAB_VDV) &&
4513 (mptr->pstring && (MATCH_CMD (gbuf, mptr->pstring) == 0))) ||
4514 (!(mptr->mask & MTAB_VDV) && (mptr->mstring && (MATCH_CMD (gbuf, mptr->mstring) == 0)))) {
4515 dptr = sim_dflt_dev;
4516 lvl = MTAB_VDV;
4517 cptr = svptr;
4518 while (sim_isspace(*cptr))
4519 ++cptr;
4520 break;
4521 }
4522 }
4523 }
4524 if (!dptr) {
4525 if (sim_dflt_dev && (shptr = find_shtab (show_dev_tab, gbuf)))
4526 return shptr->action (ofile, sim_dflt_dev, uptr, shptr->arg, cptr);
4527 else
4528 return sim_messagef (SCPE_NXDEV, "Non-existent device: %s\r\n", gbuf);
4529 }
4530 }
4531
4532 if ((*cptr == 0) || (*cptr == ';') || (*cptr == '#')) {
4533 return (lvl == MTAB_VDV)?
4534 show_device (ofile, dptr, 0):
4535 show_unit (ofile, dptr, uptr, -1);
4536 }
4537 GET_SWITCHES (cptr);
4538
4539 while (*cptr != 0) {
4540 cptr = get_glyph (cptr, gbuf, ',');
4541 if ((cvptr = strchr (gbuf, '=')))
4542 *cvptr++ = 0;
4543 for (mptr = dptr->modifiers; mptr && (mptr->mask != 0); mptr++) {
4544 if (((mptr->mask & MTAB_XTD)?
4545 ((mptr->mask & lvl) == lvl): (MTAB_VUN & lvl)) &&
4546 ((mptr->disp && mptr->pstring &&
4547 (MATCH_CMD (gbuf, mptr->pstring) == 0))
4548 )) {
4549 if (cvptr && !MODMASK(mptr,MTAB_SHP))
4550 return sim_messagef (SCPE_ARG, "Invalid Argument: %s=%s\r\n", gbuf, cvptr);
4551 show_one_mod (ofile, dptr, uptr, mptr, cvptr, 1);
4552 break;
4553 }
4554 }
4555 if (!mptr || (mptr->mask == 0)) {
4556 if (shtb && (shptr = find_shtab (shtb, gbuf))) {
4557 t_stat r;
4558
4559 r = shptr->action (ofile, dptr, uptr, shptr->arg, cptr);
4560 if (r != SCPE_OK)
4561 return r;
4562 }
4563 else {
4564 if (!dptr->modifiers)
4565 return sim_messagef (SCPE_NOPARAM, "%s device has no parameters\r\n", dptr->name);
4566 else
4567 return sim_messagef (SCPE_NXPAR, "Non-existent parameter: %s\r\n", gbuf);
4568 }
4569 }
4570 }
4571 return SCPE_OK;
4572 }
4573
4574 SHTAB *find_shtab (SHTAB *tab, const char *gbuf)
4575 {
4576 if (!tab)
4577 return NULL;
4578 for (; tab->name != NULL; tab++) {
4579 if (MATCH_CMD (gbuf, tab->name) == 0)
4580 return tab;
4581 }
4582 return NULL;
4583 }
4584
4585
4586
4587 t_stat show_device (FILE *st, DEVICE *dptr, int32 flag)
4588 {
4589 uint32 j, udbl, ucnt;
4590 UNIT *uptr;
4591 int32 toks = 0;
4592
4593 if (strcmp(sim_dname (dptr),"SYS") != 0) {
4594 (void)fprintf (st, "%s", sim_dname (dptr));
4595 if ((flag == 2) && dptr->description) {
4596 (void)fprintf (st, "\t%s\r\n", dptr->description(dptr));
4597 }
4598 else {
4599 if ((sim_switches & SWMASK ('D')) && dptr->description)
4600 (void)fprintf (st, "\t%s\r\n", dptr->description(dptr));
4601 }
4602 if (qdisable (dptr)) {
4603 (void)fprintf (st, "\tdisabled\r\n");
4604 return SCPE_OK;
4605 }
4606 for (j = ucnt = udbl = 0; j < dptr->numunits; j++) {
4607 uptr = dptr->units + j;
4608 if (!(uptr->flags & UNIT_DIS))
4609 ucnt++;
4610 else if (uptr->flags & UNIT_DISABLE)
4611 udbl++;
4612 }
4613
4614 if (dptr->numunits == 0) {
4615
4616
4617 }
4618 else
4619 {
4620 if (ucnt == 0) {
4621 fprint_sep (st, &toks);
4622 (void)fprintf (st, "all units disabled\r\n");
4623 }
4624 else if ((ucnt + udbl) == 1) {
4625 fprint_sep (st, &toks);
4626 (void)fprintf (st, " 1 unit\r\n");
4627 }
4628 else if ((ucnt > 1) || (udbl > 0)) {
4629 fprint_sep (st, &toks);
4630 (void)fprintf (st, "%2.d units\r\n", ucnt + udbl);
4631 }
4632 else
4633 if ((flag != 2) || !dptr->description || toks)
4634 (void)fprintf (st, "\r\n");
4635 toks = 0;
4636 }
4637 if (flag)
4638 return SCPE_OK;
4639 for (j = 0; j < dptr->numunits; j++) {
4640 uptr = dptr->units + j;
4641 if ((uptr->flags & UNIT_DIS) == 0)
4642 show_unit (st, dptr, uptr, ucnt + udbl);
4643 }
4644 }
4645 return SCPE_OK;
4646 }
4647
4648 void fprint_sep (FILE *st, int32 *tokens)
4649 {
4650 (void)fprintf (st, "%s", (*tokens > 0) ? "" : "\t");
4651 *tokens += 1;
4652 }
4653
4654 t_stat show_unit (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag)
4655 {
4656 int32 u = (int32)(uptr - dptr->units);
4657 int32 toks = 0;
4658
4659 if (flag > 1)
4660 (void)fprintf (st, " %s%d\r\n", sim_dname (dptr), u);
4661 else if (flag < 0)
4662 (void)fprintf (st, " %s%d ", sim_dname (dptr), u);
4663 if (uptr->flags & UNIT_ATT) {
4664 fprint_sep (st, &toks);
4665 (void)fprintf (st, "status : attached to %s", uptr->filename);
4666 if (uptr->flags & UNIT_RO)
4667 (void)fprintf (st, ", read only");
4668 }
4669 else {
4670 if (uptr->flags & UNIT_ATTABLE) {
4671 fprint_sep (st, &toks);
4672 (void)fprintf (st, "status : not attached");
4673 }
4674 }
4675 if ((uptr->capac > 0) && (uptr->flags & UNIT_FIX)) {
4676 fprint_sep (st, &toks);
4677 fprint_capac (st, dptr, uptr);
4678 }
4679 show_all_mods (st, dptr, uptr, MTAB_VUN, &toks);
4680 if (toks || (flag < 0) || (flag > 1))
4681 (void)fprintf (st, "\r\n");
4682 return SCPE_OK;
4683 }
4684
4685 const char *sprint_capac (DEVICE *dptr, UNIT *uptr)
4686 {
4687 static char capac_buf[((CHAR_BIT * sizeof (t_value) * 4 + 3)/3) + 8];
4688 t_offset kval = (t_offset)((uptr->flags & UNIT_BINK) ? 1024: 1000);
4689 t_offset mval;
4690 t_offset psize = (t_offset)uptr->capac;
4691 char *scale, *width;
4692
4693 if (sim_switches & SWMASK ('B'))
4694 kval = 1024;
4695 mval = kval * kval;
4696 if (dptr->flags & DEV_SECTORS) {
4697 kval = kval / 512;
4698 mval = mval / 512;
4699 }
4700 if ((dptr->dwidth / dptr->aincr) > 8)
4701 width = "W";
4702 else
4703 width = "B";
4704 if ((psize < (kval * 10)) &&
4705 (0 != (psize % kval))) {
4706 scale = "";
4707 }
4708 else if ((psize < (mval * 10)) &&
4709 (0 != (psize % mval))){
4710 scale = "K";
4711 psize = psize / kval;
4712 }
4713 else {
4714 scale = "M";
4715 psize = psize / mval;
4716 }
4717 sprint_val (capac_buf, (t_value) psize, 10, T_ADDR_W, PV_LEFT);
4718 (void)sprintf (&capac_buf[strlen (capac_buf)], "%s%s", scale, width);
4719 return capac_buf;
4720 }
4721
4722 void fprint_capac (FILE *st, DEVICE *dptr, UNIT *uptr)
4723 {
4724 (void)fprintf (st, " %s", sprint_capac (dptr, uptr));
4725 }
4726
4727
4728
4729 extern void print_default_base_system_script (void);
4730 t_stat show_default_base_system_script (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4731 {
4732 #if !defined(PERF_STRIP)
4733 print_default_base_system_script();
4734 #endif
4735 return 0;
4736 }
4737
4738 static void printp (unsigned char * PROM, char * label, int offset, int length) {
4739 sim_printf (" %s ", label);
4740 sim_printf (" %2d %3o(8) '", length, offset);
4741 for (int l = 0; l < length; l ++)
4742 {
4743 unsigned int byte = PROM[offset + l];
4744 if (byte == 255)
4745 {
4746 byte = ' ';
4747 }
4748 sim_printf (isprint (byte) ? "%c" : "\\%03o", byte);
4749 }
4750 sim_printf ("'\r\n");
4751 }
4752
4753 static void strip_spaces(char* str) {
4754 int i, x;
4755 for (i=x=0; str[i]; ++i)
4756 {
4757 if (!isspace((int)str[i]) || (i > 0 && !isspace((int)str[(int)(i-1)])))
4758 {
4759 str[x++] = str[i];
4760 }
4761 }
4762 str[x] = '\0';
4763 i = -1;
4764 x = 0;
4765 while (str[x] != '\0')
4766 {
4767 if (str[x] != ' ' && str[x] != '\t' && str[x] != '\n')
4768 {
4769 i=x;
4770 }
4771 x++;
4772 }
4773 str[i+1] = '\0';
4774 }
4775
4776 static void printpq (unsigned char * PROM, FILE * st, int offset, int length) {
4777 char sx[1024];
4778 sx[1023] = '\0';
4779 unsigned int lastbyte = 0;
4780 for (int l = 0; l < length; l ++)
4781 {
4782 unsigned int byte = PROM[offset + l];
4783 if (byte == 255)
4784 {
4785 byte = 20;
4786 }
4787 if ((lastbyte != 20) && (byte != 20))
4788 {
4789 (void)sprintf(&sx[l], isprint (byte) ? "%c" : " ", byte);
4790 }
4791 lastbyte = byte;
4792 }
4793 strip_spaces(sx);
4794 (void)fprintf (st, "%s", sx);
4795 }
4796
4797 t_stat show_prom (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4798 {
4799 unsigned char PROM[1024];
4800 setupPROM (0, PROM);
4801
4802 sim_printf (" PROM size: %llu bytes\r\n",
4803 (long long unsigned)sizeof(PROM));
4804 sim_printf (" PROM initialization data:\r\n\r\n");
4805
4806 sim_printf (" Field Description Length Offset Contents\r\n");
4807 sim_printf (" ========================= ======== ======== ==================================\r\n");
4808 sim_printf ("\r\n");
4809
4810
4811
4812 printp (PROM, "CPU Model ", 0, 11);
4813 printp (PROM, "CPU Serial ", 11, 11);
4814 printp (PROM, "Ship Date ", 22, 6);
4815 printp (PROM, "PROM Layout Version ", 60, 1);
4816 printp (PROM, "Release Git Commit Date ", 70, 10);
4817 printp (PROM, "Release Major ", 80, 3);
4818 printp (PROM, "Release Minor ", 83, 3);
4819 printp (PROM, "Release Patch ", 86, 3);
4820 printp (PROM, "Release Iteration ", 89, 3);
4821 printp (PROM, "Release Build Number ", 92, 8);
4822 printp (PROM, "Release Type ", 100, 1);
4823 printp (PROM, "Release Version Text ", 101, 29);
4824 printp (PROM, "Build Architecture ", 130, 20);
4825 printp (PROM, "Build Operating System ", 150, 20);
4826 printp (PROM, "Target Architecture ", 170, 20);
4827 printp (PROM, "Target Operating System ", 190, 20);
4828
4829 sim_printf("\r\n");
4830 return 0;
4831 }
4832
4833 t_stat show_buildinfo (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4834 {
4835 (void)fprintf (st, "\r Build Information:\r\n");
4836 #if defined(BUILDINFO_scp)
4837 (void)fprintf (st, "\r\n Compilation info: %s\r\n", BUILDINFO_scp );
4838 #else
4839 (void)fprintf (st, "\r\n Compilation info: Not available\r\n" );
4840 #endif
4841 #if !defined(__CYGWIN__)
4842 # if !defined(__APPLE__)
4843 # if !defined(_AIX)
4844 # if !defined(__MINGW32__)
4845 # if !defined(__MINGW64__)
4846 # if !defined(CROSS_MINGW32)
4847 # if !defined(CROSS_MINGW64)
4848 # if !defined(_WIN32)
4849 # if !defined(__HAIKU__)
4850 # if !defined(__QNX__)
4851 (void)dl_iterate_phdr (dl_iterate_phdr_callback, NULL);
4852 if (dl_iterate_phdr_callback_called)
4853 (void)fprintf (st, "\r\n");
4854 dl_iterate_phdr_callback_called = 0;
4855 # endif
4856 # endif
4857 # endif
4858 # endif
4859 # endif
4860 # endif
4861 # endif
4862 # endif
4863 # endif
4864 #endif
4865 #if defined(UV_VERSION_MAJOR) && \
4866 defined(UV_VERSION_MINOR) && \
4867 defined(UV_VERSION_PATCH)
4868 # if defined(UV_VERSION_MAJOR)
4869 # if !defined(UV_VERSION_MINOR) && \
4870 !defined(UV_VERSION_PATCH) && \
4871 !defined(UV_VERSION_SUFFIX)
4872 (void)fprintf (st, "\r\n Event loop library: Built with libuv v%d", UV_VERSION_MAJOR);
4873 # endif
4874 # if defined(UV_VERSION_MINOR)
4875 # if !defined(UV_VERSION_PATCH) && !defined(UV_VERSION_SUFFIX)
4876 (void)fprintf (st, "\r\n Event loop library: Built with libuv %d.%d", UV_VERSION_MAJOR,
4877 UV_VERSION_MINOR);
4878 # endif
4879 # if defined(UV_VERSION_PATCH)
4880 # if !defined(UV_VERSION_SUFFIX)
4881 (void)fprintf (st, "\r\n Event loop library: Built with libuv %d.%d.%d", UV_VERSION_MAJOR,
4882 UV_VERSION_MINOR, UV_VERSION_PATCH);
4883 # endif
4884 # if defined(UV_VERSION_SUFFIX)
4885 (void)fprintf (st, "\r\n Event loop library: Built with libuv %d.%d.%d", UV_VERSION_MAJOR,
4886 UV_VERSION_MINOR, UV_VERSION_PATCH);
4887 # if defined(UV_VERSION_IS_RELEASE)
4888 # if UV_VERSION_IS_RELEASE == 1
4889 # define UV_RELEASE_TYPE " (release)"
4890 # endif
4891 # if UV_VERSION_IS_RELEASE == 0
4892 # define UV_RELEASE_TYPE "-dev"
4893 # endif
4894 # if !defined(UV_RELEASE_TYPE)
4895 # define UV_RELEASE_TYPE ""
4896 # endif
4897 # if defined(UV_RELEASE_TYPE)
4898 (void)fprintf (st, "%s", UV_RELEASE_TYPE);
4899 # endif
4900 # endif
4901 # endif
4902 # endif
4903 # endif
4904 unsigned int CurrentUvVersion = uv_version();
4905 if (CurrentUvVersion > 0)
4906 if (uv_version_string() != NULL)
4907 (void)fprintf (st, "; %s in use", uv_version_string());
4908 # endif
4909 #else
4910 (void)fprintf (st, "\r\n Event loop library: Using libuv (or compatible) library, unknown version");
4911 #endif
4912
4913
4914
4915 (void)fprintf (st, "\r\n Log support library: Built with libsir %d.%d.%d%s%s; %s%s in use",
4916 SIR_VERSION_MAJOR, SIR_VERSION_MINOR, SIR_VERSION_PATCH,
4917 SIR_VERSION_SUFFIX, SIR_VERSION_IS_RELEASE ? " (release)" : "",
4918 sir_getversionstring(), SIR_VERSION_IS_RELEASE ? "" : sir_isprerelease() ? "" : " (release)");
4919 #if defined(DECNUMBERLOC)
4920 # if defined(DECVERSION)
4921 # if defined(DECVERSEXT)
4922 (void)fprintf (st, "\r\n Math library: %s-%s", DECVERSION, DECVERSEXT);
4923 # else
4924 # if defined(DECNLAUTHOR)
4925 (void)fprintf (st, "\r\n Math library: %s (%s and contributors)", DECVERSION, DECNLAUTHOR);
4926 # else
4927 (void)fprintf (st, "\r\n Math library: %s", DECVERSION);
4928 # endif
4929 # endif
4930 # else
4931 (void)fprintf (st, "\r\n Math library: decNumber, unknown version");
4932 # endif
4933 #endif
4934 #if defined(LOCKLESS)
4935 (void)fprintf (st, "\r\n Atomic operations: ");
4936 # if defined(AIX_ATOMICS)
4937 (void)fprintf (st, "C11 and IBM AIX-style");
4938 # elif defined(BSD_ATOMICS)
4939 (void)fprintf (st, "C11 and FreeBSD-style");
4940 # elif defined(GNU_ATOMICS)
4941 (void)fprintf (st, "C11 and GNU-style");
4942 # elif defined(SYNC_ATOMICS)
4943 (void)fprintf (st, "C11 and GNU sync-style");
4944 # elif defined(ISO_ATOMICS)
4945 (void)fprintf (st, "ISO/IEC 9899:2011 (C11) standard");
4946 # elif defined(NT_ATOMICS)
4947 (void)fprintf (st, "C11 and Windows NT interlocked operations");
4948 # endif
4949 #endif
4950 (void)fprintf (st, "\r\n File locking: ");
4951 #if defined(USE_FCNTL) && defined(USE_FLOCK)
4952 (void)fprintf (st, "POSIX-style fcntl() and BSD-style flock() locking");
4953 #endif
4954 #if defined(USE_FCNTL) && !defined(USE_FLOCK)
4955 (void)fprintf (st, "POSIX-style fcntl() locking");
4956 #endif
4957 #if defined(USE_FLOCK) && !defined(USE_FCNTL)
4958 (void)fprintf (st, "BSD-style flock() locking");
4959 #endif
4960 #if !defined(USE_FLOCK) && !defined(USE_FCNTL)
4961 (void)fprintf (st, "No file locking available");
4962 #endif
4963 #if defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64) || defined(__CYGWIN__)
4964 (void)fprintf (st, "\r\n Windows support: ");
4965 #endif
4966 #if defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
4967 # if defined(__MINGW64_VERSION_STR)
4968 (void)fprintf (st, "Built with MinGW-w64 %s", __MINGW64_VERSION_STR);
4969 # elif defined(__MINGW32_MAJOR_VERSION) && defined(__MINGW32_MINOR_VERSION)
4970 (void)fprintf (st, "Built with MinGW %d.%d", __MINGW32_MAJOR_VERSION, __MINGW32_MINOR_VERSION);
4971 # else
4972 (void)fprintf (st, "Built with MinGW");
4973 # endif
4974
4975 # if defined(MINGW_CRT)
4976 (void)fprintf (st, "; %s", MINGW_CRT);
4977 # if !defined(_UCRT)
4978 # if defined(__MSVCRT_VERSION__)
4979 # if __MSVCRT_VERSION__ > 0x00
4980 (void)fprintf (st, " %d.%d", (__MSVCRT_VERSION__ >> CHAR_BIT) & UCHAR_MAX, __MSVCRT_VERSION__ & UCHAR_MAX);
4981 # endif
4982 # endif
4983 # else
4984
4985 struct UCRTVersion ucrtversion;
4986 int result = GetUCRTVersion (&ucrtversion);
4987
4988 if (result == 0)
4989 (void)fprintf (st, " %u.%u.%u.%u",
4990 ucrtversion.ProductVersion[1], ucrtversion.ProductVersion[0],
4991 ucrtversion.ProductVersion[3], ucrtversion.ProductVersion[2]);
4992 # endif
4993 (void)fprintf (st, " in use");
4994 # endif
4995 #elif defined(__CYGWIN__)
4996 struct utsname utsname;
4997 (void)fprintf (st, "Built with Cygwin %d.%d.%d",
4998 CYGWIN_VERSION_DLL_MAJOR / 1000,
4999 CYGWIN_VERSION_DLL_MAJOR % 1000,
5000 CYGWIN_VERSION_DLL_MINOR);
5001 if (uname(&utsname) == 0)
5002 fprintf (st, "; %s in use", utsname.release);
5003 #endif
5004
5005 (void)fprintf (st, "\r\n");
5006 return 0;
5007 }
5008
5009 t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5010 {
5011 const char *arch = "";
5012 char *whydirty = " ";
5013 int dirty = 0;
5014
5015 if (cptr && (*cptr != 0))
5016 return SCPE_2MARG;
5017 if (flag) {
5018 (void)fprintf (st, " %s Simulator:", sim_name);
5019 #if defined(USE_DUMA)
5020 # undef NO_SUPPORT_VERSION
5021 # define NO_SUPPORT_VERSION 1
5022 nodist++;
5023 #endif
5024 #if defined(NO_SUPPORT_VERSION) || \
5025 defined(WITH_SOCKET_DEV) || \
5026 defined(WITH_ABSI_DEV) || \
5027 defined(WITH_MGP_DEV) || \
5028 defined(TESTING) || \
5029 defined(ISOLTS) || \
5030 defined(USE_DUMA)
5031 # if !defined(NO_SUPPORT_VERSION)
5032 # define NO_SUPPORT_VERSION 1
5033 # endif
5034 #endif
5035 #if defined(NO_SUPPORT_VERSION)
5036 dirty++;
5037 #endif
5038 #if defined(GENERATED_MAKE_VER_H)
5039 # if defined(VER_H_GIT_VERSION)
5040
5041
5042 if (strstr(VER_H_GIT_VERSION, "*"))
5043 {
5044 dirty++;
5045 }
5046
5047
5048 if ((strstr(VER_H_GIT_VERSION, "X")) || \
5049 (strstr(VER_H_GIT_VERSION, "D")) || \
5050 (strstr(VER_H_GIT_VERSION, "A")) || \
5051 (strstr(VER_H_GIT_VERSION, "B")))
5052 {
5053 dirty++;
5054 }
5055
5056
5057 if (dirty)
5058 {
5059 if ((strstr(VER_H_GIT_VERSION, "X")))
5060 {
5061 whydirty = " ";
5062 }
5063 else if ((strstr(VER_H_GIT_VERSION, "D")))
5064 {
5065 whydirty = " DEV ";
5066 }
5067 else if ((strstr(VER_H_GIT_VERSION, "A")))
5068 {
5069 whydirty = " ALPHA ";
5070 }
5071 else if ((strstr(VER_H_GIT_VERSION, "B")))
5072 {
5073 whydirty = " BETA ";
5074 }
5075 }
5076
5077 # if defined(VER_H_GIT_PATCH) && defined(VER_H_GIT_PATCH_INT)
5078 # if defined(VER_H_GIT_HASH)
5079 # if VER_H_GIT_PATCH_INT < 1
5080 (void)fprintf (st, "\r\n Version: %s (%ld-bit)\r\n Commit: %s",
5081 VER_H_GIT_VERSION,
5082 (long)(CHAR_BIT*sizeof(void *)),
5083 VER_H_GIT_HASH);
5084 # else
5085 # define NO_SUPPORT_VERSION 1
5086 (void)fprintf (st, "\r\n Version: %s+%s (%ld-bit)\r\n Commit: %s",
5087 VER_H_GIT_VERSION, VER_H_GIT_PATCH,
5088 (long)(CHAR_BIT*sizeof(void *)),
5089 VER_H_GIT_HASH);
5090 # endif
5091 # else
5092 # if VER_H_GIT_PATCH_INT < 1
5093 (void)fprintf (st, "\r\n Version: %s (%ld-bit)",
5094 VER_H_GIT_VERSION,
5095 (long)(CHAR_BIT*sizeof(void *)));
5096 # else
5097 # define NO_SUPPORT_VERSION 1
5098 (void)fprintf (st, "\r\n Version: %s+%s (%ld-bit)",
5099 VER_H_GIT_VERSION, VER_H_GIT_PATCH,
5100 (long)(CHAR_BIT*sizeof(void *)));
5101 # endif
5102 # endif
5103 # else
5104 # if defined(VER_H_GIT_HASH)
5105 (void)fprintf (st, "\r\n Version: %s (%ld-bit)\r\n Commit: %s",
5106 VER_H_GIT_VERSION,
5107 (long)(CHAR_BIT*sizeof(void *)),
5108 VER_H_GIT_HASH);
5109 # else
5110 (void)fprintf (st, "\r\n Version: %s (%ld-bit)",
5111 VER_H_GIT_VERSION,
5112 (long)(CHAR_BIT*sizeof(void *)));
5113 # endif
5114 # endif
5115 # endif
5116 #endif
5117
5118
5119 #if defined(TESTING)
5120 (void)fprintf (st, "\r\n Options: ");
5121 # if !defined(HAVE_DPSOPT)
5122 # define HAVE_DPSOPT 1
5123 # endif
5124 (void)fprintf (st, "TESTING");
5125 #endif
5126
5127
5128 #if defined(ISOLTS)
5129 # if defined(HAVE_DPSOPT)
5130 (void)fprintf (st, ", ");
5131 # else
5132 (void)fprintf (st, "\r\n Options: ");
5133 # endif
5134 # if !defined(HAVE_DPSOPT)
5135 # define HAVE_DPSOPT 1
5136 # endif
5137 (void)fprintf (st, "ISOLTS");
5138 #endif
5139
5140
5141 #if defined(NEED_128)
5142 # if defined(HAVE_DPSOPT)
5143 (void)fprintf (st, ", ");
5144 # else
5145 (void)fprintf (st, "\r\n Options: ");
5146 # endif
5147 # if !defined(HAVE_DPSOPT)
5148 # define HAVE_DPSOPT 1
5149 # endif
5150 (void)fprintf (st, "NEED_128");
5151 #endif
5152
5153
5154 #if defined(WAM)
5155 # if defined(HAVE_DPSOPT)
5156 (void)fprintf (st, ", ");
5157 # else
5158 (void)fprintf (st, "\r\n Options: ");
5159 # endif
5160 # if !defined(HAVE_DPSOPT)
5161 # define HAVE_DPSOPT 1
5162 # endif
5163 (void)fprintf (st, "WAM");
5164 #endif
5165
5166
5167 #if defined(ROUND_ROBIN)
5168 # if defined(HAVE_DPSOPT)
5169 (void)fprintf (st, ", ");
5170 # else
5171 (void)fprintf (st, "\r\n Options: ");
5172 # endif
5173 # if !defined(HAVE_DPSOPT)
5174 # define HAVE_DPSOPT 1
5175 # endif
5176 (void)fprintf (st, "ROUND_ROBIN");
5177 #endif
5178
5179
5180 #if !defined(LOCKLESS)
5181 # if defined(HAVE_DPSOPT)
5182 (void)fprintf (st, ", ");
5183 # else
5184 (void)fprintf (st, "\r\n Options: ");
5185 # endif
5186 # if !defined(HAVE_DPSOPT)
5187 # define HAVE_DPSOPT 1
5188 # endif
5189 (void)fprintf (st, "NO_LOCKLESS");
5190 #endif
5191
5192
5193 #if defined(PANEL68)
5194 # if defined(HAVE_DPSOPT)
5195 (void)fprintf (st, ", ");
5196 # else
5197 (void)fprintf (st, "\r\n Options: ");
5198 # endif
5199 # if !defined(HAVE_DPSOPT)
5200 # define HAVE_DPSOPT 1
5201 # endif
5202 (void)fprintf (st, "PANEL68");
5203 #endif
5204
5205
5206 #if defined(WITH_ABSI_DEV)
5207 # if defined(HAVE_DPSOPT)
5208 (void)fprintf (st, ", ");
5209 # else
5210 (void)fprintf (st, "\r\n Options: ");
5211 # endif
5212 # if !defined(HAVE_DPSOPT)
5213 # define HAVE_DPSOPT 1
5214 # endif
5215 (void)fprintf (st, "ABSI");
5216 #endif
5217
5218
5219 #if defined(WITH_SOCKET_DEV)
5220 # if defined(HAVE_DPSOPT)
5221 (void)fprintf (st, ", ");
5222 # else
5223 (void)fprintf (st, "\r\n Options: ");
5224 # endif
5225 # if !defined(HAVE_DPSOPT)
5226 # define HAVE_DPSOPT 1
5227 # endif
5228 (void)fprintf (st, "SOCKET");
5229 #endif
5230
5231
5232 #if defined(WITH_MGP_DEV)
5233 # if defined(HAVE_DPSOPT)
5234 (void)fprintf (st, ", ");
5235 # else
5236 (void)fprintf (st, "\r\n Options: ");
5237 # endif
5238 # if !defined(HAVE_DPSOPT)
5239 # define HAVE_DPSOPT 1
5240 # endif
5241 (void)fprintf (st, "CHAOSNET");
5242 # if USE_SOCKET_DEV_APPROACH
5243 (void)fprintf (st, "-S");
5244 # endif
5245 #endif
5246
5247
5248 #if defined(USE_DUMA)
5249 # if defined(HAVE_DPSOPT)
5250 (void)fprintf (st, ", ");
5251 # else
5252 (void)fprintf (st, "\r\n Options: ");
5253 # endif
5254 # if !defined(HAVE_DPSOPT)
5255 # define HAVE_DPSOPT 1
5256 # endif
5257 (void)fprintf (st, "DUMA");
5258 #endif
5259
5260 #if defined(GENERATED_MAKE_VER_H) && defined(VER_H_GIT_DATE)
5261 # if defined(NO_SUPPORT_VERSION)
5262 (void)fprintf (st, "\r\n Modified: %s", VER_H_GIT_DATE);
5263 # else
5264 (void)fprintf (st, "\r\n Released: %s", VER_H_GIT_DATE);
5265 # endif
5266 #endif
5267 #if defined(GENERATED_MAKE_VER_H) && defined(VER_H_GIT_DATE) && defined(VER_H_PREP_DATE)
5268 (void)fprintf (st, " - Kit Prepared: %s", VER_H_PREP_DATE);
5269 #endif
5270 #if defined(VER_CURRENT_TIME)
5271 (void)fprintf (st, "\r\n Compiled: %s", VER_CURRENT_TIME);
5272 #endif
5273 if (dirty)
5274 {
5275 (void)fprintf (st, "\r\n\r\n ****** THIS%sBUILD IS NOT SUPPORTED BY THE DPS8M DEVELOPMENT TEAM ******", whydirty);
5276 }
5277 (void)fprintf (st, "\r\n\r\n Build Information:");
5278 #if defined(BUILD_PROM_OSV_TEXT) && defined(BUILD_PROM_OSA_TEXT)
5279 char build_os_version_raw[255];
5280 char build_os_arch_raw[255];
5281 (void)sprintf(build_os_version_raw, "%.254s", BUILD_PROM_OSV_TEXT);
5282 (void)sprintf(build_os_arch_raw, "%.254s", BUILD_PROM_OSA_TEXT);
5283 char *build_os_version = strdup(build_os_version_raw);
5284 if (!build_os_version)
5285 {
5286 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
5287 __func__, __FILE__, __LINE__);
5288 # if defined(USE_BACKTRACE)
5289 # if defined(SIGUSR2)
5290 (void)raise(SIGUSR2);
5291
5292 # endif
5293 # endif
5294 abort();
5295 }
5296 char *build_os_arch = strdup(build_os_arch_raw);
5297 if (!build_os_arch)
5298 {
5299 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
5300 __func__, __FILE__, __LINE__);
5301 # if defined(USE_BACKTRACE)
5302 # if defined(SIGUSR2)
5303 (void)raise(SIGUSR2);
5304
5305 # endif
5306 # endif
5307 abort();
5308 }
5309 unsigned char SPROM[1024];
5310 setupPROM (0, SPROM);
5311 (void)fprintf (st, "\r\n Target: ");
5312 printpq (SPROM, st, 190, 20);
5313 if (SPROM[170] != 20)
5314 {
5315 if (SPROM[170] != 255)
5316 {
5317 (void)fprintf (st, " on ");
5318 printpq (SPROM, st, 170, 20);
5319 }
5320 }
5321 strtrimspace(build_os_version, build_os_version_raw);
5322 strtrimspace(build_os_arch, build_os_arch_raw);
5323 (void)fprintf (st, "\r\n Build OS: %s %s", build_os_version, build_os_arch);
5324 FREE(build_os_version);
5325 FREE(build_os_arch);
5326 #endif
5327 #if defined(__VERSION__)
5328 char gnumver[2];
5329 char postver[1024];
5330 (void)sprintf(gnumver, "%.1s", __VERSION__);
5331 (void)sprintf(postver, "%.1023s", __VERSION__);
5332 strremove(postver, "(TM)");
5333 strremove(postver, "(R)");
5334 strremove(postver, "git://github.com/OpenIndiana/oi-userland.git ");
5335 strremove(postver, "https://github.com/OpenIndiana/oi-userland.git ");
5336 strremove(postver, " gcc 4.9 mode");
5337 strremove(postver, "4.2.1 Compatible ");
5338 strremove(postver, "git@github.com:llvm/llvm-project.git ");
5339 strremove(postver, "https://github.com/llvm/llvm-project.git ");
5340 strremove(postver, " (https://github.com/yrnkrn/zapcc)");
5341 strremove(postver, "https://github.com/yrnkrn/zapcc ");
5342 strremove(postver, "(experimental) ");
5343 strremove(postver, ".module+el8.7.0+20823+214a699d");
5344 strremove(postver, "17.1.1 (5725-C72, 5765-J20), version ");
5345 strremove(postver, "17.1.1 (5725-C72, 5765-J18), version ");
5346 strremove(postver, "17.1.2 (5725-C72, 5765-J20), version ");
5347 strremove(postver, "17.1.2 (5725-C72, 5765-J18), version ");
5348 strremove(postver, "llvmorg-16.0.6-0-");
5349 strremove(postver, " Clang 15.0.0 (build 760095e)");
5350 strremove(postver, " Clang 15.0.0 (build 6af5742)");
5351 strremove(postver, " Clang 15.0.0 (build ca7115e)");
5352 strremove(postver, " Clang 15.0.0 (build 232543c)");
5353 strremove(postver, " Clang 17.0.6 (build 19a779f)");
5354 strremove(postver, "CLANG: ");
5355 #endif
5356 #if ( defined(__GNUC__) && defined(__VERSION__) ) && !defined(__EDG__)
5357 # if !defined(__clang_version__)
5358 if (isdigit((unsigned char)gnumver[0])) {
5359 (void)fprintf (st, "\r\n Compiler: GCC %s", postver);
5360 } else {
5361 (void)fprintf (st, "\r\n Compiler: %s", postver);
5362 }
5363 # endif
5364 # if defined(__clang_analyzer__ )
5365 (void)fprintf (st, "\r\n Compiler: Clang C/C++ Static Analyzer");
5366 # elif defined(__clang_version__) && defined(__VERSION__)
5367 char clangllvmver[1024];
5368 (void)sprintf(clangllvmver, "%.1023s", __clang_version__);
5369 strremove(clangllvmver, "git://github.com/OpenIndiana/oi-userland.git ");
5370 strremove(clangllvmver, "https://github.com/OpenIndiana/oi-userland.git ");
5371 strremove(clangllvmver, "https://github.com/llvm/llvm-project.git ");
5372 strremove(clangllvmver, "c13b7485b87909fcf739f62cfa382b55407433c0");
5373 strremove(clangllvmver, "e6c3289804a67ea0bb6a86fadbe454dd93b8d855");
5374 strremove(clangllvmver, "https://github.com/llvm/llvm-project.git");
5375 strremove(clangllvmver, " ( )");
5376 strremove(clangllvmver, " ()");
5377 if (gnumver[0] == 'c' || gnumver[0] == 'C') {
5378 (void)fprintf (st, "\r\n Compiler: Clang %s", clangllvmver);
5379 } else {
5380 (void)fprintf (st, "\r\n Compiler: %s", postver);
5381 }
5382 # elif defined(__clang_version__)
5383 (void)fprintf (st, "\r\n Compiler: %s", postver);
5384 # endif
5385 #elif defined(__PGI) && !defined(__NVCOMPILER)
5386 (void)fprintf (st, "\r\n Compiler: Portland Group, Inc. (PGI) C Compiler ");
5387 # if defined(__PGIC__)
5388 (void)fprintf (st, "%d", __PGIC__);
5389 # if defined(__PGIC_MINOR__)
5390 (void)fprintf (st, ".%d", __PGIC_MINOR__);
5391 # if defined(__PGIC_PATCHLEVEL__)
5392 (void)fprintf (st, ".%d", __PGIC_PATCHLEVEL__);
5393 # endif
5394 # endif
5395 # endif
5396 #elif defined(__NVCOMPILER)
5397 (void)fprintf (st, "\r\n Compiler: NVIDIA HPC SDK C Compiler ");
5398 # if defined(__NVCOMPILER_MAJOR__)
5399 (void)fprintf (st, "%d", __NVCOMPILER_MAJOR__);
5400 # if defined(__NVCOMPILER_MINOR__)
5401 (void)fprintf (st, ".%d", __NVCOMPILER_MINOR__);
5402 # if defined(__NVCOMPILER_PATCHLEVEL__)
5403 (void)fprintf (st, ".%d", __NVCOMPILER_PATCHLEVEL__);
5404 # endif
5405 # endif
5406 # endif
5407 #elif defined(_MSC_FULL_VER) && defined(_MSC_BUILD)
5408 (void)fprintf (st, "\r\n Compiler: Microsoft C %d.%02d.%05d.%02d",
5409 _MSC_FULL_VER/10000000,
5410 (_MSC_FULL_VER/100000)%100,
5411 _MSC_FULL_VER%100000,
5412 _MSC_BUILD);
5413 #elif ( defined(__xlc__) && !defined(__clang_version__) )
5414 # if defined(_AIX) && defined(__PASE__)
5415 (void)fprintf (st, "\r\n Compiler: IBM XL C/C++ V%s (PASE for IBM i)", __xlc__);
5416 # endif
5417 # if defined(_AIX) && !defined(__PASE__)
5418 (void)fprintf (st, "\r\n Compiler: IBM XL C/C++ for AIX V%s", __xlc__);
5419 # endif
5420 # if defined(__linux__) && ( !defined(_AIX) || !defined(__PASE__) )
5421 (void)fprintf (st, "\r\n Compiler: IBM XL C/C++ for Linux V%s", __xlc__);
5422 # endif
5423 # if ( !defined(_AIX) && !defined(__clang_version__) && !defined(__PASE__) && !defined(__linux__) && defined(__xlc__) )
5424 # if defined(__PPC__) && defined(__APPLE__)
5425 (void)fprintf (st, "\r\n Compiler: IBM XL C/C++ V%s for Mac OS X", __xlc__);
5426 # else
5427 (void)fprintf (st, "\r\n Compiler: IBM XL C/C++ V%s", __xlc__);
5428 # endif
5429 # endif
5430 #elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) || defined(__SUNPRO_CC_COMPAT)
5431 # define VER_ENC(maj, min, rev) \
5432 (((maj) * 1000000) + ((min) * 1000) + (rev))
5433 # define VER_DEC_MAJ(ver) \
5434 ((ver) / 1000000)
5435 # define VER_DEC_MIN(ver) \
5436 (((ver) % 1000000) / 1000)
5437 # define VER_DEC_REV(ver) \
5438 ((ver) % 1000)
5439 # if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
5440 # define COMP_VER VER_ENC( \
5441 (((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), \
5442 (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), \
5443 (__SUNPRO_C & 0xf) * 10)
5444 # elif defined(__SUNPRO_C)
5445 # define COMP_VER VER_ENC( \
5446 (__SUNPRO_C >> 8) & 0xf, \
5447 (__SUNPRO_C >> 4) & 0xf, \
5448 (__SUNPRO_C) & 0xf)
5449 # elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
5450 # define COMP_VER VER_ENC( \
5451 (((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), \
5452 (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), \
5453 (__SUNPRO_CC & 0xf) * 10)
5454 # elif defined(__SUNPRO_CC)
5455 # define COMP_VER VER_ENC( \
5456 (__SUNPRO_CC >> 8) & 0xf, \
5457 (__SUNPRO_CC >> 4) & 0xf, \
5458 (__SUNPRO_CC) & 0xf)
5459 # endif
5460 # if !defined(COMP_VER)
5461 # define COMP_VER 0
5462 # endif
5463 (void)fprintf (st, "\r\n Compiler: Oracle Developer Studio C/C++ %d.%d.%d",
5464 VER_DEC_MAJ(COMP_VER),
5465 VER_DEC_MIN(COMP_VER),
5466 VER_DEC_REV(COMP_VER));
5467 #elif defined(__DMC__)
5468 (void)fprintf (st, "\r\n Compiler: Digital Mars C/C++");
5469 #elif defined(__PCC__)
5470 (void)fprintf (st, "\r\n Compiler: Portable C Compiler");
5471 #elif defined(KENC) || defined(KENCC) || defined(__KENC__) || defined(__KENCC__)
5472 (void)fprintf (st, "\r\n Compiler: Plan 9 Compiler Suite");
5473 #elif defined(__ACK__)
5474 (void)fprintf (st, "\r\n Compiler: Amsterdam Compiler Kit");
5475 #elif defined(__COMO__)
5476 (void)fprintf (st, "\r\n Compiler: Comeau C++");
5477 #elif defined(__COMPCERT__)
5478 (void)fprintf (st, "\r\n Compiler: CompCert C");
5479 #elif defined(__COVERITY__)
5480 (void)fprintf (st, "\r\n Compiler: Coverity C/C++ Static Analyzer");
5481 #elif defined(__LCC__)
5482 # if defined(__e2k__) || defined(__e2k64__) || defined(__elbrus__) || defined(__ELBRUS__) || defined(__elbrus64__) || defined(__E2K__)
5483 (void)fprintf (st, "\r\n Compiler: MCST Elbrus C Compiler");
5484 # if __LCC__ > 99
5485 (void)fprintf(st, " - LCC %1.2f", (double)(__LCC__) / (double)100);
5486 # if defined(__LCC_MINOR__)
5487 # if __LCC_MINOR__ > 0
5488 (void)fprintf(st, ".%02ld", (long)(__LCC_MINOR__));
5489 # endif
5490 # endif
5491 # endif
5492 # if defined(__EDG__) && defined(__EDG_VERSION__)
5493 # if __EDG_VERSION__ > 99
5494 (void)fprintf(st, " - EDG %d.%d", (int)((__EDG_VERSION__) / 100),
5495 (int)(((__EDG_VERSION__) % 100) % 10));
5496 # endif
5497 # endif
5498 # else
5499 (void)fprintf (st, "\r\n Compiler: Local/Little C Compiler (lcc)");
5500 # endif
5501 #elif defined(sgi) || defined(__sgi) || defined(_sgi) || defined(_SGI_COMPILER_VERSION)
5502 (void)fprintf (st, "\r\n Compiler: SGI MIPSpro");
5503 #elif defined(__OPEN64__)
5504 (void)fprintf (st, "\r\n Compiler: Open64 %s", __OPEN64__);
5505 #elif defined(__PGI) || defined(__PGIC__)
5506 (void)fprintf (st, "\r\n Compiler: Portland Group/PGI C/C++");
5507 #elif defined(__VBCC__)
5508 (void)fprintf (st, "\r\n Compiler: Volker Barthelmann C Compiler (vbcc)");
5509 #elif defined(__WATCOMC__)
5510 (void)fprintf (st, "\r\n Compiler: Watcom C/C++ %d.%d",
5511 __WATCOMC__ / 100,
5512 __WATCOMC__ % 100);
5513 #elif defined(__xlC__)
5514 (void)fprintf (st, "\r\n Compiler: IBM XL C/C++");
5515 #elif defined(__INTEL_COMPILER) || defined(__ICC)
5516 # if defined(__INTEL_COMPILER_UPDATE)
5517 # if defined(__INTEL_COMPILER_BUILD_DATE)
5518 (void)fprintf (st, "\r\n Compiler: Intel C++ Compiler %d.%d (%d)",
5519 __INTEL_COMPILER, __INTEL_COMPILER_UPDATE,
5520 __INTEL_COMPILER_BUILD_DATE);
5521 # else
5522 (void)fprintf (st, "\r\n Compiler: Intel C++ Compiler %d.%d",
5523 __INTEL_COMPILER, __INTEL_COMPILER_UPDATE);
5524 # endif
5525 # else
5526 (void)fprintf (st, "\r\n Compiler: Intel C++ Compiler %d",
5527 __INTEL_COMPILER);
5528 # endif
5529 #elif defined(SIM_COMPILER)
5530 # define S_xstr(a) S_str(a)
5531 # define S_str(a) #a
5532 (void)fprintf (st, "\r\n Compiler: %s", S_xstr(SIM_COMPILER));
5533 # undef S_str
5534 # undef S_xstr
5535 #else
5536 (void)fprintf (st, "\r\n Compiler: Unknown");
5537 #endif
5538
5539 #if defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__) || defined(__powerpc64__) || \
5540 defined(__POWERPC64__) || defined(_M_PPC64) || defined(__PPC64) || defined(_ARCH_PPC64)
5541 # define SC_IS_PPC64 1
5542 #else
5543 # define SC_IS_PPC64 0
5544 #endif
5545
5546 #if defined(__ppc__) || defined(__PPC__) || defined(__powerpc__) || defined(__POWERPC__) || defined(_M_PPC) || defined(__PPC) || \
5547 defined(__ppc32__) || defined(__PPC32__) || defined(__powerpc32__) || defined(__POWERPC32__) || defined(_M_PPC32) || \
5548 defined(__PPC32)
5549 # define SC_IS_PPC32 1
5550 #else
5551 # define SC_IS_PPC32 0
5552 #endif
5553
5554 #if defined(_M_X64) || defined(_M_AMD64) || defined(__amd64__) || defined(__x86_64__) || defined(__AMD64)
5555 arch = " x86_64";
5556 #elif defined(_M_IX86) || defined(__i386) || defined(__i486) || defined(__i586) || defined(__i686) || defined(__ix86)
5557 arch = " x86";
5558 #elif defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__)
5559 arch = " arm64";
5560 #elif defined(_M_ARM) || defined(__arm__)
5561 arch = " arm";
5562 #elif defined(__ia64__) || defined(_M_IA64) || defined(__itanium__)
5563 arch = " ia64";
5564 #elif SC_IS_PPC64
5565 arch = " powerpc64";
5566 #elif SC_IS_PPC32
5567 arch = " powerpc";
5568 #elif defined(__s390x__)
5569 arch = " s390x";
5570 #elif defined(__s390__)
5571 arch = " s390";
5572 #elif defined(__J2__) || defined(__J2P__) || defined(__j2__) || defined(__j2p__)
5573 arch = " j2";
5574 #elif defined(__SH4__) || defined(__sh4__) || defined(__SH4) || defined(__sh4)
5575 arch = " sh4";
5576 #elif defined(__SH2__) || defined(__sh2__) || defined(__SH2) || defined(__sh2)
5577 arch = " sh2";
5578 #elif defined(__alpha__)
5579 arch = " alpha";
5580 #elif defined(__hppa__) || defined(__HPPA__) || defined(__PARISC__) || defined(__parisc__)
5581 arch = " hppa";
5582 #elif defined(__ICE9__) || defined(__ice9__) || defined(__ICE9) || defined(__ice9)
5583 arch = " ice9";
5584 #elif defined(mips64) || defined(__mips64__) || defined(MIPS64) || defined(_MIPS64_) || defined(__mips64)
5585 arch = " mips64";
5586 #elif defined(mips) || defined(__mips__) || defined(MIPS) || defined(_MIPS_) || defined(__mips)
5587 arch = " mips";
5588 #elif defined(__OpenRISC__) || defined(__OPENRISC__) || defined(__openrisc__) || \
5589 defined(__OR1K__) || defined(__JOR1K__) || defined(__OPENRISC1K__) || defined(__OPENRISC1200__)
5590 arch = " openrisc";
5591 #elif defined(__sparc64) || defined(__SPARC64) || defined(__SPARC64__) || defined(__sparc64__)
5592 arch = " sparc64";
5593 #elif defined(__sparc) || defined(__SPARC) || defined(__SPARC__) || defined(__sparc__)
5594 arch = " sparc";
5595 #elif defined(__riscv) || defined(__riscv__)
5596 arch = " riscv";
5597 #elif defined(__e2k__) || defined(__E2K__) || defined(__elbrus64__) || defined(__elbrus__) || defined(__ELBRUS__)
5598 arch = " e2k";
5599 #elif defined(__myriad2__)
5600 arch = " myriad2";
5601 #elif defined(__loongarch64) || defined(__loongarch__)
5602 arch = " loongarch";
5603 #elif defined(_m68851) || defined(__m68k__) || defined(__m68000__) || defined(__M68K)
5604 arch = " m68k";
5605 #elif defined(__m88k__) || defined(__m88000__) || defined(__M88K)
5606 arch = " m88k";
5607 #elif defined(__VAX__) || defined(__vax__)
5608 arch = " vax";
5609 #elif defined(__NIOS2__) || defined(__nios2__)
5610 arch = " nios2";
5611 #elif defined(__MICROBLAZE__) || defined(__microblaze__)
5612 arch = " microblaze";
5613 #else
5614 arch = " ";
5615 #endif
5616 (void)fprintf (st, "%s", arch);
5617 #if defined(BUILD_BY_USER)
5618 (void)fprintf (st, "\r\n Built by: %s", BUILD_BY_USER);
5619 #else
5620 # if defined(GENERATED_MAKE_VER_H) && defined(VER_H_PREP_USER)
5621 (void)fprintf (st, "\r\n Built by: %s", VER_H_PREP_USER);
5622 # endif
5623 #endif
5624 (void)fprintf (st, "\r\n\r\n Host System Information:");
5625 #if defined(_WIN32)
5626 if (1) {
5627 char *arch = getenv ("PROCESSOR_ARCHITECTURE");
5628 char *proc_arch3264 = getenv ("PROCESSOR_ARCHITEW6432");
5629 char osversion[PATH_MAX+1] = "";
5630 FILE *f;
5631
5632 if ((f = _popen ("ver", "r"))) {
5633 (void)memset (osversion, 0, sizeof(osversion));
5634 do {
5635 if (NULL == fgets (osversion, sizeof(osversion)-1, f))
5636 break;
5637 sim_trim_endspc (osversion);
5638 } while (osversion[0] == '\0');
5639 _pclose (f);
5640 }
5641 (void)fprintf (st, "\r\n Host OS: %s", osversion);
5642 (void)fprintf (st, " %s%s%s", arch, proc_arch3264 ? " on " : "", proc_arch3264 ? proc_arch3264 : "");
5643 }
5644 #else
5645 if (1) {
5646 char osversion[2*PATH_MAX+1] = "";
5647 FILE *f;
5648 # if !defined(_AIX)
5649 if ((f = popen \
5650 ("uname -mrs 2> /dev/null", "r"))) {
5651 # else
5652 if ((f = popen \
5653 ("sh -c 'echo \"$(command -p env uname -v \
5654 2> /dev/null).$(command -p env uname -r \
5655 2> /dev/null) $(command -p env uname -p \
5656 2> /dev/null)\"' 2> /dev/null", "r"))) {
5657 # endif
5658 (void)memset (osversion, 0, sizeof(osversion));
5659 do {
5660 if (NULL == fgets (osversion, sizeof(osversion)-1, f)) {
5661 break;
5662 }
5663 sim_trim_endspc (osversion);
5664 } while (osversion[0] == '\0');
5665 pclose (f);
5666 strremove(osversion, "0000000000000000 ");
5667 strremove(osversion, " 0000000000000000");
5668 strremove(osversion, "000000000000 ");
5669 strremove(osversion, " 000000000000");
5670 strremove(osversion, "IBM ");
5671 strremove(osversion, " (emulated by qemu)");
5672 strremove(osversion, " (emulated by QEMU)");
5673 }
5674 # if !defined(_AIX)
5675 (void)fprintf (st, "\r\n Host OS: %s", osversion);
5676 # else
5677 strremove(osversion, "AIX ");
5678 # if !defined(__PASE__)
5679 (void)fprintf (st, "\r\n Host OS: IBM AIX %s", osversion);
5680 # else
5681 (void)fprintf (st, "\r\n Host OS: IBM OS/400 (PASE) %s", osversion);
5682 # endif
5683 # endif
5684 } else {
5685 # if !defined(_AIX)
5686 (void)fprintf (st, "\r\n Host OS: Unknown");
5687 # else
5688 # if !defined(__PASE__)
5689 (void)fprintf (st, "\r\n Host OS: IBM AIX");
5690 # else
5691 (void)fprintf (st, "\r\n Host OS: IBM OS/400 (PASE)");
5692 # endif
5693 # endif
5694 }
5695 #endif
5696 if (nodist)
5697 {
5698 sim_printf ("\r\n\r\n ********* LICENSE RESTRICTED BUILD *** NOT FOR REDISTRIBUTION *********\r\n");
5699 }
5700 else
5701 {
5702 (void)fprintf (st, "\r\n");
5703 (void)fprintf (st, "\r\n This software is made available under the terms of the ICU License.");
5704 (void)fprintf (st, "\r\n For complete license details, see the LICENSE file included with the");
5705 (void)fprintf (st, "\r\n software or https://gitlab.com/dps8m/dps8m/-/blob/master/LICENSE.md");
5706 }
5707 (void)fprintf (st, "\r\n");
5708 }
5709 return SCPE_OK;
5710 }
5711
5712 t_stat show_config (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5713 {
5714 size_t i;
5715 DEVICE *dptr;
5716 t_bool only_enabled = (sim_switches & SWMASK ('E'));
5717
5718 if (cptr && (*cptr != 0))
5719 return SCPE_2MARG;
5720 (void)fprintf (st, "%s simulator configuration%s\r\n\r\n", sim_name, only_enabled ? " (enabled devices)" : "");
5721 for (i = 0; (dptr = sim_devices[i]) != NULL; i++)
5722 if (!only_enabled || !qdisable (dptr))
5723 show_device (st, dptr, flag);
5724 return SCPE_OK;
5725 }
5726
5727 t_stat show_log_names (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5728 {
5729 int32 i;
5730 DEVICE *dptr;
5731
5732 if (cptr && (*cptr != 0))
5733 return SCPE_2MARG;
5734 for (i = 0; (dptr = sim_devices[i]) != NULL; i++)
5735 show_dev_logicals (st, dptr, NULL, 1, cptr);
5736 return SCPE_OK;
5737 }
5738
5739 t_stat show_dev_logicals (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5740 {
5741 if (dptr->lname)
5742 (void)fprintf (st, "%s -> %s\r\n", dptr->lname, dptr->name);
5743 else if (!flag)
5744 fputs ("no logical name assigned\r\n", st);
5745 return SCPE_OK;
5746 }
5747
5748 t_stat show_queue (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5749 {
5750 DEVICE *dptr;
5751 UNIT *uptr;
5752 int32 accum;
5753
5754 if (cptr && (*cptr != 0))
5755 return SCPE_2MARG;
5756 if (sim_clock_queue == QUEUE_LIST_END)
5757 (void)fprintf (st, "%s event queue empty, time = %.0f, executing %.0f instructions/sec\r\n",
5758 sim_name, sim_time, sim_timer_inst_per_sec ());
5759 else {
5760 const char *tim;
5761
5762 (void)fprintf (st, "%s event queue status, time = %.0f, executing %.0f instructions/sec\r\n",
5763 sim_name, sim_time, sim_timer_inst_per_sec ());
5764 accum = 0;
5765 for (uptr = sim_clock_queue; uptr != QUEUE_LIST_END; uptr = uptr->next) {
5766 if (uptr == &sim_step_unit)
5767 (void)fprintf (st, " Step timer");
5768 else
5769 if (uptr == &sim_expect_unit)
5770 (void)fprintf (st, " Expect fired");
5771 else
5772 if ((dptr = find_dev_from_unit (uptr)) != NULL) {
5773 (void)fprintf (st, " %s", sim_dname (dptr));
5774 if (dptr->numunits > 1)
5775 (void)fprintf (st, " unit %d", (int32) (uptr - dptr->units));
5776 }
5777 else
5778 (void)fprintf (st, " Unknown");
5779 tim = sim_fmt_secs((accum + uptr->time)/sim_timer_inst_per_sec ());
5780 (void)fprintf (st, " at %d%s%s%s%s\r\n", accum + uptr->time,
5781 (*tim) ? " (" : "", tim, (*tim) ? ")" : "",
5782 (uptr->flags & UNIT_IDLE) ? " (Idle capable)" : "");
5783 accum = accum + uptr->time;
5784 }
5785 }
5786 sim_show_clock_queues (st, dnotused, unotused, flag, cptr);
5787 return SCPE_OK;
5788 }
5789
5790 t_stat show_time (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5791 {
5792 if (cptr && (*cptr != 0))
5793 return SCPE_2MARG;
5794 (void)fprintf (st, "Time:\t%.0f\r\n", sim_gtime());
5795 return SCPE_OK;
5796 }
5797
5798 t_stat show_break (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5799 {
5800 t_stat r;
5801
5802 if (cptr && (*cptr != 0))
5803 r = ssh_break (st, cptr, 1);
5804 else
5805 r = sim_brk_showall (st, (uint32)sim_switches);
5806 return r;
5807 }
5808
5809 t_stat show_dev_radix (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5810 {
5811 (void)fprintf (st, "Radix=%d\r\n", dptr->dradix);
5812 return SCPE_OK;
5813 }
5814
5815 t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5816 {
5817 int32 any = 0;
5818 DEBTAB *dep;
5819
5820 if (dptr->flags & DEV_DEBUG) {
5821 if (dptr->dctrl == 0)
5822 fputs ("Debugging disabled", st);
5823 else if (dptr->debflags == NULL)
5824 fputs ("Debugging enabled", st);
5825 else {
5826 uint32 dctrl = dptr->dctrl;
5827
5828 fputs ("Debug=", st);
5829 for (dep = dptr->debflags; (dctrl != 0) && (dep->name != NULL); dep++) {
5830 if ((dctrl & dep->mask) == dep->mask) {
5831 dctrl &= ~dep->mask;
5832 if (any)
5833 fputc (';', st);
5834 fputs (dep->name, st);
5835 any = 1;
5836 }
5837 }
5838 }
5839 fputc ('\n', st);
5840 return SCPE_OK;
5841 }
5842 else return SCPE_NOFNC;
5843 }
5844
5845
5846
5847 t_stat show_on (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5848 {
5849 int32 lvl, i;
5850
5851 if (cptr && (*cptr != 0)) return SCPE_2MARG;
5852 for (lvl=sim_do_depth; lvl >= 0; --lvl) {
5853 if (lvl > 0)
5854 (void)fprintf(st, "On Processing at Do Nest Level: %d", lvl);
5855 else
5856 (void)fprintf(st, "On Processing for input commands");
5857 (void)fprintf(st, " is %s\r\n", (sim_on_check[lvl]) ? "enabled" : "disabled");
5858 for (i=1; i<SCPE_BASE; ++i) {
5859 if (sim_on_actions[lvl][i])
5860 (void)fprintf(st, " on %5d %s\r\n", i, sim_on_actions[lvl][i]); }
5861 for (i=SCPE_BASE; i<=SCPE_MAX_ERR; ++i) {
5862 if (sim_on_actions[lvl][i])
5863 (void)fprintf(st, " on %-5s %s\r\n", scp_errors[i-SCPE_BASE].code, sim_on_actions[lvl][i]); }
5864 if (sim_on_actions[lvl][0])
5865 (void)fprintf(st, " on ERROR %s\r\n", sim_on_actions[lvl][0]);
5866 (void)fprintf(st, "\r\n");
5867 }
5868 if (sim_on_inherit)
5869 (void)fprintf(st, "on state and actions are inherited by nested do commands and subroutines\r\n");
5870 return SCPE_OK;
5871 }
5872
5873
5874
5875 t_stat show_mod_names (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5876 {
5877 int32 i;
5878 DEVICE *dptr;
5879
5880 if (cptr && (*cptr != 0))
5881 return SCPE_2MARG;
5882 for (i = 0; (dptr = sim_devices[i]) != NULL; i++)
5883 show_dev_modifiers (st, dptr, NULL, flag, cptr);
5884 for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i)
5885 show_dev_modifiers (st, dptr, NULL, flag, cptr);
5886 return SCPE_OK;
5887 }
5888
5889 t_stat show_dev_modifiers (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5890 {
5891 fprint_set_help (st, dptr);
5892 return SCPE_OK;
5893 }
5894
5895 t_stat show_all_mods (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, int32 *toks)
5896 {
5897 MTAB *mptr;
5898 t_stat r = SCPE_OK;
5899
5900 if (dptr->modifiers == NULL)
5901 return SCPE_OK;
5902 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
5903 if (mptr->pstring &&
5904 ((mptr->mask & MTAB_XTD)?
5905 (MODMASK(mptr,flag) && !MODMASK(mptr,MTAB_NMO)):
5906 ((MTAB_VUN == (uint32)flag) && ((uptr->flags & mptr->mask) == mptr->match)))) {
5907 if (*toks > 0) {
5908 (void)fprintf (st, "\r\n");
5909 *toks = 0;
5910 }
5911 if (r == SCPE_OK)
5912 fprint_sep (st, toks);
5913 r = show_one_mod (st, dptr, uptr, mptr, NULL, 0);
5914 }
5915 }
5916 return SCPE_OK;
5917 }
5918
5919 t_stat show_one_mod (FILE *st, DEVICE *dptr, UNIT *uptr, MTAB *mptr,
5920 CONST char *cptr, int32 flag)
5921 {
5922 t_stat r = SCPE_OK;
5923
5924 if (mptr->disp)
5925 r = mptr->disp (st, uptr, mptr->match, (CONST void *)(cptr? cptr: mptr->desc));
5926 else
5927 fputs (mptr->pstring, st);
5928 if ((r == SCPE_OK) && (flag && !((mptr->mask & MTAB_XTD) && MODMASK(mptr,MTAB_NMO))))
5929 fputc ('\n', st);
5930 return r;
5931 }
5932
5933
5934
5935 t_stat show_show_commands (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5936 {
5937 int32 i;
5938 DEVICE *dptr;
5939
5940 if (cptr && (*cptr != 0))
5941 return SCPE_2MARG;
5942 for (i = 0; (dptr = sim_devices[i]) != NULL; i++)
5943 show_dev_show_commands (st, dptr, NULL, flag, cptr);
5944 for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i)
5945 show_dev_show_commands (st, dptr, NULL, flag, cptr);
5946 return SCPE_OK;
5947 }
5948
5949 t_stat show_dev_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5950 {
5951 fprint_show_help (st, dptr);
5952 return SCPE_OK;
5953 }
5954
5955
5956
5957 t_stat brk_cmd (int32 flg, CONST char *cptr)
5958 {
5959 GET_SWITCHES (cptr);
5960 return ssh_break (NULL, cptr, flg);
5961 }
5962
5963 t_stat ssh_break (FILE *st, const char *cptr, int32 flg)
5964 {
5965 char gbuf[CBUFSIZE], *aptr, abuf[4*CBUFSIZE];
5966 CONST char *tptr, *t1ptr;
5967 DEVICE *dptr = sim_dflt_dev;
5968 UNIT *uptr;
5969 t_stat r;
5970 t_addr lo, hi, max;
5971 int32 cnt;
5972
5973 if (sim_brk_types == 0)
5974 return sim_messagef (SCPE_NOFNC, "No breakpoint support in this simulator\r\n");
5975 if (dptr == NULL)
5976 return SCPE_IERR;
5977 uptr = dptr->units;
5978 if (uptr == NULL)
5979 return SCPE_IERR;
5980 max = uptr->capac - 1;
5981 abuf[sizeof(abuf)-1] = '\0';
5982 strncpy (abuf, cptr, sizeof(abuf)-1);
5983 cptr = abuf;
5984 if ((aptr = strchr (abuf, ';'))) {
5985 if (flg != SSH_ST)
5986 return sim_messagef (SCPE_ARG, "Invalid argument: %s\r\n", aptr);
5987 *aptr++ = 0;
5988 }
5989 if (*cptr == 0) {
5990 lo = (t_addr) get_rval (sim_PC, 0);
5991 return ssh_break_one (st, flg, lo, 0, aptr);
5992 }
5993 while (*cptr) {
5994 cptr = get_glyph (cptr, gbuf, ',');
5995 tptr = get_range (dptr, gbuf, &lo, &hi, dptr->aradix, max, 0);
5996 if (tptr == NULL)
5997 return sim_messagef (SCPE_ARG, "Invalid address specifier: %s\r\n", gbuf);
5998 if (*tptr == '[') {
5999 cnt = (int32) strtotv (tptr + 1, &t1ptr, 10);
6000 if ((tptr == t1ptr) || (*t1ptr != ']') || (flg != SSH_ST))
6001 return sim_messagef (SCPE_ARG, "Invalid repeat count specifier: %s\r\n", tptr + 1);
6002 tptr = t1ptr + 1;
6003 }
6004 else cnt = 0;
6005 if (*tptr != 0)
6006 return sim_messagef (SCPE_ARG, "Unexpected argument: %s\r\n", tptr);
6007 if ((lo == 0) && (hi == max)) {
6008 if (flg == SSH_CL)
6009 sim_brk_clrall (sim_switches);
6010 else
6011 if (flg == SSH_SH)
6012 sim_brk_showall (st, (uint32)sim_switches);
6013 else
6014 return SCPE_ARG;
6015 }
6016 else {
6017 for ( ; lo <= hi; lo = lo + 1) {
6018 r = ssh_break_one (st, flg, lo, cnt, aptr);
6019 if (r != SCPE_OK)
6020 return r;
6021 }
6022 }
6023 }
6024 return SCPE_OK;
6025 }
6026
6027 t_stat ssh_break_one (FILE *st, int32 flg, t_addr lo, int32 cnt, CONST char *aptr)
6028 {
6029 if (!sim_brk_types)
6030 return sim_messagef (SCPE_NOFNC, "No breakpoint support in this simulator\r\n");
6031 switch (flg) {
6032 case SSH_ST:
6033 return sim_brk_set (lo, sim_switches, cnt, aptr);
6034
6035 break;
6036
6037 case SSH_CL:
6038 return sim_brk_clr (lo, sim_switches);
6039
6040 break;
6041
6042 case SSH_SH:
6043 return sim_brk_show (st, lo, sim_switches);
6044
6045 break;
6046
6047 default:
6048 return SCPE_ARG;
6049 }
6050 }
6051
6052
6053
6054 static t_bool run_cmd_did_reset = FALSE;
6055
6056 t_stat reset_cmd (int32 flag, CONST char *cptr)
6057 {
6058 char gbuf[CBUFSIZE];
6059 DEVICE *dptr;
6060
6061 GET_SWITCHES (cptr);
6062 run_cmd_did_reset = FALSE;
6063 if (*cptr == 0)
6064 return (reset_all (0));
6065 cptr = get_glyph (cptr, gbuf, 0);
6066 if (*cptr != 0)
6067 return SCPE_2MARG;
6068 if (strcmp (gbuf, "ALL") == 0)
6069 return (reset_all (0));
6070 dptr = find_dev (gbuf);
6071 if (dptr == NULL)
6072 return SCPE_NXDEV;
6073 if (dptr->reset != NULL)
6074 return dptr->reset (dptr);
6075 else return SCPE_OK;
6076 }
6077
6078
6079
6080
6081
6082
6083
6084
6085
6086 t_stat reset_all (uint32 start)
6087 {
6088 DEVICE *dptr;
6089 uint32 i;
6090 t_stat reason;
6091
6092 for (i = 0; i < start; i++) {
6093 if (sim_devices[i] == NULL)
6094 return SCPE_IERR;
6095 }
6096 for (i = start; (dptr = sim_devices[i]) != NULL; i++) {
6097 if (dptr->reset != NULL) {
6098 reason = dptr->reset (dptr);
6099 if (reason != SCPE_OK)
6100 return reason;
6101 }
6102 }
6103 for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i) {
6104 if (dptr->reset != NULL) {
6105 reason = dptr->reset (dptr);
6106 if (reason != SCPE_OK)
6107 return reason;
6108 }
6109 }
6110 return SCPE_OK;
6111 }
6112
6113
6114
6115
6116
6117
6118
6119
6120
6121 t_stat reset_all_p (uint32 start)
6122 {
6123 t_stat r;
6124 int32 old_sw = sim_switches;
6125
6126 sim_switches = SWMASK ('P');
6127 r = reset_all (start);
6128 sim_switches = old_sw;
6129 return r;
6130 }
6131
6132
6133
6134 t_stat attach_cmd (int32 flag, CONST char *cptr)
6135 {
6136 char gbuf[4*CBUFSIZE];
6137 DEVICE *dptr;
6138 UNIT *uptr;
6139 t_stat r;
6140
6141 GET_SWITCHES (cptr);
6142 if ((NULL == cptr) || (*cptr == 0))
6143 return SCPE_2FARG;
6144 cptr = get_glyph (cptr, gbuf, 0);
6145 GET_SWITCHES (cptr);
6146 if ((NULL == cptr) || (*cptr == 0))
6147 return SCPE_2FARG;
6148 dptr = find_unit (gbuf, &uptr);
6149 if (dptr == NULL)
6150 return SCPE_NXDEV;
6151 if (uptr == NULL)
6152 return SCPE_NXUN;
6153 if (uptr->flags & UNIT_ATT) {
6154 if (!(uptr->dynflags & UNIT_ATTMULT) &&
6155 !(dptr->flags & DEV_DONTAUTO)) {
6156 r = scp_detach_unit (dptr, uptr);
6157 if (r != SCPE_OK)
6158 return r; }
6159 else {
6160 if (!(uptr->dynflags & UNIT_ATTMULT))
6161 return SCPE_ALATT;
6162 }
6163 }
6164 gbuf[sizeof(gbuf)-1] = '\0';
6165 strncpy (gbuf, cptr, sizeof(gbuf)-1);
6166 sim_trim_endspc (gbuf);
6167 return scp_attach_unit (dptr, uptr, gbuf);
6168 }
6169
6170
6171
6172 t_stat scp_attach_unit (DEVICE *dptr, UNIT *uptr, const char *cptr)
6173 {
6174 if (dptr->attach != NULL)
6175 return dptr->attach (uptr, (CONST char *)cptr);
6176 return attach_unit (uptr, (CONST char *)cptr);
6177 }
6178
6179
6180
6181 t_stat attach_unit (UNIT *uptr, CONST char *cptr)
6182 {
6183 DEVICE *dptr;
6184
6185 if (uptr->flags & UNIT_DIS)
6186 return SCPE_UDIS;
6187 if (!(uptr->flags & UNIT_ATTABLE))
6188 return SCPE_NOATT;
6189 if ((dptr = find_dev_from_unit (uptr)) == NULL)
6190 return SCPE_NOATT;
6191 uptr->filename = (char *) calloc (CBUFSIZE, sizeof (char));
6192 if (uptr->filename == NULL)
6193 return SCPE_MEM;
6194 strncpy (uptr->filename, cptr, CBUFSIZE-1);
6195 if ((sim_switches & SWMASK ('R')) ||
6196 ((uptr->flags & UNIT_RO) != 0)) {
6197 if (((uptr->flags & UNIT_ROABLE) == 0) &&
6198 ((uptr->flags & UNIT_RO) == 0))
6199 return attach_err (uptr, SCPE_NORO);
6200 uptr->fileref = sim_fopen (cptr, "rb");
6201 if (uptr->fileref == NULL)
6202 return attach_err (uptr, SCPE_OPENERR);
6203 uptr->flags = uptr->flags | UNIT_RO;
6204 if (!sim_quiet && !(sim_switches & SWMASK ('Q'))) {
6205 sim_printf ("%s: unit is read only (%s)\r\n", sim_dname (dptr), cptr);
6206 }
6207 }
6208 else {
6209 if (sim_switches & SWMASK ('N')) {
6210 uptr->fileref = sim_fopen (cptr, "wb+");
6211 if (uptr->fileref == NULL)
6212 return attach_err (uptr, SCPE_OPENERR);
6213 if (!sim_quiet && !(sim_switches & SWMASK ('Q'))) {
6214 sim_printf ("%s: creating new file (%s)\r\n", sim_dname (dptr), cptr);
6215 }
6216 }
6217 else {
6218 uptr->fileref = sim_fopen (cptr, "rb+");
6219 if (uptr->fileref == NULL) {
6220 #if defined(EWOULDBLOCK)
6221 if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
6222 #else
6223 if ((errno == EAGAIN))
6224 #endif
6225 return attach_err (uptr, SCPE_OPENERR);
6226
6227 #if defined(EPERM)
6228 if ((errno == EROFS) || (errno == EACCES) || (errno == EPERM)) {
6229 #else
6230 if ((errno == EROFS) || (errno == EACCES)) {
6231 #endif
6232 if ((uptr->flags & UNIT_ROABLE) == 0)
6233 return attach_err (uptr, SCPE_NORO);
6234 uptr->fileref = sim_fopen (cptr, "rb");
6235 if (uptr->fileref == NULL)
6236 return attach_err (uptr, SCPE_OPENERR);
6237 uptr->flags = uptr->flags | UNIT_RO;
6238 if (!sim_quiet) {
6239 sim_printf ("%s: unit is read only (%s)\r\n", sim_dname (dptr), cptr);
6240 }
6241 }
6242 else {
6243 if (sim_switches & SWMASK ('E'))
6244 return attach_err (uptr, SCPE_OPENERR);
6245 uptr->fileref = sim_fopen (cptr, "wb+");
6246 if (uptr->fileref == NULL)
6247 return attach_err (uptr, SCPE_OPENERR);
6248 if (!sim_quiet) {
6249 sim_printf ("%s: creating new file (%s)\r\n", sim_dname (dptr), cptr);
6250 }
6251 }
6252 }
6253 }
6254 }
6255 if (uptr->flags & UNIT_BUFABLE) {
6256 uint32 cap = ((uint32) uptr->capac) / dptr->aincr;
6257 if (uptr->flags & UNIT_MUSTBUF)
6258 uptr->filebuf = calloc (cap, SZ_D (dptr));
6259 if (uptr->filebuf == NULL)
6260 return attach_err (uptr, SCPE_MEM);
6261 if (!sim_quiet) {
6262 sim_printf ("%s: buffering file in memory\r\n", sim_dname (dptr));
6263 }
6264 uptr->hwmark = (uint32)sim_fread (uptr->filebuf,
6265 SZ_D (dptr), cap, uptr->fileref);
6266 uptr->flags = uptr->flags | UNIT_BUF;
6267 }
6268 uptr->flags = uptr->flags | UNIT_ATT;
6269 uptr->pos = 0;
6270 return SCPE_OK;
6271 }
6272
6273 t_stat attach_err (UNIT *uptr, t_stat stat)
6274 {
6275 FREE (uptr->filename);
6276 uptr->filename = NULL;
6277 return stat;
6278 }
6279
6280
6281
6282 t_stat detach_cmd (int32 flag, CONST char *cptr)
6283 {
6284 char gbuf[CBUFSIZE];
6285 DEVICE *dptr;
6286 UNIT *uptr;
6287
6288 GET_SWITCHES (cptr);
6289 if ((NULL == cptr) || (*cptr == 0))
6290 return SCPE_2FARG;
6291 cptr = get_glyph (cptr, gbuf, 0);
6292 if (*cptr != 0)
6293 return SCPE_2MARG;
6294 if (strcmp (gbuf, "ALL") == 0)
6295 return (detach_all (0, FALSE));
6296 dptr = find_unit (gbuf, &uptr);
6297 if (dptr == NULL)
6298 return SCPE_NXDEV;
6299 if (uptr == NULL)
6300 return SCPE_NXUN;
6301 return scp_detach_unit (dptr, uptr);
6302 }
6303
6304
6305
6306
6307
6308
6309
6310
6311
6312
6313
6314
6315
6316
6317 t_stat detach_all (int32 start, t_bool shutdown)
6318 {
6319 uint32 i, j;
6320 DEVICE *dptr;
6321 UNIT *uptr;
6322 t_stat r;
6323
6324 if ((start < 0) || (start > 1))
6325 return SCPE_IERR;
6326 if (shutdown)
6327 sim_switches = sim_switches | SIM_SW_SHUT;
6328 for (i = start; (dptr = sim_devices[i]) != NULL; i++) {
6329 for (j = 0; j < dptr->numunits; j++) {
6330 uptr = (dptr->units) + j;
6331 if ((uptr->flags & UNIT_ATT) ||
6332 (shutdown && dptr->detach &&
6333 !(uptr->flags & UNIT_ATTABLE))) {
6334 r = scp_detach_unit (dptr, uptr);
6335
6336 if ((r != SCPE_OK) && !shutdown)
6337 return r;
6338 }
6339 }
6340 }
6341 return SCPE_OK;
6342 }
6343
6344
6345
6346 t_stat scp_detach_unit (DEVICE *dptr, UNIT *uptr)
6347 {
6348 if (dptr->detach != NULL)
6349 return dptr->detach (uptr);
6350 return detach_unit (uptr);
6351 }
6352
6353
6354
6355 t_stat detach_unit (UNIT *uptr)
6356 {
6357 DEVICE *dptr;
6358
6359 if (uptr == NULL)
6360 return SCPE_IERR;
6361 if (!(uptr->flags & UNIT_ATTABLE))
6362 return SCPE_NOATT;
6363 if (!(uptr->flags & UNIT_ATT)) {
6364 if (sim_switches & SIM_SW_REST)
6365 return SCPE_OK;
6366 else
6367 return SCPE_NOTATT;
6368 }
6369 if ((dptr = find_dev_from_unit (uptr)) == NULL)
6370 return SCPE_OK;
6371 if (uptr->flags & UNIT_BUF) {
6372 uint32 cap = (uptr->hwmark + dptr->aincr - 1) / dptr->aincr;
6373 if (uptr->hwmark && ((uptr->flags & UNIT_RO) == 0)) {
6374 if (!sim_quiet) {
6375 sim_printf ("%s: writing buffer to file\r\n", sim_dname (dptr));
6376 }
6377 rewind (uptr->fileref);
6378 sim_fwrite (uptr->filebuf, SZ_D (dptr), cap, uptr->fileref);
6379 if (ferror (uptr->fileref))
6380 sim_printf ("%s: I/O error - %s (Error %d)\r\n",
6381 sim_dname (dptr), xstrerror_l(errno), errno);
6382 }
6383 if (uptr->flags & UNIT_MUSTBUF) {
6384 FREE (uptr->filebuf);
6385 uptr->filebuf = NULL;
6386 }
6387 uptr->flags = uptr->flags & ~UNIT_BUF;
6388 }
6389 uptr->flags = uptr->flags & ~(UNIT_ATT | UNIT_RO);
6390 FREE (uptr->filename);
6391 uptr->filename = NULL;
6392 if (fclose (uptr->fileref) == EOF)
6393 return SCPE_IOERR;
6394 return SCPE_OK;
6395 }
6396
6397
6398
6399 const char *sim_dname (DEVICE *dptr)
6400 {
6401 return (dptr ? (dptr->lname? dptr->lname: dptr->name) : "");
6402 }
6403
6404
6405
6406 const char *sim_uname (UNIT *uptr)
6407 {
6408 DEVICE *d = find_dev_from_unit(uptr);
6409 static char uname[CBUFSIZE];
6410
6411 if (!d)
6412 return "";
6413 if (d->numunits == 1)
6414 return sim_dname (d);
6415 (void)sprintf (uname, "%s%d", sim_dname (d), (int)(uptr-d->units));
6416 return uname;
6417 }
6418
6419
6420
6421 t_stat run_cmd (int32 flag, CONST char *cptr)
6422 {
6423 char gbuf[CBUFSIZE] = "";
6424 CONST char *tptr;
6425 uint32 i, j;
6426 int32 sim_next = 0;
6427 int32 unitno;
6428 t_value pcv, orig_pcv;
6429 t_stat r;
6430 DEVICE *dptr;
6431 UNIT *uptr;
6432
6433 GET_SWITCHES (cptr);
6434 sim_step = 0;
6435 if ((flag == RU_RUN) || (flag == RU_GO)) {
6436 orig_pcv = get_rval (sim_PC, 0);
6437 if (*cptr != 0) {
6438 cptr = get_glyph (cptr, gbuf, 0);
6439 if (MATCH_CMD (gbuf, "UNTIL") != 0) {
6440 if (sim_dflt_dev && sim_vm_parse_addr)
6441 pcv = sim_vm_parse_addr (sim_dflt_dev, gbuf, &tptr);
6442 else pcv = strtotv (gbuf, &tptr, sim_PC->radix);
6443 if ((tptr == gbuf) || (*tptr != 0) ||
6444 (pcv > width_mask[sim_PC->width]))
6445 return SCPE_ARG;
6446 put_rval (sim_PC, 0, pcv);
6447 }
6448 }
6449 if ((flag == RU_RUN) &&
6450 ((r = sim_run_boot_prep (flag)) != SCPE_OK)) {
6451 put_rval (sim_PC, 0, orig_pcv);
6452 return r;
6453 }
6454 if ((*cptr) || (MATCH_CMD (gbuf, "UNTIL") == 0)) {
6455 int32 saved_switches = sim_switches;
6456
6457 if (MATCH_CMD (gbuf, "UNTIL") != 0)
6458 cptr = get_glyph (cptr, gbuf, 0);
6459 if (MATCH_CMD (gbuf, "UNTIL") != 0)
6460 return sim_messagef (SCPE_2MARG, "Unexpected %s command argument: %s %s\r\n",
6461 (flag == RU_RUN) ? "RUN" : "GO", gbuf, cptr);
6462 sim_switches = 0;
6463 GET_SWITCHES (cptr);
6464 if ((*cptr == '\'') || (*cptr == '"')) {
6465 r = expect_cmd (1, cptr);
6466 if (r != SCPE_OK)
6467 return r;
6468 }
6469 else {
6470 if (sim_switches == 0)
6471 sim_switches = sim_brk_dflt;
6472 sim_switches |= BRK_TYP_TEMP;
6473 sim_brk_types |= BRK_TYP_TEMP;
6474 r = ssh_break (NULL, cptr, SSH_ST);
6475 if (r != SCPE_OK)
6476 return sim_messagef (r, "Unable to establish breakpoint at: %s\r\n", cptr);
6477 }
6478 sim_switches = saved_switches;
6479 }
6480 }
6481
6482 else if ((flag == RU_STEP) ||
6483 ((flag == RU_NEXT) && !sim_vm_is_subroutine_call)) {
6484 static t_bool not_implemented_message = FALSE;
6485
6486 if ((!not_implemented_message) && (flag == RU_NEXT)) {
6487 not_implemented_message = TRUE;
6488 flag = RU_STEP;
6489 }
6490 if (*cptr != 0) {
6491 cptr = get_glyph (cptr, gbuf, 0);
6492 if (*cptr != 0)
6493 return SCPE_2MARG;
6494 sim_step = (int32) get_uint (gbuf, 10, INT_MAX, &r);
6495 if ((r != SCPE_OK) || (sim_step <= 0))
6496 return SCPE_ARG;
6497 }
6498 else sim_step = 1;
6499 if ((flag == RU_STEP) && (sim_switches & SWMASK ('T')))
6500 sim_step = (int32)((sim_timer_inst_per_sec ()*sim_step)/1000000.0);
6501 }
6502 else if (flag == RU_NEXT) {
6503 t_addr *addrs;
6504
6505 if (*cptr != 0) {
6506 cptr = get_glyph (cptr, gbuf, 0);
6507 if (*cptr != 0)
6508 return SCPE_2MARG;
6509 sim_next = (int32) get_uint (gbuf, 10, INT_MAX, &r);
6510 if ((r != SCPE_OK) || (sim_next <= 0))
6511 return SCPE_ARG;
6512 }
6513 else sim_next = 1;
6514 if (sim_vm_is_subroutine_call(&addrs)) {
6515 sim_brk_types |= BRK_TYP_DYN_STEPOVER;
6516 for (i=0; addrs[i]; i++)
6517 sim_brk_set (addrs[i], BRK_TYP_DYN_STEPOVER, 0, NULL);
6518 }
6519 else
6520 sim_step = 1;
6521 }
6522 else if (flag == RU_BOOT) {
6523 if (*cptr == 0)
6524 return SCPE_2FARG;
6525 cptr = get_glyph (cptr, gbuf, 0);
6526 if (*cptr != 0)
6527 return SCPE_2MARG;
6528 dptr = find_unit (gbuf, &uptr);
6529 if (dptr == NULL)
6530 return SCPE_NXDEV;
6531 if (uptr == NULL)
6532 return SCPE_NXUN;
6533 if (dptr->boot == NULL)
6534 return SCPE_NOFNC;
6535 if (uptr->flags & UNIT_DIS)
6536 return SCPE_UDIS;
6537 if ((uptr->flags & UNIT_ATTABLE) &&
6538 !(uptr->flags & UNIT_ATT))
6539 return SCPE_UNATT;
6540 unitno = (int32) (uptr - dptr->units);
6541 if ((r = sim_run_boot_prep (flag)) != SCPE_OK)
6542 return r;
6543 if ((r = dptr->boot (unitno, dptr)) != SCPE_OK)
6544 return r;
6545 }
6546
6547 else
6548 if (flag != RU_CONT)
6549 return SCPE_IERR;
6550 else
6551 if (*cptr != 0)
6552 return sim_messagef (SCPE_2MARG, "CONTINUE command takes no arguments\r\n");
6553
6554 if (sim_switches & SIM_SW_HIDE)
6555 return SCPE_OK;
6556
6557 for (i = 1; (dptr = sim_devices[i]) != NULL; i++) {
6558 for (j = 0; j < dptr->numunits; j++) {
6559 uptr = dptr->units + j;
6560 if ((uptr->flags & (UNIT_ATT + UNIT_SEQ)) == (UNIT_ATT + UNIT_SEQ))
6561 sim_fseek (uptr->fileref, uptr->pos, SEEK_SET);
6562 }
6563 }
6564 stop_cpu = 0;
6565 sim_is_running = 1;
6566 if (sim_ttrun () != SCPE_OK) {
6567 sim_is_running = 0;
6568 sim_ttcmd ();
6569 return SCPE_TTYERR;
6570 }
6571 if ((r = sim_check_console (30)) != SCPE_OK) {
6572 sim_is_running = 0;
6573 sim_ttcmd ();
6574 return r;
6575 }
6576 #if !defined(IS_WINDOWS)
6577 # if defined(SIGINT)
6578 if (signal (SIGINT, int_handler) == SIG_ERR) {
6579 sim_is_running = 0;
6580 sim_ttcmd ();
6581 return SCPE_SIGERR;
6582 }
6583 # endif
6584 #endif
6585 #if !defined(IS_WINDOWS)
6586 # if defined(SIGHUP)
6587 if (signal (SIGHUP, int_handler) == SIG_ERR) {
6588 sim_is_running = 0;
6589 sim_ttcmd ();
6590 return SCPE_SIGERR;
6591 }
6592 # endif
6593 #endif
6594 #if !defined(IS_WINDOWS)
6595 # if defined(SIGTERM)
6596 if (signal (SIGTERM, int_handler) == SIG_ERR) {
6597 sim_is_running = 0;
6598 sim_ttcmd ();
6599 return SCPE_SIGERR;
6600 }
6601 # endif
6602 #endif
6603 if (sim_step)
6604 sim_activate (&sim_step_unit, sim_step);
6605 (void)fflush(stdout);
6606 if (sim_log)
6607 (void)fflush (sim_log);
6608 sim_rtcn_init_all ();
6609 sim_start_timer_services ();
6610
6611 do {
6612 t_addr *addrs;
6613
6614 while (1) {
6615 r = sim_instr();
6616 if (r != SCPE_REMOTE)
6617 break;
6618 sim_remote_process_command ();
6619 }
6620 if ((flag != RU_NEXT) ||
6621 (--sim_next <=0))
6622 break;
6623 if (sim_step == 0) {
6624 t_addr val;
6625 BRKTAB *bp;
6626
6627 if (SCPE_BARE_STATUS(r) >= SCPE_BASE)
6628 break;
6629 if (sim_vm_pc_value)
6630 val = (t_addr)(*sim_vm_pc_value)();
6631 else
6632 val = (t_addr)get_rval (sim_PC, 0);
6633 if ((!(bp = sim_brk_fnd (val))) || (!(bp->typ & BRK_TYP_DYN_STEPOVER)))
6634 break;
6635 sim_brk_clrall (BRK_TYP_DYN_STEPOVER);
6636 }
6637 else {
6638 if (r != SCPE_STEP)
6639 break;
6640 }
6641
6642 sim_step = 0;
6643 if (sim_vm_is_subroutine_call(&addrs)) {
6644 sim_brk_types |= BRK_TYP_DYN_STEPOVER;
6645 for (i=0; addrs[i]; i++)
6646 sim_brk_set (addrs[i], BRK_TYP_DYN_STEPOVER, 0, NULL);
6647 }
6648 else
6649 sim_step = 1;
6650 if (sim_step)
6651 sim_activate (&sim_step_unit, sim_step);
6652 } while (1);
6653
6654 sim_is_running = 0;
6655 sim_stop_timer_services ();
6656 sim_ttcmd ();
6657 sim_brk_clrall (BRK_TYP_DYN_STEPOVER);
6658 signal (SIGINT, SIG_DFL);
6659 #if defined(SIGHUP)
6660 signal (SIGHUP, SIG_DFL);
6661 #endif
6662 signal (SIGTERM, SIG_DFL);
6663 if (sim_log)
6664 (void)fflush (sim_log);
6665 if (sim_deb)
6666 sim_debug_flush ();
6667 for (i = 1; (dptr = sim_devices[i]) != NULL; i++) {
6668 for (j = 0; j < dptr->numunits; j++) {
6669 uptr = dptr->units + j;
6670 if (uptr->flags & UNIT_ATT) {
6671 if (uptr->io_flush)
6672 uptr->io_flush (uptr);
6673 else {
6674 if (!(uptr->flags & UNIT_BUF) &&
6675 (uptr->fileref) &&
6676 !(uptr->dynflags & UNIT_NO_FIO) &&
6677 !(uptr->flags & UNIT_RO))
6678 (void)fflush (uptr->fileref);
6679 }
6680 }
6681 }
6682 }
6683 sim_cancel (&sim_step_unit);
6684 UPDATE_SIM_TIME;
6685 return r | ((sim_switches & SWMASK ('Q')) ? SCPE_NOMESSAGE : 0);
6686 }
6687
6688
6689
6690 void
6691 run_cmd_message (const char *unechoed_cmdline, t_stat r)
6692 {
6693 if (unechoed_cmdline && (r >= SCPE_BASE) && (r != SCPE_STEP) && (r != SCPE_STOP) && (r != SCPE_EXPECT))
6694 sim_printf("%s> %s\r\n", do_position(), unechoed_cmdline);
6695 #if defined(WIN_STDIO)
6696 (void)fflush(stderr);
6697 (void)fflush(stdout);
6698 #endif
6699 fprint_stopped (stdout, r);
6700 if (sim_log && (sim_log != stdout))
6701 fprint_stopped (sim_log, r);
6702 if (sim_deb && (sim_deb != stdout) && (sim_deb != sim_log))
6703 fprint_stopped (sim_deb, r);
6704 #if defined(WIN_STDIO)
6705 (void)fflush(stderr);
6706 (void)fflush(stdout);
6707 #endif
6708 }
6709
6710
6711
6712 t_stat sim_run_boot_prep (int32 flag)
6713 {
6714 UNIT *uptr;
6715 t_stat r;
6716
6717 sim_interval = 0;
6718 sim_time = sim_rtime = 0;
6719 noqueue_time = 0;
6720 for (uptr = sim_clock_queue; uptr != QUEUE_LIST_END; uptr = sim_clock_queue) {
6721 sim_clock_queue = uptr->next;
6722 uptr->next = NULL;
6723 }
6724 r = reset_all (0);
6725 if ((r == SCPE_OK) && (flag == RU_RUN)) {
6726 if ((run_cmd_did_reset) && (0 == (sim_switches & SWMASK ('Q')))) {
6727 sim_printf ("Resetting all devices... This may not have been your intention.\r\n");
6728 sim_printf ("The GO and CONTINUE commands do not reset devices.\r\n");
6729 }
6730 run_cmd_did_reset = TRUE;
6731 }
6732 return r;
6733 }
6734
6735
6736
6737
6738
6739
6740
6741
6742 void fprint_stopped_gen (FILE *st, t_stat v, REG *pc, DEVICE *dptr)
6743 {
6744 int32 i;
6745 t_stat r = 0;
6746 t_addr k;
6747 t_value pcval;
6748
6749 fputc ('\n', st);
6750
6751 if (v >= SCPE_BASE)
6752 fputs (sim_error_text (v), st);
6753 else {
6754 fputs (sim_stop_messages [v], st);
6755
6756 if ((sim_vm_fprint_stopped != NULL) &&
6757 (!sim_vm_fprint_stopped (st, v)))
6758 return;
6759 }
6760
6761 (void)fprintf (st, ", %s: ", pc->name);
6762
6763 pcval = get_rval (pc, 0);
6764 if ((pc->flags & REG_VMAD) && sim_vm_fprint_addr)
6765 sim_vm_fprint_addr (st, dptr, (t_addr) pcval);
6766 else fprint_val (st, pcval, pc->radix, pc->width,
6767 pc->flags & REG_FMT);
6768 if ((dptr != NULL) && (dptr->examine != NULL)) {
6769 for (i = 0; i < sim_emax; i++)
6770 sim_eval[i] = 0;
6771 for (i = 0, k = (t_addr) pcval; i < sim_emax; i++, k = k + dptr->aincr) {
6772 if ((r = dptr->examine (&sim_eval[i], k, dptr->units, SWMASK ('V')|SIM_SW_STOP)) != SCPE_OK)
6773 break;
6774 }
6775 if ((r == SCPE_OK) || (i > 0)) {
6776 (void)fprintf (st, " (");
6777 if (fprint_sym (st, (t_addr) pcval, sim_eval, NULL, SWMASK('M')|SIM_SW_STOP) > 0)
6778 fprint_val (st, sim_eval[0], dptr->dradix, dptr->dwidth, PV_RZRO);
6779 (void)fprintf (st, ")");
6780 }
6781 }
6782 (void)fprintf (st, "\r\n");
6783 return;
6784 }
6785
6786 void fprint_stopped (FILE *st, t_stat v)
6787 {
6788 #if defined(WIN_STDIO)
6789 (void)fflush(stderr);
6790 (void)fflush(stdout);
6791 #endif
6792 fprint_stopped_gen (st, v, sim_PC, sim_dflt_dev);
6793 return;
6794 }
6795
6796
6797
6798
6799 t_stat step_svc (UNIT *uptr)
6800 {
6801 return SCPE_STEP;
6802 }
6803
6804
6805
6806
6807 t_stat expect_svc (UNIT *uptr)
6808 {
6809 return SCPE_EXPECT | (sim_do_echo ? 0 : SCPE_NOMESSAGE);
6810 }
6811
6812
6813
6814 void int_handler (int sig)
6815 {
6816 stop_cpu = 1;
6817 return;
6818 }
6819
6820
6821
6822 t_stat exdep_cmd (int32 flag, CONST char *cptr)
6823 {
6824 char gbuf[CBUFSIZE];
6825 CONST char *gptr;
6826 CONST char *tptr = NULL;
6827 int32 opt;
6828 t_addr low, high;
6829 t_stat reason = SCPE_IERR;
6830 DEVICE *tdptr;
6831 REG *lowr, *highr;
6832 FILE *ofile;
6833
6834 opt = CMD_OPT_SW|CMD_OPT_SCH|CMD_OPT_DFT;
6835 if (flag == EX_E)
6836 opt = opt | CMD_OPT_OF;
6837 cptr = get_sim_opt (opt, cptr, &reason);
6838 if (NULL == cptr)
6839 return reason;
6840 if (*cptr == 0)
6841 return SCPE_2FARG;
6842 if (sim_dfunit == NULL)
6843 return SCPE_NXUN;
6844 cptr = get_glyph (cptr, gbuf, 0);
6845 if ((flag == EX_D) && (*cptr == 0))
6846
6847 return SCPE_2FARG;
6848 ofile = sim_ofile? sim_ofile: stdout;
6849
6850 for (gptr = gbuf, reason = SCPE_OK;
6851 (*gptr != 0) && (reason == SCPE_OK); gptr = tptr) {
6852 tdptr = sim_dfdev;
6853 if (strncmp (gptr, "STATE", strlen ("STATE")) == 0) {
6854 tptr = gptr + strlen ("STATE");
6855 if (*tptr && (*tptr++ != ','))
6856 return SCPE_ARG;
6857 if ((lowr = sim_dfdev->registers) == NULL)
6858 return SCPE_NXREG;
6859 for (highr = lowr; highr->name != NULL; highr++) ;
6860 sim_switches = sim_switches | SIM_SW_HIDE;
6861 reason = exdep_reg_loop (ofile, sim_schrptr, flag, cptr,
6862 lowr, --highr, 0, 0);
6863 continue;
6864 }
6865
6866
6867 if ((lowr = find_reg (gptr, &tptr, tdptr)) ||
6868 (!(sim_opt_out & CMD_OPT_DFT) &&
6869 (lowr = find_reg_glob (gptr, &tptr, &tdptr)))) {
6870 low = high = 0;
6871 if ((*tptr == '-') || (*tptr == ':')) {
6872 highr = find_reg (tptr + 1, &tptr, tdptr);
6873 if (highr == NULL)
6874 return SCPE_NXREG;
6875 }
6876 else {
6877 highr = lowr;
6878 if (*tptr == '[') {
6879 if (lowr->depth <= 1)
6880 return SCPE_ARG;
6881 tptr = get_range (NULL, tptr + 1, &low, &high,
6882 10, lowr->depth - 1, ']');
6883 if (tptr == NULL)
6884 return SCPE_ARG;
6885 }
6886 }
6887 if (*tptr && (*tptr++ != ','))
6888 return SCPE_ARG;
6889 reason = exdep_reg_loop (ofile, sim_schrptr, flag, cptr,
6890 lowr, highr, (uint32) low, (uint32) high);
6891 continue;
6892 }
6893
6894 tptr = get_range (sim_dfdev, gptr, &low, &high, sim_dfdev->aradix,
6895 (((sim_dfunit->capac == 0) || (flag == EX_E))? 0:
6896 sim_dfunit->capac - sim_dfdev->aincr), 0);
6897 if (tptr == NULL)
6898 return SCPE_ARG;
6899 if (*tptr && (*tptr++ != ','))
6900 return SCPE_ARG;
6901 reason = exdep_addr_loop (ofile, sim_schaptr, flag, cptr, low, high,
6902 sim_dfdev, sim_dfunit);
6903 }
6904 if (sim_ofile)
6905 fclose (sim_ofile);
6906 return reason;
6907 }
6908
6909
6910
6911
6912
6913
6914
6915 t_stat exdep_reg_loop (FILE *ofile, SCHTAB *schptr, int32 flag, CONST char *cptr,
6916 REG *lowr, REG *highr, uint32 lows, uint32 highs)
6917 {
6918 t_stat reason;
6919 uint32 idx, val_start=lows;
6920 t_value val, last_val;
6921 REG *rptr;
6922
6923 if ((lowr == NULL) || (highr == NULL))
6924 return SCPE_IERR;
6925 if (lowr > highr)
6926 return SCPE_ARG;
6927 for (rptr = lowr; rptr <= highr; rptr++) {
6928 if ((sim_switches & SIM_SW_HIDE) &&
6929 (rptr->flags & REG_HIDDEN))
6930 continue;
6931 val = last_val = 0;
6932 for (idx = lows; idx <= highs; idx++) {
6933 if (idx >= rptr->depth)
6934 return SCPE_SUB;
6935 val = get_rval (rptr, idx);
6936 if (schptr && !test_search (&val, schptr))
6937 continue;
6938 if (flag == EX_E) {
6939 if ((idx > lows) && (val == last_val))
6940 continue;
6941 if (idx > val_start+1) {
6942 if (idx-1 == val_start+1) {
6943 reason = ex_reg (ofile, val, flag, rptr, idx-1);
6944 if (reason != SCPE_OK)
6945 return reason;
6946 if (sim_log && (ofile == stdout))
6947 ex_reg (sim_log, val, flag, rptr, idx-1);
6948 }
6949 else {
6950 if (val_start+1 != idx-1) {
6951 (void)Fprintf (ofile, "%s[%d]-%s[%d]: same as above\r\n", rptr->name, val_start+1, rptr->name, idx-1);
6952 if (sim_log && (ofile == stdout))
6953 (void)Fprintf (sim_log, "%s[%d]-%s[%d]: same as above\r\n", rptr->name, val_start+1, rptr->name, idx-1);
6954 }
6955 else {
6956 (void)Fprintf (ofile, "%s[%d]: same as above\r\n", rptr->name, val_start+1);
6957 if (sim_log && (ofile == stdout))
6958 (void)Fprintf (sim_log, "%s[%d]: same as above\r\n", rptr->name, val_start+1);
6959 }
6960 }
6961 }
6962 sim_last_val = last_val = val;
6963 val_start = idx;
6964 reason = ex_reg (ofile, val, flag, rptr, idx);
6965 if (reason != SCPE_OK)
6966 return reason;
6967 if (sim_log && (ofile == stdout))
6968 ex_reg (sim_log, val, flag, rptr, idx);
6969 }
6970 if (flag != EX_E) {
6971 reason = dep_reg (flag, cptr, rptr, idx);
6972 if (reason != SCPE_OK)
6973 return reason;
6974 }
6975 }
6976 if ((flag == EX_E) && (val_start != highs)) {
6977 if (highs == val_start+1) {
6978 reason = ex_reg (ofile, val, flag, rptr, highs);
6979 if (reason != SCPE_OK)
6980 return reason;
6981 if (sim_log && (ofile == stdout))
6982 ex_reg (sim_log, val, flag, rptr, highs);
6983 }
6984 else {
6985 if (val_start+1 != highs) {
6986 (void)Fprintf (ofile, "%s[%d]-%s[%d]: same as above\r\n", rptr->name, val_start+1, rptr->name, highs);
6987 if (sim_log && (ofile == stdout))
6988 (void)Fprintf (sim_log, "%s[%d]-%s[%d]: same as above\r\n", rptr->name, val_start+1, rptr->name, highs);
6989 }
6990 else {
6991 (void)Fprintf (ofile, "%s[%d]: same as above\r\n", rptr->name, val_start+1);
6992 if (sim_log && (ofile == stdout))
6993 (void)Fprintf (sim_log, "%s[%d]: same as above\r\n", rptr->name, val_start+1);
6994 }
6995 }
6996 }
6997 }
6998 return SCPE_OK;
6999 }
7000
7001 t_stat exdep_addr_loop (FILE *ofile, SCHTAB *schptr, int32 flag, const char *cptr,
7002 t_addr low, t_addr high, DEVICE *dptr, UNIT *uptr)
7003 {
7004 t_addr i, mask;
7005 t_stat reason;
7006
7007 if (uptr->flags & UNIT_DIS)
7008 return SCPE_UDIS;
7009 mask = (t_addr) width_mask[dptr->awidth];
7010 if ((low > mask) || (high > mask) || (low > high))
7011 return SCPE_ARG;
7012 for (i = low; i <= high; ) {
7013 reason = get_aval (i, dptr, uptr);
7014 if (reason != SCPE_OK)
7015 return reason;
7016 if (schptr && !test_search (sim_eval, schptr))
7017 i = i + dptr->aincr;
7018 else {
7019 if (flag != EX_D) {
7020 reason = ex_addr (ofile, flag, i, dptr, uptr);
7021 if (reason > SCPE_OK)
7022 return reason;
7023 if (sim_log && (ofile == stdout))
7024 ex_addr (sim_log, flag, i, dptr, uptr);
7025 }
7026 else reason = 1 - dptr->aincr;
7027 if (flag != EX_E) {
7028 reason = dep_addr (flag, cptr, i, dptr, uptr, reason);
7029 if (reason > SCPE_OK)
7030 return reason;
7031 }
7032 i = i + (1 - reason);
7033 }
7034 }
7035 return SCPE_OK;
7036 }
7037
7038
7039
7040
7041
7042
7043
7044
7045
7046
7047
7048
7049
7050 t_stat ex_reg (FILE *ofile, t_value val, int32 flag, REG *rptr, uint32 idx)
7051 {
7052 int32 rdx;
7053
7054 if (rptr == NULL)
7055 return SCPE_IERR;
7056 if (rptr->depth > 1)
7057 (void)Fprintf (ofile, "%s[%d]:\t", rptr->name, idx);
7058 else
7059 (void)Fprintf (ofile, "%s:\t", rptr->name);
7060 if (!(flag & EX_E))
7061 return SCPE_OK;
7062 GET_RADIX (rdx, rptr->radix);
7063 if ((rptr->flags & REG_VMAD) && sim_vm_fprint_addr && sim_dflt_dev)
7064 sim_vm_fprint_addr (ofile, sim_dflt_dev, (t_addr) val);
7065 else if (!(rptr->flags & REG_VMFLAGS) ||
7066 (fprint_sym (ofile, (rptr->flags & REG_UFMASK) | rdx, &val,
7067 NULL, sim_switches | SIM_SW_REG) > 0)) {
7068 fprint_val (ofile, val, rdx, rptr->width, rptr->flags & REG_FMT);
7069 if (rptr->fields) {
7070 (void)Fprintf (ofile, "\t");
7071 fprint_fields (ofile, val, val, rptr->fields);
7072 }
7073 }
7074 if (flag & EX_I)
7075 (void)Fprintf (ofile, "\t");
7076 else
7077 (void)Fprintf (ofile, "\r\n");
7078 return SCPE_OK;
7079 }
7080
7081
7082
7083
7084
7085
7086
7087
7088
7089
7090 t_value get_rval (REG *rptr, uint32 idx)
7091 {
7092 size_t sz;
7093 t_value val;
7094 uint32 *ptr;
7095
7096 sz = SZ_R (rptr);
7097 if ((rptr->depth > 1) && (rptr->flags & REG_CIRC)) {
7098 idx = idx + rptr->qptr;
7099 if (idx >= rptr->depth) idx = idx - rptr->depth;
7100 }
7101 if ((rptr->depth > 1) && (rptr->flags & REG_UNIT)) {
7102 ptr = (uint32 *)(((UNIT *) rptr->loc) + idx);
7103 if (sz <= sizeof (uint32))
7104 val = *ptr;
7105 else val = *((t_uint64 *) ptr);
7106 }
7107 else if ((rptr->depth > 1) && (rptr->flags & REG_STRUCT)) {
7108 ptr = (uint32 *)(((size_t) rptr->loc) + (idx * rptr->str_size));
7109 if (sz <= sizeof (uint32))
7110 val = *ptr;
7111 else val = *((t_uint64 *) ptr);
7112 }
7113 else if (((rptr->depth > 1) || (rptr->flags & REG_FIT)) &&
7114 (sz == sizeof (uint8)))
7115 val = *(((uint8 *) rptr->loc) + idx);
7116 else if (((rptr->depth > 1) || (rptr->flags & REG_FIT)) &&
7117 (sz == sizeof (uint16)))
7118 val = *(((uint16 *) rptr->loc) + idx);
7119 else if (sz <= sizeof (uint32))
7120 val = *(((uint32 *) rptr->loc) + idx);
7121 else val = *(((t_uint64 *) rptr->loc) + idx);
7122 val = (val >> rptr->offset) & width_mask[rptr->width];
7123 return val;
7124 }
7125
7126
7127
7128
7129
7130
7131
7132
7133
7134
7135
7136
7137 t_stat dep_reg (int32 flag, CONST char *cptr, REG *rptr, uint32 idx)
7138 {
7139 t_stat r;
7140 t_value val, mask;
7141 int32 rdx;
7142 CONST char *tptr;
7143 char gbuf[CBUFSIZE];
7144
7145 if ((cptr == NULL) || (rptr == NULL))
7146 return SCPE_IERR;
7147 if (rptr->flags & REG_RO)
7148 return SCPE_RO;
7149 if (flag & EX_I) {
7150 cptr = read_line (gbuf, sizeof(gbuf), stdin);
7151 if (sim_log)
7152 (void)fprintf (sim_log, "%s\r\n", cptr? cptr: "");
7153 if (cptr == NULL)
7154 return 1;
7155 if (*cptr == 0)
7156 return SCPE_OK;
7157 }
7158 mask = width_mask[rptr->width];
7159 GET_RADIX (rdx, rptr->radix);
7160 if ((rptr->flags & REG_VMAD) && sim_vm_parse_addr && sim_dflt_dev) {
7161 val = sim_vm_parse_addr (sim_dflt_dev, cptr, &tptr);
7162 if ((tptr == cptr) || (*tptr != 0) || (val > mask))
7163 return SCPE_ARG;
7164 }
7165 else
7166 if (!(rptr->flags & REG_VMFLAGS) ||
7167 (parse_sym ((CONST char *)cptr, (rptr->flags & REG_UFMASK) | rdx, NULL,
7168 &val, sim_switches | SIM_SW_REG) > SCPE_OK)) {
7169 val = get_uint (cptr, rdx, mask, &r);
7170 if (r != SCPE_OK)
7171 return SCPE_ARG;
7172 }
7173 if ((rptr->flags & REG_NZ) && (val == 0))
7174 return SCPE_ARG;
7175 put_rval (rptr, idx, val);
7176 return SCPE_OK;
7177 }
7178
7179
7180
7181
7182
7183
7184
7185
7186
7187
7188
7189
7190 void put_rval (REG *rptr, uint32 idx, t_value val)
7191 {
7192 size_t sz;
7193 t_value mask;
7194 uint32 *ptr;
7195
7196 #define PUT_RVAL(sz,rp,id,v,m) \
7197 *(((sz *) rp->loc) + id) = \
7198 (sz)((*(((sz *) rp->loc) + id) & \
7199 ~((m) << (rp)->offset)) | ((v) << (rp)->offset))
7200
7201 if (rptr == sim_PC)
7202 sim_brk_npc (0);
7203 sz = SZ_R (rptr);
7204 mask = width_mask[rptr->width];
7205 if ((rptr->depth > 1) && (rptr->flags & REG_CIRC)) {
7206 idx = idx + rptr->qptr;
7207 if (idx >= rptr->depth)
7208 idx = idx - rptr->depth;
7209 }
7210 if ((rptr->depth > 1) && (rptr->flags & REG_UNIT)) {
7211 ptr = (uint32 *)(((UNIT *) rptr->loc) + idx);
7212 if (sz <= sizeof (uint32))
7213 *ptr = (*ptr &
7214 ~(((uint32) mask) << rptr->offset)) |
7215 (((uint32) val) << rptr->offset);
7216 else *((t_uint64 *) ptr) = (*((t_uint64 *) ptr)
7217 & ~(mask << rptr->offset)) | (val << rptr->offset);
7218 }
7219 else if ((rptr->depth > 1) && (rptr->flags & REG_STRUCT)) {
7220 ptr = (uint32 *)(((size_t) rptr->loc) + (idx * rptr->str_size));
7221 if (sz <= sizeof (uint32))
7222 *((uint32 *) ptr) = (*((uint32 *) ptr) &
7223 ~(((uint32) mask) << rptr->offset)) |
7224 (((uint32) val) << rptr->offset);
7225 else *((t_uint64 *) ptr) = (*((t_uint64 *) ptr)
7226 & ~(mask << rptr->offset)) | (val << rptr->offset);
7227 }
7228 else if (((rptr->depth > 1) || (rptr->flags & REG_FIT)) &&
7229 (sz == sizeof (uint8)))
7230 PUT_RVAL (uint8, rptr, idx, (uint32) val, (uint32) mask);
7231 else if (((rptr->depth > 1) || (rptr->flags & REG_FIT)) &&
7232 (sz == sizeof (uint16)))
7233 PUT_RVAL (uint16, rptr, idx, (uint32) val, (uint32) mask);
7234 else if (sz <= sizeof (uint32))
7235 PUT_RVAL (uint32, rptr, idx, (int32) val, (uint32) mask);
7236 else PUT_RVAL (t_uint64, rptr, idx, val, mask);
7237 return;
7238 }
7239
7240
7241
7242
7243
7244
7245
7246
7247
7248
7249
7250
7251
7252
7253 t_stat ex_addr (FILE *ofile, int32 flag, t_addr addr, DEVICE *dptr, UNIT *uptr)
7254 {
7255 t_stat reason;
7256 int32 rdx;
7257
7258 if (sim_vm_fprint_addr)
7259 sim_vm_fprint_addr (ofile, dptr, addr);
7260 else fprint_val (ofile, addr, dptr->aradix, dptr->awidth, PV_LEFT);
7261 (void)Fprintf (ofile, ":\t");
7262 if (!(flag & EX_E))
7263 return (1 - dptr->aincr);
7264
7265 GET_RADIX (rdx, dptr->dradix);
7266 if ((reason = fprint_sym (ofile, addr, sim_eval, uptr, sim_switches)) > 0) {
7267 fprint_val (ofile, sim_eval[0], rdx, dptr->dwidth, PV_RZRO);
7268 reason = 1 - dptr->aincr;
7269 }
7270 if (flag & EX_I)
7271 (void)Fprintf (ofile, "\t");
7272 else
7273 (void)Fprintf (ofile, "\r\n");
7274 return reason;
7275 }
7276
7277
7278
7279
7280
7281
7282
7283
7284
7285
7286
7287
7288 t_stat get_aval (t_addr addr, DEVICE *dptr, UNIT *uptr)
7289 {
7290 int32 i;
7291 t_value mask;
7292 t_addr j, loc;
7293 size_t sz;
7294 t_stat reason = SCPE_OK;
7295
7296 if ((dptr == NULL) || (uptr == NULL))
7297 return SCPE_IERR;
7298 mask = width_mask[dptr->dwidth];
7299 for (i = 0; i < sim_emax; i++)
7300 sim_eval[i] = 0;
7301 for (i = 0, j = addr; i < sim_emax; i++, j = j + dptr->aincr) {
7302 if (dptr->examine != NULL) {
7303 reason = dptr->examine (&sim_eval[i], j, uptr, sim_switches);
7304 if (reason != SCPE_OK)
7305 break;
7306 }
7307 else {
7308 if (!(uptr->flags & UNIT_ATT))
7309 return SCPE_UNATT;
7310 if (uptr->dynflags & UNIT_NO_FIO)
7311 return SCPE_NOFNC;
7312 if ((uptr->flags & UNIT_FIX) && (j >= uptr->capac)) {
7313 reason = SCPE_NXM;
7314 break;
7315 }
7316 sz = SZ_D (dptr);
7317 loc = j / dptr->aincr;
7318 if (uptr->flags & UNIT_BUF) {
7319 SZ_LOAD (sz, sim_eval[i], uptr->filebuf, loc);
7320 }
7321 else {
7322 sim_fseek (uptr->fileref, (t_addr)(sz * loc), SEEK_SET);
7323 sim_fread (&sim_eval[i], sz, 1, uptr->fileref);
7324 if ((feof (uptr->fileref)) &&
7325 !(uptr->flags & UNIT_FIX)) {
7326 reason = SCPE_EOF;
7327 break;
7328 }
7329 else if (ferror (uptr->fileref)) {
7330 clearerr (uptr->fileref);
7331 reason = SCPE_IOERR;
7332 break;
7333 }
7334 }
7335 }
7336 sim_last_val = sim_eval[i] = sim_eval[i] & mask;
7337 }
7338 if ((reason != SCPE_OK) && (i == 0))
7339 return reason;
7340 return SCPE_OK;
7341 }
7342
7343
7344
7345
7346
7347
7348
7349
7350
7351
7352
7353
7354
7355
7356
7357 t_stat dep_addr (int32 flag, const char *cptr, t_addr addr, DEVICE *dptr,
7358 UNIT *uptr, int32 dfltinc)
7359 {
7360 int32 i, count, rdx;
7361 t_addr j, loc;
7362 t_stat r, reason;
7363 t_value mask;
7364 size_t sz;
7365 char gbuf[CBUFSIZE];
7366
7367 if (dptr == NULL)
7368 return SCPE_IERR;
7369 if (flag & EX_I) {
7370 cptr = read_line (gbuf, sizeof(gbuf), stdin);
7371 if (sim_log)
7372 (void)fprintf (sim_log, "%s\r\n", cptr? cptr: "");
7373 if (cptr == NULL)
7374 return 1;
7375 if (*cptr == 0)
7376 return dfltinc;
7377 }
7378 if (uptr->flags & UNIT_RO)
7379 return SCPE_RO;
7380 mask = width_mask[dptr->dwidth];
7381
7382 GET_RADIX (rdx, dptr->dradix);
7383 if ((reason = parse_sym ((CONST char *)cptr, addr, uptr, sim_eval, sim_switches)) > 0) {
7384 sim_eval[0] = get_uint (cptr, rdx, mask, &reason);
7385 if (reason != SCPE_OK)
7386 return reason;
7387 reason = dfltinc;
7388 }
7389 count = (1 - reason + (dptr->aincr - 1)) / dptr->aincr;
7390
7391 for (i = 0, j = addr; i < count; i++, j = j + dptr->aincr) {
7392 sim_eval[i] = sim_eval[i] & mask;
7393 if (dptr->deposit != NULL) {
7394 r = dptr->deposit (sim_eval[i], j, uptr, sim_switches);
7395 if (r != SCPE_OK)
7396 return r;
7397 }
7398 else {
7399 if (!(uptr->flags & UNIT_ATT))
7400 return SCPE_UNATT;
7401 if (uptr->dynflags & UNIT_NO_FIO)
7402 return SCPE_NOFNC;
7403 if ((uptr->flags & UNIT_FIX) && (j >= uptr->capac))
7404 return SCPE_NXM;
7405 sz = SZ_D (dptr);
7406 loc = j / dptr->aincr;
7407 if (uptr->flags & UNIT_BUF) {
7408 SZ_STORE (sz, sim_eval[i], uptr->filebuf, loc);
7409 if (loc >= uptr->hwmark)
7410 uptr->hwmark = (uint32) loc + 1;
7411 }
7412 else {
7413 sim_fseek (uptr->fileref, (t_addr)(sz * loc), SEEK_SET);
7414 sim_fwrite (&sim_eval[i], sz, 1, uptr->fileref);
7415 if (ferror (uptr->fileref)) {
7416 clearerr (uptr->fileref);
7417 return SCPE_IOERR;
7418 }
7419 }
7420 }
7421 }
7422 return reason;
7423 }
7424
7425
7426
7427 t_stat eval_cmd (int32 flg, CONST char *cptr)
7428 {
7429 if (!sim_dflt_dev)
7430 return SCPE_ARG;
7431 DEVICE *dptr = sim_dflt_dev;
7432 int32 i, rdx, a, lim;
7433 t_stat r;
7434
7435 GET_SWITCHES (cptr);
7436 GET_RADIX (rdx, dptr->dradix);
7437 for (i = 0; i < sim_emax; i++)
7438 sim_eval[i] = 0;
7439 if (*cptr == 0)
7440 return SCPE_2FARG;
7441 if ((r = parse_sym ((CONST char *)cptr, 0, dptr->units, sim_eval, sim_switches)) > 0) {
7442 sim_eval[0] = get_uint (cptr, rdx, width_mask[dptr->dwidth], &r);
7443 if (r != SCPE_OK)
7444 return r;
7445 }
7446 lim = 1 - r;
7447 for (i = a = 0; a < lim; ) {
7448 sim_printf ("%d:\t", a);
7449 if ((r = fprint_sym (stdout, a, &sim_eval[i], dptr->units, sim_switches)) > 0)
7450 r = fprint_val (stdout, sim_eval[i], rdx, dptr->dwidth, PV_RZRO);
7451 if (sim_log) {
7452 if ((r = fprint_sym (sim_log, a, &sim_eval[i], dptr->units, sim_switches)) > 0)
7453 r = fprint_val (sim_log, sim_eval[i], rdx, dptr->dwidth, PV_RZRO);
7454 }
7455 sim_printf ("\r\n");
7456 if (r < 0)
7457 a = a + 1 - r;
7458 else a = a + dptr->aincr;
7459 i = a / dptr->aincr;
7460 }
7461 return SCPE_OK;
7462 }
7463
7464
7465
7466
7467
7468
7469
7470
7471
7472
7473
7474
7475
7476
7477 char *read_line (char *cptr, int32 size, FILE *stream)
7478 {
7479 return read_line_p (NULL, cptr, size, stream);
7480 }
7481
7482
7483
7484
7485
7486
7487
7488
7489
7490
7491
7492
7493
7494 char *read_line_p (const char *prompt, char *cptr, int32 size, FILE *stream)
7495 {
7496 char *tptr;
7497
7498 if (prompt) {
7499 #if defined(HAVE_LINEHISTORY)
7500 char *tmpc = linenoise (prompt);
7501 if (tmpc == NULL)
7502 cptr = NULL;
7503 else {
7504 strncpy (cptr, tmpc, size-1);
7505 linenoiseHistoryAdd (tmpc);
7506 FREE (tmpc);
7507 }
7508 }
7509 #else
7510 (void)fflush (stdout);
7511 (void)printf ("%s", prompt);
7512 (void)fflush (stdout);
7513 cptr = fgets (cptr, size, stream);
7514 }
7515 #endif
7516 else cptr = fgets (cptr, size, stream);
7517
7518 if (cptr == NULL) {
7519 clearerr (stream);
7520 return NULL;
7521 }
7522 for (tptr = cptr; tptr < (cptr + size); tptr++) {
7523 if ((*tptr == '\n') || (*tptr == '\r') ||
7524 (tptr == (cptr + size - 1))) {
7525 *tptr = 0;
7526 break;
7527 }
7528 }
7529 if (0 == memcmp (cptr, "\xEF\xBB\xBF", 3))
7530 memmove (cptr, cptr + 3, strlen (cptr + 3));
7531 while (sim_isspace (*cptr))
7532 cptr++;
7533 if ((*cptr == ';') || (*cptr == '#')) {
7534 if (sim_do_echo)
7535 sim_printf("%s> %s\r\n", do_position(), cptr);
7536 *cptr = 0;
7537 }
7538
7539 return cptr;
7540 }
7541
7542
7543
7544
7545
7546
7547
7548
7549
7550
7551
7552
7553
7554
7555
7556
7557
7558
7559
7560 static const char *get_glyph_gen (const char *iptr, char *optr, char mchar, t_bool uc, t_bool quote, char escape_char)
7561 {
7562 t_bool quoting = FALSE;
7563 t_bool escaping = FALSE;
7564 char quote_char = 0;
7565
7566 while ((*iptr != 0) &&
7567 ((quote && quoting) || ((sim_isspace (*iptr) == 0) && (*iptr != mchar)))) {
7568 if (quote) {
7569 if (quoting) {
7570 if (!escaping) {
7571 if (*iptr == escape_char)
7572 escaping = TRUE;
7573 else
7574 if (*iptr == quote_char)
7575 quoting = FALSE;
7576 }
7577 else
7578 escaping = FALSE;
7579 }
7580 else {
7581 if ((*iptr == '"') || (*iptr == '\'')) {
7582 quoting = TRUE;
7583 quote_char = *iptr;
7584 }
7585 }
7586 }
7587 if (sim_islower (*iptr) && uc)
7588 *optr = (char)toupper (*iptr);
7589 else *optr = *iptr;
7590 iptr++; optr++;
7591 }
7592 if (mchar && (*iptr == mchar))
7593 iptr++;
7594 *optr = 0;
7595 while (sim_isspace (*iptr))
7596 iptr++;
7597 return iptr;
7598 }
7599
7600 CONST char *get_glyph (const char *iptr, char *optr, char mchar)
7601 {
7602 return (CONST char *)get_glyph_gen (iptr, optr, mchar, TRUE, FALSE, 0);
7603 }
7604
7605 CONST char *get_glyph_nc (const char *iptr, char *optr, char mchar)
7606 {
7607 return (CONST char *)get_glyph_gen (iptr, optr, mchar, FALSE, FALSE, 0);
7608 }
7609
7610 CONST char *get_glyph_quoted (const char *iptr, char *optr, char mchar)
7611 {
7612 return (CONST char *)get_glyph_gen (iptr, optr, mchar, FALSE, TRUE, '\\');
7613 }
7614
7615 CONST char *get_glyph_cmd (const char *iptr, char *optr)
7616 {
7617
7618 if ((iptr[0] == '!') && (!sim_isspace(iptr[1]))) {
7619 strcpy (optr, "!");
7620 return (CONST char *)(iptr + 1);
7621 }
7622 return (CONST char *)get_glyph_gen (iptr, optr, 0, TRUE, FALSE, 0);
7623 }
7624
7625
7626
7627
7628
7629
7630
7631
7632
7633 char *sim_trim_endspc (char *cptr)
7634 {
7635 char *tptr;
7636
7637 tptr = cptr + strlen (cptr);
7638 while ((--tptr >= cptr) && sim_isspace (*tptr))
7639 *tptr = 0;
7640 return cptr;
7641 }
7642
7643 int sim_isspace (char c)
7644 {
7645 return (c & 0x80) ? 0 : isspace (c);
7646 }
7647
7648 int sim_islower (char c)
7649 {
7650 return (c & 0x80) ? 0 : islower (c);
7651 }
7652
7653 int sim_isalpha (char c)
7654 {
7655 return (c & 0x80) ? 0 : isalpha (c);
7656 }
7657
7658 int sim_isprint (char c)
7659 {
7660 return (c & 0x80) ? 0 : isprint (c);
7661 }
7662
7663 int sim_isdigit (char c)
7664 {
7665 return (c & 0x80) ? 0 : isdigit (c);
7666 }
7667
7668 int sim_isgraph (char c)
7669 {
7670 return (c & 0x80) ? 0 : isgraph (c);
7671 }
7672
7673 int sim_isalnum (char c)
7674 {
7675 return (c & 0x80) ? 0 : isalnum (c);
7676 }
7677
7678
7679
7680
7681
7682
7683
7684
7685
7686
7687
7688
7689 t_value get_uint (const char *cptr, uint32 radix, t_value max, t_stat *status)
7690 {
7691 t_value val;
7692 CONST char *tptr;
7693
7694 *status = SCPE_OK;
7695 val = strtotv ((CONST char *)cptr, &tptr, radix);
7696 if ((cptr == tptr) || (val > max))
7697 *status = SCPE_ARG;
7698 else {
7699 while (sim_isspace (*tptr)) tptr++;
7700 if (*tptr != 0)
7701 *status = SCPE_ARG;
7702 }
7703 return val;
7704 }
7705
7706
7707
7708
7709
7710
7711
7712
7713
7714
7715
7716
7717
7718
7719
7720
7721 CONST char *get_range (DEVICE *dptr, CONST char *cptr, t_addr *lo, t_addr *hi,
7722 uint32 rdx, t_addr max, char term)
7723 {
7724 CONST char *tptr;
7725
7726 if (max && strncmp (cptr, "ALL", strlen ("ALL")) == 0) {
7727 tptr = cptr + strlen ("ALL");
7728 *lo = 0;
7729 *hi = max;
7730 }
7731 else {
7732 if ((strncmp (cptr, ".", strlen (".")) == 0) &&
7733 ((cptr[1] == '\0') ||
7734 (cptr[1] == '-') ||
7735 (cptr[1] == ':') ||
7736 (cptr[1] == '/'))) {
7737 tptr = cptr + strlen (".");
7738 *lo = *hi = sim_last_addr;
7739 }
7740 else {
7741 if (strncmp (cptr, "$", strlen ("$")) == 0) {
7742 tptr = cptr + strlen ("$");
7743 *hi = *lo = (t_addr)sim_last_val;
7744 }
7745 else {
7746 if (dptr && sim_vm_parse_addr)
7747 *lo = sim_vm_parse_addr (dptr, cptr, &tptr);
7748 else
7749 *lo = (t_addr) strtotv (cptr, &tptr, rdx);
7750 if (cptr == tptr)
7751 return NULL;
7752 }
7753 }
7754 if ((*tptr == '-') || (*tptr == ':')) {
7755 cptr = tptr + 1;
7756 if (dptr && sim_vm_parse_addr)
7757 *hi = sim_vm_parse_addr (dptr, cptr, &tptr);
7758 else *hi = (t_addr) strtotv (cptr, &tptr, rdx);
7759 if (cptr == tptr)
7760 return NULL;
7761 if (*lo > *hi)
7762 return NULL;
7763 }
7764 else if (*tptr == '/') {
7765 cptr = tptr + 1;
7766 *hi = (t_addr) strtotv (cptr, &tptr, rdx);
7767 if ((cptr == tptr) || (*hi == 0))
7768 return NULL;
7769 *hi = *lo + *hi - 1;
7770 }
7771 else *hi = *lo;
7772 }
7773 sim_last_addr = *hi;
7774 if (term && (*tptr++ != term))
7775 return NULL;
7776 return tptr;
7777 }
7778
7779
7780
7781
7782
7783
7784
7785
7786
7787
7788
7789
7790
7791
7792
7793
7794
7795
7796
7797 t_stat sim_decode_quoted_string (const char *iptr, uint8 *optr, uint32 *osize)
7798 {
7799 char quote_char;
7800 uint8 *ostart = optr;
7801
7802 *osize = 0;
7803 if ((strlen(iptr) == 1) ||
7804 (iptr[0] != iptr[strlen(iptr)-1]) ||
7805 ((iptr[strlen(iptr)-1] != '"') && (iptr[strlen(iptr)-1] != '\'')))
7806 return SCPE_ARG;
7807 quote_char = *iptr++;
7808 while (iptr[1]) {
7809 if (*iptr != '\\') {
7810 if (*iptr == quote_char)
7811 return SCPE_ARG;
7812 *(optr++) = (uint8)(*(iptr++));
7813 continue;
7814 }
7815 ++iptr;
7816 switch (*iptr) {
7817 case 'r':
7818 *(optr++) = 13; ++iptr;
7819 break;
7820 case 'n':
7821 *(optr++) = 10; ++iptr;
7822 break;
7823 case 'f':
7824 *(optr++) = 12; ++iptr;
7825 break;
7826 case 't':
7827 *(optr++) = 9; ++iptr;
7828 break;
7829 case 'v':
7830 *(optr++) = 11; ++iptr;
7831 break;
7832 case 'b':
7833 *(optr++) = 8; ++iptr;
7834 break;
7835 case '\\':
7836 *(optr++) = 92; ++iptr;
7837 break;
7838 case 'e':
7839 *(optr++) = 27; ++iptr;
7840 break;
7841 case '\'':
7842 *(optr++) = 39; ++iptr;
7843 break;
7844 case '"':
7845 *(optr++) = 34; ++iptr;
7846 break;
7847 case '?':
7848 *(optr++) = 63; ++iptr;
7849 break;
7850 case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
7851 *optr = *(iptr++) - '0';
7852 if ((*iptr >= '0') && (*iptr <= '7'))
7853 *optr = ((*optr)<<3) + (*(iptr++) - '0');
7854 if ((*iptr >= '0') && (*iptr <= '7'))
7855 *optr = ((*optr)<<3) + (*(iptr++) - '0');
7856 ++optr;
7857 break;
7858 case 'x':
7859 if (1) {
7860 static const char *hex_digits = "0123456789ABCDEF";
7861 const char *c;
7862
7863 ++iptr;
7864 *optr = 0;
7865 c = strchr (hex_digits, toupper(*iptr));
7866 if (c) {
7867 *optr = ((*optr)<<4) + (uint8)(c-hex_digits);
7868 ++iptr;
7869 }
7870 c = strchr (hex_digits, toupper(*iptr));
7871 if (c) {
7872 *optr = ((*optr)<<4) + (uint8)(c-hex_digits);
7873 ++iptr;
7874 }
7875 ++optr;
7876 }
7877 break;
7878 default:
7879 return SCPE_ARG;
7880 }
7881 }
7882 *optr = '\0';
7883 *osize = (uint32)(optr-ostart);
7884 return SCPE_OK;
7885 }
7886
7887
7888
7889
7890
7891
7892
7893
7894
7895
7896
7897
7898
7899
7900 char *sim_encode_quoted_string (const uint8 *iptr, size_t size)
7901 {
7902 size_t i;
7903 t_bool double_quote_found = FALSE;
7904 t_bool single_quote_found = FALSE;
7905 char quote = '"';
7906 char *tptr, *optr;
7907
7908 optr = (char *)malloc (4*size + 3);
7909 if (optr == NULL)
7910 return NULL;
7911 tptr = optr;
7912 for (i=0; i<size; i++)
7913 switch ((char)iptr[i]) {
7914 case '"':
7915 double_quote_found = TRUE;
7916 break;
7917 case '\'':
7918 single_quote_found = TRUE;
7919 break;
7920 }
7921 if (double_quote_found && (!single_quote_found))
7922 quote = '\'';
7923 *tptr++ = quote;
7924 while (size--) {
7925 switch (*iptr) {
7926 case '\r':
7927 *tptr++ = '\\'; *tptr++ = 'r'; break;
7928 case '\n':
7929 *tptr++ = '\\'; *tptr++ = 'n'; break;
7930 case '\f':
7931 *tptr++ = '\\'; *tptr++ = 'f'; break;
7932 case '\t':
7933 *tptr++ = '\\'; *tptr++ = 't'; break;
7934 case '\v':
7935 *tptr++ = '\\'; *tptr++ = 'v'; break;
7936 case '\b':
7937 *tptr++ = '\\'; *tptr++ = 'b'; break;
7938 case '\\':
7939 *tptr++ = '\\'; *tptr++ = '\\'; break;
7940 case '"':
7941 case '\'':
7942 if (quote == *iptr)
7943 *tptr++ = '\\';
7944
7945 default:
7946 if (sim_isprint (*iptr))
7947 *tptr++ = *iptr;
7948 else {
7949 (void)sprintf (tptr, "\\%03o", *iptr);
7950 tptr += 4;
7951 }
7952 break;
7953 }
7954 ++iptr;
7955 }
7956 *tptr++ = quote;
7957 *tptr++ = '\0';
7958 return optr;
7959 }
7960
7961 void fprint_buffer_string (FILE *st, const uint8 *buf, size_t size)
7962 {
7963 char *string;
7964
7965 string = sim_encode_quoted_string (buf, size);
7966 (void)fprintf (st, "%s", string);
7967 FREE (string);
7968 }
7969
7970
7971
7972
7973
7974
7975
7976
7977
7978 DEVICE *find_dev (const char *cptr)
7979 {
7980 int32 i;
7981 DEVICE *dptr;
7982
7983 if (cptr == NULL)
7984 return NULL;
7985 for (i = 0; (dptr = sim_devices[i]) != NULL; i++) {
7986 if ((strcmp (cptr, dptr->name) == 0) ||
7987 (dptr->lname &&
7988 (strcmp (cptr, dptr->lname) == 0)))
7989 return dptr;
7990 }
7991 for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i) {
7992 if ((strcmp (cptr, dptr->name) == 0) ||
7993 (dptr->lname &&
7994 (strcmp (cptr, dptr->lname) == 0)))
7995 return dptr;
7996 }
7997 return NULL;
7998 }
7999
8000
8001
8002
8003
8004
8005
8006
8007
8008
8009
8010
8011 DEVICE *find_unit (const char *cptr, UNIT **uptr)
8012 {
8013 uint32 i, u;
8014 const char *nptr;
8015 const char *tptr;
8016 t_stat r;
8017 DEVICE *dptr;
8018
8019 if (uptr == NULL)
8020 return NULL;
8021 *uptr = NULL;
8022 if ((dptr = find_dev (cptr))) {
8023 if (qdisable (dptr))
8024 return NULL;
8025 *uptr = dptr->units;
8026 return dptr;
8027 }
8028
8029 for (i = 0; (dptr = sim_devices[i]) != NULL; i++) {
8030 if (qdisable (dptr))
8031 continue;
8032 if (dptr->numunits &&
8033 (((nptr = dptr->name) &&
8034 (strncmp (cptr, nptr, strlen (nptr)) == 0)) ||
8035 ((nptr = dptr->lname) &&
8036 (strncmp (cptr, nptr, strlen (nptr)) == 0)))) {
8037 tptr = cptr + strlen (nptr);
8038 if (sim_isdigit (*tptr)) {
8039 if (qdisable (dptr))
8040 return NULL;
8041 u = (uint32) get_uint (tptr, 10, dptr->numunits - 1, &r);
8042 if (r != SCPE_OK)
8043 *uptr = NULL;
8044 else
8045 *uptr = dptr->units + u;
8046 return dptr;
8047 }
8048 }
8049 for (u = 0; u < dptr->numunits; u++) {
8050 if (0 == strcmp (cptr, sim_uname (&dptr->units[u]))) {
8051 *uptr = &dptr->units[u];
8052 return dptr;
8053 }
8054 }
8055 }
8056 return NULL;
8057 }
8058
8059
8060
8061
8062
8063
8064
8065 t_stat sim_register_internal_device (DEVICE *dptr)
8066 {
8067 uint32 i;
8068
8069 for (i = 0; (sim_devices[i] != NULL); i++)
8070 if (sim_devices[i] == dptr)
8071 return SCPE_OK;
8072 for (i = 0; i < sim_internal_device_count; i++)
8073 if (sim_internal_devices[i] == dptr)
8074 return SCPE_OK;
8075 ++sim_internal_device_count;
8076 sim_internal_devices = (DEVICE **)realloc(sim_internal_devices, (sim_internal_device_count+1)*sizeof(*sim_internal_devices));
8077 if (!sim_internal_devices)
8078 {
8079 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8080 __func__, __FILE__, __LINE__);
8081 #if defined(USE_BACKTRACE)
8082 # if defined(SIGUSR2)
8083 (void)raise(SIGUSR2);
8084
8085 # endif
8086 #endif
8087 abort();
8088 }
8089 sim_internal_devices[sim_internal_device_count-1] = dptr;
8090 sim_internal_devices[sim_internal_device_count] = NULL;
8091 return SCPE_OK;
8092 }
8093
8094
8095
8096
8097
8098
8099
8100
8101
8102 DEVICE *find_dev_from_unit (UNIT *uptr)
8103 {
8104 DEVICE *dptr;
8105 uint32 i, j;
8106
8107 if (uptr == NULL)
8108 return NULL;
8109 for (i = 0; (dptr = sim_devices[i]) != NULL; i++) {
8110 for (j = 0; j < dptr->numunits; j++) {
8111 if (uptr == (dptr->units + j))
8112 return dptr;
8113 }
8114 }
8115 for (i = 0; i<sim_internal_device_count; i++) {
8116 dptr = sim_internal_devices[i];
8117 for (j = 0; j < dptr->numunits; j++) {
8118 if (uptr == (dptr->units + j))
8119 return dptr;
8120 }
8121 }
8122 return NULL;
8123 }
8124
8125
8126
8127 t_bool qdisable (DEVICE *dptr)
8128 {
8129 return (dptr->flags & DEV_DIS? TRUE: FALSE);
8130 }
8131
8132
8133
8134
8135
8136
8137
8138
8139
8140
8141
8142
8143
8144 REG *find_reg_glob (CONST char *cptr, CONST char **optr, DEVICE **gdptr)
8145 {
8146 int32 i;
8147 DEVICE *dptr;
8148 REG *rptr, *srptr = NULL;
8149
8150 *gdptr = NULL;
8151 for (i = 0; (dptr = sim_devices[i]) != 0; i++) {
8152 if (dptr->flags & DEV_DIS)
8153 continue;
8154 if ((rptr = find_reg (cptr, optr, dptr))) {
8155 if (srptr)
8156 return NULL;
8157 srptr = rptr;
8158 *gdptr = dptr;
8159 }
8160 }
8161 return srptr;
8162 }
8163
8164
8165
8166
8167
8168
8169
8170
8171
8172
8173
8174
8175 REG *find_reg (CONST char *cptr, CONST char **optr, DEVICE *dptr)
8176 {
8177 CONST char *tptr;
8178 REG *rptr;
8179 size_t slnt;
8180
8181 if ((cptr == NULL) || (dptr == NULL) || (dptr->registers == NULL))
8182 return NULL;
8183 tptr = cptr;
8184 do {
8185 tptr++;
8186 } while (sim_isalnum (*tptr) || (*tptr == '*') || (*tptr == '_') || (*tptr == '.'));
8187 slnt = tptr - cptr;
8188 for (rptr = dptr->registers; rptr->name != NULL; rptr++) {
8189 if ((slnt == strlen (rptr->name)) &&
8190 (strncmp (cptr, rptr->name, slnt) == 0)) {
8191 if (optr != NULL)
8192 *optr = tptr;
8193 return rptr;
8194 }
8195 }
8196 return NULL;
8197 }
8198
8199
8200
8201
8202
8203
8204
8205
8206
8207
8208 int32 get_switches (const char *cptr)
8209 {
8210 int32 sw;
8211
8212 if (*cptr != '-')
8213 return 0;
8214 sw = 0;
8215 for (cptr++; (sim_isspace (*cptr) == 0) && (*cptr != 0); cptr++) {
8216 if (sim_isalpha (*cptr) == 0)
8217 return -1;
8218 sw = sw | SWMASK (toupper (*cptr));
8219 }
8220 return sw;
8221 }
8222
8223
8224
8225
8226
8227
8228
8229
8230
8231
8232 CONST char *get_sim_sw (CONST char *cptr)
8233 {
8234 int32 lsw;
8235 char gbuf[CBUFSIZE];
8236
8237 while (*cptr == '-') {
8238 cptr = get_glyph (cptr, gbuf, 0);
8239 lsw = get_switches (gbuf);
8240 if (lsw <= 0)
8241 return NULL;
8242 sim_switches = sim_switches | lsw;
8243 }
8244 return cptr;
8245 }
8246
8247
8248
8249
8250
8251
8252
8253
8254
8255
8256
8257 CONST char *get_sim_opt (int32 opt, CONST char *cptr, t_stat *st)
8258 {
8259 int32 t;
8260 char gbuf[CBUFSIZE];
8261 CONST char *svptr;
8262 DEVICE *tdptr;
8263 UNIT *tuptr;
8264
8265 sim_switches = 0;
8266 sim_ofile = NULL;
8267 sim_schrptr = NULL;
8268 sim_schaptr = NULL;
8269 sim_stabr.logic = sim_staba.logic = SCH_OR;
8270 sim_stabr.boolop = sim_staba.boolop = SCH_GE;
8271 sim_stabr.count = 1;
8272 sim_stabr.mask = (t_value *)realloc (sim_stabr.mask, sim_emax * sizeof(*sim_stabr.mask));
8273 if (!sim_stabr.mask)
8274 {
8275 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8276 __func__, __FILE__, __LINE__);
8277 #if defined(USE_BACKTRACE)
8278 # if defined(SIGUSR2)
8279 (void)raise(SIGUSR2);
8280
8281 # endif
8282 #endif
8283 abort();
8284 }
8285 (void)memset (sim_stabr.mask, 0, sim_emax * sizeof(*sim_stabr.mask));
8286 sim_stabr.comp = (t_value *)realloc (sim_stabr.comp, sim_emax * sizeof(*sim_stabr.comp));
8287 if (!sim_stabr.comp)
8288 {
8289 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8290 __func__, __FILE__, __LINE__);
8291 #if defined(USE_BACKTRACE)
8292 # if defined(SIGUSR2)
8293 (void)raise(SIGUSR2);
8294
8295 # endif
8296 #endif
8297 abort();
8298 }
8299 (void)memset (sim_stabr.comp, 0, sim_emax * sizeof(*sim_stabr.comp));
8300 sim_staba.count = sim_emax;
8301 sim_staba.mask = (t_value *)realloc (sim_staba.mask, sim_emax * sizeof(*sim_staba.mask));
8302 if (!sim_staba.mask)
8303 {
8304 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8305 __func__, __FILE__, __LINE__);
8306 #if defined(USE_BACKTRACE)
8307 # if defined(SIGUSR2)
8308 (void)raise(SIGUSR2);
8309
8310 # endif
8311 #endif
8312 abort();
8313 }
8314 (void)memset (sim_staba.mask, 0, sim_emax * sizeof(*sim_staba.mask));
8315 sim_staba.comp = (t_value *)realloc (sim_staba.comp, sim_emax * sizeof(*sim_staba.comp));
8316 if (!sim_staba.comp)
8317 {
8318 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8319 __func__, __FILE__, __LINE__);
8320 #if defined(USE_BACKTRACE)
8321 # if defined(SIGUSR2)
8322 (void)raise(SIGUSR2);
8323
8324 # endif
8325 #endif
8326 abort();
8327 }
8328 (void)memset (sim_staba.comp, 0, sim_emax * sizeof(*sim_staba.comp));
8329 if (! sim_dflt_dev)
8330 return NULL;
8331 sim_dfdev = sim_dflt_dev;
8332 sim_dfunit = sim_dfdev->units;
8333 sim_opt_out = 0;
8334 *st = SCPE_OK;
8335 while (*cptr) {
8336 svptr = cptr;
8337 if ((opt & CMD_OPT_OF) && (*cptr == '@')) {
8338 if (sim_ofile) {
8339 fclose (sim_ofile);
8340 *st = SCPE_ARG;
8341 return NULL;
8342 }
8343 cptr = get_glyph (cptr + 1, gbuf, 0);
8344 sim_ofile = sim_fopen (gbuf, "a");
8345 if (sim_ofile == NULL) {
8346 *st = SCPE_OPENERR;
8347 return NULL;
8348 }
8349 sim_opt_out |= CMD_OPT_OF;
8350 continue;
8351 }
8352 cptr = get_glyph (cptr, gbuf, 0);
8353 if ((t = get_switches (gbuf)) != 0) {
8354 if (t < 0) {
8355 *st = SCPE_INVSW;
8356 return NULL;
8357 }
8358 sim_switches = sim_switches | t;
8359 }
8360 else if ((opt & CMD_OPT_SCH) &&
8361 get_rsearch (gbuf, sim_dfdev->dradix, &sim_stabr)) {
8362 sim_schrptr = &sim_stabr;
8363 sim_schaptr = get_asearch (gbuf, sim_dfdev->dradix, &sim_staba);
8364 sim_opt_out |= CMD_OPT_SCH;
8365 }
8366 else if ((opt & CMD_OPT_DFT) &&
8367 ((sim_opt_out & CMD_OPT_DFT) == 0) &&
8368 (tdptr = find_unit (gbuf, &tuptr)) &&
8369 (tuptr != NULL)) {
8370 sim_dfdev = tdptr;
8371 sim_dfunit = tuptr;
8372 sim_opt_out |= CMD_OPT_DFT;
8373 }
8374 else return svptr;
8375 }
8376 return cptr;
8377 }
8378
8379
8380
8381
8382
8383
8384
8385
8386
8387
8388
8389 const char *put_switches (char *buf, size_t bufsize, uint32 sw)
8390 {
8391 char *optr = buf;
8392 int32 bit;
8393
8394 (void)memset (buf, 0, bufsize);
8395 if ((sw == 0) || (bufsize < 3))
8396 return buf;
8397 --bufsize;
8398 *optr++ = '-';
8399 for (bit=0; bit <= ('Z'-'A'); bit++)
8400 if (sw & (1 << bit))
8401 if ((size_t)(optr - buf) < bufsize)
8402 *optr++ = 'A' + bit;
8403 return buf;
8404 }
8405
8406
8407
8408
8409
8410
8411
8412
8413
8414
8415
8416
8417 SCHTAB *get_rsearch (CONST char *cptr, int32 radix, SCHTAB *schptr)
8418 {
8419 int32 c;
8420 size_t logop, cmpop;
8421 t_value logval, cmpval;
8422 const char *sptr;
8423 CONST char *tptr;
8424 const char logstr[] = "|&^", cmpstr[] = "=!><";
8425
8426 const size_t invalid_op = (size_t) -1;
8427
8428 logval = cmpval = 0;
8429 if (*cptr == 0)
8430 return NULL;
8431
8432 for (logop = cmpop = invalid_op; (c = *cptr++); ) {
8433 if ((sptr = strchr (logstr, c))) {
8434 logop = sptr - logstr;
8435 logval = strtotv (cptr, &tptr, radix);
8436 if (cptr == tptr)
8437 return NULL;
8438 cptr = tptr;
8439 }
8440 else if ((sptr = strchr (cmpstr, c))) {
8441 cmpop = sptr - cmpstr;
8442 if (*cptr == '=') {
8443 cmpop = cmpop + strlen (cmpstr);
8444 cptr++;
8445 }
8446 cmpval = strtotv (cptr, &tptr, radix);
8447 if (cptr == tptr)
8448 return NULL;
8449 cptr = tptr;
8450 }
8451 else return NULL;
8452 }
8453 if (schptr->count != 1) {
8454 FREE (schptr->mask);
8455 schptr->mask = (t_value *)calloc (sim_emax, sizeof(*schptr->mask));
8456 FREE (schptr->comp);
8457 schptr->comp = (t_value *)calloc (sim_emax, sizeof(*schptr->comp));
8458 }
8459 if (logop != invalid_op) {
8460 schptr->logic = logop;
8461 schptr->mask[0] = logval;
8462 }
8463 if (cmpop != invalid_op) {
8464 schptr->boolop = cmpop;
8465 schptr->comp[0] = cmpval;
8466 }
8467 schptr->count = 1;
8468 return schptr;
8469 }
8470
8471
8472
8473
8474
8475
8476
8477
8478
8479
8480
8481
8482 SCHTAB *get_asearch (CONST char *cptr, int32 radix, SCHTAB *schptr)
8483 {
8484 int32 c;
8485 size_t logop, cmpop;
8486 t_value *logval, *cmpval;
8487 t_stat reason = SCPE_OK;
8488 CONST char *ocptr = cptr;
8489 const char *sptr;
8490 char gbuf[CBUFSIZE];
8491 const char logstr[] = "|&^", cmpstr[] = "=!><";
8492
8493 const size_t invalid_op = (size_t) -1;
8494
8495 if (*cptr == 0)
8496 return NULL;
8497 logval = (t_value *)calloc (sim_emax, sizeof(*logval));
8498 cmpval = (t_value *)calloc (sim_emax, sizeof(*cmpval));
8499
8500 for (logop = cmpop = invalid_op; (c = *cptr++); ) {
8501 if (NULL != (sptr = strchr (logstr, c))) {
8502 logop = sptr - logstr;
8503 cptr = get_glyph (cptr, gbuf, 0);
8504 reason = parse_sym (gbuf, 0, sim_dfunit, logval, sim_switches);
8505 if (reason > 0) {
8506 FREE (logval);
8507 FREE (cmpval);
8508 return get_rsearch (ocptr, radix, schptr);
8509 }
8510 }
8511 else if (NULL != (sptr = strchr (cmpstr, c))) {
8512 cmpop = sptr - cmpstr;
8513 if (*cptr == '=') {
8514 cmpop = cmpop + strlen (cmpstr);
8515 cptr++;
8516 }
8517 cptr = get_glyph (cptr, gbuf, 0);
8518 reason = parse_sym (gbuf, 0, sim_dfunit, cmpval, sim_switches);
8519 if (reason > 0) {
8520 FREE (logval);
8521 FREE (cmpval);
8522 return get_rsearch (ocptr, radix, schptr);
8523 }
8524 }
8525 else {
8526 FREE (logval);
8527 FREE (cmpval);
8528 return NULL;
8529 }
8530 }
8531 if (schptr->count != (uint32)(1 - reason)) {
8532 schptr->count = 1 - reason;
8533 FREE (schptr->mask);
8534 schptr->mask = (t_value *)calloc (sim_emax, sizeof(*schptr->mask));
8535 FREE (schptr->comp);
8536 schptr->comp = (t_value *)calloc (sim_emax, sizeof(*schptr->comp));
8537 }
8538 if (logop != invalid_op) {
8539 schptr->logic = logop;
8540 FREE (schptr->mask);
8541 schptr->mask = logval;
8542 }
8543 else {
8544 FREE (logval);
8545 }
8546 if (cmpop != invalid_op) {
8547 schptr->boolop = cmpop;
8548 FREE (schptr->comp);
8549 schptr->comp = cmpval;
8550 }
8551 else {
8552 FREE (cmpval);
8553 }
8554 return schptr;
8555 }
8556
8557
8558
8559
8560
8561
8562
8563
8564
8565
8566 int32 test_search (t_value *values, SCHTAB *schptr)
8567 {
8568 t_value *val = NULL;
8569 int32 i, updown;
8570 int32 ret = 0;
8571
8572 if (schptr == NULL)
8573 return ret;
8574
8575 val = (t_value *)malloc (schptr->count * sizeof (*values));
8576 if (!val)
8577 {
8578 (void)fprintf(stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8579 __func__, __FILE__, __LINE__);
8580 #if defined(USE_BACKTRACE)
8581 # if defined(SIGUSR2)
8582 (void)raise(SIGUSR2);
8583
8584 # endif
8585 #endif
8586 abort();
8587 }
8588 for (i=0; i<(int32)schptr->count; i++) {
8589 val[i] = values[i];
8590 switch (schptr->logic) {
8591
8592 case SCH_OR:
8593 val[i] = val[i] | schptr->mask[i];
8594 break;
8595
8596 case SCH_AND:
8597 val[i] = val[i] & schptr->mask[i];
8598 break;
8599
8600 case SCH_XOR:
8601 val[i] = val[i] ^ schptr->mask[i];
8602 break;
8603 }
8604 }
8605
8606 ret = 1;
8607 if (1) {
8608 updown = -1;
8609 i=schptr->count-1;
8610 }
8611 else {
8612 updown = 1;
8613 i=0;
8614 }
8615 for (; (i>=0) && (i<(int32)schptr->count) && ret; i += updown) {
8616 switch (schptr->boolop) {
8617
8618 case SCH_E: case SCH_EE:
8619 if (val[i] != schptr->comp[i])
8620 ret = 0;
8621 break;
8622
8623 case SCH_N: case SCH_NE:
8624 if (val[i] == schptr->comp[i])
8625 ret = 0;
8626 break;
8627
8628 case SCH_G:
8629 if (val[i] <= schptr->comp[i])
8630 ret = 0;
8631 break;
8632
8633 case SCH_GE:
8634 if (val[i] < schptr->comp[i])
8635 ret = 0;
8636 break;
8637
8638 case SCH_L:
8639 if (val[i] >= schptr->comp[i])
8640 ret = 0;
8641 break;
8642
8643 case SCH_LE:
8644 if (val[i] > schptr->comp[i])
8645 ret = 0;
8646 break;
8647 }
8648 }
8649 FREE (val);
8650 return ret;
8651 }
8652
8653
8654
8655
8656
8657
8658
8659
8660
8661
8662
8663
8664
8665
8666
8667 t_value strtotv (CONST char *inptr, CONST char **endptr, uint32 radix)
8668 {
8669 int32 nodigit;
8670 t_value val;
8671 uint32 c, digit;
8672
8673 *endptr = inptr;
8674 if ((radix < 2) || (radix > 36))
8675 return 0;
8676 while (sim_isspace (*inptr))
8677 inptr++;
8678 val = 0;
8679 nodigit = 1;
8680 for (c = *inptr; sim_isalnum(c); c = *++inptr) {
8681 if (sim_islower (c))
8682 c = toupper (c);
8683 if (sim_isdigit (c))
8684 digit = c - (uint32) '0';
8685 else if (radix <= 10)
8686 break;
8687 else digit = c + 10 - (uint32) 'A';
8688 if (digit >= radix)
8689 return 0;
8690 val = (val * radix) + digit;
8691 nodigit = 0;
8692 }
8693 if (nodigit)
8694 return 0;
8695 *endptr = inptr;
8696 return val;
8697 }
8698
8699
8700
8701
8702
8703
8704
8705
8706
8707
8708
8709
8710
8711
8712
8713 t_stat sprint_val (char *buffer, t_value val, uint32 radix,
8714 size_t width, uint32 format)
8715 {
8716 #define MAX_WIDTH ((CHAR_BIT * sizeof (t_value) * 4 + 3) / 3)
8717 t_value owtest, wtest;
8718 size_t d;
8719 size_t digit;
8720 size_t ndigits;
8721 size_t commas = 0;
8722 char dbuf[MAX_WIDTH + 1];
8723
8724 for (d = 0; d < MAX_WIDTH; d++)
8725 dbuf[d] = (format == PV_RZRO)? '0': ' ';
8726 dbuf[MAX_WIDTH] = 0;
8727 d = MAX_WIDTH;
8728 do {
8729 d = d - 1;
8730 digit = val % radix;
8731 val = val / radix;
8732 dbuf[d] = (char)((digit <= 9)? '0' + digit: 'A' + (digit - 10));
8733 } while ((d > 0) && (val != 0));
8734
8735 switch (format) {
8736 case PV_LEFT:
8737 break;
8738 case PV_RZRO:
8739 wtest = owtest = radix;
8740 ndigits = 1;
8741 while ((wtest < width_mask[width]) && (wtest >= owtest)) {
8742 owtest = wtest;
8743 wtest = wtest * radix;
8744 ndigits = ndigits + 1;
8745 }
8746 if ((MAX_WIDTH - (ndigits + commas)) < d)
8747 d = MAX_WIDTH - (ndigits + commas);
8748 break;
8749 }
8750 if (NULL == buffer)
8751 return ((t_stat) strlen(dbuf+d));
8752 *buffer = '\0';
8753 if (width < strlen(dbuf+d))
8754 return SCPE_IOERR;
8755 strcpy(buffer, dbuf+d);
8756 return SCPE_OK;
8757 }
8758
8759 t_stat fprint_val (FILE *stream, t_value val, uint32 radix,
8760 uint32 width, uint32 format)
8761 {
8762 char dbuf[MAX_WIDTH + 1];
8763
8764 if (!stream)
8765 return sprint_val (NULL, val, radix, width, format);
8766 if (width > MAX_WIDTH)
8767 width = MAX_WIDTH;
8768 sprint_val (dbuf, val, radix, width, format);
8769 if (Fprintf (stream, "%s", dbuf) < 0)
8770 return SCPE_IOERR;
8771 return SCPE_OK;
8772 }
8773
8774 const char *sim_fmt_secs (double seconds)
8775 {
8776 static char buf[60];
8777 char frac[16] = "";
8778 const char *sign = "";
8779 double val = seconds;
8780 double days, hours, mins, secs, msecs, usecs;
8781
8782 if (val == 0.0)
8783 return "";
8784 if (val < 0.0) {
8785 sign = "-";
8786 val = -val;
8787 }
8788 days = floor (val / (24.0*60.0*60.0));
8789 val -= (days * 24.0*60.0*60.0);
8790 hours = floor (val / (60.0*60.0));
8791 val -= (hours * 60.0 * 60.0);
8792 mins = floor (val / 60.0);
8793 val -= (mins * 60.0);
8794 secs = floor (val);
8795 val -= secs;
8796 val *= 1000.0;
8797 msecs = floor (val);
8798 val -= msecs;
8799 val *= 1000.0;
8800 usecs = floor (val+0.5);
8801 if (usecs == 1000.0) {
8802 usecs = 0.0;
8803 msecs += 1;
8804 }
8805 if ((msecs > 0.0) || (usecs > 0.0)) {
8806 (void)sprintf (frac, ".%03.0f%03.0f", msecs, usecs);
8807 while (frac[strlen (frac) - 1] == '0')
8808 frac[strlen (frac) - 1] = '\0';
8809 if (strlen (frac) == 1)
8810 frac[0] = '\0';
8811 }
8812 if (days > 0)
8813 (void)sprintf (buf, "%s%.0f day%s %02.0f:%02.0f:%02.0f%s hour%s",
8814 sign, days, (days != 1) ? "s" : "", hours, mins,
8815 secs, frac, (days == 1) ? "s" : "");
8816 else
8817 if (hours > 0)
8818 (void)sprintf (buf, "%s%.0f:%02.0f:%02.0f%s hour",
8819 sign, hours, mins, secs, frac);
8820 else
8821 if (mins > 0)
8822 (void)sprintf (buf, "%s%.0f:%02.0f%s minute",
8823 sign, mins, secs, frac);
8824 else
8825 if (secs > 0)
8826 (void)sprintf (buf, "%s%.0f%s second",
8827 sign, secs, frac);
8828 else
8829 if (msecs > 0) {
8830 if (usecs > 0)
8831 (void)sprintf (buf, "%s%.0f.%s msec",
8832 sign, msecs, frac+4);
8833 else
8834 (void)sprintf (buf, "%s%.0f msec",
8835 sign, msecs);
8836 }
8837 else
8838 (void)sprintf (buf, "%s%.0f usec",
8839 sign, usecs);
8840 if (0 != strncmp ("1 ", buf, 2))
8841 strcpy (&buf[strlen (buf)], "s");
8842 return buf;
8843 }
8844
8845
8846
8847
8848
8849
8850
8851
8852
8853
8854
8855
8856
8857
8858
8859
8860 t_stat sim_process_event (void)
8861 {
8862 UNIT *uptr;
8863 t_stat reason;
8864 #if defined(TESTING)
8865 cpu_state_t * cpup = _cpup;
8866 #endif
8867
8868 if (stop_cpu)
8869 {
8870 #if defined(WIN_STDIO)
8871 (void)fflush(stdout);
8872 (void)fflush(stderr);
8873 #endif
8874 return SCPE_STOP;
8875 }
8876 UPDATE_SIM_TIME;
8877
8878 if (sim_clock_queue == QUEUE_LIST_END) {
8879 sim_interval = noqueue_time = NOQUEUE_WAIT;
8880 sim_debug (SIM_DBG_EVENT, sim_dflt_dev,
8881 "Queue Empty New Interval = %d\r\n",
8882 sim_interval);
8883 return SCPE_OK;
8884 }
8885 sim_processing_event = TRUE;
8886 do {
8887 uptr = sim_clock_queue;
8888 sim_clock_queue = uptr->next;
8889 uptr->next = NULL;
8890 sim_interval -= uptr->time;
8891 uptr->time = 0;
8892 if (sim_clock_queue != QUEUE_LIST_END)
8893 sim_interval = sim_clock_queue->time;
8894 else
8895 sim_interval = noqueue_time = NOQUEUE_WAIT;
8896 sim_debug (SIM_DBG_EVENT, sim_dflt_dev,
8897 "Processing Event for %s\r\n", sim_uname (uptr));
8898 if (uptr->action != NULL)
8899 reason = uptr->action (uptr);
8900 else
8901 reason = SCPE_OK;
8902 } while ((reason == SCPE_OK) &&
8903 (sim_interval <= 0) &&
8904 (sim_clock_queue != QUEUE_LIST_END) &&
8905 (!stop_cpu));
8906
8907 if (sim_clock_queue == QUEUE_LIST_END) {
8908 sim_interval = noqueue_time = NOQUEUE_WAIT;
8909 sim_debug (SIM_DBG_EVENT, sim_dflt_dev,
8910 "Processing Queue Complete New Interval = %d\r\n",
8911 sim_interval);
8912 }
8913 else
8914 sim_debug (SIM_DBG_EVENT, sim_dflt_dev,
8915 "Processing Queue Complete New Interval = %d(%s)\r\n",
8916 sim_interval, sim_uname(sim_clock_queue));
8917
8918 if ((reason == SCPE_OK) && stop_cpu)
8919 {
8920 #if defined(WIN_STDIO)
8921 (void)fflush(stdout);
8922 (void)fflush(stderr);
8923 #endif
8924 reason = SCPE_STOP;
8925 }
8926 sim_processing_event = FALSE;
8927 return reason;
8928 }
8929
8930
8931
8932
8933
8934
8935
8936
8937
8938
8939 t_stat sim_activate (UNIT *uptr, int32 event_time)
8940 {
8941 if (uptr->dynflags & UNIT_TMR_UNIT)
8942 return sim_timer_activate (uptr, event_time);
8943 return _sim_activate (uptr, event_time);
8944 }
8945
8946 t_stat _sim_activate (UNIT *uptr, int32 event_time)
8947 {
8948 UNIT *cptr, *prvptr;
8949 int32 accum;
8950 #if defined(TESTING)
8951 cpu_state_t * cpup = _cpup;
8952 #endif
8953
8954 if (sim_is_active (uptr))
8955 return SCPE_OK;
8956 UPDATE_SIM_TIME;
8957
8958 sim_debug (SIM_DBG_ACTIVATE, sim_dflt_dev, "Activating %s delay=%d\r\n", sim_uname (uptr), event_time);
8959
8960 prvptr = NULL;
8961 accum = 0;
8962 for (cptr = sim_clock_queue; cptr != QUEUE_LIST_END; cptr = cptr->next) {
8963 if (event_time < (accum + cptr->time))
8964 break;
8965 accum = accum + cptr->time;
8966 prvptr = cptr;
8967 }
8968 if (prvptr == NULL) {
8969 cptr = uptr->next = sim_clock_queue;
8970 sim_clock_queue = uptr;
8971 }
8972 else {
8973 cptr = uptr->next = prvptr->next;
8974 prvptr->next = uptr;
8975 }
8976 uptr->time = event_time - accum;
8977 if (cptr != QUEUE_LIST_END)
8978 cptr->time = cptr->time - uptr->time;
8979 sim_interval = sim_clock_queue->time;
8980 return SCPE_OK;
8981 }
8982
8983
8984
8985
8986
8987
8988
8989
8990
8991
8992 t_stat sim_activate_abs (UNIT *uptr, int32 event_time)
8993 {
8994 sim_cancel (uptr);
8995 return _sim_activate (uptr, event_time);
8996 }
8997
8998
8999
9000
9001
9002
9003
9004
9005
9006
9007 t_stat sim_activate_after (UNIT *uptr, uint32 usec_delay)
9008 {
9009 return _sim_activate_after (uptr, usec_delay);
9010 }
9011
9012 t_stat _sim_activate_after (UNIT *uptr, uint32 usec_delay)
9013 {
9014 if (sim_is_active (uptr))
9015 return SCPE_OK;
9016 return sim_timer_activate_after (uptr, usec_delay);
9017 }
9018
9019
9020
9021
9022
9023
9024
9025
9026
9027
9028 t_stat sim_cancel (UNIT *uptr)
9029 {
9030 UNIT *cptr, *nptr;
9031 #if defined(TESTING)
9032 cpu_state_t * cpup = _cpup;
9033 #endif
9034
9035 if (sim_clock_queue == QUEUE_LIST_END)
9036 return SCPE_OK;
9037 if (!sim_is_active (uptr))
9038 return SCPE_OK;
9039 UPDATE_SIM_TIME;
9040 sim_debug (SIM_DBG_EVENT, sim_dflt_dev, "Canceling Event for %s\r\n", sim_uname(uptr));
9041 nptr = QUEUE_LIST_END;
9042
9043 if (sim_clock_queue == uptr) {
9044 nptr = sim_clock_queue = uptr->next;
9045 uptr->next = NULL;
9046 }
9047 else {
9048 for (cptr = sim_clock_queue; cptr != QUEUE_LIST_END; cptr = cptr->next) {
9049 if (cptr->next == uptr) {
9050 nptr = cptr->next = uptr->next;
9051 uptr->next = NULL;
9052 break;
9053 }
9054 }
9055 }
9056 if (nptr != QUEUE_LIST_END)
9057 nptr->time += (uptr->next) ? 0 : uptr->time;
9058 if (!uptr->next)
9059 uptr->time = 0;
9060 if (sim_clock_queue != QUEUE_LIST_END)
9061 sim_interval = sim_clock_queue->time;
9062 else sim_interval = noqueue_time = NOQUEUE_WAIT;
9063 if (uptr->next) {
9064 sim_printf ("\rCancel failed for '%s'!\r\n", sim_uname(uptr));
9065 if (sim_deb)
9066 fclose(sim_deb);
9067 (void)fprintf (stderr, "\rFATAL: Bugcheck! Aborting at %s[%s:%d]\r\n",
9068 __func__, __FILE__, __LINE__);
9069 abort ();
9070 }
9071 return SCPE_OK;
9072 }
9073
9074
9075
9076
9077
9078
9079
9080
9081
9082 t_bool sim_is_active (UNIT *uptr)
9083 {
9084 if (uptr->next == NULL)
9085 return FALSE;
9086 else
9087 return TRUE;
9088 }
9089
9090
9091
9092
9093
9094
9095
9096
9097
9098 int32 sim_activate_time (UNIT *uptr)
9099 {
9100 UNIT *cptr;
9101 int32 accum = 0;
9102
9103 for (cptr = sim_clock_queue; cptr != QUEUE_LIST_END; cptr = cptr->next) {
9104 if (cptr == sim_clock_queue) {
9105 if (sim_interval > 0)
9106 accum = accum + sim_interval;
9107 }
9108 else
9109 accum = accum + cptr->time;
9110 if (cptr == uptr)
9111 return accum + 1;
9112 }
9113 return 0;
9114 }
9115
9116
9117
9118
9119
9120
9121
9122
9123 double sim_gtime (void)
9124 {
9125 return sim_time;
9126 }
9127
9128
9129
9130
9131
9132
9133
9134
9135 int32 sim_qcount (void)
9136 {
9137 int32 cnt;
9138 UNIT *uptr;
9139
9140 cnt = 0;
9141 for (uptr = sim_clock_queue; uptr != QUEUE_LIST_END; uptr = uptr->next)
9142 cnt++;
9143 return cnt;
9144 }
9145
9146
9147
9148
9149
9150
9151
9152
9153
9154
9155
9156
9157
9158
9159
9160
9161
9162
9163
9164
9165
9166
9167
9168
9169
9170
9171
9172
9173
9174
9175
9176
9177
9178
9179
9180
9181 t_stat sim_brk_init (void)
9182 {
9183 int32 i;
9184
9185 for (i=0; i<sim_brk_lnt; i++) {
9186 BRKTAB *bp;
9187 if (sim_brk_tab)
9188 {
9189 bp = sim_brk_tab[i];
9190
9191 while (bp)
9192 {
9193 BRKTAB *bpt = bp->next;
9194
9195 FREE (bp->act);
9196 FREE (bp);
9197 bp = bpt;
9198 }
9199 }
9200 }
9201 if (sim_brk_tab != NULL)
9202 (void)memset (sim_brk_tab, 0, sim_brk_lnt*sizeof (BRKTAB*));
9203 sim_brk_lnt = SIM_BRK_INILNT;
9204 sim_brk_tab = (BRKTAB **) realloc (sim_brk_tab, sim_brk_lnt*sizeof (BRKTAB*));
9205 if (sim_brk_tab == NULL)
9206 return SCPE_MEM;
9207 (void)memset (sim_brk_tab, 0, sim_brk_lnt*sizeof (BRKTAB*));
9208 sim_brk_ent = sim_brk_ins = 0;
9209 sim_brk_clract ();
9210 sim_brk_npc (0);
9211 return SCPE_OK;
9212 }
9213
9214
9215
9216 BRKTAB *sim_brk_fnd (t_addr loc)
9217 {
9218 int32 lo, hi, p;
9219 BRKTAB *bp;
9220
9221 if (sim_brk_ent == 0) {
9222 sim_brk_ins = 0;
9223 return NULL;
9224 }
9225 lo = 0;
9226 hi = sim_brk_ent - 1;
9227 do {
9228 p = (lo + hi) >> 1;
9229 bp = sim_brk_tab[p];
9230 if (loc == bp->addr) {
9231 sim_brk_ins = p;
9232 return bp;
9233 }
9234 else if (loc < bp->addr)
9235 hi = p - 1;
9236 else lo = p + 1;
9237 } while (lo <= hi);
9238 if (loc < bp->addr)
9239 sim_brk_ins = p;
9240 else sim_brk_ins = p + 1;
9241 return NULL;
9242 }
9243
9244 BRKTAB *sim_brk_fnd_ex (t_addr loc, uint32 btyp, t_bool any_typ, uint32 spc)
9245 {
9246 BRKTAB *bp = sim_brk_fnd (loc);
9247
9248 while (bp) {
9249 if (any_typ ? ((bp->typ & btyp) && (bp->time_fired[spc] != sim_gtime())) :
9250 (bp->typ == btyp))
9251 return bp;
9252 bp = bp->next;
9253 }
9254 return bp;
9255 }
9256
9257
9258
9259 BRKTAB *sim_brk_new (t_addr loc, uint32 btyp)
9260 {
9261 int32 i, t;
9262 BRKTAB *bp, **newp;
9263
9264 if (sim_brk_ins < 0)
9265 return NULL;
9266 if (sim_brk_ent >= sim_brk_lnt) {
9267 t = sim_brk_lnt + SIM_BRK_INILNT;
9268 newp = (BRKTAB **) calloc (t, sizeof (BRKTAB*));
9269 if (newp == NULL)
9270 return NULL;
9271 memcpy (newp, sim_brk_tab, sim_brk_lnt * sizeof (*sim_brk_tab));
9272 (void)memset (newp + sim_brk_lnt, 0, SIM_BRK_INILNT * sizeof (*newp));
9273 FREE (sim_brk_tab);
9274 sim_brk_tab = newp;
9275 sim_brk_lnt = t;
9276 }
9277 if ((sim_brk_ins == sim_brk_ent) ||
9278 ((sim_brk_ins != sim_brk_ent) &&
9279 (sim_brk_tab[sim_brk_ins]->addr != loc))) {
9280 for (i = sim_brk_ent; i > sim_brk_ins; --i)
9281 sim_brk_tab[i] = sim_brk_tab[i - 1];
9282 sim_brk_tab[sim_brk_ins] = NULL;
9283 }
9284 bp = (BRKTAB *)calloc (1, sizeof (*bp));
9285 if (!bp)
9286 {
9287 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
9288 __func__, __FILE__, __LINE__);
9289 #if defined(USE_BACKTRACE)
9290 # if defined(SIGUSR2)
9291 (void)raise(SIGUSR2);
9292
9293 # endif
9294 #endif
9295 abort();
9296 }
9297 bp->next = sim_brk_tab[sim_brk_ins];
9298 sim_brk_tab[sim_brk_ins] = bp;
9299 if (bp->next == NULL)
9300 sim_brk_ent += 1;
9301 bp->addr = loc;
9302 bp->typ = btyp;
9303 bp->cnt = 0;
9304 bp->act = NULL;
9305 for (i = 0; i < SIM_BKPT_N_SPC; i++)
9306 bp->time_fired[i] = -1.0;
9307 return bp;
9308 }
9309
9310
9311
9312 t_stat sim_brk_set (t_addr loc, int32 sw, int32 ncnt, CONST char *act)
9313 {
9314 BRKTAB *bp;
9315
9316 if ((sw == 0) || (sw == BRK_TYP_DYN_STEPOVER))
9317 sw |= sim_brk_dflt;
9318 if (~sim_brk_types & sw) {
9319 char gbuf[CBUFSIZE];
9320
9321 return sim_messagef (SCPE_NOFNC, "Unknown breakpoint type; %s\r\n", put_switches(gbuf, sizeof(gbuf), sw & ~sim_brk_types));
9322 }
9323 if ((sw & BRK_TYP_DYN_ALL) && act)
9324 return SCPE_ARG;
9325 bp = sim_brk_fnd (loc);
9326 if (!bp)
9327 bp = sim_brk_new (loc, sw);
9328 else {
9329 while (bp && (bp->typ != (uint32)sw))
9330 bp = bp->next;
9331 if (!bp)
9332 bp = sim_brk_new (loc, sw);
9333 }
9334 if (!bp)
9335 return SCPE_MEM;
9336 bp->cnt = ncnt;
9337 if ((!(sw & BRK_TYP_DYN_ALL)) &&
9338 (bp->act != NULL) && (act != NULL)) {
9339 FREE (bp->act);
9340 bp->act = NULL;
9341 }
9342 if ((act != NULL) && (*act != 0)) {
9343 char *newp = (char *) calloc (CBUFSIZE+1, sizeof (char));
9344 if (newp == NULL)
9345 return SCPE_MEM;
9346 strncpy (newp, act, CBUFSIZE);
9347 bp->act = newp;
9348 }
9349 sim_brk_summ = sim_brk_summ | (sw & ~BRK_TYP_TEMP);
9350 return SCPE_OK;
9351 }
9352
9353
9354
9355 t_stat sim_brk_clr (t_addr loc, int32 sw)
9356 {
9357 BRKTAB *bpl = NULL;
9358 BRKTAB *bp = sim_brk_fnd (loc);
9359 int32 i;
9360
9361 if (!bp)
9362 return SCPE_OK;
9363 if (sw == 0)
9364 sw = SIM_BRK_ALLTYP;
9365
9366 #if !defined(__clang_analyzer__)
9367 while (bp) {
9368 if (bp->typ == (bp->typ & sw)) {
9369 FREE (bp->act);
9370 if (bp == sim_brk_tab[sim_brk_ins])
9371 bpl = sim_brk_tab[sim_brk_ins] = bp->next;
9372 else
9373 {
9374 if (bpl)
9375 bpl->next = bp->next;
9376 }
9377 FREE (bp);
9378 bp = bpl;
9379 }
9380 else {
9381 bpl = bp;
9382 bp = bp->next;
9383 }
9384 }
9385 #endif
9386 if (sim_brk_tab[sim_brk_ins] == NULL) {
9387 sim_brk_ent = sim_brk_ent - 1;
9388 for (i = sim_brk_ins; i < sim_brk_ent; i++)
9389 sim_brk_tab[i] = sim_brk_tab[i+1];
9390 }
9391 sim_brk_summ = 0;
9392 for (i = 0; i < sim_brk_ent; i++) {
9393 bp = sim_brk_tab[i];
9394 while (bp) {
9395 sim_brk_summ |= (bp->typ & ~BRK_TYP_TEMP);
9396 bp = bp->next;
9397 }
9398 }
9399 return SCPE_OK;
9400 }
9401
9402
9403
9404 t_stat sim_brk_clrall (int32 sw)
9405 {
9406 int32 i;
9407
9408 if (sw == 0)
9409 sw = SIM_BRK_ALLTYP;
9410 for (i = 0; i < sim_brk_ent;) {
9411 t_addr loc = sim_brk_tab[i]->addr;
9412 sim_brk_clr (loc, sw);
9413 if ((i < sim_brk_ent) &&
9414 (loc == sim_brk_tab[i]->addr))
9415 ++i;
9416 }
9417 return SCPE_OK;
9418 }
9419
9420
9421
9422 t_stat sim_brk_show (FILE *st, t_addr loc, int32 sw)
9423 {
9424 BRKTAB *bp = sim_brk_fnd_ex (loc, sw & (~SWMASK ('C')), FALSE, 0);
9425 DEVICE *dptr;
9426 uint32 i, any;
9427
9428 if ((sw == 0) || (sw == SWMASK ('C'))) {
9429 sw = SIM_BRK_ALLTYP | ((sw == SWMASK ('C')) ? SWMASK ('C') : 0); }
9430 if (!bp || (!(bp->typ & sw))) {
9431 return SCPE_OK; }
9432 dptr = sim_dflt_dev;
9433 if (dptr == NULL) {
9434 return SCPE_OK; }
9435 if (sw & SWMASK ('C')) {
9436 if (st != NULL) {
9437 (void)fprintf (st, "SET BREAK "); }
9438 } else {
9439 if (sim_vm_fprint_addr) {
9440 sim_vm_fprint_addr
9441 (st, dptr, loc);
9442 } else {
9443 fprint_val
9444 (st, loc, dptr->aradix, dptr->awidth, PV_LEFT); }
9445 if (st != NULL) {
9446 (void)fprintf (st, ":\t"); }
9447 }
9448 for (i = any = 0; i < 26; i++) {
9449 if ((bp->typ >> i) & 1) {
9450 if ((sw & SWMASK ('C')) == 0) {
9451 if (any) {
9452 if (st != NULL) {
9453 (void)fprintf (st, ", "); } }
9454 if (st != NULL) {
9455 fputc (i + 'A', st); }
9456 }
9457 } else {
9458 if (st != NULL) {
9459 (void)fprintf (st, "-%c", i + 'A'); }
9460 any = 1;
9461 }
9462 }
9463 if (sw & SWMASK ('C')) {
9464 if (st != NULL) {
9465 (void)fprintf (st, " "); }
9466 if (sim_vm_fprint_addr) {
9467 if (st != NULL) {
9468 sim_vm_fprint_addr (st, dptr, loc); }
9469 } else {
9470 fprint_val
9471 (st, loc, dptr->aradix, dptr->awidth, PV_LEFT); }
9472 }
9473 if (bp->cnt > 0) {
9474 if (st != NULL) {
9475 (void)fprintf (st, "[%d]", bp->cnt); } }
9476 if (bp->act != NULL) {
9477 if (st != NULL) {
9478 (void)fprintf (st, "; %s", bp->act); } }
9479 (void)fprintf (st, "\r\n");
9480 return SCPE_OK;
9481 }
9482
9483
9484
9485 t_stat sim_brk_showall (FILE *st, uint32 sw)
9486 {
9487 int32 bit, mask, types;
9488 BRKTAB **bpt;
9489
9490 if ((sw == 0) || (sw == SWMASK ('C')))
9491 sw = SIM_BRK_ALLTYP | ((sw == SWMASK ('C')) ? SWMASK ('C') : 0);
9492 for (types=bit=0; bit <= ('Z'-'A'); bit++)
9493 if (sim_brk_types & (1 << bit))
9494 ++types;
9495 if ((!(sw & SWMASK ('C'))) && sim_brk_types && (types > 1)) {
9496 (void)fprintf (st, "Supported Breakpoint Types:");
9497 for (bit=0; bit <= ('Z'-'A'); bit++)
9498 if (sim_brk_types & (1 << bit))
9499 (void)fprintf (st, " -%c", 'A' + bit);
9500 (void)fprintf (st, "\r\n");
9501 }
9502 if (((sw & sim_brk_types) != sim_brk_types) && (types > 1)) {
9503 mask = (sw & sim_brk_types);
9504 (void)fprintf (st, "Displaying Breakpoint Types:");
9505 for (bit=0; bit <= ('Z'-'A'); bit++)
9506 if (mask & (1 << bit))
9507 (void)fprintf (st, " -%c", 'A' + bit);
9508 (void)fprintf (st, "\r\n");
9509 }
9510 for (bpt = sim_brk_tab; bpt < (sim_brk_tab + sim_brk_ent); bpt++) {
9511 BRKTAB *prev = NULL;
9512 BRKTAB *cur = *bpt;
9513 BRKTAB *next;
9514
9515 while (cur) {
9516 next = cur->next;
9517 cur->next = prev;
9518 prev = cur;
9519 cur = next;
9520 }
9521
9522 *bpt = prev;
9523
9524 cur = prev;
9525 while (cur) {
9526 if (cur->typ & sw)
9527 sim_brk_show (st, cur->addr, cur->typ | ((sw & SWMASK ('C')) ? SWMASK ('C') : 0));
9528 cur = cur->next;
9529 }
9530
9531 cur = prev;
9532 prev = NULL;
9533 while (cur) {
9534 next = cur->next;
9535 cur->next = prev;
9536 prev = cur;
9537 cur = next;
9538 }
9539
9540 *bpt = prev;
9541 }
9542 return SCPE_OK;
9543 }
9544
9545
9546
9547 uint32 sim_brk_test (t_addr loc, uint32 btyp)
9548 {
9549 BRKTAB *bp;
9550 uint32 spc = (btyp >> SIM_BKPT_V_SPC) & (SIM_BKPT_N_SPC - 1);
9551
9552 if (sim_brk_summ & BRK_TYP_DYN_ALL)
9553 btyp |= BRK_TYP_DYN_ALL;
9554
9555 if ((bp = sim_brk_fnd_ex (loc, btyp, TRUE, spc))) {
9556 double s_gtime = sim_gtime ();
9557
9558 if (bp->time_fired[spc] == s_gtime)
9559 return 0;
9560 bp->time_fired[spc] = s_gtime;
9561 if (--bp->cnt > 0)
9562 return 0;
9563 bp->cnt = 0;
9564 sim_brk_setact (bp->act);
9565 sim_brk_match_type = btyp & bp->typ;
9566 if (bp->typ & BRK_TYP_TEMP)
9567 sim_brk_clr (loc, bp->typ);
9568 sim_brk_match_addr = loc;
9569 return sim_brk_match_type;
9570 }
9571 return 0;
9572 }
9573
9574
9575
9576 CONST char *sim_brk_getact (char *buf, int32 size)
9577 {
9578 char *ep;
9579 size_t lnt;
9580
9581 if (sim_brk_act[sim_do_depth] == NULL)
9582 return NULL;
9583 while (sim_isspace (*sim_brk_act[sim_do_depth]))
9584 sim_brk_act[sim_do_depth]++;
9585 if (*sim_brk_act[sim_do_depth] == 0) {
9586 return sim_brk_clract ();
9587 }
9588 if ((ep = strchr (sim_brk_act[sim_do_depth], ';'))) {
9589 lnt = ep - sim_brk_act[sim_do_depth];
9590 memcpy (buf, sim_brk_act[sim_do_depth], lnt + 1);
9591 buf[lnt] = 0;
9592 sim_brk_act[sim_do_depth] += lnt + 1;
9593 }
9594 else {
9595 strncpy (buf, sim_brk_act[sim_do_depth], size);
9596 sim_brk_clract ();
9597 }
9598 return buf;
9599 }
9600
9601
9602
9603 char *sim_brk_clract (void)
9604 {
9605 FREE (sim_brk_act_buf[sim_do_depth]);
9606 return sim_brk_act[sim_do_depth] = sim_brk_act_buf[sim_do_depth] = NULL;
9607 }
9608
9609
9610
9611 void sim_brk_setact (const char *action)
9612 {
9613 if (action) {
9614 sim_brk_act_buf[sim_do_depth] = (char *)realloc (sim_brk_act_buf[sim_do_depth], strlen (action) + 1);
9615 if (!sim_brk_act_buf[sim_do_depth])
9616 {
9617 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
9618 __func__, __FILE__, __LINE__);
9619 #if defined(USE_BACKTRACE)
9620 # if defined(SIGUSR2)
9621 (void)raise(SIGUSR2);
9622
9623 # endif
9624 #endif
9625 abort();
9626 }
9627 strcpy (sim_brk_act_buf[sim_do_depth], action);
9628 sim_brk_act[sim_do_depth] = sim_brk_act_buf[sim_do_depth];
9629 }
9630 else
9631 sim_brk_clract ();
9632 }
9633
9634
9635
9636 void sim_brk_npc (uint32 cnt)
9637 {
9638 uint32 spc;
9639 BRKTAB **bpt, *bp;
9640
9641 if ((cnt == 0) || (cnt > SIM_BKPT_N_SPC))
9642 cnt = SIM_BKPT_N_SPC;
9643 for (bpt = sim_brk_tab; bpt < (sim_brk_tab + sim_brk_ent); bpt++) {
9644 for (bp = *bpt; bp; bp = bp->next) {
9645 for (spc = 0; spc < cnt; spc++)
9646 bp->time_fired[spc] = -1.0;
9647 }
9648 }
9649 }
9650
9651
9652
9653 void sim_brk_clrspc (uint32 spc, uint32 btyp)
9654 {
9655 BRKTAB **bpt, *bp;
9656
9657 if (spc < SIM_BKPT_N_SPC) {
9658 for (bpt = sim_brk_tab; bpt < (sim_brk_tab + sim_brk_ent); bpt++) {
9659 for (bp = *bpt; bp; bp = bp->next) {
9660 if (bp->typ & btyp)
9661 bp->time_fired[spc] = -1.0;
9662 }
9663 }
9664 }
9665 }
9666
9667 const char *sim_brk_message(void)
9668 {
9669 static char msg[256];
9670 char addr[65] = "";
9671 char buf[32];
9672
9673 msg[0] = '\0';
9674 if (sim_dflt_dev) {
9675 if (sim_vm_sprint_addr)
9676 sim_vm_sprint_addr (addr, sim_dflt_dev, (t_value)sim_brk_match_addr);
9677 else sprint_val (addr, (t_value)sim_brk_match_addr, sim_dflt_dev->aradix, sim_dflt_dev->awidth, PV_LEFT);
9678 }
9679 if (sim_brk_type_desc) {
9680 BRKTYPTAB *brk = sim_brk_type_desc;
9681
9682 while (2 == strlen (put_switches (buf, sizeof(buf), brk->btyp))) {
9683 if (brk->btyp == sim_brk_match_type) {
9684 (void)sprintf (msg, "%s: %s", brk->desc, addr);
9685 break;
9686 }
9687 brk++;
9688 }
9689 }
9690 if (!msg[0])
9691 (void)sprintf (msg, "%s Breakpoint at: %s\r\n",
9692 put_switches (buf, sizeof(buf), sim_brk_match_type), addr);
9693
9694 return msg;
9695 }
9696
9697
9698
9699
9700
9701
9702
9703
9704
9705
9706
9707
9708
9709
9710
9711
9712
9713
9714
9715
9716
9717
9718
9719
9720
9721
9722
9723
9724
9725
9726
9727
9728
9729
9730
9731
9732
9733 t_stat sim_set_expect (EXPECT *exp, CONST char *cptr)
9734 {
9735 char gbuf[CBUFSIZE];
9736 CONST char *tptr;
9737 CONST char *c1ptr;
9738 t_bool after_set = FALSE;
9739 uint32 after;
9740 int32 cnt = 0;
9741 t_stat r;
9742
9743 if (exp == NULL)
9744 return sim_messagef (SCPE_ARG, "Null exp!\r\n");
9745 after = exp->after;
9746
9747 if ((cptr == NULL) || (*cptr == 0))
9748 return SCPE_2FARG;
9749 if (*cptr == '[') {
9750 cnt = (int32) strtotv (cptr + 1, &c1ptr, 10);
9751 if ((cptr == c1ptr) || (*c1ptr != ']'))
9752 return sim_messagef (SCPE_ARG, "Invalid Repeat count specification\r\n");
9753 cptr = c1ptr + 1;
9754 while (sim_isspace(*cptr))
9755 ++cptr;
9756 }
9757 tptr = get_glyph (cptr, gbuf, ',');
9758 if ((!strncmp(gbuf, "HALTAFTER=", 10)) && (gbuf[10])) {
9759 after = (uint32)get_uint (&gbuf[10], 10, 2000000000, &r);
9760 if (r != SCPE_OK)
9761 return sim_messagef (SCPE_ARG, "Invalid Halt After Value\r\n");
9762 after_set = TRUE;
9763 cptr = tptr;
9764 }
9765 if ((*cptr != '"') && (*cptr != '\''))
9766 return sim_messagef (SCPE_ARG, "String must be quote delimited\r\n");
9767 cptr = get_glyph_quoted (cptr, gbuf, 0);
9768
9769 return sim_exp_set (exp, gbuf, cnt, (after_set ? after : exp->after), sim_switches, cptr);
9770 }
9771
9772
9773
9774 t_stat sim_set_noexpect (EXPECT *exp, const char *cptr)
9775 {
9776 char gbuf[CBUFSIZE];
9777
9778 if (NULL == cptr || !*cptr)
9779 return sim_exp_clrall (exp);
9780 if ((*cptr != '"') && (*cptr != '\''))
9781 return sim_messagef (SCPE_ARG, "String must be quote delimited\r\n");
9782 cptr = get_glyph_quoted (cptr, gbuf, 0);
9783 if (*cptr != '\0')
9784 return SCPE_2MARG;
9785 return sim_exp_clr (exp, gbuf);
9786 }
9787
9788
9789
9790 CONST EXPTAB *sim_exp_fnd (CONST EXPECT *exp, const char *match, size_t start_rule)
9791 {
9792 size_t i;
9793
9794 if (NULL == exp->rules)
9795 return NULL;
9796 for (i=start_rule; i<exp->size; i++)
9797 if (!strcmp (exp->rules[i].match_pattern, match))
9798 return &exp->rules[i];
9799 return NULL;
9800 }
9801
9802
9803
9804 t_stat sim_exp_clr_tab (EXPECT *exp, EXPTAB *ep)
9805 {
9806 size_t i;
9807
9808 if (NULL == ep)
9809 return SCPE_OK;
9810 FREE (ep->match);
9811 FREE (ep->match_pattern);
9812 FREE (ep->act);
9813 exp->size -= 1;
9814 #if !defined(__clang_analyzer__)
9815 for (i=ep-exp->rules; i<exp->size; i++)
9816 exp->rules[i] = exp->rules[i+1];
9817 if (exp->size == 0) {
9818 FREE (exp->rules);
9819 exp->rules = NULL;
9820 }
9821 #endif
9822 return SCPE_OK;
9823 }
9824
9825 t_stat sim_exp_clr (EXPECT *exp, const char *match)
9826 {
9827 EXPTAB *ep = (EXPTAB *)sim_exp_fnd (exp, match, 0);
9828
9829 while (ep) {
9830 sim_exp_clr_tab (exp, ep);
9831 ep = (EXPTAB *)sim_exp_fnd (exp, match, ep - exp->rules);
9832 }
9833 return SCPE_OK;
9834 }
9835
9836
9837
9838 t_stat sim_exp_clrall (EXPECT *exp)
9839 {
9840 int32 i;
9841
9842 for (i=0; i<exp->size; i++) {
9843 FREE (exp->rules[i].match);
9844 FREE (exp->rules[i].match_pattern);
9845 FREE (exp->rules[i].act);
9846 }
9847 FREE (exp->rules);
9848 exp->rules = NULL;
9849 exp->size = 0;
9850 FREE (exp->buf);
9851 exp->buf = NULL;
9852 exp->buf_size = 0;
9853 exp->buf_ins = 0;
9854 return SCPE_OK;
9855 }
9856
9857
9858
9859 t_stat sim_exp_set (EXPECT *exp, const char *match, int32 cnt, uint32 after, int32 switches, const char *act)
9860 {
9861 EXPTAB *ep;
9862 uint8 *match_buf;
9863 uint32 match_size;
9864 size_t i;
9865
9866
9867 match_buf = (uint8 *)calloc (strlen (match) + 1, 1);
9868 if (!match_buf)
9869 return SCPE_MEM;
9870 if (switches & EXP_TYP_REGEX) {
9871 FREE (match_buf);
9872 return sim_messagef (SCPE_ARG, "RegEx support not available\r\n");
9873 }
9874 else {
9875 if (switches & EXP_TYP_REGEX_I) {
9876 FREE (match_buf);
9877 return sim_messagef (SCPE_ARG, "Case independent matching is only valid for RegEx expect rules\r\n");
9878 }
9879 sim_data_trace(exp->dptr, exp->dptr->units, (const uint8 *)match, "", strlen(match)+1, "Expect Match String", exp->dbit);
9880 if (SCPE_OK != sim_decode_quoted_string (match, match_buf, &match_size)) {
9881 FREE (match_buf);
9882 return sim_messagef (SCPE_ARG, "Invalid quoted string\r\n");
9883 }
9884 }
9885 FREE (match_buf);
9886 for (i=0; i<exp->size; i++) {
9887 if ((0 == strcmp (match, exp->rules[i].match_pattern)) &&
9888 (exp->rules[i].switches & EXP_TYP_PERSIST))
9889 return sim_messagef (SCPE_ARG, "Persistent Expect rule with identical match string already exists\r\n");
9890 }
9891 if (after && exp->size)
9892 return sim_messagef (SCPE_ARG, "Multiple concurrent EXPECT rules aren't valid when a HALTAFTER parameter is non-zero\r\n");
9893 exp->rules = (EXPTAB *) realloc (exp->rules, sizeof (*exp->rules)*(exp->size + 1));
9894 if (!exp->rules)
9895 {
9896 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
9897 __func__, __FILE__, __LINE__);
9898 #if defined(USE_BACKTRACE)
9899 # if defined(SIGUSR2)
9900 (void)raise(SIGUSR2);
9901
9902 # endif
9903 #endif
9904 abort();
9905 }
9906 ep = &exp->rules[exp->size];
9907 exp->size += 1;
9908 exp->after = after;
9909 (void)memset (ep, 0, sizeof(*ep));
9910 ep->match_pattern = (char *)malloc (strlen (match) + 1);
9911 if (ep->match_pattern)
9912 strcpy (ep->match_pattern, match);
9913 ep->cnt = cnt;
9914 ep->switches = switches;
9915 match_buf = (uint8 *)calloc (strlen (match) + 1, 1);
9916 if ((match_buf == NULL) || (ep->match_pattern == NULL)) {
9917 sim_exp_clr_tab (exp, ep);
9918 FREE (match_buf);
9919 return SCPE_MEM;
9920 }
9921 if (switches & EXP_TYP_REGEX) {
9922 FREE (match_buf);
9923 match_buf = NULL;
9924 }
9925 else {
9926 sim_data_trace(exp->dptr, exp->dptr->units, (const uint8 *)match, "", strlen(match)+1, "Expect Match String", exp->dbit);
9927 sim_decode_quoted_string (match, match_buf, &match_size);
9928 ep->match = match_buf;
9929 ep->size = match_size;
9930 }
9931 ep->match_pattern = (char *)malloc (strlen (match) + 1);
9932 if (!ep->match_pattern)
9933 {
9934 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
9935 __func__, __FILE__, __LINE__);
9936 #if defined(USE_BACKTRACE)
9937 # if defined(SIGUSR2)
9938 (void)raise(SIGUSR2);
9939
9940 # endif
9941 #endif
9942 abort();
9943 }
9944 strcpy (ep->match_pattern, match);
9945 if (ep->act) {
9946 FREE (ep->act);
9947 ep->act = NULL;
9948 }
9949 if (act) while (sim_isspace(*act)) ++act;
9950 if ((act != NULL) && (*act != 0)) {
9951 char *newp = (char *) calloc (strlen (act)+1, sizeof (*act));
9952 if (newp == NULL)
9953 return SCPE_MEM;
9954 strcpy (newp, act);
9955 ep->act = newp;
9956 }
9957
9958 for (i=0; i<exp->size; i++) {
9959 size_t compare_size = (exp->rules[i].switches & EXP_TYP_REGEX) ? MAX(10 * strlen(ep->match_pattern), 1024) : exp->rules[i].size;
9960 if (compare_size >= exp->buf_size) {
9961 exp->buf = (uint8 *)realloc (exp->buf, compare_size + 2);
9962 exp->buf_size = compare_size + 1;
9963 }
9964 }
9965 return SCPE_OK;
9966 }
9967
9968
9969
9970 t_stat sim_exp_show_tab (FILE *st, const EXPECT *exp, const EXPTAB *ep)
9971 {
9972 if (!ep)
9973 return SCPE_OK;
9974 (void)fprintf (st, "EXPECT");
9975 if (ep->switches & EXP_TYP_PERSIST)
9976 (void)fprintf (st, " -p");
9977 if (ep->switches & EXP_TYP_CLEARALL)
9978 (void)fprintf (st, " -c");
9979 if (ep->switches & EXP_TYP_REGEX)
9980 (void)fprintf (st, " -r");
9981 if (ep->switches & EXP_TYP_REGEX_I)
9982 (void)fprintf (st, " -i");
9983 (void)fprintf (st, " %s", ep->match_pattern);
9984 if (ep->cnt > 0)
9985 (void)fprintf (st, " [%d]", ep->cnt);
9986 if (ep->act)
9987 (void)fprintf (st, " %s", ep->act);
9988 (void)fprintf (st, "\r\n");
9989 return SCPE_OK;
9990 }
9991
9992 t_stat sim_exp_show (FILE *st, CONST EXPECT *exp, const char *match)
9993 {
9994 CONST EXPTAB *ep = (CONST EXPTAB *)sim_exp_fnd (exp, match, 0);
9995
9996 if (exp->buf_size) {
9997 char *bstr = sim_encode_quoted_string (exp->buf, exp->buf_ins);
9998
9999 (void)fprintf (st, "Match Buffer Size: %lld\r\n",
10000 (long long)exp->buf_size);
10001 (void)fprintf (st, "Buffer Insert Offset: %lld\r\n",
10002 (long long)exp->buf_ins);
10003 (void)fprintf (st, "Buffer Contents: %s\r\n",
10004 bstr);
10005 FREE (bstr);
10006 }
10007 if (exp->after)
10008 (void)fprintf (st, "Halt After: %lld instructions\r\n",
10009 (long long)exp->after);
10010 if (exp->dptr && exp->dbit)
10011 (void)fprintf (st, "Debugging via: SET %s DEBUG%s%s\r\n",
10012 sim_dname(exp->dptr), exp->dptr->debflags ? "=" : "",
10013 exp->dptr->debflags ? get_dbg_verb (exp->dbit, exp->dptr) : "");
10014 (void)fprintf (st, "Match Rules:\r\n");
10015 if (!*match)
10016 return sim_exp_showall (st, exp);
10017 if (!ep) {
10018 (void)fprintf (st, "No Rules match '%s'\r\n", match);
10019 return SCPE_ARG;
10020 }
10021 do {
10022 sim_exp_show_tab (st, exp, ep);
10023 ep = (CONST EXPTAB *)sim_exp_fnd (exp, match, 1 + (ep - exp->rules));
10024 } while (ep);
10025 return SCPE_OK;
10026 }
10027
10028
10029
10030 t_stat sim_exp_showall (FILE *st, const EXPECT *exp)
10031 {
10032 size_t i;
10033
10034 for (i=0; i < exp->size; i++)
10035 sim_exp_show_tab (st, exp, &exp->rules[i]);
10036 return SCPE_OK;
10037 }
10038
10039
10040
10041 t_stat sim_exp_check (EXPECT *exp, uint8 data)
10042 {
10043 size_t i;
10044 EXPTAB *ep = NULL;
10045 char *tstr = NULL;
10046 #if defined(TESTING)
10047 cpu_state_t * cpup = _cpup;
10048 #endif
10049
10050 if ((!exp) || (!exp->rules))
10051 return SCPE_OK;
10052
10053 exp->buf[exp->buf_ins++] = data;
10054 exp->buf[exp->buf_ins] = '\0';
10055
10056 for (i=0; i < exp->size; i++) {
10057 ep = &exp->rules[i];
10058 if (ep == NULL)
10059 break;
10060 if (ep->switches & EXP_TYP_REGEX) {
10061 }
10062 else {
10063 if (exp->buf_ins < ep->size) {
10064
10065
10066
10067
10068 if (exp->buf_ins > 0) {
10069 if (sim_deb && exp->dptr && (exp->dptr->dctrl & exp->dbit)) {
10070 char *estr = sim_encode_quoted_string (exp->buf, exp->buf_ins);
10071 char *mstr = sim_encode_quoted_string (&ep->match[ep->size-exp->buf_ins], exp->buf_ins);
10072
10073 sim_debug (exp->dbit, exp->dptr, "Checking String[0:%lld]: %s\r\n",
10074 (long long)exp->buf_ins, estr);
10075 sim_debug (exp->dbit, exp->dptr, "Against Match Data: %s\r\n", mstr);
10076 FREE (estr);
10077 FREE (mstr);
10078 }
10079 if (memcmp (exp->buf, &ep->match[ep->size-exp->buf_ins], exp->buf_ins))
10080 continue;
10081 }
10082 if (sim_deb && exp->dptr && (exp->dptr->dctrl & exp->dbit)) {
10083 char *estr = sim_encode_quoted_string (&exp->buf[exp->buf_size-(ep->size-exp->buf_ins)], ep->size-exp->buf_ins);
10084 char *mstr = sim_encode_quoted_string (ep->match, ep->size-exp->buf_ins);
10085
10086 sim_debug (exp->dbit, exp->dptr, "Checking String[%lld:%lld]: %s\r\n",
10087 (long long)exp->buf_size-(ep->size-exp->buf_ins),
10088 (long long)ep->size-exp->buf_ins, estr);
10089 sim_debug (exp->dbit, exp->dptr, "Against Match Data: %s\r\n", mstr);
10090 FREE (estr);
10091 FREE (mstr);
10092 }
10093 if (memcmp (&exp->buf[exp->buf_size-(ep->size-exp->buf_ins)], ep->match, ep->size-exp->buf_ins))
10094 continue;
10095 break;
10096 }
10097 else {
10098 if (sim_deb && exp->dptr && (exp->dptr->dctrl & exp->dbit)) {
10099 char *estr = sim_encode_quoted_string (&exp->buf[exp->buf_ins-ep->size], ep->size);
10100 char *mstr = sim_encode_quoted_string (ep->match, ep->size);
10101
10102 sim_debug (exp->dbit, exp->dptr, "Checking String[%lld:%lld]: %s\r\n",
10103 (long long)exp->buf_ins-ep->size,
10104 (long long)ep->size, estr);
10105 sim_debug (exp->dbit, exp->dptr, "Against Match Data: %s\r\n", mstr);
10106 FREE (estr);
10107 FREE (mstr);
10108 }
10109 if (memcmp (&exp->buf[exp->buf_ins-ep->size], ep->match, ep->size))
10110 continue;
10111 break;
10112 }
10113 }
10114 }
10115 if (exp->buf_ins == exp->buf_size) {
10116 exp->buf_ins = 0;
10117 sim_debug (exp->dbit, exp->dptr, "Buffer wrapping\r\n");
10118 }
10119 if ((ep != NULL) && (i != exp->size)) {
10120 sim_debug (exp->dbit, exp->dptr, "Matched expect pattern!\r\n");
10121 if (ep->cnt > 0) {
10122 ep->cnt -= 1;
10123 sim_debug (exp->dbit, exp->dptr, "Waiting for %lld more match%s before stopping\r\n",
10124 (long long)ep->cnt, (ep->cnt == 1) ? "" : "es");
10125 }
10126 else {
10127 uint32 after = exp->after;
10128 int32 switches = ep->switches;
10129 if (ep->act && *ep->act) {
10130 sim_debug (exp->dbit, exp->dptr, "Initiating actions: %s\r\n", ep->act);
10131 }
10132 else {
10133 sim_debug (exp->dbit, exp->dptr, "No actions specified, stopping...\r\n");
10134 }
10135 sim_brk_setact (ep->act);
10136 if (ep->switches & EXP_TYP_CLEARALL)
10137 sim_exp_clrall (exp);
10138 else {
10139 if (!(ep->switches & EXP_TYP_PERSIST))
10140 sim_exp_clr_tab (exp, ep);
10141 }
10142 sim_activate (&sim_expect_unit,
10143 (switches & EXP_TYP_TIME) ?
10144 (uint32)((sim_timer_inst_per_sec ()*exp->after)/1000000.0) :
10145 after);
10146 }
10147
10148 exp->buf_ins = 0;
10149 }
10150 if (tstr)
10151 FREE (tstr);
10152 return SCPE_OK;
10153 }
10154
10155
10156
10157 t_stat sim_send_input (SEND *snd, uint8 *data, size_t size, uint32 after, uint32 delay)
10158 {
10159 if (snd->extoff != 0) {
10160 if (snd->insoff > snd->extoff)
10161 memmove(snd->buffer, snd->buffer+snd->extoff, snd->insoff-snd->extoff);
10162 snd->insoff -= snd->extoff;
10163 snd->extoff = 0;
10164 }
10165 if (snd->insoff+size > snd->bufsize) {
10166 snd->bufsize = snd->insoff+size;
10167 snd->buffer = (uint8 *)realloc(snd->buffer, snd->bufsize);
10168 if (!snd->buffer)
10169 {
10170 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
10171 __func__, __FILE__, __LINE__);
10172 #if defined(USE_BACKTRACE)
10173 # if defined(SIGUSR2)
10174 (void)raise(SIGUSR2);
10175
10176 # endif
10177 #endif
10178 abort();
10179 }
10180 }
10181 memcpy(snd->buffer+snd->insoff, data, size);
10182 snd->insoff += size;
10183 if (delay)
10184 snd->delay = (sim_switches & SWMASK ('T')) ? (uint32)((sim_timer_inst_per_sec()*delay)/1000000.0) : delay;
10185 if (after)
10186 snd->after = (sim_switches & SWMASK ('T')) ? (uint32)((sim_timer_inst_per_sec()*after)/1000000.0) : after;
10187 if (snd->after == 0)
10188 snd->after = snd->delay;
10189 snd->next_time = sim_gtime() + snd->after;
10190 return SCPE_OK;
10191 }
10192
10193
10194 t_stat sim_send_clear (SEND *snd)
10195 {
10196 snd->insoff = 0;
10197 snd->extoff = 0;
10198 return SCPE_OK;
10199 }
10200
10201
10202
10203 t_stat sim_show_send_input (FILE *st, const SEND *snd)
10204 {
10205 if (snd->extoff < snd->insoff) {
10206 (void)fprintf (st, "%lld bytes of pending input Data:\r\n ",
10207 (long long)snd->insoff-snd->extoff);
10208 fprint_buffer_string (st, snd->buffer+snd->extoff, snd->insoff-snd->extoff);
10209 (void)fprintf (st, "\r\n");
10210 }
10211 else
10212 (void)fprintf (st, "No Pending Input Data\r\n");
10213 if ((snd->next_time - sim_gtime()) > 0) {
10214 if ((snd->next_time - sim_gtime()) > (sim_timer_inst_per_sec()/1000000.0))
10215 (void)fprintf (st, "Minimum of %d instructions (%d microseconds) before sending first character\r\n",
10216 (int)(snd->next_time - sim_gtime()),
10217 (int)((snd->next_time - sim_gtime())/(sim_timer_inst_per_sec()/1000000.0)));
10218 else
10219 (void)fprintf (st, "Minimum of %d instructions before sending first character\r\n",
10220 (int)(snd->next_time - sim_gtime()));
10221 }
10222 if (snd->delay > (sim_timer_inst_per_sec()/1000000.0))
10223 (void)fprintf (st, "Minimum of %d instructions (%d microseconds) between characters\r\n",
10224 (int)snd->delay, (int)(snd->delay/(sim_timer_inst_per_sec()/1000000.0)));
10225 else
10226 (void)fprintf (st, "Minimum of %d instructions between characters\r\n",
10227 (int)snd->delay);
10228 if (snd->dptr && snd->dbit)
10229 (void)fprintf (st, "Debugging via: SET %s DEBUG%s%s\r\n",
10230 sim_dname(snd->dptr), snd->dptr->debflags ? "=" : "",
10231 snd->dptr->debflags ? get_dbg_verb (snd->dbit, snd->dptr) : "");
10232 return SCPE_OK;
10233 }
10234
10235
10236
10237 t_bool sim_send_poll_data (SEND *snd, t_stat *stat)
10238 {
10239 #if defined(TESTING)
10240 cpu_state_t * cpup = _cpup;
10241 #endif
10242 if ((NULL != snd) && (snd->extoff < snd->insoff)) {
10243 if (sim_gtime() < snd->next_time) {
10244 *stat = SCPE_OK;
10245 sim_debug (snd->dbit, snd->dptr, "Too soon to inject next byte\r\n");
10246 }
10247 else {
10248 char dstr[8] = "";
10249 *stat = snd->buffer[snd->extoff++] | SCPE_KFLAG;
10250 snd->next_time = sim_gtime() + snd->delay;
10251 if (sim_isgraph(*stat & 0xFF) || ((*stat & 0xFF) == ' '))
10252 (void)sprintf (dstr, " '%c'", *stat & 0xFF);
10253 sim_debug (snd->dbit, snd->dptr, "Byte value: 0x%02X%s injected\r\n", *stat & 0xFF, dstr);
10254 }
10255 return TRUE;
10256 }
10257 return FALSE;
10258 }
10259
10260
10261
10262 const char *sim_error_text (t_stat stat)
10263 {
10264 static char msgbuf[64];
10265
10266 stat &= ~(SCPE_KFLAG|SCPE_BREAK|SCPE_NOMESSAGE);
10267 if (stat == SCPE_OK)
10268 return "No Error";
10269 if ((stat >= SCPE_BASE) && (stat <= SCPE_MAX_ERR))
10270 return scp_errors[stat-SCPE_BASE].message;
10271 (void)sprintf(msgbuf, "Error %d", stat);
10272 return msgbuf;
10273 }
10274
10275 t_stat sim_string_to_stat (const char *cptr, t_stat *stat)
10276 {
10277 char gbuf[CBUFSIZE];
10278 size_t cond;
10279
10280 *stat = SCPE_ARG;
10281 cptr = get_glyph (cptr, gbuf, 0);
10282 if (0 == memcmp("SCPE_", gbuf, 5))
10283 memmove (gbuf, gbuf + 5, 1 + strlen (gbuf + 5));
10284 for (cond=0; cond < (SCPE_MAX_ERR-SCPE_BASE); cond++)
10285 if (0 == strcmp(scp_errors[cond].code, gbuf)) {
10286 cond += SCPE_BASE;
10287 break;
10288 }
10289 if (0 == strcmp(gbuf, "OK"))
10290 cond = SCPE_OK;
10291 if (cond == (SCPE_MAX_ERR-SCPE_BASE)) {
10292 unsigned long numeric_cond = strtol(gbuf, NULL, 0);
10293 if (0 == numeric_cond)
10294 return SCPE_ARG;
10295 cond = (t_stat) numeric_cond;
10296 }
10297 if (cond > SCPE_MAX_ERR)
10298 return SCPE_ARG;
10299 *stat = cond;
10300 return SCPE_OK;
10301 }
10302
10303
10304
10305 const char* debug_bstates = "01_^";
10306 char debug_line_prefix[256];
10307 int32 debug_unterm = 0;
10308
10309
10310
10311 static const char *get_dbg_verb (uint32 dbits, DEVICE* dptr)
10312 {
10313 static const char *debtab_none = "DEBTAB_ISNULL";
10314 static const char *debtab_nomatch = "DEBTAB_NOMATCH";
10315 const char *some_match = NULL;
10316 int32 offset = 0;
10317
10318 if (dptr->debflags == 0)
10319 return debtab_none;
10320
10321 dbits &= dptr->dctrl;
10322
10323
10324
10325 while ((offset < 32) && dptr->debflags[offset].name) {
10326 if (dptr->debflags[offset].mask == dbits)
10327 return dptr->debflags[offset].name;
10328 if (dptr->debflags[offset].mask & dbits)
10329 some_match = dptr->debflags[offset].name;
10330 offset++;
10331 }
10332 return some_match ? some_match : debtab_nomatch;
10333 }
10334
10335
10336
10337 static const char *sim_debug_prefix (uint32 dbits, DEVICE* dptr)
10338 {
10339 const char* debug_type = get_dbg_verb (dbits, dptr);
10340 char tim_t[32] = "";
10341 char tim_a[32] = "";
10342 char pc_s[64] = "";
10343 struct timespec time_now;
10344
10345 if (sim_deb_switches & (SWMASK ('T') | SWMASK ('R') | SWMASK ('A'))) {
10346 clock_gettime(CLOCK_REALTIME, &time_now);
10347 if (sim_deb_switches & SWMASK ('R'))
10348 sim_timespec_diff (&time_now, &time_now, &sim_deb_basetime);
10349 if (sim_deb_switches & SWMASK ('T')) {
10350 time_t tnow = (time_t)time_now.tv_sec;
10351 struct tm *now = gmtime(&tnow);
10352 (void)sprintf(tim_t, "%02d:%02d:%02d.%03ld ",
10353 (int)now->tm_hour,
10354 (int)now->tm_min,
10355 (int)now->tm_sec,
10356 (long)(time_now.tv_nsec / 1000000));
10357 }
10358 if (sim_deb_switches & SWMASK ('A')) {
10359 (void)sprintf(tim_t, "%d.%03ld ",
10360 (int)(time_now.tv_sec),
10361 (long)(time_now.tv_nsec / 1000000));
10362 }
10363 }
10364 if (sim_deb_switches & SWMASK ('P')) {
10365 t_value val;
10366
10367 if (sim_vm_pc_value)
10368 val = (*sim_vm_pc_value)();
10369 else
10370 val = get_rval (sim_PC, 0);
10371 (void)sprintf(pc_s, "-%s:", sim_PC->name);
10372 sprint_val (&pc_s[strlen(pc_s)], val, sim_PC->radix, sim_PC->width, sim_PC->flags & REG_FMT);
10373 }
10374 (void)sprintf(debug_line_prefix, "DBG(%s%s%.0f%s)%s> %s %s: ",
10375 tim_t, tim_a, sim_gtime(), pc_s,
10376 "", dptr->name, debug_type);
10377 return debug_line_prefix;
10378 }
10379
10380 void fprint_fields (FILE *stream, t_value before, t_value after, BITFIELD* bitdefs)
10381 {
10382 int32 i, fields, offset;
10383 uint32 value, beforevalue, mask;
10384
10385 for (fields=offset=0; bitdefs[fields].name; ++fields) {
10386 if (bitdefs[fields].offset == 0xffffffff)
10387 bitdefs[fields].offset = offset;
10388 offset += bitdefs[fields].width;
10389 }
10390 for (i = fields-1; i >= 0; i--) {
10391 if (bitdefs[i].name[0] == '\0')
10392 continue;
10393 if ((bitdefs[i].width == 1) && (bitdefs[i].valuenames == NULL)) {
10394 int off = ((after >> bitdefs[i].offset) & 1) + (((before ^ after) >> bitdefs[i].offset) & 1) * 2;
10395 (void)Fprintf(stream, "%s%c ", bitdefs[i].name, debug_bstates[off]);
10396 }
10397 else {
10398 const char *delta = "";
10399 mask = 0xFFFFFFFF >> (32-bitdefs[i].width);
10400 value = (uint32)((after >> bitdefs[i].offset) & mask);
10401 beforevalue = (uint32)((before >> bitdefs[i].offset) & mask);
10402 if (value < beforevalue)
10403 delta = "_";
10404 if (value > beforevalue)
10405 delta = "^";
10406 if (bitdefs[i].valuenames)
10407 (void)Fprintf(stream, "%s=%s%s ", bitdefs[i].name, delta, bitdefs[i].valuenames[value]);
10408 else
10409 if (bitdefs[i].format) {
10410 (void)Fprintf(stream, "%s=%s", bitdefs[i].name, delta);
10411 (void)Fprintf(stream, bitdefs[i].format, value);
10412 (void)Fprintf(stream, " ");
10413 }
10414 else
10415 (void)Fprintf(stream, "%s=%s0x%X ", bitdefs[i].name, delta, value);
10416 }
10417 }
10418 }
10419
10420
10421
10422
10423
10424 void sim_debug_bits_hdr(uint32 dbits, DEVICE* dptr, const char *header,
10425 BITFIELD* bitdefs, uint32 before, uint32 after, int terminate)
10426 {
10427 if (sim_deb && dptr && (dptr->dctrl & dbits)) {
10428 if (!debug_unterm)
10429 (void)fprintf(sim_deb, "%s", sim_debug_prefix(dbits, dptr));
10430 if (header)
10431 (void)fprintf(sim_deb, "%s: ", header);
10432 fprint_fields (sim_deb, (t_value)before, (t_value)after, bitdefs);
10433 if (terminate)
10434 (void)fprintf(sim_deb, "\r\n");
10435 debug_unterm = terminate ? 0 : 1;
10436 }
10437 }
10438 void sim_debug_bits(uint32 dbits, DEVICE* dptr, BITFIELD* bitdefs,
10439 uint32 before, uint32 after, int terminate)
10440 {
10441 sim_debug_bits_hdr(dbits, dptr, NULL, bitdefs, before, after, terminate);
10442 }
10443
10444
10445 void sim_printf (const char* fmt, ...)
10446 {
10447 char stackbuf[STACKBUFSIZE];
10448 int32 bufsize = sizeof(stackbuf);
10449 char *buf = stackbuf;
10450 int32 len;
10451 va_list arglist;
10452
10453 while (1) {
10454 va_start (arglist, fmt);
10455 len = vsnprintf (buf, bufsize-1, fmt, arglist);
10456 va_end (arglist);
10457
10458
10459
10460 if ((len < 0) || (len >= bufsize-1)) {
10461 if (buf != stackbuf)
10462 FREE (buf);
10463 if (bufsize >= (INT_MAX / 2))
10464 return;
10465 bufsize = bufsize * 2;
10466 if (bufsize < len + 2)
10467 bufsize = len + 2;
10468 buf = (char *) malloc (bufsize);
10469 if (buf == NULL)
10470 return;
10471 buf[bufsize-1] = '\0';
10472 continue;
10473 }
10474 break;
10475 }
10476
10477 if (sim_is_running) {
10478 char *c, *remnant = buf;
10479 while ((c = strchr(remnant, '\n'))) {
10480 if ((c != buf) && (*(c - 1) != '\r'))
10481 (void)printf("%.*s\r\n", (int)(c-remnant), remnant);
10482 else
10483 (void)printf("%.*s\n", (int)(c-remnant), remnant);
10484 remnant = c + 1;
10485 }
10486 (void)printf("%s", remnant);
10487 }
10488 else
10489 (void)printf("%s", buf);
10490 if (sim_log && (sim_log != stdout))
10491 (void)fprintf (sim_log, "%s", buf);
10492 if (sim_deb && (sim_deb != stdout) && (sim_deb != sim_log))
10493 (void)fprintf (sim_deb, "%s", buf);
10494
10495 if (buf != stackbuf)
10496 FREE (buf);
10497 }
10498
10499
10500 t_stat sim_messagef (t_stat stat, const char* fmt, ...)
10501 {
10502 char stackbuf[STACKBUFSIZE];
10503 size_t bufsize = sizeof(stackbuf);
10504 char *buf = stackbuf;
10505 size_t len;
10506 va_list arglist;
10507 t_bool inhibit_message = (!sim_show_message || (stat & SCPE_NOMESSAGE));
10508
10509 while (1) {
10510 va_start (arglist, fmt);
10511 len = vsnprintf (buf, bufsize-1, fmt, arglist);
10512 va_end (arglist);
10513
10514
10515
10516 if (len >= bufsize - 1) {
10517 if (buf != stackbuf)
10518 FREE (buf);
10519 bufsize = bufsize * 2;
10520 if (bufsize < len + 2)
10521 bufsize = len + 2;
10522 buf = (char *) malloc (bufsize);
10523 if (buf == NULL)
10524 return SCPE_MEM;
10525 buf[bufsize-1] = '\0';
10526 continue;
10527 }
10528 break;
10529 }
10530
10531 if (sim_do_ocptr[sim_do_depth]) {
10532 if (!sim_do_echo && !sim_quiet && !inhibit_message)
10533 sim_printf("%s> %s\r\n", do_position(), sim_do_ocptr[sim_do_depth]);
10534 else {
10535 if (sim_deb)
10536 (void)fprintf (sim_deb, "%s> %s\r\n", do_position(), sim_do_ocptr[sim_do_depth]);
10537 }
10538 }
10539 if (sim_is_running && !inhibit_message) {
10540 char *c, *remnant = buf;
10541 while ((c = strchr(remnant, '\n'))) {
10542 if ((c != buf) && (*(c - 1) != '\r'))
10543 (void)printf("%.*s\r\n", (int)(c-remnant), remnant);
10544 else
10545 (void)printf("%.*s\n", (int)(c-remnant), remnant);
10546 remnant = c + 1;
10547 }
10548 (void)printf("%s", remnant);
10549 }
10550 else {
10551 if (!inhibit_message)
10552 (void)printf("%s", buf);
10553 }
10554 if (sim_log && (sim_log != stdout) && !inhibit_message)
10555 (void)fprintf (sim_log, "%s", buf);
10556 if (sim_deb && (((sim_deb != stdout) && (sim_deb != sim_log)) || inhibit_message))
10557 (void)fprintf (sim_deb, "%s", buf);
10558
10559 if (buf != stackbuf)
10560 FREE (buf);
10561 return stat | SCPE_NOMESSAGE;
10562 }
10563
10564
10565
10566
10567
10568
10569
10570
10571
10572 void _sim_debug (uint32 dbits, DEVICE* vdptr, const char* fmt, ...)
10573 {
10574 DEVICE *dptr = (DEVICE *)vdptr;
10575 if (sim_deb && dptr && (dbits == 0 || (dptr->dctrl & dbits))) {
10576 char stackbuf[STACKBUFSIZE];
10577 int32 bufsize = sizeof(stackbuf);
10578 char *buf = stackbuf;
10579 va_list arglist;
10580 int32 i, j, len;
10581 const char* debug_prefix = sim_debug_prefix(dbits, dptr);
10582
10583 buf[bufsize-1] = '\0';
10584 while (1) {
10585 va_start (arglist, fmt);
10586 len = vsnprintf (buf, bufsize-1, fmt, arglist);
10587 va_end (arglist);
10588
10589
10590
10591 if ((len < 0) || (len >= bufsize-1)) {
10592 if (buf != stackbuf)
10593 FREE (buf);
10594 if (bufsize >= (INT_MAX / 2))
10595 return;
10596 bufsize = bufsize * 2;
10597 if (bufsize < len + 2)
10598 bufsize = len + 2;
10599 buf = (char *) malloc (bufsize);
10600 if (buf == NULL)
10601 return;
10602 buf[bufsize-1] = '\0';
10603 continue;
10604 }
10605 break;
10606 }
10607
10608
10609
10610 for (i = j = 0; i < len; ++i) {
10611 if ('\n' == buf[i]) {
10612 if (i >= j) {
10613 if ((i != j) || (i == 0)) {
10614 if (debug_unterm)
10615 (void)fprintf (sim_deb, "%.*s\r\n", i-j, &buf[j]);
10616 else
10617 (void)fprintf (sim_deb, "%s%.*s\r\n", debug_prefix, i-j, &buf[j]);
10618 }
10619 debug_unterm = 0;
10620 }
10621 j = i + 1;
10622 }
10623 }
10624 if (i > j) {
10625 if (debug_unterm)
10626 (void)fprintf (sim_deb, "%.*s", i-j, &buf[j]);
10627 else
10628 (void)fprintf (sim_deb, "%s%.*s", debug_prefix, i-j, &buf[j]);
10629 }
10630
10631
10632
10633 debug_unterm = len ? (((buf[len-1]=='\n')) ? 0 : 1) : debug_unterm;
10634 if (buf != stackbuf)
10635 FREE (buf);
10636 }
10637 return;
10638 }
10639
10640 void sim_data_trace(DEVICE *dptr, UNIT *uptr, const uint8 *data, const char *position, size_t len, const char *txt, uint32 reason)
10641 {
10642 #if defined(TESTING)
10643 cpu_state_t * cpup = _cpup;
10644 #endif
10645 if (sim_deb && (dptr->dctrl & reason)) {
10646 sim_debug (reason, dptr, "%s %s %slen: %08X\r\n", sim_uname(uptr), txt, position, (unsigned int)len);
10647 if (data && len) {
10648 size_t i, same, group, sidx, oidx, ridx, eidx, soff;
10649 char outbuf[80], strbuf[28], rad50buf[36], ebcdicbuf[32];
10650 static char hex[] = "0123456789ABCDEF";
10651 static char rad50[] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ$._0123456789";
10652 static unsigned char ebcdic2ascii[] = {
10653 0000, 0001, 0002, 0003, 0234, 0011, 0206, 0177,
10654 0227, 0215, 0216, 0013, 0014, 0015, 0016, 0017,
10655 0020, 0021, 0022, 0023, 0235, 0205, 0010, 0207,
10656 0030, 0031, 0222, 0217, 0034, 0035, 0036, 0037,
10657 0200, 0201, 0202, 0203, 0204, 0012, 0027, 0033,
10658 0210, 0211, 0212, 0213, 0214, 0005, 0006, 0007,
10659 0220, 0221, 0026, 0223, 0224, 0225, 0226, 0004,
10660 0230, 0231, 0232, 0233, 0024, 0025, 0236, 0032,
10661 0040, 0240, 0241, 0242, 0243, 0244, 0245, 0246,
10662 0247, 0250, 0133, 0056, 0074, 0050, 0053, 0041,
10663 0046, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
10664 0260, 0261, 0135, 0044, 0052, 0051, 0073, 0136,
10665 0055, 0057, 0262, 0263, 0264, 0265, 0266, 0267,
10666 0270, 0271, 0174, 0054, 0045, 0137, 0076, 0077,
10667 0272, 0273, 0274, 0275, 0276, 0277, 0300, 0301,
10668 0302, 0140, 0072, 0043, 0100, 0047, 0075, 0042,
10669 0303, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
10670 0150, 0151, 0304, 0305, 0306, 0307, 0310, 0311,
10671 0312, 0152, 0153, 0154, 0155, 0156, 0157, 0160,
10672 0161, 0162, 0313, 0314, 0315, 0316, 0317, 0320,
10673 0321, 0176, 0163, 0164, 0165, 0166, 0167, 0170,
10674 0171, 0172, 0322, 0323, 0324, 0325, 0326, 0327,
10675 0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
10676 0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
10677 0173, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
10678 0110, 0111, 0350, 0351, 0352, 0353, 0354, 0355,
10679 0175, 0112, 0113, 0114, 0115, 0116, 0117, 0120,
10680 0121, 0122, 0356, 0357, 0360, 0361, 0362, 0363,
10681 0134, 0237, 0123, 0124, 0125, 0126, 0127, 0130,
10682 0131, 0132, 0364, 0365, 0366, 0367, 0370, 0371,
10683 0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
10684 0070, 0071, 0372, 0373, 0374, 0375, 0376, 0377,
10685 };
10686
10687 for (i=same=0; i<len; i += 16) {
10688 if ((i > 0) && (0 == memcmp (&data[i], &data[i-16], 16))) {
10689 ++same;
10690 continue;
10691 }
10692 if (same > 0) {
10693 sim_debug (reason, dptr, "%04lx thru %04lx same as above\r\n",
10694 (unsigned long int)(i - (16*same)),
10695 (unsigned long int)(i - 1));
10696 same = 0;
10697 }
10698 group = (((len - i) > 16) ? 16 : (len - i));
10699 strcpy (ebcdicbuf, (sim_deb_switches & SWMASK ('E')) ? " EBCDIC:" : "");
10700 eidx = strlen(ebcdicbuf);
10701 strcpy (rad50buf, (sim_deb_switches & SWMASK ('D')) ? " RAD50:" : "");
10702 ridx = strlen(rad50buf);
10703 strcpy (strbuf, (sim_deb_switches & (SWMASK ('E') | SWMASK ('D'))) ? "ASCII:" : "");
10704 soff = strlen(strbuf);
10705 for (sidx=oidx=0; sidx<group; ++sidx) {
10706 outbuf[oidx++] = ' ';
10707 outbuf[oidx++] = hex[(data[i+sidx]>>4)&0xf];
10708 outbuf[oidx++] = hex[data[i+sidx]&0xf];
10709 if (sim_isprint (data[i+sidx]))
10710 strbuf[soff+sidx] = data[i+sidx];
10711 else
10712 strbuf[soff+sidx] = '.';
10713 if (ridx && ((sidx&1) == 0)) {
10714 uint16 word = data[i+sidx] + (((uint16)data[i+sidx+1]) << 8);
10715
10716 if (word >= 64000) {
10717 rad50buf[ridx++] = '|';
10718 rad50buf[ridx++] = '|';
10719 rad50buf[ridx++] = '|';
10720 }
10721 else {
10722 rad50buf[ridx++] = rad50[word/1600];
10723 rad50buf[ridx++] = rad50[(word/40)%40];
10724 rad50buf[ridx++] = rad50[word%40];
10725 }
10726 }
10727 if (eidx) {
10728 if (sim_isprint (ebcdic2ascii[data[i+sidx]]))
10729 ebcdicbuf[eidx++] = ebcdic2ascii[data[i+sidx]];
10730 else
10731 ebcdicbuf[eidx++] = '.';
10732 }
10733 }
10734 outbuf[oidx] = '\0';
10735 strbuf[soff+sidx] = '\0';
10736 ebcdicbuf[eidx] = '\0';
10737 rad50buf[ridx] = '\0';
10738 sim_debug (reason, dptr, "%04lx%-48s %s%s%s\r\n",
10739 (unsigned long int)i, outbuf, strbuf, ebcdicbuf, rad50buf);
10740 }
10741 if (same > 0) {
10742 sim_debug (reason, dptr, "%04lx thru %04lx same as above\r\n",
10743 (unsigned long int)(i-(16*same)),
10744 (unsigned long int)(len-1));
10745 }
10746 }
10747 }
10748 }
10749
10750 int Fprintf (FILE *f, const char* fmt, ...)
10751 {
10752 int ret = 0;
10753 va_list args;
10754
10755 va_start (args, fmt);
10756 ret = vfprintf (f, fmt, args);
10757 va_end (args);
10758 return ret;
10759 }
10760
10761
10762
10763
10764
10765
10766
10767
10768
10769
10770
10771
10772
10773
10774
10775
10776
10777
10778
10779 #define blankch(x) ((x) == ' ' || (x) == '\t')
10780
10781 typedef struct topic {
10782 size_t level;
10783 char *title;
10784 char *label;
10785 struct topic *parent;
10786 struct topic **children;
10787 uint32 kids;
10788 char *text;
10789 size_t len;
10790 uint32 flags;
10791 size_t kidwid;
10792 #define HLP_MAGIC_TOPIC 1
10793 } TOPIC;
10794
10795 static volatile struct {
10796 const char *error;
10797 const char *prox;
10798 size_t block;
10799 size_t line;
10800 } help_where = { "", NULL, 0, 0 };
10801 jmp_buf help_env;
10802
10803 #define FAIL(why,text,here) \
10804 { \
10805 help_where.error = #text; \
10806 help_where.prox = here; \
10807 longjmp ( help_env, (why) ); \
10808 \
10809 }
10810
10811
10812
10813
10814
10815
10816 static void appendText (TOPIC *topic, const char *text, size_t len)
10817 {
10818 char *newt;
10819
10820 if (!len)
10821 return;
10822
10823 newt = (char *)realloc (topic->text, topic->len + len +1);
10824 if (!newt) {
10825 #if !defined(SUNLINT)
10826 FAIL (SCPE_MEM, No memory, NULL);
10827 #endif
10828 }
10829 topic->text = newt;
10830 memcpy (newt + topic->len, text, len);
10831 topic->len +=len;
10832 newt[topic->len] = '\0';
10833 return;
10834 }
10835
10836
10837
10838 static void cleanHelp (TOPIC *topic)
10839 {
10840 TOPIC *child;
10841 size_t i;
10842
10843 FREE (topic->title);
10844 FREE (topic->text);
10845 FREE (topic->label);
10846 for (i = 0; i < topic->kids; i++) {
10847 child = topic->children[i];
10848 cleanHelp (child);
10849 FREE (child);
10850 }
10851 FREE (topic->children);
10852 return;
10853 }
10854
10855
10856
10857
10858 static TOPIC *buildHelp (TOPIC *topic, DEVICE *dptr,
10859 UNIT *uptr, const char *htext, va_list ap)
10860 {
10861 char *end;
10862 size_t n, ilvl;
10863 #define VSMAX 100
10864 char *vstrings[VSMAX];
10865 size_t vsnum = 0;
10866 char * astrings[VSMAX+1];
10867 size_t asnum = 0;
10868 char *const *hblock;
10869 const char *ep;
10870 t_bool excluded = FALSE;
10871
10872
10873
10874
10875
10876
10877
10878 (void)memset (vstrings, 0, sizeof (vstrings));
10879 (void)memset (astrings, 0, sizeof (astrings));
10880 astrings[asnum++] = (char *) htext;
10881
10882 for (hblock = astrings; (htext = *hblock) != NULL; hblock++) {
10883 help_where.block = hblock - astrings;
10884 help_where.line = 0;
10885 while (*htext) {
10886 const char *start;
10887
10888 help_where.line++;
10889 if (sim_isspace (*htext) || *htext == '+') {
10890 if (excluded) {
10891 while (*htext && *htext != '\n')
10892 htext++;
10893 if (*htext)
10894 ++htext;
10895 continue;
10896 }
10897 ilvl = 1;
10898 appendText (topic, " ", 4);
10899 if (*htext == '+') {
10900 while (*htext == '+') {
10901 ilvl++;
10902 appendText (topic, " ", 4);
10903 htext++;
10904 }
10905 }
10906 while (*htext && *htext != '\n' && sim_isspace (*htext))
10907 htext++;
10908 if (!*htext)
10909 break;
10910 start = htext;
10911 while (*htext) {
10912 if (*htext == '%') {
10913 appendText (topic, start, htext - start);
10914 switch (*++htext) {
10915 case 'U':
10916 if (dptr) {
10917 char buf[129];
10918 n = uptr? uptr - dptr->units: 0;
10919 (void)sprintf (buf, "%s%u", dptr->name, (int)n);
10920 appendText (topic, buf, strlen (buf));
10921 }
10922 break;
10923 case 'D':
10924 if (dptr != NULL)
10925 appendText (topic, dptr->name, strlen (dptr->name));
10926 break;
10927 case 'S':
10928 appendText (topic, sim_name, strlen (sim_name));
10929 break;
10930 case '%':
10931 appendText (topic, "%", 1);
10932 break;
10933 case '+':
10934 appendText (topic, "+", 1);
10935 break;
10936 default:
10937 if (sim_isdigit (*htext)) {
10938 n = 0;
10939 while (sim_isdigit (*htext))
10940 n += (n * 10) + (*htext++ - '0');
10941 if (( *htext != 'H' && *htext != 's') ||
10942 n == 0 || n >= VSMAX) {
10943 #if !defined(SUNLINT)
10944 FAIL (SCPE_ARG, Invalid escape, htext);
10945 #endif
10946 }
10947 while (n > vsnum)
10948 vstrings[vsnum++] = va_arg (ap, char *);
10949 start = vstrings[n-1];
10950 if (*htext == 'H') {
10951 if (asnum >= VSMAX) {
10952 #if !defined(SUNLINT)
10953 FAIL (SCPE_ARG, Too many blocks, htext);
10954 #endif
10955 }
10956 astrings[asnum++] = (char *)start;
10957 break;
10958 }
10959 ep = start;
10960 while (*ep) {
10961 if (*ep == '\n') {
10962 ep++;
10963 appendText (topic, start, ep - start);
10964 if (*ep) {
10965 size_t i;
10966 for (i = 0; i < ilvl; i++)
10967 appendText (topic, " ", 4);
10968 }
10969 start = ep;
10970 }
10971 else
10972 ep++;
10973 }
10974 appendText (topic, start, ep-start);
10975 break;
10976 }
10977 #if !defined(SUNLINT)
10978 FAIL (SCPE_ARG, Invalid escape, htext);
10979 #endif
10980 }
10981 start = ++htext;
10982 continue;
10983 }
10984 if (*htext == '\n') {
10985 htext++;
10986 appendText (topic, start, htext - start);
10987 break;
10988 }
10989 htext++;
10990 }
10991 continue;
10992 }
10993 if (sim_isdigit (*htext)) {
10994 TOPIC **children;
10995 TOPIC *newt;
10996 char nbuf[100];
10997
10998 n = 0;
10999 start = htext;
11000 while (sim_isdigit (*htext))
11001 n += (n * 10) + (*htext++ - '0');
11002 if ((htext == start) || !n) {
11003 #if !defined(SUNLINT)
11004 FAIL (SCPE_ARG, Invalid topic heading, htext);
11005 #endif
11006 }
11007 if (n <= topic->level) {
11008 while (n <= topic->level)
11009 topic = topic->parent;
11010 }
11011 else {
11012 if (n > topic->level + 1) {
11013 #if !defined(SUNLINT)
11014 FAIL (SCPE_ARG, Level not contiguous, htext);
11015 #endif
11016 }
11017 }
11018 while (*htext && (*htext != '\n') && sim_isspace (*htext))
11019 htext++;
11020 if (!*htext || (*htext == '\n')) {
11021 #if !defined(SUNLINT)
11022 FAIL (SCPE_ARG, Missing topic name, htext);
11023 #endif
11024 }
11025 start = htext;
11026 while (*htext && (*htext != '\n'))
11027 htext++;
11028 if (start == htext) {
11029 #if !defined(SUNLINT)
11030 FAIL (SCPE_ARG, Null topic name, htext);
11031 #endif
11032 }
11033 excluded = FALSE;
11034 if (*start == '?') {
11035 size_t n = 0;
11036 start++;
11037 while (sim_isdigit (*start))
11038 n += (n * 10) + (*start++ - '0');
11039 if (!*start || *start == '\n'|| n == 0 || n >= VSMAX) {
11040 #if !defined(SUNLINT)
11041 FAIL (SCPE_ARG, Invalid parameter number, start);
11042 #endif
11043 }
11044 while (n > vsnum)
11045 vstrings[vsnum++] = va_arg (ap, char *);
11046 end = vstrings[n-1];
11047 if (!end || !(toupper (*end) == 'T' || *end == '1')) {
11048 excluded = TRUE;
11049 if (*htext)
11050 htext++;
11051 continue;
11052 }
11053 }
11054 newt = (TOPIC *) calloc (sizeof (TOPIC), 1);
11055 if (!newt) {
11056 #if !defined(SUNLINT)
11057 FAIL (SCPE_MEM, No memory, NULL);
11058 #endif
11059 }
11060 size_t len = (htext > start) ? (htext - start) : 0;
11061 newt->title = (char *) malloc(len + 1);
11062 if (!newt->title) {
11063 FREE (newt);
11064 #if !defined(SUNLINT)
11065 FAIL (SCPE_MEM, No memory, NULL);
11066 #endif
11067 }
11068 memcpy (newt->title, start, htext - start);
11069 newt->title[htext - start] = '\0';
11070 if (*htext)
11071 htext++;
11072
11073 if (newt->title[0] == '$')
11074 newt->flags |= HLP_MAGIC_TOPIC;
11075
11076 children = (TOPIC **) realloc (topic->children,
11077 (topic->kids +1) * sizeof (TOPIC *));
11078 if (NULL == children) {
11079 FREE (newt->title);
11080 FREE (newt);
11081 #if !defined(SUNLINT)
11082 FAIL (SCPE_MEM, No memory, NULL);
11083 #endif
11084 }
11085 topic->children = children;
11086 topic->children[topic->kids++] = newt;
11087 newt->level = n;
11088 newt->parent = topic;
11089 n = strlen (newt->title);
11090 if (n > topic->kidwid)
11091 topic->kidwid = n;
11092 (void)sprintf (nbuf, ".%u", topic->kids);
11093 n = strlen (topic->label) + strlen (nbuf) + 1;
11094 newt->label = (char *) malloc (n);
11095 if (NULL == newt->label) {
11096 FREE (newt->title);
11097 topic->children[topic->kids -1] = NULL;
11098 FREE (newt);
11099 #if !defined(SUNLINT)
11100 FAIL (SCPE_MEM, No memory, NULL);
11101 #endif
11102 }
11103 (void)sprintf (newt->label, "%s%s", topic->label, nbuf);
11104 topic = newt;
11105 continue;
11106 }
11107 if (*htext == ';') {
11108 while (*htext && *htext != '\n')
11109 htext++;
11110 continue;
11111 }
11112 #if !defined(SUNLINT)
11113 FAIL (SCPE_ARG, Unknown line type, htext);
11114 #endif
11115 }
11116 (void)memset (vstrings, 0, VSMAX * sizeof (char *));
11117 vsnum = 0;
11118 }
11119
11120 return topic;
11121 }
11122
11123
11124
11125
11126
11127 static char *helpPrompt ( TOPIC *topic, const char *pstring, t_bool oneword )
11128 {
11129 char *prefix;
11130 char *newp, *newt;
11131
11132 if (topic->level == 0) {
11133 prefix = (char *) calloc (2,1);
11134 if (!prefix) {
11135 #if !defined(SUNLINT)
11136 FAIL (SCPE_MEM, No memory, NULL);
11137 #endif
11138 }
11139 prefix[0] = '\n';
11140 }
11141 else
11142 prefix = helpPrompt (topic->parent, "", oneword);
11143
11144 newp = (char *) malloc (strlen (prefix) + 1 + strlen (topic->title) + 1 +
11145 strlen (pstring) +1);
11146 if (!newp) {
11147 FREE (prefix);
11148 #if !defined(SUNLINT)
11149 FAIL (SCPE_MEM, No memory, NULL);
11150 #endif
11151 }
11152 strcpy (newp, prefix);
11153 if (topic->children) {
11154 if (topic->level != 0)
11155 strcat (newp, " ");
11156 newt = (topic->flags & HLP_MAGIC_TOPIC)?
11157 topic->title+1: topic->title;
11158 if (oneword) {
11159 char *np = newp + strlen (newp);
11160 while (*newt) {
11161 *np++ = blankch (*newt)? '_' : *newt;
11162 newt++;
11163 }
11164 *np = '\0';
11165 }
11166 else
11167 strcat (newp, newt);
11168 if (*pstring && *pstring != '?')
11169 strcat (newp, " ");
11170 }
11171 strcat (newp, pstring);
11172 FREE (prefix);
11173 return newp;
11174 }
11175
11176 static void displayMagicTopic (FILE *st, DEVICE *dptr, TOPIC *topic)
11177 {
11178 char tbuf[CBUFSIZE];
11179 size_t i, skiplines;
11180 #if defined(_WIN32)
11181 FILE *tmp;
11182 char *tmpnam;
11183
11184 do {
11185 int fd;
11186 tmpnam = _tempnam (NULL, "simh");
11187 fd = _open (tmpnam, _O_CREAT | _O_RDWR | _O_EXCL, _S_IREAD | _S_IWRITE);
11188 if (fd != -1) {
11189 tmp = _fdopen (fd, "w+");
11190 break;
11191 }
11192 } while (1);
11193 #else
11194 FILE *tmp = tmpfile();
11195 #endif
11196
11197 if (!tmp) {
11198 (void)fprintf (st, "Unable to create temporary file: %s (Error %d)\r\n",
11199 xstrerror_l(errno), errno);
11200 return;
11201 }
11202
11203 if (topic->title)
11204 (void)fprintf (st, "%s\r\n", topic->title+1);
11205
11206 skiplines = 0;
11207 if (topic->title) {
11208 if (!strcmp (topic->title+1, "Registers")) {
11209 fprint_reg_help (tmp, dptr) ;
11210 skiplines = 1;
11211 }
11212 else
11213 if (!strcmp (topic->title+1, "Set commands")) {
11214 fprint_set_help (tmp, dptr);
11215 skiplines = 3;
11216 }
11217 else
11218 if (!strcmp (topic->title+1, "Show commands")) {
11219 fprint_show_help (tmp, dptr);
11220 skiplines = 3;
11221 }
11222 }
11223 rewind (tmp);
11224 if (errno) {
11225 (void)fprintf (st, "rewind: error %d\r\n", errno);
11226 }
11227
11228
11229
11230 for (i =0; i < skiplines; i++)
11231 if (fgets (tbuf, sizeof (tbuf), tmp)) {};
11232
11233 while (fgets (tbuf, sizeof (tbuf), tmp)) {
11234 if (tbuf[0] != '\n')
11235 fputs (" ", st);
11236 fputs (tbuf, st);
11237 }
11238 fclose (tmp);
11239 #if defined(_WIN32)
11240 remove (tmpnam);
11241 FREE (tmpnam);
11242 #endif
11243 return;
11244 }
11245
11246
11247 static t_stat displayFlatHelp (FILE *st, DEVICE *dptr,
11248 UNIT *uptr, int32 flag,
11249 TOPIC *topic, va_list ap )
11250 {
11251 size_t i;
11252
11253 if (topic->flags & HLP_MAGIC_TOPIC) {
11254 (void)fprintf (st, "\r\n%s ", topic->label);
11255 displayMagicTopic (st, dptr, topic);
11256 }
11257 else
11258 (void)fprintf (st, "\r\n%s %s\r\n", topic->label, topic->title);
11259
11260
11261
11262
11263
11264
11265 if (topic->text)
11266 fputs (topic->text, st);
11267
11268 for (i = 0; i < topic->kids; i++)
11269 displayFlatHelp (st, dptr, uptr, flag, topic->children[i], ap);
11270
11271 return SCPE_OK;
11272 }
11273
11274 #define HLP_MATCH_AMBIGUOUS (~0u)
11275 #define HLP_MATCH_WILDCARD (~1U)
11276 #define HLP_MATCH_NONE 0
11277 static size_t matchHelpTopicName (TOPIC *topic, const char *token)
11278 {
11279 size_t i, match;
11280 char cbuf[CBUFSIZE], *cptr;
11281
11282 if (!strcmp (token, "*"))
11283 return HLP_MATCH_WILDCARD;
11284
11285 match = 0;
11286 for (i = 0; i < topic->kids; i++) {
11287 strcpy (cbuf,topic->children[i]->title +
11288 ((topic->children[i]->flags & HLP_MAGIC_TOPIC)? 1 : 0));
11289 cptr = cbuf;
11290 while (*cptr) {
11291 if (blankch (*cptr)) {
11292 *cptr++ = '_';
11293 }
11294 else {
11295 *cptr = (char)toupper (*cptr);
11296 cptr++;
11297 }
11298 }
11299 if (!strcmp (cbuf, token))
11300 return i+1;
11301 if (!strncmp (cbuf, token, strlen (token))) {
11302 if (match)
11303 return HLP_MATCH_AMBIGUOUS;
11304 match = i+1;
11305 }
11306 }
11307 return match;
11308 }
11309
11310
11311
11312 t_stat scp_vhelp (FILE *st, DEVICE *dptr,
11313 UNIT *uptr, int32 flag,
11314 const char *help, const char *cptr, va_list ap)
11315 {
11316 TOPIC top;
11317 TOPIC *topic = ⊤
11318 int failed;
11319 size_t match;
11320 size_t i;
11321 const char *p;
11322 t_bool flat_help = FALSE;
11323 char cbuf [CBUFSIZE], gbuf[CBUFSIZE];
11324
11325 static const char attach_help[] = { " ATTACH" };
11326 static const char brief_help[] = { "%s help. Type <CR> to exit, HELP for navigation help.\r\n" };
11327 static const char onecmd_help[] = { "%s help.\r\n" };
11328 static const char help_help[] = {
11329
11330 " To see more HELP information, type the listed subtopic name. To move\r\n"
11331 " up a level, just type <CR>. To review the current subtopic, type \"?\".\r\n"
11332 " To view all subtopics, type \"*\". To exit type \"EXIT\", \"^C\", or \"^D\".\r\n\r\n"
11333 };
11334
11335 (void)memset (&top, 0, sizeof(top));
11336 top.parent = ⊤
11337 if ((failed = setjmp (help_env)) != 0) {
11338 (void)fprintf (stderr, "\r\nHELP was unable to process HELP for this device.\r\n"
11339 "Error in block %u line %u: %s\r\n"
11340 "%s%*.*s%s\r\n",
11341 (int)help_where.block, (int)help_where.line, help_where.error,
11342 help_where.prox ? "Near '" : "",
11343 help_where.prox ? 15 : 0, help_where.prox ? 15 : 0,
11344 help_where.prox ? help_where.prox : "",
11345 help_where.prox ? "'" : "");
11346 cleanHelp (&top);
11347 return failed;
11348 }
11349
11350
11351
11352
11353
11354 if (dptr) {
11355 p = dptr->name;
11356 flat_help = (dptr->flags & DEV_FLATHELP) != 0;
11357 }
11358 else
11359 p = sim_name;
11360 top.title = (char *) malloc (strlen (p) + ((flag & SCP_HELP_ATTACH)? sizeof (attach_help)-1: 0) +1);
11361 if (!top.title)
11362 {
11363 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
11364 __func__, __FILE__, __LINE__);
11365 #if defined(USE_BACKTRACE)
11366 # if defined(SIGUSR2)
11367 (void)raise(SIGUSR2);
11368
11369 # endif
11370 #endif
11371 abort();
11372 }
11373 for (i = 0; p[i]; i++ )
11374 top.title[i] = (char)toupper (p[i]);
11375 top.title[i] = '\0';
11376 if (flag & SCP_HELP_ATTACH)
11377 strcpy (top.title+i, attach_help);
11378
11379 top.label = (char *) malloc (sizeof ("1"));
11380 if (!top.label)
11381 {
11382 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
11383 __func__, __FILE__, __LINE__);
11384 #if defined(USE_BACKTRACE)
11385 # if defined(SIGUSR2)
11386 (void)raise(SIGUSR2);
11387
11388 # endif
11389 #endif
11390 abort();
11391 }
11392 strcpy (top.label, "1");
11393
11394 flat_help = flat_help || !sim_ttisatty() || (flag & SCP_HELP_FLAT);
11395
11396 if (flat_help) {
11397 flag |= SCP_HELP_FLAT;
11398 if (sim_ttisatty())
11399 (void)fprintf (st, "%s help.\r\nThis help is also available in hierarchical form.\r\n", top.title);
11400 else
11401 (void)fprintf (st, "%s help.\r\n", top.title);
11402 }
11403 else
11404 (void)fprintf (st, ((flag & SCP_HELP_ONECMD)? onecmd_help: brief_help), top.title);
11405
11406
11407
11408 (void) buildHelp (&top, dptr, uptr, help, ap);
11409
11410
11411
11412 while (cptr && *cptr) {
11413 cptr = get_glyph (cptr, gbuf, 0);
11414 if (!gbuf[0])
11415 break;
11416 if (!strcmp (gbuf, "HELP")) {
11417 (void)fprintf (st, "\r\n");
11418 fputs (help_help, st);
11419 break;
11420 }
11421 match = matchHelpTopicName (topic, gbuf);
11422 if (match == HLP_MATCH_WILDCARD) {
11423 if (dptr)
11424 displayFlatHelp (st, dptr, uptr, flag, topic, ap);
11425 cleanHelp (&top);
11426 return SCPE_OK;
11427 }
11428 if (match == HLP_MATCH_AMBIGUOUS) {
11429 (void)fprintf (st, "\r\n%s is ambiguous in %s\r\n", gbuf, topic->title);
11430 break;
11431 }
11432 if (match == HLP_MATCH_NONE) {
11433 (void)fprintf (st, "\r\n%s is not available in %s\r\n", gbuf, topic->title);
11434 break;
11435 }
11436 topic = topic->children[match-1];
11437 }
11438 cptr = NULL;
11439
11440 if (flat_help) {
11441 displayFlatHelp (st, dptr, uptr, flag, topic, ap);
11442 cleanHelp (&top);
11443 return SCPE_OK;
11444 }
11445
11446
11447
11448 while (TRUE) {
11449 char *pstring;
11450 const char *prompt[2] = {"? ", "Subtopic? "};
11451
11452
11453
11454 if (topic->flags & HLP_MAGIC_TOPIC) {
11455 fputc ('\n', st);
11456 displayMagicTopic (st, dptr, topic);
11457 }
11458 else
11459 (void)fprintf (st, "\r\n%s\r\n", topic->title);
11460
11461
11462
11463
11464
11465 if (topic->text)
11466 fputs (topic->text, st);
11467
11468 if (topic->kids) {
11469 size_t w = 0;
11470 char *p;
11471 char tbuf[CBUFSIZE];
11472
11473 (void)fprintf (st, "\r\n Additional information available:\r\n\r\n");
11474 for (i = 0; i < topic->kids; i++) {
11475 strcpy (tbuf, topic->children[i]->title +
11476 ((topic->children[i]->flags & HLP_MAGIC_TOPIC)? 1 : 0));
11477 for (p = tbuf; *p; p++) {
11478 if (blankch (*p))
11479 *p = '_';
11480 }
11481 w += 4 + topic->kidwid;
11482 if (w > 80) {
11483 w = 4 + topic->kidwid;
11484 fputc ('\r', st);
11485 fputc ('\n', st);
11486 }
11487 (void)fprintf (st, " %-*s", (int32_t)topic->kidwid, tbuf);
11488 }
11489 (void)fprintf (st, "\r\n\r\n");
11490 if (flag & SCP_HELP_ONECMD) {
11491 pstring = helpPrompt (topic, "", TRUE);
11492 (void)fprintf (st, "To view additional topics, type HELP %s topicname\r\n", pstring+1);
11493 FREE (pstring);
11494 break;
11495 }
11496 }
11497
11498 if (!sim_ttisatty() || (flag & SCP_HELP_ONECMD))
11499 break;
11500
11501 reprompt:
11502 if (NULL == cptr || !*cptr) {
11503 if (topic->kids == 0)
11504 topic = topic->parent;
11505 pstring = helpPrompt (topic, prompt[topic->kids != 0], FALSE);
11506
11507 cptr = read_line_p (pstring+1, cbuf, sizeof (cbuf), stdin);
11508 FREE (pstring);
11509 if ((cptr != NULL) &&
11510 ((0 == strcmp (cptr, "\x04")) ||
11511 (0 == strcmp (cptr, "\x1A"))))
11512 cptr = NULL;
11513 }
11514
11515 if (NULL == cptr)
11516 break;
11517
11518 cptr = get_glyph (cptr, gbuf, 0);
11519 if (!strcmp (gbuf, "*")) {
11520 displayFlatHelp (st, dptr, uptr, flag, topic, ap);
11521 gbuf[0] = '\0';
11522 }
11523 if (!gbuf[0]) {
11524 if (topic->level == 0)
11525 break;
11526 topic = topic->parent;
11527 continue;
11528 }
11529 if (!strcmp (gbuf, "?"))
11530 continue;
11531 if (!strcmp (gbuf, "HELP")) {
11532 fputs (help_help, st);
11533 goto reprompt;
11534 }
11535 if (!strcmp (gbuf, "EXIT") || !strcmp (gbuf, "QUIT"))
11536 break;
11537
11538
11539
11540 if (!topic->kids) {
11541 (void)fprintf (st, "No additional help at this level.\r\n");
11542 cptr = NULL;
11543 goto reprompt;
11544 }
11545 match = matchHelpTopicName (topic, gbuf);
11546 if (match == HLP_MATCH_AMBIGUOUS) {
11547 (void)fprintf (st, "%s is ambiguous, please type more of the topic name\r\n", gbuf);
11548 cptr = NULL;
11549 goto reprompt;
11550 }
11551
11552 if (match == HLP_MATCH_NONE) {
11553 (void)fprintf (st, "Help for %s is not available\r\n", gbuf);
11554 cptr = NULL;
11555 goto reprompt;
11556 }
11557
11558
11559 topic = topic->children[match-1];
11560 }
11561
11562
11563
11564 cleanHelp (&top);
11565
11566 return SCPE_OK;
11567 }
11568
11569
11570
11571 t_stat scp_help (FILE *st, DEVICE *dptr,
11572 UNIT *uptr, int32 flag,
11573 const char *help, const char *cptr, ...)
11574 {
11575 t_stat r;
11576 va_list ap;
11577
11578 va_start (ap, cptr);
11579 r = scp_vhelp (st, dptr, uptr, flag, help, cptr, ap);
11580 va_end (ap);
11581
11582 return r;
11583 }
11584
11585 #if defined(_MSC_VER)
11586 # pragma warning(pop)
11587 #endif
![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
![[previous]](../icons/left.png)
![[last]](../icons/n_last.png)
![[bottom]](../icons/n_bottom.png){kind=icon}