1038 lines
43 KiB
C
1038 lines
43 KiB
C
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// INTEL CORPORATION PROPRIETARY INFORMATION
|
||
|
|
// This software is supplied under the terms of a license agreement or
|
||
|
|
// nondisclosure agreement with Intel Corporation and may not be copied
|
||
|
|
// or disclosed except in accordance with the terms of that agreement.
|
||
|
|
// Copyright(c) 2002-2009 Intel Corporation. All Rights Reserved.
|
||
|
|
//
|
||
|
|
//
|
||
|
|
// Intel(R) Integrated Performance Primitives
|
||
|
|
// String Manipulations Library (ippCH)
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
#if !defined( __IPPCH_H__ ) || defined( _OWN_BLDPCS )
|
||
|
|
#define __IPPCH_H__
|
||
|
|
|
||
|
|
#ifndef __IPPDEFS_H__
|
||
|
|
#include "ippdefs.h"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
extern "C" {
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if !defined( _OWN_BLDPCS )
|
||
|
|
|
||
|
|
#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
|
||
|
|
#define _IPP_STDCALL_CDECL
|
||
|
|
#undef __stdcall
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
typedef struct {
|
||
|
|
void *pFind;
|
||
|
|
int lenFind;
|
||
|
|
} IppRegExpFind;
|
||
|
|
|
||
|
|
struct RegExpState;
|
||
|
|
typedef struct RegExpState IppRegExpState;
|
||
|
|
|
||
|
|
typedef enum {
|
||
|
|
ippFmtASCII = 0,
|
||
|
|
ippFmtUTF8
|
||
|
|
} IppRegExpFormat;
|
||
|
|
|
||
|
|
#endif /* _OWN_BLDPCS */
|
||
|
|
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
////////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Functions declarations
|
||
|
|
////////////////////////////////////////////////////////////////////////////////
|
||
|
|
///////////////////////////////////////////////////////////////////////////// */
|
||
|
|
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippchGetLibVersion
|
||
|
|
// Purpose: getting of the library version
|
||
|
|
// Returns: the structure of information about version
|
||
|
|
// of ippCH library
|
||
|
|
// Parameters:
|
||
|
|
//
|
||
|
|
// Notes: not necessary to release the returned structure
|
||
|
|
*/
|
||
|
|
IPPAPI( const IppLibraryVersion*, ippchGetLibVersion, (void) )
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// String Functions
|
||
|
|
///////////////////////////////////////////////////////////////////////////// */
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsFind_8u ippsFind_16u
|
||
|
|
// ippsFindC_8u ippsFindC_16u
|
||
|
|
// ippsFindRev_8u ippsFindRev_16u
|
||
|
|
// ippsFindRevC_8u ippsFindRevC_16u
|
||
|
|
//
|
||
|
|
// Purpose: Finds the match for string of elements or single element
|
||
|
|
// within source string in direct or reverse direction
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// len - source string length
|
||
|
|
// pFind - pointer to the searching string
|
||
|
|
// lenFind - searching string length
|
||
|
|
// valFind - searching element
|
||
|
|
// pIndex - pointer to the result index:
|
||
|
|
// *pIndex = index of first occurrence ;
|
||
|
|
// *pIndex = -1 if no match;
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc, pFind or pIndex are NULL
|
||
|
|
// ippStsLengthErr len or lenFind are negative
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsFind_8u, (const Ipp8u* pSrc, int len,
|
||
|
|
const Ipp8u* pFind, int lenFind,
|
||
|
|
int *pIndex))
|
||
|
|
IPPAPI (IppStatus, ippsFind_16u, (const Ipp16u* pSrc, int len,
|
||
|
|
const Ipp16u* pFind, int lenFind,
|
||
|
|
int *pIndex))
|
||
|
|
IPPAPI (IppStatus, ippsFindC_8u, (const Ipp8u* pSrc, int len,
|
||
|
|
Ipp8u valFind, int *pIndex))
|
||
|
|
IPPAPI (IppStatus, ippsFindC_16u, (const Ipp16u* pSrc, int len,
|
||
|
|
Ipp16u valFind, int *pIndex))
|
||
|
|
|
||
|
|
IPPAPI (IppStatus, ippsFindRev_8u, (const Ipp8u* pSrc, int len,
|
||
|
|
const Ipp8u* pFind, int lenFind,
|
||
|
|
int *pIndex))
|
||
|
|
IPPAPI (IppStatus, ippsFindRev_16u, (const Ipp16u* pSrc, int len,
|
||
|
|
const Ipp16u* pFind, int lenFind,
|
||
|
|
int *pIndex))
|
||
|
|
IPPAPI (IppStatus, ippsFindRevC_8u, (const Ipp8u* pSrc, int len,
|
||
|
|
Ipp8u valFind, int *pIndex))
|
||
|
|
IPPAPI (IppStatus, ippsFindRevC_16u, (const Ipp16u* pSrc, int len,
|
||
|
|
Ipp16u valFind, int *pIndex))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsFind_Z_8u ippsFind_Z_16u
|
||
|
|
// ippsFindC_Z_8u ippsFindC_Z_16u
|
||
|
|
//
|
||
|
|
// Purpose: Finds the match for zero-ended string of elements or single element
|
||
|
|
// within source zero-ended string in direct or reverse direction
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrcZ - pointer to the source zero-ended string
|
||
|
|
// pFindZ - pointer to the searching zero-ended string
|
||
|
|
// valFind - searching element
|
||
|
|
// pIndex - pointer to the result index:
|
||
|
|
// *pIndex = index of first occurrence;
|
||
|
|
// *pIndex = -1 if no match;
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrcZ, pFindZ or pIndex are NULL
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsFind_Z_8u, (const Ipp8u* pSrcZ,
|
||
|
|
const Ipp8u* pFindZ, int *pIndex))
|
||
|
|
IPPAPI (IppStatus, ippsFind_Z_16u, (const Ipp16u* pSrcZ,
|
||
|
|
const Ipp16u* pFindZ, int *pIndex))
|
||
|
|
IPPAPI (IppStatus, ippsFindC_Z_8u, (const Ipp8u* pSrcZ,
|
||
|
|
Ipp8u valFind, int *pIndex))
|
||
|
|
IPPAPI (IppStatus, ippsFindC_Z_16u, (const Ipp16u* pSrcZ,
|
||
|
|
Ipp16u valFind, int *pIndex))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsCompare_8u ippsCompare_16u
|
||
|
|
//
|
||
|
|
// Purpose: Compares two strings element-by-element
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc1 - pointer to the first string
|
||
|
|
// pSrc2 - pointer to the second string
|
||
|
|
// len - string length to compare
|
||
|
|
// pResult - pointer to the result:
|
||
|
|
// *pResult = 0 if src1 == src2;
|
||
|
|
// *pResult = >0 if src1 > src2;
|
||
|
|
// *pResult = <0 if src1 < src2;
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc1, pSrc2 or pResult are NULL
|
||
|
|
// ippStsLengthErr len is negative
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsCompare_8u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
|
||
|
|
int len, int *pResult))
|
||
|
|
IPPAPI (IppStatus, ippsCompare_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2,
|
||
|
|
int len, int *pResult))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsEqual_8u ippsEqual_16u
|
||
|
|
//
|
||
|
|
// Purpose: Compares two strings element-by-element
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc1 - pointer to the first string
|
||
|
|
// pSrc2 - pointer to the second string
|
||
|
|
// len - string length to compare
|
||
|
|
// pResult - pointer to the result:
|
||
|
|
// *pResult = 1 if src1 == src2;
|
||
|
|
// *pResult = 0 if src1 != src2;
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc1, pSrc2 or pResult are NULL
|
||
|
|
// ippStsLengthErr len is negative
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsEqual_8u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2,
|
||
|
|
int len, int *pResult))
|
||
|
|
IPPAPI (IppStatus, ippsEqual_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2,
|
||
|
|
int len, int *pResult))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsTrimC_8u_I ippsTrimC_16u_I
|
||
|
|
//
|
||
|
|
// Purpose: Deletes an odd symbol at the end and the beginning of a string
|
||
|
|
// in-place
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrcDst - pointer to the string
|
||
|
|
// pLen - pointer to the string length:
|
||
|
|
// *pLen = source length on input;
|
||
|
|
// *pLen = destination length on output;
|
||
|
|
// odd - odd symbol
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrcDst or pLen are NULL
|
||
|
|
// ippStsLengthErr *pLen is negative
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsTrimC_8u_I, (Ipp8u* pSrcDst, int* pLen, Ipp8u odd ))
|
||
|
|
IPPAPI (IppStatus, ippsTrimC_16u_I, (Ipp16u* pSrcDst, int* pLen, Ipp16u odd ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsTrimC_8u ippsTrimC_16u
|
||
|
|
//
|
||
|
|
// Purpose: Deletes an odd symbol at the end and the beginning of a string
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// srcLen - source string length
|
||
|
|
// odd - odd symbol
|
||
|
|
// pDst - pointer to the destination string
|
||
|
|
// pDstLen - pointer to the destination string length:
|
||
|
|
// *pDstLen doesn't use as input value;
|
||
|
|
// *pDstLen = destination length on output;
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrcDst, pDst or pDstLen are NULL
|
||
|
|
// ippStsLengthErr srcLen is negative
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsTrimC_8u, (const Ipp8u* pSrc, int srcLen, Ipp8u odd,
|
||
|
|
Ipp8u* pDst, int* pDstLen ))
|
||
|
|
IPPAPI (IppStatus, ippsTrimC_16u, (const Ipp16u* pSrc, int srcLen, Ipp16u odd,
|
||
|
|
Ipp16u* pDst, int* pDstLen ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsUppercase_16u_I
|
||
|
|
// ippsLowercase_16u_I
|
||
|
|
// ippsUppercase_16u
|
||
|
|
// ippsLowercase_16u
|
||
|
|
//
|
||
|
|
// Purpose: Forms an uppercase or lowercase version of the Unicode string
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// pDst - pointer to the destination string
|
||
|
|
// pSrcDst - pointer to the string for in-place operation
|
||
|
|
// len - string length
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc, pDst or pSrcDst are NULL;
|
||
|
|
// ippStsLengthErr len is negative;
|
||
|
|
*/
|
||
|
|
|
||
|
|
IPPAPI (IppStatus, ippsUppercase_16u_I,( Ipp16u* pSrcDst, int len ))
|
||
|
|
IPPAPI (IppStatus, ippsLowercase_16u_I,( Ipp16u* pSrcDst, int len ))
|
||
|
|
IPPAPI (IppStatus, ippsUppercase_16u, (const Ipp16u* pSrc, Ipp16u* pDst, int len))
|
||
|
|
IPPAPI (IppStatus, ippsLowercase_16u, (const Ipp16u* pSrc, Ipp16u* pDst, int len))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsUppercaseLatin_8u_I ippsUppercaseLatin_16u_I
|
||
|
|
// ippsLowercaseLatin_8u_I ippsLowercaseLatin_16u_I
|
||
|
|
// ippsLowercaseLatin_8u ippsUppercaseLatin_16u
|
||
|
|
// ippsUppercaseLatin_8u ippsLowercaseLatin_16u
|
||
|
|
//
|
||
|
|
// Purpose: Forms an uppercase or lowercase version of the ASCII string
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// pDst - pointer to the destination string
|
||
|
|
// pSrcDst - pointer to the string for in-place operation
|
||
|
|
// len - string length
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc, pDst or pSrcDst are NULL;
|
||
|
|
// ippStsLengthErr len is negative;
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsUppercaseLatin_8u_I, ( Ipp8u* pSrcDst, int len ))
|
||
|
|
IPPAPI (IppStatus, ippsLowercaseLatin_8u_I, ( Ipp8u* pSrcDst, int len ))
|
||
|
|
IPPAPI (IppStatus, ippsUppercaseLatin_16u_I,( Ipp16u* pSrcDst, int len ))
|
||
|
|
IPPAPI (IppStatus, ippsLowercaseLatin_16u_I,( Ipp16u* pSrcDst, int len ))
|
||
|
|
IPPAPI (IppStatus, ippsLowercaseLatin_8u, (const Ipp8u* pSrc, Ipp8u* pDst, int len))
|
||
|
|
IPPAPI (IppStatus, ippsUppercaseLatin_8u, (const Ipp8u* pSrc, Ipp8u* pDst, int len))
|
||
|
|
IPPAPI (IppStatus, ippsUppercaseLatin_16u, (const Ipp16u* pSrc, Ipp16u* pDst, int len))
|
||
|
|
IPPAPI (IppStatus, ippsLowercaseLatin_16u, (const Ipp16u* pSrc, Ipp16u* pDst, int len))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsHash_8u32u ippsHash_16u32u
|
||
|
|
//
|
||
|
|
// Purpose: Calculates hashed value so that different strings yield different
|
||
|
|
// values:
|
||
|
|
// for (i=0; i<len; i++) hash = (hash << 1) ^ src[i];
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// len - source string length
|
||
|
|
// pHashVal - pointer to the result value
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc or pHashVal are NULL
|
||
|
|
// ippStsLengthErr len is negative
|
||
|
|
*/
|
||
|
|
|
||
|
|
IPPAPI (IppStatus, ippsHash_8u32u, (const Ipp8u* pSrc, int len, Ipp32u* pHashVal ))
|
||
|
|
IPPAPI (IppStatus, ippsHash_16u32u, (const Ipp16u* pSrc, int len, Ipp32u* pHashVal ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsHashSJ2_8u32u ippsHashSJ2_16u32u
|
||
|
|
//
|
||
|
|
// Purpose: Calculates hashed value so that different strings yield different
|
||
|
|
// values:
|
||
|
|
// for (i=0; i<len; i++) hash =
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// len - source string length
|
||
|
|
// pHashVal - pointer to the result value
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc or pHashVal are NULL
|
||
|
|
// ippStsLengthErr len is negative
|
||
|
|
*/
|
||
|
|
|
||
|
|
IPPAPI (IppStatus,ippsHashSJ2_8u32u, (const Ipp8u* pSrc, int len, Ipp32u* pHashVal))
|
||
|
|
IPPAPI (IppStatus,ippsHashSJ2_16u32u, (const Ipp16u* pSrc, int len, Ipp32u* pHashVal))
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsHashMSCS_8u32u ippsHashMSCS_16u32u
|
||
|
|
//
|
||
|
|
// Purpose: Calculates hashed value so that different strings yield different
|
||
|
|
// values:
|
||
|
|
// for (i=0; i<len; i++) hash =
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// len - source string length
|
||
|
|
// pHashVal - pointer to the result value
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc or pHashVal are NULL
|
||
|
|
// ippStsLengthErr len is negative
|
||
|
|
*/
|
||
|
|
|
||
|
|
IPPAPI (IppStatus,ippsHashMSCS_8u32u, (const Ipp8u* pSrc, int len, Ipp32u* pHashVal))
|
||
|
|
IPPAPI (IppStatus,ippsHashMSCS_16u32u, (const Ipp16u* pSrc, int len, Ipp32u* pHashVal))
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsConcat_8u ippsConcat_16u
|
||
|
|
//
|
||
|
|
// Purpose: Concatenates two strings together
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc1 - pointer to the first source string
|
||
|
|
// len1 - first source string length
|
||
|
|
// pSrc2 - pointer to the second source string
|
||
|
|
// len2 - second source string length
|
||
|
|
// pDst - pointer to the destination string
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc1, pSrc2 or pDst are NULL
|
||
|
|
// ippStsLengthErr len1 or len2 are negative
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsConcat_8u, (const Ipp8u* pSrc1, int len1,
|
||
|
|
const Ipp8u* pSrc2, int len2,
|
||
|
|
Ipp8u* pDst))
|
||
|
|
IPPAPI (IppStatus, ippsConcat_16u, (const Ipp16u* pSrc1, int len1,
|
||
|
|
const Ipp16u* pSrc2, int len2,
|
||
|
|
Ipp16u* pDst))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsConcat_8u_D2L ippsConcat_16u_D2L
|
||
|
|
//
|
||
|
|
// Purpose: Concatenates several strings together
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the array of source strings
|
||
|
|
// srcLen - pointer to the array of source strings' lengths
|
||
|
|
// numSrc - number of source strings
|
||
|
|
// pDst - pointer to the destination string
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc, srcLen or pDst are NULL;
|
||
|
|
// pSrc[i] is NULL for i < numSrc
|
||
|
|
// ippStsLengthErr srcLen[i] is negative for i < numSrc
|
||
|
|
// ippStsSizeErr numSrc is not positive
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsConcat_8u_D2L, (const Ipp8u* const pSrc[], const int srcLen[], int numSrc,
|
||
|
|
Ipp8u* pDst ))
|
||
|
|
IPPAPI (IppStatus, ippsConcat_16u_D2L, (const Ipp16u* const pSrc[], const int srcLen[], int numSrc,
|
||
|
|
Ipp16u* pDst ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsConcatC_8u_D2L ippsConcatC_16u_D2L
|
||
|
|
//
|
||
|
|
// Purpose: Concatenates several strings together and separates them
|
||
|
|
// by the symbol delimiter
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the array of source strings
|
||
|
|
// srcLen - pointer to the array of source strings' lengths
|
||
|
|
// numSrc - number of source strings
|
||
|
|
// delim - delimiter
|
||
|
|
// pDst - pointer to the destination string
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc, srcLen or pDst are NULL;
|
||
|
|
// pSrc[i] is NULL for i < numSrc
|
||
|
|
// ippStsLengthErr srcLen[i] is negative for i < numSrc
|
||
|
|
// ippStsSizeErr numSrc is not positive
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsConcatC_8u_D2L, (const Ipp8u* const pSrc[], const int srcLen[], int numSrc,
|
||
|
|
Ipp8u delim, Ipp8u* pDst ))
|
||
|
|
IPPAPI (IppStatus, ippsConcatC_16u_D2L, (const Ipp16u* const pSrc[], const int srcLen[], int numSrc,
|
||
|
|
Ipp16u delim, Ipp16u* pDst ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsSplitC_8u_D2L ippsSplitC_16u_D2L
|
||
|
|
//
|
||
|
|
// Purpose: Splits source string to several destination strings
|
||
|
|
// using the symbol delimiter; all delimiters are significant,
|
||
|
|
// in the case of double delimiter empty string is inserted.
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// srcLen - source string length
|
||
|
|
// delim - delimiter
|
||
|
|
// pDst - pointer to the array of destination strings
|
||
|
|
// dstLen - pointer to the array of destination strings' lengths
|
||
|
|
// pNumDst - pointer to the number of destination strings:
|
||
|
|
// *pNumDst = initial number of destination strings on input;
|
||
|
|
// *pNumDst = number of splitted strings on output;
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ERRORS:
|
||
|
|
// ippStsNullPtrErr pSrc, pDst, dstLen or pNumDst are NULL;
|
||
|
|
// pDst[i] is NULL for i < number of splitted strings
|
||
|
|
// ippStsLengthErr srcLen is negative;
|
||
|
|
// dstLen[i] is negative for i < number of splitted strings
|
||
|
|
// ippStsSizeErr *pNumDst is not positive
|
||
|
|
// WARNINGS:
|
||
|
|
// ippStsOvermuchStrings the initial number of destination strings is less
|
||
|
|
// than the number of splitted strings;
|
||
|
|
// number of destination strings is truncated to
|
||
|
|
// initial number in this case
|
||
|
|
// ippStsOverlongString the length of one of destination strings is less than
|
||
|
|
// length of corresponding splitted string;
|
||
|
|
// splitted string is truncated to destination length
|
||
|
|
// in this case
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsSplitC_8u_D2L, (const Ipp8u* pSrc, int srcLen, Ipp8u delim,
|
||
|
|
Ipp8u* pDst[], int dstLen[], int* pNumDst))
|
||
|
|
IPPAPI (IppStatus, ippsSplitC_16u_D2L, (const Ipp16u* pSrc, int srcLen, Ipp16u delim,
|
||
|
|
Ipp16u* pDst[], int dstLen[], int* pNumDst))
|
||
|
|
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsFindCAny_8u
|
||
|
|
// ippsFindCAny_16u
|
||
|
|
// ippsFindRevCAny_8u
|
||
|
|
// ippsFindRevCAny_16u
|
||
|
|
//
|
||
|
|
// Purpose: Reports the index of the first/last occurrence in
|
||
|
|
// the vector of any value in a specified array.
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - The pointer of vector to find.
|
||
|
|
// len - The length of the vector.
|
||
|
|
// pAnyOf - A pointer of array containing one or more values to seek.
|
||
|
|
// lenFind - The length of array.
|
||
|
|
// pIndex - The positive integer index of the first occurrence in
|
||
|
|
// the vector where any value in pAnyOf was found;
|
||
|
|
// otherwise, -1 if no value in pAnyOf was found.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr Any of pointers is NULL.
|
||
|
|
// ippStsLengthErr len or lenAnyOf are negative.
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsFindCAny_8u, ( const Ipp8u* pSrc, int len,
|
||
|
|
const Ipp8u* pAnyOf, int lenAnyOf, int* pIndex ))
|
||
|
|
IPPAPI (IppStatus, ippsFindCAny_16u, ( const Ipp16u* pSrc, int len,
|
||
|
|
const Ipp16u* pAnyOf, int lenAnyOf, int* pIndex ))
|
||
|
|
IPPAPI (IppStatus, ippsFindRevCAny_8u, ( const Ipp8u* pSrc, int len,
|
||
|
|
const Ipp8u* pAnyOf, int lenAnyOf, int* pIndex ))
|
||
|
|
IPPAPI (IppStatus, ippsFindRevCAny_16u, ( const Ipp16u* pSrc, int len,
|
||
|
|
const Ipp16u* pAnyOf, int lenAnyOf, int* pIndex ))
|
||
|
|
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsReplaceC_8u
|
||
|
|
// ippsReplaceC_16u
|
||
|
|
//
|
||
|
|
// Purpose: Replaces all occurrences of a specified value in
|
||
|
|
// the vector with another specified value.
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - The pointer of vector to replace.
|
||
|
|
// pDst - The ponter of replaced vector.
|
||
|
|
// len - The length of the vector.
|
||
|
|
// oldVal - A value to be replaced.
|
||
|
|
// newVal - A value to replace all occurrences of oldVal.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr Any of pointers is NULL.
|
||
|
|
// ippStsLengthErr len is negative.
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsReplaceC_8u, ( const Ipp8u* pSrc, Ipp8u* pDst, int len,
|
||
|
|
Ipp8u oldVal, Ipp8u newVal ))
|
||
|
|
IPPAPI (IppStatus, ippsReplaceC_16u, ( const Ipp16u* pSrc, Ipp16u* pDst, int len,
|
||
|
|
Ipp16u oldVal, Ipp16u newVal ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsTrimCAny_8u
|
||
|
|
// ippsTrimCAny_16u
|
||
|
|
// ippsTrimEndCAny_8u
|
||
|
|
// ippsTrimEndCAny_16u
|
||
|
|
// ippsTrimStartCAny_8u
|
||
|
|
// ippsTrimStartCAny_16u
|
||
|
|
//
|
||
|
|
// Purpose: Removes all occurrences of a set of specified values
|
||
|
|
// from:
|
||
|
|
// TrimCAny - the beginning and end of the vector.
|
||
|
|
// TrimEndCAny - the end of the vector.
|
||
|
|
// TrimStartCAny - the beginning of the vector.
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - The pointer of src vector to remove.
|
||
|
|
// srcLen - The length of the src vector.
|
||
|
|
// pTrim - An array of values to be removed.
|
||
|
|
// trimLen - The length of the array values.
|
||
|
|
// pDst - The pointer of dst vector to result save.
|
||
|
|
// pDstLen - The result length of the dst vector.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr Any of pointers is NULL.
|
||
|
|
// ippStsLengthErr srcLen or trimLen are negative.
|
||
|
|
//
|
||
|
|
// Note:
|
||
|
|
// The length of the pDst should be sufficient;
|
||
|
|
// if values not found, *pDstLen = srcLen.
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsTrimCAny_8u, ( const Ipp8u* pSrc, int srcLen,
|
||
|
|
const Ipp8u* pTrim, int trimLen, Ipp8u* pDst, int* pDstLen ))
|
||
|
|
IPPAPI (IppStatus, ippsTrimCAny_16u, ( const Ipp16u* pSrc, int srcLen,
|
||
|
|
const Ipp16u* pTrim, int trimLen, Ipp16u* pDst, int* pDstLen ))
|
||
|
|
IPPAPI (IppStatus, ippsTrimEndCAny_8u, ( const Ipp8u* pSrc, int srcLen,
|
||
|
|
const Ipp8u* pTrim, int trimLen, Ipp8u* pDst, int* pDstLen ))
|
||
|
|
IPPAPI (IppStatus, ippsTrimEndCAny_16u, ( const Ipp16u* pSrc, int srcLen,
|
||
|
|
const Ipp16u* pTrim, int trimLen, Ipp16u* pDst, int* pDstLen ))
|
||
|
|
IPPAPI (IppStatus, ippsTrimStartCAny_8u, ( const Ipp8u* pSrc, int srcLen,
|
||
|
|
const Ipp8u* pTrim, int trimLen, Ipp8u* pDst, int* pDstLen ))
|
||
|
|
IPPAPI (IppStatus, ippsTrimStartCAny_16u, ( const Ipp16u* pSrc, int srcLen,
|
||
|
|
const Ipp16u* pTrim, int trimLen, Ipp16u* pDst, int* pDstLen ))
|
||
|
|
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsCompareIgnoreCase_16u
|
||
|
|
//
|
||
|
|
// Purpose: Compares two Unicode strings element-by-element
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc1 - pointer to the first string
|
||
|
|
// pSrc2 - pointer to the second string
|
||
|
|
// len - string length to compare
|
||
|
|
// pResult - pointer to the result:
|
||
|
|
// *pResult = 0 if src1 == src2;
|
||
|
|
// *pResult > 0 if src1 > src2;
|
||
|
|
// *pResult < 0 if src1 < src2;
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc1, pSrc2 or pResult is NULL
|
||
|
|
// ippStsLengthErr len is negative
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsCompareIgnoreCase_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2, int len,
|
||
|
|
int *pResult))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsCompareIgnoreCaseLatin_8u
|
||
|
|
// ippsCompareIgnoreCaseLatin_16u
|
||
|
|
//
|
||
|
|
// Purpose: Compares two ASCII strings element-by-element
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc1 - pointer to the first string
|
||
|
|
// pSrc2 - pointer to the second string
|
||
|
|
// len - string length to compare
|
||
|
|
// pResult - pointer to the result:
|
||
|
|
// *pResult = 0 if src1 == src2;
|
||
|
|
// *pResult > 0 if src1 > src2;
|
||
|
|
// *pResult < 0 if src1 < src2;
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc1, pSrc2 or pResult is NULL
|
||
|
|
// ippStsLengthErr len is negative
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsCompareIgnoreCaseLatin_8u, (const Ipp8u* pSrc1, const Ipp8u* pSrc2, int len,
|
||
|
|
int *pResult))
|
||
|
|
IPPAPI (IppStatus, ippsCompareIgnoreCaseLatin_16u, (const Ipp16u* pSrc1, const Ipp16u* pSrc2,
|
||
|
|
int len, int *pResult))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsInsert_8u_I ippsInsert_16u_I
|
||
|
|
// ippsInsert_8u ippsInsert_16u
|
||
|
|
//
|
||
|
|
// Purpose: Inserts one string at a specified index position in other string
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// srcLen - source string length
|
||
|
|
// pInsert - pointer to the string to be inserted
|
||
|
|
// insertLen - length of the string to be inserted
|
||
|
|
// pDst - pointer to the destination string
|
||
|
|
// pSrcDst - pointer to the string for in-place operation
|
||
|
|
// pSrcDstLen - pointer to the string length:
|
||
|
|
// *pSrcDstLen = source length on input;
|
||
|
|
// *pSrcDstLen = destination length on output;
|
||
|
|
// startIndex - index of start position
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc, pInsert, pDst, pSrcDst or pSrcDstLen is NULL
|
||
|
|
// ippStsLengthErr srcLen, insertLen, *pSrcDstLen or startIndex is negative Or
|
||
|
|
// startIndex is greater than srcLen or *pSrcDstLen
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsInsert_8u_I, (const Ipp8u* pInsert, int insertLen, Ipp8u* pSrcDst,
|
||
|
|
int* pSrcDstLen, int startIndex))
|
||
|
|
IPPAPI (IppStatus, ippsInsert_16u_I, (const Ipp16u* pInsert, int insertLen, Ipp16u* pSrcDst,
|
||
|
|
int* pSrcDstLen, int startIndex))
|
||
|
|
IPPAPI (IppStatus, ippsInsert_8u, (const Ipp8u* pSrc, int srcLen, const Ipp8u* pInsert,
|
||
|
|
int insertLen, Ipp8u* pDst, int startIndex))
|
||
|
|
IPPAPI (IppStatus, ippsInsert_16u, (const Ipp16u* pSrc, int srcLen, const Ipp16u* pInsert,
|
||
|
|
int insertLen, Ipp16u* pDst, int startIndex))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRemove_8u_I ippsRemove_16u_I
|
||
|
|
// ippsRemove_8u ippsRemove_16u
|
||
|
|
//
|
||
|
|
// Purpose: Deletes a specified number of characters from the string
|
||
|
|
// beginning at a specified position.
|
||
|
|
//
|
||
|
|
// Arguments:
|
||
|
|
// pSrc - pointer to the source string
|
||
|
|
// srcLen - source string length
|
||
|
|
// pDst - pointer to the destination string
|
||
|
|
// pSrcDst - pointer to the string for in-place operation
|
||
|
|
// pSrcDstLen - pointer to the string length:
|
||
|
|
// *pSrcDstLen = source length on input;
|
||
|
|
// *pSrcDstLen = destination length on output;
|
||
|
|
// startIndex - index of start position
|
||
|
|
// len - number of characters to be deleted
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Ok
|
||
|
|
// ippStsNullPtrErr pSrc, pDst, pSrcDst or pSrcDstLen are NULL
|
||
|
|
// ippStsLengthErr srcLen, *pSrcDstLen, len or startIndex is negative Or
|
||
|
|
// (startIndex + len) is greater than srcLen or *pSrcDstLen
|
||
|
|
*/
|
||
|
|
IPPAPI (IppStatus, ippsRemove_8u_I, (Ipp8u* pSrcDst, int* pSrcDstLen, int startIndex, int len))
|
||
|
|
IPPAPI (IppStatus, ippsRemove_16u_I, (Ipp16u* pSrcDst, int* pSrcDstLen, int startIndex, int len))
|
||
|
|
IPPAPI (IppStatus, ippsRemove_8u, (const Ipp8u* pSrc, int srcLen, Ipp8u* pDst, int startIndex,
|
||
|
|
int len))
|
||
|
|
IPPAPI (IppStatus, ippsRemove_16u, (const Ipp16u* pSrc, int srcLen, Ipp16u* pDst, int startIndex,
|
||
|
|
int len))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpInitAlloc
|
||
|
|
// Purpose: Allocates necessary memory, compiles a pattern into the
|
||
|
|
// internal form consideration corresponding options and
|
||
|
|
// writes it into the pRegExpState
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pPattern Pointer to the pattern of regular expression
|
||
|
|
// pOptions Pointer to options for compiling and executing
|
||
|
|
// regular expression (possible values 'i','s','m','x','g')
|
||
|
|
// It should be NULL if no options are required.
|
||
|
|
// pRegExpState Pointer to the structure containing internal form of
|
||
|
|
// a regular expression.
|
||
|
|
// pErrOffset Pointer to offset into the pattern if compiling is break
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsMemAllocErr Can't allocate memory for pRegExpState
|
||
|
|
// ippStsRegExpOptionsErr Options are incorrect
|
||
|
|
// ippStsRegExpQuantifierErr Error caused by using wrong quantifier
|
||
|
|
// ippStsRegExpGroupingErr Error caused by using wrong grouping
|
||
|
|
// ippStsRegExpBackRefErr Error caused by using wrong back reference
|
||
|
|
// ippStsRegExpChClassErr Error caused by using wrong character class
|
||
|
|
// ippStsRegExpMetaChErr Error caused by using wrong metacharacter
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpInitAlloc, ( const char* pPattern, const char* pOptions,
|
||
|
|
IppRegExpState** ppRegExpState, int* pErrOffset ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpGetSize
|
||
|
|
// Purpose: Computes the size of necessary memory (in bytes) for
|
||
|
|
// structure containing internal form of regular expression
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pPattern Pointer to the pattern of regular expression
|
||
|
|
// pRegExpStateSize Pointer to the computed size of structure containing
|
||
|
|
// internal form of regular expression
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpGetSize, ( const char* pPattern, int* pRegExpStateSize ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpInit
|
||
|
|
// Purpose: Compiles a pattern into the internal form consideration
|
||
|
|
// corresponding options and writes it into the pRegExpState
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pPattern Pointer to the pattern of regular expression
|
||
|
|
// pOptions Pointer to options for compiling and executing
|
||
|
|
// regular expression (possible values 'i','s','m','x','g')
|
||
|
|
// It should be NULL if no options are required.
|
||
|
|
// pRegExpState Pointer to the structure containing internal form of
|
||
|
|
// a regular expression.
|
||
|
|
// pErrOffset Pointer to offset into the pattern if compiling is break
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsRegExpOptionsErr Options are incorrect
|
||
|
|
// ippStsRegExpQuantifierErr Error caused by using wrong quantifier
|
||
|
|
// ippStsRegExpGroupingErr Error caused by using wrong grouping
|
||
|
|
// ippStsRegExpBackRefErr Error caused by using wrong back reference
|
||
|
|
// ippStsRegExpChClassErr Error caused by using wrong character class
|
||
|
|
// ippStsRegExpMetaChErr Error caused by using wrong metacharacter
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpInit, ( const char* pPattern, const char* pOptions,
|
||
|
|
IppRegExpState* pRegExpState, int* pErrOffset ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpSetMatchLimit
|
||
|
|
// Purpose: Changes initial value of the matches kept in stack
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// matchLimit New value of the matches kept in stack
|
||
|
|
// pRegExpState Pointer to the structure containing internal form of
|
||
|
|
// a regular expression
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNullPtrErr Pointer is NULL
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpSetMatchLimit, ( int matchLimit, IppRegExpState* pRegExpState ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpSetFormat
|
||
|
|
// Purpose: Changes initial value of the matches kept in stack
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// fmt New source encoding mode
|
||
|
|
// pRegExpState Pointer to the structure containing internal form of
|
||
|
|
// a regular expression
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNullPtrErr Pointer is NULL.
|
||
|
|
// ippStsRangeErr When
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpSetFormat, ( IppRegExpFormat fmt, IppRegExpState* pRegExpState ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpFree
|
||
|
|
// Purpose: Frees allocated memory for the structure containing
|
||
|
|
// internal form of regular expression
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pRegExpState Pointer to the structure containing internal form of
|
||
|
|
// a regular expression.
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(void, ippsRegExpFree, ( IppRegExpState* pRegExpState ))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpFind_8u
|
||
|
|
// Purpose: Looks for the occurrences of the substrings matching
|
||
|
|
// the specified regular expression.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pSrc Pointer to the source string
|
||
|
|
// srcLen Number of elements in the source string.
|
||
|
|
// pRegExpState Pointer to the structure containing internal form of
|
||
|
|
// a regular expression
|
||
|
|
// pFind Array of pointers to the matching substrings
|
||
|
|
// pNumFind Size of the array pFind on input,
|
||
|
|
// number of matching substrings on output.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsSizeErr Length of the source vector is less zero or or
|
||
|
|
// pNumFind is less than or equal to 0
|
||
|
|
// ippStsRegExpErr The structure pRegExpState contains wrong data
|
||
|
|
// ippStsRegExpMatchLimitErr The match limit has been exhausted
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpFind_8u, ( const Ipp8u* pSrc, int srcLen, IppRegExpState* pRegExpState,
|
||
|
|
IppRegExpFind* pFind, int* pNumFind ))
|
||
|
|
|
||
|
|
|
||
|
|
#if !defined( _OWN_BLDPCS )
|
||
|
|
|
||
|
|
struct RegExpMultiState;
|
||
|
|
typedef struct RegExpMultiState IppRegExpMultiState;
|
||
|
|
|
||
|
|
typedef struct {
|
||
|
|
Ipp32u regexpDoneFlag;
|
||
|
|
Ipp32u regexpID;
|
||
|
|
Ipp32s numMultiFind;
|
||
|
|
IppStatus status;
|
||
|
|
IppRegExpFind* pFind;
|
||
|
|
} IppRegExpMultiFind;
|
||
|
|
|
||
|
|
#endif /* _OWN_BLDPCS */
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpMultiGetSize
|
||
|
|
// Purpose: Computes the size of necessary memory (in bytes) for
|
||
|
|
// structure containing internal form of multi patterns search engine.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// maxPatterns Maximum number of pattern.
|
||
|
|
// pSize Pointer to the computed size of structure containing
|
||
|
|
// internal form of search engine
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsSizeErr When maxPatterns is less or equal 0.
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpMultiGetSize, ( Ipp32u maxPatterns, int *pSize))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpMultiInit
|
||
|
|
// Purpose: Initialize internal form of multi patterns search engine.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// maxPatterns Maximum number of pattern.
|
||
|
|
// pState Pointer to the structure containing internal form of
|
||
|
|
// multi patterns search engine.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsSizeErr When maxPatterns is less or equal 0.
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpMultiInit, ( IppRegExpMultiState* pState, Ipp32u maxPatterns))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpMultiInitAlloc
|
||
|
|
// Purpose: Allocates necessary memory, initialize internal form of multi patterns search engine
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// maxPatterns Maximum number of pattern.
|
||
|
|
// pState Double pointer to the structure containing internal form of
|
||
|
|
// multi patterns search engine.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsSizeErr When maxPatterns is less or equal 0.
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpMultiInitAlloc, ( IppRegExpMultiState** ppState, Ipp32u maxPatterns))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpMultiFree
|
||
|
|
// Purpose: Frees allocated memory for the structure containing
|
||
|
|
// internal form of multi patterns search engine
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pState Pointer to the structure containing internal form of
|
||
|
|
// multi patterns search engine.
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(void, ippsRegExpMultiFree, (IppRegExpMultiState* pState))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpMulti*
|
||
|
|
// Purpose: Controls multi patterns database. Add, remove or modify patterns.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pRegExpState Pointer to the structure containing internal form of a
|
||
|
|
// compiled regular expression.
|
||
|
|
// regexpID Pattern ID. 0 is invalid ID.
|
||
|
|
// pState Pointer to the structure containing internal form of
|
||
|
|
// multi patterns search engine.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsSizeErr When ID is equal 0.
|
||
|
|
// ippStsMemAllocErr When number of patterns exceeded its maximum value.
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpMultiAdd, ( const IppRegExpState* pRegExpState, Ipp32u regexpID, IppRegExpMultiState* pState))
|
||
|
|
IPPAPI(IppStatus, ippsRegExpMultiModify, ( const IppRegExpState* pRegExpState, Ipp32u regexpID, IppRegExpMultiState* pState))
|
||
|
|
IPPAPI(IppStatus, ippsRegExpMultiDelete, (Ipp32u regexpID, IppRegExpMultiState* pState))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpMultiFind_8u
|
||
|
|
// Purpose: Looks for the occurrences of the substrings matching
|
||
|
|
// the specified patterns.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pSrc Pointer to the source string
|
||
|
|
// srcLen Number of elements in the source string.
|
||
|
|
// pState Pointer to the structure containing internal form of
|
||
|
|
// multi patterns search engine
|
||
|
|
// pDstMultiFind Array of pointers to the matching patterns
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsSizeErr Length of the source vector is less or equal zero.
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpMultiFind_8u, ( const Ipp8u* pSrc, int srcLen, IppRegExpMultiFind *pDstMultiFind, const IppRegExpMultiState* pState))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsConvertUTF
|
||
|
|
// Purpose: Convert UTF16BE or UTF16LE format to UTF8 and vice versa.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pSrc Pointer to the input vector.
|
||
|
|
// pSrcLen Length of the pSrc vector on input and its used length on output.
|
||
|
|
// BEFlag Flag to indicate UTF16BE format. 0 means UTF16LE format.
|
||
|
|
// pDst Pointer to the output vector.
|
||
|
|
// pDstLen Length of the pDst vector on input and its used length on output.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
*/
|
||
|
|
|
||
|
|
IPPAPI(IppStatus, ippsConvertUTF_8u16u,( const Ipp8u* pSrc, Ipp32u *pSrcLen, Ipp16u* pDst, Ipp32u *pDstLen, int BEFlag))
|
||
|
|
IPPAPI(IppStatus, ippsConvertUTF_16u8u,( const Ipp16u* pSrc, Ipp32u *pSrcLen, Ipp8u* pDst, Ipp32u *pDstLen, int BEFlag))
|
||
|
|
|
||
|
|
#if !defined( _OWN_BLDPCS )
|
||
|
|
|
||
|
|
struct RegExpMultiState;
|
||
|
|
typedef struct RegExpReplaceState IppRegExpReplaceState;
|
||
|
|
#endif /* _OWN_BLDPCS */
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpReplaceGetSize
|
||
|
|
// Purpose: Computes the size the find and replace engine memory.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pSrcReplacement Pointer to the input null-terminated replace pattern.
|
||
|
|
// pSize Pointer to the computed size of the replace engine memory.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNullPtrErr pSize pointer is NULL
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpReplaceGetSize, ( const Ipp8u* pSrcReplacement, Ipp32u *pSize))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpReplaceInit
|
||
|
|
// Purpose: Initialize internal form of find and replace engine.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pSrcReplacement Pointer to the input null-terminated replace pattern.
|
||
|
|
// pReplaceState Pointer to the memory allocated for the find and replace
|
||
|
|
// engine structure of size after ippsRegExpReplaceGetSize function.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr No errors
|
||
|
|
// ippStsNullPtrErr pReplaceState pointer is NULL
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpReplaceInit, ( const Ipp8u* pSrcReplacement, IppRegExpReplaceState *pReplaceState))
|
||
|
|
|
||
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: ippsRegExpReplace_8u
|
||
|
|
// Purpose: Performs find and replace.
|
||
|
|
//
|
||
|
|
// Parameters:
|
||
|
|
// pSrc Pointer to the source string.
|
||
|
|
// pSrcLenOffset Length of the pSrc vector on input and its used length on output.
|
||
|
|
// pRegExpState Pointer to the compiled pattern structure.
|
||
|
|
// pReplaceState Pointer to the memory allocated for the find and replace engine structure.
|
||
|
|
// pDst Pointer to the destination string.
|
||
|
|
// pDstLen Length of the pDst vector on input and its used length on output.
|
||
|
|
// pFind Array of pointers to the matching substrings.
|
||
|
|
// pNumFind Size of the array pFind on input, number of matching substrings on output.
|
||
|
|
//
|
||
|
|
// Return:
|
||
|
|
// ippStsNoErr Indicates no error.
|
||
|
|
// ippStsNullPtrErr One or several pointer(s) is NULL.
|
||
|
|
// ippStsSizeErr Indicates an error when value in pSrcLen or pDstLen is less or equal to zero.
|
||
|
|
//
|
||
|
|
*/
|
||
|
|
IPPAPI(IppStatus, ippsRegExpReplace_8u, ( const Ipp8u* pSrc, int *pSrcLenOffset, Ipp8u *pDst, int *pDstLen, IppRegExpFind* pFind, int* pNumFind, IppRegExpState* pRegExpState,
|
||
|
|
IppRegExpReplaceState *pReplaceState ))
|
||
|
|
|
||
|
|
#if defined (_IPP_STDCALL_CDECL)
|
||
|
|
#undef _IPP_STDCALL_CDECL
|
||
|
|
#define __stdcall __cdecl
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif /* __IPPCH_H__ */
|
||
|
|
/* ////////////////////////////// End of file /////////////////////////////// */
|