⟦3acad4053⟧

TextFile

/* llib-lquipu - quipu lint library */

/*
 *                                NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */

#include "quipu/util.h"
#include "quipu/entry.h"
#include "quipu/connection.h"
#include <sys/types.h>
#include "usr.dirent.h"
#include "quipu/list.h"

check_acl (who,mode,acl,node)
register DN     who;
register int    mode;
struct acl_info *acl;
DN     node;
{
return (check_acl (who,mode,acl,node) );
}

check_known_oids ()
{
(void) check_known_oids () ;
}

unravel_attribute (eptr,error,decode)
Entry eptr;
struct DSError * error;
char decode;
{
return (unravel_attribute (eptr,error,decode) );
}


dsa_init (name)
char * name;
{
return (dsa_init (name) );
}

Entry new_constructor (parent)
DN parent;
{
return (new_constructor (parent) );
}

Entry make_path (dn)
DN dn;
{
return (make_path (dn) );
}

dsa_quit ()
{
(void) dsa_quit () ;
}

directory_free (directory)
Entry directory;
{
(void) directory_free (directory) ;
}

entry_free (entryptr)
Entry entryptr;
{
(void) entry_free (entryptr) ;
}

entry_block_free (block)
Entry block;
{
(void) entry_block_free (block) ;
}

Entry entry_cpy (entryptr)
register Entry entryptr;
{
return (entry_cpy (entryptr) );
}


Entry get_default_entry (parent)
Entry parent;
{
return (get_default_entry (parent) );
}

entry_print (ps,entryptr,format)
PS ps;
Entry entryptr;
int format;
{
(void) entry_print (ps,entryptr,format) ;
}

entry_block_print (ps,block,format)
PS ps;
Entry block;
int format;
{
(void) entry_block_print (ps,block,format) ;
}

directory_print (ps,directory)
PS ps;
Entry directory;
{
(void) directory_print (ps,directory) ;
}

mk_directory (offset,entryptr)
register int offset;
register Entry entryptr;
{
return (mk_directory (offset,entryptr) );
}

header_print (ps,edb,format)
PS ps;
Entry edb;
int format;
{
(void) header_print (ps,edb,format) ;
}

directory_dump (dir,directory,format,level)
char * dir;
Entry directory;
int format;
char level;
{
(void) directory_dump (dir,directory,format,level) ;
}

FILE * file_open (offset,entryptr,mode)
register int offset;
register Entry entryptr;
register char * mode;
{
return (file_open (offset,entryptr,mode) );
}

Entry directory_load (root,level,check)
char * root;
char level;
char check;      /* if TRUE check attributes against mandatory/may list */
{
return (directory_load (root,level,check) );
}


entry_load_kids (entryptr,offset,check)
register Entry entryptr;
register int offset;
char check;
{
	return(entry_load_kids (entryptr,offset,check));
}

file_check (offset,entryptr,dirp)
register int offset;
register Entry entryptr;
DIR * dirp;
{
return (file_check (offset,entryptr,dirp) );
}

Entry subtree_load (parent,dn)
Entry parent;
DN dn;
{
return (subtree_load (parent,dn) );
}

refresh_from_disk(str)
char * str;
{
return (refresh_from_disk(str) );
}

Entry find_entry (object,ca,err,acl_who)
DN                      object;
common_args             *ca;
struct DSError          *err;
DN    acl_who;
{
return (find_entry (object,ca,err,acl_who) );
}

Entry find_master_entry (object,ca,err,acl_who)
DN                      object;
common_args             *ca;
struct DSError          *err;
DN    acl_who;
{
return (find_entry (object,ca,err,acl_who) );
}

Entry really_find_entry (object,err,deref)
DN                      object;
struct DSError          *err;
char deref;
{
return (really_find_entry (object,err,deref) );
}

Entry local_find_entry (object,deref)
DN                      object;
char deref;
{
return (local_find_entry (object,deref) );
}

DN get_copy_dn (entryptr)
Entry entryptr;
{
return (get_copy_dn (entryptr) );
}

constructor_referral (ptr,err,object)
Entry ptr;
struct DSError * err;
DN object;
{
(void) constructor_referral (ptr,err,object) ;
}

Entry definate_no (object,entryptr,err)
DN object;
Entry entryptr;
struct DSError * err;
{
return (definate_no (object,entryptr,err) );
}

struct PSAPaddr * get_dsa_psap (dn)
DN dn;
{
return (get_dsa_psap (dn) );
}

journal (myentry)
Entry myentry;
{
return (journal (myentry) );
}


ContinuationRef cont_ref_new (name,entry_ptr)
DN name;
Entry entry_ptr;
{
return (cont_ref_new (name,entry_ptr) );
}



ContinuationRef cont_ref_parent (name)
DN name;
{
return (cont_ref_parent (name) );
}

add_str_parent (sdn,spsap)
char * sdn, *spsap;
{
(void) add_str_parent (sdn,spsap) ;
}

check_schema (eptr,as,error,decode)
Entry eptr;
Attr_Sequence as;
struct DSError * error;
char decode;
{
return (check_schema (eptr,as,error,decode) );
}

check_schema_type (eptr,attr,error)
Entry eptr;
AttributeType attr;
struct DSError * error;
{
return (check_schema_type (eptr,attr,error) );
}

avs_soundex_key (a)
AV_Sequence a;
{
(void) avs_soundex_key (a) ;
}

fitem_soundex_key (a)
struct filter_item *a;
{
(void) fitem_soundex_key (a) ;
}

soundex_cmp (a,b)
Soundex a [MAXSOUNDEXKEYS][SOUNDEXKEYSIZE];
Soundex b [MAXSOUNDEXKEYS][SOUNDEXKEYSIZE];
{
return (soundex_cmp (a,b) );
}


Entry getentry_block (file,p_parent,fname,check)
FILE * file;
Entry p_parent;
char * fname;
char check;
{
return (getentry_block (file,p_parent,fname,check) );
}


get_header (file,typeptr,versionptr)
FILE * file;
int * typeptr;
char ** versionptr;
{
	return (get_header (file,typeptr,versionptr));
}

Entry get_entries (file,parent,check,version,dtype)
FILE * file;
Entry parent;
char check;
char * version;
int dtype;
{
	return (get_entries (file,parent,check,version,dtype));
}

Entry get_entries_aux (file,parent,check,version,dtype)
FILE * file;
Entry parent;
char check;
char * version;
int dtype;
{
	return (get_entries_aux (file,parent,check,version,dtype));
}

Entry get_entry (file,parent,check,dtype)
FILE * file;
Entry parent;
char check;
int dtype;
{
	return (get_entry (file,parent,check,dtype));
}

Entry get_entry_aux (file,parent,check,dtype)
FILE * file;
Entry parent;
char check;
int dtype;
{
	return (get_entry_aux (file,parent,check,dtype));
}


Attr_Sequence get_attributes (file)
FILE * file;
{
	return (get_attributes (file));
}

Attr_Sequence get_attributes_aux (file)
FILE * file;
{
	return (get_attributes_aux(file));
}


print_arg_error (opt)
PS opt;
{
	return (print_arg_error (opt));
}


int test_arg (x, y, c)		
char           *x;		
char           *y;
int   		c;
{
	return (test_arg (x, y, c));
}


int get_default_service (ca)
CommonArgs * ca;
{
return (get_default_service (ca));
}

int service_control (opt,argc, argv, ca)
PS 		opt;
int             argc;
char          **argv;
CommonArgs     *ca;
{
return (service_control (opt,argc, argv, ca));
}

int do_service_control (opt,argc, argv, ca)
PS 		opt;
int             argc;
char          **argv;
CommonArgs     *ca;
{
return (do_service_control (opt,argc, argv, ca));
}

shuffle_up (argc, argv, start)
register int    argc;
char          **argv;
register int    start;
{
(void) shuffle_up (argc, argv, start);
}

new_service (ptr)
char * ptr;
{
(void) new_service (ptr);
}

struct subordinate * subord_cpy (x)
struct subordinate * x;
{
return (subord_cpy (x));
}

cache_list (ptr, prob,dn,sizelimit)
struct subordinate *ptr;
int             prob;
DN 		dn;
int 		sizelimit;
{
(void) cache_list (ptr, prob,dn,sizelimit);
}

struct list_cache *find_list_cache (dn,sizelimit)
DN dn;
int sizelimit;
{
return (find_list_cache (dn,sizelimit));
}



cache_entry (ptr, complete, vals)
EntryInfo      *ptr;
char            complete;
char            vals;
{
(void) cache_entry (ptr, complete, vals);
}

delete_cache (adn)
DN              adn;
{
(void) delete_cache (adn);
}
DataMuseum.dk

DKUUG/EUUG Conference tapes

⟦3acad4053⟧ TextFile

Derivation

TextFile
