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
This commit is contained in:
Frédéric Boyer
14
src/libapat/CODES/dft_code.h
Normal file
14
src/libapat/CODES/dft_code.h
Normal file
@ -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 */
|
||||
71
src/libapat/CODES/dna_code.h
Normal file
71
src/libapat/CODES/dna_code.h
Normal file
@ -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
|
||||
51
src/libapat/CODES/prot_code.h
Normal file
51
src/libapat/CODES/prot_code.h
Normal file
@ -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
|
||||
97
src/libapat/Gmach.h
Normal file
97
src/libapat/Gmach.h
Normal file
@ -0,0 +1,97 @@
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Copyright (c) Atelier de BioInformatique */
|
||||
/* @file: Gmach.h */
|
||||
/* @desc: machine dependant setup */
|
||||
/* @+ *should* be included in all ABI softs */
|
||||
/* */
|
||||
/* @history: */
|
||||
/* @+ <Gloup> : Jul 95 : MWC first draft */
|
||||
/* @+ <Gloup> : Jan 96 : adapted to Pwg */
|
||||
/* @+ <Gloup> : 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 <unistd.h>
|
||||
#endif
|
||||
|
||||
/* getopt.h header file */
|
||||
|
||||
#ifdef MAC_OS_C
|
||||
#define HAS_GETOPT_H "getopt.h"
|
||||
#endif
|
||||
|
||||
#ifdef SGI
|
||||
#define HAS_GETOPT_H <getopt.h>
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
104
src/libapat/Gtypes.h
Normal file
104
src/libapat/Gtypes.h
Normal file
@ -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: */
|
||||
/* @+ <Gloup> : Jan 91 : MWC first draft */
|
||||
/* @+ <Gloup> : Jul 95 : Gmach addition */
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
#define _H_Gtypes
|
||||
|
||||
#ifndef _H_Gmach
|
||||
#include "Gmach.h"
|
||||
#endif
|
||||
|
||||
#ifndef NULL
|
||||
#include <stdio.h> /* 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 <please edit Gmach.h>
|
||||
|
||||
#endif
|
||||
|
||||
/* ==================================================== */
|
||||
/* special macro for prototypes */
|
||||
/* ==================================================== */
|
||||
|
||||
#if PROTO
|
||||
#define P(s) s
|
||||
#else
|
||||
#define P(s) ()
|
||||
#endif
|
||||
24
src/libapat/Makefile
Normal file
24
src/libapat/Makefile
Normal file
@ -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) $@
|
||||
173
src/libapat/apat.h
Normal file
173
src/libapat/apat.h
Normal file
@ -0,0 +1,173 @@
|
||||
/* ==================================================== */
|
||||
/* Copyright (c) Atelier de BioInformatique */
|
||||
/* Dec. 94 */
|
||||
/* File: apat.h */
|
||||
/* Purpose: pattern scan */
|
||||
/* History: */
|
||||
/* 28/12/94 : <Gloup> ascan first version */
|
||||
/* 14/05/99 : <Gloup> 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 /* <unused> 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);
|
||||
|
||||
369
src/libapat/apat_parse.c
Normal file
369
src/libapat/apat_parse.c
Normal file
@ -0,0 +1,369 @@
|
||||
/* ==================================================== */
|
||||
/* Copyright (c) Atelier de BioInformatique */
|
||||
/* Mar. 92 */
|
||||
/* File: apat_parse.c */
|
||||
/* Purpose: Codage du pattern */
|
||||
/* History: */
|
||||
/* 00/07/94 : <Gloup> first version (stanford) */
|
||||
/* 00/11/94 : <Gloup> revised for DNA/PROTEIN */
|
||||
/* 30/12/94 : <Gloup> modified EncodePattern */
|
||||
/* for manber search */
|
||||
/* 14/05/99 : <Gloup> indels added */
|
||||
/* ==================================================== */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#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 */
|
||||
/* <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");
|
||||
}
|
||||
|
||||
339
src/libapat/apat_search.c
Normal file
339
src/libapat/apat_search.c
Normal file
@ -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 : <MFS> first version */
|
||||
/* 28/12/94 : <Gloup> revised version */
|
||||
/* 14/05/99 : <Gloup> last revision */
|
||||
/* ==================================================== */
|
||||
|
||||
#if 0
|
||||
#ifndef THINK_C
|
||||
#include <sys/types.h>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#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;
|
||||
}
|
||||
379
src/libapat/libstki.c
Normal file
379
src/libapat/libstki.c
Normal file
@ -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 : <Gloup> first draft */
|
||||
/* 15/08/93 : <Gloup> revised version */
|
||||
/* 14/05/99 : <Gloup> last revision */
|
||||
/* ==================================================== */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#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 */
|
||||
|
||||
87
src/libapat/libstki.h
Normal file
87
src/libapat/libstki.h
Normal file
@ -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 : <Gloup> first draft */
|
||||
/* 07/07/93 : <Gloup> complete revision */
|
||||
/* 10/03/94 : <Gloup> added xxxVector funcs */
|
||||
/* 14/05/99 : <Gloup> 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 );
|
||||
Reference in New Issue
Block a user