From 4315aecbf0cdbfa4425ffb1155fc75c27e27a2e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Boyer?= Date: Thu, 26 Apr 2012 16:23:35 +0000 Subject: [PATCH] ADD libapat so that everything is included when fetching the project from svn git-svn-id: https://www.grenoble.prabi.fr/svn/LECASofts/ecoPrimers/trunk@411 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 insertions(+) create mode 100644 src/libapat/CODES/dft_code.h create mode 100644 src/libapat/CODES/dna_code.h create mode 100644 src/libapat/CODES/prot_code.h create mode 100644 src/libapat/Gmach.h create mode 100644 src/libapat/Gtypes.h create mode 100644 src/libapat/Makefile create mode 100644 src/libapat/apat.h create mode 100644 src/libapat/apat_parse.c create mode 100644 src/libapat/apat_search.c create mode 100644 src/libapat/libstki.c create mode 100644 src/libapat/libstki.h diff --git a/src/libapat/CODES/dft_code.h b/src/libapat/CODES/dft_code.h new file mode 100644 index 0000000..b9caf28 --- /dev/null +++ b/src/libapat/CODES/dft_code.h @@ -0,0 +1,14 @@ +/* ----------------------------------------------- */ +/* 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 new file mode 100644 index 0000000..0febf41 --- /dev/null +++ b/src/libapat/CODES/dna_code.h @@ -0,0 +1,71 @@ +/* ----------------------------------------------- */ +/* 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 new file mode 100644 index 0000000..edcdfc1 --- /dev/null +++ b/src/libapat/CODES/prot_code.h @@ -0,0 +1,51 @@ +/* ----------------------------------------------- */ +/* 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 new file mode 100644 index 0000000..8fb1c69 --- /dev/null +++ b/src/libapat/Gmach.h @@ -0,0 +1,97 @@ +/* ---------------------------------------------------------------- */ +/* 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 new file mode 100644 index 0000000..9bf5a93 --- /dev/null +++ b/src/libapat/Gtypes.h @@ -0,0 +1,104 @@ +/* ---------------------------------------------------------------- */ +/* 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 new file mode 100644 index 0000000..b4dc9be --- /dev/null +++ b/src/libapat/Makefile @@ -0,0 +1,24 @@ + +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 new file mode 100644 index 0000000..eaa06df --- /dev/null +++ b/src/libapat/apat.h @@ -0,0 +1,173 @@ +/* ==================================================== */ +/* 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 new file mode 100644 index 0000000..43cda48 --- /dev/null +++ b/src/libapat/apat_parse.c @@ -0,0 +1,369 @@ +/* ==================================================== */ +/* 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 new file mode 100644 index 0000000..f0dd394 --- /dev/null +++ b/src/libapat/apat_search.c @@ -0,0 +1,339 @@ +/* ==================================================== */ +/* 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 new file mode 100644 index 0000000..1ca9868 --- /dev/null +++ b/src/libapat/libstki.c @@ -0,0 +1,379 @@ +/* ==================================================== */ +/* 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 new file mode 100644 index 0000000..6331ae7 --- /dev/null +++ b/src/libapat/libstki.h @@ -0,0 +1,87 @@ +/* ==================================================== */ +/* 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 );