![[bottom]](../icons/bottom.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[first]](../icons/n_first.png){kind=icon}
![[last]](../icons/n_last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /*
2 * scp.h: simulator control program headers
3 *
4 * vim: filetype=c:tabstop=4:ai:expandtab
5 * SPDX-License-Identifier: MIT
6 * scspell-id: 9166cfe3-f62a-11ec-beb9-80ee73e9b8e7
7 *
8 * ---------------------------------------------------------------------------
9 *
10 * Copyright (c) 1993-2009 Robert M. Supnik
11 * Copyright (c) 2021-2023 Jeffrey H. Johnson
12 * Copyright (c) 2021-2025 The DPS8M Development Team
13 *
14 * Permission is hereby granted, free of charge, to any person obtaining a
15 * copy of this software and associated documentation files (the "Software"),
16 * to deal in the Software without restriction, including without limitation
17 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
18 * and/or sell copies of the Software, and to permit persons to whom the
19 * Software is furnished to do so, subject to the following conditions:
20 *
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 * ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
28 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
29 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 *
32 * Except as contained in this notice, the name of Robert M. Supnik shall not
33 * be used in advertising or otherwise to promote the sale, use or other
34 * dealings in this Software without prior written authorization from
35 * Robert M. Supnik.
36 *
37 * ---------------------------------------------------------------------------
38 */
39
40 #if !defined(SIM_SCP_H_)
41 # define SIM_SCP_H_ 0
42
43 # include <stdbool.h>
44
45 /* run_cmd parameters */
46
47 # define RU_RUN 0 /* run */
48 # define RU_GO 1 /* go */
49 # define RU_STEP 2 /* step */
50 # define RU_NEXT 3 /* step or step/over */
51 # define RU_CONT 4 /* continue */
52 # define RU_BOOT 5 /* boot */
53
54 /* exdep_cmd parameters */
55
56 # define EX_D 0 /* deposit */
57 # define EX_E 1 /* examine */
58 # define EX_I 2 /* interactive */
59
60 /* brk_cmd parameters */
61
62 # define SSH_ST 0 /* set */
63 # define SSH_SH 1 /* show */
64 # define SSH_CL 2 /* clear */
65
66 /* get_sim_opt parameters */
67
68 # define CMD_OPT_SW 001 /* switches */
69 # define CMD_OPT_OF 002 /* output file */
70 # define CMD_OPT_SCH 004 /* search */
71 # define CMD_OPT_DFT 010 /* defaults */
72
73 /* Command processors */
74
75 t_stat reset_cmd (int32 flag, CONST char *ptr);
76 t_stat exdep_cmd (int32 flag, CONST char *ptr);
77 t_stat eval_cmd (int32 flag, CONST char *ptr);
78 t_stat load_cmd (int32 flag, CONST char *ptr);
79 t_stat run_cmd (int32 flag, CONST char *ptr);
80 void run_cmd_message (const char *unechod_cmdline, t_stat r);
81 t_stat attach_cmd (int32 flag, CONST char *ptr);
82 t_stat detach_cmd (int32 flag, CONST char *ptr);
83
84
85
86
87 t_stat exit_cmd (int32 flag, CONST char *ptr);
88 t_stat set_cmd (int32 flag, CONST char *ptr);
89 t_stat show_cmd (int32 flag, CONST char *ptr);
90 t_stat brk_cmd (int32 flag, CONST char *ptr);
91 t_stat do_cmd (int32 flag, CONST char *ptr);
92 t_stat goto_cmd (int32 flag, CONST char *ptr);
93 t_stat return_cmd (int32 flag, CONST char *ptr);
94 t_stat shift_cmd (int32 flag, CONST char *ptr);
95 t_stat call_cmd (int32 flag, CONST char *ptr);
96 t_stat on_cmd (int32 flag, CONST char *ptr);
97 t_stat noop_cmd (int32 flag, CONST char *ptr);
98 t_stat assert_cmd (int32 flag, CONST char *ptr);
99 t_stat send_cmd (int32 flag, CONST char *ptr);
100 t_stat expect_cmd (int32 flag, CONST char *ptr);
101 t_stat help_cmd (int32 flag, CONST char *ptr);
102 t_stat screenshot_cmd (int32 flag, CONST char *ptr);
103 t_stat spawn_cmd (int32 flag, CONST char *ptr);
104 t_stat echo_cmd (int32 flag, CONST char *ptr);
105
106 /* Allow compiler to help validate printf style format arguments */
107 # if !defined (__GNUC__)
108 # define GCC_FMT_ATTR(n, m)
109 # endif
110
111 # if !defined(GCC_FMT_ATTR)
112 # define GCC_FMT_ATTR(n, m) __attribute__ ((format (__printf__, n, m)))
113 # endif
114
115 /* Utility routines */
116 t_stat sim_process_event (void);
117 t_stat sim_activate (UNIT *uptr, int32 interval);
118 t_stat _sim_activate (UNIT *uptr, int32 interval);
119 t_stat sim_activate_abs (UNIT *uptr, int32 interval);
120 t_stat sim_activate_after (UNIT *uptr, uint32 usecs_walltime);
121 t_stat _sim_activate_after (UNIT *uptr, uint32 usecs_walltime);
122 t_stat sim_cancel (UNIT *uptr);
123 t_bool sim_is_active (UNIT *uptr);
124 int32 sim_activate_time (UNIT *uptr);
125 t_stat sim_run_boot_prep (int32 flag);
126 double sim_gtime (void);
127 uint32 sim_grtime (void);
128 int32 sim_qcount (void);
129 t_stat attach_unit (UNIT *uptr, CONST char *cptr);
130 t_stat detach_unit (UNIT *uptr);
131 t_stat assign_device (DEVICE *dptr, const char *cptr);
132 t_stat deassign_device (DEVICE *dptr);
133 t_stat reset_all (uint32 start_device);
134 t_stat reset_all_p (uint32 start_device);
135 const char *sim_dname (DEVICE *dptr);
136 const char *sim_uname (UNIT *dptr);
137 int sim_isspace (char c);
138 int sim_islower (char c);
139 int sim_isalpha (char c);
140 int sim_isprint (char c);
141 int sim_isdigit (char c);
142 int sim_isgraph (char c);
143 int sim_isalnum (char c);
144 CONST char *get_sim_opt (int32 opt, CONST char *cptr, t_stat *st);
145 const char *put_switches (char *buf, size_t bufsize, uint32 sw);
146 CONST char *get_glyph (const char *iptr, char *optr, char mchar);
147 CONST char *get_glyph_nc (const char *iptr, char *optr, char mchar);
148 CONST char *get_glyph_quoted (const char *iptr, char *optr, char mchar);
149 CONST char *get_glyph_cmd (const char *iptr, char *optr);
150 t_value get_uint (const char *cptr, uint32 radix, t_value max, t_stat *status);
151 CONST char *get_range (DEVICE *dptr, CONST char *cptr, t_addr *lo, t_addr *hi,
152 uint32 rdx, t_addr max, char term);
153 t_stat sim_decode_quoted_string (const char *iptr, uint8 *optr, uint32 *osize);
154 char *sim_encode_quoted_string (const uint8 *iptr, size_t size);
155 void fprint_buffer_string (FILE *st, const uint8 *buf, size_t size);
156 t_value strtotv (CONST char *cptr, CONST char **endptr, uint32 radix);
157 int Fprintf (FILE *f, const char *fmt, ...) GCC_FMT_ATTR(2, 3);
158 t_stat fprint_val (FILE *stream, t_value val, uint32 rdx, uint32 wid, uint32 fmt);
159 t_stat sprint_val (char *buf, t_value val, uint32 rdx, size_t wid, uint32 fmt);
160 const char *sim_fmt_secs (double seconds);
161 const char *sprint_capac (DEVICE *dptr, UNIT *uptr);
162 char *read_line (char *cptr, int32 size, FILE *stream);
163 void fprint_reg_help (FILE *st, DEVICE *dptr);
164 void fprint_set_help (FILE *st, DEVICE *dptr);
165 void fprint_show_help (FILE *st, DEVICE *dptr);
166 CTAB *find_cmd (const char *gbuf);
167 DEVICE *find_dev (const char *ptr);
168 DEVICE *find_unit (const char *ptr, UNIT **uptr);
169 DEVICE *find_dev_from_unit (UNIT *uptr);
170 t_stat sim_register_internal_device (DEVICE *dptr);
171 void sim_sub_args (char *in_str, size_t in_str_size, char *do_arg[]);
172 REG *find_reg (CONST char *ptr, CONST char **optr, DEVICE *dptr);
173 CTAB *find_ctab (CTAB *tab, const char *gbuf);
174 C1TAB *find_c1tab (C1TAB *tab, const char *gbuf);
175 SHTAB *find_shtab (SHTAB *tab, const char *gbuf);
176 t_stat get_aval (t_addr addr, DEVICE *dptr, UNIT *uptr);
177 BRKTAB *sim_brk_fnd (t_addr loc);
178 uint32 sim_brk_test (t_addr bloc, uint32 btyp);
179 void sim_brk_clrspc (uint32 spc, uint32 btyp);
180 void sim_brk_npc (uint32 cnt);
181 void sim_brk_setact (const char *action);
182 const char *sim_brk_message(void);
183 t_stat sim_send_input (SEND *snd, uint8 *data, size_t size, uint32 after, uint32 delay);
184 t_stat sim_show_send_input (FILE *st, const SEND *snd);
185 t_bool sim_send_poll_data (SEND *snd, t_stat *stat);
186 t_stat sim_send_clear (SEND *snd);
187 t_stat sim_set_expect (EXPECT *exp, CONST char *cptr);
188 t_stat sim_set_noexpect (EXPECT *exp, const char *cptr);
189 t_stat sim_exp_set (EXPECT *exp, const char *match, int32 cnt, uint32 after, int32 switches, const char *act);
190 t_stat sim_exp_clr (EXPECT *exp, const char *match);
191 t_stat sim_exp_clrall (EXPECT *exp);
192 t_stat sim_exp_show (FILE *st, CONST EXPECT *exp, const char *match);
193 t_stat sim_exp_showall (FILE *st, const EXPECT *exp);
194 t_stat sim_exp_check (EXPECT *exp, uint8 data);
195 t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
196 t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
197 t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr);
198 const char *sim_error_text (t_stat stat);
199 t_stat sim_string_to_stat (const char *cptr, t_stat *cond);
200 void sim_printf (const char *fmt, ...) GCC_FMT_ATTR(1, 2);
201 t_stat sim_messagef (t_stat stat, const char *fmt, ...) GCC_FMT_ATTR(2, 3);
202 void sim_data_trace(DEVICE *dptr, UNIT *uptr, const uint8 *data, const char *position, size_t len, const char *txt, uint32 reason);
203 void sim_debug_bits_hdr (uint32 dbits, DEVICE* dptr, const char *header,
204 BITFIELD* bitdefs, uint32 before, uint32 after, int terminate);
205 void sim_debug_bits (uint32 dbits, DEVICE* dptr, BITFIELD* bitdefs,
206 uint32 before, uint32 after, int terminate);
207 void _sim_debug (uint32 dbits, DEVICE* dptr, const char *fmt, ...) GCC_FMT_ATTR(3, 4);
208 # define sim_debug(dbits, dptr, ...) \
209 do { \
210 if ((sim_deb != NULL) && ((dptr != NULL) && ((dptr)->dctrl & dbits))) \
211 _sim_debug (dbits, dptr, __VA_ARGS__); \
212 } \
213 while (0)
214 void fprint_stopped_gen (FILE *st, t_stat v, REG *pc, DEVICE *dptr);
215 # define SCP_HELP_FLAT (1u << 31) /* Force flat help when prompting is not possible */
216 # define SCP_HELP_ONECMD (1u << 30) /* Display one topic, do not prompt */
217 # define SCP_HELP_ATTACH (1u << 29) /* Top level topic is ATTACH help */
218 t_stat scp_help (FILE *st, DEVICE *dptr,
219 UNIT *uptr, int32 flag, const char *help, const char *cptr, ...);
220 t_stat scp_vhelp (FILE *st, DEVICE *dptr,
221 UNIT *uptr, int32 flag, const char *help, const char *cptr, va_list ap);
222 t_stat scp_helpFromFile (FILE *st, DEVICE *dptr,
223 UNIT *uptr, int32 flag, const char *help, const char *cptr, ...);
224 t_stat scp_vhelpFromFile (FILE *st, DEVICE *dptr,
225 UNIT *uptr, int32 flag, const char *help, const char *cptr, va_list ap);
226
227 /* Global data */
228
229 extern DEVICE *sim_dflt_dev;
230 extern int32 sim_interval;
231 extern int32 sim_switches;
232 extern int32 sim_iglock;
233 extern int32 sim_nolock;
234 extern int32 sim_randompst;
235 extern int32 sim_quiet;
236 extern int32 sim_localopc;
237 extern int32 sim_randstate;
238 extern int32 sim_nostate;
239 extern int32 sim_step;
240 extern t_stat sim_last_cmd_stat; /* Command Status */
241 extern FILE *sim_log; /* log file */
242 extern FILEREF *sim_log_ref; /* log file file reference */
243 extern FILE *sim_deb; /* debug file */
244 extern FILEREF *sim_deb_ref; /* debug file file reference */
245 extern int32 sim_deb_switches; /* debug display flags */
246 extern struct timespec sim_deb_basetime; /* debug base time for relative time output */
247 extern DEVICE **sim_internal_devices;
248 extern uint32 sim_internal_device_count;
249 extern UNIT *sim_clock_queue;
250 extern int32 sim_is_running;
251 extern t_bool sim_processing_event; /* Called from sim_process_event */
252 extern char *sim_prompt; /* prompt string */
253 extern const char *sim_savename; /* Simulator Name used in Save/Restore files */
254 extern t_value *sim_eval;
255 extern volatile int32 stop_cpu;
256 extern uint32 sim_brk_types; /* breakpoint info */
257 extern uint32 sim_brk_dflt;
258 extern uint32 sim_brk_summ;
259 extern uint32 sim_brk_match_type;
260 extern t_addr sim_brk_match_addr;
261 extern BRKTYPTAB *sim_brk_type_desc; /* type descriptions */
262 extern FILE *stdnul;
263 extern t_bool sim_asynch_enabled;
264 extern bool mlock_failure;
265 extern char* sim_appfilename;
266 extern uint64_t sim_free_memory;
267
268 /* VM interface */
269
270 extern const char* appname;
271 extern char sim_name[];
272 extern DEVICE *sim_devices[];
273 extern REG *sim_PC;
274 extern const char *sim_stop_messages[];
275 extern t_stat sim_instr (void);
276 extern int32 sim_emax;
277 extern t_stat fprint_sym (FILE *ofile, t_addr addr, t_value *val,
278 UNIT *uptr, int32 sw);
279 extern t_stat parse_sym (CONST char *cptr, t_addr addr, UNIT *uptr, t_value *val,
280 int32 sw);
281
282 /* The per-simulator init routine is a weak global that defaults to NULL
283 The other per-simulator pointers can be overridden by the init routine */
284
285 extern void (*sim_vm_init) (void);
286 extern char *(*sim_vm_read) (char *ptr, int32 size, FILE *stream);
287 extern void (*sim_vm_post) (t_bool from_scp);
288 extern CTAB *sim_vm_cmd;
289 extern void (*sim_vm_sprint_addr) (char *buf, DEVICE *dptr, t_addr addr);
290 extern void (*sim_vm_fprint_addr) (FILE *st, DEVICE *dptr, t_addr addr);
291 extern t_addr (*sim_vm_parse_addr) (DEVICE *dptr, CONST char *cptr, CONST char **tptr);
292 extern t_bool (*sim_vm_fprint_stopped) (FILE *st, t_stat reason);
293 extern t_value (*sim_vm_pc_value) (void);
294 extern t_bool (*sim_vm_is_subroutine_call) (t_addr **ret_addrs);
295 # if !defined(NO_LOCALE)
296 extern const char *xstrerror_l(int errnum);
297 # else
298 # define xstrerror_l strerror
299 # endif
300
301 # define SIM_FRONTPANEL_VERSION 2
302
303 /**
304
305 sim_panel_start_simulator A starts a simulator with a particular
306 configuration
307
308 sim_path the path to the simulator binary
309 sim_config the configuration to run the simulator with
310 device_panel_count the number of sub panels for connected devices
311
312 Note 1: - The path specified must be either a fully specified path or
313 it could be merely the simulator name if the simulator binary
314 is located in the current PATH.
315 - The simulator binary must be built from the same version
316 simh source code that the front-panel API was acquired from
317 (the API and the simh framework must speak the same language)
318
319 Note 2: - Configuration file specified should contain device setup
320 statements (enable, disable, CPU types and attach commands).
321 It should not start a simulator running.
322
323 */
324
325 typedef struct PANEL PANEL;
326
327 PANEL *
328 sim_panel_start_simulator (const char *sim_path,
329 const char *sim_config,
330 size_t device_panel_count);
331
332 PANEL *
333 sim_panel_start_simulator_debug (const char *sim_path,
334 const char *sim_config,
335 size_t device_panel_count,
336 const char *debug_file);
337
338 /**
339
340 sim_panel_add_device_panel - creates a sub panel associated
341 with a specific simulator panel
342
343 simulator_panel the simulator panel to connect to
344 device_name the simulator's name for the device
345
346 */
347 PANEL *
348 sim_panel_add_device_panel (PANEL *simulator_panel,
349 const char *device_name);
350
351 /**
352
353 sim_panel_destroy to shutdown a panel or sub panel.
354
355 Note: destroying a simulator panel will also destroy any
356 related sub panels
357
358 */
359 int
360 sim_panel_destroy (PANEL *panel);
361
362 /**
363
364 The front-panel API exposes the state of a simulator via access to
365 simh register variables that the simulator and its devices define.
366 These registers certainly include any architecturally described
367 registers (PC, PSL, SP, etc.), but also include anything else
368 the simulator uses as internal state to implement the running
369 simulator.
370
371 The registers that a particular front-panel application might need
372 access to are described by the application by calling:
373
374 sim_panel_add_register
375 sim_panel_add_register_array
376 and
377 sim_panel_add_register_indirect
378
379 name the name the simulator knows this register by
380 device_name the device this register is part of. Defaults to
381 the device of the panel (in a device panel) or the
382 default device in the simulator (usually the CPU).
383 element_count number of elements in the register array
384 size the size (in local storage) of the buffer which will
385 receive the data in the simulator's register
386 addr a pointer to the location of the buffer which will
387 be loaded with the data in the simulator's register
388
389 */
390 int
391 sim_panel_add_register (PANEL *panel,
392 const char *name,
393 const char *device_name,
394 size_t size,
395 void *addr);
396
397 int
398 sim_panel_add_register_array (PANEL *panel,
399 const char *name,
400 const char *device_name,
401 size_t element_count,
402 size_t size,
403 void *addr);
404
405 int
406 sim_panel_add_register_indirect (PANEL *panel,
407 const char *name,
408 const char *device_name,
409 size_t size,
410 void *addr);
411 /**
412
413 A panel application has a choice of two different methods of getting
414 the values contained in the set of registers it has declared interest in via
415 the sim_panel_add_register API.
416
417 1) The values can be polled (when ever it is desired) by calling
418 sim_panel_get_registers().
419 2) The panel can call sim_panel_set_display_callback() to specify a
420 callback routine and a periodic rate that the callback routine
421 should be called. The panel API will make a best effort to deliver
422 the current register state at the desired rate.
423
424 Note 1: The buffers described in a panel's register set will be
425 dynamically revised as soon as data is available from the
426 simulator. The callback routine merely serves as a notification
427 that a complete register set has arrived.
428 Note 2: The callback routine should, in general, not run for a long time
429 or front-panel interactions with the simulator may be disrupted.
430 Setting a flag, signaling an event or posting a message are
431 reasonable activities to perform in a callback routine.
432
433 */
434 int
435 sim_panel_get_registers (PANEL *panel, unsigned long long *simulation_time);
436
437 typedef void (*PANEL_DISPLAY_PCALLBACK)(PANEL *panel,
438 unsigned long long simulation_time,
439 void *context);
440
441 int
442 sim_panel_set_display_callback (PANEL *panel,
443 PANEL_DISPLAY_PCALLBACK callback,
444 void *context,
445 int callbacks_per_second);
446
447 /**
448
449 When a front panel application needs to change the running
450 state of a simulator one of the following routines should
451 be called:
452
453 sim_panel_exec_halt - Stop instruction execution
454 sim_panel_exec_boot - Boot a simulator from a specific device
455 sim_panel_exec_run - Start/Resume a simulator running instructions
456 sim_panel_exec_step - Have a simulator execute a single step
457
458 */
459 int
460 sim_panel_exec_halt (PANEL *panel);
461
462 int
463 sim_panel_exec_boot (PANEL *panel, const char *device);
464
465 int
466 sim_panel_exec_run (PANEL *panel);
467
468 int
469 sim_panel_exec_step (PANEL *panel);
470
471 /**
472
473 When a front panel application wants to describe conditions that
474 should stop instruction execution an execution or an output
475 should be used. To established or clear a breakpoint, one of
476 the following routines should be called:
477
478 sim_panel_break_set - Establish a simulation breakpoint
479 sim_panel_break_clear - Cancel/Delete a previously defined
480 breakpoint
481 sim_panel_break_output_set - Establish a simulator output
482 breakpoint
483 sim_panel_break_output_clear - Cancel/Delete a previously defined
484 output breakpoint
485
486 Note: Any breakpoint switches/flags must be located at the
487 beginning of the condition string
488
489 */
490
491 int
492 sim_panel_break_set (PANEL *panel, const char *condition);
493
494 int
495 sim_panel_break_clear (PANEL *panel, const char *condition);
496
497 int
498 sim_panel_break_output_set (PANEL *panel, const char *condition);
499
500 int
501 sim_panel_break_output_clear (PANEL *panel, const char *condition);
502
503 /**
504
505 When a front panel application needs to change or access
506 memory or a register one of the following routines should
507 be called:
508
509 sim_panel_gen_examine - Examine register or memory
510 sim_panel_gen_deposit - Deposit to register or memory
511 sim_panel_mem_examine - Examine memory location
512 sim_panel_mem_deposit - Deposit to memory location
513 sim_panel_set_register_value - Deposit to a register or memory
514 location
515
516 */
517
518 /**
519
520 sim_panel_gen_examine
521
522 name_or_addr the name the simulator knows this register by
523 size the size (in local storage) of the buffer which will
524 receive the data returned when examining the simulator
525 value a pointer to the buffer which will be loaded with the
526 data returned when examining the simulator
527 */
528
529 int
530 sim_panel_gen_examine (PANEL *panel,
531 const char *name_or_addr,
532 size_t size,
533 void *value);
534 /**
535
536 sim_panel_gen_deposit
537
538 name_or_addr the name the simulator knows this register by
539 size the size (in local storage) of the buffer which
540 contains the data to be deposited into the simulator
541 value a pointer to the buffer which contains the data to
542 be deposited into the simulator
543 */
544
545 int
546 sim_panel_gen_deposit (PANEL *panel,
547 const char *name_or_addr,
548 size_t size,
549 const void *value);
550
551 /**
552
553 sim_panel_mem_examine
554
555 addr_size the size (in local storage) of the buffer which
556 contains the memory address of the data to be examined
557 in the simulator
558 addr a pointer to the buffer containing the memory address
559 of the data to be examined in the simulator
560 value_size the size (in local storage) of the buffer which will
561 receive the data returned when examining the simulator
562 value a pointer to the buffer which will be loaded with the
563 data returned when examining the simulator
564 */
565
566 int
567 sim_panel_mem_examine (PANEL *panel,
568 size_t addr_size,
569 const void *addr,
570 size_t value_size,
571 void *value);
572
573 /**
574
575 sim_panel_mem_deposit
576
577 addr_size the size (in local storage) of the buffer which
578 contains the memory address of the data to be deposited
579 into the simulator
580 addr a pointer to the buffer containing the memory address
581 of the data to be deposited into the simulator
582 value_size the size (in local storage) of the buffer which will
583 contains the data to be deposited into the simulator
584 value a pointer to the buffer which contains the data to be
585 deposited into the simulator
586 */
587
588 int
589 sim_panel_mem_deposit (PANEL *panel,
590 size_t addr_size,
591 const void *addr,
592 size_t value_size,
593 const void *value);
594
595 /**
596 sim_panel_set_register_value
597
598 name the name of a simulator register or a memory address
599 which is to receive a new value
600 value the new value in character string form. The string
601 must be in the native/natural radix that the simulator
602 uses when referencing that register
603
604 */
605 int
606 sim_panel_set_register_value (PANEL *panel,
607 const char *name,
608 const char *value);
609
610 /**
611
612 When a front panel application may needs to change the media
613 in a simulated removable media device one of the following
614 routines should be called:
615
616 sim_panel_mount - mounts the indicated media file on a device
617 sim_panel_dismount - dismounts the currently mounted media file
618 from a device
619
620 */
621
622 /**
623 sim_panel_mount
624
625 device the name of a simulator device/unit
626 switches any switches appropriate for the desire attach
627 path the path on the local system to be attached
628
629 */
630 int
631 sim_panel_mount (PANEL *panel,
632 const char *device,
633 const char *switches,
634 const char *path);
635
636 /**
637 sim_panel_dismount
638
639 device the name of a simulator device/unit
640
641 */
642 int
643 sim_panel_dismount (PANEL *panel,
644 const char *device);
645
646 typedef enum {
647 Halt, /* Simulation is halted (instructions not being executed) */
648 Run, /* Simulation is executing instructions */
649 Error /* Panel simulator is in an error state and should be */
650 /* closed (destroyed). sim_panel_get_error might help */
651 /* explain why */
652 } OperationalState;
653
654 OperationalState
655 sim_panel_get_state (PANEL *panel);
656
657 /**
658
659 All APIs routines which return an int return 0 for
660 success and -1 for an error.
661
662 An API which returns an error (-1), will not change the panel state.
663
664 sim_panel_get_error - the details of the most recent error
665 sim_panel_clear_error - clears the error buffer
666
667 */
668
669 const char *sim_panel_get_error (void);
670 void sim_panel_clear_error (void);
671
672 /**
673
674 The panel<->simulator wire protocol can be traced if protocol problems arise.
675
676 sim_panel_set_debug_file - Specifies the log file to record debug traffic
677 sim_panel_set_debug_mode - Specifies the debug detail to be recorded
678 sim_panel_flush_debug - Flushes debug output to disk
679
680 */
681 void
682 sim_panel_set_debug_file (PANEL *panel, const char *debug_file);
683
684 void
685 sim_panel_set_debug_mode (PANEL *panel, int debug_bits);
686
687 void
688 sim_panel_flush_debug (PANEL *panel);
689
690 #endif
![[top]](../icons/top.png){kind=icon}
![[bottom]](../icons/n_bottom.png){kind=icon}
*/