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