ippch.hpp

经典的嵌入式教程C和C++的内容中的源代码

//   The length of the pDst should be sufficient;
//   if values not found, *pDstLen = srcLen.
*/
 static inline IppStatus ippsTrimCAny( const Ipp8u* pSrc, int srcLen, const Ipp8u*
                             pTrim, int trimLen, Ipp8u* pDst, int* pDstLen) {
     return ippsTrimCAny_8u( pSrc, srcLen, pTrim, trimLen, pDst, pDstLen );
     }
 static inline IppStatus ippsTrimCAny( const Ipp16u* pSrc, int srcLen, const Ipp16u*
                             pTrim, int trimLen, Ipp16u* pDst, int* pDstLen) {
     return ippsTrimCAny_16u( pSrc, srcLen, pTrim, trimLen, pDst, pDstLen );
     }
 static inline IppStatus ippsTrimEndCAny( const Ipp8u* pSrc, int srcLen, const Ipp8u*
                             pTrim, int trimLen, Ipp8u* pDst, int* pDstLen) {
     return ippsTrimEndCAny_8u( pSrc, srcLen, pTrim, trimLen, pDst, pDstLen );
     }
 static inline IppStatus ippsTrimEndCAny( const Ipp16u* pSrc, int srcLen, const Ipp16u*
                             pTrim, int trimLen, Ipp16u* pDst, int* pDstLen) {
     return ippsTrimEndCAny_16u( pSrc, srcLen, pTrim, trimLen, pDst, pDstLen );
     }
 static inline IppStatus ippsTrimStartCAny( const Ipp8u* pSrc, int srcLen, const Ipp8u*
                             pTrim, int trimLen, Ipp8u* pDst, int* pDstLen) {
     return ippsTrimStartCAny_8u( pSrc, srcLen, pTrim, trimLen, pDst, pDstLen );
     }
 static inline IppStatus ippsTrimStartCAny( const Ipp16u* pSrc, int srcLen, const
                             Ipp16u* pTrim, int trimLen, Ipp16u* pDst, int* pDstLen) {
     return ippsTrimStartCAny_16u( pSrc, srcLen, pTrim, trimLen, pDst, 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 lengh 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
*/
 static inline IppStatus ippsCompareIgnoreCase( const Ipp16u* pSrc1, const Ipp16u*
                             pSrc2, int len, int *pResult) {
     return ippsCompareIgnoreCase_16u( pSrc1, pSrc2, len, 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 lengh 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
*/
 static inline IppStatus ippsCompareIgnoreCaseLatin( const Ipp8u* pSrc1, const Ipp8u*
                             pSrc2, int len, int *pResult) {
     return ippsCompareIgnoreCaseLatin_8u( pSrc1, pSrc2, len, pResult );
     }
 static inline IppStatus ippsCompareIgnoreCaseLatin( const Ipp16u* pSrc1, const Ipp16u*
                             pSrc2, int len, int *pResult) {
     return ippsCompareIgnoreCaseLatin_16u( pSrc1, pSrc2, len, 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 lengh
//     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
*/
 static inline IppStatus ippsInsert( const Ipp8u* pInsert, int insertLen, Ipp8u*
                             pSrcDst, int* pSrcDstLen, int startIndex) {
     return ippsInsert_8u_I( pInsert, insertLen, pSrcDst, pSrcDstLen, startIndex );
     }
 static inline IppStatus ippsInsert( const Ipp16u* pInsert, int insertLen, Ipp16u*
                             pSrcDst, int* pSrcDstLen, int startIndex) {
     return ippsInsert_16u_I( pInsert, insertLen, pSrcDst, pSrcDstLen, startIndex );
     }
 static inline IppStatus ippsInsert( const Ipp8u* pSrc, int srcLen, const Ipp8u*
                             pInsert, int insertLen, Ipp8u* pDst, int startIndex) {
     return ippsInsert_8u( pSrc, srcLen, pInsert, insertLen, pDst, startIndex );
     }
 static inline IppStatus ippsInsert( const Ipp16u* pSrc, int srcLen, const Ipp16u*
                             pInsert, int insertLen, Ipp16u* pDst, int startIndex) {
     return ippsInsert_16u( pSrc, srcLen, pInsert, insertLen, pDst, 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 lengh
//     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
*/
 static inline IppStatus ippsRemove( Ipp8u* pSrcDst, int* pSrcDstLen, int startIndex,
                             int len) {
     return ippsRemove_8u_I( pSrcDst, pSrcDstLen, startIndex, len );
     }
 static inline IppStatus ippsRemove( Ipp16u* pSrcDst, int* pSrcDstLen, int startIndex,
                             int len) {
     return ippsRemove_16u_I( pSrcDst, pSrcDstLen, startIndex, len );
     }
 static inline IppStatus ippsRemove( const Ipp8u* pSrc, int srcLen, Ipp8u* pDst, int
                             startIndex, int len) {
     return ippsRemove_8u( pSrc, srcLen, pDst, startIndex, len );
     }
 static inline IppStatus ippsRemove( const Ipp16u* pSrc, int srcLen, Ipp16u* pDst, int
                             startIndex, int len) {
     return ippsRemove_16u( pSrc, srcLen, pDst, startIndex, 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:                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
//
*/
 static inline IppStatus ippsRegExpFind( const Ipp8u* pSrc, int srcLen, IppRegExpState*
                             pRegExpState, IppRegExpFind* pFind, int* pNumFind) {
     return ippsRegExpFind_8u( pSrc, srcLen, pRegExpState, pFind, pNumFind );
     }

//-- #if defined (_IPP_STDCALL_CDECL)
//--   #undef  _IPP_STDCALL_CDECL
//--   #define __stdcall __cdecl
//-- #endif

//-- #ifdef __cplusplus
//-- }
//-- #endif

//-- #endif /* __IPPCH_H__ */
/* ////////////////////////////// End of file /////////////////////////////// */

};
#endif
#endif