/* begincopyright
  Copyright (c) 1988 Xerox Corporation. All rights reserved.
  Use and copying of this software and preparation of derivative works based
  upon this software are permitted. Any distribution of this software or
  derivative works must comply with all applicable United States export
  control laws. This software is made available AS IS, and Xerox Corporation
  makes no warranty about the software, its performance or its conformity to
  any specification. Any person obtaining a copy of this software is requested
  to send their name and post office or electronic mail address to:
    PCR Coordinator
    Xerox PARC
    3333 Coyote Hill Rd.
    Palo Alto, CA 94304
  endcopyright */

/*
 * CirioNubLocalProcs.h
 *
 * Demers, August 5, 1992 5:36:21 pm PDT
 *
 * CirioNub local procedure descriptions.
 */

#ifndef ←CIRIO←NUB←LOCAL←PROCS←
#define ←CIRIO←NUB←LOCAL←PROCS←

#ifndef ←CIRIO←NUB←TYPES←
#   include "xr/CirioNubTypes.h"
#endif


#define CIRIO←NUB←LOCAL←PROCS←LOW←VERSION	1
#define CIRIO←NUB←LOCAL←PROCS←VERSION		2


extern bool
CirioNubLocalGetIgnoreLockFailure();

extern void
CirioNubLocalSetIgnoreLockFailure(/* bool ignore */);
/*
    TRUE => local procs ignore failure to acquire load state lock and
      forge ahead anyway.
*/



extern unsigned
CirioNubLocalNull(/* unsigned desiredVersion */);
/*
    Return the "best" Cirio nub version number exported by this nub.
*/


extern int
CirioNubLocalGetThread(/* int index, CirioNubThreadData buf */);
/*
    Get data about specified thread.
    Return 0 on success, (-1) on failure (specified thread inactive).
*/


extern int
CirioNubLocalPCtoInfo(/* XR←Pointer pc, CirioNubPCInfo buf */);
/*
    Map absolute pc to info.
    Return 0 on success, (-1) on failure.
*/

/*
 * For the following procs, consult IncrementalLoad.h
 */


extern int
CirioNubLocalGetFileEntry(/* unsigned seqNum, CirioNubFileEntry buf */);
/*
    Get file entry with largest seqNum <= the specified one.
    Return 0 on success, -1 on failure.
*/


extern int
CirioNubLocalGetMatchingSymEntryByName(/*
    unsigned symID,
    char *pattern,
    bool caseSensitive,
    unsigned wantedTypes,
    unsigned ignoredClasses,
    int numToSkip,
    CirioNubSymEntry buf
*/);
/*
    Like XR←ILGetMatchingSymEntryByName.
    Returns 0 on success, (-1) on error.
*/

extern int
CirioNubLocalGetMatchingSymEntryByValue(/*
    unsigned symID,
    unsigned val,
    unsigned wantedTypes,
    unsigned ignoredClasses,
    int numToSkip,
    CirioNubSymEntry buf
*/);
/*
    Like XR←ILGetMatchingSymEntryByValue.
    Returns 0 on success, (-1) on error.
*/




/*
 * Replace a patch area ... OBSOLETE
 */

extern int
CirioNubLocalReplacePatchArea(/*
    XR←Pointer pc,
    XR←Pointer newPatchArea,
    unsigned long newSize
*/);
/*
    Replace the patch area associated with given pc value.
    If newPatchArea is NIL, CirioNubLocalReplacePatchArea will allocate
      a new patch area of the requested size.
    Return 0 on success, (-1) on failure.
*/


/*
 * Remote debugging listener query
 */

extern int
CirioNubLocalGetPort();
/*
    Return port at which local debugnub is listening.
    Return 0 if no local debugnub is running.
    Return (-1) on other failure.
*/


/*
    OBSOLETE:
*/
extern int
CirioNubLocalLookupSymEntryByName(/*
    char *sym,
    bool caseSensitive,
    bool externOnly,
    int numToSkip,
    CirioNubSymEntry buf
*/);
/*
    Lookup symbol by name,
      then skip backward the specified number of symbols.
    Return 0 on success, (-1) on error.
*/


extern int
CirioNubLocalLookupSymEntryByValue(/*
    unsigned val,
    int numToSkip,
    CirioNubSymEntry buf
*/);
/*
    Lookup symbol entry by value -- get most-recently-loaded symbol
      of highest value <= val.
    Then skip forward (numToSkip > 0) or backward (numToSkip < 0).
    Return 0 on success, (-1) on failure.
*/

extern int
CirioNubLocalLookupSymEntryByID(/*
    unsigned symID,
    CirioNubSymEntry buf
*/);
/*
    Lookup symbol entry by ID.
    This is included for completeness; it is equivalent to

        CirioNubLocalSkipSymEntryByValue(symID, 0, buf)

    See below.
*/

extern int
CirioNubLocalSkipSymEntryByName(/*
    unsigned symID,
    bool caseSensitive,
    bool externOnly,
    int numToSkip,
    CirioNubSymEntry buf
*/);
/*
    Skip forward/backward specified number of symbols by name.
    Return 0 on success, (-1) on failure.
*/

extern int
CirioNubLocalSkipSymEntryByValue(/*
    unsigned symID,
    int numToSkip,
    CirioNubSymEntry buf
*/);
/*
    Skip forward/backward specified number of symbols by value.
    Return 0 on success, (-1) on failure.
*/


extern int
CirioNubLocalGetMaxThreads();
/*
    Return max number of threads supported.
*/

extern int
CirioNubLocalGetThreadIndex(/* XR←CT t */);
/*
    Return thread index of thread t.
    If t == NIL interpret as current thread.
    Return (-1) on error (t invalid).
*/


/*
 * Fetch / Store procs for local world ...
 *   able to store into text segment.
 */

extern int
CirioNubLocalGetBytes(/* char *buf, char *addr, int nBytes */);

extern int
CirioNubLocalPutBytes(/* char *buf, char *addr, int nBytes */);


extern int
CirioNubLocalGetWords16(/* short *buf, short *addr, int nBytes */);

extern int
CirioNubLocalPutWords16(/* short *buf, short *addr, int nBytes */);


extern int
CirioNubLocalGetWords32(/* long *buf, long *addr, int nBytes */);

extern int
CirioNubLocalPutWords32(/* long *buf, long *addr, int nBytes */);



 
#endif /* ←CIRIO←NUB←LOCAL←PROCS← */