debian/cdesktop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2c3e1c8e3170c3b9529bb1f93edc003e08ff142d
cdesktop/cde/include/Dt/task.h
Jon Trulson 369308b737 The great includes migration of 2019 (autotools) 
Ok - so one of the steps in building CDE is an early phase called the
includes phase (make includes).  At this point, all of the public
header files are exported to exports/include/Dt, DtI, ...

Then, the software is built using that include dir.

This of course does not work in autotools.  Much of the software does
things like #include <Dt/something.h>, so in order for the build to
succeed, this behavior must be represented/replicated in some way.

It seems the usual way of dealing with this is to place all public
headers (and in some projects, ALL headers) into a toplevel include
directory.

We now do this for all public headers - they have been moved from
wherever they were and placed in the appropriate spot in includes/

This will break the Imake 'make includes' phase unless the Imakefiles
are fixed (remove the HEADERS = stuff, and the incdir defines).  This
has not been done at this point since in reality, once autotools works
properly, there will be no need for the Imake stuff anymore, and I
intend to get rid of it.

This is just a warning for now - Imake builds in this tree will now
fail at the 'includes' stage.

This commit is only the migration.  In upcoming commits, libtt will be
fixed so that the hack being used before to get around this problem is
removed as there will no longer be any need.

And then the autotools work continues...
2019-10-25 17:01:34 -06:00

480 lines
18 KiB
C
Raw Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/* $XConsortium: task.h /main/2 1996/05/09 04:20:28 drk $ */
/*
* COMPONENT_NAME: austext
*
* FUNCTIONS: Pi
* d_close
* d_cmstat
* d_cmtype
* d_connect
* d_costat
* d_cotype
* d_crget
* d_crread
* d_crset
* d_crstat
* d_crtype
* d_crwrite
* d_csmget
* d_csmread
* d_csmset
* d_csmwrite
* d_csoget
* d_csoread
* d_csoset
* d_csowrite
* d_csstat
* d_ctscm
* d_ctsco
* d_ctscr
* d_dbdpath
* d_dbfpath
* d_dblog
* d_dbuserid
* d_delete
* d_destroy
* d_discon
* d_disdel
* d_fillnew
* d_findco
* d_findfm
* d_findlm
* d_findnm
* d_findpm
* d_freeall
* d_gtscm
* d_gtsco
* d_gtscr
* d_gtscs
* d_initfile
* d_initialize
* d_ismember
* d_isowner
* d_keydel
* d_keyexist
* d_keyfind
* d_keyfree
* d_keyfrst
* d_keylast
* d_keylock
* d_keylstat
* d_keynext
* d_keyprev
* d_keyread
* d_keystore
* d_lock
* d_makenew
* d_members
* d_off_opt
* d_on_opt
* d_open
* d_rdcurr
* d_recfree
* d_recfrst
* d_reclast
* d_reclock
* d_reclstat
* d_recnext
* d_recover
* d_recprev
* d_recread
* d_recset
* d_recstat
* d_recwrite
* d_renfile
* d_rerdcurr
* d_retries
* d_rlbclr
* d_rlbset
* d_rlbtst
* d_set_dberr
* d_setdb
* d_setfree
* d_setkey
* d_setlock
* d_setlstat
* d_setmm
* d_setmo
* d_setmr
* d_setom
* d_setoo
* d_setor
* d_setrm
* d_setro
* d_stscm
* d_stsco
* d_stscr
* d_stscs
* d_timeout
* d_trabort
* d_trbegin
* d_trend
* d_utscm
* d_utsco
* d_utscr
* d_utscs
* d_wrcurr
* dt_closetask
* dt_cmstat
* dt_cmtype
* dt_connect
* dt_costat
* dt_cotype
* dt_crget
* dt_crread
* dt_crset
* dt_crtype
* dt_crwrite
* dt_csmget
* dt_csmread
* dt_csmset
* dt_csmwrite
* dt_csoget
* dt_csoread
* dt_csoset
* dt_csowrite
* dt_csstat
* dt_ctbpath
* dt_ctscm
* dt_ctsco
* dt_ctscr
* dt_dbdpath
* dt_dbfpath
* dt_dblog
* dt_dbuserid
* dt_destroy
* dt_discon
* dt_fillnew
* dt_findco
* dt_findfm
* dt_findlm
* dt_findnm
* dt_findpm
* dt_gtscm
* dt_gtsco
* dt_gtscr
* dt_gtscs
* dt_initfile
* dt_ismember
* dt_isowner
* dt_keydel
* dt_keyexist
* dt_keyfind
* dt_keyfree
* dt_keyfrst
* dt_keylast
* dt_keylock
* dt_keylstat
* dt_keynext
* dt_keyprev
* dt_keyread
* dt_keystore
* dt_lock
* dt_makenew
* dt_mapchar
* dt_members
* dt_off_opt
* dt_on_opt
* dt_open
* dt_opentask
* dt_rdcurr
* dt_recfree
* dt_recfrst
* dt_reclast
* dt_reclock
* dt_reclstat
* dt_recover
* dt_recread
* dt_recset
* dt_recstat
* dt_recwrite
* dt_renfile
* dt_rerdcurr
* dt_retries
* dt_set_dberr
* dt_setdb
* dt_setfree
* dt_setkey
* dt_setlock
* dt_setlstat
* dt_setmm
* dt_setmo
* dt_setmr
* dt_setom
* dt_setoo
* dt_setor
* dt_setrm
* dt_setro
* dt_stscm
* dt_stsco
* dt_stscr
* dt_stscs
* dt_timeout
* dt_trbegin
* dt_utscm
* dt_utsco
* dt_utscr
* dt_utscs
* dt_wrcurr
*
* ORIGINS: 157
*
*/
/*----------------------------------------------------------------------------
task.h: db_VISTA task cover function declaration header file
(C) Copyright 1988 by Raima Corporation.
----------------------------------------------------------------------------*/
/* ********************** EDIT HISTORY *******************************
SCR DATE INI DESCRIPTION
----- --------- --- -----------------------------------------------------
571 31-Jan-89 RSC Placed ctbpath inside NO_COUNTRY, not NO_TIMESTAMP
*/
int EXTERNAL_FIXED dt_opentask(P1(DB_TASK *));
int EXTERNAL_FIXED dt_closetask(P1(DB_TASK));
int EXTERNAL_FIXED dt_close(TASK_D1); /* dblfcns.c */
int EXTERNAL_DBN dt_cmstat(P1(int) TASK_Di DBN_Dn); /* cmstat.c */
int EXTERNAL_DBN dt_cmtype(P1(int) Pi(int *) TASK_Di DBN_Dn);
/* cmtype.c */
int EXTERNAL_DBN dt_connect(P1(int) TASK_Di DBN_Dn); /* connect.c */
int EXTERNAL_DBN dt_cotype(P1(int) Pi(int *) TASK_Di DBN_Dn);
/* cotype.c */
int EXTERNAL_DBN dt_crget(P1(DB_ADDR *) TASK_Di DBN_Dn); /* crget.c */
int EXTERNAL_DBN dt_crread(P1(long) Pi(char *) TASK_Di DBN_Dn);
/* crread.c */
int EXTERNAL_DBN dt_crset(P1(DB_ADDR *) TASK_Di DBN_Dn); /* crset.c */
int EXTERNAL_DBN dt_crtype(P1(int *) TASK_Di DBN_Dn); /* crtype.c */
int EXTERNAL_DBN dt_crwrite(P1(long) Pi(char *) TASK_Di DBN_Dn);
/* crwrite.c */
int EXTERNAL_DBN dt_csmget(P1(int) Pi(DB_ADDR *) TASK_Di DBN_Dn);
/* csmget.c */
int EXTERNAL_DBN dt_csmread(P1(int) Pi(long) Pi(char *) TASK_Di DBN_Dn);
/* csmread.c */
int EXTERNAL_DBN dt_csmset(P1(int) Pi(DB_ADDR *) TASK_Di DBN_Dn);
/* csmset.c */
int EXTERNAL_DBN dt_csmwrite(P1(int) Pi(long) Pi(const char *) TASK_Di
DBN_Dn); /* csmwrite.c */
int EXTERNAL_DBN dt_csoget(P1(int) Pi(DB_ADDR *) TASK_Di DBN_Dn);
/* csoget.c */
int EXTERNAL_DBN dt_csoread(P1(int) Pi(long) Pi(char *) TASK_Di DBN_Dn);
/* csoread.c */
int EXTERNAL_DBN dt_csoset(P1(int) Pi(DB_ADDR *) TASK_Di DBN_Dn);
/* csoset.c */
int EXTERNAL_DBN dt_csowrite(P1(int) Pi(long) Pi(const char *) TASK_Di
DBN_Dn); /* csowrite.c */
int EXTERNAL_FIXED dt_ctbpath(P1(const char *) TASK_Di); /* pathfcns.c */
int EXTERNAL_FIXED dt_dbdpath(P1(const char *) TASK_Di ); /* dbdpath.c */
int EXTERNAL_FIXED dt_dbfpath(P1(const char *) TASK_Di ); /* dbfpath.c */
int EXTERNAL_FIXED dt_dblog(P1(const char *) TASK_Di ); /* dblog.c */
int EXTERNAL_FIXED dt_dbuserid(P1(const char *) TASK_Di ); /* dbuserid.c */
int EXTERNAL_DBN dt_delete(TASK_D1 DBN_Dn); /* delete.c */
int EXTERNAL_DBN dt_disdel(TASK_D1 DBN_Dn); /* disdel.c */
int EXTERNAL_DBN dt_recnext(TASK_D1 DBN_Dn); /* recnext.c */
int EXTERNAL_DBN dt_recprev(TASK_D1 DBN_Dn); /* recprev.c */
int EXTERNAL_FIXED dt_destroy(P1(const char *) TASK_Di ); /* destroy.c */
int EXTERNAL_DBN dt_discon(P1(int) TASK_Di DBN_Dn); /* discon.c */
int EXTERNAL_DBN dt_fillnew(P1(int) Pi(const char *) TASK_Di DBN_Dn);
/* fillnew.c */
int EXTERNAL_DBN dt_findco(P1(int) TASK_Di DBN_Dn); /* findco.c */
int EXTERNAL_DBN dt_findfm(P1(int) TASK_Di DBN_Dn); /* findfm.c */
int EXTERNAL_DBN dt_findlm(P1(int) TASK_Di DBN_Dn); /* findlm.c */
int EXTERNAL_DBN dt_findnm(P1(int) TASK_Di DBN_Dn); /* findnm.c */
int EXTERNAL_DBN dt_findpm(P1(int) TASK_Di DBN_Dn); /* findpm.c */
int EXTERNAL_FIXED dt_freeall(TASK_D1); /* dblfcns.c */
int EXTERNAL_DBN dt_initialize(TASK_D1 DBN_Dn); /* initial.c */
int EXTERNAL_DBN dt_initfile(P1(FILE_NO) TASK_Di DBN_Dn); /* initial.c */
int EXTERNAL_DBN dt_ismember(P1(int) TASK_Di DBN_Dn); /* ismember.c */
int EXTERNAL_DBN dt_isowner(P1(int) TASK_Di DBN_Dn); /* isowner.c */
int EXTERNAL_DBN dt_keydel(P1(long) TASK_Di DBN_Dn); /* keydel.c */
int EXTERNAL_DBN dt_keyexist(P1(long) TASK_Di DBN_Dn); /* keyexist.c */
int EXTERNAL_DBN dt_keyfind(P1(long) Pi(const char *) TASK_Di DBN_Dn);
/* keyfind.c */
int EXTERNAL_DBN dt_keyfree(P1(long) TASK_Di DBN_Dn); /* dblfcns.c */
int EXTERNAL_DBN dt_keyfrst(P1(long) TASK_Di DBN_Dn); /* keyfrst.c */
int EXTERNAL_DBN dt_keylast(P1(long) TASK_Di DBN_Dn); /* keylast.c */
int EXTERNAL_DBN dt_keylock(P1(long) Pi(char *) TASK_Di DBN_Dn);
/* dblfcns.c */
int EXTERNAL_DBN dt_keylstat(P1(long) Pi(char *) TASK_Di DBN_Dn);
/* dblfcns.c */
int EXTERNAL_DBN dt_keynext(P1(long) TASK_Di DBN_Dn); /* keynext.c */
int EXTERNAL_DBN dt_keyprev(P1(long) TASK_Di DBN_Dn); /* keyprev.c */
int EXTERNAL_FIXED dt_keyread(P1(char *) TASK_Di ); /* keyfcns.c */
int EXTERNAL_DBN dt_keystore(P1(long) TASK_Di DBN_Dn); /* keystore.c */
int EXTERNAL_DBN dt_lock(P1(int) Pi(LOCK_REQUEST *) TASK_Di DBN_Dn);
/* dblfcns.c */
int EXTERNAL_DBN dt_makenew(P1(int) TASK_Di DBN_Dn); /* makenew.c */
int EXTERNAL_FIXED dt_mapchar(P1(unsigned char) Pi(unsigned char)
Pi(const char *) Pi(unsigned char) TASK_Di);
/* mapchar.c */
int EXTERNAL_DBN dt_members(P1(int) Pi(LONG *) TASK_Di DBN_Dn);
/* members.c */
int EXTERNAL_FIXED dt_off_opt(P1(int) TASK_Di ); /* options.c */
int EXTERNAL_FIXED dt_on_opt(P1(int) TASK_Di ); /* options.c */
int EXTERNAL_FIXED dt_open(P1(const char *) Pi(const char *) TASK_Di);
/* dblfcns.c */
int EXTERNAL_FIXED dt_rdcurr(P1(DB_ADDR **) Pi(int *) TASK_Di);
/* rwcurr.c */
int EXTERNAL_FIXED dt_rerdcurr(P1(DB_ADDR **) TASK_Di); /* rwcurr.c */
int EXTERNAL_FIXED dt_wrcurr(P1(DB_ADDR *) TASK_Di); /* rwcurr.c */
int EXTERNAL_DBN dt_recfree(P1(int) TASK_Di DBN_Dn); /* dblfcns.c */
int EXTERNAL_DBN dt_recfrst(P1(int) TASK_Di DBN_Dn); /* recfrst.c */
int EXTERNAL_DBN dt_reclast(P1(int) TASK_Di DBN_Dn); /* reclast.c */
int EXTERNAL_DBN dt_reclock(P1(int) Pi(char *) TASK_Di DBN_Dn);
/* dblfcns.c */
int EXTERNAL_DBN dt_reclstat(P1(int) Pi(char *) TASK_Di DBN_Dn);
/* dblfcns.c */
int EXTERNAL_FIXED dt_recover(P1(const char *) TASK_Di ); /* recover.c */
int EXTERNAL_DBN dt_recread(P1(char *) TASK_Di DBN_Dn); /* recread.c */
int EXTERNAL_DBN dt_recset(P1(int) TASK_Di DBN_Dn); /* recset.c */
int EXTERNAL_DBN dt_recwrite(P1(const char *) TASK_Di DBN_Dn);
/* recwrite.c */
int EXTERNAL_FIXED dt_renfile(P1(const char *) Pi(FILE_NO)
Pi(const char *) TASK_Di); /* renfile.c */
int EXTERNAL_FIXED dt_retries(P1(int) TASK_Di ); /* dblfcns.c */
int EXTERNAL_FIXED dt_rlbclr(TASK_D1); /* dblfcns.c */
int EXTERNAL_FIXED dt_rlbset(TASK_D1); /* dblfcns.c */
int EXTERNAL_FIXED dt_rlbtst(TASK_D1); /* dblfcns.c */
int EXTERNAL_FIXED dt_set_dberr(P1(FARPROC) TASK_Di); /* dberr.c */
int EXTERNAL_FIXED dt_setdb(P1(int) TASK_Di); /* setdb.c */
int EXTERNAL_DBN dt_setfree(P1(int) TASK_Di DBN_Dn); /* dblfcns.c */
int EXTERNAL_DBN dt_setkey(P1(long) Pi(const char *) TASK_Di DBN_Dn);
/* makenew.c */
int EXTERNAL_DBN dt_setlock(P1(int) Pi(char *) TASK_Di DBN_Dn);
/* dblfcns.c */
int EXTERNAL_DBN dt_setlstat(P1(int) Pi(char *) TASK_Di DBN_Dn);
/* dblfcns.c */
int EXTERNAL_DBN dt_setmm(P1(int) Pi(int) TASK_Di DBN_Dn); /* setmm.c */
int EXTERNAL_DBN dt_setmo(P1(int) Pi(int) TASK_Di DBN_Dn); /* setmo.c */
int EXTERNAL_DBN dt_setmr(P1(int) TASK_Di DBN_Dn); /* setmr.c */
int EXTERNAL_DBN dt_setom(P1(int) Pi(int) TASK_Di DBN_Dn); /* setom.c */
int EXTERNAL_DBN dt_setoo(P1(int) Pi(int) TASK_Di DBN_Dn); /* setoo.c */
int EXTERNAL_DBN dt_setor(P1(int) TASK_Di DBN_Dn); /* setor.c */
int EXTERNAL_DBN dt_setrm(P1(int) TASK_Di DBN_Dn); /* setrm.c */
int EXTERNAL_DBN dt_setro(P1(int) TASK_Di DBN_Dn); /* setro.c */
int EXTERNAL_FIXED dt_timeout(P1(int) TASK_Di ); /* dblfcns.c */
int EXTERNAL_FIXED dt_trabort(TASK_D1); /* dblfcns.c */
int EXTERNAL_FIXED dt_trbegin(P1(const char *) TASK_Di); /* dblfcns.c */
int EXTERNAL_FIXED dt_trend(TASK_D1); /* dblfcns.c */
#ifndef NO_DT_COVER
#define d_close() dt_close(CURRTASK_ONLY)
#define d_dbdpath(a) dt_dbdpath(a CURRTASK_PARM)
#define d_dbfpath(a) dt_dbfpath(a CURRTASK_PARM)
#define d_dblog(a) dt_dblog(a CURRTASK_PARM)
#define d_dbuserid(a) dt_dbuserid(a CURRTASK_PARM)
#define d_destroy(a) dt_destroy(a CURRTASK_PARM)
#define d_freeall() dt_freeall(CURRTASK_ONLY)
#define d_off_opt(a) dt_off_opt(a CURRTASK_PARM)
#define d_on_opt(a) dt_on_opt(a CURRTASK_PARM)
#define d_open(a, b) dt_open(a, b CURRTASK_PARM)
#define d_rdcurr(a, b) dt_rdcurr(a, b CURRTASK_PARM)
#define d_rerdcurr(a, b) dt_rerdcurr(a, b CURRTASK_PARM)
#define d_recover(a) dt_recover(a CURRTASK_PARM)
#define d_renfile(a, b, c) dt_renfile(a, b, c CURRTASK_PARM)
#define d_retries(a) dt_retries(a CURRTASK_PARM)
#define d_set_dberr(a, b) dt_set_dberr(a, b, CURRTASK_PARM)
#define d_setdb(a) dt_setdb(a CURRTASK_PARM)
#define d_timeout(a) dt_timeout(a CURRTASK_PARM)
#define d_trabort() dt_trabort(CURRTASK_ONLY)
#define d_trbegin(a) dt_trbegin(a CURRTASK_PARM)
#define d_trend() dt_trend(CURRTASK_ONLY)
#define d_wrcurr(a) dt_wrcurr(a CURRTASK_PARM)
#define d_cmstat(a , dbn) dt_cmstat(a CURRTASK_PARM , dbn)
#define d_cmtype(a, b , dbn) dt_cmtype(a, b CURRTASK_PARM , dbn)
#define d_connect(a , dbn) dt_connect(a CURRTASK_PARM , dbn)
#define d_cotype(a, b , dbn) dt_cotype(a, b CURRTASK_PARM , dbn)
#define d_crget(a , dbn) dt_crget(a CURRTASK_PARM , dbn)
#define d_crread(a, b , dbn) dt_crread(a, b CURRTASK_PARM , dbn)
#define d_crset(a , dbn) dt_crset(a CURRTASK_PARM , dbn)
#define d_crtype(a , dbn) dt_crtype(a CURRTASK_PARM , dbn)
#define d_crwrite(a, b , dbn) dt_crwrite(a, b CURRTASK_PARM , dbn)
#define d_csmget(a, b , dbn) dt_csmget(a, b CURRTASK_PARM , dbn)
#define d_csmread(a, b, c , dbn) dt_csmread(a, b, c CURRTASK_PARM , dbn)
#define d_csmset(a, b , dbn) dt_csmset(a, b CURRTASK_PARM , dbn)
#define d_csmwrite(a, b, c , dbn) dt_csmwrite(a, b, c CURRTASK_PARM , dbn)
#define d_csoget(a, b , dbn) dt_csoget(a, b CURRTASK_PARM , dbn)
#define d_csoread(a, b, c , dbn) dt_csoread(a, b, c CURRTASK_PARM , dbn)
#define d_csoset(a, b , dbn) dt_csoset(a, b CURRTASK_PARM , dbn)
#define d_csowrite(a, b, c , dbn) dt_csowrite(a, b, c CURRTASK_PARM , dbn)
#define d_delete(, dbn) dt_delete(CURRTASK_ONLY , dbn)
#define d_disdel(, dbn) dt_disdel(CURRTASK_ONLY , dbn)
#define d_recnext(, dbn) dt_recnext(CURRTASK_ONLY , dbn)
#define d_recprev(, dbn) dt_recprev(CURRTASK_ONLY , dbn)
#define d_discon(a , dbn) dt_discon(a CURRTASK_PARM , dbn)
#define d_fillnew(a, b , dbn) dt_fillnew(a, b CURRTASK_PARM , dbn)
#define d_findco(a , dbn) dt_findco(a CURRTASK_PARM , dbn)
#define d_findfm(a , dbn) dt_findfm(a CURRTASK_PARM , dbn)
#define d_findlm(a , dbn) dt_findlm(a CURRTASK_PARM , dbn)
#define d_findnm(a , dbn) dt_findnm(a CURRTASK_PARM , dbn)
#define d_findpm(a , dbn) dt_findpm(a CURRTASK_PARM , dbn)
#define d_initialize(, dbn) dt_initialize(CURRTASK_ONLY , dbn)
#define d_initfile(a , dbn) dt_initfile(a CURRTASK_PARM , dbn)
#define d_ismember(a , dbn) dt_ismember(a CURRTASK_PARM , dbn)
#define d_isowner(a , dbn) dt_isowner(a CURRTASK_PARM , dbn)
#define d_keydel(a , dbn) dt_keydel(a CURRTASK_PARM , dbn)
#define d_keyexist(a , dbn) dt_keyexist(a CURRTASK_PARM , dbn)
#define d_keyfind(a, b , dbn) dt_keyfind(a, b CURRTASK_PARM , dbn)
#define d_keyfree(a , dbn) dt_keyfree(a CURRTASK_PARM , dbn)
#define d_keyfrst(a , dbn) dt_keyfrst(a CURRTASK_PARM , dbn)
#define d_keylast(a , dbn) dt_keylast(a CURRTASK_PARM , dbn)
#define d_keylock(a, b , dbn) dt_keylock(a, b CURRTASK_PARM , dbn)
#define d_keylstat(a, b , dbn) dt_keylstat(a, b CURRTASK_PARM , dbn)
#define d_keynext(a , dbn) dt_keynext(a CURRTASK_PARM , dbn)
#define d_keyprev(a , dbn) dt_keyprev(a CURRTASK_PARM , dbn)
#define d_keyread(a , dbn) dt_keyread(a CURRTASK_PARM)
#define d_keystore(a , dbn) dt_keystore(a CURRTASK_PARM , dbn)
#define d_lock(a, b , dbn) dt_lock(a, b CURRTASK_PARM , dbn)
#define d_makenew(a , dbn) dt_makenew(a CURRTASK_PARM , dbn)
#define d_members(a, b , dbn) dt_members(a, b CURRTASK_PARM , dbn)
#define d_recfree(a , dbn) dt_recfree(a CURRTASK_PARM , dbn)
#define d_recfrst(a , dbn) dt_recfrst(a CURRTASK_PARM , dbn)
#define d_reclast(a , dbn) dt_reclast(a CURRTASK_PARM , dbn)
#define d_reclock(a, b , dbn) dt_reclock(a, b CURRTASK_PARM , dbn)
#define d_reclstat(a, b , dbn) dt_reclstat(a, b CURRTASK_PARM , dbn)
#define d_recread(a , dbn) dt_recread(a CURRTASK_PARM , dbn)
#define d_recset(a , dbn) dt_recset(a CURRTASK_PARM , dbn)
#define d_recwrite(a , dbn) dt_recwrite(a CURRTASK_PARM , dbn)
#define d_setfree(a , dbn) dt_setfree(a CURRTASK_PARM , dbn)
#define d_setkey(a, b , dbn) dt_setkey(a, b CURRTASK_PARM , dbn)
#define d_setlock(a, b , dbn) dt_setlock(a, b CURRTASK_PARM , dbn)
#define d_setlstat(a, b , dbn) dt_setlstat(a, b CURRTASK_PARM , dbn)
#define d_setmm(a, b , dbn) dt_setmm(a, b CURRTASK_PARM , dbn)
#define d_setmo(a, b , dbn) dt_setmo(a, b CURRTASK_PARM , dbn)
#define d_setmr(a , dbn) dt_setmr(a CURRTASK_PARM , dbn)
#define d_setom(a, b , dbn) dt_setom(a, b CURRTASK_PARM , dbn)
#define d_setoo(a, b , dbn) dt_setoo(a, b CURRTASK_PARM , dbn)
#define d_setor(a , dbn) dt_setor(a CURRTASK_PARM , dbn)
#define d_setrm(a , dbn) dt_setrm(a CURRTASK_PARM , dbn)
#define d_setro(a , dbn) dt_setro(a CURRTASK_PARM , dbn)
#endif /* NO_DT_COVER */
/* vpp -nOS2 -dUNIX -nBSD -nVANILLA_BSD -nVMS -nMEMLOCK -nWINDOWS -nFAR_ALLOC task.h */
Reference in New Issue View Git Blame Copy Permalink