ToolTalk Reference Guide
この本のみを検索
PDF 文書ファイルをダウンロードする

NAME

tt_c, Tttt_c - ToolTalk definitions

SYNOPSIS

#include <Tt/tt_c.h>

DESCRIPTION

The <Tt/tt_c.h> header includes typedef sfor the following callback functions:
typedef Tt_filter_action (* Tt_filter_function)(constchar * nodeid,
                                             void * context,
                                             void * accumulator);

typedef Tt_callback_action (* Tt_message_callback)(Tt_messagem,
Tt_pattern p );
The header defines the TT_VERSION constant with the value 10200, indicating the version of the ToolTalk API.
The header defines the Tt_status enumeration data type, with the following members and specific values:
typedef enum tt_status {
    TT_OK             = 0,
    TT_WRN_NOTFOUND              = 1,
    TT_WRN_STALE_OBJID           = 2,
    TT_WRN_STOPPED             = 3,
    TT_WRN_SAME_OBJID            = 4,
    TT_WRN_START_MESSAGE             = 5,
    TT_WRN_NOT_ENABLED             = 6,
    TT_WRN_APPFIRST           = 512,
    TT_WRN_LAST             = 1024,
    TT_ERR_CLASS           = 1025,
    TT_ERR_DBAVAIL            = 1026,
    TT_ERR_DBEXIST           = 1027,
    TT_ERR_FILE          = 1028,
    TT_ERR_INVALID           = 1029,
    TT_ERR_MODE             = 1031,
    TT_ERR_ACCESS           = 1032,
    TT_ERR_NOMP             = 1033,
    TT_ERR_NOTHANDLER             = 1034,
    TT_ERR_NUM             = 1035,
    TT_ERR_OBJID           = 1036,
    TT_ERR_OP            = 1037,
    TT_ERR_OTYPE           = 1038,
    TT_ERR_ADDRESS            = 1039,
    TT_ERR_PATH            = 1040,
    TT_ERR_POINTER           = 1041,
    TT_ERR_PROCID            = 1042,
    TT_ERR_PROPLEN            = 1043,
    TT_ERR_PROPNAME             = 1044,

TT_ERR_PTYPE           = 1045,
TT_ERR_DISPOSITION          = 1046,
TT_ERR_SCOPE           = 1047,
TT_ERR_SESSION           = 1048,
TT_ERR_VTYPE           = 1049,
TT_ERR_NO_VALUE            = 1050,
TT_ERR_INTERNAL           = 1051,
TT_ERR_READONLY            = 1052,
TT_ERR_NO_MATCH             = 1053,
TT_ERR_UNIMP            = 1054,
TT_ERR_OVERFLOW            = 1055,
TT_ERR_PTYPE_START          = 1056,
TT_ERR_CATEGORY            = 1057,
TT_ERR_DBUPDATE            = 1058,
TT_ERR_DBFULL           = 1059,
TT_ERR_DBCONSIST           = 1060,
TT_ERR_STATE           = 1061,
TT_ERR_NOMEM             = 1062,
TT_ERR_SLOTNAME            = 1063,
TT_ERR_XDR            = 1064,
TT_ERR_NETFILE          = 1065,
TT_ERR_TOOLATE            = 1066,
TT_DESKTOP_            = 1100,
TT_DESKTOP_EPERM            = 1101,
TT_DESKTOP_ENOENT            = 1102,
TT_DESKTOP_EINTR           = 1104,
TT_DESKTOP_EIO           = 1105,
TT_DESKTOP_EAGAIN            = 1111,
TT_DESKTOP_ENOMEM             = 1112,
TT_DESKTOP_EACCES            = 1113,
TT_DESKTOP_EFAULT           = 1114,
TT_DESKTOP_EEXIST          = 1117,
TT_DESKTOP_ENODEV             = 1119,
TT_DESKTOP_ENOTDIR            = 1120,
TT_DESKTOP_EISDIR          = 1121,
TT_DESKTOP_EINVAL           = 1122,
TT_DESKTOP_ENFILE           = 1123,
TT_DESKTOP_EMFILE           = 1124,
TT_DESKTOP_ETXTBSY           = 1126,
TT_DESKTOP_EFBIG           = 1127,
TT_DESKTOP_ENOSPC            = 1128,
TT_DESKTOP_EROFS            = 1130,
TT_DESKTOP_EMLINK            = 1131,
TT_DESKTOP_EPIPE          = 1132,
TT_DESKTOP_ENOMSG             = 1135,

    TT_DESKTOP_EDEADLK            = 1145,
    TT_DESKTOP_ECANCELED            = 1147,
    TT_DESKTOP_ENOTSUP            = 1148,
    TT_DESKTOP_ENODATA             = 1161,
    TT_DESKTOP_EPROTO            = 1171,
    TT_DESKTOP_ENOTEMPTY            = 1193,
    TT_DESKTOP_ETIMEDOUT = 1245,
    TT_DESKTOP_EALREADY            = 1249,
    TT_DESKTOP_UNMODIFIED = 1299,
    TT_MEDIA_ERR_SIZE          = 1300,
    TT_MEDIA_ERR_FORMAT            = 1301,
    TT_ERR_APPFIRST          = 1536,
    TT_ERR_LAST           = 2047,
    TT_STATUS_LAST           = 2048
} Tt_status;

Specific values are required because they can be communicated between ToolTalk clients on different platforms, usually via tt_message_status_set(3) and tt_message_status(3).
The header defines the following enumeration data types, with the following members:
Tt_filter_action
      TT_FILTER_CONTINUE, TT_FILTER_LAST, TT_FILTER_STOP

Tt_callback_action
      TT_CALLBACK_CONTINUE ,TT_CALLBACK_LAST ,
      TT_CALLBACK_PROCESSED

Tt_mode
      TT_IN ,TT_INOUT ,TT_MODE_LAST ,TT_MODE_UNDEFINED, TT_OUT

Tt_scope
      TT_BOTH ,TT_FILE, TT_FILE_IN_SESSION, TT_SCOPE_NONE ,TT_SESSION

Tt_class
      TT_CLASS_LAST ,TT_CLASS_UNDEFINED, TT_NOTICE ,TT_REQUEST ,
      TT_OFFER

Tt_category
      TT_CATEGORY_LAST ,TT_CATEGORY_UNDEFINED, TT_HANDLE ,
      TT_HANDLE_PUSH ,TT_HANDLE_ROTATE ,TT_OBSERVE

Tt_address
      TT_ADDRESS_LAST ,TT_HANDLER ,TT_OBJECT ,TT_OTYPE ,TT_PROCEDURE

Tt_disposition
      TT_DISCARD ,TT_QUEUE ,TT_START

Tt_state
      TT_CREATED ,TT_FAILED, TT_HANDLED ,TT_QUEUED ,TT_REJECTED ,
      TT_RETURNED ,TT_ACCEPTED ,TT_ABSTAINED ,TT_SENT ,TT_STARTED ,
      TT_STATE_LAST

Tt_feature
_TT_FEATURE_MULTITHREADED, _TT_FEATURE_LAST
The header defines the following as opaque data types: Tt_message, Tt_pattern.
The header declares the following as functions:
char * tt_X_session(constchar * xdisplaystring);
Tt_status tt_bcontext_join(const char * slotname,
                           const unsigned char * value,
                           int length);
Tt_status tt_bcontext_quit(const char * slotname,
                           const unsigned char * value,
                           int length);
Tt_status tt_close(void);
Tt_status tt_context_join(const char * slotname,
                         const char * value);
Tt_status tt_context_quit(const char * slotname,
                         const char * value);
char * tt_default_file(void);
Tt_status tt_default_file_set(const char * docid);
char * tt_default_procid(void);
Tt_status tt_default_procid_set(const char * procid);
char * tt_thread_procid(void);
Tt_status tt_thread_procid_set(const char * procid);
char * tt_procid_session(constchar * procid);
char * tt_default_ptype(void);
Tt_status tt_default_ptype_set(const char * ptid);
char * tt_default_session(void);
Tt_status tt_default_session_set(const char * sessid);
char * tt_thread_session(void);
Tt_status tt_thread_session_set(const char * sessid);
int tt_error_int(Tt_status ttrc);
void * tt_error_pointer(Tt_statusttrc);
int tt_fd(void);
Tt_status tt_file_copy(const char * oldfilepath,
                      const char * newfilepath);
Tt_status tt_file_destroy(const char * filepath);
Tt_status tt_file_join(const char * filepath);

Tt_status tt_file_move(const char * oldfilepath,
                       const char * newfilepath);
char * tt_file_netfile(constchar * filename);

Tt_status tt_file_objects_query(const char * filepath,
                               Tt_filter_function filter,
                               void * context,
                               void * accumulator);
Tt_status tt_file_quit(const char * filepath);
void tt_free(caddr_t p );

char * tt_host_file_netfile(constchar * host,
                         const char * filename);

char * tt_host_netfile_file(constchar * host,
                         const char * netfilename);
Tt_status tt_icontext_join(const char * slotname, int value);
Tt_status tt_icontext_quit(const char * slotname, int value);
char * tt_initial_session(void);
Tt_status tt_int_error(int return_val);
int tt_is_err(Tt_status s);
caddr_t tt_malloc(size_t s);
int tt_mark(void);
Tt_status tt_message_accept(Tt_message m);
Tt_address tt_message_address(Tt_message m);
Tt_status tt_message_address_set(Tt_message m, Tt_address a);

Tt_status tt_message_arg_add(Tt_message m,
                               Tt_mode n,
                               const char * vtype,
                               const char * value);

Tt_status tt_message_arg_bval(Tt_message m,
                               int n,
                               unsigned char ** value,
                               int * len);

Tt_status tt_message_arg_bval_set(Tt_message m,
                                   int n,
                                   const unsigned char * value,
                                   int len);

Tt_status tt_message_arg_ival(Tt_message m,
                               int n,
                               int * value);

Tt_status tt_message_arg_ival_set(Tt_message m,
                                  int n,
                                  int value);

Tt_mode tt_message_arg_mode(Tt_message m,
                                int n);

char * tt_message_arg_type(Tt_messagem,
                           int n);

char * tt_message_arg_val(Tt_messagem,
                          int n);

Tt_status tt_message_arg_val_set(Tt_message m,
                                  int n,
                                  const char * value);

Tt_status tt_message_arg_xval(Tt_message m,
                               int n,
                               xdrproc_t xdr_proc,
                               void ** value);

Tt_status tt_message_arg_xval_set(Tt_message m,
                                   int n,
                                   xdrproc_t xdr_proc,
                                   void * value);
int tt_message_args_count(Tt_message m);

Tt_status tt_message_barg_add(Tt_message m,
                                Tt_mode n,
                                const char * vtype,
                                const unsigned char * value,
                                int len);

Tt_status tt_message_bcontext_set(Tt_message m,
                                   const char * slotname,
                                   const unsigned char * value,
                                   int length);

Tt_status tt_message_callback_add(Tt_message m,
                                    Tt_message_callback f);
Tt_class tt_message_class(Tt_message m);

Tt_status tt_message_class_set(Tt_message m,
                               Tt_class c);

Tt_status tt_message_context_bval(Tt_message m,
                                   const char * slotname,
                                   unsigned char ** value,
                                   int * len);

Tt_status tt_message_context_ival(Tt_message m,
                                   const char * slotname,
                                   int * value);

Tt_status tt_message_context_set(Tt_message m,
                                  const char * slotname,
                                  const char * value);

char * tt_message_context_slotname(Tt_messagem,
                                    int n);

char * tt_message_context_val(Tt_messagem,
                              const char * slotname);

Tt_status tt_message_context_xval(Tt_message m,
                                   const char * slotname,
                                   xdrproc_t xdr_proc,
                                   void ** value);

int tt_message_contexts_count(Tt_message m);
Tt_message tt_message_create(void);
Tt_message tt_message_create_super(Tt_message m);
Tt_status tt_message_destroy(Tt_message m);
Tt_disposition tt_message_disposition(Tt_message m);
Tt_status tt_message_disposition_set(Tt_message m,
                                      Tt_disposition r);
Tt_status tt_message_fail(Tt_message m);
char * tt_message_file(Tt_messagem);
Tt_status tt_message_file_set(Tt_message m,
                              const char * file);
gid_t tt_message_gid(Tt_message m);
char * tt_message_handler(Tt_messagem);
char * tt_message_handler_ptype(Tt_messagem);
Tt_status tt_message_handler_ptype_set(Tt_message m,
                                         const char * ptid);
Tt_status tt_message_handler_set(Tt_message m,
                                  const char * procid);
Tt_status tt_message_iarg_add(Tt_message m,
                               Tt_mode n,
                               const char * vtype,
                               int value);
Tt_status tt_message_icontext_set(Tt_message m,
                                  const char * slotname,
                                  int value);

char * tt_message_id(Tt_messagem);
char * tt_message_object(Tt_messagem);
Tt_status tt_message_object_set(Tt_message m,
                                 const char * objid);
char * tt_message_op(Tt_messagem);
Tt_status tt_message_op_set(Tt_message m,
                             const char * opname);
int tt_message_opnum(Tt_message m);
char * tt_message_otype(Tt_messagem);
Tt_status tt_message_otype_set(Tt_message m,
                                const char * otype);
Tt_pattern tt_message_pattern(Tt_message m);
char * tt_message_print(Tt_message* m);
Tt_message tt_message_receive(void);
Tt_status tt_message_reject(Tt_message m);
Tt_status tt_message_reply(Tt_message m);
Tt_scope tt_message_scope(Tt_message m);
Tt_status tt_message_scope_set(Tt_message m,
                                Tt_scope s);
Tt_status tt_message_send(Tt_message m);
Tt_status tt_message_send_on_exit(Tt_message m);
char * tt_message_sender(Tt_messagem);
char * tt_message_sender_ptype(Tt_messagem);
Tt_status tt_message_sender_ptype_set(Tt_message m,
                                        const char * ptid);
char * tt_message_session(Tt_messagem);
Tt_status tt_message_session_set(Tt_message m,
                                  const char * sessid);
Tt_state tt_message_state(Tt_message m);
int tt_message_status(Tt_message m);
Tt_status tt_message_status_set(Tt_message m,
                                int status);
char * tt_message_status_string(Tt_messagem);
Tt_status tt_message_status_string_set(Tt_message m,
                                       const char * status_str);

uid_t tt_message_uid(Tt_message m);

void * tt_message_user(Tt_messagem,
                       int key);

Tt_status tt_message_user_set(Tt_message m,
                               int key,
                               void * v );

Tt_status tt_message_xarg_add(Tt_message m,
                                Tt_mode n,
                                const char * vtype,
                                xdrproc_t xdr_proc,
                                void * value);

Tt_status tt_message_xcontext_join(const char * slotname,
                                    xdrproc_t xdr_proc,
                                    void * value);

Tt_status tt_message_xcontext_set(Tt_message m,
                                   const char * slotname,
                                   xdrproc_t xdr_proc,
                                   void * value);
char * tt_netfile_file(constchar * netfilename);

int tt_objid_equal(const char * objid1,
                   const char * objid2);
char * tt_objid_objkey(constchar * objid);

Tt_message tt_onotice_create(const char * objid,
                              const char * op);
char * tt_open(void);

Tt_message tt_orequest_create(const char * objid,
                               const char * op);
char * tt_otype_base(constchar * otype);

char * tt_otype_derived(constchar * otype,
                       int i);
int tt_otype_deriveds_count(const char * otype);

Tt_mode tt_otype_hsig_arg_mode(const char * otype,
                                   int sig,
                                   int arg);

char * tt_otype_hsig_arg_type(constchar * otype,
                              int sig,
                              int arg);

int tt_otype_hsig_args_count(const char * otype,
int sig);
int tt_otype_hsig_count(const char * otype);

char * tt_otype_hsig_op(constchar * otype,
                        int sig);

int tt_otype_is_derived(const char * derivedotype,
                        const char * baseotype);

Tt_status tt_otype_opnum_callback_add(const char * otid,
                                         int opnum,
                                         Tt_message_callback f);

Tt_mode tt_otype_osig_arg_mode(const char * otype,
                                  int sig,
                                  int arg);

char * tt_otype_osig_arg_type(constchar * otype,
                              int sig,
                              int arg);

int tt_otype_osig_args_count(const char * otype,
                             int sig);
int tt_otype_osig_count(const char* otype);

char * tt_otype_osig_op(constchar * otype,
                        int sig);

Tt_status tt_pattern_address_add(Tt_pattern p ,
                                  Tt_address d );

Tt_status tt_pattern_arg_add(Tt_pattern p ,
                             Tt_mode n,
                             const char * vtype,
                             const char * value);

Tt_status tt_pattern_barg_add(Tt_pattern m,
                               Tt_mode n,
                               const char * vtype,
                               const unsigned char * value,
                               int len);

Tt_status tt_pattern_bcontext_add(Tt_pattern p ,
                                   const char * slotname,
                                   const unsigned char * value,
                                   int length);

Tt_status tt_pattern_callback_add(Tt_pattern m,
                                   Tt_message_callback f);
Tt_category tt_pattern_category(Tt_pattern p );

Tt_status tt_pattern_category_set(Tt_pattern p ,
Tt_category c);
Tt_status tt_pattern_class_add(Tt_pattern p ,
                               Tt_class c);

Tt_status tt_pattern_context_add(Tt_pattern p ,
                                 const char * slotname,
                                 const char * value);
Tt_pattern tt_pattern_create(void);
Tt_status tt_pattern_destroy(Tt_pattern p );

Tt_status tt_pattern_disposition_add(Tt_pattern p ,
                                      Tt_disposition r);

Tt_status tt_pattern_file_add(Tt_pattern p ,
                             const char * file);

Tt_status tt_pattern_iarg_add(Tt_pattern m,
                              Tt_mode n,
                              const char * vtype,
                              int value);

Tt_status tt_pattern_icontext_add(Tt_pattern p ,
                                  const char * slotname,
                                  int value);

Tt_status tt_pattern_object_add(Tt_pattern p ,
                                const char * objid);

Tt_status tt_pattern_op_add(Tt_pattern p ,
                             const char * opname);

Tt_status tt_pattern_opnum_add(Tt_pattern p ,
                                 int opnum);

Tt_status tt_pattern_otype_add(Tt_pattern p ,
                                const char * otype);
char * tt_pattern_print(Tt_pattern* p );
Tt_status tt_pattern_register(Tt_pattern p );

Tt_status tt_pattern_scope_add(Tt_pattern p ,
                                Tt_scope s);

Tt_status tt_pattern_sender_add(Tt_pattern p ,
                                 const char * procid);

Tt_status tt_pattern_sender_ptype_add(Tt_pattern p ,
                                        const char * ptid);

Tt_status tt_pattern_session_add(Tt_pattern p ,
                                  const char * sessid);

Tt_status tt_pattern_state_add(Tt_pattern p ,
Tt_state s);
Tt_status tt_pattern_unregister(Tt_pattern p );

void * tt_pattern_user(Tt_patternp ,
                      int key);

Tt_status tt_pattern_user_set(Tt_pattern p ,
                             int key,
                             void * v );

Tt_status tt_pattern_xarg_add(Tt_pattern m,
                              Tt_mode n,
                              const char * vtype,
                              xdrproc_t xdr_proc,
                              void * value);

Tt_status tt_pattern_xcontext_add(Tt_pattern p ,
                                   const char * slotname,
                                   xdrproc_t xdr_proc,
                                   void * value);

Tt_message tt_pnotice_create(Tt_scope scope,
                              const char * op);
Tt_status tt_pointer_error(void * pointer);

Tt_message tt_prequest_create(Tt_scope scope,
                               const char * op);
Tt_status tt_ptr_error(pointer);
Tt_status tt_ptype_declare(const char * ptid);
Tt_status tt_ptype_exists(const char * ptid);

Tt_status tt_ptype_opnum_callback_add(const char * ptid,
                                         int opnum,
                                         Tt_message_callback f);
Tt_status tt_ptype_undeclare(const char * ptid);
void tt_release(int mark);

Tt_status tt_session_bprop(const char * sessid,
                           const char * propname ,
                           int i,
                           unsigned char ** value,
                           int * length);

Tt_status tt_session_bprop_add(const char * sessid,
                                const char * propname ,
                                const unsigned char * value,
                                int length);

Tt_status tt_session_bprop_set(const char * sessid,
                               const char * propname ,
                               const unsigned char * value,
                               int length);

Tt_status tt_session_join(const char * sessid);

char * tt_session_prop(constchar * sessid,
                      const char * propname ,
                      int i);

Tt_status tt_session_prop_add(const char * sessid,
                               const char * propname ,
                               const char * value);

int tt_session_prop_count(const char * sessid,
                          const char * propname );

Tt_status tt_session_prop_set(const char * sessid,
                              const char * propname ,
                              const char * value);

char * tt_session_propname(constchar * sessid,
                            int n);
int tt_session_propnames_count(const char * sessid);
Tt_status tt_session_quit(const char * sessid);

Tt_status tt_session_types_load(const char * session,
                                const char * filename);

Tt_status tt_spec_bprop(const char * objid,
                        const char * propname ,
                        int i,
                        unsigned char ** value,
                        int * length);

Tt_status tt_spec_bprop_add(const char * objid,
                             const char * propname ,
                             const unsigned char * value,
                             int length);

Tt_status tt_spec_bprop_set(const char * objid,
                            const char * propname ,
                            const unsigned char * value,
                            int length);
char * tt_spec_create(constchar * filepath);
Tt_status tt_spec_destroy(const char * objid);
char * tt_spec_file(constchar * objid);

char * tt_spec_move(constchar * objid,
                    const char * newfilepath);

char * tt_spec_prop(constchar * objid,
                   const char * propname ,
                   int i);

Tt_status tt_spec_prop_add(const char * objid,
                            const char * propname ,
                            const char * value);
int tt_spec_prop_count(const char * objid,
                       const char * propname );
Tt_status tt_spec_prop_set(const char * objid,
                           const char * propname ,
                           const char * value);
char * tt_spec_propname(constchar * objid,
                         int n);
int tt_spec_propnames_count(const char * objid);
char * tt_spec_type(constchar * objid);
Tt_status tt_spec_type_set(const char * objid,
                           const char * otid);
Tt_status tt_spec_write(const char * objid);
char * tt_status_message(Tt_statusttrc);
int tt_trace_control(int onoff );
Tt_status tt_xcontext_quit(const char * slotname,
                          xdrproc_t xdr_proc,
                          void * value);
Tt_status tt_feature_enabled(Tt_feature * f);
Tt_status tt_feature_required(Tt_feature * f);
int tt_message_accepters_count(Tt_message * m);
char * tt_message_accepter(Tt_message * m,
                           int n);
int tt_message_rejecters_count(Tt_message * m);
char * tt_message_rejecter(Tt_message * m,
                           int n);
int tt_message_abstainers_count(Tt_message * m);
char * tt_message_abstainer(Tt_message * m,
                            int n);


ToolTalk Definitions 5-14

ToolTalk 1.3
modified 1 March 1996