Callin Function Reference

Alphabetical Function List

This section contains an alphabetical list of all Callin functions with a brief description of each function and links to detailed descriptions.

• IrisAbort — Tells InterSystems IRIS® to cancel the current request being processed on the InterSystems IRIS side, when it is convenient to do so.

• IrisAcquireLock — Executes an InterSystems IRIS LOCK command. The lock reference should already be set up with IrisPushLockX[W][H].

• IrisCallExecuteFunc — Performs the $Xecute() function after the command string has been pushed onto the stack by IrisPushExecuteFuncA[W][H].

• IrisChangePasswordA[W][H] — Changes the user's password if InterSystems authentication is used (not valid for other forms of authentication).

• IrisBitFind[B] — Returns the position of specified bit values within a bitstring (similar to InterSystems IRIS $BITFIND).

• IrisCloseOref — Decrements the system reference counter for an OREF.

• IrisContext — Returns true if there is a request currently being processed on the InterSystems IRIS side of the connection when using an external Callin program.

• IrisConvert — Converts the value returned by IrisEvalA[W][H] into proper format and places in address specified in its return value.

• IrisCtrl — Determines whether or not InterSystems IRIS ignores CTRL-C.

• IrisCvtExStrInA[W][H] — Translates a string with specified external character set encoding to the local 8-bit character string encoding used internally only in 8-bit versions of InterSystems IRIS.

• IrisCvtExStrOutA[W][H] — Translates a string from the local 8-bit character string encoding used internally in the InterSystems IRIS 8-bit product to a string with the specified external character set encoding. (This is only available with 8-bit versions of InterSystems IRIS.)

• IrisCvtInA[W][H] — Translates string with specified external character set encoding to the local 8-bit character string encoding (used internally only in 8-bit versions of InterSystems IRIS) or the Unicode character string encoding (used internally in Unicode versions of InterSystems IRIS).

• IrisCvtOutA[W][H] — Translates a string from the local 8-bit character string encoding used internally in the InterSystems IRIS 8-bit product to a string with the specified external character set encoding. (This is only available with 8-bit versions of InterSystems IRIS.)

• IrisDoFun — Performs a routine call (special case).

• IrisDoRtn — Performs a routine call.

• IrisEnd — Terminates an InterSystems IRIS process. If there is a broken connection, it also performs clean-up operations.

• IrisEndAll — Disconnects all Callin threads and waits until they terminate.

• IrisErrorA[W][H] — Returns the most recent error message, its associated source string, and the offset to where in the source string the error occurred.

• IrisErrxlateA[W][H] — Translates an integer error code into an InterSystems IRIS error string.

• IrisEvalA[W][H] — Evaluates a string as if it were an InterSystems IRIS expression and places the return value in memory for further processing by IrisType and IrisConvert.

• IrisExecuteA[W][H] — Executes a command string as if it were typed in the Terminal.

• IrisExecuteArgs — Executes a command string with arguments.

• IrisExStrKill — Releases the storage associated with an EXSTR string.

• IrisExStrNew[W][H] — Allocates the requested amount of storage for a string, and fills in the EXSTR structure with the length and a pointer to the value field of the structure.

• IrisExtFun — Performs an extrinsic function call where the return value is pushed onto the argument stack.

• IrisGetProperty — Obtains the value of the property defined by IrisPushProperty[W][H]. The value is pushed onto the argument stack.

• IrisGlobalData — Performs a $Data on the specified global.

• IrisGlobalGet — Obtains the value of the global reference defined by IrisPushGlobal[W][H] and any subscripts. The node value is pushed onto the argument stack.

• IrisGlobalIncrement — Performs a $INCREMENT and returns the result on top of the stack.

• IrisGlobalKill — Performs a ZKILL on a global node or tree.

• IrisGlobalOrder — Performs a $Order on the specified global.

• IrisGlobalQuery — Performs a $Query on the specified global.

• IrisGlobalRelease — Release ownership of a retained global buffer, if one exists.

• IrisGlobalSet — Stores the value of the global reference defined by IrisPushGlobal[W][H] and any subscripts. The node value must be pushed onto the argument stack before this call.

• IrisIncrementCountOref — Increments the system reference counter for an OREF.

• IrisInvokeClassMethod — Executes the class method call defined by IrisPushClassMethod[W][H] and any arguments. The return value is pushed onto the argument stack.

• IrisInvokeMethod — Executes the instance method call defined by IrisPushMethod[W][H] and any arguments pushed onto the argument stack.

• IrisOflush — Flushes any pending output.

• IrisPop — Pops a value off argument stack.

• IrisPopCvtW[H] — Pops a local 8-bit string off argument stack and translates it to Unicode. Identical to IrisPopStr[W][H] for Unicode versions.

• IrisPopDbl — Pops a value off argument stack and converts it to a double.

• IrisPopExStr[W][H] — Pops a value off argument stack and converts it to a string.

• IrisPopExStrCvtW[H] — Pops a value off argument stack and converts it to a long Unicode string.

• IrisPopInt — Pops a value off argument stack and converts it to an integer.

• IrisPopInt64 — Pops a value off argument stack and converts it to a 64-bit (long long) number.

• IrisPopList — Pops a $LIST object off argument stack and converts it.

• IrisPopOref — Pops an OREF off argument stack.

• IrisPopPtr — Pops a pointer off argument stack in internal format.

• IrisPopStr[W][H] — Pops a value off argument stack and converts it to a string.

• IrisPromptA[W][H] — Returns a string that would be the Terminal.

• IrisPushClassMethod[W][H] — Pushes a class method reference onto the argument stack.

• IrisPushCvtW[H] — Translates a Unicode string to local 8-bit and pushes it onto the argument stack. Identical to IrisPushStr[W][H] for Unicode versions.

• IrisPushDbl — Pushes a double onto the argument stack.

• IrisPushExecuteFuncA[W][H] — Pushes the $Xecute() command string onto the stack in preparation for a call by IrisCallExecuteFunc.

• IrisPushExStr[W][H] — Pushes a string onto the argument stack.

• IrisPushExStrCvtW[H] — Converts a Unicode string to local 8–bit encoding and pushes it onto the argument stack.

• IrisPushFunc[W][H] — Pushes an extrinsic function reference onto the argument stack.

• IrisPushFuncX[W][H] — Pushes an extended extrinsic function reference onto the argument stack.

• IrisPushGlobal[W][H] — Pushes a global reference onto the argument stack.

• IrisPushGlobalX[W][H] — Pushes an extended global reference onto the argument stack.

• IrisPushIEEEDbl — Pushes an IEEE double onto the argument stack.

• IrisPushInt — Pushes an integer onto the argument stack.

• IrisPushInt64 — Pushes a 64-bit (long long) number onto the argument stack.

• IrisPushList — Converts a $LIST object and pushes it onto the argument stack.

• IrisPushLock[W][H] — Initializes a IrisAcquireLock command by pushing the lock name on the argument stack.

• IrisPushLockX[W][H] — Initializes a IrisAcquireLock command by pushing the lock name and an environment string on the argument stack.

• IrisPushMethod[W][H] — Pushes an instance method reference onto the argument stack.

• IrisPushOref — Pushes an OREF onto the argument stack.

• IrisPushProperty[W][H] — Pushes a property reference onto the argument stack.

• IrisPushPtr — Pushes a pointer onto the argument stack in internal format.

• IrisPushRtn[W][H] — Pushes a routine reference onto the argument stack.

• IrisPushRtnX[W][H] — Pushes an extended routine reference onto the argument stack.

• IrisPushStr[W][H] — Pushes a byte string onto the argument stack.

• IrisPushUndef — pushes an Undefined value that is interpreted as an omitted function argument.

• IrisReleaseAllLocks — Performs an argumentless InterSystems IRIS LOCK command to remove all locks currently held by the process.

• IrisReleaseLock — Executes an InterSystems IRIS LOCK command to decrement the lock count for the specified lock name. This command will only release one incremental lock at a time.

• IrisSecureStartA[W][H] — Calls into InterSystems IRIS to set up a process.

• IrisSetDir — Dynamically sets the name of the manager's directory at runtime.

• IrisSetProperty — Stores the value of the property defined by IrisPushProperty[W][H].

• IrisSignal — Passes on signals caught by user's program to InterSystems IRIS.

• IrisSPCReceive — Receive single-process-communication message.

• IrisSPCSend — Send a single-process-communication message.

• IrisStartA[W][H] — Calls into InterSystems IRIS to set up an InterSystems IRIS process.

• IrisTCommit — Executes an InterSystems IRIS TCommit command.

• IrisTLevel — Returns the current nesting level ($TLEVEL) for transaction processing.

• IrisTRollback — Executes an InterSystems IRIS TRollback command.

• IrisTStart — Executes an InterSystems IRIS TStart command.

• IrisType — Returns the native type of the item returned by IrisEvalA[W][H], as the function value.

• IrisUnPop — Restores the stack entry from IrisPop.

IrisAbort

int IrisAbort(unsigned long type)

Tells InterSystems IRIS to cancel the current request being processed on the InterSystems IRIS side, when it is convenient to do so. This function is for use if you detect some critical event in an AST (asynchronous trap) or thread running on the Callin side. (You can use IrisContext to determine if there is an InterSystems IRIS request currently being processed.) Note that this only applies to Callin programs that use an AST or separate thread.

rc = IrisAbort(IRIS_CTRLC);

IrisAcquireLock

int IrisAcquireLock(int nsub, int flg, int tout, int * rval)

Executes an InterSystems IRIS LOCK command. The lock reference should already be set up with IrisPushLock.

IrisBitFind

int IrisBitFind(int strlen, unsigned short *bitstr, int newlen, int srch, int revflg)

Returns the bit position (1-based) of the next bit within bitstring bitstr that has the value specified by srch. The direction of the search is indicated by revflg. Returns 0 if there are no more bits of the specified value in the specified direction.

This function is similar to InterSystems IRIS $BITFIND (also see “General Information on Bitstring Functions”).

IrisBitFindB

int IrisBitFindB(int strlen, unsigned char *bitstr, int newlen, int srch, int revflg)

Returns the bit position (1-based) of the next bit within bitstring bitstr that has the value specified by srch. The direction of the search is indicated by revflg. Returns 0 if there are no more bits of the specified value in the specified direction.

This function is similar to InterSystems IRIS $BITFIND (also see “General Information on Bitstring Functions”).

IrisCallExecuteFunc

int IrisCallExecuteFunc(int numargs)

Calls the $Xecute() function with arguments. The function command string must have been pushed onto the argument stack by IrisPushExecuteFuncA[W][H], followed by pushing the arguments. The number of arguments may be 0. The result of the function will be left on the argument stack.

IrisChangePasswordA

Variants: IrisChangePasswordW, IrisChangePasswordH

int IrisChangePasswordA(IRIS_ASTRP username, IRIS_ASTRP oldpassword, IRIS_ASTRP newpassword)

This function can change the user's password if InterSystems authentication or delegated authentication is used. It is not valid for LDAP, Kerberos, or other forms of authentication. It must be called before a Callin session is initialized. A typical use would be to handle a IRIS_CHANGEPASSWORD error from IrisSecureStart. In such a case IrisChangePassword would be called to change the password, then IrisSecureStart would be called again.

IrisChangePasswordH

Variants: IrisChangePasswordA, IrisChangePasswordW

int IrisChangePasswordH(IRISHSTRP username, IRISHSTRP oldpassword, IRISHSTRP newpassword)

This function can change the user's password if InterSystems authentication or delegated authentication is used. It is not valid for LDAP, Kerberos, or other forms of authentication. It must be called before a Callin session is initialized. A typical use would be to handle a IRIS_CHANGEPASSWORD error from IrisSecureStart. In such a case IrisChangePassword would be called to change the password, then IrisSecureStart would be called again.

IrisChangePasswordW

Variants: IrisChangePasswordA, IrisChangePasswordH

int IrisChangePasswordW(IRISWSTRP username, IRISWSTRP oldpassword, IRISWSTRP newpassword)

This function can change the user's password if InterSystems authentication or delegated authentication is used. It is not valid for LDAP, Kerberos, or other forms of authentication. It must be called before a Callin session is initialized. A typical use would be to handle a IRIS_CHANGEPASSWORD error from IrisSecureStart. In such a case IrisChangePassword would be called to change the password, then IrisSecureStart would be called again.

IrisCloseOref

int IrisCloseOref(unsigned int oref)

Decrements the system reference counter for an OREF.

IrisContext

int IrisContext()

Returns an integer as the function value.

If you are using an external Callin program (as opposed to a module that was called from a $ZF function) and your program employs an AST or separate thread, then IrisContext tells you if there is a request currently being processed on the InterSystems IRIS side of the connection. This information is needed to decide if you must return to InterSystems IRIS to allow processing to complete.

rc = IrisContext();

IrisConvert

int IrisConvert(unsigned long type, void * rbuf)

Converts the value returned by IrisEval into proper format and places in address specified in its return value (listed below as rbuf).

Valid values of type are:

• IRIS_ASTRING — 8-bit character string.

• IRIS_CHAR — 8-bit signed integer.

• IRIS_DOUBLE — 64-bit floating point.

• IRIS_FLOAT — 32-bit floating point.

• IRIS_INT — 32-bit signed integer.

• IRIS_INT2 — 16-bit signed integer.

• IRIS_INT4 — 32-bit signed integer.

• IRIS_INT8 — 64-bit signed integer.

• IRIS_UCHAR — 8-bit unsigned integer.

• IRIS_UINT — 32-bit unsigned integer.

• IRIS_UINT2 — 16-bit unsigned integer.

• IRIS_UINT4 — 32-bit unsigned integer.

• IRIS_UINT8 — 64-bit unsigned integer.

• IRIS_WSTRING — Unicode character string.

IRIS_ASTR retval;
/* define variable retval */

retval.len = 20;
/* maximum return length of string */

rc = IrisConvert(IRIS_ASTRING,&retval);

IrisCtrl

int IrisCtrl(unsigned long flags)

Determines whether or not InterSystems IRIS ignores CTRL-C. flags can have bit state values of

• IRIS_DISACTRLC — InterSystems IRIS ignores CTRL-C.

• IRIS_ENABCTRLC — Default if function is not called, unless overridden by a BREAK or an OPEN command. In InterSystems IRIS, CTRL-C generates an <INTERRUPT>.

rc = IrisCtrl(IRIS_ENABCTRLC);

IrisCvtExStrInA

Variants: IrisCvtExStrInW, IrisCvtExStrInH

int IrisCvtExStrInA(IRIS_EXSTRP src, IRIS_ASTRP tbl, IRIS_EXSTRP res)

Translates a string with specified external character set encoding to the local 8-bit character string encoding used internally.

IrisCvtExStrInW

Variants: IrisCvtExStrInA, IrisCvtExStrInH

int IrisCvtExStrInW(IRIS_EXSTRP src, IRISWSTRP tbl, IRIS_EXSTRP res)

Translates a string with specified external character set encoding to the 2–byte Unicode character string encoding used internally in InterSystems IRIS.

IrisCvtExStrInH

Variants: IrisCvtExStrInA, IrisCvtExStrInW

int IrisCvtExStrInH(IRIS_EXSTRP src, IRISWSTRP tbl, IRIS_EXSTRP res)

Translates a string with specified external character set encoding to the 4–byte Unicode character string encoding used internally in InterSystems IRIS.

IrisCvtExStrOutA

Variants: IrisCvtExStrOutW, IrisCvtExStrOutH

int IrisCvtExStrOutA(IRIS_EXSTRP src, IRIS_ASTRP tbl, IRIS_EXSTRP res)

Translates a string from the 8-bit character string encoding used internally in an older InterSystems 8-bit product to a string with the specified external character set encoding.

IrisCvtExStrOutW

Variants: IrisCvtExStrOutA, IrisCvtExStrOutH

int IrisCvtExStrOutW(IRIS_EXSTRP src, IRISWSTRP tbl, IRIS_EXSTRP res)

Translates a string from the 2–byte Unicode character string encoding used internally in InterSystems IRIS to a string with the specified external character set encoding.

IrisCvtExStrOutH

Variants: IrisCvtExStrOutA, IrisCvtExStrOutW

int IrisCvtExStrOutH(IRIS_EXSTRP src, IRISWSTRP tbl, IRIS_EXSTRP res)

Translates a string from the 4–byte Unicode character string encoding used internally in InterSystems IRIS to a string with the specified external character set encoding.

IrisCvtInA

Variants: IrisCvtInW, IrisCvtInH

int IrisCvtInA(IRIS_ASTRP src, IRIS_ASTRP tbl, IRIS_ASTRP res)

Translates string with specified external character set encoding to the local 8-bit character string encoding used internally only in 8-bit versions of InterSystems IRIS.

IrisCvtInW

Variants: IrisCvtInA, IrisCvtInH

int IrisCvtInW(IRIS_ASTRP src, IRISWSTRP tbl, IRISWSTRP res)

Translates string with specified external character set encoding to the Unicode character string encoding used internally in Unicode versions of InterSystems IRIS.

IrisCvtInH

Variants: IrisCvtInA, IrisCvtInW

int IrisCvtInH(IRIS_ASTRP src, IRISHSTRP tbl, IRISHSTRP res)

Translates string with specified external character set encoding to the Unicode character string encoding used internally in Unicode versions of InterSystems IRIS.

IrisCvtOutA

Variants: IrisCvtOutW, IrisCvtOutH

int IrisCvtOutA(IRIS_ASTRP src, IRIS_ASTRP tbl, IRIS_ASTRP res)

Translates a string from the local 8-bit character string encoding used internally in the InterSystems IRIS 8-bit product to a string with the specified external character set encoding. (This is only available with 8-bit versions of InterSystems IRIS.)

IrisCvtOutW

Variants: IrisCvtOutA, IrisCvtOutH

int IrisCvtOutW(IRISWSTRP src, IRISWSTRP tbl, IRIS_ASTRP res)

Translates a string from the Unicode character string encoding used internally in Unicode versions of InterSystems IRIS to a string with the specified external character set encoding. (This is only available with Unicode versions of InterSystems IRIS.)

IrisCvtOutH

Variants: IrisCvtOutA, IrisCvtOutW

int IrisCvtOutH(IRISHSTRP src, IRISHSTRP tbl, IRIS_ASTRP res)

Translates a string from the Unicode character string encoding used internally in Unicode versions of InterSystems IRIS to a string with the specified external character set encoding. (This is only available with Unicode versions of InterSystems IRIS.)

IrisDoFun

int IrisDoFun(unsigned int flags, int narg)

Performs a routine call (special case).

IrisDoRtn

int IrisDoRtn(unsigned int flags, int narg)

Performs a routine call.

IrisEnd

int IrisEnd()

Terminates an InterSystems IRIS process. If there is a broken connection, it also performs clean-up operations.

IrisEnd can also return any of the InterSystems IRIS error codes.

rc = IrisEnd();

IrisEndAll

int IrisEndAll()

Disconnects all threads in a threaded Callin environment, then schedules the threads for termination and waits until they are done.

rc = IrisEndAll();

IrisErrorA

Variants: IrisErrorW, IrisErrorH

int IrisErrorA(IRIS_ASTRP msg, IRIS_ASTRP src, int * offp)

Returns the most recent error message, its associated source string, and the offset to where in the source string the error occurred.

IRIS_ASTR errmsg;
IRIS_ASTR srcline;
int offset;
errmsg.len = 50;
srcline.len = 100;
if ((rc = IrisErrorA(&errmsg, &srcline, &offset)) != IRIS_SUCCESS)
printf("\r\nfailed to display error - rc = %d",rc);

IrisErrorH

Variants: IrisErrorA, IrisErrorW

int IrisErrorH(IRISHSTRP msg, IRISHSTRP src, int * offp)

Returns the most recent error message, its associated source string, and the offset to where in the source string the error occurred.

IRISHSTRP errmsg;
IRISHSTRP srcline;
int offset;
errmsg.len = 50;
srcline.len = 100;
if ((rc = IrisErrorH(&errmsg, &srcline, &offset)) != IRIS_SUCCESS)
printf("\r\nfailed to display error - rc = %d",rc);

IrisErrorW

Variants: IrisErrorA, IrisErrorH

int IrisErrorW(IRISWSTRP msg, IRISWSTRP src, int * offp)

Returns the most recent error message, its associated source string, and the offset to where in the source string the error occurred.

IRISWSTRP errmsg;
IRISWSTRP srcline;
int offset;
errmsg.len = 50;
srcline.len = 100;
if ((rc = IrisErrorW(&errmsg, &srcline, &offset)) != IRIS_SUCCESS)
printf("\r\nfailed to display error - rc = %d",rc);

IrisErrxlateA

Variants: IrisErrxlateW, IrisErrxlateH

int IrisErrxlateA(int code, IRIS_ASTRP rbuf)

Translates error code code into an InterSystems IRIS error string, and writes that string into the structure pointed to by rbuf

IRIS_ASTR retval; /* define variable retval */
retval.len = 30; /* maximum return length of string */
rc = IrisErrxlateA(IRIS_ERSTORE,&retval);

IrisErrxlateH

Variants: IrisErrxlateA, IrisErrxlateW

int IrisErrxlateH(int code, IRISHSTRP rbuf)

Translates error code code into an InterSystems IRIS error string, and writes that string into the structure pointed to by rbuf

IRISHSTR retval; /* define variable retval */
retval.len = 30; /* maximum return length of string */
rc = IrisErrxlateH(IRIS_ERSTORE,&retval);

IrisErrxlateW

Variants: IrisErrxlateA, IrisErrxlateH

int IrisErrxlateW(int code, IRISWSTRP rbuf)

Translates error code code into an InterSystems IRIS error string, and writes that string into the structure pointed to by rbuf

IRISWSTR retval; /* define variable retval */
retval.len = 30; /* maximum return length of string */
rc = IrisErrxlateW(IRIS_ERSTORE,&retval);

IrisEvalA

Variants: IrisEvalW, IrisEvalH

int IrisEvalA(IRIS_ASTRP volatile expr)

Evaluates a string as if it were an InterSystems IRIS expression and places the return value in memory for further processing by IrisType and IrisConvert.

If IrisEvalA completes successfully, it sets a flag that allows calls to IrisType and IrisConvert to complete. These functions are used to process the item returned from IrisEvalA.

IrisEvalA can also return any of the InterSystems IRIS error codes.

int rc;
IRIS_ASTR retval;
IRIS_ASTR expr;

strcpy(expr.str, "\"Record\"_^Recnum_\" = \"_$$^GetRec(^Recnum)");
expr.len = strlen(expr.str);
rc = IrisEvalA(&expr);
if (rc == IRIS_SUCCESS)
    rc = IrisConvert(IRIS_ASTRING,&retval);

IrisEvalH

Variants: IrisEvalA, IrisEvalW

int IrisEvalH(IRISHSTRP volatile expr)

Evaluates a string as if it were an InterSystems IRIS expression and places the return value in memory for further processing by IrisType and IrisConvert.

If IrisEvalH completes successfully, it sets a flag that allows calls to IrisType and IrisConvert to complete. These functions are used to process the item returned from IrisEvalA.

IrisEvalH can also return any of the InterSystems IRIS error codes.

int rc;
IRISHSTRP retval;
IRISHSTRP expr;

strcpy(expr.str, "\"Record\"_^Recnum_\" = \"_$$^GetRec(^Recnum)");
expr.len = strlen(expr.str);
rc = IrisEvalH(&expr);
if (rc == IRIS_SUCCESS)
    rc = IrisConvert(ING,&retval);

IrisEvalW

Variants: IrisEvalA, IrisEvalH

int IrisEvalW(IRISWSTRP volatile expr)

Evaluates a string as if it were an InterSystems IRIS expression and places the return value in memory for further processing by IrisType and IrisConvert.

If IrisEvalW completes successfully, it sets a flag that allows calls to IrisType and IrisConvert to complete. These functions are used to process the item returned from IrisEvalA.

IrisEvalW can also return any of the InterSystems IRIS error codes.

int rc;
IRISWSTR retval;
IRISWSTR expr;

strcpy(expr.str, "\"Record\"_^Recnum_\" = \"_$$^GetRec(^Recnum)");
expr.len = strlen(expr.str);
rc = IrisEvalW(&expr);
if (rc == IRIS_SUCCESS)
    rc = IrisConvert(ING,&retval);

IrisExecuteA

Variants: IrisExecuteW, IrisExecuteH

int IrisExecuteA(IRIS_ASTRP volatile cmd)

Executes the command string as if it were typed in the Terminal.

IrisExecuteA can also return any of the InterSystems IRIS error codes.

int rc;
IRIS_ASTR command;
sprintf(command.str,"set $namespace = \"USER\""); /* changes namespace */
command.len = strlen(command.str);
rc = IrisExecuteA(&command);

IrisExecuteH

Variants: IrisExecuteA, IrisExecuteW

int IrisExecuteH(IRISHSTRP volatile cmd)

Executes the command string as if it were typed in the Terminal.

If IrisExecuteH completes successfully, it sets a flag that allows calls to IrisType and IrisConvert to complete. These functions are used to process the item returned from IrisEvalH.

IrisExecuteH can also return any of the InterSystems IRIS error codes.

int rc;
unsigned short zname[] = {'Z','N',' ','"','U','S','E','R','"'};
IRISHSTRP pcommand;
pcommand.str = zname;
pcommand.len = sizeof(zname) / sizeof(unsigned short);
rc = IrisExecuteH(pcommand);

IrisExecuteW

Variants: IrisExecuteA, IrisExecuteH

int IrisExecuteW(IRISWSTRP volatile cmd)

Executes the command string as if it were typed in the Terminal.

If IrisExecuteW completes successfully, it sets a flag that allows calls to IrisType and IrisConvert to complete. These functions are used to process the item returned from IrisEvalW.

IrisExecuteW can also return any of the InterSystems IRIS error codes.

int rc;
unsigned short zname[] = {'Z','N',' ','"','U','S','E','R','"'};
IRISWSTRP pcommand;
pcommand.str = zname;
pcommand.len = sizeof(zname) / sizeof(unsigned short);
rc = IrisExecuteW(pcommand);

IrisExecuteArgs

int IrisExecuteArgs(int numargs)

Executes a command string with arguments. The command string must have been pushed onto the argument stack with normal push string functions, followed by pushing the arguments. The number of arguments may be 0.

IrisExStrKill

int IrisExStrKill(IRIS_EXSTRP obj)

Releases the storage associated with an EXSTR string.

IrisExStrNew

Variants: IrisExStrNewW, IrisExStrNewH

unsigned char * IrisExStrNew(IRIS_EXSTRP zstr, int size)

Allocates the requested amount of storage for a string, and fills in the EXSTR structure with the length and a pointer to the value field of the structure.

Returns a pointer to the allocated string, or NULL if no string was allocated.

IrisExStrNewW

Variants: IrisExStrNew, IrisExStrNewH

unsigned short * IrisExStrNewW(IRIS_EXSTRP zstr, int size)

Allocates the requested amount of storage for a string, and fills in the EXSTR structure with the length and a pointer to the value field of the structure.

Returns a pointer to the allocated string, or NULL if no string was allocated.

IrisExStrNewH

Variants: IrisExStrNew, IrisExStrNewW

unsigned short * IrisExStrNewH(IRIS_EXSTRP zstr, int size)

Allocates the requested amount of storage for a string, and fills in the EXSTR structure with the length and a pointer to the value field of the structure.

Returns a pointer to the allocated string, or NULL if no string was allocated.

IrisExtFun

int IrisExtFun(unsigned int flags, int narg)

Performs an extrinsic function call where the return value is pushed onto the argument stack.

IrisGetProperty

int IrisGetProperty()

Obtains the value of the property defined by IrisPushProperty. The value is pushed onto the argument stack.

IrisGlobalData

int IrisGlobalData(int narg, int valueflag)

Performs a $Data on the specified global.

IrisGlobalGet

int IrisGlobalGet(int narg, int flag)

Obtains the value of the global reference defined by IrisPushGlobal and any subscripts. The node value is pushed onto the argument stack.

IrisGlobalGetBinary

int IrisGlobalGetBinary(int numsub, int flag, int *plen, Callin_char_t **pbuf)

Obtains the value of the global reference defined by IrisPushGlobal[W][H] and any subscripts, and also tests to make sure that the result is a binary string that will fit in the provided buffer. The node value is pushed onto the argument stack.

IrisGlobalIncrement

int IrisGlobalIncrement(int narg)

Performs a $INCREMENT and returns the result on top of the stack.

IrisGlobalKill

int IrisGlobalKill(int narg, int nodeonly)

Performs a ZKILL on a global node or tree.

IrisGlobalOrder

int IrisGlobalOrder(int narg, int dir, int valueflag)

Performs a $Order on the specified global.

IrisGlobalQuery

int IrisGlobalQuery(int narg, int dir, int valueflag)

Performs a $Query on the specified global.

IrisGlobalRelease

int IrisGlobalRelease( )

Release ownership of a retained global buffer, if one exists.

IrisGlobalSet

int IrisGlobalSet(int narg)

Stores the value of the global reference defined by IrisPushGlobal and any subscripts. The node value must be pushed onto the argument stack before this call.

IrisIncrementCountOref

int IrisIncrementCountOref(unsigned int oref)

Increments the system reference counter for an OREF.

IrisInvokeClassMethod

int IrisInvokeClassMethod(int narg)

Executes the class method call defined by IrisPushClassMethod[W] and any arguments. The return value is pushed onto the argument stack.

IrisInvokeMethod

int IrisInvokeMethod(int narg)

Executes the instance method call defined by IrisPushMethod[W] and any arguments pushed onto the argument stack.

IrisOflush

int IrisOflush()

Flushes any pending output.

IrisPop

int IrisPop(void ** arg)

Pops a value off argument stack.

IrisPopCvtW

Variants: IrisPopCvtH

int IrisPopCvtW(int * lenp, unsigned short ** strp)

Deprecated: The long string function IrisPopExStrCvtW should be used for all strings.

Pops a local 8-bit string off argument stack and translates it to 2–byte Unicode. Identical to IrisPopStrW in Unicode environments.

IrisPopCvtH

Variants: IrisPopCvtW

int IrisPopCvtH(int * lenp, wchar_t ** strp)

Pops a local 8-bit string off argument stack and translates it to 4–byte Unicode. Identical to IrisPopStrH in Unicode environments.

IrisPopDbl

int IrisPopDbl(double * nump)

Pops a value off argument stack and converts it to a double.

IrisPopExStr

Variants: IrisPopExStrW, IrisPopExStrH

int IrisPopExStr(IRIS_EXSTRP sstrp)

Pops a value off argument stack and converts it to a string in local 8–bit encoding.

IrisPopExStrW

Variants: IrisPopExStr, IrisPopExStrH

int IrisPopExStrW(IRIS_EXSTRP sstrp)

Pops a value off argument stack and converts it to a 2–byte Unicode string.

IrisPopExStrH

Variants: IrisPopExStr, IrisPopExStrW

int IrisPopExStrH(IRIS_EXSTRP sstrp)

Pops a value off argument stack and converts it to a 4–byte Unicode string.

IrisPopExStrCvtW

Variants: IrisPopExStrCvtH

int IrisPopExStrCvtW(IRIS_EXSTRP sstr)

Pops a local 8-bit string off the argument stack and translates it to a 2–byte Unicode string. On Unicode systems, this is the same as IrisPopExStrW.

IrisPopExStrCvtH

Variants: IrisPopExStrCvtW

int IrisPopExStrCvtW(IRIS_EXSTRP sstr)

Pops a local 8-bit string off argument stack and translates it to a 4–byte Unicode string. On Unicode systems, this is the same as IrisPopExStrH.

IrisPopInt

int IrisPopInt(int* nump)

Pops a value off argument stack and converts it to an integer.

IrisPopInt64

int IrisPopInt64(long long * nump)

Pops a value off argument stack and converts it to a 64–bit (long long) value.

IrisPopList

int IrisPopList(int * lenp, Callin_char_t ** strp)

Pops a $LIST object off argument stack and converts it.

IrisPopOref

int IrisPopOref(unsigned int * orefp)

Pops an OREF off argument stack.

IrisPopPtr

int IrisPopPtr(void ** ptrp)

Pops a pointer off argument stack in internal format.

IrisPopStr

Variants: IrisPopStrW, IrisPopStrH

int IrisPopStr(int * lenp, Callin_char_t ** strp)

Pops a value off argument stack and converts it to a string.

IrisPopStrW

Variants: IrisPopStr, IrisPopStrH

int IrisPopStrW(int * lenp, unsigned short ** strp)

Pops a value off argument stack and converts it to a 2-byte Unicode string.

IrisPopStrH

Variants: IrisPopStr, IrisPopStrW

int IrisPopStrH(int * lenp, wchar_t ** strp)

Pops a value off argument stack and converts it to a 4-byte Unicode string.

IrisPromptA

Variants: IrisPromptW, IrisPromptH

int IrisPromptA(IRIS_ASTRP rbuf)

Returns a string that would be the Terminal (without the “>”).

IRIS_ASTR retval;      /* define variable retval */
retval.len = 5;         /* maximum return length of string */
rc = IrisPromptA(&retval);

IrisPromptH

Variants: IrisPromptA, IrisPromptW

int IrisPromptH(IRISHSTRP rbuf)

Returns a string that would be the Terminal (without the “>”).

IRISHSTRP retval; /* define variable retval */
retval.len = 5; /* maximum return length of string */
rc = IrisPromptH( &retval);

IrisPromptW

Variants: IrisPromptA, IrisPromptH

int IrisPromptW(IRISWSTRP rbuf)

Returns a string that would be the Terminal (without the “>”).

IRISWSTR retval; /* define variable retval */
retval.len = 5; /* maximum return length of string */
rc = IrisConvertW( &retval);

IrisPushClassMethod

Variants: IrisPushClassMethodW, IrisPushClassMethodH

int IrisPushClassMethod(int clen, const Callin_char_t * cptr,
                         int mlen, const Callin_char_t * mptr, int flg)

Pushes a class method reference onto the argument stack.

IrisPushClassMethodH

Variants: IrisPushClassMethod, IrisPushClassMethodW

int IrisPushClassMethodH(int clen, const wchar_t * cptr,
                          int mlen, const wchar_t * mptr, int flg)

Pushes a 4-byte Unicode class method reference onto the argument stack.

IrisPushClassMethodW

Variants: IrisPushClassMethod, IrisPushClassMethodH

int IrisPushClassMethodW(int clen, const unsigned short * cptr,
                          int mlen, const unsigned short * mptr, int flg)

Pushes a 2-byte Unicode class method reference onto the argument stack.

IrisPushCvtW

Variants: IrisPushCvtH

int IrisPushCvtW(int len, const unsigned short * ptr)

Deprecated: The long string function IrisPushExStrCvtW should be used for all strings.

Translates a Unicode string to local 8-bit and pushes it onto the argument stack. Identical to IrisPushStrW for Unicode versions.

IrisPushCvtH

Variants: IrisPushCvtW

int IrisPushCvtH(int len, const wchar_t * ptr)

Translates a Unicode string to local 8-bit and pushes it onto the argument stack. Identical to IrisPushStrH for Unicode versions.

IrisPushDbl

int IrisPushDbl(double num)

Pushes a double onto the argument stack.

IrisPushExecuteFuncA

Variants: IrisPushExecuteFuncW, IrisPushExecuteFuncH

int IrisPushExecuteFuncA(int len, const unsigned char *ptr)

Pushes the $Xecute() command string onto the argument stack to prepare for a call by IrisCallExecuteFunc().

IrisPushExecuteFuncW

Variants: IrisPushExecuteFuncA, IrisPushExecuteFuncH

int IrisPushExecuteFuncW(int len, const unsigned short *ptr)

Pushes the $Xecute() command string onto the argument stack to prepare for a call by IrisCallExecuteFunc().

IrisPushExecuteFuncH

Variants: IrisPushExecuteFuncA, IrisPushExecuteFuncW

int IrisPushExecuteFuncH(int len, const wchar_t *ptr)

Pushes the $Xecute() command string onto the argument stack to prepare for a call by IrisCallExecuteFunc().

IrisPushExStr

Variants: IrisPushExStrW, IrisPushExStrH

int IrisPushExStr(IRIS_EXSTRP sptr)

Pushes a string onto the argument stack.

IrisPushExStrW

Variants: IrisPushExStr, IrisPushExStrH

int IrisPushExStrW(IRIS_EXSTRP sptr)

Pushes a Unicode string onto the argument stack.

IrisPushExStrH

Variants: IrisPushExStr, IrisPushExStrW

int IrisPushExStrH(IRIS_EXSTRP sptr)

Pushes a 4–byte Unicode string onto the argument stack.

IrisPushExStrCvtW

Variants: IrisPushExStrCvtH

int IrisPushExStrCvtW(IRIS_EXSTRP sptr)

Translates a Unicode string to local 8-bit and pushes it onto the argument stack.

IrisPushExStrCvtH

Variants: IrisPushExStrCvtW

int IrisPushExStrCvtH(IRIS_EXSTRP sptr)

Translates a 4–byte Unicode string to local 8-bit and pushes it onto the argument stack.

IrisPushFunc

Variants: IrisPushFuncW, IrisPushFuncH

int IrisPushFunc(unsigned int * rflag, int tlen, const Callin_char_t * tptr,
                  int nlen, const Callin_char_t * nptr)

Pushes an extrinsic function reference onto the argument stack.

IrisPushFuncH

Variants: IrisPushFunc, IrisPushFuncW

int IrisPushFuncH(unsigned int * rflag, int tlen, const wchar_t * tptr,
                   int nlen, const wchar_t * nptr)

Pushes a 4-byte Unicode extrinsic function reference onto the argument stack.

IrisPushFuncW

Variants: IrisPushFunc, IrisPushFuncH

int IrisPushFuncW(unsigned int * rflag, int tlen, const unsigned short * tptr,
                   int nlen, const unsigned short * nptr)

Pushes a 2-byte Unicode extrinsic function reference onto the argument stack.

IrisPushFuncX

Variants: IrisPushFuncXW, IrisPushFuncXH

int IrisPushFuncX(unsigned int * rflag, int tlen, const Callin_char_t * tptr, int off,
                   int elen, const Callin_char_t * eptr,
                   int nlen, const Callin_char_t * nptr)

Pushes an extended extrinsic function reference onto the argument stack.

IrisPushFuncXH

Variants: IrisPushFuncX, IrisPushFuncXW

int IrisPushFuncXH(unsigned int * rflag, int tlen, const wchar_t * tptr, int off,
                    int elen, const wchar_t * eptr, int nlen, const wchar_t * nptr)

Pushes a 4-byte Unicode extended function routine reference onto the argument stack.

IrisPushFuncXW

Variants: IrisPushFuncX, IrisPushFuncXH

int IrisPushFuncXW(unsigned int * rflag, int tlen, const unsigned short * tptr, int off,
                    int elen, const unsigned short * eptr,
                    int nlen, const unsigned short * nptr)

Pushes a 2-byte Unicode extended function routine reference onto the argument stack.

IrisPushGlobal

Variants: IrisPushGlobalW, IrisPushGlobalH

int IrisPushGlobal(int nlen, const Callin_char_t * nptr)

Pushes a global reference onto the argument stack.

IrisPushGlobalH

Variants: IrisPushGlobal, IrisPushGlobalW

intIrisPushGlobalH(int nlen, const wchar_t * nptr)

Pushes a 4-byte Unicode global reference onto the argument stack.

IrisPushGlobalW

Variants: IrisPushGlobal, IrisPushGlobalH

int IrisPushGlobalW(int nlen, const unsigned short * nptr)

Pushes a 2-byte Unicode global reference onto the argument stack.

IrisPushGlobalX

Variants: IrisPushGlobalXW, IrisPushGlobalXH

int IrisPushGlobalX(int nlen, const Callin_char_t * nptr,
                     int elen, const Callin_char_t * eptr)

Pushes an extended global reference onto the argument stack.

IrisPushGlobalXH

Variants: IrisPushGlobalX, IrisPushGlobalXW

int IrisPushGlobalXH(int nlen, const wchar_t * nptr, int elen, const wchar_t * eptr)

Pushes a 4-byte Unicode extended global reference onto the argument stack.

IrisPushGlobalXW

Variants: IrisPushGlobalX, IrisPushGlobalXH

int IrisPushGlobalXW(int nlen, const unsigned short * nptr,
                      int elen, const unsigned short * eptr)

Pushes a 2-byte Unicode extended global reference onto the argument stack.

IrisPushIEEEDbl

int IrisPushIEEEDbl(double num)

Pushes an IEEE double onto the argument stack.

IrisPushInt

int IrisPushInt(int num)

Pushes an integer onto the argument stack.

IrisPushInt64

int IrisPushInt64(long long num)

Pushes a 64–bit (long long) value onto the argument stack.

IrisPushList

int IrisPushList(int len, const Callin_char_t * ptr)

Converts a $LIST object and pushes it onto the argument stack.

IrisPushLock

Variants: IrisPushLockW, IrisPushLockH

int IrisPushLock(int nlen, const Callin_char_t * nptr)

Initializes a IrisAcquireLock command by pushing the lock name on the argument stack.

IrisPushLockH

Variants: IrisPushLock, IrisPushLockW

int IrisPushLockH(int nlen, const wchar_t * nptr)

Initializes a IrisAcquireLock command by pushing the lock name on the argument stack.

IrisPushLockW

Variants: IrisPushLock, IrisPushLockH

int IrisPushLockW(int nlen, const unsigned short * nptr)

Initializes a IrisAcquireLock command by pushing the lock name on the argument stack.

IrisPushLockX

Variants: IrisPushLockXW, IrisPushLockXH

int IrisPushLockX(int nlen, const Callin_char_t * nptr, int elen, const Callin_char_t * eptr)

Initializes a IrisAcquireLock command by pushing the lock name and an environment string on the argument stack.

IrisPushLockXH

Variants: IrisPushLockX, IrisPushLockXW

int IrisPushLockXH(int nlen, const wchar_t * nptr, int elen, const wchar_t * eptr)

Initializes a IrisAcquireLock command by pushing the lock name and an environment string on the argument stack.

IrisPushLockXW

Variants: IrisPushLockX, IrisPushLockXH

int IrisPushLockXW(int nlen, const unsigned short * nptr, int elen, const unsigned short * eptr)

Initializes a IrisAcquireLock command by pushing the lock name and an environment string on the argument stack.

IrisPushMethod

Variants: IrisPushMethodW, IrisPushMethodH

int IrisPushMethod(unsigned int oref, int mlen, const Callin_char_t * mptr, int flg)

Pushes an instance method reference onto the argument stack.

IrisPushMethodH

Variants: IrisPushMethod, IrisPushMethodW

int IrisPushMethodH(unsigned int oref, int mlen, const wchar_t * mptr, int flg)

Pushes a 4-byte Unicode instance method reference onto the argument stack.

IrisPushMethodW

Variants: IrisPushMethod, IrisPushMethodH

int IrisPushMethodW(unsigned int oref, int mlen, const unsigned short * mptr, int flg)

Pushes a 2-byte Unicode instance method reference onto the argument stack.

IrisPushOref

int IrisPushOref(unsigned int oref)

Pushes an OREF onto the argument stack.

IrisPushProperty

Variants: IrisPushPropertyW, IrisPushPropertyH

int IrisPushProperty(unsigned int oref, int plen, const Callin_char_t * pptr)

Pushes a property reference onto the argument stack.

IrisPushPropertyH

Variants: IrisPushProperty, IrisPushPropertyW

int IrisPushPropertyH(unsigned int oref, int plen, const wchar_t * pptr)

Pushes a 4-byte Unicode property reference onto the argument stack.

IrisPushPropertyW

Variants: IrisPushProperty, IrisPushPropertyH

int IrisPushPropertyW(unsigned int oref, int plen, const unsigned short * pptr)

Pushes a 2-byte Unicode property reference onto the argument stack.

IrisPushPtr

int IrisPushPtr(void * ptr)

Pushes a pointer onto the argument stack in internal format.

IrisPushRtn

Variants: IrisPushRtnW, IrisPushRtnH

int IrisPushRtn(unsigned int * rflag, int tlen, const Callin_char_t * tptr,
                 int nlen, const Callin_char_t * nptr)

Pushes a routine reference onto the argument stack. See IrisPushRtnX for a version that takes all arguments. This is a short form that only takes a tag name and a routine name.

IrisPushRtnH

Variants: IrisPushRtn, IrisPushRtnW

int IrisPushRtnH(unsigned int * rflag, int tlen, const wchar_t * tptr,
                  int nlen, const wchar_t * nptr)

Pushes a 4–byte Unicode routine reference onto the argument stack. See IrisPushRtnXH for a version that takes all arguments. This is a short form that only takes a tag name and a routine name.

IrisPushRtnW

Variants: IrisPushRtn, IrisPushRtnH

int IrisPushRtnW(unsigned int * rflag, int tlen, const unsigned short * tptr,
                  int nlen, const unsigned short * nptr)

Pushes a 2–byte Unicode routine reference onto the argument stack. See IrisPushRtnXW for a version that takes all arguments. This is a short form that only takes a tag name and a routine name.

IrisPushRtnX

Variants: IrisPushRtnXW, IrisPushRtnXH

int IrisPushRtnX(unsigned int * rflag, int tlen, const Callin_char_t * tptr,
                  int off, int elen, const Callin_char_t * eptr,
                  int nlen, const Callin_char_t * nptr)

Pushes an extended routine reference onto the argument stack. See IrisPushRtn for a short form that only takes a tag name and a routine name.

IrisPushRtnXH

Variants: IrisPushRtnX, IrisPushRtnXW

int IrisPushRtnXH(unsigned int * rflag, int tlen, const wchar_t * tptr,
                   int off, int elen, const wchar_t * eptr,
                   int nlen, const wchar_t * nptr)

Pushes a 4–byte Unicode extended routine reference onto the argument stack. See IrisPushRtnH for a short form that only takes a tag name and a routine name.

IrisPushRtnXW

Variants: IrisPushRtnX, IrisPushRtnXH

int IrisPushRtnXW(unsigned int * rflag, int tlen, const unsigned short * tptr,
                   int off, int elen, const unsigned short * eptr,
                   int nlen, const unsigned short * nptr)

Pushes a 2–byte Unicode extended routine reference onto the argument stack. See IrisPushRtnW for a short form that only takes a tag name and a routine name.

IrisPushStr

Variants: IrisPushStrW, IrisPushStrH

int IrisPushStr(int len, const Callin_char_t * ptr)

Pushes a byte string onto the argument stack.