This source file includes following definitions.
- setenv
- unsetenv
- xstrerror_l
- processIsTranslated
- strremove
- strtrimspace
- allowCores
- CleanDUMA
- dl_iterate_phdr_callback
- GetUCRTVersion
- 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_tape.h"
59 #include "sim_sock.h"
60
61 #include <signal.h>
62 #include <ctype.h>
63 #include <time.h>
64 #include <math.h>
65 #include <stddef.h>
66 #if defined(_WIN32)
67 # if !defined(WIN32_LEAN_AND_MEAN)
68 # define WIN32_LEAN_AND_MEAN
69 # endif
70 # if defined(_MSC_VER)
71 # pragma warning(push, 3)
72 # endif
73 # include <direct.h>
74 # include <io.h>
75 # include <fcntl.h>
76 #else
77 # include <unistd.h>
78 # define HAVE_UNISTD 1
79 #endif
80 #include <sys/stat.h>
81 #include <sys/types.h>
82 #if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__MINGW64__) && !defined(CROSS_MINGW32) && !defined(CROSS_MINGW64)
83 # include <sys/resource.h>
84 #endif
85 #include <setjmp.h>
86 #include <stdint.h>
87 #include <limits.h>
88 #if defined(__APPLE__)
89 # include <xlocale.h>
90 #endif
91 #include <locale.h>
92
93 #include "linehistory.h"
94
95 #if defined(__APPLE__)
96 # include <sys/sysctl.h>
97 #endif
98
99 #if ( defined(__linux__) || defined(__linux) || defined(_linux) || defined(linux) )
100 # include <sys/sysinfo.h>
101 # define LINUX_OS
102 #endif
103
104 #include <uv.h>
105
106 #if !defined(HAVE_UNISTD)
107 # undef USE_BACKTRACE
108 #endif
109
110 #if defined(USE_BACKTRACE)
111 # include <string.h>
112 # include <signal.h>
113 #endif
114
115 #if defined(__HAIKU__)
116 # include <OS.h>
117 #endif
118
119 #if !defined(__CYGWIN__)
120 # if !defined(__APPLE__)
121 # if !defined(_AIX)
122 # if !defined(__MINGW32__)
123 # if !defined(__MINGW64__)
124 # if !defined(CROSS_MINGW32)
125 # if !defined(CROSS_MINGW64)
126 # if !defined(_WIN32)
127 # if !defined(__HAIKU__)
128 # include <link.h>
129 # endif
130 # endif
131 # endif
132 # endif
133 # endif
134 # endif
135 # endif
136 # endif
137 #endif
138
139 #if defined(_WIN32) || defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
140 # include <windows.h>
141 #endif
142
143 #if defined(__CYGWIN__)
144 # include <windows.h>
145 # include <sys/utsname.h>
146 # include <sys/cygwin.h>
147 # include <cygwin/version.h>
148 #endif
149
150 #define DBG_CTR 0
151
152 #include "../dps8/dps8.h"
153 #include "../dps8/dps8_cpu.h"
154 #include "../dps8/ver.h"
155 #include "../dps8/sysdefs.h"
156
157 #include "../dps8/dps8_iom.h"
158 #include "../dps8/dps8_fnp2.h"
159
160 #include "../decNumber/decContext.h"
161 #include "../decNumber/decNumberLocal.h"
162
163 #include "../dps8/dps8_math128.h"
164
165 #if !defined(__CYGWIN__)
166 # if !defined(__APPLE__)
167 # if !defined(_AIX)
168 # if !defined(__MINGW32__)
169 # if !defined(__MINGW64__)
170 # if !defined(CROSS_MINGW32)
171 # if !defined(CROSS_MINGW64)
172 # if !defined(_WIN32)
173 # if !defined(__HAIKU__)
174 static unsigned int dl_iterate_phdr_callback_called = 0;
175 # endif
176 # endif
177 # endif
178 # endif
179 # endif
180 # endif
181 # endif
182 # endif
183 #endif
184
185 #if defined(MAX)
186 # undef MAX
187 #endif
188 #define MAX(a,b) (((a) >= (b)) ? (a) : (b))
189
190 #if defined(FREE)
191 # undef FREE
192 #endif
193 #define FREE(p) do \
194 { \
195 free((p)); \
196 (p) = NULL; \
197 } while(0)
198
199
200
201 #define SCH_OR 0
202 #define SCH_AND 1
203 #define SCH_XOR 2
204 #define SCH_E 0
205 #define SCH_N 1
206 #define SCH_G 2
207 #define SCH_L 3
208 #define SCH_EE 4
209 #define SCH_NE 5
210 #define SCH_GE 6
211 #define SCH_LE 7
212
213 #define MAX_DO_NEST_LVL 20
214 #define SRBSIZ 1024
215 #define SIM_BRK_INILNT 4096
216 #define SIM_BRK_ALLTYP 0xFFFFFFFB
217
218 #define UPDATE_SIM_TIME \
219 if (1) { \
220 int32 _x; \
221 if (sim_clock_queue == QUEUE_LIST_END) \
222 _x = noqueue_time; \
223 else \
224 _x = sim_clock_queue->time; \
225 sim_time = sim_time + (_x - sim_interval); \
226 sim_rtime = sim_rtime + ((uint32) (_x - sim_interval)); \
227 if (sim_clock_queue == QUEUE_LIST_END) \
228 noqueue_time = sim_interval; \
229 else \
230 sim_clock_queue->time = sim_interval; \
231 } \
232 else \
233 (void)0
234
235 #define SZ_D(dp) (size_map[((dp)->dwidth + CHAR_BIT - 1) / CHAR_BIT])
236
237 #define SZ_R(rp) \
238 (size_map[((rp)->width + (rp)->offset + CHAR_BIT - 1) / CHAR_BIT])
239
240 #define SZ_LOAD(sz,v,mb,j) \
241 if (sz == sizeof (uint8)) v = *(((uint8 *) mb) + ((uint32) j)); \
242 else if (sz == sizeof (uint16)) v = *(((uint16 *) mb) + ((uint32) j)); \
243 else if (sz == sizeof (uint32)) v = *(((uint32 *) mb) + ((uint32) j)); \
244 else v = *(((t_uint64 *) mb) + ((uint32) j));
245
246 #define SZ_STORE(sz,v,mb,j) \
247 if (sz == sizeof (uint8)) *(((uint8 *) mb) + j) = (uint8) v; \
248 else if (sz == sizeof (uint16)) *(((uint16 *) mb) + ((uint32) j)) = (uint16) v; \
249 else if (sz == sizeof (uint32)) *(((uint32 *) mb) + ((uint32) j)) = (uint32) v; \
250 else *(((t_uint64 *) mb) + ((uint32) j)) = v;
251
252 #define GET_SWITCHES(cp) \
253 if ((cp = get_sim_sw (cp)) == NULL) return SCPE_INVSW
254
255 #define GET_RADIX(val,dft) \
256 if (sim_switches & SWMASK ('O')) val = 8; \
257 else if (sim_switches & SWMASK ('D')) val = 10; \
258 else if (sim_switches & SWMASK ('H')) val = 16; \
259 else val = dft;
260
261
262
263
264
265
266 t_bool sim_asynch_enabled = FALSE;
267 t_stat tmxr_locate_line_send (const char *dev_line, SEND **snd);
268 t_stat tmxr_locate_line_expect (const char *dev_line, EXPECT **exp);
269 extern void (*sim_vm_init) (void);
270 extern void (*sim_vm_exit) (void);
271 char* (*sim_vm_read) (char *ptr, int32 size, FILE *stream) = NULL;
272 void (*sim_vm_post) (t_bool from_scp) = NULL;
273 CTAB *sim_vm_cmd = NULL;
274 void (*sim_vm_sprint_addr) (char *buf, DEVICE *dptr, t_addr addr) = NULL;
275 void (*sim_vm_fprint_addr) (FILE *st, DEVICE *dptr, t_addr addr) = NULL;
276 t_addr (*sim_vm_parse_addr) (DEVICE *dptr, CONST char *cptr, CONST char **tptr) = NULL;
277 t_value (*sim_vm_pc_value) (void) = NULL;
278 t_bool (*sim_vm_is_subroutine_call) (t_addr **ret_addrs) = NULL;
279 t_bool (*sim_vm_fprint_stopped) (FILE *st, t_stat reason) = NULL;
280
281
282
283
284
285 t_stat set_dev_radix (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
286 t_stat set_dev_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
287 t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
288 t_stat set_unit_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
289 t_stat ssh_break (FILE *st, const char *cptr, int32 flg);
290 t_stat show_cmd_fi (FILE *ofile, int32 flag, CONST char *cptr);
291 t_stat show_config (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
292 t_stat show_queue (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
293 t_stat show_time (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
294 t_stat show_mod_names (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
295 t_stat show_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
296 t_stat show_log_names (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
297 t_stat show_dev_radix (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
298 t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
299 t_stat show_dev_logicals (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
300 t_stat show_dev_modifiers (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
301 t_stat show_dev_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
302 t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
303 t_stat show_buildinfo (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cprr);
304 t_stat show_prom (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
305 t_stat show_default_base_system_script (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
306 t_stat show_default (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
307 t_stat show_break (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
308 t_stat show_on (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
309 t_stat sim_show_send (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
310 t_stat sim_show_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
311 t_stat show_device (FILE *st, DEVICE *dptr, int32 flag);
312 t_stat show_unit (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag);
313 t_stat show_all_mods (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flg, int32 *toks);
314 t_stat show_one_mod (FILE *st, DEVICE *dptr, UNIT *uptr, MTAB *mptr, CONST char *cptr, int32 flag);
315 t_stat sim_save (FILE *sfile);
316 t_stat sim_rest (FILE *rfile);
317
318
319
320 t_stat sim_brk_init (void);
321 t_stat sim_brk_set (t_addr loc, int32 sw, int32 ncnt, CONST char *act);
322 t_stat sim_brk_clr (t_addr loc, int32 sw);
323 t_stat sim_brk_clrall (int32 sw);
324 t_stat sim_brk_show (FILE *st, t_addr loc, int32 sw);
325 t_stat sim_brk_showall (FILE *st, int32 sw);
326 CONST char *sim_brk_getact (char *buf, int32 size);
327 BRKTAB *sim_brk_new (t_addr loc, uint32 btyp);
328 char *sim_brk_clract (void);
329
330 FILE *stdnul;
331
332
333
334 SCHTAB *get_rsearch (CONST char *cptr, int32 radix, SCHTAB *schptr);
335 SCHTAB *get_asearch (CONST char *cptr, int32 radix, SCHTAB *schptr);
336 int32 test_search (t_value *val, SCHTAB *schptr);
337 static const char *get_glyph_gen (const char *iptr, char *optr, char mchar, t_bool uc, t_bool quote, char escape_char);
338 int32 get_switches (const char *cptr);
339 CONST char *get_sim_sw (CONST char *cptr);
340 t_stat get_aval (t_addr addr, DEVICE *dptr, UNIT *uptr);
341 t_value get_rval (REG *rptr, uint32 idx);
342 void put_rval (REG *rptr, uint32 idx, t_value val);
343 void fprint_help (FILE *st);
344 void fprint_stopped (FILE *st, t_stat r);
345 void fprint_capac (FILE *st, DEVICE *dptr, UNIT *uptr);
346 void fprint_sep (FILE *st, int32 *tokens);
347 char *read_line (char *ptr, int32 size, FILE *stream);
348 char *read_line_p (const char *prompt, char *ptr, int32 size, FILE *stream);
349 REG *find_reg_glob (CONST char *ptr, CONST char **optr, DEVICE **gdptr);
350 char *sim_trim_endspc (char *cptr);
351
352
353
354 t_stat scp_attach_unit (DEVICE *dptr, UNIT *uptr, const char *cptr);
355 t_stat scp_detach_unit (DEVICE *dptr, UNIT *uptr);
356 t_bool qdisable (DEVICE *dptr);
357 t_stat attach_err (UNIT *uptr, t_stat stat);
358 t_stat detach_all (int32 start_device, t_bool shutdown);
359 t_stat assign_device (DEVICE *dptr, const char *cptr);
360 t_stat deassign_device (DEVICE *dptr);
361 t_stat ssh_break_one (FILE *st, int32 flg, t_addr lo, int32 cnt, CONST char *aptr);
362 t_stat exdep_reg_loop (FILE *ofile, SCHTAB *schptr, int32 flag, CONST char *cptr,
363 REG *lowr, REG *highr, uint32 lows, uint32 highs);
364 t_stat ex_reg (FILE *ofile, t_value val, int32 flag, REG *rptr, uint32 idx);
365 t_stat dep_reg (int32 flag, CONST char *cptr, REG *rptr, uint32 idx);
366 t_stat exdep_addr_loop (FILE *ofile, SCHTAB *schptr, int32 flag, const char *cptr,
367 t_addr low, t_addr high, DEVICE *dptr, UNIT *uptr);
368 t_stat ex_addr (FILE *ofile, int32 flag, t_addr addr, DEVICE *dptr, UNIT *uptr);
369 t_stat dep_addr (int32 flag, const char *cptr, t_addr addr, DEVICE *dptr,
370 UNIT *uptr, int32 dfltinc);
371 void fprint_fields (FILE *stream, t_value before, t_value after, BITFIELD* bitdefs);
372 t_stat step_svc (UNIT *ptr);
373 t_stat expect_svc (UNIT *ptr);
374 t_stat set_on (int32 flag, CONST char *cptr);
375 t_stat set_verify (int32 flag, CONST char *cptr);
376 t_stat set_message (int32 flag, CONST char *cptr);
377 t_stat set_quiet (int32 flag, CONST char *cptr);
378 t_stat set_localopc (int32 flag, CONST char *cptr);
379 t_stat set_asynch (int32 flag, CONST char *cptr);
380 t_stat sim_show_asynch (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
381 t_stat do_cmd_label (int32 flag, CONST char *cptr, CONST char *label);
382 void int_handler (int signal);
383 t_stat set_prompt (int32 flag, CONST char *cptr);
384 t_stat sim_set_asynch (int32 flag, CONST char *cptr);
385 t_stat sim_set_environment (int32 flag, CONST char *cptr);
386 static const char *get_dbg_verb (uint32 dbits, DEVICE* dptr);
387
388
389
390 DEVICE *sim_dflt_dev = NULL;
391 UNIT *sim_clock_queue = QUEUE_LIST_END;
392 int32 sim_interval = 0;
393 int32 sim_switches = 0;
394 FILE *sim_ofile = NULL;
395 SCHTAB *sim_schrptr = FALSE;
396 SCHTAB *sim_schaptr = FALSE;
397 DEVICE *sim_dfdev = NULL;
398 UNIT *sim_dfunit = NULL;
399 DEVICE **sim_internal_devices = NULL;
400 uint32 sim_internal_device_count = 0;
401 int32 sim_opt_out = 0;
402 int32 sim_is_running = 0;
403 t_bool sim_processing_event = FALSE;
404 uint32 sim_brk_summ = 0;
405 uint32 sim_brk_types = 0;
406 BRKTYPTAB *sim_brk_type_desc = NULL;
407 uint32 sim_brk_dflt = 0;
408 uint32 sim_brk_match_type;
409 t_addr sim_brk_match_addr;
410 char *sim_brk_act[MAX_DO_NEST_LVL];
411 char *sim_brk_act_buf[MAX_DO_NEST_LVL];
412 BRKTAB **sim_brk_tab = NULL;
413 int32 sim_brk_ent = 0;
414 int32 sim_brk_lnt = 0;
415 int32 sim_brk_ins = 0;
416 int32 sim_iglock = 0;
417 int32 sim_nolock = 0;
418 int32 sim_quiet = 0;
419 int32 sim_localopc = 1;
420 int32 sim_randompst = 0;
421 int32 sim_randstate = 0;
422 int32 sim_step = 0;
423 int nodist = 0;
424 #if defined(PERF_STRIP)
425 int32 sim_nostate = 1;
426 #else
427 int32 sim_nostate = 0;
428 #endif
429 static double sim_time;
430 static uint32 sim_rtime;
431 static int32 noqueue_time;
432 volatile int32 stop_cpu = 0;
433 t_value *sim_eval = NULL;
434 static t_value sim_last_val;
435 static t_addr sim_last_addr;
436 FILE *sim_log = NULL;
437 FILEREF *sim_log_ref = NULL;
438 FILE *sim_deb = NULL;
439 FILEREF *sim_deb_ref = NULL;
440 int32 sim_deb_switches = 0;
441 struct timespec sim_deb_basetime;
442 char *sim_prompt = NULL;
443 static FILE *sim_gotofile;
444 static int32 sim_goto_line[MAX_DO_NEST_LVL+1];
445 static int32 sim_do_echo = 0;
446 static int32 sim_show_message = 1;
447 static int32 sim_on_inherit = 0;
448 static int32 sim_do_depth = 0;
449
450 static int32 sim_on_check[MAX_DO_NEST_LVL+1];
451 static char *sim_on_actions[MAX_DO_NEST_LVL+1][SCPE_MAX_ERR+1];
452 static char sim_do_filename[MAX_DO_NEST_LVL+1][CBUFSIZE];
453 static const char *sim_do_ocptr[MAX_DO_NEST_LVL+1];
454 static const char *sim_do_label[MAX_DO_NEST_LVL+1];
455
456 t_stat sim_last_cmd_stat;
457
458 static SCHTAB sim_stabr;
459 static SCHTAB sim_staba;
460
461 static UNIT sim_step_unit = { UDATA (&step_svc, 0, 0) };
462 static UNIT sim_expect_unit = { UDATA (&expect_svc, 0, 0) };
463
464
465
466 const char save_vercur[] = "V4.1";
467 const char save_ver40[] = "V4.0";
468 const char save_ver35[] = "V3.5";
469 const char save_ver32[] = "V3.2";
470 const char save_ver30[] = "V3.0";
471 const struct scp_error {
472 const char *code;
473 const char *message;
474 } scp_errors[1+SCPE_MAX_ERR-SCPE_BASE] =
475 {{"NXM", "Address space exceeded"},
476 {"UNATT", "Unit not attached"},
477 {"IOERR", "I/O error"},
478 {"CSUM", "Checksum error"},
479 {"FMT", "Format error"},
480 {"NOATT", "Unit not attachable"},
481 {"OPENERR", "File open error"},
482 {"MEM", "Memory exhausted"},
483 {"ARG", "Invalid argument"},
484 {"STEP", "Step expired"},
485 {"UNK", "Unknown command"},
486 {"RO", "Read only argument"},
487 {"INCOMP", "Command not completed"},
488 {"STOP", "Simulation stopped"},
489 {"EXIT", "Goodbye"},
490 {"TTIERR", "Console input I/O error"},
491 {"TTOERR", "Console output I/O error"},
492 {"EOF", "End of file"},
493 {"REL", "Relocation error"},
494 {"NOPARAM", "No settable parameters"},
495 {"ALATT", "Unit already attached"},
496 {"TIMER", "Hardware timer error"},
497 {"SIGERR", "Signal handler setup error"},
498 {"TTYERR", "Console terminal setup error"},
499 {"SUB", "Subscript out of range"},
500 {"NOFNC", "Command not allowed"},
501 {"UDIS", "Unit disabled"},
502 {"NORO", "Read only operation not allowed"},
503 {"INVSW", "Invalid switch"},
504 {"MISVAL", "Missing value"},
505 {"2FARG", "Too few arguments"},
506 {"2MARG", "Too many arguments"},
507 {"NXDEV", "Non-existent device"},
508 {"NXUN", "Non-existent unit"},
509 {"NXREG", "Non-existent register"},
510 {"NXPAR", "Non-existent parameter"},
511 {"NEST", "Nested DO command limit exceeded"},
512 {"IERR", "Internal error"},
513 {"MTRLNT", "Invalid magtape record length"},
514 {"LOST", "Console Telnet connection lost"},
515 {"TTMO", "Console Telnet connection timed out"},
516 {"STALL", "Console Telnet output stall"},
517 {"AFAIL", "Assertion failed"},
518 {"INVREM", "Invalid remote console command"},
519 {"NOTATT", "Not attached"},
520 {"EXPECT", "Expect matched"},
521 {"REMOTE", "Remote console command"},
522 };
523
524 const size_t size_map[] = { sizeof (int8),
525 sizeof (int8), sizeof (int16), sizeof (int32), sizeof (int32)
526 , sizeof (t_int64), sizeof (t_int64), sizeof (t_int64), sizeof (t_int64)
527 };
528
529 const t_value width_mask[] = { 0,
530 0x1, 0x3, 0x7, 0xF,
531 0x1F, 0x3F, 0x7F, 0xFF,
532 0x1FF, 0x3FF, 0x7FF, 0xFFF,
533 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF,
534 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF,
535 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, 0xFFFFFF,
536 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF,
537 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF,
538 0x1FFFFFFFF, 0x3FFFFFFFF, 0x7FFFFFFFF, 0xFFFFFFFFF,
539 0x1FFFFFFFFF, 0x3FFFFFFFFF, 0x7FFFFFFFFF, 0xFFFFFFFFFF,
540 0x1FFFFFFFFFF, 0x3FFFFFFFFFF, 0x7FFFFFFFFFF, 0xFFFFFFFFFFF,
541 0x1FFFFFFFFFFF, 0x3FFFFFFFFFFF, 0x7FFFFFFFFFFF, 0xFFFFFFFFFFFF,
542 0x1FFFFFFFFFFFF, 0x3FFFFFFFFFFFF, 0x7FFFFFFFFFFFF, 0xFFFFFFFFFFFFF,
543 0x1FFFFFFFFFFFFF, 0x3FFFFFFFFFFFFF, 0x7FFFFFFFFFFFFF, 0xFFFFFFFFFFFFFF,
544 0x1FFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFF,
545 0x1FFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF
546 };
547
548 static const char simh_help[] =
549
550 "1Commands\n"
551 #define HLP_RESET "*Commands Resetting Devices"
552
553 "2Resetting Devices\n"
554 " The `RESET` command (*abbreviated* `RE`) resets a device or the entire\n"
555 " simulator to a predefined condition. If the switch \"`-p`\" is specified,\n"
556 " the device is reset to its initial power-on state:\n\n"
557 "++RESET resets all devices\n"
558 "++RESET -p power-cycle all devices\n"
559 "++RESET ALL resets all devices\n"
560 "++RESET <device> resets the specified <device>\n\n"
561 " * Typically, `RESET` *aborts* in-progress I/O operations, *clears* any\n"
562 " interrupt requests, and returns the device to a quiescent state.\n\n"
563 " * It does **NOT** clear the main memory or affect associated I/O\n"
564 " connections.\n"
565 #define HLP_EXAMINE "*Commands Examining_and_Changing_State"
566 #define HLP_IEXAMINE "*Commands Examining_and_Changing_State"
567 #define HLP_DEPOSIT "*Commands Examining_and_Changing_State"
568 #define HLP_IDEPOSIT "*Commands Examining_and_Changing_State"
569
570 "2Examining and Changing State\n"
571 " There are four commands to examine and change state:\n\n"
572 " * `EXAMINE` (*abbreviated* `E`) examines state\n"
573 " * `DEPOSIT` (*abbreviated* `D`) changes state\n"
574 " * `IEXAMINE` (\"interactive examine\", *abbreviated* `IE`) examines state\n"
575 " and allows the user to interactively change it\n"
576 " * `IDEPOSIT` (interactive deposit, *abbreviated* `ID`) allows the user to\n"
577 " interactively change state\n\n"
578 " All four commands take the form:\n\n"
579 "++command {modifiers} <object list>\n\n"
580 " The `DEPOSIT` command requires the deposit value at the end of the command.\n\n"
581 " There are four kinds of modifiers: **switches**, **device/unit name**,\n"
582 " **search specifier**, and for `EXAMINE`, **output file**.\n\n"
583 " * **Switches** have been described previously.\n"
584 " * A **device/unit name** identifies the device and unit whose address\n"
585 " space is to be examined or modified. If no device is specified, the CPU\n"
586 " main memory is selected. If a device but no unit is specified, unit `0`\n"
587 " of the specified device is selected automatically.\n"
588 " * The **search specifier** provides criteria for testing addresses or\n"
589 " registers to see if they should be processed. The search specifier\n"
590 " consists of a \"<`logical operator`>\", a \"<`relational operator`>\", or\n"
591 " both, optionally separated by spaces:\n\n"
592 "++{ < logical op > < value > } < relational op > < value >\n\n"
593
594 " * * The \"<`logical operator`>\" may be \"`&`\" (*and*), \"`|`\" (*or*),\n"
595 " or \"`^`\" (*exclusive or*), and the \"<`relational operator`>\" may\n"
596 " be \"`=`\" or \"`==`\" (*equal*), \"`!`\" or \"`!=`\" (*not\n"
597 " equal*), \">=\" (*greater than or equal*), \">\" (*greater\n"
598 " than*), \"<=\" (*less than or equal*), or \"<\" (*less than*).\n"
599 " * * If any \"<`logical operator`>\" is specified without\n"
600 " a \"<`relational operator`>\", it is ignored.\n"
601 " * * If any \"<`relational operator`>\" is specified without\n"
602 " a \"<`logical operator`>\", no logical operation is performed.\n"
603 " * * All comparisons are unsigned.\n\n"
604 " * The **output file** modifier redirects the command output to a file\n"
605 " instead of the console. The **output file** modifier is specified with\n"
606 " the \"`@`\" (*commercial-at*) character, followed by a valid file name.\n\n"
607 " **NOTE**: Modifiers may be specified in any order. If multiple\n"
608 " modifiers of the same type are specified, later modifiers override earlier\n"
609 " modifiers. If the **device/unit name** comes *after* the search specifier,\n"
610 " the search values will interpreted in the *radix of the CPU*, rather than\n"
611 " of the device/unit.\n\n"
612 " The \"<`object list`>\" argument consists of one or more of the following,\n"
613 " separated by commas:\n\n"
614
615 "++register the specified register\n"
616 "++register[sub1-sub2] the specified register array locations,\n"
617 "++++++++ starting at location sub1 up to and\n"
618 "++++++++ including location sub2\n"
619 "++register[sub1/length] the specified register array locations,\n"
620 "++++++++ starting at location sub1 up to but\n"
621 "++++++++ not including sub1+length\n"
622 "++register[ALL] all locations in the specified register\n"
623 "++++++++ array\n"
624 "++register1-register2 all the registers starting at register1\n"
625 "++++++++ up to and including register2\n"
626 "++address the specified location\n"
627 "++address1-address2 all locations starting at address1 up to\n"
628 "++++++++ and including address2\n"
629 "++address/length all location starting at address up to\n"
630 "++++++++ but not including address+length\n"
631 "++STATE all registers in the device\n"
632 "++ALL all locations in the unit\n"
633 "++$ the last value displayed by an EXAMINE\n"
634 "++++++++ command interpreted as an address\n"
635 "3Switches\n"
636 "4Formatting Control\n"
637 " Switches can be used to control the format of the displayed information:\n\n"
638
639 "5-a\n"
640 " display as ASCII\n"
641 "5-c\n"
642 " display as character string\n"
643 "5-m\n"
644 " display as instruction mnemonics\n"
645 "5-o\n"
646 " display as octal\n"
647 "5-d\n"
648 " display as decimal\n"
649 "5-h\n"
650 " display as hexadecimal\n\n"
651 "3Examples\n"
652 "++ex 1000-1100 examine 1000 to 1100\n"
653 "++de PC 1040 set PC to 1040\n"
654 "++ie 40-50 interactively examine 40:50\n"
655 "++ie >1000 40-50 interactively examine the subset\n"
656 "+++++++++ of locations 40:50 that are >1000\n"
657 "++ex rx0 50060 examine 50060, RX unit 0\n"
658 "++ex rx sbuf[3-6] examine SBUF[3] to SBUF[6] in RX\n"
659 "++de all 0 set main memory to 0\n"
660 "++de &77>0 0 set all addresses whose low order\n"
661 "+++++++++ bits are non-zero to 0\n"
662 "++ex -m @memdump.txt 0-7777 dump memory to file\n\n"
663 " * **NOTE**: To terminate an interactive command, simply type any bad value\n"
664 " (*e.g.* `XYZ`) when input is requested.\n"
665 #define HLP_EVALUATE "*Commands Evaluating_Instructions"
666
667 "2Evaluating Instructions\n"
668 " The `EVAL` command evaluates a symbolic expression and returns the\n"
669 " equivalent numeric value.\n\n"
670
671 "2Running A Simulated Program\n"
672 #define HLP_RUN "*Commands Running_A_Simulated_Program RUN"
673 "3RUN\n"
674 " The `RUN` command (*abbreviated* `RU`) resets all devices, deposits its\n"
675 " argument, if given, in the PC (program counter), and starts execution.\n"
676 " If no argument is given execution starts at the current PC.\n"
677 #define HLP_GO "*Commands Running_A_Simulated_Program GO"
678 "3GO\n"
679 " The `GO` command does *not* reset devices, deposits its argument (if\n"
680 " given) in the PC, and starts execution. If no argument is given,\n"
681 " execution starts at the current PC (program counter).\n"
682 #define HLP_CONTINUE "*Commands Running_A_Simulated_Program Continuing_Execution"
683 "3Continuing Execution\n"
684 " The `CONTINUE` command (*abbreviated* `CONT` or `CO`) resumes execution\n"
685 " (if execution was stopped, possibly due to hitting a breakpoint) at the\n"
686 " current program counter without resetting any devices.\n"
687 #define HLP_STEP "*Commands Running_A_Simulated_Program Step_Execution"
688 "3Step Execution\n"
689 " The `STEP` command (*abbreviated* `S`) resumes execution at the current\n"
690 " PC for the number of instructions given by its argument. If no argument\n"
691 " is supplied, one instruction is executed.\n"
692 "4Switches\n"
693 "5`-T`\n"
694 " If the `STEP` command is invoked with the \"`-T`\" switch, the step\n"
695 " command will cause execution to run for *microseconds* rather than\n"
696 " instructions.\n"
697 #define HLP_NEXT "*Commands Running_A_Simulated_Program NEXT"
698 "3NEXT\n"
699 " The `NEXT` command (*abbreviated* `N`) resumes execution at the current PC\n"
700 " for one instruction, attempting to execute *through* subroutine calls.\n"
701 " If the next instruction to be executed is *not* a subroutine call, then\n"
702 " one instruction is executed.\n"
703 #define HLP_BOOT "*Commands Running_A_Simulated_Program Booting_the_system"
704 "3Booting the system\n"
705 " The `BOOT` command (*abbreviated* `BO`) resets all devices and bootstraps\n"
706 " the device and unit given by its argument. If no unit is supplied,\n"
707 " unit `0` is bootstrapped. The specified unit must be `ATTACH`'ed.\n\n"
708 " When booting Multics, the boot device should always be `iom0`.\n"
709 " Assuming a tape is attached to the `tape0` device, it will be bootstrapped\n"
710 " into memory and the system will transfer control to the boot record.\n\n"
711 " **Example**\n\n"
712 "++; Boot Multics using iom0\n"
713 "++boot iom0\n\n"
714
715 "2Stopping The Simulator\n"
716 " The simulator runs until the simulated hardware encounters an error, or\n"
717 " until the user forces a stop condition.\n"
718 "3Simulator Detected Stop Conditions\n"
719 " These simulator-detected conditions stop simulation:\n\n"
720 "++- HALT instruction. If a HALT instruction is decoded, simulation stops.\n\n"
721 "++- I/O error. If an I/O error occurs during simulation of an I/O\n"
722 "+++operation, and the device stop-on-I/O-error flag is set, simulation\n"
723 "+++usually stops.\n\n"
724 "++- Processor condition. Certain processor conditions can stop\n"
725 "+++the simulation.\n"
726 "3User Specified Stop Conditions\n"
727 " Typing the interrupt character stops simulation. The interrupt character\n"
728 " is defined by the `WRU` (*Where aRe yoU*) console option, and is initially\n"
729 " set to `005` (`^E`).\n\n"
730
731 #define HLP_BREAK "*Commands Stopping_The_Simulator User_Specified_Stop_Conditions BREAK"
732 #define HLP_NOBREAK "*Commands Stopping_The_Simulator User_Specified_Stop_Conditions BREAK"
733 "4Breakpoints\n"
734 " The simulator offers breakpoint capability for debugging. Users may define\n"
735 " breakpoints of different types, identified by letter (for example, `E`\n"
736 " for *execution*, `R` for *read*, `W` for *write*, etc).\n\n"
737 " Associated with each breakpoint is a count and, optionally, one or more\n"
738 " actions. Each time a breakpoint occurs, the associated count\n"
739 " is *decremented*. If the count is less than or equal to `0`, the breakpoint\n"
740 " occurs; otherwise, it is deferred. When the breakpoint occurs, any\n"
741 " optional actions are automatically executed.\n\n"
742 " A breakpoint is set by the `BREAK` (or `SET BREAK`) command:\n\n"
743 "++BREAK {-types} {<addr range>{[count]},{addr range...}}{;action;action...}\n\n"
744 " If no type is specified, the default breakpoint type (`E`, *execution*) is\n"
745 " used. If no address range is specified, the current PC is used. As\n"
746 " with `EXAMINE` and `DEPOSIT`, an address range may be a single address, a\n"
747 " range of addresses low-high, or a relative range of address/length.\n"
748
749 "5Displaying Breakpoints\n"
750 " Currently set breakpoints can be displayed with the `SHOW BREAK` command:\n\n"
751 "++SHOW {-C} {-types} BREAK {ALL|<addr range>{,<addr range>...}}\n\n"
752 " Locations with breakpoints of the specified type are displayed.\n\n"
753 " The \"`-C`\" switch displays the selected breakpoint(s) formatted as\n"
754 " commands which may be subsequently used to establish the same\n"
755 " breakpoint(s).\n\n"
756 "5Removing Breakpoints\n"
757 " Breakpoints can be cleared by the `NOBREAK` or the `SET NOBREAK` commands.\n"
758 "5Examples\n"
759 " The following examples illustrate breakpoint usage:\n\n"
760 "++BREAK set E break at current PC\n"
761 "++BREAK -e 200 set E break at 200\n"
762 "++BREAK 2000/2[2] set E breaks at 2000,2001 with count = 2\n"
763 "++BREAK 100;EX AC;D MQ 0 set E break at 100 with actions EX AC and\n"
764 "+++++++++D MQ 0\n"
765 "++BREAK 100; delete action on break at 100\n\n"
766
767 "2Connecting and Disconnecting Devices\n"
768 " Units are simulated as files on the host file system. Before using any\n"
769 " simulated unit, the user must specify the file to be accessed by that unit.\n"
770 #define HLP_ATTACH "*Commands Connecting_and_Disconnecting_Devices Attaching_devices"
771 "3Attaching devices\n"
772 " The `ATTACH` (*abbreviation* `AT`) command associates a unit and a file:\n\n"
773 "++ATTACH <unit> <filename>\n\n"
774 " Some devices have more detailed or specific help available with:\n\n"
775 "++HELP <device> ATTACH\n\n"
776 "4Switches\n"
777 "5-n\n"
778 " If the \"`-n`\" switch is specified when `ATTACH` is executed, a new\n"
779 " file will be created when the filename specified does not exist, or an\n"
780 " existing file will have it's size truncated to zero, and an appropriate\n"
781 " message is printed.\n"
782 "5-e\n"
783 " If the file does not exist, and the \"`-e`\" switch *was not* specified,\n"
784 " a new file is created, and an appropriate message is printed. If\n"
785 " the \"`-e`\" switch *was* specified, a new file is *not* created, and an\n"
786 " error message is printed.\n"
787 "5-r\n"
788 " If the \"`-r`\" switch is specified, or the file is write protected by\n"
789 " host operating system, `ATTACH` tries to open the file in read only mode.\n"
790 " If the file does not exist, or the unit does not support read only\n"
791 " operation, an error occurs. Input-only devices, such as card readers, or\n"
792 " storage devices with write locking switches, such as disks or tapes,\n"
793 " support read only operation - other devices do not. If a file is\n"
794 " attached read only, its contents can be examined but not modified.\n"
795 "5-q\n"
796 " If the \"`-q`\" switch is specified when creating a new file (\"`-n`\")\n"
797 " or opening one read only (\"`-r`\"), the message announcing this fact\n"
798 " is suppressed.\n"
799 "5-f\n"
800 " For simulated magnetic tapes, the `ATTACH` command can specify the format\n"
801 " of the attached tape image file:\n\n"
802 "++ATTACH -f <tape_unit> <format> <filename>\n\n"
803 " * The currently supported magnetic tape image file formats are:\n\n"
804 " | | |\n"
805 " | ----------------:|:---------------------------------------------------- |\n"
806 " | \"**`SIMH`**\" | The **SIMH** / **DPS8M** native portable tape format |\n"
807 " | \"**`E11`**\" | The *D Bit* **Ersatz-11** simulator format |\n"
808 " | \"**`TPC`**\" | The **TPC** format (*used by _SIMH_ prior to V2.3*) |\n"
809 " | \"**`P7B`**\" | The **Paul Pierce** `7`-track tape archive format |\n\n"
810
811 " * The default tape format can also be specified with the `SET` command\n"
812 " prior to using the `ATTACH` command:\n\n"
813 "++SET <tape_unit> FORMAT=<format>\n"
814 "++ATTACH <tape_unit> <filename>\n\n"
815 " * The format of a currently attached tape image can be displayed with\n"
816 " the `SHOW FORMAT` command:\n\n"
817 "++SHOW <unit> FORMAT\n\n"
818 " **Examples**\n\n"
819 " The following example illustrates common `ATTACH` usage:\n"
820 "++; Associate the tape image file \"12.7MULTICS.tap\" with the tape0 unit\n"
821 "++; in read-only mode, where tape0 corresponds to the first tape device.\n"
822 "++ATTACH -r tape0 12.7MULTICS.tap\n\n"
823 "++; Associate the disk image file \"root.dsk\" with the disk0 unit.\n"
824 "++; The disk0 unit corresponds to the first disk device.\n"
825 "++ATTACH disk0 root.dsk\n\n"
826
827 #define HLP_DETACH "*Commands Connecting_and_Disconnecting_Devices Detaching_devices"
828 "3Detaching devices\n"
829 " The `DETACH` (*abbreviation* `DET`) command breaks the association between\n"
830 " a unit and its backing file or device:\n\n"
831 "++DETACH ALL Detach all units\n"
832 "++DETACH <unit> Detach specified unit\n\n"
833 " * **NOTE:** The `EXIT` command performs an automatic `DETACH ALL`.\n"
834 #define HLP_SET "*Commands SET"
835 "2SET\n"
836
837 #define HLP_SET_LOG "*Commands SET Logging"
838 "3Logging\n"
839 " Interactions with the simulator session can be recorded to a log file.\n\n"
840 "+SET LOG log_file Specify the log destination\n"
841 "++++++++ (STDOUT, DEBUG, or filename)\n"
842 "+SET NOLOG Disables any currently active logging\n"
843 "4Switches\n"
844 "5`-N`\n"
845 " By default, log output is written at the *end* of the specified log file.\n"
846 " A new log file can created if the \"`-N`\" switch is used on the command\n"
847 " line.\n\n"
848 "5`-B`\n"
849 " By default, log output is written in *text* mode. The log file can be\n"
850 " opened for *binary* mode writing if the \"`-B`\" switch is used on the\n"
851 " command line.\n"
852 #define HLP_SET_DEBUG "*Commands SET Debug_Messages"
853
854 "3Debug Messages\n"
855 "+SET DEBUG debug_file Specify the debug destination\n"
856 "++++++++ (STDOUT, STDERR, LOG, or filename)\n"
857 "+SET NODEBUG Disables any currently active debug output\n"
858 "4Switches\n"
859 " Debug message output contains a timestamp which indicates the number of\n"
860 " simulated instructions which have been executed prior to the debug event.\n\n"
861 " Debug message output can be enhanced to contain additional, potentially\n"
862 " useful information.\n\n\n"
863 " **NOTE**: If neither \"`-T`\" or \"`-A`\" is specified, \"`-T`\" is implied.\n"
864 "5-T\n"
865 " The \"`-T`\" switch causes debug output to contain a time of day displayed\n"
866 " as `hh:mm:ss.msec`.\n"
867 "5-A\n"
868 " The \"`-A`\" switch causes debug output to contain a time of day displayed\n"
869 " as `seconds.msec`.\n"
870 "5-R\n"
871 " The \"`-R`\" switch causes timing to be relative to the start of debugging.\n"
872 "5-P\n"
873 " The \"`-P`\" switch adds the output of the PC (program counter) to each\n"
874 " debug message.\n"
875 "5-N\n"
876 " The \"`-N`\" switch causes a new (empty) file to be written to.\n"
877 " (The default is to append to an existing debug log file).\n"
878 "5-D\n"
879 " The \"`-D`\" switch causes data blob output to also display the data\n"
880 " as **`RADIX-50`** characters.\n"
881 "5-E\n"
882 " The \"`-E`\" switch causes data blob output to also display the data\n"
883 " as \"**EBCDIC**\" characters.\n"
884
885 #define HLP_SET_ENVIRON "*Commands SET Environment_Variables"
886 "3Environment Variables\n"
887 "+SET ENVIRONMENT NAME=val Set environment variable\n"
888 "+SET ENVIRONMENT NAME Clear environment variable\n"
889 #define HLP_SET_ON "*Commands SET Command_Status_Trap_Dispatching"
890 "3Command Status Trap Dispatching\n"
891 "+SET ON Enables error checking command execution\n"
892 "+SET NOON Disables error checking command execution\n"
893 "+SET ON INHERIT Enables inheritance of ON state and actions\n"
894 "+SET ON NOINHERIT Disables inheritance of ON state and actions\n"
895 #define HLP_SET_VERIFY "*Commands SET Command_Execution_Display"
896 "3Command Execution Display\n"
897 "+SET VERIFY Enables display of processed script commands\n"
898 "+SET VERBOSE Enables display of processed script commands\n"
899 "+SET NOVERIFY Disables display of processed script commands\n"
900 "+SET NOVERBOSE Disables display of processed script commands\n"
901 #define HLP_SET_MESSAGE "*Commands SET Command_Error_Status_Display"
902 "3Command Error Status Display\n"
903 "+SET MESSAGE Re-enables display of script error messages\n"
904 "+SET NOMESSAGE Disables display of script error messages\n"
905 #define HLP_SET_QUIET "*Commands SET Command_Output_Display"
906 "3Command Output Display\n"
907 "+SET QUIET Disables suppression of some messages\n"
908 "+SET NOQUIET Re-enables suppression of some messages\n"
909 #define HLP_SET_LOCALOPC "*Commands SET Local_Operator_Console"
910 "3Local Operator Console\n"
911 "+SET LOCALOPC Enables local operator console\n"
912 "+SET NOLOCALOPC Disables local operator console\n"
913 #define HLP_SET_PROMPT "*Commands SET Command_Prompt"
914 "3Command Prompt\n"
915 "+SET PROMPT \"string\" Sets an alternate simulator prompt string\n"
916 "3Device and Unit Settings\n"
917 "+SET <dev> OCT|DEC|HEX Set device display radix\n"
918 "+SET <dev> ENABLED Enable device\n"
919 "+SET <dev> DISABLED Disable device\n"
920 "+SET <dev> DEBUG{=arg} Set device debug flags\n"
921 "+SET <dev> NODEBUG={arg} Clear device debug flags\n"
922 "+SET <dev> arg{,arg...} Set device parameters\n"
923 "+SET <unit> ENABLED Enable unit\n"
924 "+SET <unit> DISABLED Disable unit\n"
925 "+SET <unit> arg{,arg...} Set unit parameters\n"
926 "+HELP <dev> SET Displays any device specific SET commands\n"
927 " \n\n"
928 " See the Omnibus documentation for a complete SET command reference.\n"
929
930 #define HLP_SHOW "*Commands SHOW"
931 "2SHOW\n"
932 "+SH{OW} B{UILDINFO} Show build-time compilation information\n"
933 "+SH{OW} CL{OCKS} Show wall clock and timer information\n"
934 "+SH{OW} C{ONFIGURATION} Show simulator configuration\n"
935 "+SH{OW} D{EFAULT_BASE_SYSTEM} Show default base system script\n"
936 "+SH{OW} DEV{ICES} Show devices\n"
937 "+SH{OW} M{ODIFIERS} Show SET commands for all devices\n"
938 "+SH{OW} O{N} Show ON condition actions\n"
939 "+SH{OW} P{ROM} Show CPU ID PROM initialization data\n"
940 "+SH{OW} Q{UEUE} Show event queue\n"
941 "+SH{OW} S{HOW} Show SHOW commands for all devices\n"
942 "+SH{OW} T{IME} Show simulated timer\n"
943 "+SH{OW} VE{RSION} Show simulator version\n"
944 "+H{ELP} <dev> SHOW Show device-specific SHOW commands\n"
945 "+SH{OW} <dev> {arg,...} Show device parameters\n"
946 "+SH{OW} <dev> DEBUG Show device debug flags\n"
947 "+SH{OW} <dev> MODIFIERS Show device modifiers\n"
948 "+SH{OW} <dev> RADIX Show device display radix\n"
949 "+SH{OW} <dev> SHOW Show device SHOW commands\n"
950 "+SH{OW} <unit> {arg,...} Show unit parameters\n\n"
951 " See the Omnibus documentation for a complete SHOW command reference.\n\n"
952 #define HLP_SHOW_CONFIG "*Commands SHOW"
953 #define HLP_SHOW_DEVICES "*Commands SHOW"
954 #define HLP_SHOW_FEATURES "*Commands SHOW"
955 #define HLP_SHOW_QUEUE "*Commands SHOW"
956 #define HLP_SHOW_TIME "*Commands SHOW"
957 #define HLP_SHOW_MODIFIERS "*Commands SHOW"
958 #define HLP_SHOW_NAMES "*Commands SHOW"
959 #define HLP_SHOW_SHOW "*Commands SHOW"
960 #define HLP_SHOW_VERSION "*Commands SHOW"
961 #define HLP_SHOW_BUILDINFO "*Commands SHOW"
962 #define HLP_SHOW_PROM "*Commands SHOW"
963 #define HLP_SHOW_DBS "*Commands SHOW"
964 #define HLP_SHOW_DEFAULT "*Commands SHOW"
965 #define HLP_SHOW_CONSOLE "*Commands SHOW"
966 #define HLP_SHOW_REMOTE "*Commands SHOW"
967 #define HLP_SHOW_BREAK "*Commands SHOW"
968 #define HLP_SHOW_LOG "*Commands SHOW"
969 #define HLP_SHOW_DEBUG "*Commands SHOW"
970 #define HLP_SHOW_CLOCKS "*Commands SHOW"
971 #define HLP_SHOW_ON "*Commands SHOW"
972 #define HLP_SHOW_SEND "*Commands SHOW"
973 #define HLP_SHOW_EXPECT "*Commands SHOW"
974 #define HLP_HELP "*Commands HELP"
975
976 "2HELP\n"
977 "+H{ELP} Show this message\n"
978 "+H{ELP} <command> Show help for command\n"
979 "+H{ELP} <dev> Show help for device\n"
980 "+H{ELP} <dev> REGISTERS Show help for device register variables\n"
981 "+H{ELP} <dev> ATTACH Show help for device specific ATTACH command\n"
982 "+H{ELP} <dev> SET Show help for device specific SET commands\n"
983 "+H{ELP} <dev> SHOW Show help for device specific SHOW commands\n"
984 "+H{ELP} <dev> <command> Show help for device specific <command> command\n"
985
986 "2Altering The Simulated Configuration\n"
987 " The \"SET <device> DISABLED\" command removes a device from the configuration.\n"
988 " A `DISABLED` device is invisible to running programs. The device can still\n"
989 " be `RESET`, but it cannot be `ATTACH`ed, `DETACH`ed, or `BOOT`ed.\n\n"
990 " The \"SET <device> ENABLED\" command restores a disabled device to a\n"
991 " configuration.\n\n"
992 " Most multi-unit devices allow units to be enabled or disabled:\n\n"
993 "++SET <unit> ENABLED\n"
994 "++SET <unit> DISABLED\n\n"
995 " When a unit is disabled, it will not be displayed by SHOW DEVICE.\n\n"
996
997 #define HLP_DO "*Commands Executing_Command_Files Processing_Command_Files"
998 "2Executing Command Files\n"
999 "3Processing Command Files\n"
1000 " The simulator can invoke another script file with the \"`DO`\" command:\n\n"
1001 "++DO <filename> {arguments...} execute commands in specified file\n\n"
1002 " The \"`DO`\" command allows command files to contain substitutable\n"
1003 " arguments. The string \"`%%n`\", where \"`n`\" is a number\n"
1004 " between \"`1`\" and \"`9`\", is replaced with argument \"`n`\" from\n"
1005 " the \"`DO`\" command line. (*i.e.* \"`%%0`\", \"`%%1`\", \"`%%2`\", etc.).\n"
1006 " The string \"`%%0`\" is replaced with \"<`filename`>\".\n The\n"
1007 " sequences \"`\\%%`\" and \"`\\\\`\" are replaced with the literal\n"
1008 " characters \"`%%`\" and \"`\\`\", respectively. Arguments with spaces must\n"
1009 " be enclosed in matching single or double quotation marks.\n\n"
1010 " * **NOTE**: Nested \"`DO`\" commands are supported, up to ten invocations\n"
1011 " deep.\n\n"
1012 "4Switches\n"
1013 "5`-v`\n\n"
1014 " If the switch \"`-v`\" is specified, commands in the command file are\n"
1015 " echoed *before* they are executed.\n\n"
1016 "5`-e`\n\n"
1017 " If the switch \"`-e`\" is specified, command processing (including nested\n"
1018 " command invocations) will be aborted if any command error is encountered.\n"
1019 " (A simulation stop **never** aborts processing; use `ASSERT` to catch\n"
1020 " unexpected stops.) Without this switch, all errors except `ASSERT` failures\n"
1021 " will be ignored, and command processing will continue.\n\n"
1022 "5`-o`\n\n"
1023 " If the switch \"`-o`\" is specified, the `ON` conditions and actions from\n"
1024 " the calling command file will be inherited by the command file being\n"
1025 " invoked.\n"
1026 "5`-q`\n\n"
1027 " If the switch \"`-q`\" is specified, *quiet mode* will be explicitly\n"
1028 " enabled for the called command file, otherwise the *quiet mode* setting\n"
1029 " is inherited from the calling context.\n"
1030
1031 #define HLP_GOTO "*Commands Executing_Command_Files GOTO"
1032 "3GOTO\n"
1033 " Commands in a command file execute in sequence until either an error\n"
1034 " trap occurs (when a command completes with an error status), or when an\n"
1035 " explicit request is made to start command execution elsewhere with\n"
1036 " the `GOTO` command:\n\n"
1037 "++GOTO <label>\n\n"
1038 " * Labels are lines in a command file which the first non-whitespace\n"
1039 " character is a \"`:`\".\n"
1040 " * The target of a `GOTO` is the first matching label in the current `DO`\n"
1041 " command file which is encountered.\n\n"
1042 " **Example**\n\n"
1043 " The following example illustrates usage of the `GOTO` command (by\n"
1044 " creating an infinite loop):\n\n"
1045 "++:Label\n"
1046 "++:: This is a loop.\n"
1047 "++GOTO Label\n\n"
1048 #define HLP_RETURN "*Commands Executing_Command_Files RETURN"
1049
1050 "3RETURN\n"
1051 " The `RETURN` command causes the current procedure call to be restored to\n"
1052 " the calling context, possibly returning a specific return status.\n"
1053 " If no return status is specified, the return status from the last command\n"
1054 " executed will be returned. The calling context may have `ON` traps defined\n"
1055 " which may redirect command flow in that context.\n\n"
1056 "++RETURN return from command file with last command status\n"
1057 "++RETURN {-Q} <status> return from command file with specific status\n\n"
1058 " * The status return can be any numeric value or one of the standard SCPE_\n"
1059 " condition names.\n\n"
1060 " * The \"`-Q`\" switch on the `RETURN` command will cause the specified\n"
1061 " status to be returned, but normal error status message printing to be\n"
1062 " suppressed.\n\n"
1063 " **Condition Names**\n\n"
1064 " The available standard SCPE_ condition names and their meanings are:\n\n"
1065 " | Name | Meaning | Name | Meaning |\n"
1066 " | ------- | --------------------------------| ------- | ----------------------------------- |\n"
1067 " | NXM | Address space exceeded | UNATT | Unit not attached |\n"
1068 " | IOERR | I/O error | CSUM | Checksum error |\n"
1069 " | FMT | Format error | NOATT | Unit not attachable |\n"
1070 " | OPENERR | File open error | MEM | Memory exhausted |\n"
1071 " | ARG | Invalid argument | STEP | Step expired |\n"
1072 " | UNK | Unknown command | RO | Read only argument |\n"
1073 " | INCOMP | Command not completed | STOP | Simulation stopped |\n"
1074 " | EXIT | Goodbye | TTIERR | Console input I/O error |\n"
1075 " | TTOERR | Console output I/O error | EOF | End of file |\n"
1076 " | REL | Relocation error | NOPARAM | No settable parameters |\n"
1077 " | ALATT | Unit already attached | TIMER | Hardware timer error |\n"
1078 " | SIGERR | Signal handler setup error | TTYERR | Console terminal setup error |\n"
1079 " | NOFNC | Command not allowed | UDIS | Unit disabled |\n"
1080 " | NORO | Read only operation not allowed | INVSW | Invalid switch |\n"
1081 " | MISVAL | Missing value | 2FARG | Too few arguments |\n"
1082 " | 2MARG | Too many arguments | NXDEV | Non-existent device |\n"
1083 " | NXUN | Non-existent unit | NXREG | Non-existent register |\n"
1084 " | NXPAR | Non-existent parameter | NEST | Nested DO command limit exceeded |\n"
1085 " | IERR | Internal error | MTRLNT | Invalid magtape record length |\n"
1086 " | LOST | Console Telnet connection lost | TTMO | Console Telnet connection timed out |\n"
1087 " | STALL | Console Telnet output stall | AFAIL | Assertion failed |\n"
1088 " | INVREM | Invalid remote console command | | |\n"
1089 "\n\n"
1090 #define HLP_SHIFT "*Commands Executing_Command_Files Shift_Parameters"
1091 "3Shift Parameters\n"
1092 " Shift the command files positional parameters\n"
1093 #define HLP_CALL "*Commands Executing_Command_Files Call_a_subroutine"
1094 "3Call a subroutine\n"
1095 " Control can be transferred to a labeled subroutine using `CALL`.\n\n"
1096 " **Example**\n\n"
1097 "++CALL routine\n"
1098 "++BYE\n"
1099 "++\n"
1100 "++:routine\n"
1101 "++ECHO routine called\n"
1102 "++RETURN\n\n"
1103 #define HLP_ON "*Commands Executing_Command_Files ON"
1104 "3ON\n"
1105 " The `ON` command performs actions after a condition, or clears a condition.\n"
1106 "++ON <condition> <action> Perform action after condition\n"
1107 "++ON <condition> Clears action of specified condition\n"
1108 #define HLP_PROCEED "*Commands Executing_Command_Files PROCEED_or_IGNORE"
1109 #define HLP_IGNORE "*Commands Executing_Command_Files PROCEED_or_IGNORE"
1110
1111 "3PROCEED or IGNORE\n"
1112 " The `PROCEED` (or `IGNORE`) command does nothing. It is potentially\n"
1113 " useful as a placeholder for any `ON` action condition that should be\n"
1114 " explicitly ignored, allowing command file execution to continue without\n"
1115 " taking any specific action.\n"
1116 #define HLP_ECHO "*Commands Executing_Command_Files Displaying_Arbitrary_Text"
1117
1118 "3Displaying Arbitrary Text\n"
1119 " The `ECHO` command is a useful way of annotating command files. `ECHO`\n"
1120 " prints out its arguments to the console (and to any applicable log file):\n\n"
1121 "++ECHO <string> Output string to console\n\n"
1122 " **NOTE**: If no arguments are specified, `ECHO` prints a blank line.\n"
1123 " This may be used to provide spacing for console messages or log file\n"
1124 " output.\n"
1125
1126 #define HLP_ASSERT "*Commands Executing_Command_Files Testing_Assertions"
1127 "3Testing Assertions\n"
1128 " The `ASSERT` command tests a simulator state condition and halts command\n"
1129 " file execution if the condition is false:\n\n"
1130 "++ASSERT <Simulator State Expressions>\n\n"
1131 " * If the indicated expression evaluates to false, the command completes\n"
1132 " with an `AFAIL` condition. By default, when a command file encounters a\n"
1133 " command which returns the `AFAIL` condition, it will exit the running\n"
1134 " command file with the `AFAIL` status to the calling command file. This\n"
1135 " behavior can be changed with the `ON` command as well as switches to the\n"
1136 " invoking `DO` command.\n\n"
1137 " **Examples**\n\n"
1138 " The command file below might be used to bootstrap a hypothetical system\n"
1139 " that halts after the initial load from disk. The `ASSERT` command can then\n"
1140 " be used to confirm that the load completed successfully by examining the\n"
1141 " CPU's \"`A`\" register for the expected value:\n\n"
1142 "++; Example INI file\n"
1143 "++BOOT\n"
1144 "++; A register contains error code; 0 = good boot\n"
1145 "++ASSERT A=0\n"
1146 "++RUN\n\n"
1147
1148 " * In the above example, if the \"`A`\" register is *not* `0`,\n"
1149 " the \"`ASSERT A=0`\" command will be displayed to the user, and the\n"
1150 " command file will be aborted with an \"`Assertion failed`\" message.\n"
1151 " Otherwise, the command file will continue to bring up the system.\n\n"
1152 " * See the **`IF`** command documentation for more information and details\n"
1153 " regarding simulator state expressions.\n\n"
1154 #define HLP_IF "*Commands Executing_Command_Files Testing_Conditions"
1155 "3Testing Conditions\n"
1156 " The `IF` command tests a simulator state condition and executes additional\n"
1157 " commands if the condition is true:\n\n"
1158 "++IF <Simulator State Expressions> commandtoprocess{; additionalcommand}...\n\n"
1159 " **Examples**\n\n"
1160 " The command file below might be used to bootstrap a hypothetical system\n"
1161 " that halts after the initial load from disk. The `IF` command can then\n"
1162 " be used to confirm that the load completed successfully by examining the\n"
1163 " CPU's \"`A`\" register for an expected value:\n\n"
1164 "++; Example INI file\n"
1165 "++BOOT\n"
1166 "++; A register contains error code; 0 = good boot\n"
1167 "++IF NOT A=0 echo Boot failed - Failure Code ; EX A; exit AFAIL\n"
1168 "++RUN\n\n"
1169
1170 " * In the above example, if the \"`A`\" register is *not* `0`, the\n"
1171 " message \"`Boot failed - Failure Code `\" will be displayed, the contents\n"
1172 " of the \"`A`\" register will be displayed, and the command file will be\n"
1173 " aborted with an \"`Assertion failed`\" message. Otherwise, the command\n"
1174 " file will continue to bring up the system.\n"
1175 "4Conditional Expressions\n"
1176 " The `IF` and `ASSERT` commands evaluate the following two different forms\n"
1177 " of conditional expressions.\n\n"
1178 "5Simulator State Expressions\n"
1179 " \n \n"
1180 " The values of simulator registers can be evaluated with:\n\n"
1181 "++{NOT} {<dev>} <reg>|<addr>{<logical-op><value>}<conditional-op><value>\n\n"
1182 " * If \"<`dev`>\" is not specified, `CPU` is assumed. \"<`reg`>\" is a\n"
1183 " register belonging to the indicated device.\n"
1184 " * The \"<`addr`>\" is an address in the address space of the indicated\n"
1185 " device.\n"
1186 " * The \"<`conditional-op`>\" and optional \"<`logical-op`>\" are\n"
1187 " the same as those used for \"search specifiers\" by the `EXAMINE` and\n"
1188 " `DEPOSIT` commands.\n"
1189 " The \"<`value`>\" is expressed in the radix specified for \"<`reg`>\",\n"
1190 " not in the radix for the device when referencing a register; when an\n"
1191 " address is referenced the device radix is used as the default.\n\n"
1192 " * If \"<`logical-op`>\" and \"<`value`>\" are specified, the target\n"
1193 " register value is first altered as indicated. The result is then compared\n"
1194 " to the \"<`value`>\" via the \"<`conditional-op`>\".\n"
1195 " * * If the result is *true*, the command(s) are executed before proceeding\n"
1196 " to the next line in the command file.\n"
1197 " * * If the result is *false*, the next command in the command file is\n"
1198 " processed.\n\n"
1199 "5String Comparison Expressions\n"
1200 " \n \n"
1201 " String Values can be compared with:\n\n"
1202 "++{-i} {NOT} \"<string1>\" <compare-op> \"<string2>\"\n\n"
1203 " * The \"`-i`\" switch, if present, causes a comparison to be case\n"
1204 " insensitive.\n"
1205 " * The \"<`string1`>\" and \"<`string2`>\" arguments are quoted string\n"
1206 " values which may have environment variables substituted as desired.\n"
1207 " * The \"<`compare-op`>\" may be one of:\n\n"
1208 " | | |\n"
1209 " | --------------:|:---------------------- |\n"
1210 " | \"**`==`**\" | equal |\n"
1211 " | \"**`EQU`**\" | equal |\n"
1212 " | \"**`!=`**\" | not equal |\n"
1213 " | \"**`NEQ`**\" | not equal |\n"
1214 " | \"**<**\" | less than |\n"
1215 " | \"**`LSS`**\" | less than |\n"
1216 " | \"**<=**\" | less than or equal |\n"
1217 " | \"**`LEQ`**\" | less than or equal |\n"
1218 " | \"**>**\" | greater than |\n"
1219 " | \"**`GTR`**\" | greater than |\n"
1220 " | \"**>=**\" | greater than or equal |\n"
1221 " | \"**`GEQ`**\" | greater than or equal |\n"
1222 " * **NOTE**: Comparisons are *generic*. This means that if\n"
1223 " both \"<`string1`>\" and \"<`string2`>\" are comprised of all numeric\n"
1224 " digits, then the strings are converted to numbers and a numeric\n"
1225 " comparison is performed. For example, the comparison\n"
1226 " '`\"+1\"` `EQU` `\"1\"`' evaluates to *true*.\n"
1227
1228 #define HLP_EXIT "*Commands Exiting_the_Simulator"
1229 "2Exiting the Simulator\n"
1230 " The `EXIT` command (*synonyms* `QUIT` *and* `BYE`) exits the simulator,\n"
1231 " returning control to the host operating system.\n"
1232
1233 #define HLP_SPAWN "*Commands Executing_System_Commands"
1234 "2Executing System Commands\n"
1235 " * The simulator can execute host operating system commands with\n"
1236 " the \"`!`\" (*spawn*) command.\n\n"
1237 " | | |\n"
1238 " |:----------------------- |:------------------------------------------- |\n"
1239 " | \"**`!`**\" | Spawn the hosts default command interpreter |\n"
1240 " | \"**`!`** <`command`>\" | Execute the host operating system `command` |\n\n"
1241 " * **NOTE**: The *exit status* from the command which was executed is set\n"
1242 " as the *command completion status* for the \"`!`\" command. This may\n"
1243 " influence any enabled `ON` condition traps.\n" ;
1244
1245
1246 static CTAB cmd_table[] = {
1247 { "RESET", &reset_cmd, 0, HLP_RESET },
1248 { "EXAMINE", &exdep_cmd, EX_E, HLP_EXAMINE },
1249 { "IEXAMINE", &exdep_cmd, EX_E+EX_I, HLP_IEXAMINE },
1250 { "DEPOSIT", &exdep_cmd, EX_D, HLP_DEPOSIT },
1251 { "IDEPOSIT", &exdep_cmd, EX_D+EX_I, HLP_IDEPOSIT },
1252 { "EVALUATE", &eval_cmd, 0, HLP_EVALUATE },
1253 { "RUN", &run_cmd, RU_RUN, HLP_RUN, NULL, &run_cmd_message },
1254 { "GO", &run_cmd, RU_GO, HLP_GO, NULL, &run_cmd_message },
1255 { "STEP", &run_cmd, RU_STEP, HLP_STEP, NULL, &run_cmd_message },
1256 { "NEXT", &run_cmd, RU_NEXT, HLP_NEXT, NULL, &run_cmd_message },
1257 { "CONTINUE", &run_cmd, RU_CONT, HLP_CONTINUE, NULL, &run_cmd_message },
1258 { "BOOT", &run_cmd, RU_BOOT, HLP_BOOT, NULL, &run_cmd_message },
1259 { "BREAK", &brk_cmd, SSH_ST, HLP_BREAK },
1260 { "NOBREAK", &brk_cmd, SSH_CL, HLP_NOBREAK },
1261 { "ATTACH", &attach_cmd, 0, HLP_ATTACH },
1262 { "DETACH", &detach_cmd, 0, HLP_DETACH },
1263 { "EXIT", &exit_cmd, 0, HLP_EXIT },
1264 { "QUIT", &exit_cmd, 0, NULL },
1265 { "BYE", &exit_cmd, 0, NULL },
1266 { "SET", &set_cmd, 0, HLP_SET },
1267 { "SHOW", &show_cmd, 0, HLP_SHOW },
1268 { "DO", &do_cmd, 1, HLP_DO },
1269 { "GOTO", &goto_cmd, 1, HLP_GOTO },
1270 { "RETURN", &return_cmd, 0, HLP_RETURN },
1271 { "SHIFT", &shift_cmd, 0, HLP_SHIFT },
1272 { "CALL", &call_cmd, 0, HLP_CALL },
1273 { "ON", &on_cmd, 0, HLP_ON },
1274 { "IF", &assert_cmd, 0, HLP_IF },
1275 { "PROCEED", &noop_cmd, 0, HLP_PROCEED },
1276 { "IGNORE", &noop_cmd, 0, HLP_IGNORE },
1277 { "ECHO", &echo_cmd, 0, HLP_ECHO },
1278 { "ASSERT", &assert_cmd, 1, HLP_ASSERT },
1279 { "SEND", &send_cmd, 0 },
1280 { "EXPECT", &expect_cmd, 1 },
1281 { "NOEXPECT", &expect_cmd, 0 },
1282 { "!", &spawn_cmd, 0, HLP_SPAWN },
1283 { "HELP", &help_cmd, 0, HLP_HELP },
1284 { NULL, NULL, 0 }
1285 };
1286
1287 static CTAB set_glob_tab[] = {
1288 { "CONSOLE", &sim_set_console, 0 },
1289 { "REMOTE", &sim_set_remote_console, 0 },
1290 { "BREAK", &brk_cmd, SSH_ST },
1291 { "NOBREAK", &brk_cmd, SSH_CL },
1292 { "TELNET", &sim_set_telnet, 0 },
1293 { "NOTELNET", &sim_set_notelnet, 0 },
1294 { "LOG", &sim_set_logon, 0, HLP_SET_LOG },
1295 { "NOLOG", &sim_set_logoff, 0, HLP_SET_LOG },
1296 { "DEBUG", &sim_set_debon, 0, HLP_SET_DEBUG },
1297 { "NODEBUG", &sim_set_deboff, 0, HLP_SET_DEBUG },
1298 { "ENVIRONMENT", &sim_set_environment, 1, HLP_SET_ENVIRON },
1299 { "ON", &set_on, 1, HLP_SET_ON },
1300 { "NOON", &set_on, 0, HLP_SET_ON },
1301 { "VERIFY", &set_verify, 1, HLP_SET_VERIFY },
1302 { "VERBOSE", &set_verify, 1, HLP_SET_VERIFY },
1303 { "NOVERIFY", &set_verify, 0, HLP_SET_VERIFY },
1304 { "NOVERBOSE", &set_verify, 0, HLP_SET_VERIFY },
1305 { "MESSAGE", &set_message, 1, HLP_SET_MESSAGE },
1306 { "NOMESSAGE", &set_message, 0, HLP_SET_MESSAGE },
1307 { "QUIET", &set_quiet, 1, HLP_SET_QUIET },
1308 { "NOQUIET", &set_quiet, 0, HLP_SET_QUIET },
1309 { "LOCALOPC", &set_localopc, 1, HLP_SET_LOCALOPC },
1310 { "NOLOCALOPC", &set_localopc, 0, HLP_SET_LOCALOPC },
1311 { "PROMPT", &set_prompt, 0, HLP_SET_PROMPT },
1312 { NULL, NULL, 0 }
1313 };
1314
1315 static C1TAB set_dev_tab[] = {
1316 { "OCTAL", &set_dev_radix, 8 },
1317 { "DECIMAL", &set_dev_radix, 10 },
1318 { "HEX", &set_dev_radix, 16 },
1319 { "ENABLED", &set_dev_enbdis, 1 },
1320 { "DISABLED", &set_dev_enbdis, 0 },
1321 { "DEBUG", &set_dev_debug, 1 },
1322 { "NODEBUG", &set_dev_debug, 0 },
1323 { NULL, NULL, 0 }
1324 };
1325
1326 static C1TAB set_unit_tab[] = {
1327 { "ENABLED", &set_unit_enbdis, 1 },
1328 { "DISABLED", &set_unit_enbdis, 0 },
1329 { NULL, NULL, 0 }
1330 };
1331
1332 static SHTAB show_glob_tab[] = {
1333 { "CONFIGURATION", &show_config, 0, HLP_SHOW_CONFIG },
1334 { "DEFAULT_BASE_SYSTEM_SCRIPT",
1335 &show_default_base_system_script, 0, HLP_SHOW_DBS },
1336 { "DEVICES", &show_config, 1, HLP_SHOW_DEVICES },
1337 { "FEATURES", &show_config, 2, HLP_SHOW_FEATURES },
1338 { "QUEUE", &show_queue, 0, HLP_SHOW_QUEUE },
1339 { "TIME", &show_time, 0, HLP_SHOW_TIME },
1340 { "MODIFIERS", &show_mod_names, 0, HLP_SHOW_MODIFIERS },
1341 { "NAMES", &show_log_names, 0, HLP_SHOW_NAMES },
1342 { "SHOW", &show_show_commands, 0, HLP_SHOW_SHOW },
1343 { "VERSION", &show_version, 1, HLP_SHOW_VERSION },
1344 { "BUILDINFO", &show_buildinfo, 1, HLP_SHOW_BUILDINFO },
1345 { "PROM", &show_prom, 0, HLP_SHOW_PROM },
1346 { "CONSOLE", &sim_show_console, 0, HLP_SHOW_CONSOLE },
1347 { "REMOTE", &sim_show_remote_console, 0, HLP_SHOW_REMOTE },
1348 { "BREAK", &show_break, 0, HLP_SHOW_BREAK },
1349 { "LOG", &sim_show_log, 0, HLP_SHOW_LOG },
1350 { "TELNET", &sim_show_telnet, 0 },
1351 { "DEBUG", &sim_show_debug, 0, HLP_SHOW_DEBUG },
1352 { "CLOCKS", &sim_show_timers, 0, HLP_SHOW_CLOCKS },
1353 { "SEND", &sim_show_send, 0, HLP_SHOW_SEND },
1354 { "EXPECT", &sim_show_expect, 0, HLP_SHOW_EXPECT },
1355 { "ON", &show_on, 0, HLP_SHOW_ON },
1356 { NULL, NULL, 0 }
1357 };
1358
1359 static SHTAB show_dev_tab[] = {
1360 { "RADIX", &show_dev_radix, 0 },
1361 { "DEBUG", &show_dev_debug, 0 },
1362 { "MODIFIERS", &show_dev_modifiers, 0 },
1363 { "NAMES", &show_dev_logicals, 0 },
1364 { "SHOW", &show_dev_show_commands, 0 },
1365 { NULL, NULL, 0 }
1366 };
1367
1368 static SHTAB show_unit_tab[] = {
1369 { NULL, NULL, 0 }
1370 };
1371
1372 #if defined(_WIN32)
1373 static
1374 int setenv(const char *envname, const char *envval, int overwrite)
1375 {
1376 char *envstr = (char *)malloc(strlen(envname)+strlen(envval)+2);
1377 int r;
1378
1379 (void)sprintf(envstr, "%s=%s", envname, envval);
1380 r = _putenv(envstr);
1381 FREE(envstr);
1382 return r;
1383 }
1384
1385 static
1386 int unsetenv(const char *envname)
1387 {
1388 setenv(envname, "", 1);
1389 return 0;
1390 }
1391 #endif
1392
1393 #define XSTR_EMAXLEN 32767
1394
1395 const char
1396 *xstrerror_l(int errnum)
1397 {
1398 int saved = errno;
1399 const char *ret = NULL;
1400 static __thread char buf[XSTR_EMAXLEN];
1401
1402 #if defined(__APPLE__) || defined(_AIX) || defined(__MINGW32__) || \
1403 defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
1404 # if defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
1405 if (strerror_s(buf, sizeof(buf), errnum) == 0) ret = buf;
1406 # else
1407 if (strerror_r(errnum, buf, sizeof(buf)) == 0) ret = buf;
1408 # endif
1409 #else
1410 # if defined(__NetBSD__)
1411 locale_t loc = LC_GLOBAL_LOCALE;
1412 # else
1413 locale_t loc = uselocale((locale_t)0);
1414 # endif
1415 locale_t copy = loc;
1416 if (copy == LC_GLOBAL_LOCALE)
1417 copy = duplocale(copy);
1418
1419 if (copy != (locale_t)0)
1420 {
1421 ret = strerror_l(errnum, copy);
1422 if (loc == LC_GLOBAL_LOCALE)
1423 {
1424 freelocale(copy);
1425 }
1426 }
1427 #endif
1428
1429 if (!ret)
1430 {
1431 (void)snprintf(buf, sizeof(buf), "Unknown error %d", errnum);
1432 ret = buf;
1433 }
1434
1435 errno = saved;
1436 return ret;
1437 }
1438
1439 t_stat process_stdin_commands (t_stat stat, char *argv[]);
1440
1441
1442
1443 #if defined(__APPLE__)
1444 int processIsTranslated(void)
1445 {
1446 int ret = 0;
1447 size_t size = sizeof(ret);
1448 if (sysctlbyname("sysctl.proc_translated", &ret, &size, NULL, 0) == -1) {
1449 if (errno == ENOENT)
1450 return 0;
1451 return -1; }
1452 return ret;
1453 }
1454 #endif
1455
1456
1457
1458 char *strremove(char *str, const char *sub)
1459 {
1460 char *p, *q, *r;
1461 if (*sub && (q = r = strstr(str, sub)) != NULL) {
1462 size_t len = strlen(sub);
1463 while ((r = strstr(p = r + len, sub)) != NULL) {
1464 while (p < r)
1465 *q++ = *p++;
1466 }
1467 while ((*q++ = *p++) != '\0')
1468 continue;
1469 }
1470 return str;
1471 }
1472
1473
1474
1475 void strtrimspace (char *str_trimmed, const char *str_untrimmed)
1476 {
1477 while (*str_untrimmed != '\0') {
1478 if(!isspace((unsigned char)*str_untrimmed)) {
1479 *str_trimmed = (char)*str_untrimmed;
1480 str_trimmed++;
1481 }
1482 str_untrimmed++;
1483 }
1484 *str_trimmed = '\0';
1485 }
1486
1487 #if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__MINGW64__) && !defined(CROSS_MINGW32) && !defined(CROSS_MINGW64)
1488 void allowCores(void)
1489 {
1490 int ret;
1491 struct rlimit limit;
1492 # if defined(RLIMIT_CORE)
1493 ret = getrlimit(RLIMIT_CORE, &limit);
1494 (void)ret;
1495 # if defined(TESTING)
1496 if (ret != 0)
1497 {
1498 sim_warn ("Failed to query core dump configuration.");
1499 return;
1500 }
1501 # endif
1502 limit.rlim_cur = limit.rlim_max;
1503 ret = setrlimit(RLIMIT_CORE, &limit);
1504 # if defined(TESTING)
1505 if (ret != 0)
1506 {
1507 sim_warn ("Failed to enable unlimited core dumps.");
1508 return;
1509 }
1510 # endif
1511 # else
1512 # if defined(TESTING)
1513 sim_warn ("Unable to query core dump configuration.");
1514 # endif
1515 # endif
1516 return;
1517 }
1518 #endif
1519
1520 #if defined(USE_DUMA)
1521 void CleanDUMA(void)
1522 {
1523 (void)fflush(stdout);
1524 DUMA_CHECKALL();
1525 (void)fflush(stderr);
1526 }
1527 # undef USE_DUMA
1528 # define USE_DUMA 1
1529 #endif
1530
1531 #if !defined(SIG_SETMASK)
1532 # undef USE_BACKTRACE
1533 #endif
1534
1535 #if defined(PERF_STRIP)
1536 # undef USE_BACKTRACE
1537 #endif
1538
1539 #if defined(USE_BACKTRACE)
1540 # include <backtrace.h>
1541 # include <backtrace-supported.h>
1542 # define BACKTRACE_SKIP 1
1543 # define BACKTRACE_MAIN "main"
1544 # undef USE_BACKTRACE
1545 # define USE_BACKTRACE 1
1546 #endif
1547
1548 #if defined(BACKTRACE_SUPPORTED)
1549 # if defined(BACKTRACE_SUPPORTS_THREADS)
1550 # if !(BACKTRACE_SUPPORTED)
1551 # undef USE_BACKTRACE
1552 # endif
1553 # else
1554 # undef USE_BACKTRACE
1555 # endif
1556 #else
1557 # undef USE_BACKTRACE
1558 #endif
1559
1560 #if defined(USE_BACKTRACE)
1561 # if defined(BACKTRACE_SUPPORTED)
1562 # include "backtrace_func.c"
1563 # endif
1564 #endif
1565
1566 #if !defined(__CYGWIN__)
1567 # if !defined(__APPLE__)
1568 # if !defined(_AIX)
1569 # if !defined(__MINGW32__)
1570 # if !defined(__MINGW64__)
1571 # if !defined(CROSS_MINGW32)
1572 # if !defined(CROSS_MINGW64)
1573 # if !defined(_WIN32)
1574 # if !defined(__HAIKU__)
1575 static int
1576 dl_iterate_phdr_callback (struct dl_phdr_info *info, size_t size, void *data)
1577 {
1578 (void)size;
1579 (void)data;
1580
1581 if (strlen(info->dlpi_name) >= 2) {
1582 if (!dl_iterate_phdr_callback_called)
1583 (void)printf ("\r\n Loaded shared objects: ");
1584
1585 dl_iterate_phdr_callback_called++;
1586 (void)printf ("%s ", info->dlpi_name);
1587 }
1588
1589 return 0;
1590 }
1591 # endif
1592 # endif
1593 # endif
1594 # endif
1595 # endif
1596 # endif
1597 # endif
1598 # endif
1599 #endif
1600
1601 #if defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
1602 # if defined(_UCRT)
1603 # define MINGW_CRT "UCRT"
1604 # else
1605 # define MINGW_CRT "MSVCRT"
1606 # endif
1607 #endif
1608
1609 #if defined(_WIN32) || defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
1610 struct UCRTVersion
1611 {
1612 uint16_t ProductVersion[4];
1613 };
1614
1615 int
1616 GetUCRTVersion (struct UCRTVersion *ucrtversion)
1617 {
1618 # ifdef _DEBUG
1619 static const wchar_t *DllName = L"ucrtbased.dll";
1620 # else
1621 static const wchar_t *DllName = L"ucrtbase.dll";
1622 # endif
1623
1624 HMODULE ucrt = GetModuleHandleW (DllName);
1625 if (!ucrt)
1626 return GetLastError ();
1627
1628 wchar_t path[MAX_PATH];
1629 if (!GetModuleFileNameW (ucrt, path, MAX_PATH))
1630 return GetLastError ();
1631
1632 DWORD versionInfoSize = GetFileVersionInfoSizeW (path, NULL);
1633 if (!versionInfoSize)
1634 return GetLastError ();
1635
1636 uint8_t versionInfo[versionInfoSize];
1637
1638 if (!GetFileVersionInfoW (path, 0, versionInfoSize, versionInfo))
1639 return GetLastError ();
1640
1641 VS_FIXEDFILEINFO *fixedFileInfo;
1642 UINT fixedFileInfoSize;
1643 if (!VerQueryValueW (versionInfo, L"\\", (void **)&fixedFileInfo, &fixedFileInfoSize))
1644 return GetLastError ();
1645
1646 memcpy (ucrtversion->ProductVersion, &fixedFileInfo->dwProductVersionMS, sizeof (uint32_t) * 2);
1647
1648 return 0;
1649 }
1650 #endif
1651
1652
1653
1654 #if !defined(PERF_STRIP)
1655 int main (int argc, char *argv[])
1656 {
1657 char *cptr, *cptr2;
1658 char nbuf[PATH_MAX + 7];
1659 char cbuf[4*CBUFSIZE];
1660 char **targv = NULL;
1661 # if defined(USE_BACKTRACE)
1662 # if defined(BACKTRACE_SUPPORTED)
1663 # if defined(_INC_BACKTRACE_FUNC)
1664 bt_pid = (long)getpid();
1665 (void)bt_pid;
1666 # endif
1667 # endif
1668 # endif
1669 int32 i, sw;
1670 t_bool lookswitch;
1671 t_stat stat;
1672
1673 # if defined(__MINGW32__)
1674 # undef IS_WINDOWS
1675 # define IS_WINDOWS 1
1676 # if !defined(NEED_CONSOLE_SETUP)
1677 # define NEED_CONSOLE_SETUP
1678 # endif
1679 # endif
1680
1681 # if defined(CROSS_MINGW32)
1682 # undef IS_WINDOWS
1683 # define IS_WINDOWS 1
1684 # if !defined(NEED_CONSOLE_SETUP)
1685 # define NEED_CONSOLE_SETUP
1686 # endif
1687 # endif
1688
1689 # if defined(__MINGW64__)
1690 # undef IS_WINDOWS
1691 # define IS_WINDOWS 1
1692 # if !defined(NEED_CONSOLE_SETUP)
1693 # define NEED_CONSOLE_SETUP
1694 # endif
1695 # endif
1696
1697 # if defined(CROSS_MINGW64)
1698 # undef IS_WINDOWS
1699 # define IS_WINDOWS 1
1700 # if !defined(NEED_CONSOLE_SETUP)
1701 # define NEED_CONSOLE_SETUP
1702 # endif
1703 # endif
1704
1705 # if defined(__CYGWIN__)
1706 # if defined(IS_WINDOWS)
1707 # undef IS_WINDOWS
1708 # endif
1709 # endif
1710
1711 # if defined(USE_DUMA)
1712 # if defined(DUMA_EXPLICIT_INIT)
1713 duma_init();
1714 (void)fflush(stderr);
1715 # endif
1716 # if defined(DUMA_MIN_ALIGNMENT)
1717 # if DUMA_MIN_ALIGNMENT > 0
1718 DUMA_SET_ALIGNMENT(DUMA_MIN_ALIGNMENT);
1719 # endif
1720 # endif
1721 DUMA_SET_FILL(0x2E);
1722 (void)fflush(stderr);
1723 (void)atexit(CleanDUMA);
1724 # endif
1725
1726 # if defined(USE_BACKTRACE)
1727 # if defined(BACKTRACE_SUPPORTED)
1728 # include "backtrace_main.c"
1729 # endif
1730 # endif
1731
1732 (void)setlocale(LC_ALL, "");
1733
1734 # if defined(NEED_CONSOLE_SETUP) && defined(_WIN32)
1735 # if !defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
1736 # define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
1737 # endif
1738 # endif
1739
1740 # if defined(NEED_CONSOLE_SETUP)
1741 HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
1742 if (handle != INVALID_HANDLE_VALUE)
1743 {
1744 DWORD mode = 0;
1745 if (GetConsoleMode(handle, &mode))
1746 {
1747 mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
1748 SetConsoleMode(handle, mode);
1749 }
1750 }
1751 puts ("\e[0m");
1752 # endif
1753
1754 # if defined(__HAIKU__)
1755 (void)disable_debugger(1);
1756 # endif
1757
1758
1759
1760 # if defined(__clang_analyzer__)
1761 (void)fprintf (stderr, "Error: Attempting to execute a Clang Analyzer build!\n");
1762 return 1;
1763 # endif
1764
1765 if (argc == 0) {
1766 (void)fprintf (stderr, "Error: main() called directly!\n");
1767 return 1;
1768 }
1769
1770
1771 # if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__MINGW64__) && !defined(CROSS_MINGW32) && !defined(CROSS_MINGW64)
1772 allowCores();
1773 # endif
1774
1775 int testEndian = decContextTestEndian();
1776 if (testEndian != 0) {
1777 if (testEndian == 1) {
1778 (void)fprintf (stderr,
1779 "Error: Compiled for big-endian, but little-endian ordering detected; aborting.\n");
1780 return 1;
1781 }
1782 if (testEndian == -1) {
1783 (void)fprintf (stderr,
1784 "Error: Compiled for little-endian, but big-endian ordering detected; aborting.\n");
1785 return 1;
1786 }
1787 (void)fprintf (stderr,
1788 "Error: Unable to determine system byte order; aborting.\n");
1789 return 1;
1790 }
1791 # if defined(NEED_128)
1792 test_math128();
1793 # endif
1794
1795
1796 targv = (char **)calloc (1+MAX(10, argc), sizeof(*targv));
1797 if (!targv)
1798 {
1799 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1800 __func__, __FILE__, __LINE__);
1801 # if defined(USE_BACKTRACE)
1802 # if defined(SIGUSR2)
1803 (void)raise(SIGUSR2);
1804
1805 # endif
1806 # endif
1807 abort();
1808 }
1809 for (i=0; i<argc; i++)
1810 targv[i] = argv[i];
1811 argv = targv;
1812
1813
1814 set_prompt (0, "sim>");
1815 *cbuf = 0;
1816 sim_switches = 0;
1817 lookswitch = TRUE;
1818 stdnul = fopen(NULL_DEVICE,"wb");
1819
1820
1821 for (i = 1; i < argc; i++) {
1822 if (argv[i] == NULL)
1823 continue;
1824
1825 # if defined(THREADZ) || defined(LOCKLESS)
1826
1827 int perftestflag = strcmp(argv[i], "--perftest");
1828 if (perftestflag == 0) {
1829 char * testName = NULL;
1830 if (i + 1 < argc)
1831 testName = argv[i + 1];
1832 perfTest (testName);
1833 return 0;
1834 }
1835 # endif
1836
1837
1838 int onlyvers = strcmp(argv[i], "--version");
1839 if (onlyvers == 0) {
1840 # if defined(VER_H_GIT_VERSION)
1841 # if defined(VER_H_GIT_PATCH) && defined(VER_H_GIT_PATCH_INT)
1842 # if VER_H_GIT_PATCH_INT < 1
1843 (void)fprintf (stdout, "%s simulator %s\n",
1844 sim_name, VER_H_GIT_VERSION);
1845 # else
1846 (void)fprintf (stdout, "%s simulator %s+%s\n",
1847 sim_name, VER_H_GIT_VERSION, VER_H_GIT_PATCH);
1848 # endif
1849 # else
1850 (void)fprintf (stdout, "%s simulator %s\n",
1851 sim_name, VER_H_GIT_VERSION);
1852 # endif
1853 # else
1854 (void)fprintf (stdout, "%s simulator\n", sim_name);
1855 # endif
1856 FREE (targv);
1857 return 0;
1858 }
1859
1860
1861 int longhelp = strcmp(argv[i], "--help");
1862 int shorthelp = strcmp(argv[i], "-h");
1863 if (shorthelp != 0) shorthelp = strcmp(argv[i], "-H");
1864 if (longhelp == 0 || shorthelp == 0) {
1865 # if defined(VER_H_GIT_VERSION)
1866 # if defined(VER_H_GIT_PATCH) && defined(VER_H_GIT_PATCH_INT)
1867 # if VER_H_GIT_PATCH_INT < 1
1868 (void)fprintf (stdout, "%s simulator %s", sim_name, VER_H_GIT_VERSION);
1869 # else
1870 (void)fprintf (stdout, "%s simulator %s+%s", sim_name, VER_H_GIT_VERSION, VER_H_GIT_PATCH);
1871 # endif
1872 # else
1873 (void)fprintf (stdout, "%s simulator %s", sim_name, VER_H_GIT_VERSION);
1874 # endif
1875 # else
1876 (void)fprintf (stdout, "%s simulator", sim_name);
1877 # endif
1878 (void)fprintf (stdout, "\n");
1879 (void)fprintf (stdout, "\n USAGE: %s { [ SWITCHES ] ... } { < SCRIPT > }", argv[0]);
1880 (void)fprintf (stdout, "\n");
1881 (void)fprintf (stdout, "\n Invokes the %s simulator, with optional switches and/or script file.", sim_name);
1882 (void)fprintf (stdout, "\n");
1883 (void)fprintf (stdout, "\n Switches:");
1884 (void)fprintf (stdout, "\n -e, -E Aborts script processing immediately upon any error");
1885 (void)fprintf (stdout, "\n -h, -H, --help Prints only this informational help text and exit");
1886 (void)fprintf (stdout, "\n -k, -K Disables all support for exclusive file locking");
1887 (void)fprintf (stdout, "\n -l, -L Reports but ignores all exclusive file locking errors");
1888 (void)fprintf (stdout, "\n -o, -O Makes scripting ON conditions and actions inheritable");
1889 (void)fprintf (stdout, "\n -q, -Q Disables printing of non-fatal informational messages");
1890 (void)fprintf (stdout, "\n -r, -R Enables an unlinked ephemeral system state file");
1891 (void)fprintf (stdout, "\n -s, -S Enables a randomized persistent system state file");
1892 (void)fprintf (stdout, "\n -t, -T Disables fsync and creation/usage of system state file");
1893 (void)fprintf (stdout, "\n -v, -V Prints commands read from script file before execution");
1894 (void)fprintf (stdout, "\n --version Prints only the simulator identification text and exit");
1895 (void)fprintf (stdout, "\n");
1896 # if defined(USE_DUMA)
1897 nodist++;
1898 # endif
1899 if (!nodist) {
1900 (void)fprintf (stdout, "\n This software is made available under the terms of the ICU License.");
1901 (void)fprintf (stdout, "\n For complete license details, see the LICENSE file included with the");
1902 (void)fprintf (stdout, "\n software or https://gitlab.com/dps8m/dps8m/-/blob/master/LICENSE.md\n");
1903 }
1904 else
1905 {
1906 (void)fprintf (stdout, "\n********** LICENSE RESTRICTED BUILD ****** NOT FOR REDISTRIBUTION **********");
1907 }
1908 (void)fprintf (stdout, "\n");
1909 FREE(argv);
1910 return 0;
1911 }
1912
1913 if ((*argv[i] == '-') && lookswitch) {
1914 if ((sw = get_switches (argv[i])) < 0) {
1915 (void)fprintf (stderr, "Invalid switch \"%s\".\nTry \"%s -h\" for help.\n", argv[i], argv[0]);
1916 FREE(argv);
1917 return 1;
1918 }
1919 sim_switches = sim_switches | sw;
1920 }
1921
1922 else {
1923 if ((strlen (argv[i]) + strlen (cbuf) + 3) >= sizeof(cbuf)) {
1924 (void)fprintf (stderr, "Argument string too long\n");
1925 FREE(argv);
1926 return 1;
1927 }
1928 if (*cbuf)
1929 strcat (cbuf, " ");
1930 (void)sprintf(&cbuf[strlen(cbuf)], "%s%s%s",
1931 strchr(argv[i], ' ') ? "\"" : "", argv[i], strchr(argv[i], ' ') ? "\"" : "");
1932 lookswitch = FALSE;
1933 }
1934 }
1935 sim_nolock = sim_switches & SWMASK ('K');
1936 sim_iglock = sim_switches & SWMASK ('L');
1937 sim_randompst = sim_switches & SWMASK ('S');
1938 sim_quiet = sim_switches & SWMASK ('Q');
1939 sim_randstate = sim_switches & SWMASK ('R');
1940 if (sim_randompst) sim_randstate = 1;
1941 sim_nostate = sim_switches & SWMASK ('T');
1942 if (sim_nostate)
1943 {
1944 sim_randompst = 0;
1945 sim_randstate = 0;
1946 }
1947 sim_on_inherit = sim_switches & SWMASK ('O');
1948
1949 sim_init_sock ();
1950 if (sim_dflt_dev == NULL)
1951 sim_dflt_dev = sim_devices[0];
1952 if (sim_vm_init != NULL)
1953 (*sim_vm_init)();
1954 sim_finit ();
1955 for (i = 0; cmd_table[i].name; i++) {
1956 size_t alias_len = strlen (cmd_table[i].name);
1957 char *cmd_name = (char *)calloc (1 + alias_len, sizeof (*cmd_name));
1958 if (!cmd_name)
1959 {
1960 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1961 __func__, __FILE__, __LINE__);
1962 # if defined(USE_BACKTRACE)
1963 # if defined(SIGUSR2)
1964 (void)raise(SIGUSR2);
1965
1966 # endif
1967 # endif
1968 abort();
1969 }
1970
1971 strcpy (cmd_name, cmd_table[i].name);
1972 while (alias_len > 1) {
1973 cmd_name[alias_len] = '\0';
1974 --alias_len;
1975 if (getenv (cmd_name))
1976 unsetenv (cmd_name);
1977 }
1978 FREE (cmd_name);
1979 }
1980 stop_cpu = 0;
1981 sim_interval = 0;
1982 sim_time = sim_rtime = 0;
1983 noqueue_time = 0;
1984 sim_clock_queue = QUEUE_LIST_END;
1985 sim_is_running = 0;
1986 sim_log = NULL;
1987 if (sim_emax <= 0)
1988 sim_emax = 1;
1989 sim_timer_init ();
1990
1991 if ((stat = sim_ttinit ()) != SCPE_OK) {
1992 (void)fprintf (stderr, "Fatal terminal initialization error\n%s\n",
1993 sim_error_text (stat));
1994 FREE(argv);
1995 return 1;
1996 }
1997 if ((sim_eval = (t_value *) calloc (sim_emax, sizeof (t_value))) == NULL) {
1998 (void)fprintf (stderr, "Unable to allocate examine buffer\n");
1999 FREE(argv);
2000 return 1;
2001 };
2002 if ((stat = reset_all_p (0)) != SCPE_OK) {
2003 (void)fprintf (stderr, "Fatal simulator initialization error\n%s\n",
2004 sim_error_text (stat));
2005 FREE(argv);
2006 return 1;
2007 }
2008 if ((stat = sim_brk_init ()) != SCPE_OK) {
2009 (void)fprintf (stderr, "Fatal breakpoint table initialization error\n%s\n",
2010 sim_error_text (stat));
2011 FREE(argv);
2012 return 1;
2013 }
2014 if (!sim_quiet) {
2015 (void)printf ("\n");
2016 show_version (stdout, NULL, NULL, 0, NULL);
2017 }
2018
2019 cptr = getenv("HOME");
2020 if (cptr == NULL) {
2021 cptr = getenv("HOMEPATH");
2022 cptr2 = getenv("HOMEDRIVE");
2023 }
2024 else
2025 cptr2 = NULL;
2026 (void)cptr2;
2027 if ( (*cbuf) && (strcmp(cbuf, "")) )
2028 stat = do_cmd (0, cbuf);
2029 else if (*argv[0]) {
2030 char *np;
2031 nbuf[0] = '"';
2032 stat = do_cmd (-1, nbuf) & ~SCPE_NOMESSAGE;
2033 if (stat == SCPE_OPENERR) {
2034 np = strrchr (nbuf, '/');
2035 if (np == NULL)
2036 np = strrchr (nbuf, '\\');
2037 if (np != NULL) {
2038 *np = '"';
2039 stat = do_cmd (-1, np) & ~SCPE_NOMESSAGE;
2040 }
2041 }
2042 }
2043
2044 stat = process_stdin_commands (SCPE_BARE_STATUS(stat), argv);
2045
2046 if (sim_vm_exit != NULL)
2047 (*sim_vm_exit)();
2048
2049 detach_all (0, TRUE);
2050 sim_set_deboff (0, NULL);
2051 sim_set_logoff (0, NULL);
2052 sim_set_notelnet (0, NULL);
2053 sim_ttclose ();
2054 sim_cleanup_sock ();
2055 fclose (stdnul);
2056 FREE (targv);
2057 FREE (sim_prompt);
2058 FREE (sim_eval);
2059 FREE (sim_internal_devices);
2060 FREE (sim_brk_tab);
2061 FREE (sim_staba.comp);
2062 FREE (sim_staba.mask);
2063 FREE (sim_stabr.comp);
2064 FREE (sim_stabr.mask);
2065 return 0;
2066 }
2067 #endif
2068
2069 t_stat process_stdin_commands (t_stat stat, char *argv[])
2070 {
2071 char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE];
2072 CONST char *cptr;
2073 t_stat stat_nomessage;
2074 CTAB *cmdp = NULL;
2075
2076 stat = SCPE_BARE_STATUS(stat);
2077 while (stat != SCPE_EXIT) {
2078 if ((cptr = sim_brk_getact (cbuf, sizeof(cbuf))))
2079 (void)printf ("%s%s\n", sim_prompt, cptr);
2080 else if (sim_vm_read != NULL) {
2081 (void)printf ("%s", sim_prompt);
2082 cptr = (*sim_vm_read) (cbuf, sizeof(cbuf), stdin);
2083 }
2084 else cptr = read_line_p (sim_prompt, cbuf, sizeof(cbuf), stdin);
2085 if (cptr == NULL) {
2086 if (sim_ttisatty()) continue;
2087 else break;
2088 }
2089 if (*cptr == 0)
2090 continue;
2091 sim_sub_args (cbuf, sizeof(cbuf), argv);
2092 if (sim_log)
2093 (void)fprintf (sim_log, "%s%s\n", sim_prompt, cptr);
2094 if (sim_deb && (sim_deb != sim_log) && (sim_deb != stdout))
2095 (void)fprintf (sim_deb, "%s%s\n", sim_prompt, cptr);
2096 cptr = get_glyph_cmd (cptr, gbuf);
2097 sim_switches = 0;
2098 if ((cmdp = find_cmd (gbuf)))
2099 stat = cmdp->action (cmdp->arg, cptr);
2100 else
2101 stat = SCPE_UNK;
2102 stat_nomessage = stat & SCPE_NOMESSAGE;
2103 stat_nomessage = stat_nomessage || (!sim_show_message);
2104 stat = SCPE_BARE_STATUS(stat);
2105 sim_last_cmd_stat = stat;
2106 if (!stat_nomessage) {
2107 if (cmdp && (cmdp->message))
2108 cmdp->message (NULL, stat);
2109 else
2110 if (stat >= SCPE_BASE)
2111 sim_printf ("%s\n", sim_error_text (stat));
2112 }
2113 if (sim_vm_post != NULL)
2114 (*sim_vm_post) (TRUE);
2115 }
2116 return stat;
2117 }
2118
2119
2120
2121 t_stat set_prompt (int32 flag, CONST char *cptr)
2122 {
2123 char gbuf[CBUFSIZE], *gptr;
2124
2125 if ((NULL == cptr) || (*cptr == '\0'))
2126 return SCPE_ARG;
2127
2128 cptr = get_glyph_nc (cptr, gbuf, '"');
2129 if (gbuf[0] == '\0') {
2130 gbuf[sizeof (gbuf)-1] = '\0';
2131 strncpy (gbuf, cptr, sizeof (gbuf)-1);
2132 gptr = strchr (gbuf, '"');
2133 if (NULL != gptr)
2134 *gptr = '\0';
2135 }
2136 sim_prompt = (char *)realloc (sim_prompt, strlen (gbuf) + 2);
2137 if (!sim_prompt)
2138 {
2139 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
2140 __func__, __FILE__, __LINE__);
2141 #if defined(USE_BACKTRACE)
2142 # if defined(SIGUSR2)
2143 (void)raise(SIGUSR2);
2144
2145 # endif
2146 #endif
2147 abort();
2148 }
2149 (void)sprintf (sim_prompt, "%s ", gbuf);
2150 return SCPE_OK;
2151 }
2152
2153
2154
2155 CTAB *find_cmd (const char *gbuf)
2156 {
2157 CTAB *cmdp = NULL;
2158
2159 if (sim_vm_cmd)
2160 cmdp = find_ctab (sim_vm_cmd, gbuf);
2161 if (cmdp == NULL)
2162 cmdp = find_ctab (cmd_table, gbuf);
2163 return cmdp;
2164 }
2165
2166
2167
2168 t_stat exit_cmd (int32 flag, CONST char *cptr)
2169 {
2170 return SCPE_EXIT;
2171 }
2172
2173
2174
2175
2176 static int _cmd_name_compare (const void *pa, const void *pb)
2177 {
2178 CTAB * const *a = (CTAB * const *)pa;
2179 CTAB * const *b = (CTAB * const *)pb;
2180
2181 return strcmp((*a)->name, (*b)->name);
2182 }
2183
2184 void fprint_help (FILE *st)
2185 {
2186 CTAB *cmdp;
2187 CTAB **hlp_cmdp = NULL;
2188 size_t cmd_cnt = 0;
2189 size_t cmd_size = 0;
2190 size_t max_cmdname_size = 0;
2191 size_t i, line_offset;
2192
2193 for (cmdp = sim_vm_cmd; cmdp && (cmdp->name != NULL); cmdp++) {
2194 if (cmdp->help) {
2195 if (cmd_cnt >= cmd_size) {
2196 cmd_size += 20;
2197 hlp_cmdp = (CTAB **)realloc (hlp_cmdp, sizeof(*hlp_cmdp)*cmd_size);
2198 if (!hlp_cmdp)
2199 {
2200 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
2201 __func__, __FILE__, __LINE__);
2202 #if defined(USE_BACKTRACE)
2203 # if defined(SIGUSR2)
2204 (void)raise(SIGUSR2);
2205
2206 # endif
2207 #endif
2208 abort();
2209 }
2210 }
2211 hlp_cmdp[cmd_cnt] = cmdp;
2212 ++cmd_cnt;
2213 if (strlen(cmdp->name) > max_cmdname_size)
2214 max_cmdname_size = strlen(cmdp->name);
2215 }
2216 }
2217 for (cmdp = cmd_table; cmdp && (cmdp->name != NULL); cmdp++) {
2218 if (cmdp->help && (NULL == sim_vm_cmd || NULL == find_ctab (sim_vm_cmd, cmdp->name))) {
2219 if (cmd_cnt >= cmd_size) {
2220 cmd_size += 20;
2221 hlp_cmdp = (CTAB **)realloc (hlp_cmdp, sizeof(*hlp_cmdp)*cmd_size);
2222 if (!hlp_cmdp)
2223 {
2224 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
2225 __func__, __FILE__, __LINE__);
2226 #if defined(USE_BACKTRACE)
2227 # if defined(SIGUSR2)
2228 (void)raise(SIGUSR2);
2229
2230 # endif
2231 #endif
2232 abort();
2233 }
2234 }
2235 hlp_cmdp[cmd_cnt] = cmdp;
2236 ++cmd_cnt;
2237 if (strlen (cmdp->name) > max_cmdname_size)
2238 max_cmdname_size = strlen(cmdp->name);
2239 }
2240 }
2241 (void)fprintf (st, "HELP is available for the following commands:\n\n ");
2242 if (hlp_cmdp)
2243 qsort (hlp_cmdp, cmd_cnt, sizeof(*hlp_cmdp), _cmd_name_compare);
2244 line_offset = 4;
2245 for ( i = 0 ; i < cmd_cnt ; ++i ) {
2246 fputs (hlp_cmdp[i]->name, st);
2247 line_offset += 5 + max_cmdname_size;
2248 if (line_offset + max_cmdname_size > 79) {
2249 line_offset = 4;
2250 (void)fprintf (st, "\n ");
2251 }
2252 else
2253 (void)fprintf (st, "%*s", (int)(max_cmdname_size + 5 - strlen (hlp_cmdp[i]->name)), "");
2254 }
2255 FREE (hlp_cmdp);
2256 (void)fprintf (st, "\n");
2257 return;
2258 }
2259
2260 static void fprint_header (FILE *st, t_bool *pdone, char *context)
2261 {
2262 if (!*pdone)
2263 (void)fprintf (st, "%s", context);
2264 *pdone = TRUE;
2265 }
2266
2267 void fprint_reg_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2268 {
2269 REG *rptr, *trptr;
2270 t_bool found = FALSE;
2271 t_bool all_unique = TRUE;
2272 size_t max_namelen = 0;
2273 DEVICE *tdptr;
2274 CONST char *tptr;
2275 char *namebuf;
2276 char rangebuf[32];
2277
2278 if (dptr->registers)
2279 for (rptr = dptr->registers; rptr->name != NULL; rptr++) {
2280 if (rptr->flags & REG_HIDDEN)
2281 continue;
2282 if (rptr->depth > 1)
2283 (void)sprintf (rangebuf, "[%d:%d]", 0, rptr->depth-1);
2284 else
2285 strcpy (rangebuf, "");
2286 if (max_namelen < (strlen(rptr->name) + strlen (rangebuf)))
2287 max_namelen = strlen(rptr->name) + strlen (rangebuf);
2288 found = TRUE;
2289 trptr = find_reg_glob (rptr->name, &tptr, &tdptr);
2290 if ((trptr == NULL) || (tdptr != dptr))
2291 all_unique = FALSE;
2292 }
2293 if (!found) {
2294 if (!silent)
2295 (void)fprintf (st, "No register HELP available for the %s device\n",
2296 dptr->name);
2297 }
2298 else {
2299 namebuf = (char *)calloc (max_namelen + 1, sizeof (*namebuf));
2300 if (!namebuf)
2301 {
2302 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
2303 __func__, __FILE__, __LINE__);
2304 #if defined(USE_BACKTRACE)
2305 # if defined(SIGUSR2)
2306 (void)raise(SIGUSR2);
2307
2308 # endif
2309 #endif
2310 abort();
2311 }
2312 (void)fprintf (st, "\nThe %s device implements these registers:\n\n",
2313 dptr->name);
2314 for (rptr = dptr->registers; rptr->name != NULL; rptr++) {
2315 if (rptr->flags & REG_HIDDEN)
2316 continue;
2317 if (rptr->depth <= 1)
2318 (void)sprintf (namebuf, "%*s",
2319 -((int)max_namelen),
2320 rptr->name);
2321 else {
2322 (void)sprintf (rangebuf, "[%d:%d]",
2323 0,
2324 rptr->depth-1);
2325 (void)sprintf (namebuf, "%s%*s",
2326 rptr->name,
2327 (int)(strlen(rptr->name))-((int)max_namelen),
2328 rangebuf);
2329 }
2330 if (all_unique) {
2331 (void)fprintf (st, " %s %4d %s\n",
2332 namebuf,
2333 rptr->width,
2334 rptr->desc ? rptr->desc : "");
2335 continue;
2336 }
2337 trptr = find_reg_glob (rptr->name, &tptr, &tdptr);
2338 if ((trptr == NULL) || (tdptr != dptr))
2339 (void)fprintf (st, " %s %s %4d %s\n",
2340 dptr->name,
2341 namebuf,
2342 rptr->width,
2343 rptr->desc ? rptr->desc : "");
2344 else
2345 (void)fprintf (st, " %*s %s %4d %s\n",
2346 (int)strlen(dptr->name), "",
2347 namebuf,
2348 rptr->width,
2349 rptr->desc ? rptr->desc : "");
2350 }
2351 FREE (namebuf);
2352 }
2353 }
2354
2355 void fprint_reg_help (FILE *st, DEVICE *dptr)
2356 {
2357 fprint_reg_help_ex (st, dptr, TRUE);
2358 }
2359
2360 void fprint_attach_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2361 {
2362 if (dptr->attach_help) {
2363 (void)fprintf (st, "\n%s device ATTACH commands:\n\n", dptr->name);
2364 dptr->attach_help (st, dptr, NULL, 0, NULL);
2365 return;
2366 }
2367 if (DEV_TYPE(dptr) == DEV_DISK) {
2368 (void)fprintf (st, "\n%s device ATTACH commands:\n\n", dptr->name);
2369 sim_disk_attach_help (st, dptr, NULL, 0, NULL);
2370 return;
2371 }
2372 if (DEV_TYPE(dptr) == DEV_TAPE) {
2373 (void)fprintf (st, "\n%s device ATTACH commands:\n\n", dptr->name);
2374 sim_tape_attach_help (st, dptr, NULL, 0, NULL);
2375 return;
2376 }
2377 if (!silent) {
2378 (void)fprintf (st, "No ATTACH help is available for the %s device\n", dptr->name);
2379 if (dptr->help)
2380 dptr->help (st, dptr, NULL, 0, NULL);
2381 }
2382 }
2383
2384 void fprint_set_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2385 {
2386 MTAB *mptr;
2387 DEBTAB *dep;
2388 t_bool found = FALSE;
2389 char buf[CBUFSIZE], header[CBUFSIZE];
2390 uint32 enabled_units = dptr->numunits;
2391 uint32 unit;
2392
2393 (void)sprintf (header, "\n%s device SET commands:\n\n", dptr->name);
2394 for (unit=0; unit < dptr->numunits; unit++)
2395 if (dptr->units[unit].flags & UNIT_DIS)
2396 --enabled_units;
2397 if (dptr->modifiers) {
2398 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
2399 if (!MODMASK(mptr,MTAB_VDV) && MODMASK(mptr,MTAB_VUN) && (dptr->numunits != 1))
2400 continue;
2401 if ((enabled_units != 1) && !(mptr->mask & MTAB_XTD))
2402 continue;
2403 if (mptr->mstring) {
2404 fprint_header (st, &found, header);
2405 (void)sprintf (buf, "SET %s %s%s", sim_dname (dptr),
2406 mptr->mstring,
2407 (strchr(mptr->mstring, '=')) \
2408 ? "" : (MODMASK(mptr,MTAB_VALR) \
2409 ? "=val" : (MODMASK(mptr,MTAB_VALO) \
2410 ? "{=val}" : "")));
2411 if ((strlen (buf) < 30) || (NULL == mptr->help))
2412 (void)fprintf (st, "%-30s\t%s\n", buf, mptr->help ? mptr->help : "");
2413 else
2414 (void)fprintf (st, "%s\n%-30s\t%s\n", buf, "", mptr->help);
2415 }
2416 }
2417 }
2418 if (dptr->flags & DEV_DISABLE) {
2419 fprint_header (st, &found, header);
2420 (void)sprintf (buf, "SET %s ENABLE", sim_dname (dptr));
2421 (void)fprintf (st, "%-30s\tEnables device %s\n", buf, sim_dname (dptr));
2422 (void)sprintf (buf, "SET %s DISABLE", sim_dname (dptr));
2423 (void)fprintf (st, "%-30s\tDisables device %s\n", buf, sim_dname (dptr));
2424 }
2425 if (dptr->flags & DEV_DEBUG) {
2426 fprint_header (st, &found, header);
2427 (void)sprintf (buf, "SET %s DEBUG", sim_dname (dptr));
2428 (void)fprintf (st, "%-30s\tEnables debugging for device %s\n", buf, sim_dname (dptr));
2429 (void)sprintf (buf, "SET %s NODEBUG", sim_dname (dptr));
2430 (void)fprintf (st, "%-30s\tDisables debugging for device %s\n", buf, sim_dname (dptr));
2431 if (dptr->debflags) {
2432 t_bool desc_available = FALSE;
2433 strcpy (buf, "");
2434 (void)fprintf (st, "SET %s DEBUG=", sim_dname (dptr));
2435 for (dep = dptr->debflags; dep->name != NULL; dep++) {
2436 (void)fprintf (st, "%s%s", ((dep == dptr->debflags) ? "" : ";"), dep->name);
2437 desc_available |= ((dep->desc != NULL) && (dep->desc[0] != '\0'));
2438 }
2439 (void)fprintf (st, "\n");
2440 (void)fprintf (st, "%-30s\tEnables specific debugging for device %s\n", buf, sim_dname (dptr));
2441 (void)fprintf (st, "SET %s NODEBUG=", sim_dname (dptr));
2442 for (dep = dptr->debflags; dep->name != NULL; dep++)
2443 (void)fprintf (st, "%s%s", ((dep == dptr->debflags) ? "" : ";"), dep->name);
2444 (void)fprintf (st, "\n");
2445 (void)fprintf (st, "%-30s\tDisables specific debugging for device %s\n", buf, sim_dname (dptr));
2446 if (desc_available) {
2447 (void)fprintf (st, "\n*%s device DEBUG settings:\n", sim_dname (dptr));
2448 for (dep = dptr->debflags; dep->name != NULL; dep++)
2449 (void)fprintf (st, "%4s%-12s%s\n", "", dep->name, dep->desc ? dep->desc : "");
2450 }
2451 }
2452 }
2453 if ((dptr->modifiers) && (dptr->units) && (enabled_units != 1)) {
2454 if (dptr->units->flags & UNIT_DISABLE) {
2455 fprint_header (st, &found, header);
2456 (void)sprintf (buf, "SET %sn ENABLE", sim_dname (dptr));
2457 (void)fprintf (st, "%-30s\tEnables unit %sn\n", buf, sim_dname (dptr));
2458 (void)sprintf (buf, "SET %sn DISABLE", sim_dname (dptr));
2459 (void)fprintf (st, "%-30s\tDisables unit %sn\n", buf, sim_dname (dptr));
2460 }
2461 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
2462 if ((!MODMASK(mptr,MTAB_VUN)) && MODMASK(mptr,MTAB_XTD))
2463 continue;
2464 if ((NULL == mptr->valid) && MODMASK(mptr,MTAB_XTD))
2465 continue;
2466 if (mptr->mstring) {
2467 fprint_header (st, &found, header);
2468 (void)sprintf (buf, "SET %s%s %s%s", sim_dname (dptr),
2469 (dptr->numunits > 1) ? "n" : "0", mptr->mstring,
2470 (strchr(mptr->mstring, '=')) \
2471 ? "" : (MODMASK(mptr,MTAB_VALR) \
2472 ? "=val" : (MODMASK(mptr,MTAB_VALO) \
2473 ? "{=val}" : "")));
2474 (void)fprintf (st, "%-30s\t%s\n", buf,
2475 (strchr(mptr->mstring, '=')) \
2476 ? "" : (mptr->help ? mptr->help : ""));
2477 }
2478 }
2479 }
2480 if (!found && !silent)
2481 (void)fprintf (st, "No SET help is available for the %s device\n", dptr->name);
2482 }
2483
2484 void fprint_set_help (FILE *st, DEVICE *dptr)
2485 {
2486 fprint_set_help_ex (st, dptr, TRUE);
2487 }
2488
2489 void fprint_show_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2490 {
2491 MTAB *mptr;
2492 t_bool found = FALSE;
2493 char buf[CBUFSIZE], header[CBUFSIZE];
2494 uint32 enabled_units = dptr->numunits;
2495 uint32 unit;
2496
2497 (void)sprintf (header, "\n%s device SHOW commands:\n\n", dptr->name);
2498 for (unit=0; unit < dptr->numunits; unit++)
2499 if (dptr->units[unit].flags & UNIT_DIS)
2500 --enabled_units;
2501 if (dptr->modifiers) {
2502 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
2503 if (!MODMASK(mptr,MTAB_VDV) && MODMASK(mptr,MTAB_VUN) && (dptr->numunits != 1))
2504 continue;
2505 if ((enabled_units != 1) && !(mptr->mask & MTAB_XTD))
2506 continue;
2507 if ((!mptr->disp) || (!mptr->pstring) || !(*mptr->pstring))
2508 continue;
2509 fprint_header (st, &found, header);
2510 (void)sprintf (buf, "SHOW %s %s%s", sim_dname (dptr),
2511 mptr->pstring, MODMASK(mptr,MTAB_SHP) ? "{=arg}" : "");
2512 (void)fprintf (st, "%-30s\t%s\n", buf, mptr->help ? mptr->help : "");
2513 }
2514 }
2515 if (dptr->flags & DEV_DEBUG) {
2516 fprint_header (st, &found, header);
2517 (void)sprintf (buf, "SHOW %s DEBUG", sim_dname (dptr));
2518 (void)fprintf (st, "%-30s\tDisplays debugging status for device %s\n", buf, sim_dname (dptr));
2519 }
2520 if ((dptr->modifiers) && (dptr->units) && (enabled_units != 1)) {
2521 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
2522 if ((!MODMASK(mptr,MTAB_VUN)) && MODMASK(mptr,MTAB_XTD))
2523 continue;
2524 if ((!mptr->disp) || (!mptr->pstring))
2525 continue;
2526 fprint_header (st, &found, header);
2527 (void)sprintf (buf, "SHOW %s%s %s%s", sim_dname (dptr),
2528 (dptr->numunits > 1) ? "n" : "0", mptr->pstring,
2529 MODMASK(mptr,MTAB_SHP) ? "=arg" : "");
2530 (void)fprintf (st, "%-30s\t%s\n", buf, mptr->help ? mptr->help : "");
2531 }
2532 }
2533 if (!found && !silent)
2534 (void)fprintf (st, "No SHOW help is available for the %s device\n", dptr->name);
2535 }
2536
2537 void fprint_show_help (FILE *st, DEVICE *dptr)
2538 {
2539 fprint_show_help_ex (st, dptr, TRUE);
2540 }
2541
2542 void fprint_brk_help_ex (FILE *st, DEVICE *dptr, t_bool silent)
2543 {
2544 BRKTYPTAB *brkt = dptr->brk_types;
2545 char gbuf[CBUFSIZE];
2546
2547 if (sim_brk_types == 0) {
2548 if ((dptr != sim_dflt_dev) && (!silent)) {
2549 (void)fprintf (st, "Breakpoints are not supported in the %s simulator\n", sim_name);
2550 if (dptr->help)
2551 dptr->help (st, dptr, NULL, 0, NULL);
2552 }
2553 return;
2554 }
2555 if (brkt == NULL) {
2556 int i;
2557
2558 if (dptr == sim_dflt_dev) {
2559 if (sim_brk_types & ~sim_brk_dflt) {
2560 (void)fprintf (st, "%s supports the following breakpoint types:\n", sim_dname (dptr));
2561 for (i=0; i<26; i++) {
2562 if (sim_brk_types & (1<<i))
2563 (void)fprintf (st, " -%c\n", 'A'+i);
2564 }
2565 }
2566 (void)fprintf (st, "The default breakpoint type is: %s\n", put_switches (gbuf, sizeof(gbuf), sim_brk_dflt));
2567 }
2568 return;
2569 }
2570 (void)fprintf (st, "%s supports the following breakpoint types:\n", sim_dname (dptr));
2571 while (brkt->btyp) {
2572 (void)fprintf (st, " %s %s\n", put_switches (gbuf, sizeof(gbuf), brkt->btyp), brkt->desc);
2573 ++brkt;
2574 }
2575 (void)fprintf (st, "The default breakpoint type is: %s\n", put_switches (gbuf, sizeof(gbuf), sim_brk_dflt));
2576 }
2577
2578 t_stat help_dev_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr)
2579 {
2580 char gbuf[CBUFSIZE];
2581 CTAB *cmdp;
2582
2583 if (*cptr) {
2584 (void)get_glyph (cptr, gbuf, 0);
2585 if ((cmdp = find_cmd (gbuf))) {
2586 if (cmdp->action == &exdep_cmd) {
2587 if (dptr->help)
2588 return dptr->help (st, dptr, uptr, flag, cptr);
2589 else
2590 (void)fprintf (st, "No HELP available for the %s %s command\n", cmdp->name, sim_dname(dptr));
2591 return SCPE_OK;
2592 }
2593 if (cmdp->action == &set_cmd) {
2594 fprint_set_help_ex (st, dptr, FALSE);
2595 return SCPE_OK;
2596 }
2597 if (cmdp->action == &show_cmd) {
2598 fprint_show_help_ex (st, dptr, FALSE);
2599 return SCPE_OK;
2600 }
2601 if (cmdp->action == &attach_cmd) {
2602 fprint_attach_help_ex (st, dptr, FALSE);
2603 return SCPE_OK;
2604 }
2605 if (cmdp->action == &brk_cmd) {
2606 fprint_brk_help_ex (st, dptr, FALSE);
2607 return SCPE_OK;
2608 }
2609 if (dptr->help)
2610 return dptr->help (st, dptr, uptr, flag, cptr);
2611 (void)fprintf (st, "No %s HELP is available for the %s device\n", cmdp->name, dptr->name);
2612 return SCPE_OK;
2613 }
2614 if (MATCH_CMD (gbuf, "REGISTERS") == 0) {
2615 fprint_reg_help_ex (st, dptr, FALSE);
2616 return SCPE_OK;
2617 }
2618 if (dptr->help)
2619 return dptr->help (st, dptr, uptr, flag, cptr);
2620 (void)fprintf (st, "No %s HELP is available for the %s device\n", gbuf, dptr->name);
2621 return SCPE_OK;
2622 }
2623 if (dptr->help) {
2624 return dptr->help (st, dptr, uptr, flag, cptr);
2625 }
2626 if (dptr->description)
2627 (void)fprintf (st, "%s %s HELP\n", dptr->description (dptr), dptr->name);
2628 else
2629 (void)fprintf (st, "%s HELP\n", dptr->name);
2630 fprint_set_help_ex (st, dptr, TRUE);
2631 fprint_show_help_ex (st, dptr, TRUE);
2632 fprint_attach_help_ex (st, dptr, TRUE);
2633 fprint_reg_help_ex (st, dptr, TRUE);
2634 fprint_brk_help_ex (st, dptr, TRUE);
2635 return SCPE_OK;
2636 }
2637
2638 t_stat help_cmd_output (int32 flag, const char *help, const char *help_base)
2639 {
2640 switch (help[0]) {
2641 case '*':
2642 scp_help (stdout, NULL, NULL, flag, help_base ? help_base : simh_help, help+1);
2643 if (sim_log)
2644 scp_help (sim_log, NULL, NULL, flag | SCP_HELP_FLAT, help_base ? help_base : simh_help, help+1);
2645 break;
2646 default:
2647 fputs (help, stdout);
2648 if (sim_log)
2649 fputs (help, sim_log);
2650 break;
2651 }
2652 return SCPE_OK;
2653 }
2654
2655 t_stat help_cmd (int32 flag, CONST char *cptr)
2656 {
2657 char gbuf[CBUFSIZE];
2658 CTAB *cmdp;
2659
2660 GET_SWITCHES (cptr);
2661 if (sim_switches & SWMASK ('F'))
2662 flag = flag | SCP_HELP_FLAT;
2663 if (*cptr) {
2664 cptr = get_glyph (cptr, gbuf, 0);
2665 if ((cmdp = find_cmd (gbuf))) {
2666 if (*cptr) {
2667 if ((cmdp->action == &set_cmd) || (cmdp->action == &show_cmd)) {
2668 DEVICE *dptr;
2669 UNIT *uptr;
2670 t_stat r;
2671 cptr = get_glyph (cptr, gbuf, 0);
2672 dptr = find_unit (gbuf, &uptr);
2673 if (dptr == NULL)
2674 dptr = find_dev (gbuf);
2675 if (dptr != NULL) {
2676 r = help_dev_help (stdout, dptr, uptr, flag, (cmdp->action == &set_cmd) ? "SET" : "SHOW");
2677 if (sim_log)
2678 help_dev_help (sim_log, dptr, uptr, flag | SCP_HELP_FLAT, (cmdp->action == &set_cmd) ? "SET" : "SHOW");
2679 return r;
2680 }
2681 if (cmdp->action == &set_cmd) {
2682
2683 if ((cmdp = find_ctab (set_glob_tab, gbuf)) &&
2684 (cmdp->help))
2685 return help_cmd_output (flag, cmdp->help, cmdp->help_base);
2686 }
2687 else {
2688 SHTAB *shptr = find_shtab (show_glob_tab, gbuf);
2689 if ((shptr == NULL) || (shptr->help == NULL) || (*shptr->help == '\0'))
2690 return SCPE_ARG;
2691 return help_cmd_output (flag, shptr->help, NULL);
2692 }
2693 return SCPE_ARG;
2694 }
2695 else
2696 return SCPE_2MARG;
2697 }
2698 if (cmdp->help) {
2699 if (strcmp (cmdp->name, "HELP") == 0) {
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734 }
2735 else {
2736 if (((cmdp->action == &exdep_cmd) || (0 == strcmp(cmdp->name, "BOOT"))) &&
2737 sim_dflt_dev && sim_dflt_dev->help) {
2738 sim_dflt_dev->help (stdout, sim_dflt_dev, sim_dflt_dev->units, 0, cmdp->name);
2739 if (sim_log)
2740 sim_dflt_dev->help (sim_log, sim_dflt_dev, sim_dflt_dev->units, 0, cmdp->name);
2741 }
2742 }
2743 help_cmd_output (flag, cmdp->help, cmdp->help_base);
2744 }
2745 else {
2746 CTAB *cmdpa;
2747 for (cmdpa=cmd_table; cmdpa->name != NULL; cmdpa++)
2748 if ((cmdpa->action == cmdp->action) && (cmdpa->help)) {
2749 sim_printf ("%s is an alias for the %s command:\n%s",
2750 cmdp->name, cmdpa->name, cmdpa->help);
2751 break;
2752 }
2753 if (cmdpa->name == NULL)
2754 sim_printf ("No help available for the %s command\n", cmdp->name);
2755 }
2756 }
2757 else {
2758 DEVICE *dptr;
2759 UNIT *uptr;
2760 t_stat r;
2761 dptr = find_unit (gbuf, &uptr);
2762 if (dptr == NULL) {
2763 dptr = find_dev (gbuf);
2764 if (dptr == NULL)
2765 return SCPE_ARG;
2766 if (dptr->flags & DEV_DIS)
2767 sim_printf ("Device %s is currently disabled\n", dptr->name);
2768 }
2769 r = help_dev_help (stdout, dptr, uptr, flag, cptr);
2770 if (sim_log)
2771 help_dev_help (sim_log, dptr, uptr, flag | SCP_HELP_FLAT, cptr);
2772 return r;
2773 }
2774 }
2775 else {
2776 fprint_help (stdout);
2777 if (sim_log)
2778 fprint_help (sim_log);
2779 }
2780 return SCPE_OK;
2781 }
2782
2783
2784
2785 t_stat spawn_cmd (int32 flag, CONST char *cptr)
2786 {
2787 t_stat status;
2788 if ((cptr == NULL) || (strlen (cptr) == 0))
2789 cptr = getenv("SHELL");
2790 if ((cptr == NULL) || (strlen (cptr) == 0))
2791 cptr = getenv("ComSpec");
2792 (void)fflush(stdout);
2793 if (sim_log)
2794 (void)fflush (sim_log);
2795 if (sim_deb)
2796 (void)fflush (sim_deb);
2797 status = system (cptr);
2798
2799 return status;
2800 }
2801
2802
2803
2804 t_stat echo_cmd (int32 flag, CONST char *cptr)
2805 {
2806 sim_printf ("%s\n", cptr);
2807 return SCPE_OK;
2808 }
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830 t_stat do_cmd (int32 flag, CONST char *fcptr)
2831 {
2832 return do_cmd_label (flag, fcptr, NULL);
2833 }
2834
2835 static char *do_position(void)
2836 {
2837 static char cbuf[4*CBUFSIZE];
2838
2839 (void)snprintf (cbuf, sizeof (cbuf), "%s%s%s-%d", sim_do_filename[sim_do_depth],
2840 sim_do_label[sim_do_depth] ? "::" : "",
2841 sim_do_label[sim_do_depth] ? sim_do_label[sim_do_depth] : "",
2842 sim_goto_line[sim_do_depth]);
2843 return cbuf;
2844 }
2845
2846 t_stat do_cmd_label (int32 flag, CONST char *fcptr, CONST char *label)
2847 {
2848 char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE], abuf[4*CBUFSIZE], quote, *c, *do_arg[11];
2849 CONST char *cptr;
2850 FILE *fpin;
2851 CTAB *cmdp = NULL;
2852 int32 echo, nargs, errabort, i;
2853 int32 saved_sim_do_echo = sim_do_echo,
2854 saved_sim_show_message = sim_show_message,
2855 saved_sim_on_inherit = sim_on_inherit,
2856 saved_sim_quiet = sim_quiet;
2857 t_bool staying;
2858 t_stat stat, stat_nomessage;
2859
2860 stat = SCPE_OK;
2861 staying = TRUE;
2862 if (flag > 0)
2863 GET_SWITCHES (fcptr);
2864 echo = (sim_switches & SWMASK ('V')) || sim_do_echo;
2865 sim_quiet = (sim_switches & SWMASK ('Q')) || sim_quiet;
2866 sim_on_inherit =(sim_switches & SWMASK ('O')) || sim_on_inherit;
2867 errabort = sim_switches & SWMASK ('E');
2868
2869 abuf[sizeof(abuf)-1] = '\0';
2870 strncpy (abuf, fcptr, sizeof(abuf)-1);
2871 c = abuf;
2872 do_arg[10] = NULL;
2873 for (nargs = 0; nargs < 10; ) {
2874 while (sim_isspace (*c))
2875 c++;
2876 if (*c == 0)
2877 do_arg [nargs++] = NULL;
2878 else {
2879 if (*c == '\'' || *c == '"')
2880 quote = *c++;
2881 else quote = 0;
2882 do_arg[nargs++] = c;
2883 while (*c && (quote ? (*c != quote) : !sim_isspace (*c)))
2884 c++;
2885 if (*c)
2886 *c++ = 0;
2887 }
2888 }
2889
2890 if (do_arg [0] == NULL)
2891 return SCPE_2FARG;
2892 if ((fpin = fopen (do_arg[0], "r")) == NULL) {
2893 strcat (strcpy (cbuf, do_arg[0]), ".ini");
2894 if ((fpin = fopen (cbuf, "r")) == NULL) {
2895 if (flag == 0)
2896 (void)fprintf (stderr, "Can't open file %s\n", do_arg[0]);
2897 return SCPE_OPENERR;
2898 }
2899 }
2900 if (flag >= 0) {
2901 ++sim_do_depth;
2902 if (sim_on_inherit) {
2903 sim_on_check[sim_do_depth] = sim_on_check[sim_do_depth-1];
2904 for (i=0; i<SCPE_MAX_ERR; i++) {
2905 if (sim_on_actions[sim_do_depth-1][i]) {
2906 sim_on_actions[sim_do_depth][i] = (char *)malloc(1+strlen(sim_on_actions[sim_do_depth-1][i]));
2907 if (NULL == sim_on_actions[sim_do_depth][i]) {
2908 while (--i >= 0) {
2909 FREE(sim_on_actions[sim_do_depth][i]);
2910 sim_on_actions[sim_do_depth][i] = NULL;
2911 }
2912 sim_on_check[sim_do_depth] = 0;
2913 sim_brk_clract ();
2914 --sim_do_depth;
2915 fclose(fpin);
2916 return SCPE_MEM;
2917 }
2918 strcpy(sim_on_actions[sim_do_depth][i], sim_on_actions[sim_do_depth-1][i]);
2919 }
2920 }
2921 }
2922 }
2923
2924 strcpy( sim_do_filename[sim_do_depth], do_arg[0]);
2925 sim_do_label[sim_do_depth] = label;
2926 sim_goto_line[sim_do_depth] = 0;
2927 if (label) {
2928 sim_gotofile = fpin;
2929 sim_do_echo = echo;
2930 stat = goto_cmd (0, label);
2931 if (stat != SCPE_OK) {
2932 strcpy(cbuf, "RETURN SCPE_ARG");
2933 cptr = get_glyph (cbuf, gbuf, 0);
2934 cmdp = find_cmd (gbuf);
2935 goto Cleanup_Return;
2936 }
2937 }
2938 if (errabort)
2939 set_on (1, NULL);
2940
2941 do {
2942 sim_do_ocptr[sim_do_depth] = cptr = sim_brk_getact (cbuf, sizeof(cbuf));
2943 if (!sim_do_ocptr[sim_do_depth]) {
2944 sim_do_ocptr[sim_do_depth] = cptr = read_line (cbuf, sizeof(cbuf), fpin);
2945 sim_goto_line[sim_do_depth] += 1;
2946 }
2947 sim_sub_args (cbuf, sizeof(cbuf), do_arg);
2948 if (cptr == NULL) {
2949 stat = SCPE_OK;
2950 break;
2951 }
2952 if (*cptr == 0)
2953 continue;
2954 if (echo)
2955 sim_printf("%s> %s\n", do_position(), cptr);
2956 if (*cptr == ':')
2957 continue;
2958 cptr = get_glyph_cmd (cptr, gbuf);
2959 sim_switches = 0;
2960 sim_gotofile = fpin;
2961 sim_do_echo = echo;
2962 if ((cmdp = find_cmd (gbuf))) {
2963 if (cmdp->action == &return_cmd)
2964 break;
2965 if (cmdp->action == &do_cmd) {
2966 if (sim_do_depth >= MAX_DO_NEST_LVL)
2967 stat = SCPE_NEST;
2968 else
2969 stat = do_cmd (sim_do_depth+1, cptr);
2970 }
2971 else
2972 stat = cmdp->action (cmdp->arg, cptr);
2973 }
2974 else stat = SCPE_UNK;
2975 echo = sim_do_echo;
2976 stat_nomessage = stat & SCPE_NOMESSAGE;
2977 stat_nomessage = stat_nomessage || (!sim_show_message);
2978 stat = SCPE_BARE_STATUS(stat);
2979 if (cmdp)
2980 if (((stat != SCPE_OK) && (stat != SCPE_EXPECT)) ||
2981 ((cmdp->action != &return_cmd) &&
2982 (cmdp->action != &goto_cmd) &&
2983 (cmdp->action != &on_cmd) &&
2984 (cmdp->action != &echo_cmd)))
2985 sim_last_cmd_stat = stat;
2986 switch (stat) {
2987 case SCPE_AFAIL:
2988 staying = (sim_on_check[sim_do_depth] &&
2989 sim_on_actions[sim_do_depth][stat]);
2990 break;
2991 case SCPE_EXIT:
2992 staying = FALSE;
2993 break;
2994 case SCPE_OK:
2995 case SCPE_STEP:
2996 break;
2997 default:
2998 break;
2999 }
3000 if ((stat >= SCPE_BASE) && (stat != SCPE_EXIT) &&
3001 (stat != SCPE_STEP)) {
3002 if (!echo && !sim_quiet &&
3003 !stat_nomessage &&
3004 !(cmdp && cmdp->message)) {
3005 sim_printf("%s> %s\n", do_position(), sim_do_ocptr[sim_do_depth]);
3006 }
3007 }
3008 if (!stat_nomessage) {
3009 if (cmdp && cmdp->message)
3010 cmdp->message ((!echo && !sim_quiet) ? sim_do_ocptr[sim_do_depth] : NULL, stat);
3011 else
3012 if (stat >= SCPE_BASE)
3013 sim_printf ("%s\n", sim_error_text (stat));
3014 }
3015 if (stat == SCPE_EXPECT)
3016 stat = SCPE_OK;
3017 if (staying &&
3018 (sim_on_check[sim_do_depth]) &&
3019 (stat != SCPE_OK) &&
3020 (stat != SCPE_STEP)) {
3021 if ((stat <= SCPE_MAX_ERR) && sim_on_actions[sim_do_depth][stat])
3022 sim_brk_setact (sim_on_actions[sim_do_depth][stat]);
3023 else
3024 sim_brk_setact (sim_on_actions[sim_do_depth][0]);
3025 }
3026 if (sim_vm_post != NULL)
3027 (*sim_vm_post) (TRUE);
3028 } while (staying);
3029 Cleanup_Return:
3030 if (fpin)
3031 fclose (fpin);
3032 sim_gotofile = NULL;
3033 if (flag >= 0) {
3034 sim_do_echo = saved_sim_do_echo;
3035 sim_show_message = saved_sim_show_message;
3036 sim_on_inherit = saved_sim_on_inherit;
3037 }
3038 sim_quiet = saved_sim_quiet;
3039 if ((flag >= 0) || (!sim_on_inherit)) {
3040 for (i=0; i<SCPE_MAX_ERR; i++) {
3041 FREE (sim_on_actions[sim_do_depth][i]);
3042 sim_on_actions[sim_do_depth][i] = NULL;
3043 }
3044 sim_on_check[sim_do_depth] = 0;
3045 }
3046 if (flag >= 0)
3047 --sim_do_depth;
3048 sim_brk_clract ();
3049 if (cmdp && (cmdp->action == &return_cmd) && (0 != *cptr)) {
3050 sim_string_to_stat (cptr, &stat);
3051 sim_last_cmd_stat = stat;
3052 if (sim_switches & SWMASK ('Q'))
3053 stat |= SCPE_NOMESSAGE;
3054 return stat;
3055 }
3056 return stat | SCPE_NOMESSAGE;
3057 }
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101 void sim_sub_args (char *instr, size_t instr_size, char *do_arg[])
3102 {
3103 char gbuf[CBUFSIZE];
3104 char *ip = instr, *op, *oend, *tmpbuf;
3105 const char *ap;
3106 char rbuf[CBUFSIZE];
3107 int i;
3108 time_t now;
3109 struct tm *tmnow;
3110
3111 time(&now);
3112 tmnow = localtime(&now);
3113 tmpbuf = (char *)malloc(instr_size);
3114 if (!tmpbuf)
3115 {
3116 (void)fprintf(stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
3117 __func__, __FILE__, __LINE__);
3118 #if defined(USE_BACKTRACE)
3119 # if defined(SIGUSR2)
3120 (void)raise(SIGUSR2);
3121
3122 # endif
3123 #endif
3124 abort();
3125 }
3126 op = tmpbuf;
3127 oend = tmpbuf + instr_size - 2;
3128 while (sim_isspace (*ip))
3129 *op++ = *ip++;
3130 for (; *ip && (op < oend); ) {
3131 if ((ip [0] == '\\') &&
3132 ((ip [1] == '%') || (ip [1] == '\\'))) {
3133 ip++;
3134 *op++ = *ip++;
3135 }
3136 else
3137 if ((*ip == '%') &&
3138 (sim_isalnum(ip[1]) || (ip[1] == '*') || (ip[1] == '_'))) {
3139 if ((ip[1] >= '0') && (ip[1] <= ('9'))) {
3140 ap = do_arg[ip[1] - '0'];
3141 for (i=0; i<ip[1] - '0'; ++i)
3142 if (do_arg[i] == NULL) {
3143 ap = NULL;
3144 break;
3145 }
3146 ip = ip + 2;
3147 }
3148 else if (ip[1] == '*') {
3149 (void)memset (rbuf, '\0', sizeof(rbuf));
3150 ap = rbuf;
3151 for (i=1; i<=9; ++i)
3152 if (do_arg[i] == NULL)
3153 break;
3154 else
3155 if ((sizeof(rbuf)-strlen(rbuf)) < (2 + strlen(do_arg[i]))) {
3156 if (strchr(do_arg[i], ' ')) {
3157 char quote = '"';
3158 if (strchr(do_arg[i], quote))
3159 quote = '\'';
3160 (void)sprintf(&rbuf[strlen(rbuf)], "%s%c%s%c\"",
3161 (i != 1) ? " " : "", quote,
3162 do_arg[i], quote);
3163 }
3164 else
3165 (void)sprintf(&rbuf[strlen(rbuf)], "%s%s",
3166 (i != 1) ? " " : "", do_arg[i]);
3167 }
3168 else
3169 break;
3170 ip = ip + 2;
3171 }
3172 else {
3173 ap = NULL;
3174 (void)get_glyph_nc (ip+1, gbuf, '%');
3175 ap = getenv(gbuf);
3176 if (!ap) {
3177 (void)get_glyph (ip+1, gbuf, '%');
3178 ap = getenv(gbuf);
3179 }
3180 ip += 1 + strlen (gbuf);
3181 if (*ip == '%') ++ip;
3182 if (!ap) {
3183
3184 if (!strcmp ("DATE", gbuf)) {
3185 (void)sprintf (rbuf, "%4d-%02d-%02d",
3186 tmnow->tm_year + 1900,
3187 tmnow->tm_mon + 1,
3188 tmnow->tm_mday);
3189 ap = rbuf;
3190 }
3191 else if (!strcmp ("TIME", gbuf)) {
3192 (void)sprintf (rbuf, "%02d:%02d:%02d",
3193 tmnow->tm_hour,
3194 tmnow->tm_min,
3195 tmnow->tm_sec);
3196 ap = rbuf;
3197 }
3198 else if (!strcmp ("DATETIME", gbuf)) {
3199 (void)sprintf (rbuf, "%04d-%02d-%02dT%02d:%02d:%02d",
3200 tmnow->tm_year + 1900,
3201 tmnow->tm_mon + 1,
3202 tmnow->tm_mday,
3203 tmnow->tm_hour,
3204 tmnow->tm_min,
3205 tmnow->tm_sec);
3206 ap = rbuf;
3207 }
3208
3209 if (!strcmp ("LDATE", gbuf)) {
3210 strftime (rbuf, sizeof(rbuf), "%x", tmnow);
3211 ap = rbuf;
3212 }
3213 else if (!strcmp ("LTIME", gbuf)) {
3214 strftime (rbuf, sizeof(rbuf), "%I:%M:%S %p", tmnow);
3215 ap = rbuf;
3216 }
3217 else if (!strcmp ("CTIME", gbuf)) {
3218 strftime (rbuf, sizeof(rbuf), "%c", tmnow);
3219 ap = rbuf;
3220 }
3221
3222 else if (!strcmp ("DATE_YYYY", gbuf)) {
3223 strftime (rbuf, sizeof(rbuf), "%Y", tmnow);
3224 ap = rbuf;
3225 }
3226 else if (!strcmp ("DATE_YY", gbuf)) {
3227 strftime (rbuf, sizeof(rbuf), "%y", tmnow);
3228 ap = rbuf;
3229 }
3230 else if (!strcmp ("DATE_YC", gbuf)) {
3231 (void)sprintf (rbuf, "%d", (tmnow->tm_year + 1900)/100);
3232 ap = rbuf;
3233 }
3234 else if ((!strcmp ("DATE_19XX_YY", gbuf)) ||
3235 (!strcmp ("DATE_19XX_YYYY", gbuf))) {
3236 int year = tmnow->tm_year + 1900;
3237 int days = year - 2001;
3238 int leaps = days/4 - days/100 + days/400;
3239 int lyear = ((year % 4) == 0) && (((year % 100) != 0) || ((year % 400) == 0));
3240 int selector = ((days + leaps + 7) % 7) + lyear * 7;
3241 static int years[] = {90, 91, 97, 98, 99, 94, 89,
3242 96, 80, 92, 76, 88, 72, 84};
3243 int cal_year = years[selector];
3244
3245 if (!strcmp ("DATE_19XX_YY", gbuf))
3246 (void)sprintf (rbuf, "%d", cal_year);
3247 else
3248 (void)sprintf (rbuf, "%d", cal_year + 1900);
3249 ap = rbuf;
3250 }
3251 else if (!strcmp ("DATE_MM", gbuf)) {
3252 strftime (rbuf, sizeof(rbuf), "%m", tmnow);
3253 ap = rbuf;
3254 }
3255 else if (!strcmp ("DATE_MMM", gbuf)) {
3256 strftime (rbuf, sizeof(rbuf), "%b", tmnow);
3257 ap = rbuf;
3258 }
3259 else if (!strcmp ("DATE_DD", gbuf)) {
3260 strftime (rbuf, sizeof(rbuf), "%d", tmnow);
3261 ap = rbuf;
3262 }
3263 else if (!strcmp ("DATE_D", gbuf)) {
3264 (void)sprintf (rbuf, "%d", (tmnow->tm_wday ? tmnow->tm_wday : 7));
3265 ap = rbuf;
3266 }
3267 else if ((!strcmp ("DATE_WW", gbuf)) ||
3268 (!strcmp ("DATE_WYYYY", gbuf))) {
3269 int iso_yr = tmnow->tm_year + 1900;
3270 int iso_wk = (tmnow->tm_yday + 11 - (tmnow->tm_wday ? tmnow->tm_wday : 7))/7;;
3271
3272 if (iso_wk == 0) {
3273 iso_yr = iso_yr - 1;
3274 tmnow->tm_yday += 365 + (((iso_yr % 4) == 0) ? 1 : 0);
3275 iso_wk = (tmnow->tm_yday + 11 - (tmnow->tm_wday ? tmnow->tm_wday : 7))/7;
3276 }
3277 else
3278 if ((iso_wk == 53) && (((31 - tmnow->tm_mday) + tmnow->tm_wday) < 4)) {
3279 ++iso_yr;
3280 iso_wk = 1;
3281 }
3282 if (!strcmp ("DATE_WW", gbuf))
3283 (void)sprintf (rbuf, "%02d", iso_wk);
3284 else
3285 (void)sprintf (rbuf, "%04d", iso_yr);
3286 ap = rbuf;
3287 }
3288 else if (!strcmp ("DATE_JJJ", gbuf)) {
3289 strftime (rbuf, sizeof(rbuf), "%j", tmnow);
3290 ap = rbuf;
3291 }
3292 else if (!strcmp ("TIME_HH", gbuf)) {
3293 strftime (rbuf, sizeof(rbuf), "%H", tmnow);
3294 ap = rbuf;
3295 }
3296 else if (!strcmp ("TIME_MM", gbuf)) {
3297 strftime (rbuf, sizeof(rbuf), "%M", tmnow);
3298 ap = rbuf;
3299 }
3300 else if (!strcmp ("TIME_SS", gbuf)) {
3301 strftime (rbuf, sizeof(rbuf), "%S", tmnow);
3302 ap = rbuf;
3303 }
3304 else if (!strcmp ("STATUS", gbuf)) {
3305 (void)sprintf (rbuf, "%08X", sim_last_cmd_stat);
3306 ap = rbuf;
3307 }
3308 else if (!strcmp ("TSTATUS", gbuf)) {
3309 (void)sprintf (rbuf, "%s", sim_error_text (sim_last_cmd_stat));
3310 ap = rbuf;
3311 }
3312 else if (!strcmp ("SIM_VERIFY", gbuf)) {
3313 (void)sprintf (rbuf, "%s", sim_do_echo ? "-V" : "");
3314 ap = rbuf;
3315 }
3316 else if (!strcmp ("SIM_VERBOSE", gbuf)) {
3317 (void)sprintf (rbuf, "%s", sim_do_echo ? "-V" : "");
3318 ap = rbuf;
3319 }
3320 else if (!strcmp ("SIM_LOCALOPC", gbuf)) {
3321 (void)sprintf (rbuf, "%s", sim_localopc ? "1" : "");
3322 ap = rbuf;
3323 }
3324 else if (!strcmp ("SIM_QUIET", gbuf)) {
3325 (void)sprintf (rbuf, "%s", sim_quiet ? "-Q" : "");
3326 ap = rbuf;
3327 }
3328 else if (!strcmp ("SIM_MESSAGE", gbuf)) {
3329 (void)sprintf (rbuf, "%s", sim_show_message ? "" : "-Q");
3330 ap = rbuf;
3331 }
3332 else if (!strcmp ("HOSTID", gbuf)) {
3333 #if defined(HAVE_UNISTD) && !defined(__HAIKU__) && !defined(__ANDROID__) && !defined(__serenity__)
3334 (void)sprintf (rbuf, "%ld", (long)gethostid());
3335 #else
3336 (void)sprintf (rbuf, "00000000");
3337 #endif
3338 ap = rbuf;
3339 }
3340 else if (!strcmp ("UID", gbuf)) {
3341 #if defined(HAVE_UNISTD)
3342 (void)sprintf (rbuf, "%ld", (long)getuid());
3343 #else
3344 (void)sprintf (rbuf, "0");
3345 #endif
3346 ap = rbuf;
3347 }
3348 else if (!strcmp ("GID", gbuf)) {
3349 #if defined(HAVE_UNISTD)
3350 (void)sprintf (rbuf, "%ld", (long)getgid());
3351 #else
3352 (void)sprintf (rbuf, "0");
3353 #endif
3354 ap = rbuf;
3355 }
3356 else if (!strcmp ("EUID", gbuf)) {
3357 #if defined(HAVE_UNISTD)
3358 (void)sprintf (rbuf, "%ld", (long)geteuid());
3359 #else
3360 (void)sprintf (rbuf, "0");
3361 #endif
3362 ap = rbuf;
3363 }
3364 else if (!strcmp ("EGID", gbuf)) {
3365 #if defined(HAVE_UNISTD)
3366 (void)sprintf (rbuf, "%ld", (long)getegid());
3367 #else
3368 (void)sprintf (rbuf, "0");
3369 #endif
3370 ap = rbuf;
3371 }
3372 else if (!strcmp ("PID", gbuf)) {
3373 #if defined(HAVE_UNISTD)
3374 (void)sprintf (rbuf, "%ld", (long)getpid());
3375 #else
3376 (void)sprintf (rbuf, "0");
3377 #endif
3378 ap = rbuf;
3379 }
3380 else if (!strcmp ("PPID", gbuf)) {
3381 #if defined(HAVE_UNISTD)
3382 (void)sprintf (rbuf, "%ld", (long)getppid());
3383 #else
3384 (void)sprintf (rbuf, "0");
3385 #endif
3386 ap = rbuf;
3387 }
3388 else if (!strcmp ("PGID", gbuf)) {
3389 #if defined(HAVE_UNISTD)
3390 (void)sprintf (rbuf, "%ld", (long)getpgid(getpid()));
3391 #else
3392 (void)sprintf (rbuf, "0");
3393 #endif
3394 ap = rbuf;
3395 }
3396 else if (!strcmp ("SID", gbuf)) {
3397 #if defined(HAVE_UNISTD)
3398 (void)sprintf (rbuf, "%ld", (long)getsid(getpid()));
3399 #else
3400 (void)sprintf (rbuf, "0");
3401 #endif
3402 ap = rbuf;
3403 }
3404 else if (!strcmp ("ENDIAN", gbuf)) {
3405 #if ( defined(DECLITEND) && DECLITEND == 1 )
3406 (void)sprintf (rbuf, "LITTLE");
3407 #elif ( defined(DECLITEND) && DECLITEND == 0 )
3408 (void)sprintf (rbuf, "BIG");
3409 #else
3410 (void)sprintf (rbuf, "UNKNOWN");
3411 #endif
3412 ap = rbuf;
3413 }
3414 else if (!strcmp("SIM_NAME", gbuf)) {
3415 (void)sprintf (rbuf, "%s", sim_name);
3416 ap = rbuf;
3417 }
3418 else if (!strcmp("SIM_VERSION", gbuf)) {
3419 #if defined(VER_H_GIT_VERSION)
3420 (void)sprintf (rbuf, "%s", VER_H_GIT_VERSION);
3421 #else
3422 (void)sprintf (rbuf, "UNKNOWN");
3423 #endif
3424 ap = rbuf;
3425 }
3426 else if (!strcmp("SIM_HASH", gbuf)) {
3427 #if defined(VER_H_GIT_HASH)
3428 (void)sprintf (rbuf, "%s", VER_H_GIT_HASH);
3429 #else
3430 (void)sprintf (rbuf, "0000000000000000000000000000000000000000");
3431 #endif
3432 ap = rbuf;
3433 }
3434 else if (!strcmp("SIM_RELT", gbuf)) {
3435 #if defined(VER_H_GIT_RELT)
3436 (void)sprintf (rbuf, "%s", VER_H_GIT_RELT);
3437 #else
3438 (void)sprintf (rbuf, "X");
3439 #endif
3440 ap = rbuf;
3441 }
3442 else if (!strcmp("SIM_DATE", gbuf)) {
3443 #if defined(VER_H_GIT_DATE)
3444 (void)sprintf (rbuf, "%s", VER_H_GIT_DATE);
3445 #else
3446 (void)sprintf (rbuf, "UNKNOWN");
3447 #endif
3448 ap = rbuf;
3449 }
3450 else if ( (!strcmp("CPUS", gbuf)) \
3451 || (!strcmp("PROCESSORS", gbuf) ) ) {
3452 #if defined(LINUX_OS) && !defined(__ANDROID__)
3453 (void)sprintf(rbuf, "%ld", (long)get_nprocs());
3454 #elif defined(__HAIKU__)
3455 system_info hinfo;
3456 get_system_info(&hinfo);
3457 (void)sprintf (rbuf, "%llu",
3458 (long long unsigned int)hinfo.cpu_count);
3459 #else
3460 (void)sprintf(rbuf, "1");
3461 #endif
3462 ap = rbuf;
3463 }
3464 }
3465 }
3466 if (ap) {
3467 while (*ap && (op < oend))
3468 *op++ = *ap++;
3469 }
3470 }
3471 else
3472 *op++ = *ip++;
3473 }
3474 *op = 0;
3475 strcpy (instr, tmpbuf);
3476 FREE (tmpbuf);
3477 return;
3478 }
3479
3480 static
3481 int sim_cmp_string (const char *s1, const char *s2)
3482 {
3483 long int v1, v2;
3484 char *ep1, *ep2;
3485
3486 v1 = strtol(s1+1, &ep1, 0);
3487 v2 = strtol(s2+1, &ep2, 0);
3488 if ((ep1 != s1 + strlen (s1) - 1) ||
3489 (ep2 != s2 + strlen (s2) - 1))
3490 return strcmp (s1, s2);
3491 if (v1 == v2)
3492 return 0;
3493 if (v1 < v2)
3494 return -1;
3495 return 1;
3496 }
3497
3498
3499
3500 t_stat assert_cmd (int32 flag, CONST char *cptr)
3501 {
3502 char gbuf[CBUFSIZE], gbuf2[CBUFSIZE];
3503 CONST char *tptr, *gptr;
3504 REG *rptr;
3505 uint32 idx = 0;
3506 t_value val;
3507 t_stat r;
3508 t_bool Not = FALSE;
3509 t_bool result;
3510 t_addr addr = 0;
3511 t_stat reason;
3512
3513 cptr = (CONST char *)get_sim_opt (CMD_OPT_SW|CMD_OPT_DFT, (CONST char *)cptr, &r);
3514
3515 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3516 # pragma diagnostic push
3517 # pragma diag_suppress = integer_sign_change
3518 #endif
3519 sim_stabr.boolop = sim_staba.boolop = -1;
3520 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3521 # pragma diagnostic pop
3522 #endif
3523 if (*cptr == 0)
3524 return SCPE_2FARG;
3525 tptr = get_glyph (cptr, gbuf, 0);
3526 if (!strcmp (gbuf, "NOT")) {
3527 Not = TRUE;
3528 cptr = (CONST char *)tptr;
3529 }
3530 if (*cptr == '"') {
3531 char op[CBUFSIZE];
3532 static struct {
3533 const char *op;
3534 int aval;
3535 int bval;
3536 t_bool invert;
3537 } *optr, compare_ops[] =
3538 {
3539 { "==", 0, 0, FALSE },
3540 { "EQU", 0, 0, FALSE },
3541 { "!=", 0, 0, TRUE },
3542 { "NEQ", 0, 0, TRUE },
3543 { "<", -1, -1, FALSE },
3544 { "LSS", -1, -1, FALSE },
3545 { "<=", 0, -1, FALSE },
3546 { "LEQ", 0, -1, FALSE },
3547 { ">", 1, 1, FALSE },
3548 { "GTR", 1, 1, FALSE },
3549 { ">=", 0, 1, FALSE },
3550 { "GEQ", 0, 1, FALSE },
3551 { NULL }
3552 };
3553
3554 tptr = (CONST char *)get_glyph_gen (cptr, gbuf, '=', (sim_switches & SWMASK ('I')), TRUE, '\\');
3555
3556 if (!*tptr)
3557 return SCPE_2FARG;
3558 cptr += strlen (gbuf);
3559 while (sim_isspace (*cptr))
3560 ++cptr;
3561 (void)get_glyph (cptr, op, '"');
3562 for (optr = compare_ops; optr->op; optr++)
3563 if (0 == strcmp (op, optr->op))
3564 break;
3565 if (!optr->op)
3566 return sim_messagef (SCPE_ARG, "Invalid operator: %s\n", op);
3567 cptr += strlen (op);
3568 while (sim_isspace (*cptr))
3569 ++cptr;
3570 cptr = (CONST char *)get_glyph_gen (cptr, gbuf2, 0, (sim_switches & SWMASK ('I')), TRUE, '\\');
3571
3572 if (*cptr) {
3573 if (flag)
3574 return SCPE_2MARG;
3575 }
3576 else {
3577 if (!flag)
3578 return SCPE_2FARG;
3579 }
3580 result = sim_cmp_string (gbuf, gbuf2);
3581 result = ((result == optr->aval) || (result == optr->bval));
3582 if (optr->invert)
3583 result = !result;
3584 }
3585 else {
3586 cptr = get_glyph (cptr, gbuf, 0);
3587 rptr = find_reg (gbuf, &gptr, sim_dfdev);
3588 if (rptr) {
3589 if (*gptr == '[') {
3590 if (rptr->depth <= 1)
3591 return SCPE_ARG;
3592 idx = (uint32) strtotv (++gptr, &tptr, 10);
3593 if ((gptr == tptr) || (*tptr++ != ']'))
3594 return SCPE_ARG;
3595 gptr = tptr;
3596 }
3597 else idx = 0;
3598 if (idx >= rptr->depth)
3599 return SCPE_SUB;
3600 }
3601 else {
3602 if (sim_dfdev && sim_vm_parse_addr)
3603 addr = sim_vm_parse_addr (sim_dfdev, gbuf, &gptr);
3604 else
3605 addr = (t_addr) strtotv (gbuf, &gptr, sim_dfdev ? sim_dfdev->dradix : sim_dflt_dev->dradix);
3606 if (gbuf == gptr)
3607 return SCPE_NXREG;
3608 }
3609 if (*gptr != 0)
3610 (void)get_glyph (gptr, gbuf, 0);
3611 else {
3612 if (*cptr == 0)
3613 return SCPE_2FARG;
3614 cptr = get_glyph (cptr, gbuf, 0);
3615 }
3616 if (*cptr) {
3617 if (flag)
3618 return SCPE_2MARG;
3619 }
3620 else {
3621 if (!flag)
3622 return SCPE_2FARG;
3623 }
3624 if (rptr) {
3625 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3626 # pragma diagnostic push
3627 # pragma diag_suppress = integer_sign_change
3628 #endif
3629 if (!get_rsearch (gbuf, rptr->radix, &sim_stabr) ||
3630 (sim_stabr.boolop == -1))
3631 return SCPE_MISVAL;
3632 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3633 # pragma diagnostic pop
3634 #endif
3635 val = get_rval (rptr, idx);
3636 result = test_search (&val, &sim_stabr);
3637 }
3638 else {
3639 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3640 # pragma diagnostic push
3641 # pragma diag_suppress = integer_sign_change
3642 #endif
3643 if (!get_asearch (gbuf, sim_dfdev->dradix, &sim_staba) ||
3644 (sim_staba.boolop == -1))
3645 return SCPE_MISVAL;
3646 #if defined(__NVCOMPILER) || defined(__NVCOMPILER_LLVM__) || defined(__PGI) || defined(__PGLLVM__)
3647 # pragma diagnostic pop
3648 #endif
3649 reason = get_aval (addr, sim_dfdev, sim_dfunit);
3650 if (reason != SCPE_OK)
3651 return reason;
3652 result = test_search (sim_eval, &sim_staba);
3653 }
3654 }
3655 if (Not ^ result) {
3656 if (!flag)
3657 sim_brk_setact (cptr);
3658 }
3659 else
3660 if (flag)
3661 return SCPE_AFAIL;
3662 return SCPE_OK;
3663 }
3664
3665
3666
3667 t_stat send_cmd (int32 flag, CONST char *cptr)
3668 {
3669 char gbuf[CBUFSIZE];
3670 CONST char *tptr;
3671 uint8 dbuf[CBUFSIZE];
3672 uint32 dsize = 0;
3673 uint32 delay = 0;
3674 uint32 after = 0;
3675 t_stat r;
3676 SEND *snd = NULL;
3677
3678 GET_SWITCHES (cptr);
3679 tptr = get_glyph (cptr, gbuf, ',');
3680 if (sim_isalpha(gbuf[0]) && (strchr (gbuf, ':'))) {
3681 r = tmxr_locate_line_send (gbuf, &snd);
3682 if (r != SCPE_OK)
3683 return r;
3684 cptr = tptr;
3685 tptr = get_glyph (tptr, gbuf, ',');
3686 }
3687 else
3688 snd = sim_cons_get_send ();
3689
3690 while (*cptr) {
3691 if ((!strncmp(gbuf, "DELAY=", 6)) && (gbuf[6])) {
3692 delay = (uint32)get_uint (&gbuf[6], 10, 2000000000, &r);
3693 if (r != SCPE_OK)
3694 return sim_messagef (SCPE_ARG, "Invalid Delay Value\n");
3695 cptr = tptr;
3696 tptr = get_glyph (cptr, gbuf, ',');
3697 continue;
3698 }
3699 if ((!strncmp(gbuf, "AFTER=", 6)) && (gbuf[6])) {
3700 after = (uint32)get_uint (&gbuf[6], 10, 2000000000, &r);
3701 if (r != SCPE_OK)
3702 return sim_messagef (SCPE_ARG, "Invalid After Value\n");
3703 cptr = tptr;
3704 tptr = get_glyph (cptr, gbuf, ',');
3705 continue;
3706 }
3707 if ((*cptr == '"') || (*cptr == '\''))
3708 break;
3709 return SCPE_ARG;
3710 }
3711 if (*cptr) {
3712 if ((*cptr != '"') && (*cptr != '\''))
3713 return sim_messagef (SCPE_ARG, "String must be quote delimited\n");
3714 cptr = get_glyph_quoted (cptr, gbuf, 0);
3715 if (*cptr != '\0')
3716 return SCPE_2MARG;
3717
3718 if (SCPE_OK != sim_decode_quoted_string (gbuf, dbuf, &dsize))
3719 return sim_messagef (SCPE_ARG, "Invalid String\n");
3720 }
3721 if ((dsize == 0) && (delay == 0) && (after == 0))
3722 return SCPE_2FARG;
3723 return sim_send_input (snd, dbuf, dsize, after, delay);
3724 }
3725
3726 t_stat sim_show_send (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
3727 {
3728 char gbuf[CBUFSIZE];
3729 CONST char *tptr;
3730 t_stat r;
3731 SEND *snd = NULL;
3732
3733 tptr = get_glyph (cptr, gbuf, ',');
3734 if (sim_isalpha(gbuf[0]) && (strchr (gbuf, ':'))) {
3735 r = tmxr_locate_line_send (gbuf, &snd);
3736 if (r != SCPE_OK)
3737 return r;
3738 cptr = tptr;
3739 }
3740 else
3741 snd = sim_cons_get_send ();
3742 if (*cptr)
3743 return SCPE_2MARG;
3744 return sim_show_send_input (st, snd);
3745 }
3746
3747 t_stat expect_cmd (int32 flag, CONST char *cptr)
3748 {
3749 char gbuf[CBUFSIZE];
3750 CONST char *tptr;
3751 EXPECT *exp = NULL;
3752
3753 GET_SWITCHES (cptr);
3754 tptr = get_glyph (cptr, gbuf, ',');
3755 if (sim_isalpha(gbuf[0]) && (strchr (gbuf, ':'))) {
3756 cptr = tptr;
3757 }
3758 else
3759 exp = sim_cons_get_expect ();
3760 if (flag)
3761 return sim_set_expect (exp, cptr);
3762 else
3763 return sim_set_noexpect (exp, cptr);
3764 }
3765
3766 t_stat sim_show_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
3767 {
3768 char gbuf[CBUFSIZE];
3769 CONST char *tptr;
3770 EXPECT *exp = NULL;
3771 t_stat r;
3772
3773 tptr = get_glyph (cptr, gbuf, ',');
3774 if (sim_isalpha(gbuf[0]) && (strchr (gbuf, ':'))) {
3775 r = tmxr_locate_line_expect (gbuf, &exp);
3776 if (r != SCPE_OK)
3777 return r;
3778 cptr = tptr;
3779 }
3780 else
3781 exp = sim_cons_get_expect ();
3782 if (*cptr && (*cptr != '"') && (*cptr != '\''))
3783 return SCPE_ARG;
3784 tptr = get_glyph_quoted (cptr, gbuf, 0);
3785 if (*tptr != '\0')
3786 return SCPE_2MARG;
3787 if (*cptr && (cptr[strlen(cptr)-1] != '"') && (cptr[strlen(cptr)-1] != '\''))
3788 return SCPE_ARG;
3789 return sim_exp_show (st, exp, gbuf);
3790 }
3791
3792
3793
3794 t_stat goto_cmd (int32 flag, CONST char *fcptr)
3795 {
3796 char cbuf[CBUFSIZE], gbuf[CBUFSIZE], gbuf1[CBUFSIZE];
3797 const char *cptr;
3798 long fpos;
3799 int32 saved_do_echo = sim_do_echo;
3800 int32 saved_goto_line = sim_goto_line[sim_do_depth];
3801
3802 if (NULL == sim_gotofile) return SCPE_UNK;
3803 (void)get_glyph (fcptr, gbuf1, 0);
3804 if ('\0' == gbuf1[0]) return SCPE_ARG;
3805 fpos = ftell(sim_gotofile);
3806 rewind(sim_gotofile);
3807 sim_goto_line[sim_do_depth] = 0;
3808 sim_do_echo = 0;
3809 while (1) {
3810 cptr = read_line (cbuf, sizeof(cbuf), sim_gotofile);
3811 if (cptr == NULL) break;
3812 sim_goto_line[sim_do_depth] += 1;
3813 if (*cptr == 0) continue;
3814 if (*cptr != ':') continue;
3815 ++cptr;
3816 while (sim_isspace (*cptr)) ++cptr;
3817 cptr = get_glyph (cptr, gbuf, 0);
3818 if (0 == strcmp(gbuf, gbuf1)) {
3819 sim_brk_clract ();
3820 sim_do_echo = saved_do_echo;
3821 if (sim_do_echo)
3822 sim_printf("%s> %s\n", do_position(), cbuf);
3823 return SCPE_OK;
3824 }
3825 }
3826 sim_do_echo = saved_do_echo;
3827 fseek(sim_gotofile, fpos, SEEK_SET);
3828 sim_goto_line[sim_do_depth] = saved_goto_line;
3829 return SCPE_ARG;
3830 }
3831
3832
3833
3834
3835
3836
3837
3838
3839 t_stat return_cmd (int32 flag, CONST char *fcptr)
3840 {
3841 return SCPE_UNK;
3842 }
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852 t_stat shift_cmd (int32 flag, CONST char *fcptr)
3853 {
3854 return SCPE_UNK;
3855 }
3856
3857
3858
3859
3860
3861
3862
3863
3864 t_stat call_cmd (int32 flag, CONST char *fcptr)
3865 {
3866 char cbuf[2*CBUFSIZE], gbuf[CBUFSIZE];
3867 const char *cptr;
3868
3869 if (NULL == sim_gotofile) return SCPE_UNK;
3870 cptr = get_glyph (fcptr, gbuf, 0);
3871 if ('\0' == gbuf[0]) return SCPE_ARG;
3872 (void)snprintf(cbuf, sizeof (cbuf), "%s %s", sim_do_filename[sim_do_depth], cptr);
3873 sim_switches |= SWMASK ('O');
3874 return do_cmd_label (flag, cbuf, gbuf);
3875 }
3876
3877
3878
3879 t_stat on_cmd (int32 flag, CONST char *cptr)
3880 {
3881 char gbuf[CBUFSIZE];
3882 t_stat cond;
3883
3884 cptr = get_glyph (cptr, gbuf, 0);
3885 if ('\0' == gbuf[0]) return SCPE_ARG;
3886 if (0 == strcmp("ERROR", gbuf))
3887 cond = 0;
3888 else
3889 if (SCPE_OK != sim_string_to_stat (gbuf, &cond))
3890 return SCPE_ARG;
3891 if ((NULL == cptr) || ('\0' == *cptr)) {
3892 FREE(sim_on_actions[sim_do_depth][cond]);
3893 sim_on_actions[sim_do_depth][cond] = NULL; }
3894 else {
3895 sim_on_actions[sim_do_depth][cond] =
3896 (char *)realloc(sim_on_actions[sim_do_depth][cond], 1+strlen(cptr));
3897 if (!sim_on_actions[sim_do_depth][cond])
3898 {
3899 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
3900 __func__, __FILE__, __LINE__);
3901 #if defined(USE_BACKTRACE)
3902 # if defined(SIGUSR2)
3903 (void)raise(SIGUSR2);
3904
3905 # endif
3906 #endif
3907 abort();
3908 }
3909 strcpy(sim_on_actions[sim_do_depth][cond], cptr);
3910 }
3911 return SCPE_OK;
3912 }
3913
3914
3915
3916 t_stat noop_cmd (int32 flag, CONST char *cptr)
3917 {
3918 if (cptr && (*cptr != 0))
3919 return SCPE_2MARG;
3920 return SCPE_OK;
3921 }
3922
3923
3924
3925 t_stat set_on (int32 flag, CONST char *cptr)
3926 {
3927 if ((flag) && (cptr) && (*cptr)) {
3928 char gbuf[CBUFSIZE];
3929
3930 cptr = get_glyph (cptr, gbuf, 0);
3931 if (((MATCH_CMD(gbuf,"INHERIT")) &&
3932 (MATCH_CMD(gbuf,"NOINHERIT"))) ||
3933 (*cptr))
3934 return SCPE_2MARG;
3935 if ((gbuf[0]) && (0 == MATCH_CMD(gbuf,"INHERIT")))
3936 sim_on_inherit = 1;
3937 if ((gbuf[0]) && (0 == MATCH_CMD(gbuf,"NOINHERIT")))
3938 sim_on_inherit = 0;
3939 return SCPE_OK;
3940 }
3941 if (cptr && (*cptr != 0))
3942 return SCPE_2MARG;
3943 sim_on_check[sim_do_depth] = flag;
3944 if ((sim_do_depth != 0) &&
3945 (NULL == sim_on_actions[sim_do_depth][0])) {
3946 sim_on_actions[sim_do_depth][0] =
3947 (char *)malloc(1+strlen("RETURN"));
3948 strcpy(sim_on_actions[sim_do_depth][0], "RETURN");
3949 }
3950 if ((sim_do_depth != 0) &&
3951 (NULL == sim_on_actions[sim_do_depth][SCPE_AFAIL])) {
3952 sim_on_actions[sim_do_depth][SCPE_AFAIL] =
3953 (char *)malloc(1+strlen("RETURN"));
3954 strcpy(sim_on_actions[sim_do_depth][SCPE_AFAIL], "RETURN");
3955 }
3956 return SCPE_OK;
3957 }
3958
3959
3960
3961 t_stat set_verify (int32 flag, CONST char *cptr)
3962 {
3963 if (cptr && (*cptr != 0))
3964 return SCPE_2MARG;
3965 if (flag == sim_do_echo)
3966 return SCPE_OK;
3967 sim_do_echo = flag;
3968 return SCPE_OK;
3969 }
3970
3971
3972
3973 t_stat set_message (int32 flag, CONST char *cptr)
3974 {
3975 if (cptr && (*cptr != 0))
3976 return SCPE_2MARG;
3977 if (flag == sim_show_message)
3978 return SCPE_OK;
3979 sim_show_message = flag;
3980 return SCPE_OK;
3981 }
3982
3983
3984
3985 t_stat set_localopc (int32 flag, CONST char *cptr)
3986 {
3987 if (cptr && (*cptr != 0))
3988 return SCPE_2MARG;
3989 if (flag == sim_localopc)
3990 return SCPE_OK;
3991 sim_localopc = flag;
3992 return SCPE_OK;
3993 }
3994
3995
3996 t_stat set_quiet (int32 flag, CONST char *cptr)
3997 {
3998 if (cptr && (*cptr != 0))
3999 return SCPE_2MARG;
4000 if (flag == sim_quiet)
4001 return SCPE_OK;
4002 sim_quiet = flag;
4003 return SCPE_OK;
4004 }
4005
4006
4007
4008 t_stat sim_set_environment (int32 flag, CONST char *cptr)
4009 {
4010 char varname[CBUFSIZE];
4011
4012 if ((NULL == cptr) || (*cptr == 0))
4013 return SCPE_2FARG;
4014 cptr = get_glyph (cptr, varname, '=');
4015 setenv(varname, cptr, 1);
4016 return SCPE_OK;
4017 }
4018
4019
4020
4021 t_stat set_cmd (int32 flag, CONST char *cptr)
4022 {
4023 uint32 lvl = 0;
4024 t_stat r;
4025 char gbuf[CBUFSIZE], *cvptr;
4026 CONST char *svptr;
4027 DEVICE *dptr;
4028 UNIT *uptr;
4029 MTAB *mptr;
4030 CTAB *gcmdp;
4031 C1TAB *ctbr = NULL, *glbr;
4032
4033 GET_SWITCHES (cptr);
4034 if ((NULL == cptr) || (*cptr == 0))
4035 return SCPE_2FARG;
4036 cptr = get_glyph (svptr = cptr, gbuf, 0);
4037
4038 if ((dptr = find_dev (gbuf))) {
4039 uptr = dptr->units;
4040 ctbr = set_dev_tab;
4041 lvl = MTAB_VDV;
4042 GET_SWITCHES (cptr);
4043 }
4044 else if ((dptr = find_unit (gbuf, &uptr))) {
4045 if (uptr == NULL)
4046 return SCPE_NXUN;
4047 ctbr = set_unit_tab;
4048 lvl = MTAB_VUN;
4049 GET_SWITCHES (cptr);
4050 }
4051 else if ((gcmdp = find_ctab (set_glob_tab, gbuf))) {
4052 GET_SWITCHES (cptr);
4053 return gcmdp->action (gcmdp->arg, cptr);
4054 }
4055 else {
4056 if (sim_dflt_dev && sim_dflt_dev->modifiers) {
4057 if ((cvptr = strchr (gbuf, '=')))
4058 *cvptr++ = 0;
4059 for (mptr = sim_dflt_dev->modifiers; mptr->mask != 0; mptr++) {
4060 if (mptr->mstring && (MATCH_CMD (gbuf, mptr->mstring) == 0)) {
4061 dptr = sim_dflt_dev;
4062 cptr = svptr;
4063 while (sim_isspace(*cptr))
4064 ++cptr;
4065 break;
4066 }
4067 }
4068 }
4069 if (!dptr)
4070 return SCPE_NXDEV;
4071 lvl = MTAB_VDV;
4072 uptr = dptr->units;
4073 }
4074 if ((*cptr == 0) || (*cptr == ';') || (*cptr == '#'))
4075 return SCPE_2FARG;
4076 GET_SWITCHES (cptr);
4077
4078 while (*cptr != 0) {
4079 cptr = get_glyph (svptr = cptr, gbuf, ',');
4080 if (0 == strcmp (gbuf, ";"))
4081 break;
4082 if ((cvptr = strchr (gbuf, '=')))
4083 *cvptr++ = 0;
4084 for (mptr = dptr->modifiers; mptr && (mptr->mask != 0); mptr++) {
4085 if ((mptr->mstring) &&
4086 (MATCH_CMD (gbuf, mptr->mstring) == 0)) {
4087 if (mptr->mask & MTAB_XTD) {
4088 if (((lvl & mptr->mask) & ~MTAB_XTD) == 0)
4089 return SCPE_ARG;
4090 if ((lvl == MTAB_VUN) && (uptr->flags & UNIT_DIS))
4091 return SCPE_UDIS;
4092 if (mptr->valid) {
4093 if (cvptr && MODMASK(mptr,MTAB_QUOTE)) {
4094 svptr = get_glyph_quoted (svptr, gbuf, ',');
4095 if ((cvptr = strchr (gbuf, '='))) {
4096 *cvptr++ = 0;
4097 cptr = svptr;
4098 }
4099 }
4100 else {
4101 if (cvptr && MODMASK(mptr,MTAB_NC)) {
4102 (void)get_glyph_nc (svptr, gbuf, ',');
4103 if ((cvptr = strchr (gbuf, '=')))
4104 *cvptr++ = 0;
4105 }
4106 }
4107 r = mptr->valid (uptr, mptr->match, cvptr, mptr->desc);
4108 if (r != SCPE_OK)
4109 return r;
4110 }
4111 else if (!mptr->desc)
4112 break;
4113 else if (cvptr)
4114 return SCPE_ARG;
4115 else *((int32 *) mptr->desc) = mptr->match;
4116 }
4117 else {
4118 if (cvptr)
4119 return SCPE_ARG;
4120 if (uptr->flags & UNIT_DIS)
4121 return SCPE_UDIS;
4122 if ((mptr->valid) &&
4123 ((r = mptr->valid (uptr, mptr->match, cvptr, mptr->desc)) != SCPE_OK))
4124 return r;
4125 uptr->flags = (uptr->flags & ~(mptr->mask)) |
4126 (mptr->match & mptr->mask);
4127 }
4128 break;
4129 }
4130 }
4131 if (!mptr || (mptr->mask == 0)) {
4132 if ((glbr = find_c1tab (ctbr, gbuf))) {
4133 r = glbr->action (dptr, uptr, glbr->arg, cvptr);
4134 if (r != SCPE_OK)
4135 return r;
4136 }
4137 else if (!dptr->modifiers)
4138 return SCPE_NOPARAM;
4139 else return SCPE_NXPAR;
4140 }
4141 }
4142 return SCPE_OK;
4143 }
4144
4145
4146
4147 CTAB *find_ctab (CTAB *tab, const char *gbuf)
4148 {
4149 if (!tab)
4150 return NULL;
4151 for (; tab->name != NULL; tab++) {
4152 if (MATCH_CMD (gbuf, tab->name) == 0)
4153 return tab;
4154 }
4155 return NULL;
4156 }
4157
4158 C1TAB *find_c1tab (C1TAB *tab, const char *gbuf)
4159 {
4160 if (!tab)
4161 return NULL;
4162 for (; tab->name != NULL; tab++) {
4163 if (MATCH_CMD (gbuf, tab->name) == 0)
4164 return tab;
4165 }
4166 return NULL;
4167 }
4168
4169
4170
4171 t_stat set_dev_radix (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4172 {
4173 if (cptr)
4174 return SCPE_ARG;
4175 dptr->dradix = flag & 037;
4176 return SCPE_OK;
4177 }
4178
4179
4180
4181 t_stat set_dev_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4182 {
4183 UNIT *up;
4184 uint32 i;
4185
4186 if (cptr)
4187 return SCPE_ARG;
4188 if ((dptr->flags & DEV_DISABLE) == 0)
4189 return SCPE_NOFNC;
4190 if (flag) {
4191 if ((dptr->flags & DEV_DIS) == 0)
4192 return SCPE_OK;
4193 dptr->flags = dptr->flags & ~DEV_DIS;
4194 }
4195 else {
4196 if (dptr->flags & DEV_DIS)
4197 return SCPE_OK;
4198 for (i = 0; i < dptr->numunits; i++) {
4199 up = (dptr->units) + i;
4200 if ((up->flags & UNIT_ATT) || sim_is_active (up))
4201 return SCPE_NOFNC;
4202 }
4203 dptr->flags = dptr->flags | DEV_DIS;
4204 }
4205 if (dptr->reset)
4206 return dptr->reset (dptr);
4207 else return SCPE_OK;
4208 }
4209
4210
4211
4212 t_stat set_unit_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4213 {
4214 if (cptr)
4215 return SCPE_ARG;
4216 if (!(uptr->flags & UNIT_DISABLE))
4217 return SCPE_NOFNC;
4218 if (flag)
4219 uptr->flags = uptr->flags & ~UNIT_DIS;
4220 else {
4221 if ((uptr->flags & UNIT_ATT) ||
4222 sim_is_active (uptr))
4223 return SCPE_NOFNC;
4224 uptr->flags = uptr->flags | UNIT_DIS;
4225 }
4226 return SCPE_OK;
4227 }
4228
4229
4230
4231 t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4232 {
4233 char gbuf[CBUFSIZE];
4234 DEBTAB *dep;
4235
4236 if ((dptr->flags & DEV_DEBUG) == 0)
4237 return SCPE_NOFNC;
4238 if (cptr == NULL) {
4239 dptr->dctrl = flag ? (dptr->debflags ? flag : 0xFFFFFFFF) : 0;
4240 if (flag && dptr->debflags) {
4241 for (dep = dptr->debflags; dep->name != NULL; dep++)
4242 dptr->dctrl = dptr->dctrl | dep->mask;
4243 }
4244 return SCPE_OK;
4245 }
4246 if (dptr->debflags == NULL)
4247 return SCPE_ARG;
4248 while (*cptr) {
4249 cptr = get_glyph (cptr, gbuf, ';');
4250 for (dep = dptr->debflags; dep->name != NULL; dep++) {
4251 if (strcmp (dep->name, gbuf) == 0) {
4252 if (flag)
4253 dptr->dctrl = dptr->dctrl | dep->mask;
4254 else dptr->dctrl = dptr->dctrl & ~dep->mask;
4255 break;
4256 }
4257 }
4258 if (dep->mask == 0)
4259 return SCPE_ARG;
4260 }
4261 return SCPE_OK;
4262 }
4263
4264
4265
4266 t_stat show_cmd (int32 flag, CONST char *cptr)
4267 {
4268 t_stat r = SCPE_IERR;
4269
4270 cptr = get_sim_opt (CMD_OPT_SW|CMD_OPT_OF, cptr, &r);
4271
4272 if (NULL == cptr)
4273 return r;
4274 if (sim_ofile) {
4275 r = show_cmd_fi (sim_ofile, flag, cptr);
4276 fclose (sim_ofile);
4277 }
4278 else {
4279 r = show_cmd_fi (stdout, flag, cptr);
4280 if (sim_log && (sim_log != stdout))
4281 show_cmd_fi (sim_log, flag, cptr);
4282 if (sim_deb && (sim_deb != stdout) && (sim_deb != sim_log))
4283 show_cmd_fi (sim_deb, flag, cptr);
4284 }
4285 return r;
4286 }
4287
4288 t_stat show_cmd_fi (FILE *ofile, int32 flag, CONST char *cptr)
4289 {
4290 uint32 lvl = 0xFFFFFFFF;
4291 char gbuf[CBUFSIZE], *cvptr;
4292 CONST char *svptr;
4293 DEVICE *dptr;
4294 UNIT *uptr;
4295 MTAB *mptr;
4296 SHTAB *shtb = NULL, *shptr;
4297
4298 GET_SWITCHES (cptr);
4299 if ((*cptr == 0) || (*cptr == ';') || (*cptr == '#'))
4300 return SCPE_2FARG;
4301 cptr = get_glyph (svptr = cptr, gbuf, 0);
4302
4303 if ((dptr = find_dev (gbuf))) {
4304 uptr = dptr->units;
4305 shtb = show_dev_tab;
4306 lvl = MTAB_VDV;
4307 GET_SWITCHES (cptr);
4308 }
4309 else if ((dptr = find_unit (gbuf, &uptr))) {
4310 if (uptr == NULL)
4311 return sim_messagef (SCPE_NXUN, "Non-existent unit: %s\n", gbuf);
4312 if (uptr->flags & UNIT_DIS)
4313 return sim_messagef (SCPE_UDIS, "Unit disabled: %s\n", gbuf);
4314 shtb = show_unit_tab;
4315 lvl = MTAB_VUN;
4316 GET_SWITCHES (cptr);
4317 }
4318 else if ((shptr = find_shtab (show_glob_tab, gbuf))) {
4319 GET_SWITCHES (cptr);
4320 return shptr->action (ofile, NULL, NULL, shptr->arg, cptr);
4321 }
4322 else {
4323 if (sim_dflt_dev && sim_dflt_dev->modifiers) {
4324 if ((cvptr = strchr (gbuf, '=')))
4325 *cvptr++ = 0;
4326 for (mptr = sim_dflt_dev->modifiers; mptr && (mptr->mask != 0); mptr++) {
4327 if ((((mptr->mask & MTAB_VDV) == MTAB_VDV) &&
4328 (mptr->pstring && (MATCH_CMD (gbuf, mptr->pstring) == 0))) ||
4329 (!(mptr->mask & MTAB_VDV) && (mptr->mstring && (MATCH_CMD (gbuf, mptr->mstring) == 0)))) {
4330 dptr = sim_dflt_dev;
4331 lvl = MTAB_VDV;
4332 cptr = svptr;
4333 while (sim_isspace(*cptr))
4334 ++cptr;
4335 break;
4336 }
4337 }
4338 }
4339 if (!dptr) {
4340 if (sim_dflt_dev && (shptr = find_shtab (show_dev_tab, gbuf)))
4341 return shptr->action (ofile, sim_dflt_dev, uptr, shptr->arg, cptr);
4342 else
4343 return sim_messagef (SCPE_NXDEV, "Non-existent device: %s\n", gbuf);
4344 }
4345 }
4346
4347 if ((*cptr == 0) || (*cptr == ';') || (*cptr == '#')) {
4348 return (lvl == MTAB_VDV)?
4349 show_device (ofile, dptr, 0):
4350 show_unit (ofile, dptr, uptr, -1);
4351 }
4352 GET_SWITCHES (cptr);
4353
4354 while (*cptr != 0) {
4355 cptr = get_glyph (cptr, gbuf, ',');
4356 if ((cvptr = strchr (gbuf, '=')))
4357 *cvptr++ = 0;
4358 for (mptr = dptr->modifiers; mptr && (mptr->mask != 0); mptr++) {
4359 if (((mptr->mask & MTAB_XTD)?
4360 ((mptr->mask & lvl) == lvl): (MTAB_VUN & lvl)) &&
4361 ((mptr->disp && mptr->pstring &&
4362 (MATCH_CMD (gbuf, mptr->pstring) == 0))
4363 )) {
4364 if (cvptr && !MODMASK(mptr,MTAB_SHP))
4365 return sim_messagef (SCPE_ARG, "Invalid Argument: %s=%s\n", gbuf, cvptr);
4366 show_one_mod (ofile, dptr, uptr, mptr, cvptr, 1);
4367 break;
4368 }
4369 }
4370 if (!mptr || (mptr->mask == 0)) {
4371 if (shtb && (shptr = find_shtab (shtb, gbuf))) {
4372 t_stat r;
4373
4374 r = shptr->action (ofile, dptr, uptr, shptr->arg, cptr);
4375 if (r != SCPE_OK)
4376 return r;
4377 }
4378 else {
4379 if (!dptr->modifiers)
4380 return sim_messagef (SCPE_NOPARAM, "%s device has no parameters\n", dptr->name);
4381 else
4382 return sim_messagef (SCPE_NXPAR, "Non-existent parameter: %s\n", gbuf);
4383 }
4384 }
4385 }
4386 return SCPE_OK;
4387 }
4388
4389 SHTAB *find_shtab (SHTAB *tab, const char *gbuf)
4390 {
4391 if (!tab)
4392 return NULL;
4393 for (; tab->name != NULL; tab++) {
4394 if (MATCH_CMD (gbuf, tab->name) == 0)
4395 return tab;
4396 }
4397 return NULL;
4398 }
4399
4400
4401
4402 t_stat show_device (FILE *st, DEVICE *dptr, int32 flag)
4403 {
4404 uint32 j, udbl, ucnt;
4405 UNIT *uptr;
4406 int32 toks = 0;
4407
4408 if (strcmp(sim_dname (dptr),"SYS") != 0) {
4409 (void)fprintf (st, "%s", sim_dname (dptr));
4410 if ((flag == 2) && dptr->description) {
4411 (void)fprintf (st, "\t%s\n", dptr->description(dptr));
4412 }
4413 else {
4414 if ((sim_switches & SWMASK ('D')) && dptr->description)
4415 (void)fprintf (st, "\t%s\n", dptr->description(dptr));
4416 }
4417 if (qdisable (dptr)) {
4418 (void)fprintf (st, "\tdisabled\n");
4419 return SCPE_OK;
4420 }
4421 for (j = ucnt = udbl = 0; j < dptr->numunits; j++) {
4422 uptr = dptr->units + j;
4423 if (!(uptr->flags & UNIT_DIS))
4424 ucnt++;
4425 else if (uptr->flags & UNIT_DISABLE)
4426 udbl++;
4427 }
4428
4429 if (dptr->numunits == 0) {
4430 if (toks)
4431 (void)fprintf (st, "\n");
4432 }
4433 else {
4434 if (ucnt == 0) {
4435 fprint_sep (st, &toks);
4436 (void)fprintf (st, "all units disabled\n");
4437 }
4438 else if ((ucnt + udbl) == 1) {
4439 fprint_sep (st, &toks);
4440 (void)fprintf (st, " 1 unit\n");
4441 }
4442 else if ((ucnt > 1) || (udbl > 0)) {
4443 fprint_sep (st, &toks);
4444 (void)fprintf (st, "%2.d units\n", ucnt + udbl);
4445 }
4446 else
4447 if ((flag != 2) || !dptr->description || toks)
4448 (void)fprintf (st, "\n");
4449 toks = 0;
4450 }
4451 if (flag)
4452 return SCPE_OK;
4453 for (j = 0; j < dptr->numunits; j++) {
4454 uptr = dptr->units + j;
4455 if ((uptr->flags & UNIT_DIS) == 0)
4456 show_unit (st, dptr, uptr, ucnt + udbl);
4457 }
4458 }
4459 return SCPE_OK;
4460 }
4461
4462 void fprint_sep (FILE *st, int32 *tokens)
4463 {
4464 (void)fprintf (st, "%s", (*tokens > 0) ? "" : "\t");
4465 *tokens += 1;
4466 }
4467
4468 t_stat show_unit (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag)
4469 {
4470 int32 u = (int32)(uptr - dptr->units);
4471 int32 toks = 0;
4472
4473 if (flag > 1)
4474 (void)fprintf (st, " %s%d \n", sim_dname (dptr), u);
4475 else if (flag < 0)
4476 (void)fprintf (st, " %s%d ", sim_dname (dptr), u);
4477 if (uptr->flags & UNIT_ATT) {
4478 fprint_sep (st, &toks);
4479 (void)fprintf (st, "status : attached to %s", uptr->filename);
4480 if (uptr->flags & UNIT_RO)
4481 (void)fprintf (st, ", read only");
4482 }
4483 else {
4484 if (uptr->flags & UNIT_ATTABLE) {
4485 fprint_sep (st, &toks);
4486 (void)fprintf (st, "status : not attached");
4487 }
4488 }
4489 if ((uptr->capac > 0) && (uptr->flags & UNIT_FIX)) {
4490 fprint_sep (st, &toks);
4491 fprint_capac (st, dptr, uptr);
4492 }
4493 show_all_mods (st, dptr, uptr, MTAB_VUN, &toks);
4494 if (toks || (flag < 0) || (flag > 1))
4495 (void)fprintf (st, "\n");
4496 return SCPE_OK;
4497 }
4498
4499 const char *sprint_capac (DEVICE *dptr, UNIT *uptr)
4500 {
4501 static char capac_buf[((CHAR_BIT * sizeof (t_value) * 4 + 3)/3) + 8];
4502 t_offset kval = (t_offset)((uptr->flags & UNIT_BINK) ? 1024: 1000);
4503 t_offset mval;
4504 t_offset psize = (t_offset)uptr->capac;
4505 char *scale, *width;
4506
4507 if (sim_switches & SWMASK ('B'))
4508 kval = 1024;
4509 mval = kval * kval;
4510 if (dptr->flags & DEV_SECTORS) {
4511 kval = kval / 512;
4512 mval = mval / 512;
4513 }
4514 if ((dptr->dwidth / dptr->aincr) > 8)
4515 width = "W";
4516 else
4517 width = "B";
4518 if ((psize < (kval * 10)) &&
4519 (0 != (psize % kval))) {
4520 scale = "";
4521 }
4522 else if ((psize < (mval * 10)) &&
4523 (0 != (psize % mval))){
4524 scale = "K";
4525 psize = psize / kval;
4526 }
4527 else {
4528 scale = "M";
4529 psize = psize / mval;
4530 }
4531 sprint_val (capac_buf, (t_value) psize, 10, T_ADDR_W, PV_LEFT);
4532 (void)sprintf (&capac_buf[strlen (capac_buf)], "%s%s", scale, width);
4533 return capac_buf;
4534 }
4535
4536 void fprint_capac (FILE *st, DEVICE *dptr, UNIT *uptr)
4537 {
4538 (void)fprintf (st, " %s", sprint_capac (dptr, uptr));
4539 }
4540
4541
4542
4543 extern void print_default_base_system_script (void);
4544 t_stat show_default_base_system_script (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4545 {
4546 #if !defined(PERF_STRIP)
4547 print_default_base_system_script();
4548 #endif
4549 return 0;
4550 }
4551
4552 static void printp (unsigned char * PROM, char * label, int offset, int length) {
4553 sim_printf (" %s ", label);
4554 sim_printf (" %2d %3o(8) '", length, offset);
4555 for (int l = 0; l < length; l ++)
4556 {
4557 unsigned int byte = PROM[offset + l];
4558 if (byte == 255)
4559 {
4560 byte = ' ';
4561 }
4562 sim_printf (isprint (byte) ? "%c" : "\\%03o", byte);
4563 }
4564 sim_printf ("'\r\n");
4565 }
4566
4567 static void strip_spaces(char* str) {
4568 int i, x;
4569 for (i=x=0; str[i]; ++i)
4570 {
4571 if (!isspace((int)str[i]) || (i > 0 && !isspace((int)str[(int)(i-1)])))
4572 {
4573 str[x++] = str[i];
4574 }
4575 }
4576 str[x] = '\0';
4577 i = -1;
4578 x = 0;
4579 while (str[x] != '\0')
4580 {
4581 if (str[x] != ' ' && str[x] != '\t' && str[x] != '\n')
4582 {
4583 i=x;
4584 }
4585 x++;
4586 }
4587 str[i+1] = '\0';
4588 }
4589
4590 static void printpq (unsigned char * PROM, FILE * st, int offset, int length) {
4591 char sx[1024];
4592 sx[1023] = '\0';
4593 unsigned int lastbyte = 0;
4594 for (int l = 0; l < length; l ++)
4595 {
4596 unsigned int byte = PROM[offset + l];
4597 if (byte == 255)
4598 {
4599 byte = 20;
4600 }
4601 if ((lastbyte != 20) && (byte != 20))
4602 {
4603 (void)sprintf(&sx[l], isprint (byte) ? "%c" : " ", byte);
4604 }
4605 lastbyte = byte;
4606 }
4607 strip_spaces(sx);
4608 (void)fprintf (st, "%s", sx);
4609 }
4610
4611 t_stat show_prom (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4612 {
4613 unsigned char PROM[1024];
4614 setupPROM (0, PROM);
4615
4616 sim_printf (" PROM size: %llu bytes\r\n",
4617 (long long unsigned)sizeof(PROM));
4618 sim_printf (" PROM initialization data:\r\n\r\n");
4619
4620 sim_printf (" Field Description Length Offset Contents\r\n");
4621 sim_printf (" ========================= ======== ======== ==================================\r\n");
4622 sim_printf ("\r\n");
4623
4624
4625
4626 printp (PROM, "CPU Model ", 0, 11);
4627 printp (PROM, "CPU Serial ", 11, 11);
4628 printp (PROM, "Ship Date ", 22, 6);
4629 printp (PROM, "PROM Layout Version ", 60, 1);
4630 printp (PROM, "Release Git Commit Date ", 70, 10);
4631 printp (PROM, "Release Major ", 80, 3);
4632 printp (PROM, "Release Minor ", 83, 3);
4633 printp (PROM, "Release Patch ", 86, 3);
4634 printp (PROM, "Release Iteration ", 89, 3);
4635 printp (PROM, "Release Build Number ", 92, 8);
4636 printp (PROM, "Release Type ", 100, 1);
4637 printp (PROM, "Release Version Text ", 101, 29);
4638 printp (PROM, "Build Architecture ", 130, 20);
4639 printp (PROM, "Build Operating System ", 150, 20);
4640 printp (PROM, "Target Architecture ", 170, 20);
4641 printp (PROM, "Target Operating System ", 190, 20);
4642
4643 sim_printf("\r\n");
4644 return 0;
4645 }
4646
4647 t_stat show_buildinfo (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4648 {
4649 (void)fprintf (st, "\r Build Information:\n");
4650 #if defined(BUILDINFO_scp) && defined(SYSDEFS_USED)
4651 (void)fprintf (st, "\r\n Compilation info: %s\n", BUILDINFO_scp );
4652 # if !defined(__OPEN64__)
4653 (void)fprintf (st, "\r\n Relevant definitions: %s\n", SYSDEFS_USED );
4654 # endif
4655 #elif defined(BUILDINFO_scp)
4656 (void)fprintf (st, "\r\n Compilation info: %s\n", BUILDINFO_scp );
4657 #else
4658 (void)fprintf (st, "\r\n Compilation info: Not available\n" );
4659 #endif
4660 #if !defined(__CYGWIN__)
4661 # if !defined(__APPLE__)
4662 # if !defined(_AIX)
4663 # if !defined(__MINGW32__)
4664 # if !defined(__MINGW64__)
4665 # if !defined(CROSS_MINGW32)
4666 # if !defined(CROSS_MINGW64)
4667 # if !defined(_WIN32)
4668 # if !defined(__HAIKU__)
4669 (void)dl_iterate_phdr (dl_iterate_phdr_callback, NULL);
4670 if (dl_iterate_phdr_callback_called)
4671 (void)fprintf (st, "\n");
4672 # endif
4673 # endif
4674 # endif
4675 # endif
4676 # endif
4677 # endif
4678 # endif
4679 # endif
4680 #endif
4681 #if defined(UV_VERSION_MAJOR) && \
4682 defined(UV_VERSION_MINOR) && \
4683 defined(UV_VERSION_PATCH)
4684 # if defined(UV_VERSION_MAJOR)
4685 # if !defined(UV_VERSION_MINOR) && \
4686 !defined(UV_VERSION_PATCH) && \
4687 !defined(UV_VERSION_SUFFIX)
4688 (void)fprintf (st, "\r\n Event loop library: Built with libuv v%d", UV_VERSION_MAJOR);
4689 # endif
4690 # if defined(UV_VERSION_MINOR)
4691 # if !defined(UV_VERSION_PATCH) && !defined(UV_VERSION_SUFFIX)
4692 (void)fprintf (st, "\r\n Event loop library: Built with libuv %d.%d", UV_VERSION_MAJOR,
4693 UV_VERSION_MINOR);
4694 # endif
4695 # if defined(UV_VERSION_PATCH)
4696 # if !defined(UV_VERSION_SUFFIX)
4697 (void)fprintf (st, "\r\n Event loop library: Built with libuv %d.%d.%d", UV_VERSION_MAJOR,
4698 UV_VERSION_MINOR, UV_VERSION_PATCH);
4699 # endif
4700 # if defined(UV_VERSION_SUFFIX)
4701 (void)fprintf (st, "\r\n Event loop library: Built with libuv %d.%d.%d", UV_VERSION_MAJOR,
4702 UV_VERSION_MINOR, UV_VERSION_PATCH);
4703 # if defined(UV_VERSION_IS_RELEASE)
4704 # if UV_VERSION_IS_RELEASE == 1
4705 # define UV_RELEASE_TYPE " (release)"
4706 # endif
4707 # if UV_VERSION_IS_RELEASE == 0
4708 # define UV_RELEASE_TYPE "-dev"
4709 # endif
4710 # if !defined(UV_RELEASE_TYPE)
4711 # define UV_RELEASE_TYPE ""
4712 # endif
4713 # if defined(UV_RELEASE_TYPE)
4714 (void)fprintf (st, "%s", UV_RELEASE_TYPE);
4715 # endif
4716 # endif
4717 # endif
4718 # endif
4719 # endif
4720 unsigned int CurrentUvVersion = uv_version();
4721 if (CurrentUvVersion > 0)
4722 if (uv_version_string() != NULL)
4723 (void)fprintf (st, "; %s in use", uv_version_string());
4724 # endif
4725 #else
4726 (void)fprintf (st, "\r\n Event loop library: Using libuv (or compatible) library, unknown version");
4727 #endif
4728
4729
4730
4731 #if defined(DECNUMBERLOC)
4732 # if defined(DECVERSION)
4733 # if defined(DECVERSEXT)
4734 (void)fprintf (st, "\r\n Math library: %s-%s", DECVERSION, DECVERSEXT);
4735 # else
4736 # if defined(DECNLAUTHOR)
4737 (void)fprintf (st, "\r\n Math library: %s (%s and contributors)", DECVERSION, DECNLAUTHOR);
4738 # else
4739 (void)fprintf (st, "\r\n Math library: %s", DECVERSION);
4740 # endif
4741 # endif
4742 # else
4743 (void)fprintf (st, "\r\n Math library: decNumber, unknown version");
4744 # endif
4745 #endif
4746 #if defined(LOCKLESS)
4747 (void)fprintf (st, "\r\n Atomic operations: ");
4748 # if defined(AIX_ATOMICS)
4749 (void)fprintf (st, "IBM AIX-style");
4750 # elif defined(BSD_ATOMICS)
4751 (void)fprintf (st, "FreeBSD-style");
4752 # elif defined(GNU_ATOMICS)
4753 (void)fprintf (st, "GNU-style");
4754 # elif defined(SYNC_ATOMICS)
4755 (void)fprintf (st, "GNU sync-style");
4756 # elif defined(ISO_ATOMICS)
4757 (void)fprintf (st, "ISO/IEC 9899:2011 (C11) standard");
4758 # elif defined(NT_ATOMICS)
4759 (void)fprintf (st, "Windows NT interlocked operations");
4760 # endif
4761 #endif
4762 (void)fprintf (st, "\r\n File locking: ");
4763 #if defined(USE_FCNTL) && defined(USE_FLOCK)
4764 (void)fprintf (st, "POSIX-style fcntl() and BSD-style flock() locking");
4765 #endif
4766 #if defined(USE_FCNTL) && !defined(USE_FLOCK)
4767 (void)fprintf (st, "POSIX-style fcntl() locking");
4768 #endif
4769 #if defined(USE_FLOCK) && !defined(USE_FCNTL)
4770 (void)fprintf (st, "BSD-style flock() locking");
4771 #endif
4772 #if !defined(USE_FLOCK) && !defined(USE_FCNTL)
4773 (void)fprintf (st, "No file locking available");
4774 #endif
4775 (void)fprintf (st, "\r\n Backtrace support: ");
4776 #if defined(USE_BACKTRACE)
4777 (void)fprintf (st, "Enabled (libbacktrace)");
4778 #else
4779 (void)fprintf (st, "Disabled");
4780 #endif
4781 (void)fprintf (st, "\r\n Windows support: ");
4782 #if defined(__MINGW32__) || defined(__MINGW64__) || defined(CROSS_MINGW32) || defined(CROSS_MINGW64)
4783 # if defined(__MINGW64_VERSION_STR)
4784 (void)fprintf (st, "Built with MinGW-w64 %s", __MINGW64_VERSION_STR);
4785 # elif defined(__MINGW32_MAJOR_VERSION) && defined(__MINGW32_MINOR_VERSION)
4786 (void)fprintf (st, "Built with MinGW %d.%d", __MINGW32_MAJOR_VERSION, __MINGW32_MINOR_VERSION);
4787 # else
4788 (void)fprintf (st, "Built with MinGW");
4789 # endif
4790
4791 # if defined(MINGW_CRT)
4792 (void)fprintf (st, "; %s", MINGW_CRT);
4793 # if !defined(_UCRT)
4794 # if defined(__MSVCRT_VERSION__)
4795 # if __MSVCRT_VERSION__ > 0x00
4796 (void)fprintf (st, " %d.%d", (__MSVCRT_VERSION__ >> CHAR_BIT) & UCHAR_MAX, __MSVCRT_VERSION__ & UCHAR_MAX);
4797 # endif
4798 # endif
4799 # else
4800
4801 struct UCRTVersion ucrtversion;
4802 int result = GetUCRTVersion (&ucrtversion);
4803
4804 if (result == 0)
4805 (void)fprintf (st, " %u.%u.%u.%u",
4806 ucrtversion.ProductVersion[1], ucrtversion.ProductVersion[0],
4807 ucrtversion.ProductVersion[3], ucrtversion.ProductVersion[2]);
4808 # endif
4809 (void)fprintf (st, " in use");
4810 # endif
4811 #elif defined(__CYGWIN__)
4812 struct utsname utsname;
4813 (void)fprintf (st, "Built with Cygwin %d.%d.%d",
4814 CYGWIN_VERSION_DLL_MAJOR / 1000,
4815 CYGWIN_VERSION_DLL_MAJOR % 1000,
4816 CYGWIN_VERSION_DLL_MINOR);
4817 if (uname(&utsname) == 0)
4818 fprintf (st, "; %s in use", utsname.release);
4819 #else
4820 (void)fprintf (st, "Disabled");
4821 #endif
4822
4823 (void)fprintf (st, "\r\n");
4824 return 0;
4825 }
4826
4827 t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
4828 {
4829 const char *arch = "";
4830 char *whydirty = " ";
4831 int dirty = 0;
4832
4833 if (cptr && (*cptr != 0))
4834 return SCPE_2MARG;
4835 if (flag) {
4836 (void)fprintf (st, " %s Simulator:", sim_name);
4837 #if defined(USE_DUMA)
4838 # undef NO_SUPPORT_VERSION
4839 # define NO_SUPPORT_VERSION 1
4840 nodist++;
4841 #endif
4842 #if defined(NO_SUPPORT_VERSION) || \
4843 defined(WITH_SOCKET_DEV) || \
4844 defined(WITH_ABSI_DEV) || \
4845 defined(WITH_MGP_DEV) || \
4846 defined(TESTING) || \
4847 defined(ISOLTS) || \
4848 defined(USE_DUMA)
4849 # if !defined(NO_SUPPORT_VERSION)
4850 # define NO_SUPPORT_VERSION 1
4851 # endif
4852 #endif
4853 #if defined(NO_SUPPORT_VERSION)
4854 dirty++;
4855 #endif
4856 #if defined(GENERATED_MAKE_VER_H)
4857 # if defined(VER_H_GIT_VERSION)
4858
4859
4860 if (strstr(VER_H_GIT_VERSION, "*"))
4861 {
4862 dirty++;
4863 }
4864
4865
4866 if ((strstr(VER_H_GIT_VERSION, "X")) || \
4867 (strstr(VER_H_GIT_VERSION, "D")) || \
4868 (strstr(VER_H_GIT_VERSION, "A")) || \
4869 (strstr(VER_H_GIT_VERSION, "B")))
4870 {
4871 dirty++;
4872 }
4873
4874
4875 if (dirty)
4876 {
4877 if ((strstr(VER_H_GIT_VERSION, "X")))
4878 {
4879 whydirty = " ";
4880 }
4881 else if ((strstr(VER_H_GIT_VERSION, "D")))
4882 {
4883 whydirty = " DEV ";
4884 }
4885 else if ((strstr(VER_H_GIT_VERSION, "A")))
4886 {
4887 whydirty = " ALPHA ";
4888 }
4889 else if ((strstr(VER_H_GIT_VERSION, "B")))
4890 {
4891 whydirty = " BETA ";
4892 }
4893 }
4894
4895 # if defined(VER_H_GIT_PATCH) && defined(VER_H_GIT_PATCH_INT)
4896 # if defined(VER_H_GIT_HASH)
4897 # if VER_H_GIT_PATCH_INT < 1
4898 (void)fprintf (st, "\n Version: %s (%ld-bit)\n Commit: %s",
4899 VER_H_GIT_VERSION,
4900 (long)(CHAR_BIT*sizeof(void *)),
4901 VER_H_GIT_HASH);
4902 # else
4903 # define NO_SUPPORT_VERSION 1
4904 (void)fprintf (st, "\n Version: %s+%s (%ld-bit)\n Commit: %s",
4905 VER_H_GIT_VERSION, VER_H_GIT_PATCH,
4906 (long)(CHAR_BIT*sizeof(void *)),
4907 VER_H_GIT_HASH);
4908 # endif
4909 # else
4910 # if VER_H_GIT_PATCH_INT < 1
4911 (void)fprintf (st, "\n Version: %s (%ld-bit)",
4912 VER_H_GIT_VERSION,
4913 (long)(CHAR_BIT*sizeof(void *)));
4914 # else
4915 # define NO_SUPPORT_VERSION 1
4916 (void)fprintf (st, "\n Version: %s+%s (%ld-bit)",
4917 VER_H_GIT_VERSION, VER_H_GIT_PATCH,
4918 (long)(CHAR_BIT*sizeof(void *)));
4919 # endif
4920 # endif
4921 # else
4922 # if defined(VER_H_GIT_HASH)
4923 (void)fprintf (st, "\n Version: %s (%ld-bit)\n Commit: %s",
4924 VER_H_GIT_VERSION,
4925 (long)(CHAR_BIT*sizeof(void *)),
4926 VER_H_GIT_HASH);
4927 # else
4928 (void)fprintf (st, "\n Version: %s (%ld-bit)",
4929 VER_H_GIT_VERSION,
4930 (long)(CHAR_BIT*sizeof(void *)));
4931 # endif
4932 # endif
4933 # endif
4934 #endif
4935
4936
4937 #if defined(TESTING)
4938 (void)fprintf (st, "\n Options: ");
4939 # if !defined(HAVE_DPSOPT)
4940 # define HAVE_DPSOPT 1
4941 # endif
4942 (void)fprintf (st, "TESTING");
4943 #endif
4944
4945
4946 #if defined(ISOLTS)
4947 # if defined(HAVE_DPSOPT)
4948 (void)fprintf (st, ", ");
4949 # else
4950 (void)fprintf (st, "\n Options: ");
4951 # endif
4952 # if !defined(HAVE_DPSOPT)
4953 # define HAVE_DPSOPT 1
4954 # endif
4955 (void)fprintf (st, "ISOLTS");
4956 #endif
4957
4958
4959 #if defined(NO_UCACHE)
4960 # if defined(HAVE_DPSOPT)
4961 (void)fprintf (st, ", ");
4962 # else
4963 (void)fprintf (st, "\n Options: ");
4964 # endif
4965 # if !defined(HAVE_DPSOPT)
4966 # define HAVE_DPSOPT 1
4967 # endif
4968 (void)fprintf (st, "NO_UCACHE");
4969 #endif
4970
4971
4972 #if defined(NEED_128)
4973 # if defined(HAVE_DPSOPT)
4974 (void)fprintf (st, ", ");
4975 # else
4976 (void)fprintf (st, "\n Options: ");
4977 # endif
4978 # if !defined(HAVE_DPSOPT)
4979 # define HAVE_DPSOPT 1
4980 # endif
4981 (void)fprintf (st, "NEED_128");
4982 #endif
4983
4984
4985 #if defined(WAM)
4986 # if defined(HAVE_DPSOPT)
4987 (void)fprintf (st, ", ");
4988 # else
4989 (void)fprintf (st, "\n Options: ");
4990 # endif
4991 # if !defined(HAVE_DPSOPT)
4992 # define HAVE_DPSOPT 1
4993 # endif
4994 (void)fprintf (st, "WAM");
4995 #endif
4996
4997
4998 #if defined(ROUND_ROBIN)
4999 # if defined(HAVE_DPSOPT)
5000 (void)fprintf (st, ", ");
5001 # else
5002 (void)fprintf (st, "\n Options: ");
5003 # endif
5004 # if !defined(HAVE_DPSOPT)
5005 # define HAVE_DPSOPT 1
5006 # endif
5007 (void)fprintf (st, "ROUND_ROBIN");
5008 #endif
5009
5010
5011 #if !defined(LOCKLESS)
5012 # if defined(HAVE_DPSOPT)
5013 (void)fprintf (st, ", ");
5014 # else
5015 (void)fprintf (st, "\n Options: ");
5016 # endif
5017 # if !defined(HAVE_DPSOPT)
5018 # define HAVE_DPSOPT 1
5019 # endif
5020 (void)fprintf (st, "NO_LOCKLESS");
5021 #endif
5022
5023
5024 #if defined(WITH_ABSI_DEV)
5025 # if defined(HAVE_DPSOPT)
5026 (void)fprintf (st, ", ");
5027 # else
5028 (void)fprintf (st, "\n Options: ");
5029 # endif
5030 # if !defined(HAVE_DPSOPT)
5031 # define HAVE_DPSOPT 1
5032 # endif
5033 (void)fprintf (st, "ABSI");
5034 #endif
5035
5036
5037 #if defined(WITH_SOCKET_DEV)
5038 # if defined(HAVE_DPSOPT)
5039 (void)fprintf (st, ", ");
5040 # else
5041 (void)fprintf (st, "\n Options: ");
5042 # endif
5043 # if !defined(HAVE_DPSOPT)
5044 # define HAVE_DPSOPT 1
5045 # endif
5046 (void)fprintf (st, "SOCKET");
5047 #endif
5048
5049
5050 #if defined(WITH_MGP_DEV)
5051 # if defined(HAVE_DPSOPT)
5052 (void)fprintf (st, ", ");
5053 # else
5054 (void)fprintf (st, "\n Options: ");
5055 # endif
5056 # if !defined(HAVE_DPSOPT)
5057 # define HAVE_DPSOPT 1
5058 # endif
5059 (void)fprintf (st, "CHAOSNET");
5060 # if USE_SOCKET_DEV_APPROACH
5061 (void)fprintf (st, "-S");
5062 # endif
5063 #endif
5064
5065
5066 #if defined(USE_DUMA)
5067 # if defined(HAVE_DPSOPT)
5068 (void)fprintf (st, ", ");
5069 # else
5070 (void)fprintf (st, "\n Options: ");
5071 # endif
5072 # if !defined(HAVE_DPSOPT)
5073 # define HAVE_DPSOPT 1
5074 # endif
5075 (void)fprintf (st, "DUMA");
5076 #endif
5077
5078 #if defined(GENERATED_MAKE_VER_H) && defined(VER_H_GIT_DATE)
5079 # if defined(NO_SUPPORT_VERSION)
5080 (void)fprintf (st, "\n Modified: %s", VER_H_GIT_DATE);
5081 # else
5082 (void)fprintf (st, "\n Released: %s", VER_H_GIT_DATE);
5083 # endif
5084 #endif
5085 #if defined(GENERATED_MAKE_VER_H) && defined(VER_H_GIT_DATE) && defined(VER_H_PREP_DATE)
5086 (void)fprintf (st, " - Kit Prepared: %s", VER_H_PREP_DATE);
5087 #endif
5088 #if defined(VER_CURRENT_TIME)
5089 (void)fprintf (st, "\n Compiled: %s", VER_CURRENT_TIME);
5090 #endif
5091 if (dirty)
5092 {
5093 (void)fprintf (st, "\r\n\r\n ****** THIS%sBUILD IS NOT SUPPORTED BY THE DPS8M DEVELOPMENT TEAM ******", whydirty);
5094 }
5095 (void)fprintf (st, "\r\n\r\n Build Information:");
5096 #if defined(BUILD_PROM_OSV_TEXT) && defined(BUILD_PROM_OSA_TEXT)
5097 char build_os_version_raw[255];
5098 char build_os_arch_raw[255];
5099 (void)sprintf(build_os_version_raw, "%.254s", BUILD_PROM_OSV_TEXT);
5100 (void)sprintf(build_os_arch_raw, "%.254s", BUILD_PROM_OSA_TEXT);
5101 char *build_os_version = strdup(build_os_version_raw);
5102 if (!build_os_version)
5103 {
5104 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
5105 __func__, __FILE__, __LINE__);
5106 # if defined(USE_BACKTRACE)
5107 # if defined(SIGUSR2)
5108 (void)raise(SIGUSR2);
5109
5110 # endif
5111 # endif
5112 abort();
5113 }
5114 char *build_os_arch = strdup(build_os_arch_raw);
5115 if (!build_os_arch)
5116 {
5117 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
5118 __func__, __FILE__, __LINE__);
5119 # if defined(USE_BACKTRACE)
5120 # if defined(SIGUSR2)
5121 (void)raise(SIGUSR2);
5122
5123 # endif
5124 # endif
5125 abort();
5126 }
5127 unsigned char SPROM[1024];
5128 setupPROM (0, SPROM);
5129 (void)fprintf (st, "\n Target: ");
5130 printpq (SPROM, st, 190, 20);
5131 if (SPROM[170] != 20)
5132 {
5133 if (SPROM[170] != 255)
5134 {
5135 (void)fprintf (st, " on ");
5136 printpq (SPROM, st, 170, 20);
5137 }
5138 }
5139 strtrimspace(build_os_version, build_os_version_raw);
5140 strtrimspace(build_os_arch, build_os_arch_raw);
5141 (void)fprintf (st, "\n Build OS: %s %s", build_os_version, build_os_arch);
5142 FREE(build_os_version);
5143 FREE(build_os_arch);
5144 #endif
5145 #if defined(__VERSION__)
5146 char gnumver[2];
5147 char postver[1024];
5148 (void)sprintf(gnumver, "%.1s", __VERSION__);
5149 (void)sprintf(postver, "%.1023s", __VERSION__);
5150 strremove(postver, "(TM)");
5151 strremove(postver, "(R)");
5152 strremove(postver, "git://github.com/OpenIndiana/oi-userland.git ");
5153 strremove(postver, "https://github.com/OpenIndiana/oi-userland.git ");
5154 strremove(postver, " gcc 4.9 mode");
5155 strremove(postver, "4.2.1 Compatible ");
5156 strremove(postver, "git@github.com:llvm/llvm-project.git ");
5157 strremove(postver, "https://github.com/llvm/llvm-project.git ");
5158 strremove(postver, " (https://github.com/yrnkrn/zapcc)");
5159 strremove(postver, "https://github.com/yrnkrn/zapcc ");
5160 strremove(postver, "(experimental) ");
5161 strremove(postver, ".module+el8.7.0+20823+214a699d");
5162 strremove(postver, "17.1.1 (5725-C72, 5765-J20), version ");
5163 strremove(postver, "17.1.1 (5725-C72, 5765-J18), version ");
5164 strremove(postver, "17.1.2 (5725-C72, 5765-J20), version ");
5165 strremove(postver, "17.1.2 (5725-C72, 5765-J18), version ");
5166 strremove(postver, "llvmorg-16.0.6-0-");
5167 strremove(postver, " Clang 15.0.0 (build 760095e)");
5168 strremove(postver, " Clang 15.0.0 (build 6af5742)");
5169 strremove(postver, " Clang 15.0.0 (build ca7115e)");
5170 strremove(postver, " Clang 15.0.0 (build 232543c)");
5171 strremove(postver, " Clang 17.0.6 (build 19a779f)");
5172 strremove(postver, "CLANG: ");
5173 #endif
5174 #if ( defined(__GNUC__) && defined(__VERSION__) ) && !defined(__EDG__)
5175 # if !defined(__clang_version__)
5176 if (isdigit((unsigned char)gnumver[0])) {
5177 (void)fprintf (st, "\n Compiler: GCC %s", postver);
5178 } else {
5179 (void)fprintf (st, "\n Compiler: %s", postver);
5180 }
5181 # endif
5182 # if defined(__clang_analyzer__ )
5183 (void)fprintf (st, "\n Compiler: Clang C/C++ Static Analyzer");
5184 # elif defined(__clang_version__) && defined(__VERSION__)
5185 char clangllvmver[1024];
5186 (void)sprintf(clangllvmver, "%.1023s", __clang_version__);
5187 strremove(clangllvmver, "git://github.com/OpenIndiana/oi-userland.git ");
5188 strremove(clangllvmver, "https://github.com/OpenIndiana/oi-userland.git ");
5189 strremove(clangllvmver, "https://github.com/llvm/llvm-project.git ");
5190 strremove(clangllvmver, "c13b7485b87909fcf739f62cfa382b55407433c0");
5191 strremove(clangllvmver, "e6c3289804a67ea0bb6a86fadbe454dd93b8d855");
5192 strremove(clangllvmver, "https://github.com/llvm/llvm-project.git");
5193 strremove(clangllvmver, " ( )");
5194 strremove(clangllvmver, " ()");
5195 if (gnumver[0] == 'c' || gnumver[0] == 'C') {
5196 (void)fprintf (st, "\n Compiler: Clang %s", clangllvmver);
5197 } else {
5198 (void)fprintf (st, "\n Compiler: %s", postver);
5199 }
5200 # elif defined(__clang_version__)
5201 (void)fprintf (st, "\n Compiler: %s", postver);
5202 # endif
5203 #elif defined(__PGI) && !defined(__NVCOMPILER)
5204 (void)fprintf (st, "\n Compiler: Portland Group, Inc. (PGI) C Compiler ");
5205 # if defined(__PGIC__)
5206 (void)fprintf (st, "%d", __PGIC__);
5207 # if defined(__PGIC_MINOR__)
5208 (void)fprintf (st, ".%d", __PGIC_MINOR__);
5209 # if defined(__PGIC_PATCHLEVEL__)
5210 (void)fprintf (st, ".%d", __PGIC_PATCHLEVEL__);
5211 # endif
5212 # endif
5213 # endif
5214 #elif defined(__NVCOMPILER)
5215 (void)fprintf (st, "\n Compiler: NVIDIA HPC SDK C Compiler ");
5216 # if defined(__NVCOMPILER_MAJOR__)
5217 (void)fprintf (st, "%d", __NVCOMPILER_MAJOR__);
5218 # if defined(__NVCOMPILER_MINOR__)
5219 (void)fprintf (st, ".%d", __NVCOMPILER_MINOR__);
5220 # if defined(__NVCOMPILER_PATCHLEVEL__)
5221 (void)fprintf (st, ".%d", __NVCOMPILER_PATCHLEVEL__);
5222 # endif
5223 # endif
5224 # endif
5225 #elif defined(_MSC_FULL_VER) && defined(_MSC_BUILD)
5226 (void)fprintf (st, "\n Compiler: Microsoft C %d.%02d.%05d.%02d",
5227 _MSC_FULL_VER/10000000,
5228 (_MSC_FULL_VER/100000)%100,
5229 _MSC_FULL_VER%100000,
5230 _MSC_BUILD);
5231 #elif ( defined(__xlc__) && !defined(__clang_version__) )
5232 # if defined(_AIX) && defined(__PASE__)
5233 (void)fprintf (st, "\n Compiler: IBM XL C/C++ V%s (PASE for IBM i)", __xlc__);
5234 # endif
5235 # if defined(_AIX) && !defined(__PASE__)
5236 (void)fprintf (st, "\n Compiler: IBM XL C/C++ for AIX V%s", __xlc__);
5237 # endif
5238 # if defined(__linux__) && ( !defined(_AIX) || !defined(__PASE__) )
5239 (void)fprintf (st, "\n Compiler: IBM XL C/C++ for Linux V%s", __xlc__);
5240 # endif
5241 # if ( !defined(_AIX) && !defined(__clang_version__) && !defined(__PASE__) && !defined(__linux__) && defined(__xlc__) )
5242 # if defined(__PPC__) && defined(__APPLE__)
5243 (void)fprintf (st, "\n Compiler: IBM XL C/C++ V%s for Mac OS X", __xlc__);
5244 # else
5245 (void)fprintf (st, "\n Compiler: IBM XL C/C++ V%s", __xlc__);
5246 # endif
5247 # endif
5248 #elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) || defined(__SUNPRO_CC_COMPAT)
5249 # define VER_ENC(maj, min, rev) \
5250 (((maj) * 1000000) + ((min) * 1000) + (rev))
5251 # define VER_DEC_MAJ(ver) \
5252 ((ver) / 1000000)
5253 # define VER_DEC_MIN(ver) \
5254 (((ver) % 1000000) / 1000)
5255 # define VER_DEC_REV(ver) \
5256 ((ver) % 1000)
5257 # if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
5258 # define COMP_VER VER_ENC( \
5259 (((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), \
5260 (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), \
5261 (__SUNPRO_C & 0xf) * 10)
5262 # elif defined(__SUNPRO_C)
5263 # define COMP_VER VER_ENC( \
5264 (__SUNPRO_C >> 8) & 0xf, \
5265 (__SUNPRO_C >> 4) & 0xf, \
5266 (__SUNPRO_C) & 0xf)
5267 # elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
5268 # define COMP_VER VER_ENC( \
5269 (((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), \
5270 (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), \
5271 (__SUNPRO_CC & 0xf) * 10)
5272 # elif defined(__SUNPRO_CC)
5273 # define COMP_VER VER_ENC( \
5274 (__SUNPRO_CC >> 8) & 0xf, \
5275 (__SUNPRO_CC >> 4) & 0xf, \
5276 (__SUNPRO_CC) & 0xf)
5277 # endif
5278 # if !defined(COMP_VER)
5279 # define COMP_VER 0
5280 # endif
5281 (void)fprintf (st, "\n Compiler: Oracle Developer Studio C/C++ %d.%d.%d",
5282 VER_DEC_MAJ(COMP_VER),
5283 VER_DEC_MIN(COMP_VER),
5284 VER_DEC_REV(COMP_VER));
5285 #elif defined(__DMC__)
5286 (void)fprintf (st, "\n Compiler: Digital Mars C/C++");
5287 #elif defined(__PCC__)
5288 (void)fprintf (st, "\n Compiler: Portable C Compiler");
5289 #elif defined(KENC) || defined(KENCC) || defined(__KENC__) || defined(__KENCC__)
5290 (void)fprintf (st, "\n Compiler: Plan 9 Compiler Suite");
5291 #elif defined(__ACK__)
5292 (void)fprintf (st, "\n Compiler: Amsterdam Compiler Kit");
5293 #elif defined(__COMO__)
5294 (void)fprintf (st, "\n Compiler: Comeau C++");
5295 #elif defined(__COMPCERT__)
5296 (void)fprintf (st, "\n Compiler: CompCert C");
5297 #elif defined(__COVERITY__)
5298 (void)fprintf (st, "\n Compiler: Coverity C/C++ Static Analyzer");
5299 #elif defined(__LCC__)
5300 (void)fprintf (st, "\n Compiler: Local C Compiler (lcc)");
5301 #elif defined(sgi) || defined(__sgi) || defined(_sgi) || defined(_SGI_COMPILER_VERSION)
5302 (void)fprintf (st, "\n Compiler: SGI MIPSpro");
5303 #elif defined(__OPEN64__)
5304 (void)fprintf (st, "\n Compiler: Open64 %s", __OPEN64__);
5305 #elif defined(__PGI) || defined(__PGIC__)
5306 (void)fprintf (st, "\n Compiler: Portland Group/PGI C/C++");
5307 #elif defined(__VBCC__)
5308 (void)fprintf (st, "\n Compiler: Volker Barthelmann C Compiler (vbcc)");
5309 #elif defined(__WATCOMC__)
5310 (void)fprintf (st, "\n Compiler: Watcom C/C++ %d.%d",
5311 __WATCOMC__ / 100,
5312 __WATCOMC__ % 100);
5313 #elif defined(__xlC__)
5314 (void)fprintf (st, "\n Compiler: IBM XL C/C++");
5315 #elif defined(__INTEL_COMPILER) || defined(__ICC)
5316 # if defined(__INTEL_COMPILER_UPDATE)
5317 # if defined(__INTEL_COMPILER_BUILD_DATE)
5318 (void)fprintf (st, "\n Compiler: Intel C++ Compiler %d.%d (%d)",
5319 __INTEL_COMPILER, __INTEL_COMPILER_UPDATE,
5320 __INTEL_COMPILER_BUILD_DATE);
5321 # else
5322 (void)fprintf (st, "\n Compiler: Intel C++ Compiler %d.%d",
5323 __INTEL_COMPILER, __INTEL_COMPILER_UPDATE);
5324 # endif
5325 # else
5326 (void)fprintf (st, "\n Compiler: Intel C++ Compiler %d",
5327 __INTEL_COMPILER);
5328 # endif
5329 #elif defined(SIM_COMPILER)
5330 # define S_xstr(a) S_str(a)
5331 # define S_str(a) #a
5332 (void)fprintf (st, "\n Compiler: %s", S_xstr(SIM_COMPILER));
5333 # undef S_str
5334 # undef S_xstr
5335 #else
5336 (void)fprintf (st, "\n Compiler: Unknown");
5337 #endif
5338
5339 #if defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__) || defined(__powerpc64__) || \
5340 defined(__POWERPC64__) || defined(_M_PPC64) || defined(__PPC64) || defined(_ARCH_PPC64)
5341 # define SC_IS_PPC64 1
5342 #else
5343 # define SC_IS_PPC64 0
5344 #endif
5345
5346 #if defined(__ppc__) || defined(__PPC__) || defined(__powerpc__) || defined(__POWERPC__) || defined(_M_PPC) || defined(__PPC) || \
5347 defined(__ppc32__) || defined(__PPC32__) || defined(__powerpc32__) || defined(__POWERPC32__) || defined(_M_PPC32) || \
5348 defined(__PPC32)
5349 # define SC_IS_PPC32 1
5350 #else
5351 # define SC_IS_PPC32 0
5352 #endif
5353
5354 #if defined(_M_X64) || defined(_M_AMD64) || defined(__amd64__) || defined(__x86_64__) || defined(__AMD64)
5355 arch = " x86_64";
5356 #elif defined(_M_IX86) || defined(__i386) || defined(__i486) || defined(__i586) || defined(__i686) || defined(__ix86)
5357 arch = " x86";
5358 #elif defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__)
5359 arch = " arm64";
5360 #elif defined(_M_ARM) || defined(__arm__)
5361 arch = " arm";
5362 #elif defined(__ia64__) || defined(_M_IA64) || defined(__itanium__)
5363 arch = " ia64";
5364 #elif SC_IS_PPC64
5365 arch = " powerpc64";
5366 #elif SC_IS_PPC32
5367 arch = " powerpc";
5368 #elif defined(__s390x__)
5369 arch = " s390x";
5370 #elif defined(__s390__)
5371 arch = " s390";
5372 #elif defined(__J2__) || defined(__J2P__) || defined(__j2__) || defined(__j2p__)
5373 arch = " j2";
5374 #elif defined(__SH4__) || defined(__sh4__) || defined(__SH4) || defined(__sh4)
5375 arch = " sh4";
5376 #elif defined(__SH2__) || defined(__sh2__) || defined(__SH2) || defined(__sh2)
5377 arch = " sh2";
5378 #elif defined(__alpha__)
5379 arch = " alpha";
5380 #elif defined(__hppa__) || defined(__HPPA__) || defined(__PARISC__) || defined(__parisc__)
5381 arch = " hppa";
5382 #elif defined(__ICE9__) || defined(__ice9__) || defined(__ICE9) || defined(__ice9)
5383 arch = " ice9";
5384 #elif defined(mips64) || defined(__mips64__) || defined(MIPS64) || defined(_MIPS64_) || defined(__mips64)
5385 arch = " mips64";
5386 #elif defined(mips) || defined(__mips__) || defined(MIPS) || defined(_MIPS_) || defined(__mips)
5387 arch = " mips";
5388 #elif defined(__OpenRISC__) || defined(__OPENRISC__) || defined(__openrisc__) || \
5389 defined(__OR1K__) || defined(__JOR1K__) || defined(__OPENRISC1K__) || defined(__OPENRISC1200__)
5390 arch = " openrisc";
5391 #elif defined(__sparc64) || defined(__SPARC64) || defined(__SPARC64__) || defined(__sparc64__)
5392 arch = " sparc64";
5393 #elif defined(__sparc) || defined(__SPARC) || defined(__SPARC__) || defined(__sparc__)
5394 arch = " sparc";
5395 #elif defined(__riscv) || defined(__riscv__)
5396 arch = " riscv";
5397 #elif defined(__myriad2__)
5398 arch = " myriad2";
5399 #elif defined(__loongarch64) || defined(__loongarch__)
5400 arch = " loongarch";
5401 #elif defined(_m68851) || defined(__m68k__) || defined(__m68000__) || defined(__M68K)
5402 arch = " m68k";
5403 #elif defined(__m88k__) || defined(__m88000__) || defined(__M88K)
5404 arch = " m88k";
5405 #elif defined(__VAX__) || defined(__vax__)
5406 arch = " vax";
5407 #elif defined(__NIOS2__) || defined(__nios2__)
5408 arch = " nios2";
5409 #elif defined(__MICROBLAZE__) || defined(__microblaze__)
5410 arch = " microblaze";
5411 #else
5412 arch = " ";
5413 #endif
5414 (void)fprintf (st, "%s", arch);
5415 #if defined(BUILD_BY_USER)
5416 (void)fprintf (st, "\n Built by: %s", BUILD_BY_USER);
5417 #else
5418 # if defined(GENERATED_MAKE_VER_H) && defined(VER_H_PREP_USER)
5419 (void)fprintf (st, "\n Built by: %s", VER_H_PREP_USER);
5420 # endif
5421 #endif
5422 (void)fprintf (st, "\n\n Host System Information:");
5423 #if defined(_WIN32)
5424 if (1) {
5425 char *arch = getenv ("PROCESSOR_ARCHITECTURE");
5426 char *proc_arch3264 = getenv ("PROCESSOR_ARCHITEW6432");
5427 char osversion[PATH_MAX+1] = "";
5428 FILE *f;
5429
5430 if ((f = _popen ("ver", "r"))) {
5431 (void)memset (osversion, 0, sizeof(osversion));
5432 do {
5433 if (NULL == fgets (osversion, sizeof(osversion)-1, f))
5434 break;
5435 sim_trim_endspc (osversion);
5436 } while (osversion[0] == '\0');
5437 _pclose (f);
5438 }
5439 (void)fprintf (st, "\n Host OS: %s", osversion);
5440 (void)fprintf (st, " %s%s%s", arch, proc_arch3264 ? " on " : "", proc_arch3264 ? proc_arch3264 : "");
5441 }
5442 #else
5443 if (1) {
5444 char osversion[2*PATH_MAX+1] = "";
5445 FILE *f;
5446 # if !defined(_AIX)
5447 if ((f = popen \
5448 ("uname -mrs 2> /dev/null", "r"))) {
5449 # else
5450 if ((f = popen \
5451 ("sh -c 'echo \"$(command -p env uname -v \
5452 2> /dev/null).$(command -p env uname -r \
5453 2> /dev/null) $(command -p env uname -p \
5454 2> /dev/null)\"' 2> /dev/null", "r"))) {
5455 # endif
5456 (void)memset (osversion, 0, sizeof(osversion));
5457 do {
5458 if (NULL == fgets (osversion, sizeof(osversion)-1, f)) {
5459 break;
5460 }
5461 sim_trim_endspc (osversion);
5462 } while (osversion[0] == '\0');
5463 pclose (f);
5464 strremove(osversion, "0000000000000000 ");
5465 strremove(osversion, " 0000000000000000");
5466 strremove(osversion, "000000000000 ");
5467 strremove(osversion, " 000000000000");
5468 strremove(osversion, "IBM ");
5469 strremove(osversion, " (emulated by qemu)");
5470 strremove(osversion, " (emulated by QEMU)");
5471 }
5472 # if !defined(_AIX)
5473 (void)fprintf (st, "\n Host OS: %s", osversion);
5474 # else
5475 strremove(osversion, "AIX ");
5476 # if !defined(__PASE__)
5477 (void)fprintf (st, "\n Host OS: IBM AIX %s", osversion);
5478 # else
5479 (void)fprintf (st, "\n Host OS: IBM OS/400 (PASE) %s", osversion);
5480 # endif
5481 # endif
5482 } else {
5483 # if !defined(_AIX)
5484 (void)fprintf (st, "\n Host OS: Unknown");
5485 # else
5486 # if !defined(__PASE__)
5487 (void)fprintf (st, "\n Host OS: IBM AIX");
5488 # else
5489 (void)fprintf (st, "\n Host OS: IBM OS/400 (PASE)");
5490 # endif
5491 # endif
5492 }
5493 #endif
5494 #if defined(__APPLE__)
5495 int isRosetta = processIsTranslated();
5496 if (isRosetta == 1) {
5497 sim_printf ("\n\n ****** RUNNING UNDER APPLE ROSETTA 2, EXPECT REDUCED PERFORMANCE ******");
5498 }
5499 #endif
5500 if (nodist)
5501 {
5502 sim_printf ("\n\n ********* LICENSE RESTRICTED BUILD *** NOT FOR REDISTRIBUTION *********\n");
5503 }
5504 else
5505 {
5506 (void)fprintf (st, "\n");
5507 (void)fprintf (st, "\n This software is made available under the terms of the ICU License.");
5508 (void)fprintf (st, "\n For complete license details, see the LICENSE file included with the");
5509 (void)fprintf (st, "\n software or https://gitlab.com/dps8m/dps8m/-/blob/master/LICENSE.md");
5510 }
5511 (void)fprintf (st, "\n");
5512 }
5513 return SCPE_OK;
5514 }
5515
5516 t_stat show_config (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5517 {
5518 size_t i;
5519 DEVICE *dptr;
5520 t_bool only_enabled = (sim_switches & SWMASK ('E'));
5521
5522 if (cptr && (*cptr != 0))
5523 return SCPE_2MARG;
5524 (void)fprintf (st, "%s simulator configuration%s\n\n", sim_name, only_enabled ? " (enabled devices)" : "");
5525 for (i = 0; (dptr = sim_devices[i]) != NULL; i++)
5526 if (!only_enabled || !qdisable (dptr))
5527 show_device (st, dptr, flag);
5528 return SCPE_OK;
5529 }
5530
5531 t_stat show_log_names (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5532 {
5533 int32 i;
5534 DEVICE *dptr;
5535
5536 if (cptr && (*cptr != 0))
5537 return SCPE_2MARG;
5538 for (i = 0; (dptr = sim_devices[i]) != NULL; i++)
5539 show_dev_logicals (st, dptr, NULL, 1, cptr);
5540 return SCPE_OK;
5541 }
5542
5543 t_stat show_dev_logicals (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5544 {
5545 if (dptr->lname)
5546 (void)fprintf (st, "%s -> %s\n", dptr->lname, dptr->name);
5547 else if (!flag)
5548 fputs ("no logical name assigned\n", st);
5549 return SCPE_OK;
5550 }
5551
5552 t_stat show_queue (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5553 {
5554 DEVICE *dptr;
5555 UNIT *uptr;
5556 int32 accum;
5557
5558 if (cptr && (*cptr != 0))
5559 return SCPE_2MARG;
5560 if (sim_clock_queue == QUEUE_LIST_END)
5561 (void)fprintf (st, "%s event queue empty, time = %.0f, executing %.0f instructions/sec\n",
5562 sim_name, sim_time, sim_timer_inst_per_sec ());
5563 else {
5564 const char *tim;
5565
5566 (void)fprintf (st, "%s event queue status, time = %.0f, executing %.0f instructions/sec\n",
5567 sim_name, sim_time, sim_timer_inst_per_sec ());
5568 accum = 0;
5569 for (uptr = sim_clock_queue; uptr != QUEUE_LIST_END; uptr = uptr->next) {
5570 if (uptr == &sim_step_unit)
5571 (void)fprintf (st, " Step timer");
5572 else
5573 if (uptr == &sim_expect_unit)
5574 (void)fprintf (st, " Expect fired");
5575 else
5576 if ((dptr = find_dev_from_unit (uptr)) != NULL) {
5577 (void)fprintf (st, " %s", sim_dname (dptr));
5578 if (dptr->numunits > 1)
5579 (void)fprintf (st, " unit %d", (int32) (uptr - dptr->units));
5580 }
5581 else
5582 (void)fprintf (st, " Unknown");
5583 tim = sim_fmt_secs((accum + uptr->time)/sim_timer_inst_per_sec ());
5584 (void)fprintf (st, " at %d%s%s%s%s\n", accum + uptr->time,
5585 (*tim) ? " (" : "", tim, (*tim) ? ")" : "",
5586 (uptr->flags & UNIT_IDLE) ? " (Idle capable)" : "");
5587 accum = accum + uptr->time;
5588 }
5589 }
5590 sim_show_clock_queues (st, dnotused, unotused, flag, cptr);
5591 return SCPE_OK;
5592 }
5593
5594 t_stat show_time (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5595 {
5596 if (cptr && (*cptr != 0))
5597 return SCPE_2MARG;
5598 (void)fprintf (st, "Time:\t%.0f\n", sim_gtime());
5599 return SCPE_OK;
5600 }
5601
5602 t_stat show_break (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5603 {
5604 t_stat r;
5605
5606 if (cptr && (*cptr != 0))
5607 r = ssh_break (st, cptr, 1);
5608 else
5609 r = sim_brk_showall (st, sim_switches);
5610 return r;
5611 }
5612
5613 t_stat show_dev_radix (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5614 {
5615 (void)fprintf (st, "Radix=%d\n", dptr->dradix);
5616 return SCPE_OK;
5617 }
5618
5619 t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5620 {
5621 int32 any = 0;
5622 DEBTAB *dep;
5623
5624 if (dptr->flags & DEV_DEBUG) {
5625 if (dptr->dctrl == 0)
5626 fputs ("Debugging disabled", st);
5627 else if (dptr->debflags == NULL)
5628 fputs ("Debugging enabled", st);
5629 else {
5630 uint32 dctrl = dptr->dctrl;
5631
5632 fputs ("Debug=", st);
5633 for (dep = dptr->debflags; (dctrl != 0) && (dep->name != NULL); dep++) {
5634 if ((dctrl & dep->mask) == dep->mask) {
5635 dctrl &= ~dep->mask;
5636 if (any)
5637 fputc (';', st);
5638 fputs (dep->name, st);
5639 any = 1;
5640 }
5641 }
5642 }
5643 fputc ('\n', st);
5644 return SCPE_OK;
5645 }
5646 else return SCPE_NOFNC;
5647 }
5648
5649
5650
5651 t_stat show_on (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5652 {
5653 int32 lvl, i;
5654
5655 if (cptr && (*cptr != 0)) return SCPE_2MARG;
5656 for (lvl=sim_do_depth; lvl >= 0; --lvl) {
5657 if (lvl > 0)
5658 (void)fprintf(st, "On Processing at Do Nest Level: %d", lvl);
5659 else
5660 (void)fprintf(st, "On Processing for input commands");
5661 (void)fprintf(st, " is %s\n", (sim_on_check[lvl]) ? "enabled" : "disabled");
5662 for (i=1; i<SCPE_BASE; ++i) {
5663 if (sim_on_actions[lvl][i])
5664 (void)fprintf(st, " on %5d %s\n", i, sim_on_actions[lvl][i]); }
5665 for (i=SCPE_BASE; i<=SCPE_MAX_ERR; ++i) {
5666 if (sim_on_actions[lvl][i])
5667 (void)fprintf(st, " on %-5s %s\n", scp_errors[i-SCPE_BASE].code, sim_on_actions[lvl][i]); }
5668 if (sim_on_actions[lvl][0])
5669 (void)fprintf(st, " on ERROR %s\n", sim_on_actions[lvl][0]);
5670 (void)fprintf(st, "\n");
5671 }
5672 if (sim_on_inherit)
5673 (void)fprintf(st, "on state and actions are inherited by nested do commands and subroutines\n");
5674 return SCPE_OK;
5675 }
5676
5677
5678
5679 t_stat show_mod_names (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5680 {
5681 int32 i;
5682 DEVICE *dptr;
5683
5684 if (cptr && (*cptr != 0))
5685 return SCPE_2MARG;
5686 for (i = 0; (dptr = sim_devices[i]) != NULL; i++)
5687 show_dev_modifiers (st, dptr, NULL, flag, cptr);
5688 for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i)
5689 show_dev_modifiers (st, dptr, NULL, flag, cptr);
5690 return SCPE_OK;
5691 }
5692
5693 t_stat show_dev_modifiers (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5694 {
5695 fprint_set_help (st, dptr);
5696 return SCPE_OK;
5697 }
5698
5699 t_stat show_all_mods (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, int32 *toks)
5700 {
5701 MTAB *mptr;
5702 t_stat r = SCPE_OK;
5703
5704 if (dptr->modifiers == NULL)
5705 return SCPE_OK;
5706 for (mptr = dptr->modifiers; mptr->mask != 0; mptr++) {
5707 if (mptr->pstring &&
5708 ((mptr->mask & MTAB_XTD)?
5709 (MODMASK(mptr,flag) && !MODMASK(mptr,MTAB_NMO)):
5710 ((MTAB_VUN == (uint32)flag) && ((uptr->flags & mptr->mask) == mptr->match)))) {
5711 if (*toks > 0) {
5712 (void)fprintf (st, "\n");
5713 *toks = 0;
5714 }
5715 if (r == SCPE_OK)
5716 fprint_sep (st, toks);
5717 r = show_one_mod (st, dptr, uptr, mptr, NULL, 0);
5718 }
5719 }
5720 return SCPE_OK;
5721 }
5722
5723 t_stat show_one_mod (FILE *st, DEVICE *dptr, UNIT *uptr, MTAB *mptr,
5724 CONST char *cptr, int32 flag)
5725 {
5726 t_stat r = SCPE_OK;
5727
5728 if (mptr->disp)
5729 r = mptr->disp (st, uptr, mptr->match, (CONST void *)(cptr? cptr: mptr->desc));
5730 else
5731 fputs (mptr->pstring, st);
5732 if ((r == SCPE_OK) && (flag && !((mptr->mask & MTAB_XTD) && MODMASK(mptr,MTAB_NMO))))
5733 fputc ('\n', st);
5734 return r;
5735 }
5736
5737
5738
5739 t_stat show_show_commands (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr)
5740 {
5741 int32 i;
5742 DEVICE *dptr;
5743
5744 if (cptr && (*cptr != 0))
5745 return SCPE_2MARG;
5746 for (i = 0; (dptr = sim_devices[i]) != NULL; i++)
5747 show_dev_show_commands (st, dptr, NULL, flag, cptr);
5748 for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i)
5749 show_dev_show_commands (st, dptr, NULL, flag, cptr);
5750 return SCPE_OK;
5751 }
5752
5753 t_stat show_dev_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr)
5754 {
5755 fprint_show_help (st, dptr);
5756 return SCPE_OK;
5757 }
5758
5759
5760
5761 t_stat brk_cmd (int32 flg, CONST char *cptr)
5762 {
5763 GET_SWITCHES (cptr);
5764 return ssh_break (NULL, cptr, flg);
5765 }
5766
5767 t_stat ssh_break (FILE *st, const char *cptr, int32 flg)
5768 {
5769 char gbuf[CBUFSIZE], *aptr, abuf[4*CBUFSIZE];
5770 CONST char *tptr, *t1ptr;
5771 DEVICE *dptr = sim_dflt_dev;
5772 UNIT *uptr;
5773 t_stat r;
5774 t_addr lo, hi, max;
5775 int32 cnt;
5776
5777 if (sim_brk_types == 0)
5778 return sim_messagef (SCPE_NOFNC, "No breakpoint support in this simulator\n");
5779 if (dptr == NULL)
5780 return SCPE_IERR;
5781 uptr = dptr->units;
5782 if (uptr == NULL)
5783 return SCPE_IERR;
5784 max = uptr->capac - 1;
5785 abuf[sizeof(abuf)-1] = '\0';
5786 strncpy (abuf, cptr, sizeof(abuf)-1);
5787 cptr = abuf;
5788 if ((aptr = strchr (abuf, ';'))) {
5789 if (flg != SSH_ST)
5790 return sim_messagef (SCPE_ARG, "Invalid argument: %s\n", aptr);
5791 *aptr++ = 0;
5792 }
5793 if (*cptr == 0) {
5794 lo = (t_addr) get_rval (sim_PC, 0);
5795 return ssh_break_one (st, flg, lo, 0, aptr);
5796 }
5797 while (*cptr) {
5798 cptr = get_glyph (cptr, gbuf, ',');
5799 tptr = get_range (dptr, gbuf, &lo, &hi, dptr->aradix, max, 0);
5800 if (tptr == NULL)
5801 return sim_messagef (SCPE_ARG, "Invalid address specifier: %s\n", gbuf);
5802 if (*tptr == '[') {
5803 cnt = (int32) strtotv (tptr + 1, &t1ptr, 10);
5804 if ((tptr == t1ptr) || (*t1ptr != ']') || (flg != SSH_ST))
5805 return sim_messagef (SCPE_ARG, "Invalid repeat count specifier: %s\n", tptr + 1);
5806 tptr = t1ptr + 1;
5807 }
5808 else cnt = 0;
5809 if (*tptr != 0)
5810 return sim_messagef (SCPE_ARG, "Unexpected argument: %s\n", tptr);
5811 if ((lo == 0) && (hi == max)) {
5812 if (flg == SSH_CL)
5813 sim_brk_clrall (sim_switches);
5814 else
5815 if (flg == SSH_SH)
5816 sim_brk_showall (st, sim_switches);
5817 else
5818 return SCPE_ARG;
5819 }
5820 else {
5821 for ( ; lo <= hi; lo = lo + 1) {
5822 r = ssh_break_one (st, flg, lo, cnt, aptr);
5823 if (r != SCPE_OK)
5824 return r;
5825 }
5826 }
5827 }
5828 return SCPE_OK;
5829 }
5830
5831 t_stat ssh_break_one (FILE *st, int32 flg, t_addr lo, int32 cnt, CONST char *aptr)
5832 {
5833 if (!sim_brk_types)
5834 return sim_messagef (SCPE_NOFNC, "No breakpoint support in this simulator\n");
5835 switch (flg) {
5836 case SSH_ST:
5837 return sim_brk_set (lo, sim_switches, cnt, aptr);
5838
5839 break;
5840
5841 case SSH_CL:
5842 return sim_brk_clr (lo, sim_switches);
5843
5844 break;
5845
5846 case SSH_SH:
5847 return sim_brk_show (st, lo, sim_switches);
5848
5849 break;
5850
5851 default:
5852 return SCPE_ARG;
5853 }
5854 }
5855
5856
5857
5858 static t_bool run_cmd_did_reset = FALSE;
5859
5860 t_stat reset_cmd (int32 flag, CONST char *cptr)
5861 {
5862 char gbuf[CBUFSIZE];
5863 DEVICE *dptr;
5864
5865 GET_SWITCHES (cptr);
5866 run_cmd_did_reset = FALSE;
5867 if (*cptr == 0)
5868 return (reset_all (0));
5869 cptr = get_glyph (cptr, gbuf, 0);
5870 if (*cptr != 0)
5871 return SCPE_2MARG;
5872 if (strcmp (gbuf, "ALL") == 0)
5873 return (reset_all (0));
5874 dptr = find_dev (gbuf);
5875 if (dptr == NULL)
5876 return SCPE_NXDEV;
5877 if (dptr->reset != NULL)
5878 return dptr->reset (dptr);
5879 else return SCPE_OK;
5880 }
5881
5882
5883
5884
5885
5886
5887
5888
5889
5890 t_stat reset_all (uint32 start)
5891 {
5892 DEVICE *dptr;
5893 uint32 i;
5894 t_stat reason;
5895
5896 for (i = 0; i < start; i++) {
5897 if (sim_devices[i] == NULL)
5898 return SCPE_IERR;
5899 }
5900 for (i = start; (dptr = sim_devices[i]) != NULL; i++) {
5901 if (dptr->reset != NULL) {
5902 reason = dptr->reset (dptr);
5903 if (reason != SCPE_OK)
5904 return reason;
5905 }
5906 }
5907 for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i) {
5908 if (dptr->reset != NULL) {
5909 reason = dptr->reset (dptr);
5910 if (reason != SCPE_OK)
5911 return reason;
5912 }
5913 }
5914 return SCPE_OK;
5915 }
5916
5917
5918
5919
5920
5921
5922
5923
5924
5925 t_stat reset_all_p (uint32 start)
5926 {
5927 t_stat r;
5928 int32 old_sw = sim_switches;
5929
5930 sim_switches = SWMASK ('P');
5931 r = reset_all (start);
5932 sim_switches = old_sw;
5933 return r;
5934 }
5935
5936
5937
5938 t_stat attach_cmd (int32 flag, CONST char *cptr)
5939 {
5940 char gbuf[4*CBUFSIZE];
5941 DEVICE *dptr;
5942 UNIT *uptr;
5943 t_stat r;
5944
5945 GET_SWITCHES (cptr);
5946 if ((NULL == cptr) || (*cptr == 0))
5947 return SCPE_2FARG;
5948 cptr = get_glyph (cptr, gbuf, 0);
5949 GET_SWITCHES (cptr);
5950 if ((NULL == cptr) || (*cptr == 0))
5951 return SCPE_2FARG;
5952 dptr = find_unit (gbuf, &uptr);
5953 if (dptr == NULL)
5954 return SCPE_NXDEV;
5955 if (uptr == NULL)
5956 return SCPE_NXUN;
5957 if (uptr->flags & UNIT_ATT) {
5958 if (!(uptr->dynflags & UNIT_ATTMULT) &&
5959 !(dptr->flags & DEV_DONTAUTO)) {
5960 r = scp_detach_unit (dptr, uptr);
5961 if (r != SCPE_OK)
5962 return r; }
5963 else {
5964 if (!(uptr->dynflags & UNIT_ATTMULT))
5965 return SCPE_ALATT;
5966 }
5967 }
5968 gbuf[sizeof(gbuf)-1] = '\0';
5969 strncpy (gbuf, cptr, sizeof(gbuf)-1);
5970 sim_trim_endspc (gbuf);
5971 return scp_attach_unit (dptr, uptr, gbuf);
5972 }
5973
5974
5975
5976 t_stat scp_attach_unit (DEVICE *dptr, UNIT *uptr, const char *cptr)
5977 {
5978 if (dptr->attach != NULL)
5979 return dptr->attach (uptr, (CONST char *)cptr);
5980 return attach_unit (uptr, (CONST char *)cptr);
5981 }
5982
5983
5984
5985 t_stat attach_unit (UNIT *uptr, CONST char *cptr)
5986 {
5987 DEVICE *dptr;
5988
5989 if (uptr->flags & UNIT_DIS)
5990 return SCPE_UDIS;
5991 if (!(uptr->flags & UNIT_ATTABLE))
5992 return SCPE_NOATT;
5993 if ((dptr = find_dev_from_unit (uptr)) == NULL)
5994 return SCPE_NOATT;
5995 uptr->filename = (char *) calloc (CBUFSIZE, sizeof (char));
5996 if (uptr->filename == NULL)
5997 return SCPE_MEM;
5998 strncpy (uptr->filename, cptr, CBUFSIZE-1);
5999 if ((sim_switches & SWMASK ('R')) ||
6000 ((uptr->flags & UNIT_RO) != 0)) {
6001 if (((uptr->flags & UNIT_ROABLE) == 0) &&
6002 ((uptr->flags & UNIT_RO) == 0))
6003 return attach_err (uptr, SCPE_NORO);
6004 uptr->fileref = sim_fopen (cptr, "rb");
6005 if (uptr->fileref == NULL)
6006 return attach_err (uptr, SCPE_OPENERR);
6007 uptr->flags = uptr->flags | UNIT_RO;
6008 if (!sim_quiet && !(sim_switches & SWMASK ('Q'))) {
6009 sim_printf ("%s: unit is read only (%s)\n", sim_dname (dptr), cptr);
6010 }
6011 }
6012 else {
6013 if (sim_switches & SWMASK ('N')) {
6014 uptr->fileref = sim_fopen (cptr, "wb+");
6015 if (uptr->fileref == NULL)
6016 return attach_err (uptr, SCPE_OPENERR);
6017 if (!sim_quiet && !(sim_switches & SWMASK ('Q'))) {
6018 sim_printf ("%s: creating new file (%s)\n", sim_dname (dptr), cptr);
6019 }
6020 }
6021 else {
6022 uptr->fileref = sim_fopen (cptr, "rb+");
6023 if (uptr->fileref == NULL) {
6024 #if defined(EWOULDBLOCK)
6025 if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
6026 #else
6027 if ((errno == EAGAIN))
6028 #endif
6029 return attach_err (uptr, SCPE_OPENERR);
6030
6031 #if defined(EPERM)
6032 if ((errno == EROFS) || (errno == EACCES) || (errno == EPERM)) {
6033 #else
6034 if ((errno == EROFS) || (errno == EACCES)) {
6035 #endif
6036 if ((uptr->flags & UNIT_ROABLE) == 0)
6037 return attach_err (uptr, SCPE_NORO);
6038 uptr->fileref = sim_fopen (cptr, "rb");
6039 if (uptr->fileref == NULL)
6040 return attach_err (uptr, SCPE_OPENERR);
6041 uptr->flags = uptr->flags | UNIT_RO;
6042 if (!sim_quiet) {
6043 sim_printf ("%s: unit is read only (%s)\n", sim_dname (dptr), cptr);
6044 }
6045 }
6046 else {
6047 if (sim_switches & SWMASK ('E'))
6048 return attach_err (uptr, SCPE_OPENERR);
6049 uptr->fileref = sim_fopen (cptr, "wb+");
6050 if (uptr->fileref == NULL)
6051 return attach_err (uptr, SCPE_OPENERR);
6052 if (!sim_quiet) {
6053 sim_printf ("%s: creating new file (%s)\n", sim_dname (dptr), cptr);
6054 }
6055 }
6056 }
6057 }
6058 }
6059 if (uptr->flags & UNIT_BUFABLE) {
6060 uint32 cap = ((uint32) uptr->capac) / dptr->aincr;
6061 if (uptr->flags & UNIT_MUSTBUF)
6062 uptr->filebuf = calloc (cap, SZ_D (dptr));
6063 if (uptr->filebuf == NULL)
6064 return attach_err (uptr, SCPE_MEM);
6065 if (!sim_quiet) {
6066 sim_printf ("%s: buffering file in memory\n", sim_dname (dptr));
6067 }
6068 uptr->hwmark = (uint32)sim_fread (uptr->filebuf,
6069 SZ_D (dptr), cap, uptr->fileref);
6070 uptr->flags = uptr->flags | UNIT_BUF;
6071 }
6072 uptr->flags = uptr->flags | UNIT_ATT;
6073 uptr->pos = 0;
6074 return SCPE_OK;
6075 }
6076
6077 t_stat attach_err (UNIT *uptr, t_stat stat)
6078 {
6079 FREE (uptr->filename);
6080 uptr->filename = NULL;
6081 return stat;
6082 }
6083
6084
6085
6086 t_stat detach_cmd (int32 flag, CONST char *cptr)
6087 {
6088 char gbuf[CBUFSIZE];
6089 DEVICE *dptr;
6090 UNIT *uptr;
6091
6092 GET_SWITCHES (cptr);
6093 if ((NULL == cptr) || (*cptr == 0))
6094 return SCPE_2FARG;
6095 cptr = get_glyph (cptr, gbuf, 0);
6096 if (*cptr != 0)
6097 return SCPE_2MARG;
6098 if (strcmp (gbuf, "ALL") == 0)
6099 return (detach_all (0, FALSE));
6100 dptr = find_unit (gbuf, &uptr);
6101 if (dptr == NULL)
6102 return SCPE_NXDEV;
6103 if (uptr == NULL)
6104 return SCPE_NXUN;
6105 return scp_detach_unit (dptr, uptr);
6106 }
6107
6108
6109
6110
6111
6112
6113
6114
6115
6116
6117
6118
6119
6120
6121 t_stat detach_all (int32 start, t_bool shutdown)
6122 {
6123 uint32 i, j;
6124 DEVICE *dptr;
6125 UNIT *uptr;
6126 t_stat r;
6127
6128 if ((start < 0) || (start > 1))
6129 return SCPE_IERR;
6130 if (shutdown)
6131 sim_switches = sim_switches | SIM_SW_SHUT;
6132 for (i = start; (dptr = sim_devices[i]) != NULL; i++) {
6133 for (j = 0; j < dptr->numunits; j++) {
6134 uptr = (dptr->units) + j;
6135 if ((uptr->flags & UNIT_ATT) ||
6136 (shutdown && dptr->detach &&
6137 !(uptr->flags & UNIT_ATTABLE))) {
6138 r = scp_detach_unit (dptr, uptr);
6139
6140 if ((r != SCPE_OK) && !shutdown)
6141 return r;
6142 }
6143 }
6144 }
6145 return SCPE_OK;
6146 }
6147
6148
6149
6150 t_stat scp_detach_unit (DEVICE *dptr, UNIT *uptr)
6151 {
6152 if (dptr->detach != NULL)
6153 return dptr->detach (uptr);
6154 return detach_unit (uptr);
6155 }
6156
6157
6158
6159 t_stat detach_unit (UNIT *uptr)
6160 {
6161 DEVICE *dptr;
6162
6163 if (uptr == NULL)
6164 return SCPE_IERR;
6165 if (!(uptr->flags & UNIT_ATTABLE))
6166 return SCPE_NOATT;
6167 if (!(uptr->flags & UNIT_ATT)) {
6168 if (sim_switches & SIM_SW_REST)
6169 return SCPE_OK;
6170 else
6171 return SCPE_NOTATT;
6172 }
6173 if ((dptr = find_dev_from_unit (uptr)) == NULL)
6174 return SCPE_OK;
6175 if (uptr->flags & UNIT_BUF) {
6176 uint32 cap = (uptr->hwmark + dptr->aincr - 1) / dptr->aincr;
6177 if (uptr->hwmark && ((uptr->flags & UNIT_RO) == 0)) {
6178 if (!sim_quiet) {
6179 sim_printf ("%s: writing buffer to file\n", sim_dname (dptr));
6180 }
6181 rewind (uptr->fileref);
6182 sim_fwrite (uptr->filebuf, SZ_D (dptr), cap, uptr->fileref);
6183 if (ferror (uptr->fileref))
6184 sim_printf ("%s: I/O error - %s (Error %d)",
6185 sim_dname (dptr), xstrerror_l(errno), errno);
6186 }
6187 if (uptr->flags & UNIT_MUSTBUF) {
6188 FREE (uptr->filebuf);
6189 uptr->filebuf = NULL;
6190 }
6191 uptr->flags = uptr->flags & ~UNIT_BUF;
6192 }
6193 uptr->flags = uptr->flags & ~(UNIT_ATT | UNIT_RO);
6194 FREE (uptr->filename);
6195 uptr->filename = NULL;
6196 if (fclose (uptr->fileref) == EOF)
6197 return SCPE_IOERR;
6198 return SCPE_OK;
6199 }
6200
6201
6202
6203 const char *sim_dname (DEVICE *dptr)
6204 {
6205 return (dptr ? (dptr->lname? dptr->lname: dptr->name) : "");
6206 }
6207
6208
6209
6210 const char *sim_uname (UNIT *uptr)
6211 {
6212 DEVICE *d = find_dev_from_unit(uptr);
6213 static char uname[CBUFSIZE];
6214
6215 if (!d)
6216 return "";
6217 if (d->numunits == 1)
6218 return sim_dname (d);
6219 (void)sprintf (uname, "%s%d", sim_dname (d), (int)(uptr-d->units));
6220 return uname;
6221 }
6222
6223
6224
6225 t_stat run_cmd (int32 flag, CONST char *cptr)
6226 {
6227 char gbuf[CBUFSIZE] = "";
6228 CONST char *tptr;
6229 uint32 i, j;
6230 int32 sim_next = 0;
6231 int32 unitno;
6232 t_value pcv, orig_pcv;
6233 t_stat r;
6234 DEVICE *dptr;
6235 UNIT *uptr;
6236
6237 GET_SWITCHES (cptr);
6238 sim_step = 0;
6239 if ((flag == RU_RUN) || (flag == RU_GO)) {
6240 orig_pcv = get_rval (sim_PC, 0);
6241 if (*cptr != 0) {
6242 cptr = get_glyph (cptr, gbuf, 0);
6243 if (MATCH_CMD (gbuf, "UNTIL") != 0) {
6244 if (sim_dflt_dev && sim_vm_parse_addr)
6245 pcv = sim_vm_parse_addr (sim_dflt_dev, gbuf, &tptr);
6246 else pcv = strtotv (gbuf, &tptr, sim_PC->radix);
6247 if ((tptr == gbuf) || (*tptr != 0) ||
6248 (pcv > width_mask[sim_PC->width]))
6249 return SCPE_ARG;
6250 put_rval (sim_PC, 0, pcv);
6251 }
6252 }
6253 if ((flag == RU_RUN) &&
6254 ((r = sim_run_boot_prep (flag)) != SCPE_OK)) {
6255 put_rval (sim_PC, 0, orig_pcv);
6256 return r;
6257 }
6258 if ((*cptr) || (MATCH_CMD (gbuf, "UNTIL") == 0)) {
6259 int32 saved_switches = sim_switches;
6260
6261 if (MATCH_CMD (gbuf, "UNTIL") != 0)
6262 cptr = get_glyph (cptr, gbuf, 0);
6263 if (MATCH_CMD (gbuf, "UNTIL") != 0)
6264 return sim_messagef (SCPE_2MARG, "Unexpected %s command argument: %s %s\n",
6265 (flag == RU_RUN) ? "RUN" : "GO", gbuf, cptr);
6266 sim_switches = 0;
6267 GET_SWITCHES (cptr);
6268 if ((*cptr == '\'') || (*cptr == '"')) {
6269 r = expect_cmd (1, cptr);
6270 if (r != SCPE_OK)
6271 return r;
6272 }
6273 else {
6274 if (sim_switches == 0)
6275 sim_switches = sim_brk_dflt;
6276 sim_switches |= BRK_TYP_TEMP;
6277 sim_brk_types |= BRK_TYP_TEMP;
6278 r = ssh_break (NULL, cptr, SSH_ST);
6279 if (r != SCPE_OK)
6280 return sim_messagef (r, "Unable to establish breakpoint at: %s\n", cptr);
6281 }
6282 sim_switches = saved_switches;
6283 }
6284 }
6285
6286 else if ((flag == RU_STEP) ||
6287 ((flag == RU_NEXT) && !sim_vm_is_subroutine_call)) {
6288 static t_bool not_implemented_message = FALSE;
6289
6290 if ((!not_implemented_message) && (flag == RU_NEXT)) {
6291 not_implemented_message = TRUE;
6292 flag = RU_STEP;
6293 }
6294 if (*cptr != 0) {
6295 cptr = get_glyph (cptr, gbuf, 0);
6296 if (*cptr != 0)
6297 return SCPE_2MARG;
6298 sim_step = (int32) get_uint (gbuf, 10, INT_MAX, &r);
6299 if ((r != SCPE_OK) || (sim_step <= 0))
6300 return SCPE_ARG;
6301 }
6302 else sim_step = 1;
6303 if ((flag == RU_STEP) && (sim_switches & SWMASK ('T')))
6304 sim_step = (int32)((sim_timer_inst_per_sec ()*sim_step)/1000000.0);
6305 }
6306 else if (flag == RU_NEXT) {
6307 t_addr *addrs;
6308
6309 if (*cptr != 0) {
6310 cptr = get_glyph (cptr, gbuf, 0);
6311 if (*cptr != 0)
6312 return SCPE_2MARG;
6313 sim_next = (int32) get_uint (gbuf, 10, INT_MAX, &r);
6314 if ((r != SCPE_OK) || (sim_next <= 0))
6315 return SCPE_ARG;
6316 }
6317 else sim_next = 1;
6318 if (sim_vm_is_subroutine_call(&addrs)) {
6319 sim_brk_types |= BRK_TYP_DYN_STEPOVER;
6320 for (i=0; addrs[i]; i++)
6321 sim_brk_set (addrs[i], BRK_TYP_DYN_STEPOVER, 0, NULL);
6322 }
6323 else
6324 sim_step = 1;
6325 }
6326 else if (flag == RU_BOOT) {
6327 if (*cptr == 0)
6328 return SCPE_2FARG;
6329 cptr = get_glyph (cptr, gbuf, 0);
6330 if (*cptr != 0)
6331 return SCPE_2MARG;
6332 dptr = find_unit (gbuf, &uptr);
6333 if (dptr == NULL)
6334 return SCPE_NXDEV;
6335 if (uptr == NULL)
6336 return SCPE_NXUN;
6337 if (dptr->boot == NULL)
6338 return SCPE_NOFNC;
6339 if (uptr->flags & UNIT_DIS)
6340 return SCPE_UDIS;
6341 if ((uptr->flags & UNIT_ATTABLE) &&
6342 !(uptr->flags & UNIT_ATT))
6343 return SCPE_UNATT;
6344 unitno = (int32) (uptr - dptr->units);
6345 if ((r = sim_run_boot_prep (flag)) != SCPE_OK)
6346 return r;
6347 if ((r = dptr->boot (unitno, dptr)) != SCPE_OK)
6348 return r;
6349 }
6350
6351 else
6352 if (flag != RU_CONT)
6353 return SCPE_IERR;
6354 else
6355 if (*cptr != 0)
6356 return sim_messagef (SCPE_2MARG, "CONTINUE command takes no arguments\n");
6357
6358 if (sim_switches & SIM_SW_HIDE)
6359 return SCPE_OK;
6360
6361 for (i = 1; (dptr = sim_devices[i]) != NULL; i++) {
6362 for (j = 0; j < dptr->numunits; j++) {
6363 uptr = dptr->units + j;
6364 if ((uptr->flags & (UNIT_ATT + UNIT_SEQ)) == (UNIT_ATT + UNIT_SEQ))
6365 sim_fseek (uptr->fileref, uptr->pos, SEEK_SET);
6366 }
6367 }
6368 stop_cpu = 0;
6369 sim_is_running = 1;
6370 if (sim_ttrun () != SCPE_OK) {
6371 sim_is_running = 0;
6372 sim_ttcmd ();
6373 return SCPE_TTYERR;
6374 }
6375 if ((r = sim_check_console (30)) != SCPE_OK) {
6376 sim_is_running = 0;
6377 sim_ttcmd ();
6378 return r;
6379 }
6380 #if !defined(IS_WINDOWS)
6381 # if defined(SIGINT)
6382 if (signal (SIGINT, int_handler) == SIG_ERR) {
6383 sim_is_running = 0;
6384 sim_ttcmd ();
6385 return SCPE_SIGERR;
6386 }
6387 # endif
6388 #endif
6389 #if !defined(IS_WINDOWS)
6390 # if defined(SIGHUP)
6391 if (signal (SIGHUP, int_handler) == SIG_ERR) {
6392 sim_is_running = 0;
6393 sim_ttcmd ();
6394 return SCPE_SIGERR;
6395 }
6396 # endif
6397 #endif
6398 #if !defined(IS_WINDOWS)
6399 # if defined(SIGTERM)
6400 if (signal (SIGTERM, int_handler) == SIG_ERR) {
6401 sim_is_running = 0;
6402 sim_ttcmd ();
6403 return SCPE_SIGERR;
6404 }
6405 # endif
6406 #endif
6407 if (sim_step)
6408 sim_activate (&sim_step_unit, sim_step);
6409 (void)fflush(stdout);
6410 if (sim_log)
6411 (void)fflush (sim_log);
6412 sim_rtcn_init_all ();
6413 sim_start_timer_services ();
6414
6415 do {
6416 t_addr *addrs;
6417
6418 while (1) {
6419 r = sim_instr();
6420 if (r != SCPE_REMOTE)
6421 break;
6422 sim_remote_process_command ();
6423 }
6424 if ((flag != RU_NEXT) ||
6425 (--sim_next <=0))
6426 break;
6427 if (sim_step == 0) {
6428 t_addr val;
6429 BRKTAB *bp;
6430
6431 if (SCPE_BARE_STATUS(r) >= SCPE_BASE)
6432 break;
6433 if (sim_vm_pc_value)
6434 val = (t_addr)(*sim_vm_pc_value)();
6435 else
6436 val = (t_addr)get_rval (sim_PC, 0);
6437 if ((!(bp = sim_brk_fnd (val))) || (!(bp->typ & BRK_TYP_DYN_STEPOVER)))
6438 break;
6439 sim_brk_clrall (BRK_TYP_DYN_STEPOVER);
6440 }
6441 else {
6442 if (r != SCPE_STEP)
6443 break;
6444 }
6445
6446 sim_step = 0;
6447 if (sim_vm_is_subroutine_call(&addrs)) {
6448 sim_brk_types |= BRK_TYP_DYN_STEPOVER;
6449 for (i=0; addrs[i]; i++)
6450 sim_brk_set (addrs[i], BRK_TYP_DYN_STEPOVER, 0, NULL);
6451 }
6452 else
6453 sim_step = 1;
6454 if (sim_step)
6455 sim_activate (&sim_step_unit, sim_step);
6456 } while (1);
6457
6458 sim_is_running = 0;
6459 sim_stop_timer_services ();
6460 sim_ttcmd ();
6461 sim_brk_clrall (BRK_TYP_DYN_STEPOVER);
6462 signal (SIGINT, SIG_DFL);
6463 #if defined(SIGHUP)
6464 signal (SIGHUP, SIG_DFL);
6465 #endif
6466 signal (SIGTERM, SIG_DFL);
6467 if (sim_log)
6468 (void)fflush (sim_log);
6469 if (sim_deb)
6470 sim_debug_flush ();
6471 for (i = 1; (dptr = sim_devices[i]) != NULL; i++) {
6472 for (j = 0; j < dptr->numunits; j++) {
6473 uptr = dptr->units + j;
6474 if (uptr->flags & UNIT_ATT) {
6475 if (uptr->io_flush)
6476 uptr->io_flush (uptr);
6477 else {
6478 if (!(uptr->flags & UNIT_BUF) &&
6479 (uptr->fileref) &&
6480 !(uptr->dynflags & UNIT_NO_FIO) &&
6481 !(uptr->flags & UNIT_RO))
6482 (void)fflush (uptr->fileref);
6483 }
6484 }
6485 }
6486 }
6487 sim_cancel (&sim_step_unit);
6488 UPDATE_SIM_TIME;
6489 return r | ((sim_switches & SWMASK ('Q')) ? SCPE_NOMESSAGE : 0);
6490 }
6491
6492
6493
6494 void
6495 run_cmd_message (const char *unechoed_cmdline, t_stat r)
6496 {
6497 if (unechoed_cmdline && (r >= SCPE_BASE) && (r != SCPE_STEP) && (r != SCPE_STOP) && (r != SCPE_EXPECT))
6498 sim_printf("%s> %s\n", do_position(), unechoed_cmdline);
6499 #if defined(WIN_STDIO)
6500 (void)fflush(stderr);
6501 (void)fflush(stdout);
6502 #endif
6503 fprint_stopped (stdout, r);
6504 if (sim_log && (sim_log != stdout))
6505 fprint_stopped (sim_log, r);
6506 if (sim_deb && (sim_deb != stdout) && (sim_deb != sim_log))
6507 fprint_stopped (sim_deb, r);
6508 #if defined(WIN_STDIO)
6509 (void)fflush(stderr);
6510 (void)fflush(stdout);
6511 #endif
6512 }
6513
6514
6515
6516 t_stat sim_run_boot_prep (int32 flag)
6517 {
6518 UNIT *uptr;
6519 t_stat r;
6520
6521 sim_interval = 0;
6522 sim_time = sim_rtime = 0;
6523 noqueue_time = 0;
6524 for (uptr = sim_clock_queue; uptr != QUEUE_LIST_END; uptr = sim_clock_queue) {
6525 sim_clock_queue = uptr->next;
6526 uptr->next = NULL;
6527 }
6528 r = reset_all (0);
6529 if ((r == SCPE_OK) && (flag == RU_RUN)) {
6530 if ((run_cmd_did_reset) && (0 == (sim_switches & SWMASK ('Q')))) {
6531 sim_printf ("Resetting all devices... This may not have been your intention.\n");
6532 sim_printf ("The GO and CONTINUE commands do not reset devices.\n");
6533 }
6534 run_cmd_did_reset = TRUE;
6535 }
6536 return r;
6537 }
6538
6539
6540
6541
6542
6543
6544
6545
6546 void fprint_stopped_gen (FILE *st, t_stat v, REG *pc, DEVICE *dptr)
6547 {
6548 int32 i;
6549 t_stat r = 0;
6550 t_addr k;
6551 t_value pcval;
6552
6553 fputc ('\n', st);
6554
6555 if (v >= SCPE_BASE)
6556 fputs (sim_error_text (v), st);
6557 else {
6558 fputs (sim_stop_messages [v], st);
6559
6560 if ((sim_vm_fprint_stopped != NULL) &&
6561 (!sim_vm_fprint_stopped (st, v)))
6562 return;
6563 }
6564
6565 (void)fprintf (st, ", %s: ", pc->name);
6566
6567 pcval = get_rval (pc, 0);
6568 if ((pc->flags & REG_VMAD) && sim_vm_fprint_addr)
6569 sim_vm_fprint_addr (st, dptr, (t_addr) pcval);
6570 else fprint_val (st, pcval, pc->radix, pc->width,
6571 pc->flags & REG_FMT);
6572 if ((dptr != NULL) && (dptr->examine != NULL)) {
6573 for (i = 0; i < sim_emax; i++)
6574 sim_eval[i] = 0;
6575 for (i = 0, k = (t_addr) pcval; i < sim_emax; i++, k = k + dptr->aincr) {
6576 if ((r = dptr->examine (&sim_eval[i], k, dptr->units, SWMASK ('V')|SIM_SW_STOP)) != SCPE_OK)
6577 break;
6578 }
6579 if ((r == SCPE_OK) || (i > 0)) {
6580 (void)fprintf (st, " (");
6581 if (fprint_sym (st, (t_addr) pcval, sim_eval, NULL, SWMASK('M')|SIM_SW_STOP) > 0)
6582 fprint_val (st, sim_eval[0], dptr->dradix, dptr->dwidth, PV_RZRO);
6583 (void)fprintf (st, ")");
6584 }
6585 }
6586 (void)fprintf (st, "\n");
6587 return;
6588 }
6589
6590 void fprint_stopped (FILE *st, t_stat v)
6591 {
6592 #if defined(WIN_STDIO)
6593 (void)fflush(stderr);
6594 (void)fflush(stdout);
6595 #endif
6596 fprint_stopped_gen (st, v, sim_PC, sim_dflt_dev);
6597 return;
6598 }
6599
6600
6601
6602
6603 t_stat step_svc (UNIT *uptr)
6604 {
6605 return SCPE_STEP;
6606 }
6607
6608
6609
6610
6611 t_stat expect_svc (UNIT *uptr)
6612 {
6613 return SCPE_EXPECT | (sim_do_echo ? 0 : SCPE_NOMESSAGE);
6614 }
6615
6616
6617
6618 void int_handler (int sig)
6619 {
6620 stop_cpu = 1;
6621 return;
6622 }
6623
6624
6625
6626 t_stat exdep_cmd (int32 flag, CONST char *cptr)
6627 {
6628 char gbuf[CBUFSIZE];
6629 CONST char *gptr;
6630 CONST char *tptr = NULL;
6631 int32 opt;
6632 t_addr low, high;
6633 t_stat reason = SCPE_IERR;
6634 DEVICE *tdptr;
6635 REG *lowr, *highr;
6636 FILE *ofile;
6637
6638 opt = CMD_OPT_SW|CMD_OPT_SCH|CMD_OPT_DFT;
6639 if (flag == EX_E)
6640 opt = opt | CMD_OPT_OF;
6641 cptr = get_sim_opt (opt, cptr, &reason);
6642 if (NULL == cptr)
6643 return reason;
6644 if (*cptr == 0)
6645 return SCPE_2FARG;
6646 if (sim_dfunit == NULL)
6647 return SCPE_NXUN;
6648 cptr = get_glyph (cptr, gbuf, 0);
6649 if ((flag == EX_D) && (*cptr == 0))
6650
6651 return SCPE_2FARG;
6652 ofile = sim_ofile? sim_ofile: stdout;
6653
6654 for (gptr = gbuf, reason = SCPE_OK;
6655 (*gptr != 0) && (reason == SCPE_OK); gptr = tptr) {
6656 tdptr = sim_dfdev;
6657 if (strncmp (gptr, "STATE", strlen ("STATE")) == 0) {
6658 tptr = gptr + strlen ("STATE");
6659 if (*tptr && (*tptr++ != ','))
6660 return SCPE_ARG;
6661 if ((lowr = sim_dfdev->registers) == NULL)
6662 return SCPE_NXREG;
6663 for (highr = lowr; highr->name != NULL; highr++) ;
6664 sim_switches = sim_switches | SIM_SW_HIDE;
6665 reason = exdep_reg_loop (ofile, sim_schrptr, flag, cptr,
6666 lowr, --highr, 0, 0);
6667 continue;
6668 }
6669
6670
6671 if ((lowr = find_reg (gptr, &tptr, tdptr)) ||
6672 (!(sim_opt_out & CMD_OPT_DFT) &&
6673 (lowr = find_reg_glob (gptr, &tptr, &tdptr)))) {
6674 low = high = 0;
6675 if ((*tptr == '-') || (*tptr == ':')) {
6676 highr = find_reg (tptr + 1, &tptr, tdptr);
6677 if (highr == NULL)
6678 return SCPE_NXREG;
6679 }
6680 else {
6681 highr = lowr;
6682 if (*tptr == '[') {
6683 if (lowr->depth <= 1)
6684 return SCPE_ARG;
6685 tptr = get_range (NULL, tptr + 1, &low, &high,
6686 10, lowr->depth - 1, ']');
6687 if (tptr == NULL)
6688 return SCPE_ARG;
6689 }
6690 }
6691 if (*tptr && (*tptr++ != ','))
6692 return SCPE_ARG;
6693 reason = exdep_reg_loop (ofile, sim_schrptr, flag, cptr,
6694 lowr, highr, (uint32) low, (uint32) high);
6695 continue;
6696 }
6697
6698 tptr = get_range (sim_dfdev, gptr, &low, &high, sim_dfdev->aradix,
6699 (((sim_dfunit->capac == 0) || (flag == EX_E))? 0:
6700 sim_dfunit->capac - sim_dfdev->aincr), 0);
6701 if (tptr == NULL)
6702 return SCPE_ARG;
6703 if (*tptr && (*tptr++ != ','))
6704 return SCPE_ARG;
6705 reason = exdep_addr_loop (ofile, sim_schaptr, flag, cptr, low, high,
6706 sim_dfdev, sim_dfunit);
6707 }
6708 if (sim_ofile)
6709 fclose (sim_ofile);
6710 return reason;
6711 }
6712
6713
6714
6715
6716
6717
6718
6719 t_stat exdep_reg_loop (FILE *ofile, SCHTAB *schptr, int32 flag, CONST char *cptr,
6720 REG *lowr, REG *highr, uint32 lows, uint32 highs)
6721 {
6722 t_stat reason;
6723 uint32 idx, val_start=lows;
6724 t_value val, last_val;
6725 REG *rptr;
6726
6727 if ((lowr == NULL) || (highr == NULL))
6728 return SCPE_IERR;
6729 if (lowr > highr)
6730 return SCPE_ARG;
6731 for (rptr = lowr; rptr <= highr; rptr++) {
6732 if ((sim_switches & SIM_SW_HIDE) &&
6733 (rptr->flags & REG_HIDDEN))
6734 continue;
6735 val = last_val = 0;
6736 for (idx = lows; idx <= highs; idx++) {
6737 if (idx >= rptr->depth)
6738 return SCPE_SUB;
6739 val = get_rval (rptr, idx);
6740 if (schptr && !test_search (&val, schptr))
6741 continue;
6742 if (flag == EX_E) {
6743 if ((idx > lows) && (val == last_val))
6744 continue;
6745 if (idx > val_start+1) {
6746 if (idx-1 == val_start+1) {
6747 reason = ex_reg (ofile, val, flag, rptr, idx-1);
6748 if (reason != SCPE_OK)
6749 return reason;
6750 if (sim_log && (ofile == stdout))
6751 ex_reg (sim_log, val, flag, rptr, idx-1);
6752 }
6753 else {
6754 if (val_start+1 != idx-1) {
6755 (void)Fprintf (ofile, "%s[%d]-%s[%d]: same as above\n", rptr->name, val_start+1, rptr->name, idx-1);
6756 if (sim_log && (ofile == stdout))
6757 (void)Fprintf (sim_log, "%s[%d]-%s[%d]: same as above\n", rptr->name, val_start+1, rptr->name, idx-1);
6758 }
6759 else {
6760 (void)Fprintf (ofile, "%s[%d]: same as above\n", rptr->name, val_start+1);
6761 if (sim_log && (ofile == stdout))
6762 (void)Fprintf (sim_log, "%s[%d]: same as above\n", rptr->name, val_start+1);
6763 }
6764 }
6765 }
6766 sim_last_val = last_val = val;
6767 val_start = idx;
6768 reason = ex_reg (ofile, val, flag, rptr, idx);
6769 if (reason != SCPE_OK)
6770 return reason;
6771 if (sim_log && (ofile == stdout))
6772 ex_reg (sim_log, val, flag, rptr, idx);
6773 }
6774 if (flag != EX_E) {
6775 reason = dep_reg (flag, cptr, rptr, idx);
6776 if (reason != SCPE_OK)
6777 return reason;
6778 }
6779 }
6780 if ((flag == EX_E) && (val_start != highs)) {
6781 if (highs == val_start+1) {
6782 reason = ex_reg (ofile, val, flag, rptr, highs);
6783 if (reason != SCPE_OK)
6784 return reason;
6785 if (sim_log && (ofile == stdout))
6786 ex_reg (sim_log, val, flag, rptr, highs);
6787 }
6788 else {
6789 if (val_start+1 != highs) {
6790 (void)Fprintf (ofile, "%s[%d]-%s[%d]: same as above\n", rptr->name, val_start+1, rptr->name, highs);
6791 if (sim_log && (ofile == stdout))
6792 (void)Fprintf (sim_log, "%s[%d]-%s[%d]: same as above\n", rptr->name, val_start+1, rptr->name, highs);
6793 }
6794 else {
6795 (void)Fprintf (ofile, "%s[%d]: same as above\n", rptr->name, val_start+1);
6796 if (sim_log && (ofile == stdout))
6797 (void)Fprintf (sim_log, "%s[%d]: same as above\n", rptr->name, val_start+1);
6798 }
6799 }
6800 }
6801 }
6802 return SCPE_OK;
6803 }
6804
6805 t_stat exdep_addr_loop (FILE *ofile, SCHTAB *schptr, int32 flag, const char *cptr,
6806 t_addr low, t_addr high, DEVICE *dptr, UNIT *uptr)
6807 {
6808 t_addr i, mask;
6809 t_stat reason;
6810
6811 if (uptr->flags & UNIT_DIS)
6812 return SCPE_UDIS;
6813 mask = (t_addr) width_mask[dptr->awidth];
6814 if ((low > mask) || (high > mask) || (low > high))
6815 return SCPE_ARG;
6816 for (i = low; i <= high; ) {
6817 reason = get_aval (i, dptr, uptr);
6818 if (reason != SCPE_OK)
6819 return reason;
6820 if (schptr && !test_search (sim_eval, schptr))
6821 i = i + dptr->aincr;
6822 else {
6823 if (flag != EX_D) {
6824 reason = ex_addr (ofile, flag, i, dptr, uptr);
6825 if (reason > SCPE_OK)
6826 return reason;
6827 if (sim_log && (ofile == stdout))
6828 ex_addr (sim_log, flag, i, dptr, uptr);
6829 }
6830 else reason = 1 - dptr->aincr;
6831 if (flag != EX_E) {
6832 reason = dep_addr (flag, cptr, i, dptr, uptr, reason);
6833 if (reason > SCPE_OK)
6834 return reason;
6835 }
6836 i = i + (1 - reason);
6837 }
6838 }
6839 return SCPE_OK;
6840 }
6841
6842
6843
6844
6845
6846
6847
6848
6849
6850
6851
6852
6853
6854 t_stat ex_reg (FILE *ofile, t_value val, int32 flag, REG *rptr, uint32 idx)
6855 {
6856 int32 rdx;
6857
6858 if (rptr == NULL)
6859 return SCPE_IERR;
6860 if (rptr->depth > 1)
6861 (void)Fprintf (ofile, "%s[%d]:\t", rptr->name, idx);
6862 else
6863 (void)Fprintf (ofile, "%s:\t", rptr->name);
6864 if (!(flag & EX_E))
6865 return SCPE_OK;
6866 GET_RADIX (rdx, rptr->radix);
6867 if ((rptr->flags & REG_VMAD) && sim_vm_fprint_addr && sim_dflt_dev)
6868 sim_vm_fprint_addr (ofile, sim_dflt_dev, (t_addr) val);
6869 else if (!(rptr->flags & REG_VMFLAGS) ||
6870 (fprint_sym (ofile, (rptr->flags & REG_UFMASK) | rdx, &val,
6871 NULL, sim_switches | SIM_SW_REG) > 0)) {
6872 fprint_val (ofile, val, rdx, rptr->width, rptr->flags & REG_FMT);
6873 if (rptr->fields) {
6874 (void)Fprintf (ofile, "\t");
6875 fprint_fields (ofile, val, val, rptr->fields);
6876 }
6877 }
6878 if (flag & EX_I)
6879 (void)Fprintf (ofile, "\t");
6880 else
6881 (void)Fprintf (ofile, "\n");
6882 return SCPE_OK;
6883 }
6884
6885
6886
6887
6888
6889
6890
6891
6892
6893
6894 t_value get_rval (REG *rptr, uint32 idx)
6895 {
6896 size_t sz;
6897 t_value val;
6898 uint32 *ptr;
6899
6900 sz = SZ_R (rptr);
6901 if ((rptr->depth > 1) && (rptr->flags & REG_CIRC)) {
6902 idx = idx + rptr->qptr;
6903 if (idx >= rptr->depth) idx = idx - rptr->depth;
6904 }
6905 if ((rptr->depth > 1) && (rptr->flags & REG_UNIT)) {
6906 ptr = (uint32 *)(((UNIT *) rptr->loc) + idx);
6907 if (sz <= sizeof (uint32))
6908 val = *ptr;
6909 else val = *((t_uint64 *) ptr);
6910 }
6911 else if ((rptr->depth > 1) && (rptr->flags & REG_STRUCT)) {
6912 ptr = (uint32 *)(((size_t) rptr->loc) + (idx * rptr->str_size));
6913 if (sz <= sizeof (uint32))
6914 val = *ptr;
6915 else val = *((t_uint64 *) ptr);
6916 }
6917 else if (((rptr->depth > 1) || (rptr->flags & REG_FIT)) &&
6918 (sz == sizeof (uint8)))
6919 val = *(((uint8 *) rptr->loc) + idx);
6920 else if (((rptr->depth > 1) || (rptr->flags & REG_FIT)) &&
6921 (sz == sizeof (uint16)))
6922 val = *(((uint16 *) rptr->loc) + idx);
6923 else if (sz <= sizeof (uint32))
6924 val = *(((uint32 *) rptr->loc) + idx);
6925 else val = *(((t_uint64 *) rptr->loc) + idx);
6926 val = (val >> rptr->offset) & width_mask[rptr->width];
6927 return val;
6928 }
6929
6930
6931
6932
6933
6934
6935
6936
6937
6938
6939
6940
6941 t_stat dep_reg (int32 flag, CONST char *cptr, REG *rptr, uint32 idx)
6942 {
6943 t_stat r;
6944 t_value val, mask;
6945 int32 rdx;
6946 CONST char *tptr;
6947 char gbuf[CBUFSIZE];
6948
6949 if ((cptr == NULL) || (rptr == NULL))
6950 return SCPE_IERR;
6951 if (rptr->flags & REG_RO)
6952 return SCPE_RO;
6953 if (flag & EX_I) {
6954 cptr = read_line (gbuf, sizeof(gbuf), stdin);
6955 if (sim_log)
6956 (void)fprintf (sim_log, "%s\n", cptr? cptr: "");
6957 if (cptr == NULL)
6958 return 1;
6959 if (*cptr == 0)
6960 return SCPE_OK;
6961 }
6962 mask = width_mask[rptr->width];
6963 GET_RADIX (rdx, rptr->radix);
6964 if ((rptr->flags & REG_VMAD) && sim_vm_parse_addr && sim_dflt_dev) {
6965 val = sim_vm_parse_addr (sim_dflt_dev, cptr, &tptr);
6966 if ((tptr == cptr) || (*tptr != 0) || (val > mask))
6967 return SCPE_ARG;
6968 }
6969 else
6970 if (!(rptr->flags & REG_VMFLAGS) ||
6971 (parse_sym ((CONST char *)cptr, (rptr->flags & REG_UFMASK) | rdx, NULL,
6972 &val, sim_switches | SIM_SW_REG) > SCPE_OK)) {
6973 val = get_uint (cptr, rdx, mask, &r);
6974 if (r != SCPE_OK)
6975 return SCPE_ARG;
6976 }
6977 if ((rptr->flags & REG_NZ) && (val == 0))
6978 return SCPE_ARG;
6979 put_rval (rptr, idx, val);
6980 return SCPE_OK;
6981 }
6982
6983
6984
6985
6986
6987
6988
6989
6990
6991
6992
6993
6994 void put_rval (REG *rptr, uint32 idx, t_value val)
6995 {
6996 size_t sz;
6997 t_value mask;
6998 uint32 *ptr;
6999
7000 #define PUT_RVAL(sz,rp,id,v,m) \
7001 *(((sz *) rp->loc) + id) = \
7002 (sz)((*(((sz *) rp->loc) + id) & \
7003 ~((m) << (rp)->offset)) | ((v) << (rp)->offset))
7004
7005 if (rptr == sim_PC)
7006 sim_brk_npc (0);
7007 sz = SZ_R (rptr);
7008 mask = width_mask[rptr->width];
7009 if ((rptr->depth > 1) && (rptr->flags & REG_CIRC)) {
7010 idx = idx + rptr->qptr;
7011 if (idx >= rptr->depth)
7012 idx = idx - rptr->depth;
7013 }
7014 if ((rptr->depth > 1) && (rptr->flags & REG_UNIT)) {
7015 ptr = (uint32 *)(((UNIT *) rptr->loc) + idx);
7016 if (sz <= sizeof (uint32))
7017 *ptr = (*ptr &
7018 ~(((uint32) mask) << rptr->offset)) |
7019 (((uint32) val) << rptr->offset);
7020 else *((t_uint64 *) ptr) = (*((t_uint64 *) ptr)
7021 & ~(mask << rptr->offset)) | (val << rptr->offset);
7022 }
7023 else if ((rptr->depth > 1) && (rptr->flags & REG_STRUCT)) {
7024 ptr = (uint32 *)(((size_t) rptr->loc) + (idx * rptr->str_size));
7025 if (sz <= sizeof (uint32))
7026 *((uint32 *) ptr) = (*((uint32 *) ptr) &
7027 ~(((uint32) mask) << rptr->offset)) |
7028 (((uint32) val) << rptr->offset);
7029 else *((t_uint64 *) ptr) = (*((t_uint64 *) ptr)
7030 & ~(mask << rptr->offset)) | (val << rptr->offset);
7031 }
7032 else if (((rptr->depth > 1) || (rptr->flags & REG_FIT)) &&
7033 (sz == sizeof (uint8)))
7034 PUT_RVAL (uint8, rptr, idx, (uint32) val, (uint32) mask);
7035 else if (((rptr->depth > 1) || (rptr->flags & REG_FIT)) &&
7036 (sz == sizeof (uint16)))
7037 PUT_RVAL (uint16, rptr, idx, (uint32) val, (uint32) mask);
7038 else if (sz <= sizeof (uint32))
7039 PUT_RVAL (uint32, rptr, idx, (int32) val, (uint32) mask);
7040 else PUT_RVAL (t_uint64, rptr, idx, val, mask);
7041 return;
7042 }
7043
7044
7045
7046
7047
7048
7049
7050
7051
7052
7053
7054
7055
7056
7057 t_stat ex_addr (FILE *ofile, int32 flag, t_addr addr, DEVICE *dptr, UNIT *uptr)
7058 {
7059 t_stat reason;
7060 int32 rdx;
7061
7062 if (sim_vm_fprint_addr)
7063 sim_vm_fprint_addr (ofile, dptr, addr);
7064 else fprint_val (ofile, addr, dptr->aradix, dptr->awidth, PV_LEFT);
7065 (void)Fprintf (ofile, ":\t");
7066 if (!(flag & EX_E))
7067 return (1 - dptr->aincr);
7068
7069 GET_RADIX (rdx, dptr->dradix);
7070 if ((reason = fprint_sym (ofile, addr, sim_eval, uptr, sim_switches)) > 0) {
7071 fprint_val (ofile, sim_eval[0], rdx, dptr->dwidth, PV_RZRO);
7072 reason = 1 - dptr->aincr;
7073 }
7074 if (flag & EX_I)
7075 (void)Fprintf (ofile, "\t");
7076 else
7077 (void)Fprintf (ofile, "\n");
7078 return reason;
7079 }
7080
7081
7082
7083
7084
7085
7086
7087
7088
7089
7090
7091
7092 t_stat get_aval (t_addr addr, DEVICE *dptr, UNIT *uptr)
7093 {
7094 int32 i;
7095 t_value mask;
7096 t_addr j, loc;
7097 size_t sz;
7098 t_stat reason = SCPE_OK;
7099
7100 if ((dptr == NULL) || (uptr == NULL))
7101 return SCPE_IERR;
7102 mask = width_mask[dptr->dwidth];
7103 for (i = 0; i < sim_emax; i++)
7104 sim_eval[i] = 0;
7105 for (i = 0, j = addr; i < sim_emax; i++, j = j + dptr->aincr) {
7106 if (dptr->examine != NULL) {
7107 reason = dptr->examine (&sim_eval[i], j, uptr, sim_switches);
7108 if (reason != SCPE_OK)
7109 break;
7110 }
7111 else {
7112 if (!(uptr->flags & UNIT_ATT))
7113 return SCPE_UNATT;
7114 if (uptr->dynflags & UNIT_NO_FIO)
7115 return SCPE_NOFNC;
7116 if ((uptr->flags & UNIT_FIX) && (j >= uptr->capac)) {
7117 reason = SCPE_NXM;
7118 break;
7119 }
7120 sz = SZ_D (dptr);
7121 loc = j / dptr->aincr;
7122 if (uptr->flags & UNIT_BUF) {
7123 SZ_LOAD (sz, sim_eval[i], uptr->filebuf, loc);
7124 }
7125 else {
7126 sim_fseek (uptr->fileref, (t_addr)(sz * loc), SEEK_SET);
7127 sim_fread (&sim_eval[i], sz, 1, uptr->fileref);
7128 if ((feof (uptr->fileref)) &&
7129 !(uptr->flags & UNIT_FIX)) {
7130 reason = SCPE_EOF;
7131 break;
7132 }
7133 else if (ferror (uptr->fileref)) {
7134 clearerr (uptr->fileref);
7135 reason = SCPE_IOERR;
7136 break;
7137 }
7138 }
7139 }
7140 sim_last_val = sim_eval[i] = sim_eval[i] & mask;
7141 }
7142 if ((reason != SCPE_OK) && (i == 0))
7143 return reason;
7144 return SCPE_OK;
7145 }
7146
7147
7148
7149
7150
7151
7152
7153
7154
7155
7156
7157
7158
7159
7160
7161 t_stat dep_addr (int32 flag, const char *cptr, t_addr addr, DEVICE *dptr,
7162 UNIT *uptr, int32 dfltinc)
7163 {
7164 int32 i, count, rdx;
7165 t_addr j, loc;
7166 t_stat r, reason;
7167 t_value mask;
7168 size_t sz;
7169 char gbuf[CBUFSIZE];
7170
7171 if (dptr == NULL)
7172 return SCPE_IERR;
7173 if (flag & EX_I) {
7174 cptr = read_line (gbuf, sizeof(gbuf), stdin);
7175 if (sim_log)
7176 (void)fprintf (sim_log, "%s\n", cptr? cptr: "");
7177 if (cptr == NULL)
7178 return 1;
7179 if (*cptr == 0)
7180 return dfltinc;
7181 }
7182 if (uptr->flags & UNIT_RO)
7183 return SCPE_RO;
7184 mask = width_mask[dptr->dwidth];
7185
7186 GET_RADIX (rdx, dptr->dradix);
7187 if ((reason = parse_sym ((CONST char *)cptr, addr, uptr, sim_eval, sim_switches)) > 0) {
7188 sim_eval[0] = get_uint (cptr, rdx, mask, &reason);
7189 if (reason != SCPE_OK)
7190 return reason;
7191 reason = dfltinc;
7192 }
7193 count = (1 - reason + (dptr->aincr - 1)) / dptr->aincr;
7194
7195 for (i = 0, j = addr; i < count; i++, j = j + dptr->aincr) {
7196 sim_eval[i] = sim_eval[i] & mask;
7197 if (dptr->deposit != NULL) {
7198 r = dptr->deposit (sim_eval[i], j, uptr, sim_switches);
7199 if (r != SCPE_OK)
7200 return r;
7201 }
7202 else {
7203 if (!(uptr->flags & UNIT_ATT))
7204 return SCPE_UNATT;
7205 if (uptr->dynflags & UNIT_NO_FIO)
7206 return SCPE_NOFNC;
7207 if ((uptr->flags & UNIT_FIX) && (j >= uptr->capac))
7208 return SCPE_NXM;
7209 sz = SZ_D (dptr);
7210 loc = j / dptr->aincr;
7211 if (uptr->flags & UNIT_BUF) {
7212 SZ_STORE (sz, sim_eval[i], uptr->filebuf, loc);
7213 if (loc >= uptr->hwmark)
7214 uptr->hwmark = (uint32) loc + 1;
7215 }
7216 else {
7217 sim_fseek (uptr->fileref, (t_addr)(sz * loc), SEEK_SET);
7218 sim_fwrite (&sim_eval[i], sz, 1, uptr->fileref);
7219 if (ferror (uptr->fileref)) {
7220 clearerr (uptr->fileref);
7221 return SCPE_IOERR;
7222 }
7223 }
7224 }
7225 }
7226 return reason;
7227 }
7228
7229
7230
7231 t_stat eval_cmd (int32 flg, CONST char *cptr)
7232 {
7233 if (!sim_dflt_dev)
7234 return SCPE_ARG;
7235 DEVICE *dptr = sim_dflt_dev;
7236 int32 i, rdx, a, lim;
7237 t_stat r;
7238
7239 GET_SWITCHES (cptr);
7240 GET_RADIX (rdx, dptr->dradix);
7241 for (i = 0; i < sim_emax; i++)
7242 sim_eval[i] = 0;
7243 if (*cptr == 0)
7244 return SCPE_2FARG;
7245 if ((r = parse_sym ((CONST char *)cptr, 0, dptr->units, sim_eval, sim_switches)) > 0) {
7246 sim_eval[0] = get_uint (cptr, rdx, width_mask[dptr->dwidth], &r);
7247 if (r != SCPE_OK)
7248 return r;
7249 }
7250 lim = 1 - r;
7251 for (i = a = 0; a < lim; ) {
7252 sim_printf ("%d:\t", a);
7253 if ((r = fprint_sym (stdout, a, &sim_eval[i], dptr->units, sim_switches)) > 0)
7254 r = fprint_val (stdout, sim_eval[i], rdx, dptr->dwidth, PV_RZRO);
7255 if (sim_log) {
7256 if ((r = fprint_sym (sim_log, a, &sim_eval[i], dptr->units, sim_switches)) > 0)
7257 r = fprint_val (sim_log, sim_eval[i], rdx, dptr->dwidth, PV_RZRO);
7258 }
7259 sim_printf ("\n");
7260 if (r < 0)
7261 a = a + 1 - r;
7262 else a = a + dptr->aincr;
7263 i = a / dptr->aincr;
7264 }
7265 return SCPE_OK;
7266 }
7267
7268
7269
7270
7271
7272
7273
7274
7275
7276
7277
7278
7279
7280
7281 char *read_line (char *cptr, int32 size, FILE *stream)
7282 {
7283 return read_line_p (NULL, cptr, size, stream);
7284 }
7285
7286
7287
7288
7289
7290
7291
7292
7293
7294
7295
7296
7297
7298 char *read_line_p (const char *prompt, char *cptr, int32 size, FILE *stream)
7299 {
7300 char *tptr;
7301
7302 if (prompt) {
7303 #if defined(HAVE_LINEHISTORY)
7304 char *tmpc = linenoise (prompt);
7305 if (tmpc == NULL)
7306 cptr = NULL;
7307 else {
7308 strncpy (cptr, tmpc, size-1);
7309 linenoiseHistoryAdd (tmpc);
7310 FREE (tmpc);
7311 }
7312 }
7313 #else
7314 (void)fflush (stdout);
7315 (void)printf ("%s", prompt);
7316 (void)fflush (stdout);
7317 cptr = fgets (cptr, size, stream);
7318 }
7319 #endif
7320 else cptr = fgets (cptr, size, stream);
7321
7322 if (cptr == NULL) {
7323 clearerr (stream);
7324 return NULL;
7325 }
7326 for (tptr = cptr; tptr < (cptr + size); tptr++) {
7327 if ((*tptr == '\n') || (*tptr == '\r') ||
7328 (tptr == (cptr + size - 1))) {
7329 *tptr = 0;
7330 break;
7331 }
7332 }
7333 if (0 == memcmp (cptr, "\xEF\xBB\xBF", 3))
7334 memmove (cptr, cptr + 3, strlen (cptr + 3));
7335 while (sim_isspace (*cptr))
7336 cptr++;
7337 if ((*cptr == ';') || (*cptr == '#')) {
7338 if (sim_do_echo)
7339 sim_printf("%s> %s\n", do_position(), cptr);
7340 *cptr = 0;
7341 }
7342
7343 return cptr;
7344 }
7345
7346
7347
7348
7349
7350
7351
7352
7353
7354
7355
7356
7357
7358
7359
7360
7361
7362
7363
7364 static const char *get_glyph_gen (const char *iptr, char *optr, char mchar, t_bool uc, t_bool quote, char escape_char)
7365 {
7366 t_bool quoting = FALSE;
7367 t_bool escaping = FALSE;
7368 char quote_char = 0;
7369
7370 while ((*iptr != 0) &&
7371 ((quote && quoting) || ((sim_isspace (*iptr) == 0) && (*iptr != mchar)))) {
7372 if (quote) {
7373 if (quoting) {
7374 if (!escaping) {
7375 if (*iptr == escape_char)
7376 escaping = TRUE;
7377 else
7378 if (*iptr == quote_char)
7379 quoting = FALSE;
7380 }
7381 else
7382 escaping = FALSE;
7383 }
7384 else {
7385 if ((*iptr == '"') || (*iptr == '\'')) {
7386 quoting = TRUE;
7387 quote_char = *iptr;
7388 }
7389 }
7390 }
7391 if (sim_islower (*iptr) && uc)
7392 *optr = (char)toupper (*iptr);
7393 else *optr = *iptr;
7394 iptr++; optr++;
7395 }
7396 if (mchar && (*iptr == mchar))
7397 iptr++;
7398 *optr = 0;
7399 while (sim_isspace (*iptr))
7400 iptr++;
7401 return iptr;
7402 }
7403
7404 CONST char *get_glyph (const char *iptr, char *optr, char mchar)
7405 {
7406 return (CONST char *)get_glyph_gen (iptr, optr, mchar, TRUE, FALSE, 0);
7407 }
7408
7409 CONST char *get_glyph_nc (const char *iptr, char *optr, char mchar)
7410 {
7411 return (CONST char *)get_glyph_gen (iptr, optr, mchar, FALSE, FALSE, 0);
7412 }
7413
7414 CONST char *get_glyph_quoted (const char *iptr, char *optr, char mchar)
7415 {
7416 return (CONST char *)get_glyph_gen (iptr, optr, mchar, FALSE, TRUE, '\\');
7417 }
7418
7419 CONST char *get_glyph_cmd (const char *iptr, char *optr)
7420 {
7421
7422 if ((iptr[0] == '!') && (!sim_isspace(iptr[1]))) {
7423 strcpy (optr, "!");
7424 return (CONST char *)(iptr + 1);
7425 }
7426 return (CONST char *)get_glyph_gen (iptr, optr, 0, TRUE, FALSE, 0);
7427 }
7428
7429
7430
7431
7432
7433
7434
7435
7436
7437 char *sim_trim_endspc (char *cptr)
7438 {
7439 char *tptr;
7440
7441 tptr = cptr + strlen (cptr);
7442 while ((--tptr >= cptr) && sim_isspace (*tptr))
7443 *tptr = 0;
7444 return cptr;
7445 }
7446
7447 int sim_isspace (char c)
7448 {
7449 return (c & 0x80) ? 0 : isspace (c);
7450 }
7451
7452 int sim_islower (char c)
7453 {
7454 return (c & 0x80) ? 0 : islower (c);
7455 }
7456
7457 int sim_isalpha (char c)
7458 {
7459 return (c & 0x80) ? 0 : isalpha (c);
7460 }
7461
7462 int sim_isprint (char c)
7463 {
7464 return (c & 0x80) ? 0 : isprint (c);
7465 }
7466
7467 int sim_isdigit (char c)
7468 {
7469 return (c & 0x80) ? 0 : isdigit (c);
7470 }
7471
7472 int sim_isgraph (char c)
7473 {
7474 return (c & 0x80) ? 0 : isgraph (c);
7475 }
7476
7477 int sim_isalnum (char c)
7478 {
7479 return (c & 0x80) ? 0 : isalnum (c);
7480 }
7481
7482
7483
7484
7485
7486
7487
7488
7489
7490
7491
7492
7493 t_value get_uint (const char *cptr, uint32 radix, t_value max, t_stat *status)
7494 {
7495 t_value val;
7496 CONST char *tptr;
7497
7498 *status = SCPE_OK;
7499 val = strtotv ((CONST char *)cptr, &tptr, radix);
7500 if ((cptr == tptr) || (val > max))
7501 *status = SCPE_ARG;
7502 else {
7503 while (sim_isspace (*tptr)) tptr++;
7504 if (*tptr != 0)
7505 *status = SCPE_ARG;
7506 }
7507 return val;
7508 }
7509
7510
7511
7512
7513
7514
7515
7516
7517
7518
7519
7520
7521
7522
7523
7524
7525 CONST char *get_range (DEVICE *dptr, CONST char *cptr, t_addr *lo, t_addr *hi,
7526 uint32 rdx, t_addr max, char term)
7527 {
7528 CONST char *tptr;
7529
7530 if (max && strncmp (cptr, "ALL", strlen ("ALL")) == 0) {
7531 tptr = cptr + strlen ("ALL");
7532 *lo = 0;
7533 *hi = max;
7534 }
7535 else {
7536 if ((strncmp (cptr, ".", strlen (".")) == 0) &&
7537 ((cptr[1] == '\0') ||
7538 (cptr[1] == '-') ||
7539 (cptr[1] == ':') ||
7540 (cptr[1] == '/'))) {
7541 tptr = cptr + strlen (".");
7542 *lo = *hi = sim_last_addr;
7543 }
7544 else {
7545 if (strncmp (cptr, "$", strlen ("$")) == 0) {
7546 tptr = cptr + strlen ("$");
7547 *hi = *lo = (t_addr)sim_last_val;
7548 }
7549 else {
7550 if (dptr && sim_vm_parse_addr)
7551 *lo = sim_vm_parse_addr (dptr, cptr, &tptr);
7552 else
7553 *lo = (t_addr) strtotv (cptr, &tptr, rdx);
7554 if (cptr == tptr)
7555 return NULL;
7556 }
7557 }
7558 if ((*tptr == '-') || (*tptr == ':')) {
7559 cptr = tptr + 1;
7560 if (dptr && sim_vm_parse_addr)
7561 *hi = sim_vm_parse_addr (dptr, cptr, &tptr);
7562 else *hi = (t_addr) strtotv (cptr, &tptr, rdx);
7563 if (cptr == tptr)
7564 return NULL;
7565 if (*lo > *hi)
7566 return NULL;
7567 }
7568 else if (*tptr == '/') {
7569 cptr = tptr + 1;
7570 *hi = (t_addr) strtotv (cptr, &tptr, rdx);
7571 if ((cptr == tptr) || (*hi == 0))
7572 return NULL;
7573 *hi = *lo + *hi - 1;
7574 }
7575 else *hi = *lo;
7576 }
7577 sim_last_addr = *hi;
7578 if (term && (*tptr++ != term))
7579 return NULL;
7580 return tptr;
7581 }
7582
7583
7584
7585
7586
7587
7588
7589
7590
7591
7592
7593
7594
7595
7596
7597
7598
7599
7600
7601 t_stat sim_decode_quoted_string (const char *iptr, uint8 *optr, uint32 *osize)
7602 {
7603 char quote_char;
7604 uint8 *ostart = optr;
7605
7606 *osize = 0;
7607 if ((strlen(iptr) == 1) ||
7608 (iptr[0] != iptr[strlen(iptr)-1]) ||
7609 ((iptr[strlen(iptr)-1] != '"') && (iptr[strlen(iptr)-1] != '\'')))
7610 return SCPE_ARG;
7611 quote_char = *iptr++;
7612 while (iptr[1]) {
7613 if (*iptr != '\\') {
7614 if (*iptr == quote_char)
7615 return SCPE_ARG;
7616 *(optr++) = (uint8)(*(iptr++));
7617 continue;
7618 }
7619 ++iptr;
7620 switch (*iptr) {
7621 case 'r':
7622 *(optr++) = 13; ++iptr;
7623 break;
7624 case 'n':
7625 *(optr++) = 10; ++iptr;
7626 break;
7627 case 'f':
7628 *(optr++) = 12; ++iptr;
7629 break;
7630 case 't':
7631 *(optr++) = 9; ++iptr;
7632 break;
7633 case 'v':
7634 *(optr++) = 11; ++iptr;
7635 break;
7636 case 'b':
7637 *(optr++) = 8; ++iptr;
7638 break;
7639 case '\\':
7640 *(optr++) = 92; ++iptr;
7641 break;
7642 case 'e':
7643 *(optr++) = 27; ++iptr;
7644 break;
7645 case '\'':
7646 *(optr++) = 39; ++iptr;
7647 break;
7648 case '"':
7649 *(optr++) = 34; ++iptr;
7650 break;
7651 case '?':
7652 *(optr++) = 63; ++iptr;
7653 break;
7654 case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
7655 *optr = *(iptr++) - '0';
7656 if ((*iptr >= '0') && (*iptr <= '7'))
7657 *optr = ((*optr)<<3) + (*(iptr++) - '0');
7658 if ((*iptr >= '0') && (*iptr <= '7'))
7659 *optr = ((*optr)<<3) + (*(iptr++) - '0');
7660 ++optr;
7661 break;
7662 case 'x':
7663 if (1) {
7664 static const char *hex_digits = "0123456789ABCDEF";
7665 const char *c;
7666
7667 ++iptr;
7668 *optr = 0;
7669 c = strchr (hex_digits, toupper(*iptr));
7670 if (c) {
7671 *optr = ((*optr)<<4) + (uint8)(c-hex_digits);
7672 ++iptr;
7673 }
7674 c = strchr (hex_digits, toupper(*iptr));
7675 if (c) {
7676 *optr = ((*optr)<<4) + (uint8)(c-hex_digits);
7677 ++iptr;
7678 }
7679 ++optr;
7680 }
7681 break;
7682 default:
7683 return SCPE_ARG;
7684 }
7685 }
7686 *optr = '\0';
7687 *osize = (uint32)(optr-ostart);
7688 return SCPE_OK;
7689 }
7690
7691
7692
7693
7694
7695
7696
7697
7698
7699
7700
7701
7702
7703
7704 char *sim_encode_quoted_string (const uint8 *iptr, size_t size)
7705 {
7706 size_t i;
7707 t_bool double_quote_found = FALSE;
7708 t_bool single_quote_found = FALSE;
7709 char quote = '"';
7710 char *tptr, *optr;
7711
7712 optr = (char *)malloc (4*size + 3);
7713 if (optr == NULL)
7714 return NULL;
7715 tptr = optr;
7716 for (i=0; i<size; i++)
7717 switch ((char)iptr[i]) {
7718 case '"':
7719 double_quote_found = TRUE;
7720 break;
7721 case '\'':
7722 single_quote_found = TRUE;
7723 break;
7724 }
7725 if (double_quote_found && (!single_quote_found))
7726 quote = '\'';
7727 *tptr++ = quote;
7728 while (size--) {
7729 switch (*iptr) {
7730 case '\r':
7731 *tptr++ = '\\'; *tptr++ = 'r'; break;
7732 case '\n':
7733 *tptr++ = '\\'; *tptr++ = 'n'; break;
7734 case '\f':
7735 *tptr++ = '\\'; *tptr++ = 'f'; break;
7736 case '\t':
7737 *tptr++ = '\\'; *tptr++ = 't'; break;
7738 case '\v':
7739 *tptr++ = '\\'; *tptr++ = 'v'; break;
7740 case '\b':
7741 *tptr++ = '\\'; *tptr++ = 'b'; break;
7742 case '\\':
7743 *tptr++ = '\\'; *tptr++ = '\\'; break;
7744 case '"':
7745 case '\'':
7746 if (quote == *iptr)
7747 *tptr++ = '\\';
7748
7749 default:
7750 if (sim_isprint (*iptr))
7751 *tptr++ = *iptr;
7752 else {
7753 (void)sprintf (tptr, "\\%03o", *iptr);
7754 tptr += 4;
7755 }
7756 break;
7757 }
7758 ++iptr;
7759 }
7760 *tptr++ = quote;
7761 *tptr++ = '\0';
7762 return optr;
7763 }
7764
7765 void fprint_buffer_string (FILE *st, const uint8 *buf, size_t size)
7766 {
7767 char *string;
7768
7769 string = sim_encode_quoted_string (buf, size);
7770 (void)fprintf (st, "%s", string);
7771 FREE (string);
7772 }
7773
7774
7775
7776
7777
7778
7779
7780
7781
7782 DEVICE *find_dev (const char *cptr)
7783 {
7784 int32 i;
7785 DEVICE *dptr;
7786
7787 if (cptr == NULL)
7788 return NULL;
7789 for (i = 0; (dptr = sim_devices[i]) != NULL; i++) {
7790 if ((strcmp (cptr, dptr->name) == 0) ||
7791 (dptr->lname &&
7792 (strcmp (cptr, dptr->lname) == 0)))
7793 return dptr;
7794 }
7795 for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i) {
7796 if ((strcmp (cptr, dptr->name) == 0) ||
7797 (dptr->lname &&
7798 (strcmp (cptr, dptr->lname) == 0)))
7799 return dptr;
7800 }
7801 return NULL;
7802 }
7803
7804
7805
7806
7807
7808
7809
7810
7811
7812
7813
7814
7815 DEVICE *find_unit (const char *cptr, UNIT **uptr)
7816 {
7817 uint32 i, u;
7818 const char *nptr;
7819 const char *tptr;
7820 t_stat r;
7821 DEVICE *dptr;
7822
7823 if (uptr == NULL)
7824 return NULL;
7825 *uptr = NULL;
7826 if ((dptr = find_dev (cptr))) {
7827 if (qdisable (dptr))
7828 return NULL;
7829 *uptr = dptr->units;
7830 return dptr;
7831 }
7832
7833 for (i = 0; (dptr = sim_devices[i]) != NULL; i++) {
7834 if (qdisable (dptr))
7835 continue;
7836 if (dptr->numunits &&
7837 (((nptr = dptr->name) &&
7838 (strncmp (cptr, nptr, strlen (nptr)) == 0)) ||
7839 ((nptr = dptr->lname) &&
7840 (strncmp (cptr, nptr, strlen (nptr)) == 0)))) {
7841 tptr = cptr + strlen (nptr);
7842 if (sim_isdigit (*tptr)) {
7843 if (qdisable (dptr))
7844 return NULL;
7845 u = (uint32) get_uint (tptr, 10, dptr->numunits - 1, &r);
7846 if (r != SCPE_OK)
7847 *uptr = NULL;
7848 else
7849 *uptr = dptr->units + u;
7850 return dptr;
7851 }
7852 }
7853 for (u = 0; u < dptr->numunits; u++) {
7854 if (0 == strcmp (cptr, sim_uname (&dptr->units[u]))) {
7855 *uptr = &dptr->units[u];
7856 return dptr;
7857 }
7858 }
7859 }
7860 return NULL;
7861 }
7862
7863
7864
7865
7866
7867
7868
7869 t_stat sim_register_internal_device (DEVICE *dptr)
7870 {
7871 uint32 i;
7872
7873 for (i = 0; (sim_devices[i] != NULL); i++)
7874 if (sim_devices[i] == dptr)
7875 return SCPE_OK;
7876 for (i = 0; i < sim_internal_device_count; i++)
7877 if (sim_internal_devices[i] == dptr)
7878 return SCPE_OK;
7879 ++sim_internal_device_count;
7880 sim_internal_devices = (DEVICE **)realloc(sim_internal_devices, (sim_internal_device_count+1)*sizeof(*sim_internal_devices));
7881 if (!sim_internal_devices)
7882 {
7883 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
7884 __func__, __FILE__, __LINE__);
7885 #if defined(USE_BACKTRACE)
7886 # if defined(SIGUSR2)
7887 (void)raise(SIGUSR2);
7888
7889 # endif
7890 #endif
7891 abort();
7892 }
7893 sim_internal_devices[sim_internal_device_count-1] = dptr;
7894 sim_internal_devices[sim_internal_device_count] = NULL;
7895 return SCPE_OK;
7896 }
7897
7898
7899
7900
7901
7902
7903
7904
7905
7906 DEVICE *find_dev_from_unit (UNIT *uptr)
7907 {
7908 DEVICE *dptr;
7909 uint32 i, j;
7910
7911 if (uptr == NULL)
7912 return NULL;
7913 for (i = 0; (dptr = sim_devices[i]) != NULL; i++) {
7914 for (j = 0; j < dptr->numunits; j++) {
7915 if (uptr == (dptr->units + j))
7916 return dptr;
7917 }
7918 }
7919 for (i = 0; i<sim_internal_device_count; i++) {
7920 dptr = sim_internal_devices[i];
7921 for (j = 0; j < dptr->numunits; j++) {
7922 if (uptr == (dptr->units + j))
7923 return dptr;
7924 }
7925 }
7926 return NULL;
7927 }
7928
7929
7930
7931 t_bool qdisable (DEVICE *dptr)
7932 {
7933 return (dptr->flags & DEV_DIS? TRUE: FALSE);
7934 }
7935
7936
7937
7938
7939
7940
7941
7942
7943
7944
7945
7946
7947
7948 REG *find_reg_glob (CONST char *cptr, CONST char **optr, DEVICE **gdptr)
7949 {
7950 int32 i;
7951 DEVICE *dptr;
7952 REG *rptr, *srptr = NULL;
7953
7954 *gdptr = NULL;
7955 for (i = 0; (dptr = sim_devices[i]) != 0; i++) {
7956 if (dptr->flags & DEV_DIS)
7957 continue;
7958 if ((rptr = find_reg (cptr, optr, dptr))) {
7959 if (srptr)
7960 return NULL;
7961 srptr = rptr;
7962 *gdptr = dptr;
7963 }
7964 }
7965 return srptr;
7966 }
7967
7968
7969
7970
7971
7972
7973
7974
7975
7976
7977
7978
7979 REG *find_reg (CONST char *cptr, CONST char **optr, DEVICE *dptr)
7980 {
7981 CONST char *tptr;
7982 REG *rptr;
7983 size_t slnt;
7984
7985 if ((cptr == NULL) || (dptr == NULL) || (dptr->registers == NULL))
7986 return NULL;
7987 tptr = cptr;
7988 do {
7989 tptr++;
7990 } while (sim_isalnum (*tptr) || (*tptr == '*') || (*tptr == '_') || (*tptr == '.'));
7991 slnt = tptr - cptr;
7992 for (rptr = dptr->registers; rptr->name != NULL; rptr++) {
7993 if ((slnt == strlen (rptr->name)) &&
7994 (strncmp (cptr, rptr->name, slnt) == 0)) {
7995 if (optr != NULL)
7996 *optr = tptr;
7997 return rptr;
7998 }
7999 }
8000 return NULL;
8001 }
8002
8003
8004
8005
8006
8007
8008
8009
8010
8011
8012 int32 get_switches (const char *cptr)
8013 {
8014 int32 sw;
8015
8016 if (*cptr != '-')
8017 return 0;
8018 sw = 0;
8019 for (cptr++; (sim_isspace (*cptr) == 0) && (*cptr != 0); cptr++) {
8020 if (sim_isalpha (*cptr) == 0)
8021 return -1;
8022 sw = sw | SWMASK (toupper (*cptr));
8023 }
8024 return sw;
8025 }
8026
8027
8028
8029
8030
8031
8032
8033
8034
8035
8036 CONST char *get_sim_sw (CONST char *cptr)
8037 {
8038 int32 lsw;
8039 char gbuf[CBUFSIZE];
8040
8041 while (*cptr == '-') {
8042 cptr = get_glyph (cptr, gbuf, 0);
8043 lsw = get_switches (gbuf);
8044 if (lsw <= 0)
8045 return NULL;
8046 sim_switches = sim_switches | lsw;
8047 }
8048 return cptr;
8049 }
8050
8051
8052
8053
8054
8055
8056
8057
8058
8059
8060
8061 CONST char *get_sim_opt (int32 opt, CONST char *cptr, t_stat *st)
8062 {
8063 int32 t;
8064 char gbuf[CBUFSIZE];
8065 CONST char *svptr;
8066 DEVICE *tdptr;
8067 UNIT *tuptr;
8068
8069 sim_switches = 0;
8070 sim_ofile = NULL;
8071 sim_schrptr = NULL;
8072 sim_schaptr = NULL;
8073 sim_stabr.logic = sim_staba.logic = SCH_OR;
8074 sim_stabr.boolop = sim_staba.boolop = SCH_GE;
8075 sim_stabr.count = 1;
8076 sim_stabr.mask = (t_value *)realloc (sim_stabr.mask, sim_emax * sizeof(*sim_stabr.mask));
8077 if (!sim_stabr.mask)
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 (void)memset (sim_stabr.mask, 0, sim_emax * sizeof(*sim_stabr.mask));
8090 sim_stabr.comp = (t_value *)realloc (sim_stabr.comp, sim_emax * sizeof(*sim_stabr.comp));
8091 if (!sim_stabr.comp)
8092 {
8093 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8094 __func__, __FILE__, __LINE__);
8095 #if defined(USE_BACKTRACE)
8096 # if defined(SIGUSR2)
8097 (void)raise(SIGUSR2);
8098
8099 # endif
8100 #endif
8101 abort();
8102 }
8103 (void)memset (sim_stabr.comp, 0, sim_emax * sizeof(*sim_stabr.comp));
8104 sim_staba.count = sim_emax;
8105 sim_staba.mask = (t_value *)realloc (sim_staba.mask, sim_emax * sizeof(*sim_staba.mask));
8106 if (!sim_staba.mask)
8107 {
8108 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8109 __func__, __FILE__, __LINE__);
8110 #if defined(USE_BACKTRACE)
8111 # if defined(SIGUSR2)
8112 (void)raise(SIGUSR2);
8113
8114 # endif
8115 #endif
8116 abort();
8117 }
8118 (void)memset (sim_staba.mask, 0, sim_emax * sizeof(*sim_staba.mask));
8119 sim_staba.comp = (t_value *)realloc (sim_staba.comp, sim_emax * sizeof(*sim_staba.comp));
8120 if (!sim_staba.comp)
8121 {
8122 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8123 __func__, __FILE__, __LINE__);
8124 #if defined(USE_BACKTRACE)
8125 # if defined(SIGUSR2)
8126 (void)raise(SIGUSR2);
8127
8128 # endif
8129 #endif
8130 abort();
8131 }
8132 (void)memset (sim_staba.comp, 0, sim_emax * sizeof(*sim_staba.comp));
8133 if (! sim_dflt_dev)
8134 return NULL;
8135 sim_dfdev = sim_dflt_dev;
8136 sim_dfunit = sim_dfdev->units;
8137 sim_opt_out = 0;
8138 *st = SCPE_OK;
8139 while (*cptr) {
8140 svptr = cptr;
8141 if ((opt & CMD_OPT_OF) && (*cptr == '@')) {
8142 if (sim_ofile) {
8143 fclose (sim_ofile);
8144 *st = SCPE_ARG;
8145 return NULL;
8146 }
8147 cptr = get_glyph (cptr + 1, gbuf, 0);
8148 sim_ofile = sim_fopen (gbuf, "a");
8149 if (sim_ofile == NULL) {
8150 *st = SCPE_OPENERR;
8151 return NULL;
8152 }
8153 sim_opt_out |= CMD_OPT_OF;
8154 continue;
8155 }
8156 cptr = get_glyph (cptr, gbuf, 0);
8157 if ((t = get_switches (gbuf)) != 0) {
8158 if (t < 0) {
8159 *st = SCPE_INVSW;
8160 return NULL;
8161 }
8162 sim_switches = sim_switches | t;
8163 }
8164 else if ((opt & CMD_OPT_SCH) &&
8165 get_rsearch (gbuf, sim_dfdev->dradix, &sim_stabr)) {
8166 sim_schrptr = &sim_stabr;
8167 sim_schaptr = get_asearch (gbuf, sim_dfdev->dradix, &sim_staba);
8168 sim_opt_out |= CMD_OPT_SCH;
8169 }
8170 else if ((opt & CMD_OPT_DFT) &&
8171 ((sim_opt_out & CMD_OPT_DFT) == 0) &&
8172 (tdptr = find_unit (gbuf, &tuptr)) &&
8173 (tuptr != NULL)) {
8174 sim_dfdev = tdptr;
8175 sim_dfunit = tuptr;
8176 sim_opt_out |= CMD_OPT_DFT;
8177 }
8178 else return svptr;
8179 }
8180 return cptr;
8181 }
8182
8183
8184
8185
8186
8187
8188
8189
8190
8191
8192
8193 const char *put_switches (char *buf, size_t bufsize, uint32 sw)
8194 {
8195 char *optr = buf;
8196 int32 bit;
8197
8198 (void)memset (buf, 0, bufsize);
8199 if ((sw == 0) || (bufsize < 3))
8200 return buf;
8201 --bufsize;
8202 *optr++ = '-';
8203 for (bit=0; bit <= ('Z'-'A'); bit++)
8204 if (sw & (1 << bit))
8205 if ((size_t)(optr - buf) < bufsize)
8206 *optr++ = 'A' + bit;
8207 return buf;
8208 }
8209
8210
8211
8212
8213
8214
8215
8216
8217
8218
8219
8220
8221 SCHTAB *get_rsearch (CONST char *cptr, int32 radix, SCHTAB *schptr)
8222 {
8223 int32 c;
8224 size_t logop, cmpop;
8225 t_value logval, cmpval;
8226 const char *sptr;
8227 CONST char *tptr;
8228 const char logstr[] = "|&^", cmpstr[] = "=!><";
8229
8230 const size_t invalid_op = (size_t) -1;
8231
8232 logval = cmpval = 0;
8233 if (*cptr == 0)
8234 return NULL;
8235
8236 for (logop = cmpop = invalid_op; (c = *cptr++); ) {
8237 if ((sptr = strchr (logstr, c))) {
8238 logop = sptr - logstr;
8239 logval = strtotv (cptr, &tptr, radix);
8240 if (cptr == tptr)
8241 return NULL;
8242 cptr = tptr;
8243 }
8244 else if ((sptr = strchr (cmpstr, c))) {
8245 cmpop = sptr - cmpstr;
8246 if (*cptr == '=') {
8247 cmpop = cmpop + strlen (cmpstr);
8248 cptr++;
8249 }
8250 cmpval = strtotv (cptr, &tptr, radix);
8251 if (cptr == tptr)
8252 return NULL;
8253 cptr = tptr;
8254 }
8255 else return NULL;
8256 }
8257 if (schptr->count != 1) {
8258 FREE (schptr->mask);
8259 schptr->mask = (t_value *)calloc (sim_emax, sizeof(*schptr->mask));
8260 FREE (schptr->comp);
8261 schptr->comp = (t_value *)calloc (sim_emax, sizeof(*schptr->comp));
8262 }
8263 if (logop != invalid_op) {
8264 schptr->logic = logop;
8265 schptr->mask[0] = logval;
8266 }
8267 if (cmpop != invalid_op) {
8268 schptr->boolop = cmpop;
8269 schptr->comp[0] = cmpval;
8270 }
8271 schptr->count = 1;
8272 return schptr;
8273 }
8274
8275
8276
8277
8278
8279
8280
8281
8282
8283
8284
8285
8286 SCHTAB *get_asearch (CONST char *cptr, int32 radix, SCHTAB *schptr)
8287 {
8288 int32 c;
8289 size_t logop, cmpop;
8290 t_value *logval, *cmpval;
8291 t_stat reason = SCPE_OK;
8292 CONST char *ocptr = cptr;
8293 const char *sptr;
8294 char gbuf[CBUFSIZE];
8295 const char logstr[] = "|&^", cmpstr[] = "=!><";
8296
8297 const size_t invalid_op = (size_t) -1;
8298
8299 if (*cptr == 0)
8300 return NULL;
8301 logval = (t_value *)calloc (sim_emax, sizeof(*logval));
8302 cmpval = (t_value *)calloc (sim_emax, sizeof(*cmpval));
8303
8304 for (logop = cmpop = invalid_op; (c = *cptr++); ) {
8305 if (NULL != (sptr = strchr (logstr, c))) {
8306 logop = sptr - logstr;
8307 cptr = get_glyph (cptr, gbuf, 0);
8308 reason = parse_sym (gbuf, 0, sim_dfunit, logval, sim_switches);
8309 if (reason > 0) {
8310 FREE (logval);
8311 FREE (cmpval);
8312 return get_rsearch (ocptr, radix, schptr);
8313 }
8314 }
8315 else if (NULL != (sptr = strchr (cmpstr, c))) {
8316 cmpop = sptr - cmpstr;
8317 if (*cptr == '=') {
8318 cmpop = cmpop + strlen (cmpstr);
8319 cptr++;
8320 }
8321 cptr = get_glyph (cptr, gbuf, 0);
8322 reason = parse_sym (gbuf, 0, sim_dfunit, cmpval, sim_switches);
8323 if (reason > 0) {
8324 FREE (logval);
8325 FREE (cmpval);
8326 return get_rsearch (ocptr, radix, schptr);
8327 }
8328 }
8329 else {
8330 FREE (logval);
8331 FREE (cmpval);
8332 return NULL;
8333 }
8334 }
8335 if (schptr->count != (uint32)(1 - reason)) {
8336 schptr->count = 1 - reason;
8337 FREE (schptr->mask);
8338 schptr->mask = (t_value *)calloc (sim_emax, sizeof(*schptr->mask));
8339 FREE (schptr->comp);
8340 schptr->comp = (t_value *)calloc (sim_emax, sizeof(*schptr->comp));
8341 }
8342 if (logop != invalid_op) {
8343 schptr->logic = logop;
8344 FREE (schptr->mask);
8345 schptr->mask = logval;
8346 }
8347 else {
8348 FREE (logval);
8349 }
8350 if (cmpop != invalid_op) {
8351 schptr->boolop = cmpop;
8352 FREE (schptr->comp);
8353 schptr->comp = cmpval;
8354 }
8355 else {
8356 FREE (cmpval);
8357 }
8358 return schptr;
8359 }
8360
8361
8362
8363
8364
8365
8366
8367
8368
8369
8370 int32 test_search (t_value *values, SCHTAB *schptr)
8371 {
8372 t_value *val = NULL;
8373 int32 i, updown;
8374 int32 ret = 0;
8375
8376 if (schptr == NULL)
8377 return ret;
8378
8379 val = (t_value *)malloc (schptr->count * sizeof (*values));
8380 if (!val)
8381 {
8382 (void)fprintf(stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
8383 __func__, __FILE__, __LINE__);
8384 #if defined(USE_BACKTRACE)
8385 # if defined(SIGUSR2)
8386 (void)raise(SIGUSR2);
8387
8388 # endif
8389 #endif
8390 abort();
8391 }
8392 for (i=0; i<(int32)schptr->count; i++) {
8393 val[i] = values[i];
8394 switch (schptr->logic) {
8395
8396 case SCH_OR:
8397 val[i] = val[i] | schptr->mask[i];
8398 break;
8399
8400 case SCH_AND:
8401 val[i] = val[i] & schptr->mask[i];
8402 break;
8403
8404 case SCH_XOR:
8405 val[i] = val[i] ^ schptr->mask[i];
8406 break;
8407 }
8408 }
8409
8410 ret = 1;
8411 if (1) {
8412 updown = -1;
8413 i=schptr->count-1;
8414 }
8415 else {
8416 updown = 1;
8417 i=0;
8418 }
8419 for (; (i>=0) && (i<(int32)schptr->count) && ret; i += updown) {
8420 switch (schptr->boolop) {
8421
8422 case SCH_E: case SCH_EE:
8423 if (val[i] != schptr->comp[i])
8424 ret = 0;
8425 break;
8426
8427 case SCH_N: case SCH_NE:
8428 if (val[i] == schptr->comp[i])
8429 ret = 0;
8430 break;
8431
8432 case SCH_G:
8433 if (val[i] <= schptr->comp[i])
8434 ret = 0;
8435 break;
8436
8437 case SCH_GE:
8438 if (val[i] < schptr->comp[i])
8439 ret = 0;
8440 break;
8441
8442 case SCH_L:
8443 if (val[i] >= schptr->comp[i])
8444 ret = 0;
8445 break;
8446
8447 case SCH_LE:
8448 if (val[i] > schptr->comp[i])
8449 ret = 0;
8450 break;
8451 }
8452 }
8453 FREE (val);
8454 return ret;
8455 }
8456
8457
8458
8459
8460
8461
8462
8463
8464
8465
8466
8467
8468
8469
8470
8471 t_value strtotv (CONST char *inptr, CONST char **endptr, uint32 radix)
8472 {
8473 int32 nodigit;
8474 t_value val;
8475 uint32 c, digit;
8476
8477 *endptr = inptr;
8478 if ((radix < 2) || (radix > 36))
8479 return 0;
8480 while (sim_isspace (*inptr))
8481 inptr++;
8482 val = 0;
8483 nodigit = 1;
8484 for (c = *inptr; sim_isalnum(c); c = *++inptr) {
8485 if (sim_islower (c))
8486 c = toupper (c);
8487 if (sim_isdigit (c))
8488 digit = c - (uint32) '0';
8489 else if (radix <= 10)
8490 break;
8491 else digit = c + 10 - (uint32) 'A';
8492 if (digit >= radix)
8493 return 0;
8494 val = (val * radix) + digit;
8495 nodigit = 0;
8496 }
8497 if (nodigit)
8498 return 0;
8499 *endptr = inptr;
8500 return val;
8501 }
8502
8503
8504
8505
8506
8507
8508
8509
8510
8511
8512
8513
8514
8515
8516
8517 t_stat sprint_val (char *buffer, t_value val, uint32 radix,
8518 size_t width, uint32 format)
8519 {
8520 #define MAX_WIDTH ((CHAR_BIT * sizeof (t_value) * 4 + 3) / 3)
8521 t_value owtest, wtest;
8522 size_t d;
8523 size_t digit;
8524 size_t ndigits;
8525 size_t commas = 0;
8526 char dbuf[MAX_WIDTH + 1];
8527
8528 for (d = 0; d < MAX_WIDTH; d++)
8529 dbuf[d] = (format == PV_RZRO)? '0': ' ';
8530 dbuf[MAX_WIDTH] = 0;
8531 d = MAX_WIDTH;
8532 do {
8533 d = d - 1;
8534 digit = val % radix;
8535 val = val / radix;
8536 dbuf[d] = (char)((digit <= 9)? '0' + digit: 'A' + (digit - 10));
8537 } while ((d > 0) && (val != 0));
8538
8539 switch (format) {
8540 case PV_LEFT:
8541 break;
8542 case PV_RZRO:
8543 wtest = owtest = radix;
8544 ndigits = 1;
8545 while ((wtest < width_mask[width]) && (wtest >= owtest)) {
8546 owtest = wtest;
8547 wtest = wtest * radix;
8548 ndigits = ndigits + 1;
8549 }
8550 if ((MAX_WIDTH - (ndigits + commas)) < d)
8551 d = MAX_WIDTH - (ndigits + commas);
8552 break;
8553 }
8554 if (NULL == buffer)
8555 return ((t_stat) strlen(dbuf+d));
8556 *buffer = '\0';
8557 if (width < strlen(dbuf+d))
8558 return SCPE_IOERR;
8559 strcpy(buffer, dbuf+d);
8560 return SCPE_OK;
8561 }
8562
8563 t_stat fprint_val (FILE *stream, t_value val, uint32 radix,
8564 uint32 width, uint32 format)
8565 {
8566 char dbuf[MAX_WIDTH + 1];
8567
8568 if (!stream)
8569 return sprint_val (NULL, val, radix, width, format);
8570 if (width > MAX_WIDTH)
8571 width = MAX_WIDTH;
8572 sprint_val (dbuf, val, radix, width, format);
8573 if (Fprintf (stream, "%s", dbuf) < 0)
8574 return SCPE_IOERR;
8575 return SCPE_OK;
8576 }
8577
8578 const char *sim_fmt_secs (double seconds)
8579 {
8580 static char buf[60];
8581 char frac[16] = "";
8582 const char *sign = "";
8583 double val = seconds;
8584 double days, hours, mins, secs, msecs, usecs;
8585
8586 if (val == 0.0)
8587 return "";
8588 if (val < 0.0) {
8589 sign = "-";
8590 val = -val;
8591 }
8592 days = floor (val / (24.0*60.0*60.0));
8593 val -= (days * 24.0*60.0*60.0);
8594 hours = floor (val / (60.0*60.0));
8595 val -= (hours * 60.0 * 60.0);
8596 mins = floor (val / 60.0);
8597 val -= (mins * 60.0);
8598 secs = floor (val);
8599 val -= secs;
8600 val *= 1000.0;
8601 msecs = floor (val);
8602 val -= msecs;
8603 val *= 1000.0;
8604 usecs = floor (val+0.5);
8605 if (usecs == 1000.0) {
8606 usecs = 0.0;
8607 msecs += 1;
8608 }
8609 if ((msecs > 0.0) || (usecs > 0.0)) {
8610 (void)sprintf (frac, ".%03.0f%03.0f", msecs, usecs);
8611 while (frac[strlen (frac) - 1] == '0')
8612 frac[strlen (frac) - 1] = '\0';
8613 if (strlen (frac) == 1)
8614 frac[0] = '\0';
8615 }
8616 if (days > 0)
8617 (void)sprintf (buf, "%s%.0f day%s %02.0f:%02.0f:%02.0f%s hour%s",
8618 sign, days, (days != 1) ? "s" : "", hours, mins,
8619 secs, frac, (days == 1) ? "s" : "");
8620 else
8621 if (hours > 0)
8622 (void)sprintf (buf, "%s%.0f:%02.0f:%02.0f%s hour",
8623 sign, hours, mins, secs, frac);
8624 else
8625 if (mins > 0)
8626 (void)sprintf (buf, "%s%.0f:%02.0f%s minute",
8627 sign, mins, secs, frac);
8628 else
8629 if (secs > 0)
8630 (void)sprintf (buf, "%s%.0f%s second",
8631 sign, secs, frac);
8632 else
8633 if (msecs > 0) {
8634 if (usecs > 0)
8635 (void)sprintf (buf, "%s%.0f.%s msec",
8636 sign, msecs, frac+4);
8637 else
8638 (void)sprintf (buf, "%s%.0f msec",
8639 sign, msecs);
8640 }
8641 else
8642 (void)sprintf (buf, "%s%.0f usec",
8643 sign, usecs);
8644 if (0 != strncmp ("1 ", buf, 2))
8645 strcpy (&buf[strlen (buf)], "s");
8646 return buf;
8647 }
8648
8649
8650
8651
8652
8653
8654
8655
8656
8657
8658
8659
8660
8661
8662
8663
8664 t_stat sim_process_event (void)
8665 {
8666 UNIT *uptr;
8667 t_stat reason;
8668 #if defined(TESTING)
8669 cpu_state_t * cpup = _cpup;
8670 #endif
8671
8672 if (stop_cpu)
8673 {
8674 #if defined(WIN_STDIO)
8675 (void)fflush(stdout);
8676 (void)fflush(stderr);
8677 #endif
8678 return SCPE_STOP;
8679 }
8680 UPDATE_SIM_TIME;
8681
8682 if (sim_clock_queue == QUEUE_LIST_END) {
8683 sim_interval = noqueue_time = NOQUEUE_WAIT;
8684 sim_debug (SIM_DBG_EVENT, sim_dflt_dev,
8685 "Queue Empty New Interval = %d\n",
8686 sim_interval);
8687 return SCPE_OK;
8688 }
8689 sim_processing_event = TRUE;
8690 do {
8691 uptr = sim_clock_queue;
8692 sim_clock_queue = uptr->next;
8693 uptr->next = NULL;
8694 sim_interval -= uptr->time;
8695 uptr->time = 0;
8696 if (sim_clock_queue != QUEUE_LIST_END)
8697 sim_interval = sim_clock_queue->time;
8698 else
8699 sim_interval = noqueue_time = NOQUEUE_WAIT;
8700 sim_debug (SIM_DBG_EVENT, sim_dflt_dev,
8701 "Processing Event for %s\n", sim_uname (uptr));
8702 if (uptr->action != NULL)
8703 reason = uptr->action (uptr);
8704 else
8705 reason = SCPE_OK;
8706 } while ((reason == SCPE_OK) &&
8707 (sim_interval <= 0) &&
8708 (sim_clock_queue != QUEUE_LIST_END) &&
8709 (!stop_cpu));
8710
8711 if (sim_clock_queue == QUEUE_LIST_END) {
8712 sim_interval = noqueue_time = NOQUEUE_WAIT;
8713 sim_debug (SIM_DBG_EVENT, sim_dflt_dev,
8714 "Processing Queue Complete New Interval = %d\n",
8715 sim_interval);
8716 }
8717 else
8718 sim_debug (SIM_DBG_EVENT, sim_dflt_dev,
8719 "Processing Queue Complete New Interval = %d(%s)\n",
8720 sim_interval, sim_uname(sim_clock_queue));
8721
8722 if ((reason == SCPE_OK) && stop_cpu)
8723 {
8724 #if defined(WIN_STDIO)
8725 (void)fflush(stdout);
8726 (void)fflush(stderr);
8727 #endif
8728 reason = SCPE_STOP;
8729 }
8730 sim_processing_event = FALSE;
8731 return reason;
8732 }
8733
8734
8735
8736
8737
8738
8739
8740
8741
8742
8743 t_stat sim_activate (UNIT *uptr, int32 event_time)
8744 {
8745 if (uptr->dynflags & UNIT_TMR_UNIT)
8746 return sim_timer_activate (uptr, event_time);
8747 return _sim_activate (uptr, event_time);
8748 }
8749
8750 t_stat _sim_activate (UNIT *uptr, int32 event_time)
8751 {
8752 UNIT *cptr, *prvptr;
8753 int32 accum;
8754 #if defined(TESTING)
8755 cpu_state_t * cpup = _cpup;
8756 #endif
8757
8758 if (sim_is_active (uptr))
8759 return SCPE_OK;
8760 UPDATE_SIM_TIME;
8761
8762 sim_debug (SIM_DBG_ACTIVATE, sim_dflt_dev, "Activating %s delay=%d\n", sim_uname (uptr), event_time);
8763
8764 prvptr = NULL;
8765 accum = 0;
8766 for (cptr = sim_clock_queue; cptr != QUEUE_LIST_END; cptr = cptr->next) {
8767 if (event_time < (accum + cptr->time))
8768 break;
8769 accum = accum + cptr->time;
8770 prvptr = cptr;
8771 }
8772 if (prvptr == NULL) {
8773 cptr = uptr->next = sim_clock_queue;
8774 sim_clock_queue = uptr;
8775 }
8776 else {
8777 cptr = uptr->next = prvptr->next;
8778 prvptr->next = uptr;
8779 }
8780 uptr->time = event_time - accum;
8781 if (cptr != QUEUE_LIST_END)
8782 cptr->time = cptr->time - uptr->time;
8783 sim_interval = sim_clock_queue->time;
8784 return SCPE_OK;
8785 }
8786
8787
8788
8789
8790
8791
8792
8793
8794
8795
8796 t_stat sim_activate_abs (UNIT *uptr, int32 event_time)
8797 {
8798 sim_cancel (uptr);
8799 return _sim_activate (uptr, event_time);
8800 }
8801
8802
8803
8804
8805
8806
8807
8808
8809
8810
8811 t_stat sim_activate_after (UNIT *uptr, uint32 usec_delay)
8812 {
8813 return _sim_activate_after (uptr, usec_delay);
8814 }
8815
8816 t_stat _sim_activate_after (UNIT *uptr, uint32 usec_delay)
8817 {
8818 if (sim_is_active (uptr))
8819 return SCPE_OK;
8820 return sim_timer_activate_after (uptr, usec_delay);
8821 }
8822
8823
8824
8825
8826
8827
8828
8829
8830
8831
8832 t_stat sim_cancel (UNIT *uptr)
8833 {
8834 UNIT *cptr, *nptr;
8835 #if defined(TESTING)
8836 cpu_state_t * cpup = _cpup;
8837 #endif
8838
8839 if (sim_clock_queue == QUEUE_LIST_END)
8840 return SCPE_OK;
8841 if (!sim_is_active (uptr))
8842 return SCPE_OK;
8843 UPDATE_SIM_TIME;
8844 sim_debug (SIM_DBG_EVENT, sim_dflt_dev, "Canceling Event for %s\n", sim_uname(uptr));
8845 nptr = QUEUE_LIST_END;
8846
8847 if (sim_clock_queue == uptr) {
8848 nptr = sim_clock_queue = uptr->next;
8849 uptr->next = NULL;
8850 }
8851 else {
8852 for (cptr = sim_clock_queue; cptr != QUEUE_LIST_END; cptr = cptr->next) {
8853 if (cptr->next == uptr) {
8854 nptr = cptr->next = uptr->next;
8855 uptr->next = NULL;
8856 break;
8857 }
8858 }
8859 }
8860 if (nptr != QUEUE_LIST_END)
8861 nptr->time += (uptr->next) ? 0 : uptr->time;
8862 if (!uptr->next)
8863 uptr->time = 0;
8864 if (sim_clock_queue != QUEUE_LIST_END)
8865 sim_interval = sim_clock_queue->time;
8866 else sim_interval = noqueue_time = NOQUEUE_WAIT;
8867 if (uptr->next) {
8868 sim_printf ("\rCancel failed for '%s'!\r\n", sim_uname(uptr));
8869 if (sim_deb)
8870 fclose(sim_deb);
8871 (void)fprintf (stderr, "\rFATAL: Bugcheck! Aborting at %s[%s:%d]\r\n",
8872 __func__, __FILE__, __LINE__);
8873 abort ();
8874 }
8875 return SCPE_OK;
8876 }
8877
8878
8879
8880
8881
8882
8883
8884
8885
8886 t_bool sim_is_active (UNIT *uptr)
8887 {
8888 if (uptr->next == NULL)
8889 return FALSE;
8890 else
8891 return TRUE;
8892 }
8893
8894
8895
8896
8897
8898
8899
8900
8901
8902 int32 sim_activate_time (UNIT *uptr)
8903 {
8904 UNIT *cptr;
8905 int32 accum = 0;
8906
8907 for (cptr = sim_clock_queue; cptr != QUEUE_LIST_END; cptr = cptr->next) {
8908 if (cptr == sim_clock_queue) {
8909 if (sim_interval > 0)
8910 accum = accum + sim_interval;
8911 }
8912 else
8913 accum = accum + cptr->time;
8914 if (cptr == uptr)
8915 return accum + 1;
8916 }
8917 return 0;
8918 }
8919
8920
8921
8922
8923
8924
8925
8926
8927 double sim_gtime (void)
8928 {
8929 return sim_time;
8930 }
8931
8932
8933
8934
8935
8936
8937
8938
8939 int32 sim_qcount (void)
8940 {
8941 int32 cnt;
8942 UNIT *uptr;
8943
8944 cnt = 0;
8945 for (uptr = sim_clock_queue; uptr != QUEUE_LIST_END; uptr = uptr->next)
8946 cnt++;
8947 return cnt;
8948 }
8949
8950
8951
8952
8953
8954
8955
8956
8957
8958
8959
8960
8961
8962
8963
8964
8965
8966
8967
8968
8969
8970
8971
8972
8973
8974
8975
8976
8977
8978
8979
8980
8981
8982
8983
8984
8985 t_stat sim_brk_init (void)
8986 {
8987 int32 i;
8988
8989 for (i=0; i<sim_brk_lnt; i++) {
8990 BRKTAB *bp;
8991 if (sim_brk_tab)
8992 {
8993 bp = sim_brk_tab[i];
8994
8995 while (bp)
8996 {
8997 BRKTAB *bpt = bp->next;
8998
8999 FREE (bp->act);
9000 FREE (bp);
9001 bp = bpt;
9002 }
9003 }
9004 }
9005 if (sim_brk_tab != NULL)
9006 (void)memset (sim_brk_tab, 0, sim_brk_lnt*sizeof (BRKTAB*));
9007 sim_brk_lnt = SIM_BRK_INILNT;
9008 sim_brk_tab = (BRKTAB **) realloc (sim_brk_tab, sim_brk_lnt*sizeof (BRKTAB*));
9009 if (sim_brk_tab == NULL)
9010 return SCPE_MEM;
9011 (void)memset (sim_brk_tab, 0, sim_brk_lnt*sizeof (BRKTAB*));
9012 sim_brk_ent = sim_brk_ins = 0;
9013 sim_brk_clract ();
9014 sim_brk_npc (0);
9015 return SCPE_OK;
9016 }
9017
9018
9019
9020 BRKTAB *sim_brk_fnd (t_addr loc)
9021 {
9022 int32 lo, hi, p;
9023 BRKTAB *bp;
9024
9025 if (sim_brk_ent == 0) {
9026 sim_brk_ins = 0;
9027 return NULL;
9028 }
9029 lo = 0;
9030 hi = sim_brk_ent - 1;
9031 do {
9032 p = (lo + hi) >> 1;
9033 bp = sim_brk_tab[p];
9034 if (loc == bp->addr) {
9035 sim_brk_ins = p;
9036 return bp;
9037 }
9038 else if (loc < bp->addr)
9039 hi = p - 1;
9040 else lo = p + 1;
9041 } while (lo <= hi);
9042 if (loc < bp->addr)
9043 sim_brk_ins = p;
9044 else sim_brk_ins = p + 1;
9045 return NULL;
9046 }
9047
9048 BRKTAB *sim_brk_fnd_ex (t_addr loc, uint32 btyp, t_bool any_typ, uint32 spc)
9049 {
9050 BRKTAB *bp = sim_brk_fnd (loc);
9051
9052 while (bp) {
9053 if (any_typ ? ((bp->typ & btyp) && (bp->time_fired[spc] != sim_gtime())) :
9054 (bp->typ == btyp))
9055 return bp;
9056 bp = bp->next;
9057 }
9058 return bp;
9059 }
9060
9061
9062
9063 BRKTAB *sim_brk_new (t_addr loc, uint32 btyp)
9064 {
9065 int32 i, t;
9066 BRKTAB *bp, **newp;
9067
9068 if (sim_brk_ins < 0)
9069 return NULL;
9070 if (sim_brk_ent >= sim_brk_lnt) {
9071 t = sim_brk_lnt + SIM_BRK_INILNT;
9072 newp = (BRKTAB **) calloc (t, sizeof (BRKTAB*));
9073 if (newp == NULL)
9074 return NULL;
9075 memcpy (newp, sim_brk_tab, sim_brk_lnt * sizeof (*sim_brk_tab));
9076 (void)memset (newp + sim_brk_lnt, 0, SIM_BRK_INILNT * sizeof (*newp));
9077 FREE (sim_brk_tab);
9078 sim_brk_tab = newp;
9079 sim_brk_lnt = t;
9080 }
9081 if ((sim_brk_ins == sim_brk_ent) ||
9082 ((sim_brk_ins != sim_brk_ent) &&
9083 (sim_brk_tab[sim_brk_ins]->addr != loc))) {
9084 for (i = sim_brk_ent; i > sim_brk_ins; --i)
9085 sim_brk_tab[i] = sim_brk_tab[i - 1];
9086 sim_brk_tab[sim_brk_ins] = NULL;
9087 }
9088 bp = (BRKTAB *)calloc (1, sizeof (*bp));
9089 if (!bp)
9090 {
9091 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
9092 __func__, __FILE__, __LINE__);
9093 #if defined(USE_BACKTRACE)
9094 # if defined(SIGUSR2)
9095 (void)raise(SIGUSR2);
9096
9097 # endif
9098 #endif
9099 abort();
9100 }
9101 bp->next = sim_brk_tab[sim_brk_ins];
9102 sim_brk_tab[sim_brk_ins] = bp;
9103 if (bp->next == NULL)
9104 sim_brk_ent += 1;
9105 bp->addr = loc;
9106 bp->typ = btyp;
9107 bp->cnt = 0;
9108 bp->act = NULL;
9109 for (i = 0; i < SIM_BKPT_N_SPC; i++)
9110 bp->time_fired[i] = -1.0;
9111 return bp;
9112 }
9113
9114
9115
9116 t_stat sim_brk_set (t_addr loc, int32 sw, int32 ncnt, CONST char *act)
9117 {
9118 BRKTAB *bp;
9119
9120 if ((sw == 0) || (sw == BRK_TYP_DYN_STEPOVER))
9121 sw |= sim_brk_dflt;
9122 if (~sim_brk_types & sw) {
9123 char gbuf[CBUFSIZE];
9124
9125 return sim_messagef (SCPE_NOFNC, "Unknown breakpoint type; %s\n", put_switches(gbuf, sizeof(gbuf), sw & ~sim_brk_types));
9126 }
9127 if ((sw & BRK_TYP_DYN_ALL) && act)
9128 return SCPE_ARG;
9129 bp = sim_brk_fnd (loc);
9130 if (!bp)
9131 bp = sim_brk_new (loc, sw);
9132 else {
9133 while (bp && (bp->typ != (uint32)sw))
9134 bp = bp->next;
9135 if (!bp)
9136 bp = sim_brk_new (loc, sw);
9137 }
9138 if (!bp)
9139 return SCPE_MEM;
9140 bp->cnt = ncnt;
9141 if ((!(sw & BRK_TYP_DYN_ALL)) &&
9142 (bp->act != NULL) && (act != NULL)) {
9143 FREE (bp->act);
9144 bp->act = NULL;
9145 }
9146 if ((act != NULL) && (*act != 0)) {
9147 char *newp = (char *) calloc (CBUFSIZE+1, sizeof (char));
9148 if (newp == NULL)
9149 return SCPE_MEM;
9150 strncpy (newp, act, CBUFSIZE);
9151 bp->act = newp;
9152 }
9153 sim_brk_summ = sim_brk_summ | (sw & ~BRK_TYP_TEMP);
9154 return SCPE_OK;
9155 }
9156
9157
9158
9159 t_stat sim_brk_clr (t_addr loc, int32 sw)
9160 {
9161 BRKTAB *bpl = NULL;
9162 BRKTAB *bp = sim_brk_fnd (loc);
9163 int32 i;
9164
9165 if (!bp)
9166 return SCPE_OK;
9167 if (sw == 0)
9168 sw = SIM_BRK_ALLTYP;
9169
9170 #if !defined(__clang_analyzer__)
9171 while (bp) {
9172 if (bp->typ == (bp->typ & sw)) {
9173 FREE (bp->act);
9174 if (bp == sim_brk_tab[sim_brk_ins])
9175 bpl = sim_brk_tab[sim_brk_ins] = bp->next;
9176 else
9177 {
9178 if (bpl)
9179 bpl->next = bp->next;
9180 }
9181 FREE (bp);
9182 bp = bpl;
9183 }
9184 else {
9185 bpl = bp;
9186 bp = bp->next;
9187 }
9188 }
9189 #endif
9190 if (sim_brk_tab[sim_brk_ins] == NULL) {
9191 sim_brk_ent = sim_brk_ent - 1;
9192 for (i = sim_brk_ins; i < sim_brk_ent; i++)
9193 sim_brk_tab[i] = sim_brk_tab[i+1];
9194 }
9195 sim_brk_summ = 0;
9196 for (i = 0; i < sim_brk_ent; i++) {
9197 bp = sim_brk_tab[i];
9198 while (bp) {
9199 sim_brk_summ |= (bp->typ & ~BRK_TYP_TEMP);
9200 bp = bp->next;
9201 }
9202 }
9203 return SCPE_OK;
9204 }
9205
9206
9207
9208 t_stat sim_brk_clrall (int32 sw)
9209 {
9210 int32 i;
9211
9212 if (sw == 0)
9213 sw = SIM_BRK_ALLTYP;
9214 for (i = 0; i < sim_brk_ent;) {
9215 t_addr loc = sim_brk_tab[i]->addr;
9216 sim_brk_clr (loc, sw);
9217 if ((i < sim_brk_ent) &&
9218 (loc == sim_brk_tab[i]->addr))
9219 ++i;
9220 }
9221 return SCPE_OK;
9222 }
9223
9224
9225
9226 t_stat sim_brk_show (FILE *st, t_addr loc, int32 sw)
9227 {
9228 BRKTAB *bp = sim_brk_fnd_ex (loc, sw & (~SWMASK ('C')), FALSE, 0);
9229 DEVICE *dptr;
9230 int32 i, any;
9231
9232 if ((sw == 0) || (sw == SWMASK ('C'))) {
9233 sw = SIM_BRK_ALLTYP | ((sw == SWMASK ('C')) ? SWMASK ('C') : 0); }
9234 if (!bp || (!(bp->typ & sw))) {
9235 return SCPE_OK; }
9236 dptr = sim_dflt_dev;
9237 if (dptr == NULL) {
9238 return SCPE_OK; }
9239 if (sw & SWMASK ('C')) {
9240 if (st != NULL) {
9241 (void)fprintf (st, "SET BREAK "); }
9242 } else {
9243 if (sim_vm_fprint_addr) {
9244 sim_vm_fprint_addr
9245 (st, dptr, loc);
9246 } else {
9247 fprint_val
9248 (st, loc, dptr->aradix, dptr->awidth, PV_LEFT); }
9249 if (st != NULL) {
9250 (void)fprintf (st, ":\t"); }
9251 }
9252 for (i = any = 0; i < 26; i++) {
9253 if ((bp->typ >> i) & 1) {
9254 if ((sw & SWMASK ('C')) == 0) {
9255 if (any) {
9256 if (st != NULL) {
9257 (void)fprintf (st, ", "); } }
9258 if (st != NULL) {
9259 fputc (i + 'A', st); }
9260 }
9261 } else {
9262 if (st != NULL) {
9263 (void)fprintf (st, "-%c", i + 'A'); }
9264 any = 1;
9265 }
9266 }
9267 if (sw & SWMASK ('C')) {
9268 if (st != NULL) {
9269 (void)fprintf (st, " "); }
9270 if (sim_vm_fprint_addr) {
9271 if (st != NULL) {
9272 sim_vm_fprint_addr (st, dptr, loc); }
9273 } else {
9274 fprint_val
9275 (st, loc, dptr->aradix, dptr->awidth, PV_LEFT); }
9276 }
9277 if (bp->cnt > 0) {
9278 if (st != NULL) {
9279 (void)fprintf (st, "[%d]", bp->cnt); } }
9280 if (bp->act != NULL) {
9281 if (st != NULL) {
9282 (void)fprintf (st, "; %s", bp->act); } }
9283 (void)fprintf (st, "\n");
9284 return SCPE_OK;
9285 }
9286
9287
9288
9289 t_stat sim_brk_showall (FILE *st, int32 sw)
9290 {
9291 int32 bit, mask, types;
9292 BRKTAB **bpt;
9293
9294 if ((sw == 0) || (sw == SWMASK ('C')))
9295 sw = SIM_BRK_ALLTYP | ((sw == SWMASK ('C')) ? SWMASK ('C') : 0);
9296 for (types=bit=0; bit <= ('Z'-'A'); bit++)
9297 if (sim_brk_types & (1 << bit))
9298 ++types;
9299 if ((!(sw & SWMASK ('C'))) && sim_brk_types && (types > 1)) {
9300 (void)fprintf (st, "Supported Breakpoint Types:");
9301 for (bit=0; bit <= ('Z'-'A'); bit++)
9302 if (sim_brk_types & (1 << bit))
9303 (void)fprintf (st, " -%c", 'A' + bit);
9304 (void)fprintf (st, "\n");
9305 }
9306 if (((sw & sim_brk_types) != sim_brk_types) && (types > 1)) {
9307 mask = (sw & sim_brk_types);
9308 (void)fprintf (st, "Displaying Breakpoint Types:");
9309 for (bit=0; bit <= ('Z'-'A'); bit++)
9310 if (mask & (1 << bit))
9311 (void)fprintf (st, " -%c", 'A' + bit);
9312 (void)fprintf (st, "\n");
9313 }
9314 for (bpt = sim_brk_tab; bpt < (sim_brk_tab + sim_brk_ent); bpt++) {
9315 BRKTAB *prev = NULL;
9316 BRKTAB *cur = *bpt;
9317 BRKTAB *next;
9318
9319 while (cur) {
9320 next = cur->next;
9321 cur->next = prev;
9322 prev = cur;
9323 cur = next;
9324 }
9325
9326 *bpt = prev;
9327
9328 cur = prev;
9329 while (cur) {
9330 if (cur->typ & sw)
9331 sim_brk_show (st, cur->addr, cur->typ | ((sw & SWMASK ('C')) ? SWMASK ('C') : 0));
9332 cur = cur->next;
9333 }
9334
9335 cur = prev;
9336 prev = NULL;
9337 while (cur) {
9338 next = cur->next;
9339 cur->next = prev;
9340 prev = cur;
9341 cur = next;
9342 }
9343
9344 *bpt = prev;
9345 }
9346 return SCPE_OK;
9347 }
9348
9349
9350
9351 uint32 sim_brk_test (t_addr loc, uint32 btyp)
9352 {
9353 BRKTAB *bp;
9354 uint32 spc = (btyp >> SIM_BKPT_V_SPC) & (SIM_BKPT_N_SPC - 1);
9355
9356 if (sim_brk_summ & BRK_TYP_DYN_ALL)
9357 btyp |= BRK_TYP_DYN_ALL;
9358
9359 if ((bp = sim_brk_fnd_ex (loc, btyp, TRUE, spc))) {
9360 double s_gtime = sim_gtime ();
9361
9362 if (bp->time_fired[spc] == s_gtime)
9363 return 0;
9364 bp->time_fired[spc] = s_gtime;
9365 if (--bp->cnt > 0)
9366 return 0;
9367 bp->cnt = 0;
9368 sim_brk_setact (bp->act);
9369 sim_brk_match_type = btyp & bp->typ;
9370 if (bp->typ & BRK_TYP_TEMP)
9371 sim_brk_clr (loc, bp->typ);
9372 sim_brk_match_addr = loc;
9373 return sim_brk_match_type;
9374 }
9375 return 0;
9376 }
9377
9378
9379
9380 CONST char *sim_brk_getact (char *buf, int32 size)
9381 {
9382 char *ep;
9383 size_t lnt;
9384
9385 if (sim_brk_act[sim_do_depth] == NULL)
9386 return NULL;
9387 while (sim_isspace (*sim_brk_act[sim_do_depth]))
9388 sim_brk_act[sim_do_depth]++;
9389 if (*sim_brk_act[sim_do_depth] == 0) {
9390 return sim_brk_clract ();
9391 }
9392 if ((ep = strchr (sim_brk_act[sim_do_depth], ';'))) {
9393 lnt = ep - sim_brk_act[sim_do_depth];
9394 memcpy (buf, sim_brk_act[sim_do_depth], lnt + 1);
9395 buf[lnt] = 0;
9396 sim_brk_act[sim_do_depth] += lnt + 1;
9397 }
9398 else {
9399 strncpy (buf, sim_brk_act[sim_do_depth], size);
9400 sim_brk_clract ();
9401 }
9402 return buf;
9403 }
9404
9405
9406
9407 char *sim_brk_clract (void)
9408 {
9409 FREE (sim_brk_act_buf[sim_do_depth]);
9410 return sim_brk_act[sim_do_depth] = sim_brk_act_buf[sim_do_depth] = NULL;
9411 }
9412
9413
9414
9415 void sim_brk_setact (const char *action)
9416 {
9417 if (action) {
9418 sim_brk_act_buf[sim_do_depth] = (char *)realloc (sim_brk_act_buf[sim_do_depth], strlen (action) + 1);
9419 if (!sim_brk_act_buf[sim_do_depth])
9420 {
9421 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
9422 __func__, __FILE__, __LINE__);
9423 #if defined(USE_BACKTRACE)
9424 # if defined(SIGUSR2)
9425 (void)raise(SIGUSR2);
9426
9427 # endif
9428 #endif
9429 abort();
9430 }
9431 strcpy (sim_brk_act_buf[sim_do_depth], action);
9432 sim_brk_act[sim_do_depth] = sim_brk_act_buf[sim_do_depth];
9433 }
9434 else
9435 sim_brk_clract ();
9436 }
9437
9438
9439
9440 void sim_brk_npc (uint32 cnt)
9441 {
9442 uint32 spc;
9443 BRKTAB **bpt, *bp;
9444
9445 if ((cnt == 0) || (cnt > SIM_BKPT_N_SPC))
9446 cnt = SIM_BKPT_N_SPC;
9447 for (bpt = sim_brk_tab; bpt < (sim_brk_tab + sim_brk_ent); bpt++) {
9448 for (bp = *bpt; bp; bp = bp->next) {
9449 for (spc = 0; spc < cnt; spc++)
9450 bp->time_fired[spc] = -1.0;
9451 }
9452 }
9453 }
9454
9455
9456
9457 void sim_brk_clrspc (uint32 spc, uint32 btyp)
9458 {
9459 BRKTAB **bpt, *bp;
9460
9461 if (spc < SIM_BKPT_N_SPC) {
9462 for (bpt = sim_brk_tab; bpt < (sim_brk_tab + sim_brk_ent); bpt++) {
9463 for (bp = *bpt; bp; bp = bp->next) {
9464 if (bp->typ & btyp)
9465 bp->time_fired[spc] = -1.0;
9466 }
9467 }
9468 }
9469 }
9470
9471 const char *sim_brk_message(void)
9472 {
9473 static char msg[256];
9474 char addr[65];
9475 char buf[32];
9476
9477 msg[0] = '\0';
9478 if (sim_dflt_dev) {
9479 if (sim_vm_sprint_addr)
9480 sim_vm_sprint_addr (addr, sim_dflt_dev, (t_value)sim_brk_match_addr);
9481 else sprint_val (addr, (t_value)sim_brk_match_addr, sim_dflt_dev->aradix, sim_dflt_dev->awidth, PV_LEFT);
9482 }
9483 if (sim_brk_type_desc) {
9484 BRKTYPTAB *brk = sim_brk_type_desc;
9485
9486 while (2 == strlen (put_switches (buf, sizeof(buf), brk->btyp))) {
9487 if (brk->btyp == sim_brk_match_type) {
9488 (void)sprintf (msg, "%s: %s", brk->desc, addr);
9489 break;
9490 }
9491 brk++;
9492 }
9493 }
9494 if (!msg[0])
9495 (void)sprintf (msg, "%s Breakpoint at: %s\n",
9496 put_switches (buf, sizeof(buf), sim_brk_match_type), addr);
9497
9498 return msg;
9499 }
9500
9501
9502
9503
9504
9505
9506
9507
9508
9509
9510
9511
9512
9513
9514
9515
9516
9517
9518
9519
9520
9521
9522
9523
9524
9525
9526
9527
9528
9529
9530
9531
9532
9533
9534
9535
9536
9537 t_stat sim_set_expect (EXPECT *exp, CONST char *cptr)
9538 {
9539 char gbuf[CBUFSIZE];
9540 CONST char *tptr;
9541 CONST char *c1ptr;
9542 t_bool after_set = FALSE;
9543 uint32 after;
9544 int32 cnt = 0;
9545 t_stat r;
9546
9547 if (exp == NULL)
9548 return sim_messagef (SCPE_ARG, "Null exp!\n");
9549 after = exp->after;
9550
9551 if ((cptr == NULL) || (*cptr == 0))
9552 return SCPE_2FARG;
9553 if (*cptr == '[') {
9554 cnt = (int32) strtotv (cptr + 1, &c1ptr, 10);
9555 if ((cptr == c1ptr) || (*c1ptr != ']'))
9556 return sim_messagef (SCPE_ARG, "Invalid Repeat count specification\n");
9557 cptr = c1ptr + 1;
9558 while (sim_isspace(*cptr))
9559 ++cptr;
9560 }
9561 tptr = get_glyph (cptr, gbuf, ',');
9562 if ((!strncmp(gbuf, "HALTAFTER=", 10)) && (gbuf[10])) {
9563 after = (uint32)get_uint (&gbuf[10], 10, 2000000000, &r);
9564 if (r != SCPE_OK)
9565 return sim_messagef (SCPE_ARG, "Invalid Halt After Value\n");
9566 after_set = TRUE;
9567 cptr = tptr;
9568 }
9569 if ((*cptr != '"') && (*cptr != '\''))
9570 return sim_messagef (SCPE_ARG, "String must be quote delimited\n");
9571 cptr = get_glyph_quoted (cptr, gbuf, 0);
9572
9573 return sim_exp_set (exp, gbuf, cnt, (after_set ? after : exp->after), sim_switches, cptr);
9574 }
9575
9576
9577
9578 t_stat sim_set_noexpect (EXPECT *exp, const char *cptr)
9579 {
9580 char gbuf[CBUFSIZE];
9581
9582 if (NULL == cptr || !*cptr)
9583 return sim_exp_clrall (exp);
9584 if ((*cptr != '"') && (*cptr != '\''))
9585 return sim_messagef (SCPE_ARG, "String must be quote delimited\n");
9586 cptr = get_glyph_quoted (cptr, gbuf, 0);
9587 if (*cptr != '\0')
9588 return SCPE_2MARG;
9589 return sim_exp_clr (exp, gbuf);
9590 }
9591
9592
9593
9594 CONST EXPTAB *sim_exp_fnd (CONST EXPECT *exp, const char *match, size_t start_rule)
9595 {
9596 size_t i;
9597
9598 if (NULL == exp->rules)
9599 return NULL;
9600 for (i=start_rule; i<exp->size; i++)
9601 if (!strcmp (exp->rules[i].match_pattern, match))
9602 return &exp->rules[i];
9603 return NULL;
9604 }
9605
9606
9607
9608 t_stat sim_exp_clr_tab (EXPECT *exp, EXPTAB *ep)
9609 {
9610 size_t i;
9611
9612 if (NULL == ep)
9613 return SCPE_OK;
9614 FREE (ep->match);
9615 FREE (ep->match_pattern);
9616 FREE (ep->act);
9617 exp->size -= 1;
9618 #if !defined(__clang_analyzer__)
9619 for (i=ep-exp->rules; i<exp->size; i++)
9620 exp->rules[i] = exp->rules[i+1];
9621 if (exp->size == 0) {
9622 FREE (exp->rules);
9623 exp->rules = NULL;
9624 }
9625 #endif
9626 return SCPE_OK;
9627 }
9628
9629 t_stat sim_exp_clr (EXPECT *exp, const char *match)
9630 {
9631 EXPTAB *ep = (EXPTAB *)sim_exp_fnd (exp, match, 0);
9632
9633 while (ep) {
9634 sim_exp_clr_tab (exp, ep);
9635 ep = (EXPTAB *)sim_exp_fnd (exp, match, ep - exp->rules);
9636 }
9637 return SCPE_OK;
9638 }
9639
9640
9641
9642 t_stat sim_exp_clrall (EXPECT *exp)
9643 {
9644 int32 i;
9645
9646 for (i=0; i<exp->size; i++) {
9647 FREE (exp->rules[i].match);
9648 FREE (exp->rules[i].match_pattern);
9649 FREE (exp->rules[i].act);
9650 }
9651 FREE (exp->rules);
9652 exp->rules = NULL;
9653 exp->size = 0;
9654 FREE (exp->buf);
9655 exp->buf = NULL;
9656 exp->buf_size = 0;
9657 exp->buf_ins = 0;
9658 return SCPE_OK;
9659 }
9660
9661
9662
9663 t_stat sim_exp_set (EXPECT *exp, const char *match, int32 cnt, uint32 after, int32 switches, const char *act)
9664 {
9665 EXPTAB *ep;
9666 uint8 *match_buf;
9667 uint32 match_size;
9668 size_t i;
9669
9670
9671 match_buf = (uint8 *)calloc (strlen (match) + 1, 1);
9672 if (!match_buf)
9673 return SCPE_MEM;
9674 if (switches & EXP_TYP_REGEX) {
9675 FREE (match_buf);
9676 return sim_messagef (SCPE_ARG, "RegEx support not available\n");
9677 }
9678 else {
9679 if (switches & EXP_TYP_REGEX_I) {
9680 FREE (match_buf);
9681 return sim_messagef (SCPE_ARG, "Case independent matching is only valid for RegEx expect rules\n");
9682 }
9683 sim_data_trace(exp->dptr, exp->dptr->units, (const uint8 *)match, "", strlen(match)+1, "Expect Match String", exp->dbit);
9684 if (SCPE_OK != sim_decode_quoted_string (match, match_buf, &match_size)) {
9685 FREE (match_buf);
9686 return sim_messagef (SCPE_ARG, "Invalid quoted string\n");
9687 }
9688 }
9689 FREE (match_buf);
9690 for (i=0; i<exp->size; i++) {
9691 if ((0 == strcmp (match, exp->rules[i].match_pattern)) &&
9692 (exp->rules[i].switches & EXP_TYP_PERSIST))
9693 return sim_messagef (SCPE_ARG, "Persistent Expect rule with identical match string already exists\n");
9694 }
9695 if (after && exp->size)
9696 return sim_messagef (SCPE_ARG, "Multiple concurrent EXPECT rules aren't valid when a HALTAFTER parameter is non-zero\n");
9697 exp->rules = (EXPTAB *) realloc (exp->rules, sizeof (*exp->rules)*(exp->size + 1));
9698 if (!exp->rules)
9699 {
9700 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
9701 __func__, __FILE__, __LINE__);
9702 #if defined(USE_BACKTRACE)
9703 # if defined(SIGUSR2)
9704 (void)raise(SIGUSR2);
9705
9706 # endif
9707 #endif
9708 abort();
9709 }
9710 ep = &exp->rules[exp->size];
9711 exp->size += 1;
9712 exp->after = after;
9713 (void)memset (ep, 0, sizeof(*ep));
9714 ep->match_pattern = (char *)malloc (strlen (match) + 1);
9715 if (ep->match_pattern)
9716 strcpy (ep->match_pattern, match);
9717 ep->cnt = cnt;
9718 ep->switches = switches;
9719 match_buf = (uint8 *)calloc (strlen (match) + 1, 1);
9720 if ((match_buf == NULL) || (ep->match_pattern == NULL)) {
9721 sim_exp_clr_tab (exp, ep);
9722 FREE (match_buf);
9723 return SCPE_MEM;
9724 }
9725 if (switches & EXP_TYP_REGEX) {
9726 FREE (match_buf);
9727 match_buf = NULL;
9728 }
9729 else {
9730 sim_data_trace(exp->dptr, exp->dptr->units, (const uint8 *)match, "", strlen(match)+1, "Expect Match String", exp->dbit);
9731 sim_decode_quoted_string (match, match_buf, &match_size);
9732 ep->match = match_buf;
9733 ep->size = match_size;
9734 }
9735 ep->match_pattern = (char *)malloc (strlen (match) + 1);
9736 if (!ep->match_pattern)
9737 {
9738 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
9739 __func__, __FILE__, __LINE__);
9740 #if defined(USE_BACKTRACE)
9741 # if defined(SIGUSR2)
9742 (void)raise(SIGUSR2);
9743
9744 # endif
9745 #endif
9746 abort();
9747 }
9748 strcpy (ep->match_pattern, match);
9749 if (ep->act) {
9750 FREE (ep->act);
9751 ep->act = NULL;
9752 }
9753 if (act) while (sim_isspace(*act)) ++act;
9754 if ((act != NULL) && (*act != 0)) {
9755 char *newp = (char *) calloc (strlen (act)+1, sizeof (*act));
9756 if (newp == NULL)
9757 return SCPE_MEM;
9758 strcpy (newp, act);
9759 ep->act = newp;
9760 }
9761
9762 for (i=0; i<exp->size; i++) {
9763 size_t compare_size = (exp->rules[i].switches & EXP_TYP_REGEX) ? MAX(10 * strlen(ep->match_pattern), 1024) : exp->rules[i].size;
9764 if (compare_size >= exp->buf_size) {
9765 exp->buf = (uint8 *)realloc (exp->buf, compare_size + 2);
9766 exp->buf_size = compare_size + 1;
9767 }
9768 }
9769 return SCPE_OK;
9770 }
9771
9772
9773
9774 t_stat sim_exp_show_tab (FILE *st, const EXPECT *exp, const EXPTAB *ep)
9775 {
9776 if (!ep)
9777 return SCPE_OK;
9778 (void)fprintf (st, "EXPECT");
9779 if (ep->switches & EXP_TYP_PERSIST)
9780 (void)fprintf (st, " -p");
9781 if (ep->switches & EXP_TYP_CLEARALL)
9782 (void)fprintf (st, " -c");
9783 if (ep->switches & EXP_TYP_REGEX)
9784 (void)fprintf (st, " -r");
9785 if (ep->switches & EXP_TYP_REGEX_I)
9786 (void)fprintf (st, " -i");
9787 (void)fprintf (st, " %s", ep->match_pattern);
9788 if (ep->cnt > 0)
9789 (void)fprintf (st, " [%d]", ep->cnt);
9790 if (ep->act)
9791 (void)fprintf (st, " %s", ep->act);
9792 (void)fprintf (st, "\n");
9793 return SCPE_OK;
9794 }
9795
9796 t_stat sim_exp_show (FILE *st, CONST EXPECT *exp, const char *match)
9797 {
9798 CONST EXPTAB *ep = (CONST EXPTAB *)sim_exp_fnd (exp, match, 0);
9799
9800 if (exp->buf_size) {
9801 char *bstr = sim_encode_quoted_string (exp->buf, exp->buf_ins);
9802
9803 (void)fprintf (st, "Match Buffer Size: %lld\n",
9804 (long long)exp->buf_size);
9805 (void)fprintf (st, "Buffer Insert Offset: %lld\n",
9806 (long long)exp->buf_ins);
9807 (void)fprintf (st, "Buffer Contents: %s\n",
9808 bstr);
9809 FREE (bstr);
9810 }
9811 if (exp->after)
9812 (void)fprintf (st, "Halt After: %lld instructions\n",
9813 (long long)exp->after);
9814 if (exp->dptr && exp->dbit)
9815 (void)fprintf (st, "Debugging via: SET %s DEBUG%s%s\n",
9816 sim_dname(exp->dptr), exp->dptr->debflags ? "=" : "",
9817 exp->dptr->debflags ? get_dbg_verb (exp->dbit, exp->dptr) : "");
9818 (void)fprintf (st, "Match Rules:\n");
9819 if (!*match)
9820 return sim_exp_showall (st, exp);
9821 if (!ep) {
9822 (void)fprintf (st, "No Rules match '%s'\n", match);
9823 return SCPE_ARG;
9824 }
9825 do {
9826 sim_exp_show_tab (st, exp, ep);
9827 ep = (CONST EXPTAB *)sim_exp_fnd (exp, match, 1 + (ep - exp->rules));
9828 } while (ep);
9829 return SCPE_OK;
9830 }
9831
9832
9833
9834 t_stat sim_exp_showall (FILE *st, const EXPECT *exp)
9835 {
9836 size_t i;
9837
9838 for (i=0; i < exp->size; i++)
9839 sim_exp_show_tab (st, exp, &exp->rules[i]);
9840 return SCPE_OK;
9841 }
9842
9843
9844
9845 t_stat sim_exp_check (EXPECT *exp, uint8 data)
9846 {
9847 size_t i;
9848 EXPTAB *ep = NULL;
9849 char *tstr = NULL;
9850 #if defined(TESTING)
9851 cpu_state_t * cpup = _cpup;
9852 #endif
9853
9854 if ((!exp) || (!exp->rules))
9855 return SCPE_OK;
9856
9857 exp->buf[exp->buf_ins++] = data;
9858 exp->buf[exp->buf_ins] = '\0';
9859
9860 for (i=0; i < exp->size; i++) {
9861 ep = &exp->rules[i];
9862 if (ep == NULL)
9863 break;
9864 if (ep->switches & EXP_TYP_REGEX) {
9865 }
9866 else {
9867 if (exp->buf_ins < ep->size) {
9868
9869
9870
9871
9872 if (exp->buf_ins > 0) {
9873 if (sim_deb && exp->dptr && (exp->dptr->dctrl & exp->dbit)) {
9874 char *estr = sim_encode_quoted_string (exp->buf, exp->buf_ins);
9875 char *mstr = sim_encode_quoted_string (&ep->match[ep->size-exp->buf_ins], exp->buf_ins);
9876
9877 sim_debug (exp->dbit, exp->dptr, "Checking String[0:%lld]: %s\n",
9878 (long long)exp->buf_ins, estr);
9879 sim_debug (exp->dbit, exp->dptr, "Against Match Data: %s\n", mstr);
9880 FREE (estr);
9881 FREE (mstr);
9882 }
9883 if (memcmp (exp->buf, &ep->match[ep->size-exp->buf_ins], exp->buf_ins))
9884 continue;
9885 }
9886 if (sim_deb && exp->dptr && (exp->dptr->dctrl & exp->dbit)) {
9887 char *estr = sim_encode_quoted_string (&exp->buf[exp->buf_size-(ep->size-exp->buf_ins)], ep->size-exp->buf_ins);
9888 char *mstr = sim_encode_quoted_string (ep->match, ep->size-exp->buf_ins);
9889
9890 sim_debug (exp->dbit, exp->dptr, "Checking String[%lld:%lld]: %s\n",
9891 (long long)exp->buf_size-(ep->size-exp->buf_ins),
9892 (long long)ep->size-exp->buf_ins, estr);
9893 sim_debug (exp->dbit, exp->dptr, "Against Match Data: %s\n", mstr);
9894 FREE (estr);
9895 FREE (mstr);
9896 }
9897 if (memcmp (&exp->buf[exp->buf_size-(ep->size-exp->buf_ins)], ep->match, ep->size-exp->buf_ins))
9898 continue;
9899 break;
9900 }
9901 else {
9902 if (sim_deb && exp->dptr && (exp->dptr->dctrl & exp->dbit)) {
9903 char *estr = sim_encode_quoted_string (&exp->buf[exp->buf_ins-ep->size], ep->size);
9904 char *mstr = sim_encode_quoted_string (ep->match, ep->size);
9905
9906 sim_debug (exp->dbit, exp->dptr, "Checking String[%lld:%lld]: %s\n",
9907 (long long)exp->buf_ins-ep->size,
9908 (long long)ep->size, estr);
9909 sim_debug (exp->dbit, exp->dptr, "Against Match Data: %s\n", mstr);
9910 FREE (estr);
9911 FREE (mstr);
9912 }
9913 if (memcmp (&exp->buf[exp->buf_ins-ep->size], ep->match, ep->size))
9914 continue;
9915 break;
9916 }
9917 }
9918 }
9919 if (exp->buf_ins == exp->buf_size) {
9920 exp->buf_ins = 0;
9921 sim_debug (exp->dbit, exp->dptr, "Buffer wrapping\n");
9922 }
9923 if ((ep != NULL) && (i != exp->size)) {
9924 sim_debug (exp->dbit, exp->dptr, "Matched expect pattern!\n");
9925 if (ep->cnt > 0) {
9926 ep->cnt -= 1;
9927 sim_debug (exp->dbit, exp->dptr, "Waiting for %lld more match%s before stopping\n",
9928 (long long)ep->cnt, (ep->cnt == 1) ? "" : "es");
9929 }
9930 else {
9931 uint32 after = exp->after;
9932 int32 switches = ep->switches;
9933 if (ep->act && *ep->act) {
9934 sim_debug (exp->dbit, exp->dptr, "Initiating actions: %s\n", ep->act);
9935 }
9936 else {
9937 sim_debug (exp->dbit, exp->dptr, "No actions specified, stopping...\n");
9938 }
9939 sim_brk_setact (ep->act);
9940 if (ep->switches & EXP_TYP_CLEARALL)
9941 sim_exp_clrall (exp);
9942 else {
9943 if (!(ep->switches & EXP_TYP_PERSIST))
9944 sim_exp_clr_tab (exp, ep);
9945 }
9946 sim_activate (&sim_expect_unit,
9947 (switches & EXP_TYP_TIME) ?
9948 (uint32)((sim_timer_inst_per_sec ()*exp->after)/1000000.0) :
9949 after);
9950 }
9951
9952 exp->buf_ins = 0;
9953 }
9954 if (tstr)
9955 FREE (tstr);
9956 return SCPE_OK;
9957 }
9958
9959
9960
9961 t_stat sim_send_input (SEND *snd, uint8 *data, size_t size, uint32 after, uint32 delay)
9962 {
9963 if (snd->extoff != 0) {
9964 if (snd->insoff > snd->extoff)
9965 memmove(snd->buffer, snd->buffer+snd->extoff, snd->insoff-snd->extoff);
9966 snd->insoff -= snd->extoff;
9967 snd->extoff = 0;
9968 }
9969 if (snd->insoff+size > snd->bufsize) {
9970 snd->bufsize = snd->insoff+size;
9971 snd->buffer = (uint8 *)realloc(snd->buffer, snd->bufsize);
9972 if (!snd->buffer)
9973 {
9974 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
9975 __func__, __FILE__, __LINE__);
9976 #if defined(USE_BACKTRACE)
9977 # if defined(SIGUSR2)
9978 (void)raise(SIGUSR2);
9979
9980 # endif
9981 #endif
9982 abort();
9983 }
9984 }
9985 memcpy(snd->buffer+snd->insoff, data, size);
9986 snd->insoff += size;
9987 if (delay)
9988 snd->delay = (sim_switches & SWMASK ('T')) ? (uint32)((sim_timer_inst_per_sec()*delay)/1000000.0) : delay;
9989 if (after)
9990 snd->after = (sim_switches & SWMASK ('T')) ? (uint32)((sim_timer_inst_per_sec()*after)/1000000.0) : after;
9991 if (snd->after == 0)
9992 snd->after = snd->delay;
9993 snd->next_time = sim_gtime() + snd->after;
9994 return SCPE_OK;
9995 }
9996
9997
9998 t_stat sim_send_clear (SEND *snd)
9999 {
10000 snd->insoff = 0;
10001 snd->extoff = 0;
10002 return SCPE_OK;
10003 }
10004
10005
10006
10007 t_stat sim_show_send_input (FILE *st, const SEND *snd)
10008 {
10009 if (snd->extoff < snd->insoff) {
10010 (void)fprintf (st, "%lld bytes of pending input Data:\n ",
10011 (long long)snd->insoff-snd->extoff);
10012 fprint_buffer_string (st, snd->buffer+snd->extoff, snd->insoff-snd->extoff);
10013 (void)fprintf (st, "\n");
10014 }
10015 else
10016 (void)fprintf (st, "No Pending Input Data\n");
10017 if ((snd->next_time - sim_gtime()) > 0) {
10018 if ((snd->next_time - sim_gtime()) > (sim_timer_inst_per_sec()/1000000.0))
10019 (void)fprintf (st, "Minimum of %d instructions (%d microseconds) before sending first character\n",
10020 (int)(snd->next_time - sim_gtime()),
10021 (int)((snd->next_time - sim_gtime())/(sim_timer_inst_per_sec()/1000000.0)));
10022 else
10023 (void)fprintf (st, "Minimum of %d instructions before sending first character\n",
10024 (int)(snd->next_time - sim_gtime()));
10025 }
10026 if (snd->delay > (sim_timer_inst_per_sec()/1000000.0))
10027 (void)fprintf (st, "Minimum of %d instructions (%d microseconds) between characters\n",
10028 (int)snd->delay, (int)(snd->delay/(sim_timer_inst_per_sec()/1000000.0)));
10029 else
10030 (void)fprintf (st, "Minimum of %d instructions between characters\n",
10031 (int)snd->delay);
10032 if (snd->dptr && snd->dbit)
10033 (void)fprintf (st, "Debugging via: SET %s DEBUG%s%s\n",
10034 sim_dname(snd->dptr), snd->dptr->debflags ? "=" : "",
10035 snd->dptr->debflags ? get_dbg_verb (snd->dbit, snd->dptr) : "");
10036 return SCPE_OK;
10037 }
10038
10039
10040
10041 t_bool sim_send_poll_data (SEND *snd, t_stat *stat)
10042 {
10043 #if defined(TESTING)
10044 cpu_state_t * cpup = _cpup;
10045 #endif
10046 if ((NULL != snd) && (snd->extoff < snd->insoff)) {
10047 if (sim_gtime() < snd->next_time) {
10048 *stat = SCPE_OK;
10049 sim_debug (snd->dbit, snd->dptr, "Too soon to inject next byte\n");
10050 }
10051 else {
10052 char dstr[8] = "";
10053 *stat = snd->buffer[snd->extoff++] | SCPE_KFLAG;
10054 snd->next_time = sim_gtime() + snd->delay;
10055 if (sim_isgraph(*stat & 0xFF) || ((*stat & 0xFF) == ' '))
10056 (void)sprintf (dstr, " '%c'", *stat & 0xFF);
10057 sim_debug (snd->dbit, snd->dptr, "Byte value: 0x%02X%s injected\n", *stat & 0xFF, dstr);
10058 }
10059 return TRUE;
10060 }
10061 return FALSE;
10062 }
10063
10064
10065
10066 const char *sim_error_text (t_stat stat)
10067 {
10068 static char msgbuf[64];
10069
10070 stat &= ~(SCPE_KFLAG|SCPE_BREAK|SCPE_NOMESSAGE);
10071 if (stat == SCPE_OK)
10072 return "No Error";
10073 if ((stat >= SCPE_BASE) && (stat <= SCPE_MAX_ERR))
10074 return scp_errors[stat-SCPE_BASE].message;
10075 (void)sprintf(msgbuf, "Error %d", stat);
10076 return msgbuf;
10077 }
10078
10079 t_stat sim_string_to_stat (const char *cptr, t_stat *stat)
10080 {
10081 char gbuf[CBUFSIZE];
10082 size_t cond;
10083
10084 *stat = SCPE_ARG;
10085 cptr = get_glyph (cptr, gbuf, 0);
10086 if (0 == memcmp("SCPE_", gbuf, 5))
10087 memmove (gbuf, gbuf + 5, 1 + strlen (gbuf + 5));
10088 for (cond=0; cond < (SCPE_MAX_ERR-SCPE_BASE); cond++)
10089 if (0 == strcmp(scp_errors[cond].code, gbuf)) {
10090 cond += SCPE_BASE;
10091 break;
10092 }
10093 if (0 == strcmp(gbuf, "OK"))
10094 cond = SCPE_OK;
10095 if (cond == (SCPE_MAX_ERR-SCPE_BASE)) {
10096 unsigned long numeric_cond = strtol(gbuf, NULL, 0);
10097 if (0 == numeric_cond)
10098 return SCPE_ARG;
10099 cond = (t_stat) numeric_cond;
10100 }
10101 if (cond > SCPE_MAX_ERR)
10102 return SCPE_ARG;
10103 *stat = cond;
10104 return SCPE_OK;
10105 }
10106
10107
10108
10109 const char* debug_bstates = "01_^";
10110 char debug_line_prefix[256];
10111 int32 debug_unterm = 0;
10112
10113
10114
10115 static const char *get_dbg_verb (uint32 dbits, DEVICE* dptr)
10116 {
10117 static const char *debtab_none = "DEBTAB_ISNULL";
10118 static const char *debtab_nomatch = "DEBTAB_NOMATCH";
10119 const char *some_match = NULL;
10120 int32 offset = 0;
10121
10122 if (dptr->debflags == 0)
10123 return debtab_none;
10124
10125 dbits &= dptr->dctrl;
10126
10127
10128
10129 while ((offset < 32) && dptr->debflags[offset].name) {
10130 if (dptr->debflags[offset].mask == dbits)
10131 return dptr->debflags[offset].name;
10132 if (dptr->debflags[offset].mask & dbits)
10133 some_match = dptr->debflags[offset].name;
10134 offset++;
10135 }
10136 return some_match ? some_match : debtab_nomatch;
10137 }
10138
10139
10140
10141 static const char *sim_debug_prefix (uint32 dbits, DEVICE* dptr)
10142 {
10143 const char* debug_type = get_dbg_verb (dbits, dptr);
10144 char tim_t[32] = "";
10145 char tim_a[32] = "";
10146 char pc_s[64] = "";
10147 struct timespec time_now;
10148
10149 if (sim_deb_switches & (SWMASK ('T') | SWMASK ('R') | SWMASK ('A'))) {
10150 clock_gettime(CLOCK_REALTIME, &time_now);
10151 if (sim_deb_switches & SWMASK ('R'))
10152 sim_timespec_diff (&time_now, &time_now, &sim_deb_basetime);
10153 if (sim_deb_switches & SWMASK ('T')) {
10154 time_t tnow = (time_t)time_now.tv_sec;
10155 struct tm *now = gmtime(&tnow);
10156 (void)sprintf(tim_t, "%02d:%02d:%02d.%03ld ",
10157 (int)now->tm_hour,
10158 (int)now->tm_min,
10159 (int)now->tm_sec,
10160 (long)(time_now.tv_nsec / 1000000));
10161 }
10162 if (sim_deb_switches & SWMASK ('A')) {
10163 (void)sprintf(tim_t, "%d.%03ld ",
10164 (int)(time_now.tv_sec),
10165 (long)(time_now.tv_nsec / 1000000));
10166 }
10167 }
10168 if (sim_deb_switches & SWMASK ('P')) {
10169 t_value val;
10170
10171 if (sim_vm_pc_value)
10172 val = (*sim_vm_pc_value)();
10173 else
10174 val = get_rval (sim_PC, 0);
10175 (void)sprintf(pc_s, "-%s:", sim_PC->name);
10176 sprint_val (&pc_s[strlen(pc_s)], val, sim_PC->radix, sim_PC->width, sim_PC->flags & REG_FMT);
10177 }
10178 (void)sprintf(debug_line_prefix, "DBG(%s%s%.0f%s)%s> %s %s: ",
10179 tim_t, tim_a, sim_gtime(), pc_s,
10180 "", dptr->name, debug_type);
10181 return debug_line_prefix;
10182 }
10183
10184 void fprint_fields (FILE *stream, t_value before, t_value after, BITFIELD* bitdefs)
10185 {
10186 int32 i, fields, offset;
10187 uint32 value, beforevalue, mask;
10188
10189 for (fields=offset=0; bitdefs[fields].name; ++fields) {
10190 if (bitdefs[fields].offset == 0xffffffff)
10191 bitdefs[fields].offset = offset;
10192 offset += bitdefs[fields].width;
10193 }
10194 for (i = fields-1; i >= 0; i--) {
10195 if (bitdefs[i].name[0] == '\0')
10196 continue;
10197 if ((bitdefs[i].width == 1) && (bitdefs[i].valuenames == NULL)) {
10198 int off = ((after >> bitdefs[i].offset) & 1) + (((before ^ after) >> bitdefs[i].offset) & 1) * 2;
10199 (void)Fprintf(stream, "%s%c ", bitdefs[i].name, debug_bstates[off]);
10200 }
10201 else {
10202 const char *delta = "";
10203 mask = 0xFFFFFFFF >> (32-bitdefs[i].width);
10204 value = (uint32)((after >> bitdefs[i].offset) & mask);
10205 beforevalue = (uint32)((before >> bitdefs[i].offset) & mask);
10206 if (value < beforevalue)
10207 delta = "_";
10208 if (value > beforevalue)
10209 delta = "^";
10210 if (bitdefs[i].valuenames)
10211 (void)Fprintf(stream, "%s=%s%s ", bitdefs[i].name, delta, bitdefs[i].valuenames[value]);
10212 else
10213 if (bitdefs[i].format) {
10214 (void)Fprintf(stream, "%s=%s", bitdefs[i].name, delta);
10215 (void)Fprintf(stream, bitdefs[i].format, value);
10216 (void)Fprintf(stream, " ");
10217 }
10218 else
10219 (void)Fprintf(stream, "%s=%s0x%X ", bitdefs[i].name, delta, value);
10220 }
10221 }
10222 }
10223
10224
10225
10226
10227
10228 void sim_debug_bits_hdr(uint32 dbits, DEVICE* dptr, const char *header,
10229 BITFIELD* bitdefs, uint32 before, uint32 after, int terminate)
10230 {
10231 if (sim_deb && dptr && (dptr->dctrl & dbits)) {
10232 if (!debug_unterm)
10233 (void)fprintf(sim_deb, "%s", sim_debug_prefix(dbits, dptr));
10234 if (header)
10235 (void)fprintf(sim_deb, "%s: ", header);
10236 fprint_fields (sim_deb, (t_value)before, (t_value)after, bitdefs);
10237 if (terminate)
10238 (void)fprintf(sim_deb, "\r\n");
10239 debug_unterm = terminate ? 0 : 1;
10240 }
10241 }
10242 void sim_debug_bits(uint32 dbits, DEVICE* dptr, BITFIELD* bitdefs,
10243 uint32 before, uint32 after, int terminate)
10244 {
10245 sim_debug_bits_hdr(dbits, dptr, NULL, bitdefs, before, after, terminate);
10246 }
10247
10248
10249 void sim_printf (const char* fmt, ...)
10250 {
10251 char stackbuf[STACKBUFSIZE];
10252 int32 bufsize = sizeof(stackbuf);
10253 char *buf = stackbuf;
10254 int32 len;
10255 va_list arglist;
10256
10257 while (1) {
10258 va_start (arglist, fmt);
10259 len = vsnprintf (buf, bufsize-1, fmt, arglist);
10260 va_end (arglist);
10261
10262
10263
10264 if ((len < 0) || (len >= bufsize-1)) {
10265 if (buf != stackbuf)
10266 FREE (buf);
10267 bufsize = bufsize * 2;
10268 if (bufsize < len + 2)
10269 bufsize = len + 2;
10270 buf = (char *) malloc (bufsize);
10271 if (buf == NULL)
10272 return;
10273 buf[bufsize-1] = '\0';
10274 continue;
10275 }
10276 break;
10277 }
10278
10279 if (sim_is_running) {
10280 char *c, *remnant = buf;
10281 while ((c = strchr(remnant, '\n'))) {
10282 if ((c != buf) && (*(c - 1) != '\r'))
10283 (void)printf("%.*s\r\n", (int)(c-remnant), remnant);
10284 else
10285 (void)printf("%.*s\n", (int)(c-remnant), remnant);
10286 remnant = c + 1;
10287 }
10288 (void)printf("%s", remnant);
10289 }
10290 else
10291 (void)printf("%s", buf);
10292 if (sim_log && (sim_log != stdout))
10293 (void)fprintf (sim_log, "%s", buf);
10294 if (sim_deb && (sim_deb != stdout) && (sim_deb != sim_log))
10295 (void)fprintf (sim_deb, "%s", buf);
10296
10297 if (buf != stackbuf)
10298 FREE (buf);
10299 }
10300
10301
10302 t_stat sim_messagef (t_stat stat, const char* fmt, ...)
10303 {
10304 char stackbuf[STACKBUFSIZE];
10305 size_t bufsize = sizeof(stackbuf);
10306 char *buf = stackbuf;
10307 size_t len;
10308 va_list arglist;
10309 t_bool inhibit_message = (!sim_show_message || (stat & SCPE_NOMESSAGE));
10310
10311 while (1) {
10312 va_start (arglist, fmt);
10313 len = vsnprintf (buf, bufsize-1, fmt, arglist);
10314 va_end (arglist);
10315
10316
10317
10318 if (len >= bufsize - 1) {
10319 if (buf != stackbuf)
10320 FREE (buf);
10321 bufsize = bufsize * 2;
10322 if (bufsize < len + 2)
10323 bufsize = len + 2;
10324 buf = (char *) malloc (bufsize);
10325 if (buf == NULL)
10326 return SCPE_MEM;
10327 buf[bufsize-1] = '\0';
10328 continue;
10329 }
10330 break;
10331 }
10332
10333 if (sim_do_ocptr[sim_do_depth]) {
10334 if (!sim_do_echo && !sim_quiet && !inhibit_message)
10335 sim_printf("%s> %s\n", do_position(), sim_do_ocptr[sim_do_depth]);
10336 else {
10337 if (sim_deb)
10338 (void)fprintf (sim_deb, "%s> %s\n", do_position(), sim_do_ocptr[sim_do_depth]);
10339 }
10340 }
10341 if (sim_is_running && !inhibit_message) {
10342 char *c, *remnant = buf;
10343 while ((c = strchr(remnant, '\n'))) {
10344 if ((c != buf) && (*(c - 1) != '\r'))
10345 (void)printf("%.*s\r\n", (int)(c-remnant), remnant);
10346 else
10347 (void)printf("%.*s\n", (int)(c-remnant), remnant);
10348 remnant = c + 1;
10349 }
10350 (void)printf("%s", remnant);
10351 }
10352 else {
10353 if (!inhibit_message)
10354 (void)printf("%s", buf);
10355 }
10356 if (sim_log && (sim_log != stdout) && !inhibit_message)
10357 (void)fprintf (sim_log, "%s", buf);
10358 if (sim_deb && (((sim_deb != stdout) && (sim_deb != sim_log)) || inhibit_message))
10359 (void)fprintf (sim_deb, "%s", buf);
10360
10361 if (buf != stackbuf)
10362 FREE (buf);
10363 return stat | SCPE_NOMESSAGE;
10364 }
10365
10366
10367
10368
10369
10370
10371
10372
10373
10374 void _sim_debug (uint32 dbits, DEVICE* vdptr, const char* fmt, ...)
10375 {
10376 DEVICE *dptr = (DEVICE *)vdptr;
10377 if (sim_deb && dptr && (dbits == 0 || (dptr->dctrl & dbits))) {
10378 char stackbuf[STACKBUFSIZE];
10379 int32 bufsize = sizeof(stackbuf);
10380 char *buf = stackbuf;
10381 va_list arglist;
10382 int32 i, j, len;
10383 const char* debug_prefix = sim_debug_prefix(dbits, dptr);
10384
10385 buf[bufsize-1] = '\0';
10386 while (1) {
10387 va_start (arglist, fmt);
10388 len = vsnprintf (buf, bufsize-1, fmt, arglist);
10389 va_end (arglist);
10390
10391
10392
10393 if ((len < 0) || (len >= bufsize-1)) {
10394 if (buf != stackbuf)
10395 FREE (buf);
10396 bufsize = bufsize * 2;
10397 if (bufsize < len + 2)
10398 bufsize = len + 2;
10399 buf = (char *) malloc (bufsize);
10400 if (buf == NULL)
10401 return;
10402 buf[bufsize-1] = '\0';
10403 continue;
10404 }
10405 break;
10406 }
10407
10408
10409
10410 for (i = j = 0; i < len; ++i) {
10411 if ('\n' == buf[i]) {
10412 if (i >= j) {
10413 if ((i != j) || (i == 0)) {
10414 if (debug_unterm)
10415 (void)fprintf (sim_deb, "%.*s\r\n", i-j, &buf[j]);
10416 else
10417 (void)fprintf (sim_deb, "%s%.*s\r\n", debug_prefix, i-j, &buf[j]);
10418 }
10419 debug_unterm = 0;
10420 }
10421 j = i + 1;
10422 }
10423 }
10424 if (i > j) {
10425 if (debug_unterm)
10426 (void)fprintf (sim_deb, "%.*s", i-j, &buf[j]);
10427 else
10428 (void)fprintf (sim_deb, "%s%.*s", debug_prefix, i-j, &buf[j]);
10429 }
10430
10431
10432
10433 debug_unterm = len ? (((buf[len-1]=='\n')) ? 0 : 1) : debug_unterm;
10434 if (buf != stackbuf)
10435 FREE (buf);
10436 }
10437 return;
10438 }
10439
10440 void sim_data_trace(DEVICE *dptr, UNIT *uptr, const uint8 *data, const char *position, size_t len, const char *txt, uint32 reason)
10441 {
10442 #if defined(TESTING)
10443 cpu_state_t * cpup = _cpup;
10444 #endif
10445 if (sim_deb && (dptr->dctrl & reason)) {
10446 sim_debug (reason, dptr, "%s %s %slen: %08X\n", sim_uname(uptr), txt, position, (unsigned int)len);
10447 if (data && len) {
10448 size_t i, same, group, sidx, oidx, ridx, eidx, soff;
10449 char outbuf[80], strbuf[28], rad50buf[36], ebcdicbuf[32];
10450 static char hex[] = "0123456789ABCDEF";
10451 static char rad50[] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ$._0123456789";
10452 static unsigned char ebcdic2ascii[] = {
10453 0000, 0001, 0002, 0003, 0234, 0011, 0206, 0177,
10454 0227, 0215, 0216, 0013, 0014, 0015, 0016, 0017,
10455 0020, 0021, 0022, 0023, 0235, 0205, 0010, 0207,
10456 0030, 0031, 0222, 0217, 0034, 0035, 0036, 0037,
10457 0200, 0201, 0202, 0203, 0204, 0012, 0027, 0033,
10458 0210, 0211, 0212, 0213, 0214, 0005, 0006, 0007,
10459 0220, 0221, 0026, 0223, 0224, 0225, 0226, 0004,
10460 0230, 0231, 0232, 0233, 0024, 0025, 0236, 0032,
10461 0040, 0240, 0241, 0242, 0243, 0244, 0245, 0246,
10462 0247, 0250, 0133, 0056, 0074, 0050, 0053, 0041,
10463 0046, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
10464 0260, 0261, 0135, 0044, 0052, 0051, 0073, 0136,
10465 0055, 0057, 0262, 0263, 0264, 0265, 0266, 0267,
10466 0270, 0271, 0174, 0054, 0045, 0137, 0076, 0077,
10467 0272, 0273, 0274, 0275, 0276, 0277, 0300, 0301,
10468 0302, 0140, 0072, 0043, 0100, 0047, 0075, 0042,
10469 0303, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
10470 0150, 0151, 0304, 0305, 0306, 0307, 0310, 0311,
10471 0312, 0152, 0153, 0154, 0155, 0156, 0157, 0160,
10472 0161, 0162, 0313, 0314, 0315, 0316, 0317, 0320,
10473 0321, 0176, 0163, 0164, 0165, 0166, 0167, 0170,
10474 0171, 0172, 0322, 0323, 0324, 0325, 0326, 0327,
10475 0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
10476 0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
10477 0173, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
10478 0110, 0111, 0350, 0351, 0352, 0353, 0354, 0355,
10479 0175, 0112, 0113, 0114, 0115, 0116, 0117, 0120,
10480 0121, 0122, 0356, 0357, 0360, 0361, 0362, 0363,
10481 0134, 0237, 0123, 0124, 0125, 0126, 0127, 0130,
10482 0131, 0132, 0364, 0365, 0366, 0367, 0370, 0371,
10483 0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
10484 0070, 0071, 0372, 0373, 0374, 0375, 0376, 0377,
10485 };
10486
10487 for (i=same=0; i<len; i += 16) {
10488 if ((i > 0) && (0 == memcmp (&data[i], &data[i-16], 16))) {
10489 ++same;
10490 continue;
10491 }
10492 if (same > 0) {
10493 sim_debug (reason, dptr, "%04lx thru %04lx same as above\n",
10494 i - (16*same),
10495 i - 1);
10496 same = 0;
10497 }
10498 group = (((len - i) > 16) ? 16 : (len - i));
10499 strcpy (ebcdicbuf, (sim_deb_switches & SWMASK ('E')) ? " EBCDIC:" : "");
10500 eidx = strlen(ebcdicbuf);
10501 strcpy (rad50buf, (sim_deb_switches & SWMASK ('D')) ? " RAD50:" : "");
10502 ridx = strlen(rad50buf);
10503 strcpy (strbuf, (sim_deb_switches & (SWMASK ('E') | SWMASK ('D'))) ? "ASCII:" : "");
10504 soff = strlen(strbuf);
10505 for (sidx=oidx=0; sidx<group; ++sidx) {
10506 outbuf[oidx++] = ' ';
10507 outbuf[oidx++] = hex[(data[i+sidx]>>4)&0xf];
10508 outbuf[oidx++] = hex[data[i+sidx]&0xf];
10509 if (sim_isprint (data[i+sidx]))
10510 strbuf[soff+sidx] = data[i+sidx];
10511 else
10512 strbuf[soff+sidx] = '.';
10513 if (ridx && ((sidx&1) == 0)) {
10514 uint16 word = data[i+sidx] + (((uint16)data[i+sidx+1]) << 8);
10515
10516 if (word >= 64000) {
10517 rad50buf[ridx++] = '|';
10518 rad50buf[ridx++] = '|';
10519 rad50buf[ridx++] = '|';
10520 }
10521 else {
10522 rad50buf[ridx++] = rad50[word/1600];
10523 rad50buf[ridx++] = rad50[(word/40)%40];
10524 rad50buf[ridx++] = rad50[word%40];
10525 }
10526 }
10527 if (eidx) {
10528 if (sim_isprint (ebcdic2ascii[data[i+sidx]]))
10529 ebcdicbuf[eidx++] = ebcdic2ascii[data[i+sidx]];
10530 else
10531 ebcdicbuf[eidx++] = '.';
10532 }
10533 }
10534 outbuf[oidx] = '\0';
10535 strbuf[soff+sidx] = '\0';
10536 ebcdicbuf[eidx] = '\0';
10537 rad50buf[ridx] = '\0';
10538 sim_debug (reason, dptr, "%04lx%-48s %s%s%s\n", i, outbuf, strbuf, ebcdicbuf, rad50buf);
10539 }
10540 if (same > 0) {
10541 sim_debug (reason, dptr, "%04lx thru %04lx same as above\n", i-(16*same), (long unsigned int)(len-1));
10542 }
10543 }
10544 }
10545 }
10546
10547 int Fprintf (FILE *f, const char* fmt, ...)
10548 {
10549 int ret = 0;
10550 va_list args;
10551
10552 va_start (args, fmt);
10553 ret = vfprintf (f, fmt, args);
10554 va_end (args);
10555 return ret;
10556 }
10557
10558
10559
10560
10561
10562
10563
10564
10565
10566
10567
10568
10569
10570
10571
10572
10573
10574
10575
10576 #define blankch(x) ((x) == ' ' || (x) == '\t')
10577
10578 typedef struct topic {
10579 size_t level;
10580 char *title;
10581 char *label;
10582 struct topic *parent;
10583 struct topic **children;
10584 uint32 kids;
10585 char *text;
10586 size_t len;
10587 uint32 flags;
10588 size_t kidwid;
10589 #define HLP_MAGIC_TOPIC 1
10590 } TOPIC;
10591
10592 static volatile struct {
10593 const char *error;
10594 const char *prox;
10595 size_t block;
10596 size_t line;
10597 } help_where = { "", NULL, 0, 0 };
10598 jmp_buf help_env;
10599
10600 #define FAIL(why,text,here) \
10601 { \
10602 help_where.error = #text; \
10603 help_where.prox = here; \
10604 longjmp ( help_env, (why) ); \
10605 \
10606 }
10607
10608
10609
10610
10611
10612
10613 static void appendText (TOPIC *topic, const char *text, size_t len)
10614 {
10615 char *newt;
10616
10617 if (!len)
10618 return;
10619
10620 newt = (char *)realloc (topic->text, topic->len + len +1);
10621 if (!newt) {
10622 #if !defined(SUNLINT)
10623 FAIL (SCPE_MEM, No memory, NULL);
10624 #endif
10625 }
10626 topic->text = newt;
10627 memcpy (newt + topic->len, text, len);
10628 topic->len +=len;
10629 newt[topic->len] = '\0';
10630 return;
10631 }
10632
10633
10634
10635 static void cleanHelp (TOPIC *topic)
10636 {
10637 TOPIC *child;
10638 size_t i;
10639
10640 FREE (topic->title);
10641 FREE (topic->text);
10642 FREE (topic->label);
10643 for (i = 0; i < topic->kids; i++) {
10644 child = topic->children[i];
10645 cleanHelp (child);
10646 FREE (child);
10647 }
10648 FREE (topic->children);
10649 return;
10650 }
10651
10652
10653
10654
10655 static TOPIC *buildHelp (TOPIC *topic, DEVICE *dptr,
10656 UNIT *uptr, const char *htext, va_list ap)
10657 {
10658 char *end;
10659 size_t n, ilvl;
10660 #define VSMAX 100
10661 char *vstrings[VSMAX];
10662 size_t vsnum = 0;
10663 char * astrings[VSMAX+1];
10664 size_t asnum = 0;
10665 char *const *hblock;
10666 const char *ep;
10667 t_bool excluded = FALSE;
10668
10669
10670
10671
10672
10673
10674
10675 (void)memset (vstrings, 0, sizeof (vstrings));
10676 (void)memset (astrings, 0, sizeof (astrings));
10677 astrings[asnum++] = (char *) htext;
10678
10679 for (hblock = astrings; (htext = *hblock) != NULL; hblock++) {
10680 help_where.block = hblock - astrings;
10681 help_where.line = 0;
10682 while (*htext) {
10683 const char *start;
10684
10685 help_where.line++;
10686 if (sim_isspace (*htext) || *htext == '+') {
10687 if (excluded) {
10688 while (*htext && *htext != '\n')
10689 htext++;
10690 if (*htext)
10691 ++htext;
10692 continue;
10693 }
10694 ilvl = 1;
10695 appendText (topic, " ", 4);
10696 if (*htext == '+') {
10697 while (*htext == '+') {
10698 ilvl++;
10699 appendText (topic, " ", 4);
10700 htext++;
10701 }
10702 }
10703 while (*htext && *htext != '\n' && sim_isspace (*htext))
10704 htext++;
10705 if (!*htext)
10706 break;
10707 start = htext;
10708 while (*htext) {
10709 if (*htext == '%') {
10710 appendText (topic, start, htext - start);
10711 switch (*++htext) {
10712 case 'U':
10713 if (dptr) {
10714 char buf[129];
10715 n = uptr? uptr - dptr->units: 0;
10716 (void)sprintf (buf, "%s%u", dptr->name, (int)n);
10717 appendText (topic, buf, strlen (buf));
10718 }
10719 break;
10720 case 'D':
10721 if (dptr != NULL)
10722 appendText (topic, dptr->name, strlen (dptr->name));
10723 break;
10724 case 'S':
10725 appendText (topic, sim_name, strlen (sim_name));
10726 break;
10727 case '%':
10728 appendText (topic, "%", 1);
10729 break;
10730 case '+':
10731 appendText (topic, "+", 1);
10732 break;
10733 default:
10734 if (sim_isdigit (*htext)) {
10735 n = 0;
10736 while (sim_isdigit (*htext))
10737 n += (n * 10) + (*htext++ - '0');
10738 if (( *htext != 'H' && *htext != 's') ||
10739 n == 0 || n >= VSMAX) {
10740 #if !defined(SUNLINT)
10741 FAIL (SCPE_ARG, Invalid escape, htext);
10742 #endif
10743 }
10744 while (n > vsnum)
10745 vstrings[vsnum++] = va_arg (ap, char *);
10746 start = vstrings[n-1];
10747 if (*htext == 'H') {
10748 if (asnum >= VSMAX) {
10749 #if !defined(SUNLINT)
10750 FAIL (SCPE_ARG, Too many blocks, htext);
10751 #endif
10752 }
10753 astrings[asnum++] = (char *)start;
10754 break;
10755 }
10756 ep = start;
10757 while (*ep) {
10758 if (*ep == '\n') {
10759 ep++;
10760 appendText (topic, start, ep - start);
10761 if (*ep) {
10762 size_t i;
10763 for (i = 0; i < ilvl; i++)
10764 appendText (topic, " ", 4);
10765 }
10766 start = ep;
10767 }
10768 else
10769 ep++;
10770 }
10771 appendText (topic, start, ep-start);
10772 break;
10773 }
10774 #if !defined(SUNLINT)
10775 FAIL (SCPE_ARG, Invalid escape, htext);
10776 #endif
10777 }
10778 start = ++htext;
10779 continue;
10780 }
10781 if (*htext == '\n') {
10782 htext++;
10783 appendText (topic, start, htext - start);
10784 break;
10785 }
10786 htext++;
10787 }
10788 continue;
10789 }
10790 if (sim_isdigit (*htext)) {
10791 TOPIC **children;
10792 TOPIC *newt;
10793 char nbuf[100];
10794
10795 n = 0;
10796 start = htext;
10797 while (sim_isdigit (*htext))
10798 n += (n * 10) + (*htext++ - '0');
10799 if ((htext == start) || !n) {
10800 #if !defined(SUNLINT)
10801 FAIL (SCPE_ARG, Invalid topic heading, htext);
10802 #endif
10803 }
10804 if (n <= topic->level) {
10805 while (n <= topic->level)
10806 topic = topic->parent;
10807 }
10808 else {
10809 if (n > topic->level + 1) {
10810 #if !defined(SUNLINT)
10811 FAIL (SCPE_ARG, Level not contiguous, htext);
10812 #endif
10813 }
10814 }
10815 while (*htext && (*htext != '\n') && sim_isspace (*htext))
10816 htext++;
10817 if (!*htext || (*htext == '\n')) {
10818 #if !defined(SUNLINT)
10819 FAIL (SCPE_ARG, Missing topic name, htext);
10820 #endif
10821 }
10822 start = htext;
10823 while (*htext && (*htext != '\n'))
10824 htext++;
10825 if (start == htext) {
10826 #if !defined(SUNLINT)
10827 FAIL (SCPE_ARG, Null topic name, htext);
10828 #endif
10829 }
10830 excluded = FALSE;
10831 if (*start == '?') {
10832 size_t n = 0;
10833 start++;
10834 while (sim_isdigit (*start))
10835 n += (n * 10) + (*start++ - '0');
10836 if (!*start || *start == '\n'|| n == 0 || n >= VSMAX) {
10837 #if !defined(SUNLINT)
10838 FAIL (SCPE_ARG, Invalid parameter number, start);
10839 #endif
10840 }
10841 while (n > vsnum)
10842 vstrings[vsnum++] = va_arg (ap, char *);
10843 end = vstrings[n-1];
10844 if (!end || !(toupper (*end) == 'T' || *end == '1')) {
10845 excluded = TRUE;
10846 if (*htext)
10847 htext++;
10848 continue;
10849 }
10850 }
10851 newt = (TOPIC *) calloc (sizeof (TOPIC), 1);
10852 if (!newt) {
10853 #if !defined(SUNLINT)
10854 FAIL (SCPE_MEM, No memory, NULL);
10855 #endif
10856 }
10857 newt->title = (char *) malloc ((htext - start)+1);
10858 if (!newt->title) {
10859 FREE (newt);
10860 #if !defined(SUNLINT)
10861 FAIL (SCPE_MEM, No memory, NULL);
10862 #endif
10863 }
10864 memcpy (newt->title, start, htext - start);
10865 newt->title[htext - start] = '\0';
10866 if (*htext)
10867 htext++;
10868
10869 if (newt->title[0] == '$')
10870 newt->flags |= HLP_MAGIC_TOPIC;
10871
10872 children = (TOPIC **) realloc (topic->children,
10873 (topic->kids +1) * sizeof (TOPIC *));
10874 if (NULL == children) {
10875 FREE (newt->title);
10876 FREE (newt);
10877 #if !defined(SUNLINT)
10878 FAIL (SCPE_MEM, No memory, NULL);
10879 #endif
10880 }
10881 topic->children = children;
10882 topic->children[topic->kids++] = newt;
10883 newt->level = n;
10884 newt->parent = topic;
10885 n = strlen (newt->title);
10886 if (n > topic->kidwid)
10887 topic->kidwid = n;
10888 (void)sprintf (nbuf, ".%u", topic->kids);
10889 n = strlen (topic->label) + strlen (nbuf) + 1;
10890 newt->label = (char *) malloc (n);
10891 if (NULL == newt->label) {
10892 FREE (newt->title);
10893 topic->children[topic->kids -1] = NULL;
10894 FREE (newt);
10895 #if !defined(SUNLINT)
10896 FAIL (SCPE_MEM, No memory, NULL);
10897 #endif
10898 }
10899 (void)sprintf (newt->label, "%s%s", topic->label, nbuf);
10900 topic = newt;
10901 continue;
10902 }
10903 if (*htext == ';') {
10904 while (*htext && *htext != '\n')
10905 htext++;
10906 continue;
10907 }
10908 #if !defined(SUNLINT)
10909 FAIL (SCPE_ARG, Unknown line type, htext);
10910 #endif
10911 }
10912 (void)memset (vstrings, 0, VSMAX * sizeof (char *));
10913 vsnum = 0;
10914 }
10915
10916 return topic;
10917 }
10918
10919
10920
10921
10922
10923 static char *helpPrompt ( TOPIC *topic, const char *pstring, t_bool oneword )
10924 {
10925 char *prefix;
10926 char *newp, *newt;
10927
10928 if (topic->level == 0) {
10929 prefix = (char *) calloc (2,1);
10930 if (!prefix) {
10931 #if !defined(SUNLINT)
10932 FAIL (SCPE_MEM, No memory, NULL);
10933 #endif
10934 }
10935 prefix[0] = '\n';
10936 }
10937 else
10938 prefix = helpPrompt (topic->parent, "", oneword);
10939
10940 newp = (char *) malloc (strlen (prefix) + 1 + strlen (topic->title) + 1 +
10941 strlen (pstring) +1);
10942 if (!newp) {
10943 FREE (prefix);
10944 #if !defined(SUNLINT)
10945 FAIL (SCPE_MEM, No memory, NULL);
10946 #endif
10947 }
10948 strcpy (newp, prefix);
10949 if (topic->children) {
10950 if (topic->level != 0)
10951 strcat (newp, " ");
10952 newt = (topic->flags & HLP_MAGIC_TOPIC)?
10953 topic->title+1: topic->title;
10954 if (oneword) {
10955 char *np = newp + strlen (newp);
10956 while (*newt) {
10957 *np++ = blankch (*newt)? '_' : *newt;
10958 newt++;
10959 }
10960 *np = '\0';
10961 }
10962 else
10963 strcat (newp, newt);
10964 if (*pstring && *pstring != '?')
10965 strcat (newp, " ");
10966 }
10967 strcat (newp, pstring);
10968 FREE (prefix);
10969 return newp;
10970 }
10971
10972 static void displayMagicTopic (FILE *st, DEVICE *dptr, TOPIC *topic)
10973 {
10974 char tbuf[CBUFSIZE];
10975 size_t i, skiplines;
10976 #if defined(_WIN32)
10977 FILE *tmp;
10978 char *tmpnam;
10979
10980 do {
10981 int fd;
10982 tmpnam = _tempnam (NULL, "simh");
10983 fd = _open (tmpnam, _O_CREAT | _O_RDWR | _O_EXCL, _S_IREAD | _S_IWRITE);
10984 if (fd != -1) {
10985 tmp = _fdopen (fd, "w+");
10986 break;
10987 }
10988 } while (1);
10989 #else
10990 FILE *tmp = tmpfile();
10991 #endif
10992
10993 if (!tmp) {
10994 (void)fprintf (st, "Unable to create temporary file: %s (Error %d)\n",
10995 xstrerror_l(errno), errno);
10996 return;
10997 }
10998
10999 if (topic->title)
11000 (void)fprintf (st, "%s\n", topic->title+1);
11001
11002 skiplines = 0;
11003 if (topic->title) {
11004 if (!strcmp (topic->title+1, "Registers")) {
11005 fprint_reg_help (tmp, dptr) ;
11006 skiplines = 1;
11007 }
11008 else
11009 if (!strcmp (topic->title+1, "Set commands")) {
11010 fprint_set_help (tmp, dptr);
11011 skiplines = 3;
11012 }
11013 else
11014 if (!strcmp (topic->title+1, "Show commands")) {
11015 fprint_show_help (tmp, dptr);
11016 skiplines = 3;
11017 }
11018 }
11019 rewind (tmp);
11020 if (errno) {
11021 (void)fprintf (st, "rewind: error %d\r\n", errno);
11022 }
11023
11024
11025
11026 for (i =0; i < skiplines; i++)
11027 if (fgets (tbuf, sizeof (tbuf), tmp)) {};
11028
11029 while (fgets (tbuf, sizeof (tbuf), tmp)) {
11030 if (tbuf[0] != '\n')
11031 fputs (" ", st);
11032 fputs (tbuf, st);
11033 }
11034 fclose (tmp);
11035 #if defined(_WIN32)
11036 remove (tmpnam);
11037 FREE (tmpnam);
11038 #endif
11039 return;
11040 }
11041
11042
11043 static t_stat displayFlatHelp (FILE *st, DEVICE *dptr,
11044 UNIT *uptr, int32 flag,
11045 TOPIC *topic, va_list ap )
11046 {
11047 size_t i;
11048
11049 if (topic->flags & HLP_MAGIC_TOPIC) {
11050 (void)fprintf (st, "\n%s ", topic->label);
11051 displayMagicTopic (st, dptr, topic);
11052 }
11053 else
11054 (void)fprintf (st, "\n%s %s\n", topic->label, topic->title);
11055
11056
11057
11058
11059
11060
11061 if (topic->text)
11062 fputs (topic->text, st);
11063
11064 for (i = 0; i < topic->kids; i++)
11065 displayFlatHelp (st, dptr, uptr, flag, topic->children[i], ap);
11066
11067 return SCPE_OK;
11068 }
11069
11070 #define HLP_MATCH_AMBIGUOUS (~0u)
11071 #define HLP_MATCH_WILDCARD (~1U)
11072 #define HLP_MATCH_NONE 0
11073 static size_t matchHelpTopicName (TOPIC *topic, const char *token)
11074 {
11075 size_t i, match;
11076 char cbuf[CBUFSIZE], *cptr;
11077
11078 if (!strcmp (token, "*"))
11079 return HLP_MATCH_WILDCARD;
11080
11081 match = 0;
11082 for (i = 0; i < topic->kids; i++) {
11083 strcpy (cbuf,topic->children[i]->title +
11084 ((topic->children[i]->flags & HLP_MAGIC_TOPIC)? 1 : 0));
11085 cptr = cbuf;
11086 while (*cptr) {
11087 if (blankch (*cptr)) {
11088 *cptr++ = '_';
11089 }
11090 else {
11091 *cptr = (char)toupper (*cptr);
11092 cptr++;
11093 }
11094 }
11095 if (!strcmp (cbuf, token))
11096 return i+1;
11097 if (!strncmp (cbuf, token, strlen (token))) {
11098 if (match)
11099 return HLP_MATCH_AMBIGUOUS;
11100 match = i+1;
11101 }
11102 }
11103 return match;
11104 }
11105
11106
11107
11108 t_stat scp_vhelp (FILE *st, DEVICE *dptr,
11109 UNIT *uptr, int32 flag,
11110 const char *help, const char *cptr, va_list ap)
11111 {
11112 TOPIC top;
11113 TOPIC *topic = ⊤
11114 int failed;
11115 size_t match;
11116 size_t i;
11117 const char *p;
11118 t_bool flat_help = FALSE;
11119 char cbuf [CBUFSIZE], gbuf[CBUFSIZE];
11120
11121 static const char attach_help[] = { " ATTACH" };
11122 static const char brief_help[] = { "%s help. Type <CR> to exit, HELP for navigation help.\n" };
11123 static const char onecmd_help[] = { "%s help.\n" };
11124 static const char help_help[] = {
11125
11126 " To see more HELP information, type the listed subtopic name. To move\n"
11127 " up a level, just type <CR>. To review the current subtopic, type \"?\".\n"
11128 " To view all subtopics, type \"*\". To exit type \"EXIT\", \"^C\", or \"^D\".\n\n"
11129 };
11130
11131 (void)memset (&top, 0, sizeof(top));
11132 top.parent = ⊤
11133 if ((failed = setjmp (help_env)) != 0) {
11134 (void)fprintf (stderr, "\nHELP was unable to process HELP for this device.\n"
11135 "Error in block %u line %u: %s\n"
11136 "%s%*.*s%s\n",
11137 (int)help_where.block, (int)help_where.line, help_where.error,
11138 help_where.prox ? "Near '" : "",
11139 help_where.prox ? 15 : 0, help_where.prox ? 15 : 0,
11140 help_where.prox ? help_where.prox : "",
11141 help_where.prox ? "'" : "");
11142 cleanHelp (&top);
11143 return failed;
11144 }
11145
11146
11147
11148
11149
11150 if (dptr) {
11151 p = dptr->name;
11152 flat_help = (dptr->flags & DEV_FLATHELP) != 0;
11153 }
11154 else
11155 p = sim_name;
11156 top.title = (char *) malloc (strlen (p) + ((flag & SCP_HELP_ATTACH)? sizeof (attach_help)-1: 0) +1);
11157 if (!top.title)
11158 {
11159 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
11160 __func__, __FILE__, __LINE__);
11161 #if defined(USE_BACKTRACE)
11162 # if defined(SIGUSR2)
11163 (void)raise(SIGUSR2);
11164
11165 # endif
11166 #endif
11167 abort();
11168 }
11169 for (i = 0; p[i]; i++ )
11170 top.title[i] = (char)toupper (p[i]);
11171 top.title[i] = '\0';
11172 if (flag & SCP_HELP_ATTACH)
11173 strcpy (top.title+i, attach_help);
11174
11175 top.label = (char *) malloc (sizeof ("1"));
11176 if (!top.label)
11177 {
11178 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
11179 __func__, __FILE__, __LINE__);
11180 #if defined(USE_BACKTRACE)
11181 # if defined(SIGUSR2)
11182 (void)raise(SIGUSR2);
11183
11184 # endif
11185 #endif
11186 abort();
11187 }
11188 strcpy (top.label, "1");
11189
11190 flat_help = flat_help || !sim_ttisatty() || (flag & SCP_HELP_FLAT);
11191
11192 if (flat_help) {
11193 flag |= SCP_HELP_FLAT;
11194 if (sim_ttisatty())
11195 (void)fprintf (st, "%s help.\nThis help is also available in hierarchical form.\n", top.title);
11196 else
11197 (void)fprintf (st, "%s help.\n", top.title);
11198 }
11199 else
11200 (void)fprintf (st, ((flag & SCP_HELP_ONECMD)? onecmd_help: brief_help), top.title);
11201
11202
11203
11204 (void) buildHelp (&top, dptr, uptr, help, ap);
11205
11206
11207
11208 while (cptr && *cptr) {
11209 cptr = get_glyph (cptr, gbuf, 0);
11210 if (!gbuf[0])
11211 break;
11212 if (!strcmp (gbuf, "HELP")) {
11213 (void)fprintf (st, "\n");
11214 fputs (help_help, st);
11215 break;
11216 }
11217 match = matchHelpTopicName (topic, gbuf);
11218 if (match == HLP_MATCH_WILDCARD) {
11219 displayFlatHelp (st, dptr, uptr, flag, topic, ap);
11220 cleanHelp (&top);
11221 return SCPE_OK;
11222 }
11223 if (match == HLP_MATCH_AMBIGUOUS) {
11224 (void)fprintf (st, "\n%s is ambiguous in %s\n", gbuf, topic->title);
11225 break;
11226 }
11227 if (match == HLP_MATCH_NONE) {
11228 (void)fprintf (st, "\n%s is not available in %s\n", gbuf, topic->title);
11229 break;
11230 }
11231 topic = topic->children[match-1];
11232 }
11233 cptr = NULL;
11234
11235 if (flat_help) {
11236 displayFlatHelp (st, dptr, uptr, flag, topic, ap);
11237 cleanHelp (&top);
11238 return SCPE_OK;
11239 }
11240
11241
11242
11243 while (TRUE) {
11244 char *pstring;
11245 const char *prompt[2] = {"? ", "Subtopic? "};
11246
11247
11248
11249 if (topic->flags & HLP_MAGIC_TOPIC) {
11250 fputc ('\n', st);
11251 displayMagicTopic (st, dptr, topic);
11252 }
11253 else
11254 (void)fprintf (st, "\n%s\n", topic->title);
11255
11256
11257
11258
11259
11260 if (topic->text)
11261 fputs (topic->text, st);
11262
11263 if (topic->kids) {
11264 size_t w = 0;
11265 char *p;
11266 char tbuf[CBUFSIZE];
11267
11268 (void)fprintf (st, "\n Additional information available:\n\n");
11269 for (i = 0; i < topic->kids; i++) {
11270 strcpy (tbuf, topic->children[i]->title +
11271 ((topic->children[i]->flags & HLP_MAGIC_TOPIC)? 1 : 0));
11272 for (p = tbuf; *p; p++) {
11273 if (blankch (*p))
11274 *p = '_';
11275 }
11276 w += 4 + topic->kidwid;
11277 if (w > 80) {
11278 w = 4 + topic->kidwid;
11279 fputc ('\n', st);
11280 }
11281 (void)fprintf (st, " %-*s", (int32_t)topic->kidwid, tbuf);
11282 }
11283 (void)fprintf (st, "\n\n");
11284 if (flag & SCP_HELP_ONECMD) {
11285 pstring = helpPrompt (topic, "", TRUE);
11286 (void)fprintf (st, "To view additional topics, type HELP %s topicname\n", pstring+1);
11287 FREE (pstring);
11288 break;
11289 }
11290 }
11291
11292 if (!sim_ttisatty() || (flag & SCP_HELP_ONECMD))
11293 break;
11294
11295 reprompt:
11296 if (NULL == cptr || !*cptr) {
11297 if (topic->kids == 0)
11298 topic = topic->parent;
11299 pstring = helpPrompt (topic, prompt[topic->kids != 0], FALSE);
11300
11301 cptr = read_line_p (pstring+1, cbuf, sizeof (cbuf), stdin);
11302 FREE (pstring);
11303 if ((cptr != NULL) &&
11304 ((0 == strcmp (cptr, "\x04")) ||
11305 (0 == strcmp (cptr, "\x1A"))))
11306 cptr = NULL;
11307 }
11308
11309 if (NULL == cptr)
11310 break;
11311
11312 cptr = get_glyph (cptr, gbuf, 0);
11313 if (!strcmp (gbuf, "*")) {
11314 displayFlatHelp (st, dptr, uptr, flag, topic, ap);
11315 gbuf[0] = '\0';
11316 }
11317 if (!gbuf[0]) {
11318 if (topic->level == 0)
11319 break;
11320 topic = topic->parent;
11321 continue;
11322 }
11323 if (!strcmp (gbuf, "?"))
11324 continue;
11325 if (!strcmp (gbuf, "HELP")) {
11326 fputs (help_help, st);
11327 goto reprompt;
11328 }
11329 if (!strcmp (gbuf, "EXIT") || !strcmp (gbuf, "QUIT"))
11330 break;
11331
11332
11333
11334 if (!topic->kids) {
11335 (void)fprintf (st, "No additional help at this level.\n");
11336 cptr = NULL;
11337 goto reprompt;
11338 }
11339 match = matchHelpTopicName (topic, gbuf);
11340 if (match == HLP_MATCH_AMBIGUOUS) {
11341 (void)fprintf (st, "%s is ambiguous, please type more of the topic name\n", gbuf);
11342 cptr = NULL;
11343 goto reprompt;
11344 }
11345
11346 if (match == HLP_MATCH_NONE) {
11347 (void)fprintf (st, "Help for %s is not available\n", gbuf);
11348 cptr = NULL;
11349 goto reprompt;
11350 }
11351
11352
11353 topic = topic->children[match-1];
11354 }
11355
11356
11357
11358 cleanHelp (&top);
11359
11360 return SCPE_OK;
11361 }
11362
11363
11364
11365 t_stat scp_help (FILE *st, DEVICE *dptr,
11366 UNIT *uptr, int32 flag,
11367 const char *help, const char *cptr, ...)
11368 {
11369 t_stat r;
11370 va_list ap;
11371
11372 va_start (ap, cptr);
11373 r = scp_vhelp (st, dptr, uptr, flag, help, cptr, ap);
11374 va_end (ap);
11375
11376 return r;
11377 }
11378
11379 #if defined(_MSC_VER)
11380 # pragma warning(pop)
11381 #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}