From 58a65f7ff43f462948879c0d17a60b33ae3a25b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Boyer?= Date: Fri, 27 Apr 2012 06:50:22 +0000 Subject: [PATCH] REMOVE libapat git-svn-id: https://www.grenoble.prabi.fr/svn/LECASofts/ecoPrimers/trunk@412 60f365c0-8329-0410-b2a4-ec073aeeaa1d --- src/libapat/CODES/dft_code.h | 14 -- src/libapat/CODES/dna_code.h | 71 ------- src/libapat/CODES/prot_code.h | 51 ----- src/libapat/Gmach.h | 97 --------- src/libapat/Gtypes.h | 104 ---------- src/libapat/Makefile | 24 --- src/libapat/apat.h | 173 ---------------- src/libapat/apat_parse.c | 369 --------------------------------- src/libapat/apat_search.c | 339 ------------------------------ src/libapat/libstki.c | 379 ---------------------------------- src/libapat/libstki.h | 87 -------- 11 files changed, 1708 deletions(-) delete mode 100644 src/libapat/CODES/dft_code.h delete mode 100644 src/libapat/CODES/dna_code.h delete mode 100644 src/libapat/CODES/prot_code.h delete mode 100644 src/libapat/Gmach.h delete mode 100644 src/libapat/Gtypes.h delete mode 100644 src/libapat/Makefile delete mode 100644 src/libapat/apat.h delete mode 100644 src/libapat/apat_parse.c delete mode 100644 src/libapat/apat_search.c delete mode 100644 src/libapat/libstki.c delete mode 100644 src/libapat/libstki.h diff --git a/src/libapat/CODES/dft_code.h b/src/libapat/CODES/dft_code.h deleted file mode 100644 index b9caf28..0000000 --- a/src/libapat/CODES/dft_code.h +++ /dev/null @@ -1,14 +0,0 @@ -/* ----------------------------------------------- */ -/* dft_pat_seq_code.h */ -/* default alphabet encoding for alpha */ -/* ----------------------------------------------- */ - - 0x00000001 /* A */, 0x00000002 /* B */, 0x00000004 /* C */, - 0x00000008 /* D */, 0x00000010 /* E */, 0x00000020 /* F */, - 0x00000040 /* G */, 0x00000080 /* H */, 0x00000100 /* I */, - 0x00000200 /* J */, 0x00000400 /* K */, 0x00000800 /* L */, - 0x00001000 /* M */, 0x00002000 /* N */, 0x00004000 /* O */, - 0x00008000 /* P */, 0x00010000 /* Q */, 0x00020000 /* R */, - 0x00040000 /* S */, 0x00080000 /* T */, 0x00100000 /* U */, - 0x00200000 /* V */, 0x00400000 /* W */, 0x00800000 /* X */, - 0x01000000 /* Y */, 0x02000000 /* Z */ diff --git a/src/libapat/CODES/dna_code.h b/src/libapat/CODES/dna_code.h deleted file mode 100644 index 0febf41..0000000 --- a/src/libapat/CODES/dna_code.h +++ /dev/null @@ -1,71 +0,0 @@ -/* ----------------------------------------------- */ -/* dna_code.h */ -/* alphabet encoding for dna/rna */ -/* ----------------------------------------- */ -/* IUPAC encoding */ -/* ----------------------------------------- */ -/* G/A/T/C */ -/* U=T */ -/* R=AG */ -/* Y=CT */ -/* M=AC */ -/* K=GT */ -/* S=CG */ -/* W=AT */ -/* H=ACT */ -/* B=CGT */ -/* V=ACG */ -/* D=AGT */ -/* N=ACGT */ -/* X=ACGT */ -/* EFIJLOPQZ not recognized */ -/* ----------------------------------------- */ -/* dual encoding */ -/* ----------------------------------------- */ -/* A=ADHMNRVW */ -/* B=BCDGHKMNRSTUVWY */ -/* C=BCHMNSVY */ -/* D=ABDGHKMNRSTUVWY */ -/* G=BDGKNRSV */ -/* H=ABCDHKMNRSTUVWY */ -/* K=BDGHKNRSTUVWY */ -/* M=ABCDHMNRSVWY */ -/* N=ABCDGHKMNRSTUVWY */ -/* R=ABDGHKMNRSVW */ -/* S=BCDGHKMNRSVY */ -/* T=BDHKNTUWY */ -/* U=BDHKNTUWY */ -/* V=ABCDGHKMNRSVWY */ -/* W=ABDHKMNRTUVWY */ -/* X=ABCDGHKMNRSTUVWY */ -/* Y=BCDHKMNSTUVWY */ -/* EFIJLOPQZ not recognized */ -/* ----------------------------------------------- */ - -#ifndef USE_DUAL - - /* IUPAC */ - - 0x00000001 /* A */, 0x00080044 /* B */, 0x00000004 /* C */, - 0x00080041 /* D */, 0x00000000 /* E */, 0x00000000 /* F */, - 0x00000040 /* G */, 0x00080005 /* H */, 0x00000000 /* I */, - 0x00000000 /* J */, 0x00080040 /* K */, 0x00000000 /* L */, - 0x00000005 /* M */, 0x00080045 /* N */, 0x00000000 /* O */, - 0x00000000 /* P */, 0x00000000 /* Q */, 0x00000041 /* R */, - 0x00000044 /* S */, 0x00080000 /* T */, 0x00080000 /* U */, - 0x00000045 /* V */, 0x00080001 /* W */, 0x00080045 /* X */, - 0x00080004 /* Y */, 0x00000000 /* Z */ - -#else - /* DUAL */ - - 0x00623089 /* A */, 0x017e34ce /* B */, 0x01243086 /* C */, - 0x017e34cb /* D */, 0x00000000 /* E */, 0x00000000 /* F */, - 0x0026244a /* G */, 0x017e348f /* H */, 0x00000000 /* I */, - 0x00000000 /* J */, 0x017e24ca /* K */, 0x00000000 /* L */, - 0x0166308f /* M */, 0x017e34cf /* N */, 0x00000000 /* O */, - 0x00000000 /* P */, 0x00000000 /* Q */, 0x006634cb /* R */, - 0x012634ce /* S */, 0x0158248a /* T */, 0x0158248a /* U */, - 0x016634cf /* V */, 0x017a348b /* W */, 0x017e34cf /* X */, - 0x017c348e /* Y */, 0x00000000 /* Z */ -#endif diff --git a/src/libapat/CODES/prot_code.h b/src/libapat/CODES/prot_code.h deleted file mode 100644 index edcdfc1..0000000 --- a/src/libapat/CODES/prot_code.h +++ /dev/null @@ -1,51 +0,0 @@ -/* ----------------------------------------------- */ -/* prot_code.h */ -/* alphabet encoding for proteins */ -/* ----------------------------------------- */ -/* IUPAC encoding */ -/* ----------------------------------------- */ -/* B=DN */ -/* Z=EQ */ -/* X=any - {X} */ -/* JOU not recognized */ -/* ----------------------------------------- */ -/* dual encoding */ -/* ----------------------------------------- */ -/* B=BDN */ -/* D=BD */ -/* E=EZ */ -/* N=BN */ -/* Q=QZ */ -/* X=any - {X} */ -/* Z=EQZ */ -/* JOU not recognized */ -/* ----------------------------------------------- */ - -#ifndef USE_DUAL - - /* IUPAC */ - - 0x00000001 /* A */, 0x00002008 /* B */, 0x00000004 /* C */, - 0x00000008 /* D */, 0x00000010 /* E */, 0x00000020 /* F */, - 0x00000040 /* G */, 0x00000080 /* H */, 0x00000100 /* I */, - 0x00000000 /* J */, 0x00000400 /* K */, 0x00000800 /* L */, - 0x00001000 /* M */, 0x00002000 /* N */, 0x00000000 /* O */, - 0x00008000 /* P */, 0x00010000 /* Q */, 0x00020000 /* R */, - 0x00040000 /* S */, 0x00080000 /* T */, 0x00000000 /* U */, - 0x00200000 /* V */, 0x00400000 /* W */, 0x037fffff /* X */, - 0x01000000 /* Y */, 0x00010010 /* Z */ - -#else - /* DUAL */ - - 0x00000001 /* A */, 0x0000200a /* B */, 0x00000004 /* C */, - 0x0000000a /* D */, 0x02000010 /* E */, 0x00000020 /* F */, - 0x00000040 /* G */, 0x00000080 /* H */, 0x00000100 /* I */, - 0x00000000 /* J */, 0x00000400 /* K */, 0x00000800 /* L */, - 0x00001000 /* M */, 0x00002002 /* N */, 0x00000000 /* O */, - 0x00008000 /* P */, 0x02010000 /* Q */, 0x00020000 /* R */, - 0x00040000 /* S */, 0x00080000 /* T */, 0x00000000 /* U */, - 0x00200000 /* V */, 0x00400000 /* W */, 0x037fffff /* X */, - 0x01000000 /* Y */, 0x02010010 /* Z */ - -#endif diff --git a/src/libapat/Gmach.h b/src/libapat/Gmach.h deleted file mode 100644 index 8fb1c69..0000000 --- a/src/libapat/Gmach.h +++ /dev/null @@ -1,97 +0,0 @@ -/* ---------------------------------------------------------------- */ -/* Copyright (c) Atelier de BioInformatique */ -/* @file: Gmach.h */ -/* @desc: machine dependant setup */ -/* @+ *should* be included in all ABI softs */ -/* */ -/* @history: */ -/* @+ : Jul 95 : MWC first draft */ -/* @+ : Jan 96 : adapted to Pwg */ -/* @+ : Nov 00 : adapted to Mac_OS_X */ -/* ---------------------------------------------------------------- */ - -#ifndef _H_Gmach - - /* OS names */ - -#define _H_Gmach - - /* Macintosh Classic */ - /* Think C environment */ -#ifdef THINK_C -#define MACINTOSH -#define MAC_OS_C -#endif - - - /* Macintosh Classic */ - /* Code-Warrior */ -#ifdef __MWERKS__ -#define MACINTOSH -#define MAC_OS_C -#endif - - /* Macintosh OS-X */ -#ifdef MAC_OS_X -#define MACINTOSH -#define UNIX -#define UNIX_BSD -#endif - - /* LINUX */ -#ifdef LINUX -#define UNIX -#define UNIX_BSD -#endif - - /* other Unix Boxes */ - /* SunOS / Solaris */ -#ifdef SUN -#define UNIX -#ifdef SOLARIS -#define UNIX_S7 -#else -#define UNIX_BSD -#endif -#endif - - /* SGI Irix */ -#ifdef SGI -#define UNIX -#define UNIX_S7 -#endif - -/* ansi setup */ -/* for unix machines see makefile */ - -#ifndef PROTO -#define PROTO 1 -#endif - -#ifndef ANSI_PROTO -#define ANSI_PROTO PROTO -#endif - -#ifndef ANSI_STR -#define ANSI_STR 1 -#endif - -/* unistd.h header file */ - -#ifdef UNIX -#define HAS_UNISTD_H -#endif - -/* getopt.h header file */ - -#ifdef MAC_OS_C -#define HAS_GETOPT_H "getopt.h" -#endif - -#ifdef SGI -#define HAS_GETOPT_H -#endif - - - -#endif diff --git a/src/libapat/Gtypes.h b/src/libapat/Gtypes.h deleted file mode 100644 index 9bf5a93..0000000 --- a/src/libapat/Gtypes.h +++ /dev/null @@ -1,104 +0,0 @@ -/* ---------------------------------------------------------------- */ -/* Copyright (c) Atelier de BioInformatique */ -/* @file: Gtypes.h */ -/* @desc: general & machine dependant types */ -/* @+ *should* be included in all ABI softs */ -/* */ -/* @history: */ -/* @+ : Jan 91 : MWC first draft */ -/* @+ : Jul 95 : Gmach addition */ -/* ---------------------------------------------------------------- */ - -#define _H_Gtypes - -#ifndef _H_Gmach -#include "Gmach.h" -#endif - -#ifndef NULL -#include /* is the official NULL here ? */ -#endif - -/* ==================================================== */ -/* constantes */ -/* ==================================================== */ - -#ifndef PROTO -#define PROTO 1 /* prototypes flag */ -#endif - -#ifdef MAC_OS_C -#define Vrai true /* TC boolean values */ -#define Faux false /* */ -#else -#define Vrai 0x1 /* bool values = TRUE */ -#define Faux 0x0 /* = FALSE */ -#endif - -#define Nil NULL /* nil pointer */ - -#define kBigInt16 0x7fff /* plus grand 16 bits signe */ -#define kBigInt32 0x7fffffff /* plus grand 32 bits signe */ -#define kBigUInt16 0xffff /* plus grand 16 bits ~signe */ -#define kBigUInt32 0xffffffff /* plus grand 32 bits ~signe */ - -#ifdef MAC_OS_C -/* ==================================================== */ -/* Types (for Macintosh ThinK C || MWerks) */ -/* ==================================================== */ - - /* --- specific sizes --------- */ -typedef long Int32; /* Int32 = 32 bits signe */ -typedef unsigned long UInt32; /* UInt32 = 32 bits ~signe */ -typedef short Int16; /* Int16 = 16 bits signe */ -typedef unsigned short UInt16; /* UInt32 = 16 bits ~signe */ -typedef char Int8; /* Int8 = 8 bits signe */ -typedef unsigned char UInt8; /* UInt8 = 8 bits ~signe */ - - /* --- default types ---------- */ - -typedef Boolean Bool; /* booleen */ - -typedef long Int; /* 'natural' int (>= 32 bits) */ - -typedef void *Ptr; /* pointeur */ - -#elif ((defined SUN) || (defined SGI) || (defined UNIX)) -/* ==================================================== */ -/* Types (for Sun & Iris - 32 bits machines) */ -/* ==================================================== */ - - /* --- specific sizes --------- */ -typedef int Int32; /* Int32 = 32 bits signe */ -typedef unsigned int UInt32; /* UInt32 = 32 bits ~signe */ -typedef short Int16; /* Int16 = 16 bits signe */ -typedef unsigned short UInt16; /* UInt32 = 16 bits ~signe */ -typedef char Int8; /* Int8 = 8 bits signe */ -typedef unsigned char UInt8; /* UInt8 = 8 bits ~signe */ - - /* --- default types ---------- */ - -typedef int Bool; /* booleen (int for ANSI) */ - -typedef int Int; /* 'natural' int (>= 32 bits) */ - -typedef void *Ptr; /* pointeur */ - -#else -/* ==================================================== */ -/* Types (for undefined machines) */ -/* ==================================================== */ - -#error undefined MACHINE - -#endif - -/* ==================================================== */ -/* special macro for prototypes */ -/* ==================================================== */ - -#if PROTO -#define P(s) s -#else -#define P(s) () -#endif diff --git a/src/libapat/Makefile b/src/libapat/Makefile deleted file mode 100644 index b4dc9be..0000000 --- a/src/libapat/Makefile +++ /dev/null @@ -1,24 +0,0 @@ - -SOURCES = apat_parse.c \ - apat_search.c \ - libstki.c - -SRCS=$(SOURCES) - - -OBJECTS= $(patsubst %.c,%.o,$(SOURCES)) - -LIBFILE= libapat.a -RANLIB=ranlib - - -include ../global.mk - -all: $(LIBFILE) - -clean: - rm -rf $(OBJECTS) $(LIBFILE) - -$(LIBFILE): $(OBJECTS) - ar -cr $@ $? - $(RANLIB) $@ diff --git a/src/libapat/apat.h b/src/libapat/apat.h deleted file mode 100644 index eaa06df..0000000 --- a/src/libapat/apat.h +++ /dev/null @@ -1,173 +0,0 @@ -/* ==================================================== */ -/* Copyright (c) Atelier de BioInformatique */ -/* Dec. 94 */ -/* File: apat.h */ -/* Purpose: pattern scan */ -/* History: */ -/* 28/12/94 : ascan first version */ -/* 14/05/99 : last revision */ -/* ==================================================== */ - -#ifndef _H_Gtypes -#include "Gtypes.h" -#endif - -#ifndef _H_libstki -#include "libstki.h" -#endif - -#define H_apat - -/* ----------------------------------------------- */ -/* constantes */ -/* ----------------------------------------------- */ - -#ifndef BUFSIZ -#define BUFSIZ 1024 /* io buffer size */ -#endif - -#define MAX_NAME_LEN BUFSIZ /* max length of sequence name */ - -#define ALPHA_LEN 26 /* alphabet length */ - /* *DO NOT* modify */ - -#define MAX_PATTERN 4 /* max # of patterns */ - /* *DO NOT* modify */ - -#define MAX_PAT_LEN 32 /* max pattern length */ - /* *DO NOT* modify */ - -#define MAX_PAT_ERR 32 /* max # of errors */ - /* *DO NOT* modify */ - -#define PATMASK 0x3ffffff /* mask for 26 symbols */ - /* *DO NOT* modify */ - -#define OBLIBIT 0x4000000 /* bit 27 to 1 -> oblig. pos */ - /* *DO NOT* modify */ - - /* mask for position */ -#define ONEMASK 0x80000000 /* mask for highest position */ - - /* masks for Levenhstein edit */ -#define OPER_IDT 0x00000000 /* identity */ -#define OPER_INS 0x40000000 /* insertion */ -#define OPER_DEL 0x80000000 /* deletion */ -#define OPER_SUB 0xc0000000 /* substitution */ - -#define OPER_SHFT 30 /* shift */ - - /* Levenhstein Opcodes */ -#define SOPER_IDT 0x0 /* identity */ -#define SOPER_INS 0x1 /* insertion */ -#define SOPER_DEL 0x2 /* deletion */ -#define SOPER_SUB 0x3 /* substitution */ - - /* Levenhstein Opcodes masks */ -#define OPERMASK 0xc0000000 /* mask for Opcodes */ -#define NOPERMASK 0x3fffffff /* negate of previous */ - - /* special chars in pattern */ -#define PATCHARS "[]!#" - - /* 26 letter alphabet */ - /* in alphabetical order */ - -#define ORD_ALPHA "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - - /* protein alphabet */ - -#define PROT_ALPHA "ACDEFGHIKLMNPQRSTVWY" - - /* dna/rna alphabet */ - -#define DNA_ALPHA "ABCDGHKMNRSTUVWXY" - - -/* ----------------------------------------------- */ -/* data structures */ -/* ----------------------------------------------- */ - - /* -------------------- */ -typedef enum { /* data encoding */ - /* -------------------- */ - alpha = 0, /* [A-Z] */ - dna, /* IUPAC DNA */ - protein /* IUPAC proteins */ -} CodType; - - /* -------------------- */ -typedef struct { /* sequence */ - /* -------------------- */ - char *name; /* sequence name */ - Int32 seqlen; /* sequence length */ - Int32 seqsiz; /* sequence buffer size */ - Int32 datsiz; /* data buffer size */ - Int32 circular; - UInt8 *data; /* data buffer */ - char *cseq; /* sequence buffer */ - StackiPtr hitpos[MAX_PATTERN]; /* stack of hit pos. */ - StackiPtr hiterr[MAX_PATTERN]; /* stack of errors */ -} Seq, *SeqPtr; - - /* -------------------- */ -typedef struct { /* pattern */ - /* -------------------- */ - int patlen; /* pattern length */ - int maxerr; /* max # of errors */ - char *cpat; /* pattern string */ - Int32 *patcode; /* encoded pattern */ - UInt32 *smat; /* S matrix */ - UInt32 omask; /* oblig. bits mask */ - Bool hasIndel; /* are indels allowed */ - Bool ok; /* is pattern ok */ -} Pattern, *PatternPtr; - -/* ----------------------------------------------- */ -/* macros */ -/* ----------------------------------------------- */ - -#ifndef NEW -#define NEW(typ) (typ*)malloc(sizeof(typ)) -#define NEWN(typ, dim) (typ*)malloc((unsigned long)(dim) * sizeof(typ)) -#define REALLOC(typ, ptr, dim) (typ*)realloc((void *) (ptr), (unsigned long)(dim) * sizeof(typ)) -#define FREE(ptr) free((void *) ptr) -#endif - -/* ----------------------------------------------- */ -/* prototypes */ -/* ----------------------------------------------- */ - - /* apat_seq.c */ - -SeqPtr FreeSequence (SeqPtr pseq); -SeqPtr NewSequence (void); -int ReadNextSequence (SeqPtr pseq); -int WriteSequence (FILE *filou , SeqPtr pseq); - - /* apat_parse.c */ - -Int32 *GetCode (CodType ctype); -int CheckPattern (Pattern *ppat); -int EncodePattern (Pattern *ppat, CodType ctype); -int ReadPattern (Pattern *ppat); -void PrintDebugPattern (Pattern *ppat); - - /* apat_search.c */ - -int CreateS (Pattern *ppat, Int32 lalpha); -Int32 ManberNoErr (Seq *pseq , Pattern *ppat, int patnum,int begin,int length); -Int32 ManberSub (Seq *pseq , Pattern *ppat, int patnum,int begin,int length); -Int32 ManberIndel (Seq *pseq , Pattern *ppat, int patnum,int begin,int length); -Int32 ManberAll (Seq *pseq , Pattern *ppat, int patnum,int begin,int length); -Int32 NwsPatAlign (Seq *pseq , Pattern *ppat, Int32 nerr , - Int32 *reslen , Int32 *reserr); - - /* apat_sys.c */ - -float UserCpuTime (int reset); -float SysCpuTime (int reset); -char *StrCpuTime (int reset); -void Erreur (char *msg , int stat); -int AccessFile (char *path, char *mode); - diff --git a/src/libapat/apat_parse.c b/src/libapat/apat_parse.c deleted file mode 100644 index 43cda48..0000000 --- a/src/libapat/apat_parse.c +++ /dev/null @@ -1,369 +0,0 @@ -/* ==================================================== */ -/* Copyright (c) Atelier de BioInformatique */ -/* Mar. 92 */ -/* File: apat_parse.c */ -/* Purpose: Codage du pattern */ -/* History: */ -/* 00/07/94 : first version (stanford) */ -/* 00/11/94 : revised for DNA/PROTEIN */ -/* 30/12/94 : modified EncodePattern */ -/* for manber search */ -/* 14/05/99 : indels added */ -/* ==================================================== */ - -#include -#include -#include -#include - -#include "Gtypes.h" -#include "apat.h" - /* -------------------- */ - /* default char */ - /* encodings */ - /* -------------------- */ - -static Int32 sDftCode[] = { - -#include "CODES/dft_code.h" - -}; - /* -------------------- */ - /* char encodings */ - /* IUPAC */ - /* -------------------- */ - - /* IUPAC Proteins */ -static Int32 sProtCode[] = { - -#include "CODES/prot_code.h" - -}; - /* IUPAC Dna/Rna */ -static Int32 sDnaCode[] = { - -#include "CODES/dna_code.h" - -}; - - -/* -------------------------------------------- */ -/* internal replacement of gets */ -/* -------------------------------------------- */ -static char *sGets(char *buffer, int size) { - - char *ebuf; - - if (! fgets(buffer, size-1, stdin)) - return NULL; - - /* remove trailing line feed */ - - ebuf = buffer + strlen(buffer); - - while (--ebuf >= buffer) { - if ((*ebuf == '\n') || (*ebuf == '\r')) - *ebuf = '\000'; - else - break; - } - - return buffer; -} - -/* -------------------------------------------- */ -/* returns actual code associated to type */ -/* -------------------------------------------- */ - -Int32 *GetCode(CodType ctype) -{ - Int32 *code = sDftCode; - - switch (ctype) { - case dna : code = sDnaCode ; break; - case protein : code = sProtCode ; break; - default : code = sDftCode ; break; - } - - return code; -} - -/* -------------------------------------------- */ - -#define BAD_IF(tst) if (tst) return 0 - -int CheckPattern(Pattern *ppat) -{ - int lev; - char *pat; - - pat = ppat->cpat; - - BAD_IF (*pat == '#'); - - for (lev = 0; *pat ; pat++) - - switch (*pat) { - - case '[' : - BAD_IF (lev); - BAD_IF (*(pat+1) == ']'); - lev++; - break; - - case ']' : - lev--; - BAD_IF (lev); - break; - - case '!' : - BAD_IF (lev); - BAD_IF (! *(pat+1)); - BAD_IF (*(pat+1) == ']'); - break; - - case '#' : - BAD_IF (lev); - BAD_IF (*(pat-1) == '['); - break; - - default : - if (! isupper(*pat)) - return 0; - break; - } - - return (lev ? 0 : 1); -} - -#undef BAD_IF - - -/* -------------------------------------------- */ -static char *skipOblig(char *pat) -{ - return (*(pat+1) == '#' ? pat+1 : pat); -} - -/* -------------------------------------------- */ -static char *splitPattern(char *pat) -{ - switch (*pat) { - - case '[' : - for (; *pat; pat++) - if (*pat == ']') - return skipOblig(pat); - return NULL; - break; - - case '!' : - return splitPattern(pat+1); - break; - - } - - return skipOblig(pat); -} - -/* -------------------------------------------- */ -static Int32 valPattern(char *pat, Int32 *code) -{ - Int32 val; - - switch (*pat) { - - case '[' : - return valPattern(pat+1, code); - break; - - case '!' : - val = valPattern(pat+1, code); - return (~val & PATMASK); - break; - - default : - val = 0x0; - while (isupper(*pat)) { - val |= code[*pat - 'A']; - pat++; - } - return val; - } - - return 0x0; -} - -/* -------------------------------------------- */ -static Int32 obliBitPattern(char *pat) -{ - return (*(pat + strlen(pat) - 1) == '#' ? OBLIBIT : 0x0); -} - - -/* -------------------------------------------- */ -static int lenPattern(char *pat) -{ - int lpat; - - lpat = 0; - - while (*pat) { - - if (! (pat = splitPattern(pat))) - return 0; - - pat++; - - lpat++; - } - - return lpat; -} - -/* -------------------------------------------- */ -/* Interface */ -/* -------------------------------------------- */ - -/* -------------------------------------------- */ -/* encode un pattern */ -/* -------------------------------------------- */ -int EncodePattern(Pattern *ppat, CodType ctype) -{ - int pos, lpat; - Int32 *code; - char *pp, *pa, c; - - ppat->ok = Faux; - - code = GetCode(ctype); - - ppat->patlen = lpat = lenPattern(ppat->cpat); - - if (lpat <= 0) - return 0; - - if (! (ppat->patcode = NEWN(Int32, lpat))) - return 0; - - pa = pp = ppat->cpat; - - pos = 0; - - while (*pa) { - - pp = splitPattern(pa); - - c = *++pp; - - *pp = '\000'; - - ppat->patcode[pos++] = valPattern(pa, code) | obliBitPattern(pa); - - *pp = c; - - pa = pp; - } - - ppat->ok = Vrai; - - return lpat; -} - -/* -------------------------------------------- */ -/* remove blanks */ -/* -------------------------------------------- */ -static char *RemBlanks(char *s) -{ - char *sb, *sc; - - for (sb = sc = s ; *sb ; sb++) - if (! isspace(*sb)) - *sc++ = *sb; - - return s; -} - -/* -------------------------------------------- */ -/* count non blanks */ -/* -------------------------------------------- */ -static Int32 CountAlpha(char *s) -{ - Int32 n; - - for (n = 0 ; *s ; s++) - if (! isspace(*s)) - n++; - - return n; -} - - -/* -------------------------------------------- */ -/* lit un pattern */ -/* #mis */ -/* ligne starting with '/' are comments */ -/* -------------------------------------------- */ -int ReadPattern(Pattern *ppat) -{ - int val; - char *spac; - char buffer[BUFSIZ]; - - ppat->ok = Vrai; - - if (! sGets(buffer, sizeof(buffer))) - return 0; - - if (*buffer == '/') - return ReadPattern(ppat); - - if (! CountAlpha(buffer)) - return ReadPattern(ppat); - - for (spac = buffer ; *spac ; spac++) - if ((*spac == ' ') || (*spac == '\t')) - break; - - ppat->ok = Faux; - - if (! *spac) - return 0; - - if (sscanf(spac, "%d", &val) != 1) - return 0; - - ppat->hasIndel = (val < 0); - - ppat->maxerr = ((val >= 0) ? val : -val); - - *spac = '\000'; - - (void) RemBlanks(buffer); - - if ((ppat->cpat = NEWN(char, strlen(buffer)+1))) - strcpy(ppat->cpat, buffer); - - ppat->ok = (ppat->cpat != NULL); - - return (ppat->ok ? 1 : 0); -} - -/* -------------------------------------------- */ -/* ecrit un pattern - Debug - */ -/* -------------------------------------------- */ -void PrintDebugPattern(Pattern *ppat) -{ - int i; - - printf("Pattern : %s\n", ppat->cpat); - printf("Encoding : \n\t"); - - for (i = 0 ; i < ppat->patlen ; i++) { - printf("0x%8.8x ", ppat->patcode[i]); - if (i%4 == 3) - printf("\n\t"); - } - printf("\n"); -} - diff --git a/src/libapat/apat_search.c b/src/libapat/apat_search.c deleted file mode 100644 index f0dd394..0000000 --- a/src/libapat/apat_search.c +++ /dev/null @@ -1,339 +0,0 @@ -/* ==================================================== */ -/* Copyright (c) Atelier de BioInformatique */ -/* Dec. 94 */ -/* File: apat_search.c */ -/* Purpose: recherche du pattern */ -/* algorithme de Baeza-Yates/Gonnet */ -/* Manber (agrep) */ -/* History: */ -/* 07/12/94 : first version */ -/* 28/12/94 : revised version */ -/* 14/05/99 : last revision */ -/* ==================================================== */ - -#if 0 -#ifndef THINK_C -#include -#endif -#endif - -#include -#include -#include - -#include "Gtypes.h" -#include "libstki.h" -#include "apat.h" - -#define POP PopiOut -#define PUSH PushiIn -#define TOPCURS CursiToTop -#define DOWNREAD ReadiDown - -#define KRONECK(x, msk) ((~x & msk) ? 0 : 1) -#define MIN(x, y) ((x) < (y) ? (x) : (y)) - -/* -------------------------------------------- */ -/* Construction de la matrice S */ -/* -------------------------------------------- */ - -int CreateS(Pattern *ppat, Int32 lalpha) -{ - Int32 i, j, indx; - UInt32 pindx, amask, omask, *smat; - - ppat->ok = Faux; - - omask = 0x0L; - - if (! (smat = NEWN(UInt32, lalpha))) - return 0; - - for (i = 0 ; i < lalpha ; i++) - smat[i] = 0x0; - - for (i = ppat->patlen - 1, amask = 0x1L ; i >= 0 ; i--, amask <<= 1) { - - indx = ppat->patcode[i]; - - if (ppat->patcode[i] & OBLIBIT) - omask |= amask; - - for (j = 0, pindx = 0x1L ; j < lalpha ; j++, pindx <<= 1) - if (indx & pindx) - smat[j] |= amask; - } - - ppat->smat = smat; - - ppat->omask = omask; - - ppat->ok = Vrai; - - return 1; - -} - -/* -------------------------------------------- */ -/* Baeza-Yates/Manber algorithm */ -/* NoError */ -/* -------------------------------------------- */ -Int32 ManberNoErr(Seq *pseq, Pattern *ppat, int patnum,int begin,int length) -{ - UInt32 pos; - UInt32 smask, r; - UInt8 *data; - StackiPtr *stkpos, *stkerr; - UInt32 end; - - end = begin + length; - end = (end <= (size_t)(pseq->seqlen+pseq->circular)) ? end:(size_t)(pseq->seqlen+pseq->circular); - - - /* create local masks */ - - smask = r = 0x1L << ppat->patlen; - - /* init. scan */ - data = pseq->data + begin; - stkpos = pseq->hitpos + patnum; - stkerr = pseq->hiterr + patnum; - - /* loop on text data */ - - for (pos = begin ; pos < end ; pos++) { - - r = (r >> 1) & ppat->smat[*data++]; - - if (r & 0x1L) { - PUSH(stkpos, pos - ppat->patlen + 1); - PUSH(stkerr, 0); - } - - r |= smask; - } - - return (*stkpos)->top; /* aka # of hits */ -} - -/* -------------------------------------------- */ -/* Baeza-Yates/Manber algorithm */ -/* Substitution only */ -/* */ -/* Note : r array is stored as : */ -/* 0 0 r(0,j) r(0,j+1) r(1,j) r(1,j+1) ... */ -/* */ -/* -------------------------------------------- */ -Int32 ManberSub(Seq *pseq, Pattern *ppat, int patnum,int begin,int length) -{ - int e, emax, found; - UInt32 pos; - UInt32 smask, cmask, sindx; - UInt32 *pr, r[2 * MAX_PAT_ERR + 2]; - UInt8 *data; - StackiPtr *stkpos, *stkerr; - UInt32 end; - - end = begin + length; - end = (end <= (size_t)(pseq->seqlen+pseq->circular)) ? end:(size_t)(pseq->seqlen+pseq->circular); - - /* create local masks */ - emax = ppat->maxerr; - - r[0] = r[1] = 0x0; - - cmask = smask = 0x1L << ppat->patlen; - - for (e = 0, pr = r + 3 ; e <= emax ; e++, pr += 2) - *pr = cmask; - - cmask = ~ ppat->omask; - - /* init. scan */ - data = pseq->data + begin; - stkpos = pseq->hitpos + patnum; - stkerr = pseq->hiterr + patnum; - - /* loop on text data */ - - for (pos = begin ; pos < end ; pos++) { - - sindx = ppat->smat[*data++]; - - for (e = found = 0, pr = r ; e <= emax ; e++, pr += 2) { - - pr[2] = pr[3] | smask; - - pr[3] = ((pr[0] >> 1) & cmask) /* sub */ - | ((pr[2] >> 1) & sindx); /* ident */ - - if (pr[3] & 0x1L) { /* found */ - if (! found) { - PUSH(stkpos, pos - ppat->patlen + 1); - PUSH(stkerr, e); - } - found++; - } - } - } - - return (*stkpos)->top; /* aka # of hits */ -} - -/* -------------------------------------------- */ -/* Baeza-Yates/Manber algorithm */ -/* Substitution + Indels */ -/* */ -/* Note : r array is stored as : */ -/* 0 0 r(0,j) r(0,j+1) r(1,j) r(1,j+1) ... */ -/* */ -/* Warning: may return shifted pos. */ -/* */ -/* -------------------------------------------- */ -Int32 ManberIndel(Seq *pseq, Pattern *ppat, int patnum,int begin,int length) -{ - int e, emax, found; - UInt32 pos; - UInt32 smask, cmask, sindx; - UInt32 *pr, r[2 * MAX_PAT_ERR + 2]; - UInt8 *data; - StackiPtr *stkpos, *stkerr; - UInt32 end; - - end = begin + length; - end = (end <= (size_t)(pseq->seqlen+pseq->circular)) ? end:(size_t)(pseq->seqlen+pseq->circular); - - /* create local masks */ - emax = ppat->maxerr; - - r[0] = r[1] = 0x0; - - cmask = smask = 0x1L << ppat->patlen; - - for (e = 0, pr = r + 3 ; e <= emax ; e++, pr += 2) { - *pr = cmask; - cmask = (cmask >> 1) | smask; - } - - cmask = ~ ppat->omask; - - /* init. scan */ - data = pseq->data + begin; - stkpos = pseq->hitpos + patnum; - stkerr = pseq->hiterr + patnum; - - /* loop on text data */ - - for (pos = begin ; pos < end ; pos++) { - - sindx = ppat->smat[*data++]; - - for (e = found = 0, pr = r ; e <= emax ; e++, pr += 2) { - - pr[2] = pr[3] | smask; - - pr[3] = (( pr[0] /* ins */ - | (pr[0] >> 1) /* sub */ - | (pr[1] >> 1)) /* del */ - & cmask) - | ((pr[2] >> 1) & sindx); /* ident */ - - if (pr[3] & 0x1L) { /* found */ - if (! found) { - PUSH(stkpos, pos - ppat->patlen + 1); - PUSH(stkerr, e); - } - found++; - } - - } - } - - return (*stkpos)->top; /* aka # of hits */ -} - -/* -------------------------------------------- */ -/* Baeza-Yates/Manber algorithm */ -/* API call to previous functions */ -/* -------------------------------------------- */ -Int32 ManberAll(Seq *pseq, Pattern *ppat, int patnum,int begin,int length) -{ - if (ppat->maxerr == 0) - return ManberNoErr(pseq, ppat, patnum, begin, length); - else if (ppat->hasIndel) - return ManberIndel(pseq, ppat, patnum, begin, length); - else - return ManberSub(pseq, ppat, patnum, begin, length); -} - - -/* -------------------------------------------- */ -/* Alignement NWS */ -/* pour edition des hits */ -/* (avec substitution obligatoire aux bords) */ -/* -------------------------------------------- */ - -Int32 NwsPatAlign(pseq, ppat, nerr, reslen, reserr) - Seq *pseq; - Pattern *ppat; - Int32 nerr, *reslen, *reserr; -{ - UInt8 *sseq, *px; - Int32 i, j, lseq, lpat, npos, dindel, dsub, - *pc, *pi, *pd, *ps; - UInt32 amask; - - static Int32 sTab[(MAX_PAT_LEN+MAX_PAT_ERR+1) * (MAX_PAT_LEN+1)]; - - lseq = pseq->seqlen; - - pc = sTab; /* |----|----| --> i */ - pi = pc - 1; /* | ps | pd | | */ - pd = pi - lseq; /* |----|----| | */ - ps = pd - 1; /* | pi | pc | v j */ - /* |---------| */ - - lseq = pseq->seqlen; - lpat = ppat->patlen; - - sseq = pseq->data - 1; - - amask = ONEMASK >> lpat; - - for (j = 0 ; j <= lpat ; j++) { - - for (i = 0 , px = sseq ; i <= lseq ; i++, px++) { - - if (i && j) { - dindel = MIN(*pi, *pd) + 1; - dsub = *ps + KRONECK(ppat->smat[*px], amask); - *pc = MIN(dindel, dsub); - } - else if (i) /* j == 0 */ - *pc = *pi + 1; - else if (j) /* i == 0 */ - *pc = *pd + 1; - else /* root */ - *pc = 0; - - pc++; - pi++; - pd++; - ps++; - } - - amask <<= 1; - } - - pc--; - - for (i = lseq, npos = 0 ; i >= 0 ; i--, pc--) { - if (*pc <= nerr) { - *reslen++ = i; - *reserr++ = *pc; - npos++; - } - } - - return npos; -} diff --git a/src/libapat/libstki.c b/src/libapat/libstki.c deleted file mode 100644 index 1ca9868..0000000 --- a/src/libapat/libstki.c +++ /dev/null @@ -1,379 +0,0 @@ -/* ==================================================== */ -/* Copyright (c) Atelier de BioInformatique */ -/* Mar. 92 */ -/* File: libstki.c */ -/* Purpose: A library to deal with 'stacks' of */ -/* integers */ -/* Note: 'stacks' are dynamic (i.e. size is */ -/* automatically readjusted when needed) */ -/* History: */ -/* 00/03/92 : first draft */ -/* 15/08/93 : revised version */ -/* 14/05/99 : last revision */ -/* ==================================================== */ - -#include -#include -#include - -#include "Gtypes.h" -#include "libstki.h" - - -/* ============================ */ -/* Constantes et Macros locales */ -/* ============================ */ - -#define ExpandStack(stkh) ResizeStacki((stkh), (*stkh)->size << 1) - -#define ShrinkStack(stkh) ResizeStacki((stkh), (*stkh)->size >> 1) - - -static Int16 sStkiLastError = kStkiNoErr; - -/* -------------------------------------------- */ -/* gestion des erreurs */ -/* get/reset erreur flag */ -/* */ -/* @function: StkiError */ -/* -------------------------------------------- */ - -Int16 StkiError(Bool reset) -{ - Int16 err; - - err = sStkiLastError; - - if (reset) - sStkiLastError = kStkiNoErr; - - return err; - -} /* end of StkiError */ - -/* -------------------------------------------- */ -/* creation d'un stack */ -/* */ -/* @function: NewStacki */ -/* -------------------------------------------- */ - -StackiPtr NewStacki(Int32 size) -{ - StackiPtr stki; - - if (! (stki = NEW(Stacki))) - return NULL; - - stki->size = size; - stki->top = 0; - stki->cursor = 0; - - if ( ! (stki->val = NEWN(Int32, size))) { - sStkiLastError = kStkiMemErr; - return FreeStacki(stki); - } - - return stki; - -} /* end of NewStacki */ - - -/* -------------------------------------------- */ -/* liberation d'un stack */ -/* */ -/* @function: FreeStacki */ -/* -------------------------------------------- */ - -StackiPtr FreeStacki(StackiPtr stki) -{ - if (stki) { - if (stki->val) - FREE(stki->val); - FREE(stki); - } - - return NULL; - -} /* end of FreeStacki */ - -/* -------------------------------------------- */ -/* creation d'un vecteur de stacks */ -/* */ -/* @function: NewStackiVector */ -/* -------------------------------------------- */ - -StackiHdle NewStackiVector(Int32 vectSize, Int32 stackSize) -{ - Int32 i; - StackiHdle stkh; - - if (! (stkh = NEWN(StackiPtr, vectSize))) { - sStkiLastError = kStkiMemErr; - return NULL; - } - - for (i = 0 ; i < vectSize ; i++) - if (! (stkh[i] = NewStacki(stackSize))) - return FreeStackiVector(stkh, i); - - return stkh; - -} /* end of NewStackiVector */ - - -/* -------------------------------------------- */ -/* liberation d'un vecteur de stacks */ -/* */ -/* @function: FreeStackiVector */ -/* -------------------------------------------- */ - -StackiHdle FreeStackiVector(StackiHdle stkh, Int32 vectSize) -{ - Int32 i; - - if (stkh) { - for (i = 0 ; i < vectSize ; i++) - (void) FreeStacki(stkh[i]); - FREE(stkh); - } - - return NULL; - -} /* end of FreeStackiVector */ - -/* -------------------------------------------- */ -/* resize d'un stack */ -/* */ -/* @function: ResizeStacki */ -/* -------------------------------------------- */ - -Int32 ResizeStacki(StackiHdle stkh, Int32 size) -{ - Int32 resize = 0; /* assume error */ - Int32 *val; - - if ((val = REALLOC(Int32, (*stkh)->val, size))) { - (*stkh)->size = resize = size; - (*stkh)->val = val; - } - - if (! resize) - sStkiLastError = kStkiMemErr; - - return resize; - -} /* end of ResizeStacki */ - -/* -------------------------------------------- */ -/* empilage(/lement) */ -/* */ -/* @function: PushiIn */ -/* -------------------------------------------- */ - -Bool PushiIn(StackiHdle stkh, Int32 val) -{ - if (((*stkh)->top >= (*stkh)->size) && (! ExpandStack(stkh))) - return Faux; - - (*stkh)->val[((*stkh)->top)++] = val; - - return Vrai; - -} /* end of PushiIn */ - -/* -------------------------------------------- */ -/* depilage(/lement) */ -/* */ -/* @function: PopiOut */ -/* -------------------------------------------- */ - -Bool PopiOut(StackiHdle stkh, Int32 *val) -{ - if ((*stkh)->top <= 0) - return Faux; - - *val = (*stkh)->val[--((*stkh)->top)]; - - if ( ((*stkh)->top < ((*stkh)->size >> 1)) - && ((*stkh)->top > kMinStackiSize)) - - (void) ShrinkStack(stkh); - - return Vrai; - -} /* end of PopiOut */ - -/* -------------------------------------------- */ -/* lecture descendante */ -/* */ -/* @function: ReadiDown */ -/* -------------------------------------------- */ - -Bool ReadiDown(StackiPtr stki, Int32 *val) -{ - if (stki->cursor <= 0) - return Faux; - - *val = stki->val[--(stki->cursor)]; - - return Vrai; - -} /* end of ReadiDown */ - -/* -------------------------------------------- */ -/* lecture ascendante */ -/* */ -/* @function: ReadiUp */ -/* -------------------------------------------- */ - -Bool ReadiUp(StackiPtr stki, Int32 *val) -{ - if (stki->cursor >= stki->top) - return Faux; - - *val = stki->val[(stki->cursor)++]; - - return Vrai; - -} /* end of ReadiUp */ - -/* -------------------------------------------- */ -/* remontee/descente du curseur */ -/* */ -/* @function: CursiToTop */ -/* @function: CursiToBottom */ -/* -------------------------------------------- */ - -void CursiToTop(StackiPtr stki) -{ - stki->cursor = stki->top; - -} /* end of CursiToTop */ - -void CursiToBottom(stki) - StackiPtr stki; -{ - stki->cursor = 0; - -} /* end of CursiToBottom */ - -/* -------------------------------------------- */ -/* echange des valeurs cursor <-> (top - 1) */ -/* */ -/* @function: CursiSwap */ -/* -------------------------------------------- */ - -void CursiSwap(StackiPtr stki) -{ - Int32 tmp; - - if ((stki->top <= 0) || (stki->cursor < 0)) - return; - - tmp = stki->val[stki->cursor]; - stki->val[stki->cursor] = stki->val[stki->top - 1]; - stki->val[stki->top - 1] = tmp; - -} /* end of CursiSwap */ - -/* -------------------------------------------- */ -/* Recherche d'une valeur en stack a partir du */ -/* curseur courant en descendant. */ -/* on laisse le curseur a l'endroit trouve */ -/* */ -/* @function: SearchDownStacki */ -/* -------------------------------------------- */ - -Bool SearchDownStacki(StackiPtr stki, Int32 sval) -{ - Int32 val; - Bool more; - - while ((more = ReadiDown(stki, &val))) - if (val == sval) - break; - - return more; - -} /* end of SearchDownStacki */ - -/* -------------------------------------------- */ -/* Recherche dichotomique d'une valeur en stack */ -/* le stack est suppose trie par valeurs */ -/* croissantes. */ -/* on place le curseur a l'endroit trouve */ -/* */ -/* @function: BinSearchStacki */ -/* -------------------------------------------- */ - -Bool BinSearchStacki(StackiPtr stki, Int32 sval) -{ - Int32 midd, low, high, span; - - low = 0; - high = stki->top - 1; - - while (high >= low) { - - midd = (high + low) / 2; - - span = stki->val[midd] - sval; - - if (span == 0) { - stki->cursor = midd; - return Vrai; - } - - if (span > 0) - high = midd - 1; - else - low = midd + 1; - } - - return Faux; - -} /* end of BinSearchStacki */ - -/* -------------------------------------------- */ -/* teste l'egalite *physique* de deux stacks */ -/* */ -/* @function: SameStacki */ -/* -------------------------------------------- */ - -Bool SameStacki(StackiPtr stki1, StackiPtr stki2) -{ - if (stki1->top != stki2->top) - return Faux; - - return ((memcmp(stki1->val, stki2->val, - stki1->top * sizeof(Int32)) == 0) ? Vrai : Faux); - -} /* end of SameStacki */ - - -/* -------------------------------------------- */ -/* inverse l'ordre des elements dans un stack */ -/* */ -/* @function: ReverseStacki */ -/* -------------------------------------------- */ - -Bool ReverseStacki(StackiPtr stki) -{ - Int32 *t, *b, swp; - - if (stki->top <= 0) - return Faux; - - b = stki->val; - t = b + stki->top - 1; - - while (t > b) { - swp = *t; - *t-- = *b; - *b++ = swp; - } - - return Vrai; - -} /* end of ReverseStacki */ - diff --git a/src/libapat/libstki.h b/src/libapat/libstki.h deleted file mode 100644 index 6331ae7..0000000 --- a/src/libapat/libstki.h +++ /dev/null @@ -1,87 +0,0 @@ -/* ==================================================== */ -/* Copyright (c) Atelier de BioInformatique */ -/* Mar. 92 */ -/* File: libstki.h */ -/* Purpose: library of dynamic stacks holding */ -/* integer values */ -/* History: */ -/* 00/03/92 : first draft */ -/* 07/07/93 : complete revision */ -/* 10/03/94 : added xxxVector funcs */ -/* 14/05/99 : last revision */ -/* ==================================================== */ - -#ifndef _H_Gtypes -#include "Gtypes.h" -#endif - -#define _H_libstki - -/* ==================================================== */ -/* Constantes de dimensionnement */ -/* ==================================================== */ - -#ifndef kMinStackiSize -#define kMinStackiSize 2 /* taille mini stack */ -#endif - - -#define kStkiNoErr 0 /* ok */ -#define kStkiMemErr 1 /* not enough memory */ - -#define kStkiReset Vrai -#define kStkiGet Faux - -/* ==================================================== */ -/* Macros standards */ -/* ==================================================== */ - -#ifndef NEW -#define NEW(typ) (typ*)malloc(sizeof(typ)) -#define NEWN(typ, dim) (typ*)malloc((unsigned long)(dim) * sizeof(typ)) -#define REALLOC(typ, ptr, dim) (typ*)realloc((void *) (ptr), (unsigned long)(dim) * sizeof(typ)) -#define FREE(ptr) free((Ptr) ptr) -#endif - - -/* ==================================================== */ -/* Types & Structures de donnees */ -/* ==================================================== */ - - /* -------------------- */ - /* structure : pile */ - /* -------------------- */ -typedef struct Stacki { - /* ---------------------*/ - Int32 size; /* stack size */ - Int32 top; /* current free pos. */ - Int32 cursor; /* current cursor */ - Int32 *val; /* values */ - /* ---------------------*/ -} Stacki, *StackiPtr, **StackiHdle; - - - -/* ==================================================== */ -/* Prototypes (generated by mproto) */ -/* ==================================================== */ - - /* libstki.c */ - -Int16 StkiError (Bool reset ); -StackiPtr NewStacki (Int32 size ); -StackiPtr FreeStacki (StackiPtr stki ); -StackiHdle NewStackiVector (Int32 vectSize, Int32 stackSize ); -StackiHdle FreeStackiVector (StackiHdle stkh, Int32 vectSize ); -Int32 ResizeStacki (StackiHdle stkh , Int32 size ); -Bool PushiIn (StackiHdle stkh , Int32 val ); -Bool PopiOut (StackiHdle stkh , Int32 *val ); -Bool ReadiDown (StackiPtr stki , Int32 *val ); -Bool ReadiUp (StackiPtr stki , Int32 *val ); -void CursiToTop (StackiPtr stki ); -void CursiToBottom (StackiPtr stki ); -void CursiSwap (StackiPtr stki ); -Bool SearchDownStacki (StackiPtr stki , Int32 sval ); -Bool BinSearchStacki (StackiPtr stki , Int32 sval ); -Bool SameStacki (StackiPtr stki1 , StackiPtr stki2 ); -Bool ReverseStacki (StackiPtr stki );