root/src/simh/scp.h

/* [previous][next][first][last][top][bottom][index][help] */

INCLUDED FROM


   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

/* [previous][next][first][last][top][bottom][index][help] */